LedStrip.cs

Go to the documentation of this file.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using DirectOutput.Cab.Out;
using System.Xml.Serialization;
using DirectOutput.General;
using DirectOutput.Cab.Toys.Layer;
using DirectOutput.General.Color;

namespace DirectOutput.Cab.Toys.Hardware
{
    public class LedStrip : ToyBaseUpdatable, IToy, IMatrixToy<RGBAColor>
    {
        #region Config properties
        private int _Width = 1;

        public int Width
        {
            get { return _Width; }
            set { _Width = value.Limit(0, int.MaxValue); }
        }

        private int _Height = 1;

        public int Height
        {
            get { return _Height; }
            set { _Height = value.Limit(0, int.MaxValue); }
        }


        public int NumberOfLeds
        {
            get { return Width * Height; }
        }


        public int NumberOfOutputs
        {
            get { return NumberOfLeds * 3; }
        }


        private LedStripArrangementEnum _LedStripAranggement = LedStripArrangementEnum.LeftRightTopDown;

        public LedStripArrangementEnum LedStripArrangement
        {
            get { return _LedStripAranggement; }
            set { _LedStripAranggement = value; }
        }



        private RGBOrderEnum _ColorOrder = RGBOrderEnum.RBG;

        public RGBOrderEnum ColorOrder
        {
            get { return _ColorOrder; }
            set { _ColorOrder = value; }
        }


        private int _FirstLedNumber = 1;
        public int FirstLedNumber
        {
            get { return _FirstLedNumber; }
            set { _FirstLedNumber = value.Limit(1, int.MaxValue); }
        }

        private string _FadingCurveName = "Linear";
        private Curve FadingCurve = null;

        public string FadingCurveName
        {
            get { return _FadingCurveName; }
            set { _FadingCurveName = value; }
        }

        private void InitFadingCurve(Cabinet Cabinet)
        {
            if (Cabinet.Curves.Contains(FadingCurveName))
            {
                FadingCurve = Cabinet.Curves[FadingCurveName];
            }
            else if (!FadingCurveName.IsNullOrWhiteSpace())
            {
                if (Enum.GetNames(typeof(Curve.CurveTypeEnum)).Contains(FadingCurveName))
                {
                    Curve.CurveTypeEnum T = Curve.CurveTypeEnum.Linear;
                    Enum.TryParse(FadingCurveName, out T);
                    FadingCurve = new Curve(T);
                }
                else
                {
                    FadingCurve = new Curve(Curve.CurveTypeEnum.Linear) { Name = FadingCurveName };
                    Cabinet.Curves.Add(FadingCurveName);
                }
            }
            else
            {
                FadingCurve = new Curve(Curve.CurveTypeEnum.Linear);
            }

        }


        public string OutputControllerName { get; set; }

        private ISupportsSetValues OutputController;

        #endregion


        [XmlIgnore]
        public MatrixDictionaryBase<RGBAColor> Layers { get; private set; }


        #region IToy methods

        Cabinet Cabinet;
        public override void Init(Cabinet Cabinet)
        {
            this.Cabinet = Cabinet;

            if (Cabinet.OutputControllers.Contains(OutputControllerName) && Cabinet.OutputControllers[OutputControllerName] is ISupportsSetValues)
            {
                OutputController = (ISupportsSetValues)Cabinet.OutputControllers[OutputControllerName];
            }

            BuildMappingTables();
            OutputData = new byte[NumberOfOutputs];
            InitFadingCurve(Cabinet);

            Layers = new MatrixDictionaryBase<RGBAColor>() { Width = Width, Height = Height };
        }



        public override void Reset()
        {
            OutputController.SetValues((FirstLedNumber-1) * 3, new byte[NumberOfLeds]);
        }

        public override void UpdateOutputs()
        {
            if (OutputController != null && Layers.Count > 0)
            {
                SetOutputData();
                OutputController.SetValues((FirstLedNumber-1)*3, OutputData);

            };
        }

        #endregion

        public RGBAColor[,] GetLayer(int LayerNr)
        {
            return Layers[LayerNr];
        }




        //private int[,] LedMappingTable = new int[0, 0];
        private int[,] OutputMappingTable = new int[0, 0];

