/// <summary>
        /// Loads a texture from a file
        /// </summary>
        /// <param name="filename">The file from which to get the texture</param>
        /// <returns>If it loaded the texture correctly</returns>
        public bool Load(string filename)
        {
            FileStream fs = new FileStream(filename, FileMode.Open);
            BinaryReader br = new BinaryReader(fs);

            //Read the size
            int sizex = br.ReadInt32();
            int sizey = br.ReadInt32();

            this.Scale(sizex, sizey); //Scale to new size
            ComponentEditor.ModifyAll(this,null); //And clear

            //Read textures
            int totalPixels = br.ReadInt32();

            for (int i = 0; i < totalPixels; i++ )
            {
                int x = br.ReadInt32();
                int y = br.ReadInt32();
                char c = (char)br.ReadInt32();
                ConsoleColor f = (ConsoleColor)br.ReadInt32();
                ConsoleColor b = (ConsoleColor)br.ReadInt32();
                Contents[x, y] = new Pixel(c, f, b);

            }
            return true;
        }

		//===========================================================================================
		public static void AreNotEqual(Pixel expected, Pixel actual)
		{
			Assert.IsNotNull(expected);
			Assert.IsNotNull(actual);

			AreNotEqual(expected.ToColor(), actual.ToColor());
		}

        public override void FrameSet(Pixel pixel, int position) {
            if (position < 0) { return; }

            int currentRow = position / (int)(NumberOfPanels * ColumnsPerPanel);
            int currentColumn = position % (int)(NumberOfPanels * ColumnsPerPanel);
            Frame[PointPostion(currentRow, currentColumn)] = pixel;
        }

        private static Pixel MergeRgb(Pixel p0, Pixel p1, Pixel p2)
        {
            var from = (p0 + p1 + p2) / 3;
            var to = new Pixel(p0.C0, p1.C1, p2.C2, from.C3);
            var p = 1.0;

            return from + (to - from) * p;
        }

 private static int ColorHash(Pixel colour)
 {
     int num = 0;
     if (colour.A > 0)
     {
         num = (((((0xff - colour.R) * 0x100) * 0x100) + ((0xff - colour.G) * 0x100)) + (0xff - colour.B)) + 1;
     }
     return num;
 }

        public void SetPixel( int x, int y, Pixel colour )
        {
            if ( Image.TiledView )
            {
                x = Wrap( x, Image.Width );
                y = Wrap( y, Image.Height );
            }

            Pixels[ x, y ] = colour;
            DrawPixel( x, y );
        }

        Tuple<int, int> GetLowerUpper(Pixel trimColor, IEnumerable<Pixel[]> array,
				  string lower, string upper)
        {
            Predicate<bool> notTrue = (b) => {return !b;};

              var rows = array.Select(x => AllEqual(x, trimColor)).ToList();

              return Tuple.Create((GetValue<bool>(lower)) ? rows.FindIndex(notTrue) : 0,
              (GetValue<bool>(upper)) ? rows.FindLastIndex(notTrue) + 1
              : rows.Count());
        }

        //эта штука нужна, если мы попали на границу нашей картинки. Мы не можем взять 4 точки для интерполяции, поэтому берём только две
        private double LinearInterpolate(Pixel first, Pixel second, double x, double y)
        {
            if (first == null || second == null)//если вдруг мы попали в угол картинки. У нас не будет даже двух точек - будет всего одна
                return (first ?? second).Intensity;

            if (first.Y == second.Y)
                return Math.Abs((second.X - x) * first.Intensity + (x - first.X) * second.Intensity);
            if (first.X == second.X)
                return Math.Abs((second.Y - y) * first.Intensity + (y - first.Y) * second.Intensity);

            throw new Exception("Somthing wrong :)");
        }

 double[,] Normalize(ref Pixel x)
 {
     //Gaussian distribution
     double[,] Px_i = new double[NumofClasses, NumofFeatures];
     for (int i = 0; i < NumofClasses; ++i)
     {
         Px_i[i, 0] = ((double)1 / Math.Sqrt(2 * Math.PI) * Sigma[i,0]) * Math.Exp(-Math.Pow((x.R - Mu[i,0]), 2) / (2 * Math.Pow(Sigma[i,0], 2)));
         Px_i[i, 1] = ((double)1 / Math.Sqrt(2 * Math.PI) * Sigma[i,1]) * Math.Exp(-Math.Pow((x.G - Mu[i,1]), 2) / (2 * Math.Pow(Sigma[i,1], 2)));
         Px_i[i, 2] = ((double)1 / Math.Sqrt(2 * Math.PI) * Sigma[i,2]) * Math.Exp(-Math.Pow((x.B - Mu[i,2]), 2) / (2 * Math.Pow(Sigma[i,2], 2)));
     }
     return Px_i;
 }

 public void ContainsCornerPixelsTest()
 {
     var _Rectangle = new Rectangle<Double>(10, 20, 30, 40);
     var _Pixel1    = new Pixel<Double>(10, 20);
     var _Pixel2    = new Pixel<Double>(30, 20);
     var _Pixel3    = new Pixel<Double>(10, 40);
     var _Pixel4    = new Pixel<Double>(30, 40);
     Assert.IsTrue(_Rectangle.Contains(_Pixel1));
     Assert.IsTrue(_Rectangle.Contains(_Pixel2));
     Assert.IsTrue(_Rectangle.Contains(_Pixel3));
     Assert.IsTrue(_Rectangle.Contains(_Pixel4));
 }

        public void Filter(IImage image, double[,] filter)
        {
            if (filter.GetLength(0) != filter.GetLength(1))
            {
                throw new ArgumentException("invalid filter", nameof(filter));
            }

            var result = new Pixel[image.Width, image.Height];

            double blue = 0.0;
            double green = 0.0;
            double red = 0.0;

            int filterOffset = (filter.GetLength(0) - 1) / 2;
            for (int offsetY = filterOffset; offsetY < image.Height - filterOffset; offsetY++)
            {
                for (int offsetX = filterOffset; offsetX < image.Width - filterOffset; offsetX++)
                {
                    blue = 0;
                    green = 0;
                    red = 0;

                    for (int filterY = -filterOffset; filterY <= filterOffset; filterY++)
                    {
                        for (int filterX = -filterOffset; filterX <= filterOffset; filterX++)
                        {
                            var imagePixel = image.GetPixel(offsetX + filterX, offsetY + filterY);

                            blue += (double)(imagePixel.B) * filter[filterY + filterOffset, filterX + filterOffset];
                            green += (double)(imagePixel.G) * filter[filterY + filterOffset, filterX + filterOffset];
                            red += (double)(imagePixel.R) * filter[filterY + filterOffset, filterX + filterOffset];
                        }
                    }

                    blue = Factor * blue + Bias;
                    green = Factor * green + Bias;
                    red = Factor * red + Bias;

                    result[offsetX, offsetY] = new Pixel { R = this.ToByte(red), G = this.ToByte(green), B = this.ToByte(blue) };
                }
            }

            for (int x = 0; x < result.GetLength(0); x++)
            {
                for (int y = 0; y < result.GetLength(1); y++)
                {
                    image.SetPixel(x, y, result[x, y]);
                }
            }
        }

        public void ProcessImage(IImage inputImage)
        {
            var segments = _segmentationAlgoritm.ProcessImage(inputImage);

            var image = segments.SegmentationMatrix;
            for (int j = 0; j < inputImage.Height; j++)
            {
                for (int i = 0; i < inputImage.Width; i++)
                {
                    var random = new Random(image[i, j]);
                    var pixel = new Pixel { R = (byte)random.Next(255), G = (byte)random.Next(255), B = (byte)random.Next(255) };
                    inputImage.SetPixel(i, j, pixel);
                }
            }
        }

 private byte GetForColorizer(Pixel p)
 {
     byte b = unchecked((byte)(Math.Floor((double)(getForPallet(p.R) / (byte)42)) * Math.Floor((double)(getForPallet(p.G) / (byte)42)) * Math.Floor((double)(getForPallet(p.B) / (byte)42))));
     if (b == 0)
     {
         return 1;
     }
     else if (b == 1)
     {
         return 0;
     }
     else
     {
         return unchecked((byte)(b + (byte)2));
     }
 }

        public void ReadCurrentRow__moves_through_complete_row()
        {
            var p = new Pixel(50, 25);
            var called = 0;
            var reader = new Mock<IImageReader>();
            reader.Setup(i => i.CurrentPixelType()).Returns(PixelType.Water);
            reader.Setup(i => i.NextRow()).Returns(() => { called++; return called < 50; });
            reader.Setup(i => i.CurrentPixel).Returns(p);
            reader.Setup(i => i.FrameHeight).Returns(50);

            var imageParser = new ImageParser(reader.Object);

            var res = imageParser.ReadCurrentRow();

            res.Should().Be(p);
            called.Should().BeGreaterOrEqualTo(49);
        }

        public Renderer(VariableSet variables, Drawable drawable)
            : base(variables)
        {
            _drawable = drawable;
              int bpp = drawable.Bpp;
              _pixel = drawable.CreatePixel();
              _color = GetValue<bool>("color");

              if (drawable.HasAlpha)
            {
              bpp--;
              _pixel.Alpha = 255;
            }

              _calculator = new Calculator(GetValue<int>("points"),
                   GetValue<int>("closest"),
                   bpp, drawable.MaskBounds,
                   (int) GetValue<UInt32>("seed"));
        }

        public void ConstructorTests()
        {
            var m = new Matrix<Pixel>(
                new Pixel(1, 1, 1, 1), new Pixel(1, 1, 2, 2),
                new Pixel(2, 2, 1, 1), new Pixel(2, 2, 2, 2));

            for(var i = 0; i < m.Width; i++)
            {
                var x = (byte)(i + 1);

                for (var j = 0; j < m.Height; j++)
                {
                    var y = (byte)(j + 1);
                    var p = new Pixel(y, y, x, x);

                    Trace.WriteLine($"[{x}, {y}]: {p} == {m[i,j]}");
                    Assert.AreEqual(m[i, j], p,
                        $"{m[i, j]} <> {p}\n{m}");
                }
            }
        }

        public int Classify(ref Pixel features, ref double[,] loss)
        {
            double[,] pxjwi = Normalize(ref features);
            double[] pxwi = new double[NumofClasses];
            for (int i = 0; i < NumofClasses; ++i)
            {
                pxwi[i] = 1;
                for (int j = 0; j < NumofFeatures; ++j)
                    pxwi[i] *= pxjwi[i, j];
            }
            double sum = 0;
            for (int i = 0; i < NumofClasses; ++i)
            {
                pxwi[i] *= PClasses;
                sum += pxwi[i];
            }
            for (int i = 0; i < NumofClasses; ++i)
            {
                pxwi[i] /= sum;
            }
            double[] r = new double[NumofActions];

            for (int i = 0; i < NumofActions; ++i)
            {
                sum = 0;
                for (int j = 0; j < NumofClasses; ++j)
                    sum += loss[i,j] * pxwi[j];
                r[i] = sum;
            }
            // Return the index of the lowest risk of the N Actions
            double x = int.MaxValue; int ind = 0;
            for (int i = 0; i < NumofActions; ++i)
                if (x > r[i])
                {
                    x = r[i];
                    ind = i;
                }
            return ind;
        }

        public Layer( ImageInfo image, String label = null )
        {
            Image = image;

            if ( label == null )
            {
                int i = 1;
                while ( image.Layers.Exists( x => x.Label.ToLower().Equals( "layer " + i ) ) )
                    ++i;

                label = "layer " + i;
            }

            Label = label;

            Pixels = new Pixel[ Width, Height ];
            Bitmap = new Bitmap( Width, Height );

            for ( int x = 0; x < Width; ++x )
                for ( int y = 0; y < Height; ++y )
                    SetPixel( x, y, Pixel.Empty );
        }

        public override void Write(Pixel[] frame) {
            ulong[] outputGreen = new ulong[PanelsPerFrame];
            ulong[] outputRed = new ulong[PanelsPerFrame];
            ulong pixelStateGreen = 0;
            ulong pixelStateRed = 0;

            for (int panels = 0; panels < PanelsPerFrame; panels++) {

                for (int i = panels * 64; i < 64 + (panels * 64); i++) {

                    switch (frame[i].ColourValue) {
                        case 65280:  // green
                            pixelStateGreen = 1UL;
                            pixelStateGreen = pixelStateGreen << i;
                            outputGreen[panels] = outputGreen[panels] | pixelStateGreen;
                            break;
                        case 16711680: // red
                            pixelStateRed = 1UL;
                            pixelStateRed = pixelStateRed << i;
                            outputRed[panels] = outputRed[panels] | pixelStateRed;
                            break;
                        case 16776960: //yellow
                            pixelStateGreen = 1UL;
                            pixelStateGreen = pixelStateGreen << i;
                            outputGreen[panels] = outputGreen[panels] | pixelStateGreen;

                            pixelStateRed = 1UL;
                            pixelStateRed = pixelStateRed << i;
                            outputRed[panels] = outputRed[panels] | pixelStateRed;

                            break;
                    }              
                }
            }

            Write(outputGreen, outputRed);
        }

        static void Main(string[] args)
        {
            while (true)
            {
                Console.WriteLine("Username:");
                string input = Console.ReadLine();
                int hash = input.GetHashCode();

                // 4x4
                var colorBlocks = new Pixel[16];

                var bits = new BitArray(new[] { hash });

                // katri 2 biti apzīmē krāsu
                for (int i = 0; i < bits.Length; i += 2)
                {
                    int[] colorInt = new[] { 0 };
                    var colorBits = new BitArray(new[] { colorInt[0] });
                    colorBits.Set(0, bits[i]);
                    colorBits.Set(1, bits[i + 1]);
                    colorBits.CopyTo(colorInt, 0);
                    colorBlocks[i / 2] = (Pixel)colorInt[0];
                }

                for (int i = 0; i < 16; i++)
                {
                    Console.BackgroundColor = colorBlocks[i].ToConsoleColor();
                    Console.Write("  ");
                    if ((i + 1) % 4 == 0)
                    {
                        Console.WriteLine();
                        Console.BackgroundColor = ConsoleColor.Black;
                    }
                }
            }
        }