        private void BuildMappingTables()
        {
            //LedMappingTable = new int[Width, Height];
            OutputMappingTable = new int[Width, Height];
            bool FirstException = true;
            int LedNr = 0;

            for (int Y = 0; Y < Height; Y++)
            {
                for (int X = 0; X < Width; X++)
                {

                    switch (LedStripArrangement)
                    {
                        case LedStripArrangementEnum.LeftRightTopDown:
                            LedNr = (Y * Width) + X;
                            break;
                        case LedStripArrangementEnum.LeftRightBottomUp:
                            LedNr = ((Height - 1 - Y) * Width) + X;
                            break;
                        case LedStripArrangementEnum.RightLeftTopDown:
                            LedNr = (Y * Width) + (Width - 1 - X);
                            break;
                        case LedStripArrangementEnum.RightLeftBottomUp:
                            LedNr = ((Height - 1 - Y) * Width) + (Width - 1 - X);
                            break;
                        case LedStripArrangementEnum.TopDownLeftRight:
                            LedNr = X * Height + Y;
                            break;
                        case LedStripArrangementEnum.TopDownRightLeft:
                            LedNr = ((Width - 1 - X) * Height) + Y;
                            break;
                        case LedStripArrangementEnum.BottomUpLeftRight:
                            LedNr = (X * Height) + (Height - 1 - Y);
                            break;
                        case LedStripArrangementEnum.BottomUpRightLeft:
                            LedNr = ((Width - 1 - X) * Height) + (Height - 1 - Y);
                            break;
                        case LedStripArrangementEnum.LeftRightAlternateTopDown:
                            LedNr = (Width * Y) + ((Y & 1) == 0 ? X : (Width - 1 - X));
                            break;
                        case LedStripArrangementEnum.LeftRightAlternateBottomUp:
                            LedNr = (Width * (Height - 1 - Y)) + (((Height - 1 - Y) & 1) == 0 ? X : (Width - 1 - X));
                            break;
                        case LedStripArrangementEnum.RightLeftAlternateTopDown:
                            LedNr = (Width * Y) + ((Y & 1) == 1 ? X : (Width - 1 - X));
                            break;
                        case LedStripArrangementEnum.RightLeftAlternateBottomUp:
                            LedNr = (Width * (Height - 1 - Y)) + (((Height - 1 - Y) & 1) == 1 ? X : (Width - 1 - X));
                            break;
                        case LedStripArrangementEnum.TopDownAlternateLeftRight:
                            LedNr = (Height * X) + ((X & 1) == 0 ? Y : (Height - 1 - Y));
                            break;
                        case LedStripArrangementEnum.TopDownAlternateRightLeft:
                            LedNr = (Height * (Width - 1 - X)) + ((X & 1) == 1 ? Y : (Height - 1 - Y));
                            break;
                        case LedStripArrangementEnum.BottomUpAlternateLeftRight:
                            LedNr = (Height * X) + ((X & 1) == 1 ? Y : (Height - 1 - Y));
                            break;
                        case LedStripArrangementEnum.BottomUpAlternateRightLeft:
                            LedNr = (Height * (Width - 1 - X)) + ((X & 1) == 0 ? Y : (Height - 1 - Y));
                            break;
                        default:
                            if (FirstException)
                            {
                                Log.Exception("Unknow LedStripArrangement value ({0}) found. Will use LeftRightTopDown mapping as fallback.".Build(LedStripArrangement.ToString()));
                                FirstException = false;
                            };
                            LedNr = (Y * Width) + X;
                            break;
                    }
                    //LedMappingTable[X, Y] = LedNr;
                    OutputMappingTable[X, Y] = LedNr * 3;
                }
            }

        }

        //Array for output data is not in GetResultingValues to avoid reinitiaslisation of the array
        byte[] OutputData = new byte[0];

        private void SetOutputData()
        {
            if (Layers.Count > 0)
            {
                //Blend layers
                float[, ,] Value = new float[Width, Height, 3];

                foreach (KeyValuePair<int, RGBAColor[,]> KV in Layers)
                {
                    RGBAColor[,] D = KV.Value;

                    int Nr = 0;
                    for (int y = 0; y < Height; y++)
                    {
                        for (int x = 0; x < Width; x++)
                        {
                            int Alpha = D[x, y].Alpha.Limit(0, 255);
                            if (Alpha != 0)
                            {
                                Value[x, y, 0] = AlphaMappingTable.AlphaMapping[255 - Alpha, (int)Value[x, y, 0]] + AlphaMappingTable.AlphaMapping[Alpha, D[x, y].Red.Limit(0, 255)];
                                Value[x, y, 1] = AlphaMappingTable.AlphaMapping[255 - Alpha, (int)Value[x, y, 1]] + AlphaMappingTable.AlphaMapping[Alpha, D[x, y].Green.Limit(0, 255)];
                                Value[x, y, 2] = AlphaMappingTable.AlphaMapping[255 - Alpha, (int)Value[x, y, 2]] + AlphaMappingTable.AlphaMapping[Alpha, D[x, y].Blue.Limit(0, 255)];
                            }
                            Nr++;
                        }
                    }
                }




                //The following code mapps the led data to the outputs of the stripe
                byte[] FadingTable = FadingCurve.Data;
                switch (ColorOrder)
                {
                    case RGBOrderEnum.RBG:
                        for (int y = 0; y < Height; y++)
                        {
                            for (int x = 0; x < Width; x++)
                            {
                                int OutputNumber = OutputMappingTable[x, y];
                                OutputData[OutputNumber] = FadingTable[(int)Value[x, y, 0]];
                                OutputData[OutputNumber + 2] = FadingTable[(int)Value[x, y, 1]];
                                OutputData[OutputNumber + 1] = FadingTable[(int)Value[x, y, 2]];
                            }
                        }
                        break;
                    case RGBOrderEnum.GRB:
                        for (int y = 0; y < Height; y++)
                        {
                            for (int x = 0; x < Width; x++)
                            {
                                int OutputNumber = OutputMappingTable[x, y];
                                OutputData[OutputNumber + 1] = FadingTable[(int)Value[x, y, 0]];
                                OutputData[OutputNumber] = FadingTable[(int)Value[x, y, 1]];
                                OutputData[OutputNumber + 2] = FadingTable[(int)Value[x, y, 2]];
                            }
                        }
                        break;
                    case RGBOrderEnum.GBR:
                        for (int y = 0; y < Height; y++)
                        {
                            for (int x = 0; x < Width; x++)
                            {
                                int OutputNumber = OutputMappingTable[x, y];
                                OutputData[OutputNumber + 1] = FadingTable[(int)Value[x, y, 0]];
                                OutputData[OutputNumber + 2] = FadingTable[(int)Value[x, y, 1]];
                                OutputData[OutputNumber] = FadingTable[(int)Value[x, y, 2]];
                            }
                        }
                        break;
                    case RGBOrderEnum.BRG:
                        for (int y = 0; y < Height; y++)
                        {
                            for (int x = 0; x < Width; x++)
                            {
                                int OutputNumber = OutputMappingTable[x, y];
                                OutputData[OutputNumber + 2] = FadingTable[(int)Value[x, y, 0]];
                                OutputData[OutputNumber] = FadingTable[(int)Value[x, y, 1]];
                                OutputData[OutputNumber + 1] = FadingTable[(int)Value[x, y, 2]];
                            }
                        }
                        break;
                    case RGBOrderEnum.BGR:
                        for (int y = 0; y < Height; y++)
                        {
                            for (int x = 0; x < Width; x++)
                            {
                                int OutputNumber = OutputMappingTable[x, y];
                                OutputData[OutputNumber + 2] = FadingTable[(int)Value[x, y, 0]];
                                OutputData[OutputNumber + 1] = FadingTable[(int)Value[x, y, 1]];
                                OutputData[OutputNumber] = FadingTable[(int)Value[x, y, 2]];
                            }
                        }
                        break;
                    case RGBOrderEnum.RGB:
                    default:
                        for (int y = 0; y < Height; y++)
                        {
                            for (int x = 0; x < Width; x++)
                            {
                                int OutputNumber = OutputMappingTable[x, y];
                                OutputData[OutputNumber] = FadingTable[(int)Value[x, y, 0]];
                                OutputData[OutputNumber + 1] = FadingTable[(int)Value[x, y, 1]];
                                OutputData[OutputNumber + 2] = FadingTable[(int)Value[x, y, 2]];
                            }
                        }
                        break;
                }
            }


        }

        #region Constructor



        public LedStrip()
        {
            Layers = new MatrixDictionaryBase<RGBAColor>();


        }
        #endregion

    }
}