Обрезка картинки и приведение ее к нулевым координатам

public partial class Form1 : Form
    {
        int j = 0, k = 0;
        private Bitmap image = null;
        private List<Figure> figures = new List<Figure>();
 
        public Form1()
        {
            InitializeComponent();
 
            this.Opacity = 0.85;
            this.FormBorderStyle = FormBorderStyle.None;
            this.AllowTransparency = true;
            this.BackColor = Color.Black;//цвет фона  
          //  this.TransparencyKey = this.BackColor;
        }
 
        private void Form1_Load(object sender, EventArgs e)
        {
            image = GetImage(out j,out k);
 
            label1.Text = figures.Count.ToString();
        }
 
        private Bitmap GetImage(out int j,out int k)
        {
            figures.Clear();
            Figure line1 = new Figure(FigureType.Line);
            figures.Add(line1);
            Figure line2 = new Figure(FigureType.Line);
            figures.Add(line2);
            Figure line3 = new Figure(FigureType.Line);
            figures.Add(line3);
 
            Figure[] fig = new Figure[] { line1, line2, line3 };
 
            int indexLines = -1, indexSquare = -1;
 
            Figure square = new Figure(FigureType.Square);
            figures.Add(square);
 
            Bitmap mask = Properties.Resources.n0;
            Bitmap image = Properties.Resources.n1;
 
            Bitmap bmp = null; Color color;
            using (Graphics g = Graphics.FromImage(image))
            {
                for (int y = 0; y < image.Height; y++)
                {
                    for (int x = 0; x < image.Width; x++)
                    {
                        color = mask.GetPixel(x, y);
                        //Color 255 0 0 - start
 
                      //  MessageBox.Show(string.Format("X:{0}Y:{1}",x,y));
 
                        if (Compare(color, Color.FromArgb(255, 0, 0)))
                        {
                            UpdateLines(ref indexLines, fig, new Point(x, y));
                            image.SetPixel(x, y, Color.FromArgb(0, 0, 0, 0));
 
                        }//Color 255 0 255 - end
                        else if (Compare(color, Color.FromArgb(255, 0, 255)))
                        {
                            UpdateLines(ref indexLines, fig, new Point(x, y)); 
                            image.SetPixel(x, y, Color.FromArgb(0, 0, 0, 0));
 
                        }//Color 0 0 255 - start rect
                        else if (Compare(color, Color.FromArgb(0, 0, 255)))
                        {
                            UpdateSquare(ref indexSquare, square, new Point(x, y)); 
                            image.SetPixel(x, y, Color.FromArgb(0, 0, 0, 0));
 
                        }//Color 255 255 0 - center rect
                        else if (Compare(color, Color.FromArgb(255, 255, 0)))
                        {
                            UpdateSquare(ref indexSquare, square, new Point(x, y)); 
                            image.SetPixel(x, y, Color.FromArgb(0, 0, 0, 0));
 
                        }
                        else if (Compare(color, Color.FromArgb(0, 0, 0)))
                        {
                            image.SetPixel(x, y, Color.FromArgb(0, 0, 0, 0));
                        }
                        else
                        {
                            image.SetPixel(x, y, Color.FromArgb(0, 255, 255));
                        }
                    }
                }
 
                bmp = new Bitmap(image.Width, image.Height, g);
            }
 
            j = indexLines;
            k = indexSquare;
 
            return image;// bmp;
        }
 
        private static int UpdateSquare(ref int indexSquare, Figure figure, Point point)
        {
            indexSquare++;
            if (indexSquare == 0)
            {
                figure.AddPoint(PointType.PointLT, point);
            }
            else if (indexSquare == 1)
            {
                figure.AddPoint(PointType.PointRT, point);
            }
            else if (indexSquare == 2)
            {
                figure.AddPoint(PointType.Center, point);
            }
            else if (indexSquare == 3)
            {
                figure.AddPoint(PointType.PointLB, point);
            }
            else if (indexSquare == 4)
            {
                figure.AddPoint(PointType.PointRB, point);
            }
 
            return indexSquare;
        }
 
        private static int UpdateLines(ref int indexLines, Figure[] figures, Point point)
        {
            indexLines++;
            if (indexLines == 0)
            {
                figures[0].AddPoint(PointType.PointLT, point);
            }
            else if (indexLines == 1)
            {
                figures[0].AddPoint(PointType.PointRB, point);
            }
            else if (indexLines == 2)
            {
                figures[1].AddPoint(PointType.PointLT, point);
            }
            else if (indexLines == 3)
            {
                figures[1].AddPoint(PointType.PointRB, point);
            }
            else if (indexLines == 4)
            {
                figures[2].AddPoint(PointType.PointLT, point);
            }
            else if (indexLines == 5)
            {
                figures[2].AddPoint(PointType.PointRB, point);
            }
 
            return indexLines;
        }
 
        //////////////////////////////////////////////////////////////////////////////////////////////
        
        //////////////////////////////////////////////////////////////////////////////////////////////
 
        enum FigureType
        {
            Line = 0,
            Triangle = 1,
            Square = 2,
        }
 
        enum PointType
        {
            Center = 0,
 
            PointLT = 1,
            PointLC = 2,
            PointLB = 3,
 
            PointCT = 4,
 
            PointRT = 5,
            PointRC = 6,
            PointRB = 7,
 
            PointCB = 8
        }
 
        class Figure
        {
            class _Point
            {
                readonly int _x = 0, _y = 0;
                readonly PointType _type = PointType.Center;
 
                public _Point(Point point, PointType type)
                {
                    this._x = point.X;
                    this._y = point.Y;
                    this._type = type;
                }
 
                public Point Point
                {
                    get { return new Point(_x, _y); }
                }
 
                public PointType Type
                {
                    get { return _type; }
                }
            }
 
            private List<_Point> _points = new List<_Point>();
            readonly FigureType _type = FigureType.Line;
 
            public Figure()
                : this(FigureType.Line)
            {
            }
 
            public Figure(FigureType type)
            {
                this._type = type;
            }
 
            public FigureType GetFType()
            {
                return _type;
            }
 
            public void AddPoint(PointType t, Point p)
            {
                _points.Add(new _Point(p, t));
            }
 
            public object GetFigure(Graphics gfx)
            {
 
                if (_type == FigureType.Line)
                {
                    int x = 0, y = 0, w = 0, h = 0;
                    foreach (_Point p in _points)
                    {
                        if (p.Type == PointType.PointLT)
                        {
                            x =  p.Point.X;
                            y =  p.Point.Y;
                        }
                        else if (p.Type == PointType.PointRB)
                        {
                            w =  p.Point.X;
                            h =  p.Point.Y;
                        }
                    }
 
                    if (gfx != null)
                    {
 
                        gfx.DrawRectangle(new Pen(Color.Red), x, y, w - x, h - y);
                        gfx.DrawLine(new Pen(Color.Red), x, y, w, h);
                    }
 
                  //  gfx.DrawRectangle(new Pen(Color.Red), x, y, w, h);
 
                    return new Rectangle(x, y, w, h);
                }
                else if (_type == FigureType.Triangle)
                {
                    int x1 = 0, y1 = 0, w1x2 = 0, h1y2 = 0, w2 = 0, h2 = 0;
                    foreach (_Point p in _points)
                    {
                        if (p.Type == PointType.PointLT)
                        {
                            x1 =  p.Point.X;
                            y1 =  p.Point.Y;
                        }
                        else if (p.Type == PointType.Center)
                        {
                            w1x2 =  p.Point.X;
                            h1y2 =  p.Point.Y;
                        }
                        else if (p.Type == PointType.PointRB)
                        {
                            w2 =  p.Point.X;
                            h2 =  p.Point.Y;
                        }
 
                    }
 
                    if (gfx != null)
                    {
                        gfx.DrawRectangle(new Pen(Color.Orange), x1, y1, w1x2 - x1, w1x2 - y1);
                        gfx.DrawLine(new Pen(Color.Orange), x1, y1, w1x2, w1x2);
 
                        gfx.DrawRectangle(new Pen(Color.Yellow), w1x2, h1y2, w2 - w1x2, h2 - h1y2);
                        gfx.DrawLine(new Pen(Color.Yellow), w1x2, h1y2, w2, h2);
                    }
 
                    return new Rectangle[] { 
                        new Rectangle(x1, y1, w1x2, h1y2), 
                        new Rectangle(w1x2, h1y2, w2, h2) 
                    };
                }
                else if (_type == FigureType.Square)
                {
                    int x1 = 0, x2 = 0, x3 = 0, x4 = 0, y1 = 0, y2 = 0, y3 = 0, y4 = 0, cx = 0, cy = 0;
                    foreach (_Point p in _points)
                    {
                        if (p.Type == PointType.PointLT)
                        {
                            x1 =  p.Point.X;
                            y1 =  p.Point.Y;
                        }
 
                        else if (p.Type == PointType.PointLB)
                        {
                            x3 =  p.Point.X;
                            y3 =  p.Point.Y;
                        }
                        else if (p.Type == PointType.Center)
                        {
                            cx =  p.Point.X;
                            cy =  p.Point.Y;
                        }
                        else if (p.Type == PointType.PointRB)
                        {
                            x4 =  p.Point.X;
                            y4 =  p.Point.Y;
                        }
                        else if (p.Type == PointType.PointRT)
                        {
                            x2 =  p.Point.X;
                            y2 =  p.Point.Y;
                        }
                    }
 
                    if (gfx != null)
                    {
                        gfx.DrawRectangle(new Pen(Color.Green), x1, y1, cx - x1, cy - y1);
                        gfx.DrawLine(new Pen(Color.Green), x1, y1, cx, cy);
 
                        gfx.DrawRectangle(new Pen(Color.LightBlue), cx, y1, x2 - cx, cy - y1);
                        gfx.DrawLine(new Pen(Color.LightBlue), cx, y1, x2, cy);
 
                        gfx.DrawRectangle(new Pen(Color.Blue), x1, cy, cx - x1, y3 - cy);
                        gfx.DrawLine(new Pen(Color.Blue), x1, cy, cx, y3);
 
                        gfx.DrawRectangle(new Pen(Color.Violet), cx, cy, x4 - cx, y4 - cy);
                        gfx.DrawLine(new Pen(Color.Violet), cx, cy, x4, y4);
                    }
 
                    return new Rectangle[] { 
                        new Rectangle(x1, y1, cx, cy), 
                        new Rectangle(cx, y1, x2, cy), 
                        new Rectangle(x1, cy, cx, y3), 
                        new Rectangle(cx, cy, x4, y4)
                    };
 
                    
                }
                return Rectangle.Empty;
            }
        }
        //////////////////////////////////////////////////////////////////////////////////////////////
 
        bool Compare(Color c1, Color c2, int ac = 5)
        {
            if (Math.Abs(c1.R - c2.R) > ac)
                return false;
            if (Math.Abs(c1.G - c2.G) > ac)
                return false;
            if (Math.Abs(c1.B - c2.B) > ac)
                return false;
 
            return true;
        }
 
        //////////////////////////////////////////////////////////////////////////////////////////////
        Color[] c = new Color[] 
        { 
            Color.Aqua,
            Color.BlueViolet,
            Color.Red,
            Color.Green,
            Color.Pink,
            Color.Gold
        };
 
        Random rnd = new Random();
 
        Bitmap GetBitmapRegion(Rectangle rect, Bitmap bmp)
        {
            int i = rnd.Next(c.Length);
 
            Bitmap region = new Bitmap(rect.Width, rect.Height, bmp.PixelFormat);
 
            using (Graphics g = Graphics.FromImage(region))
            {
                g.DrawImage(bmp, rect, rect, GraphicsUnit.Pixel);
 
                for (int y = 0; y < region.Height; y++)
                {
                    for (int x = 0; x < region.Width; x++)
                    {
                       Color color = region.GetPixel(x, y);
 
                       if (color.B > 10 || color.G > 10 || color.R > 10)
                           region.SetPixel(x, y, c[i]);
                    }
                }
            }
 
            return region;
        }
 
        //////////////////////////////////////////////////////////////////////////////////////////////
        //////////////////////////////////////////////////////////////////////////////////////////////
 
        protected override void OnPaint(PaintEventArgs e)
        {
            base.OnPaint(e);
 
            
            Rectangle[] rect = (Rectangle[])figures[3].GetFigure(gfx);
            Rectangle diagonal = (Rectangle)figures[0].GetFigure(gfx);
            Rectangle vertical = (Rectangle)figures[1].GetFigure(gfx);
            Rectangle horizontal = (Rectangle)figures[2].GetFigure(gfx); 
            
 
            Bitmap lt = GetBitmapRegion(rect[0], image);
            Bitmap rt = GetBitmapRegion(rect[1], image);
            Bitmap lb = GetBitmapRegion(rect[2], image);
            Bitmap rb = GetBitmapRegion(rect[3], image);
 
            Bitmap diagonal = GetBitmapRegion(rect0, image);
            Bitmap vertical = GetBitmapRegion(rect1, image);
            Bitmap horizontal = GetBitmapRegion(rect2, image);
 
 
            e.Graphics.DrawImage(lt, 0, 0);
            e.Graphics.DrawImage(lb, 0, 0);
 
            e.Graphics.DrawImage(vertical, 0, 0);
 
            e.Graphics.DrawImage(diagonal, 0, 0);
            
            e.Graphics.DrawImage(horizontal, 0, 0);
 
            e.Graphics.DrawImage(rt, 0, 0);
            e.Graphics.DrawImage(rb, 0, 0);
            
 
            this.Text = string.Format("J={0}/{1}", j, k);
        }
    }

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Drawing.Imaging;
using System.Linq;
using System.Text;
using System.Windows.Forms;
 
namespace DrawingForm
{
    public partial class Form1 : Form
    {
        int j = 0, k = 0;
        private Bitmap image = null;
        private List<Figure> figures = new List<Figure>();
 
        public Form1()
        {
            InitializeComponent();
 
            this.Opacity = 0.85;
            this.FormBorderStyle = FormBorderStyle.None;
            this.AllowTransparency = true;
            this.BackColor = Color.Black;//цвет фона  
            this.TransparencyKey = this.BackColor;
        }
 
        private void Form1_Load(object sender, EventArgs e)
        {
            image = GetImage(out j,out k);
 
            label1.Text = figures.Count.ToString();
        }
 
        private Bitmap GetImage(out int j,out int k)
        {
            figures.Clear();
            Figure line1 = new Figure(FigureType.Line);
            figures.Add(line1);
            Figure line2 = new Figure(FigureType.Line);
            figures.Add(line2);
            Figure line3 = new Figure(FigureType.Line);
            figures.Add(line3);
 
            Figure[] fig = new Figure[] { line1, line2, line3 };
 
            int indexLines = -1, indexSquare = -1;
 
            Figure square = new Figure(FigureType.Square);
            figures.Add(square);
 
            Bitmap mask = Properties.Resources.n0;
            Bitmap image = Properties.Resources.n1;
 
            Bitmap bmp = null; Color color;
            using (Graphics g = Graphics.FromImage(image))
            {
                for (int y = 0; y < image.Height; y++)
                {
                    for (int x = 0; x < image.Width; x++)
                    {
                        color = mask.GetPixel(x, y);
                        //Color 255 0 0 - start
 
                      //  MessageBox.Show(string.Format("X:{0}Y:{1}",x,y));
 
                        if (Compare(color, Color.FromArgb(255, 0, 0)))
                        {
                            UpdateLines(ref indexLines, fig, new Point(x, y));
                            image.SetPixel(x, y, Color.FromArgb(0, 0, 0, 0));
 
                        }//Color 255 0 255 - end
                        else if (Compare(color, Color.FromArgb(255, 0, 255)))
                        {
                            UpdateLines(ref indexLines, fig, new Point(x, y)); 
                            image.SetPixel(x, y, Color.FromArgb(0, 0, 0, 0));
 
                        }//Color 0 0 255 - start rect
                        else if (Compare(color, Color.FromArgb(0, 0, 255)))
                        {
                            UpdateSquare(ref indexSquare, square, new Point(x, y)); 
                            image.SetPixel(x, y, Color.FromArgb(0, 0, 0, 0));
 
                        }//Color 255 255 0 - center rect
                        else if (Compare(color, Color.FromArgb(255, 255, 0)))
                        {
                            UpdateSquare(ref indexSquare, square, new Point(x, y)); 
                            image.SetPixel(x, y, Color.FromArgb(0, 0, 0, 0));
 
                        }
                        else if (Compare(color, Color.FromArgb(0, 0, 0)))
                        {
                            image.SetPixel(x, y, Color.FromArgb(0, 0, 0, 0));
                        }
                        else
                        {
                            image.SetPixel(x, y, Color.FromArgb(0, 255, 255));
                        }
                    }
                }
 
                bmp = new Bitmap(image.Width, image.Height, g);
            }
 
            j = indexLines;
            k = indexSquare;
 
            return image;// bmp;
        }
 
        private static int UpdateSquare(ref int indexSquare, Figure figure, Point point)
        {
            indexSquare++;
            if (indexSquare == 0)
            {
                figure.AddPoint(PointType.PointLT, point);
            }
            else if (indexSquare == 1)
            {
                figure.AddPoint(PointType.PointRT, point);
            }
            else if (indexSquare == 2)
            {
                figure.AddPoint(PointType.Center, point);
            }
            else if (indexSquare == 3)
            {
                figure.AddPoint(PointType.PointLB, point);
            }
            else if (indexSquare == 4)
            {
                figure.AddPoint(PointType.PointRB, point);
            }
 
            return indexSquare;
        }
 
        private static int UpdateLines(ref int indexLines, Figure[] figures, Point point)
        {
            indexLines++;
            if (indexLines == 0)
            {
                figures[0].AddPoint(PointType.PointLT, point);
            }
            else if (indexLines == 1)
            {
                figures[0].AddPoint(PointType.PointRB, point);
            }
            else if (indexLines == 2)
            {
                figures[1].AddPoint(PointType.PointLT, point);
            }
            else if (indexLines == 3)
            {
                figures[1].AddPoint(PointType.PointRB, point);
            }
            else if (indexLines == 4)
            {
                figures[2].AddPoint(PointType.PointLT, point);
            }
            else if (indexLines == 5)
            {
                figures[2].AddPoint(PointType.PointRB, point);
            }
 
            return indexLines;
        }
 
        //////////////////////////////////////////////////////////////////////////////////////////////
        
        //////////////////////////////////////////////////////////////////////////////////////////////
 
        enum FigureType
        {
            Line = 0,
            Triangle = 1,
            Square = 2,
        }
 
        enum PointType
        {
            Center = 0,
 
            PointLT = 1,
            PointLC = 2,
            PointLB = 3,
 
            PointCT = 4,
 
            PointRT = 5,
            PointRC = 6,
            PointRB = 7,
 
            PointCB = 8
        }
 
        class Figure
        {
            class _Point
            {
                readonly int _x = 0, _y = 0;
                readonly PointType _type = PointType.Center;
 
                public _Point(Point point, PointType type)
                {
                    this._x = point.X;
                    this._y = point.Y;
                    this._type = type;
                }
 
                public Point Point
                {
                    get { return new Point(_x, _y); }
                }
 
                public PointType Type
                {
                    get { return _type; }
                }
            }
 
            private List<_Point> _points = new List<_Point>();
            readonly FigureType _type = FigureType.Line;
 
            public Figure()
                : this(FigureType.Line)
            {
            }
 
            public Figure(FigureType type)
            {
                this._type = type;
            }
 
            public FigureType GetFType()
            {
                return _type;
            }
 
            public void AddPoint(PointType t, Point p)
            {
                _points.Add(new _Point(p, t));
            }
 
            public object GetFigure(Graphics gfx)
            {
 
                if (_type == FigureType.Line)
                {
                    int x = 0, y = 0, w = 0, h = 0;
                    foreach (_Point p in _points)
                    {
                        if (p.Type == PointType.PointLT)
                        {
                            x =  p.Point.X;
                            y =  p.Point.Y;
                        }
                        else if (p.Type == PointType.PointRB)
                        {
                            w =  p.Point.X;
                            h =  p.Point.Y;
                        }
                    }
 
                    if (gfx != null)
                    {
 
                        gfx.DrawRectangle(new Pen(Color.Red), x, y, w - x, h - y);
                        gfx.DrawLine(new Pen(Color.Red), x, y, w, h);
                    }
 
                  //  gfx.DrawRectangle(new Pen(Color.Red), x, y, w, h);
 
                    return new Rectangle(x, y, w, h);
                }
                else if (_type == FigureType.Triangle)
                {
                    int x1 = 0, y1 = 0, w1x2 = 0, h1y2 = 0, w2 = 0, h2 = 0;
                    foreach (_Point p in _points)
                    {
                        if (p.Type == PointType.PointLT)
                        {
                            x1 =  p.Point.X;
                            y1 =  p.Point.Y;
                        }
                        else if (p.Type == PointType.Center)
                        {
                            w1x2 =  p.Point.X;
                            h1y2 =  p.Point.Y;
                        }
                        else if (p.Type == PointType.PointRB)
                        {
                            w2 =  p.Point.X;
                            h2 =  p.Point.Y;
                        }
 
                    }
 
                    if (gfx != null)
                    {
                        gfx.DrawRectangle(new Pen(Color.Orange), x1, y1, w1x2 - x1, w1x2 - y1);
                        gfx.DrawLine(new Pen(Color.Orange), x1, y1, w1x2, w1x2);
 
                        gfx.DrawRectangle(new Pen(Color.Yellow), w1x2, h1y2, w2 - w1x2, h2 - h1y2);
                        gfx.DrawLine(new Pen(Color.Yellow), w1x2, h1y2, w2, h2);
                    }
 
                    return new Rectangle[] { 
                        new Rectangle(x1, y1, w1x2, h1y2), 
                        new Rectangle(w1x2, h1y2, w2, h2) 
                    };
                }
                else if (_type == FigureType.Square)
                {
                    int x1 = 0, x2 = 0, x3 = 0, x4 = 0, y1 = 0, y2 = 0, y3 = 0, y4 = 0, cx = 0, cy = 0;
                    foreach (_Point p in _points)
                    {
                        if (p.Type == PointType.PointLT)
                        {
                            x1 =  p.Point.X;
                            y1 =  p.Point.Y;
                        }
 
                        else if (p.Type == PointType.PointLB)
                        {
                            x3 =  p.Point.X;
                            y3 =  p.Point.Y;
                        }
                        else if (p.Type == PointType.Center)
                        {
                            cx =  p.Point.X;
                            cy =  p.Point.Y;
                        }
                        else if (p.Type == PointType.PointRB)
                        {
                            x4 =  p.Point.X;
                            y4 =  p.Point.Y;
                        }
                        else if (p.Type == PointType.PointRT)
                        {
                            x2 =  p.Point.X;
                            y2 =  p.Point.Y;
                        }
                    }
 
                    if (gfx != null)
                    {
                        gfx.DrawRectangle(new Pen(Color.Green), x1, y1, cx - x1, cy - y1);
                        gfx.DrawLine(new Pen(Color.Green), x1, y1, cx, cy);
 
                        gfx.DrawRectangle(new Pen(Color.LightBlue), cx, y1, x2 - cx, cy - y1);
                        gfx.DrawLine(new Pen(Color.LightBlue), cx, y1, x2, cy);
 
                        gfx.DrawRectangle(new Pen(Color.Blue), x1, cy, cx - x1, y3 - cy);
                        gfx.DrawLine(new Pen(Color.Blue), x1, cy, cx, y3);
 
                        gfx.DrawRectangle(new Pen(Color.Violet), cx, cy, x4 - cx, y4 - cy);
                        gfx.DrawLine(new Pen(Color.Violet), cx, cy, x4, y4);
                    }
 
                    return new Rectangle[] { 
                        new Rectangle(x1, y1, cx, cy), 
                        new Rectangle(cx, y1, x2, cy), 
                        new Rectangle(x1, cy, cx, y3), 
                        new Rectangle(cx, cy, x4, y4)
                    };
 
                    
                }
                return Rectangle.Empty;
            }
        }
        //////////////////////////////////////////////////////////////////////////////////////////////
 
        bool Compare(Color c1, Color c2, int ac = 5)
        {
            if (Math.Abs(c1.R - c2.R) > ac)
                return false;
            if (Math.Abs(c1.G - c2.G) > ac)
                return false;
            if (Math.Abs(c1.B - c2.B) > ac)
                return false;
 
            return true;
        }
 
        //////////////////////////////////////////////////////////////////////////////////////////////
        static Color[] c = new Color[] 
        { 
            Color.Aqua,
            Color.BlueViolet,
            Color.Red,
            Color.Green,
            Color.Pink,
            Color.Gold
        };
 
        static Random rnd = new Random();
 
        public static Bitmap GetBitmapRegion(Rectangle rect, Bitmap bmp)
        {
            int i = rnd.Next(c.Length);
 
            Bitmap region = new Bitmap(rect.Width, rect.Height, bmp.PixelFormat);
 
            using (Graphics g = Graphics.FromImage(region))
            {
                g.DrawImage(bmp, rect, rect, GraphicsUnit.Pixel);
 
                for (int y = 0; y < region.Height; y++)
                {
                    for (int x = 0; x < region.Width; x++)
                    {
                       Color color = region.GetPixel(x, y);
 
                       if (color.B > 10 || color.G > 10 || color.R > 10)
                           region.SetPixel(x, y, c[i]);
                    }
                }
            }
 
            return region;
        }
 
        //////////////////////////////////////////////////////////////////////////////////////////////
        //////////////////////////////////////////////////////////////////////////////////////////////
 
        protected override void OnPaint(PaintEventArgs e)
        {
            base.OnPaint(e);
 
            AllRegions rect = UpdateRectangle(null/*e.Graphics*/);
 
            rect.Diagonal.Draw(e.Graphics, new Point(0, 0));
            rect.Horizontal.Draw(e.Graphics, new Point(10, 0));
            rect.Horizontal.Draw(e.Graphics, new Point(20, 0));
            rect.Horizontal.Draw(e.Graphics, new Point(30, 0));
            rect.Horizontal.Draw(e.Graphics, new Point(40, 0));
            rect.Horizontal.Draw(e.Graphics, new Point(50, 0));
            rect.Horizontal.Draw(e.Graphics, new Point(60, 0));
            rect.Horizontal.Draw(e.Graphics, new Point(70, 0));
            rect.Horizontal.Draw(e.Graphics, new Point(80, 0));
            rect.Horizontal.Draw(e.Graphics, new Point(90, 0));
 
            rect.RightTop.Draw(e.Graphics, new Point(100, 0));
 
            rect.Vertical.Draw(e.Graphics, new Point(0, 10));
            rect.Vertical.Draw(e.Graphics, new Point(0, 20));
            rect.Vertical.Draw(e.Graphics, new Point(0, 30));
            rect.Vertical.Draw(e.Graphics, new Point(0, 40));
            rect.Vertical.Draw(e.Graphics, new Point(0, 50));
 
            rect.Vertical.Draw(e.Graphics, new Point(102, 8));
            rect.Vertical.Draw(e.Graphics, new Point(102, 18));
            rect.Vertical.Draw(e.Graphics, new Point(102, 28));
            rect.Vertical.Draw(e.Graphics, new Point(102, 38));
            rect.Vertical.Draw(e.Graphics, new Point(102, 48));
            ////
            rect.LeftBottom.Draw(e.Graphics, new Point(0, 60));
            ////
            rect.Horizontal.Draw(e.Graphics, new Point(8, 62));
            rect.Horizontal.Draw(e.Graphics, new Point(17, 62));
            rect.Horizontal.Draw(e.Graphics, new Point(27, 62));
            rect.Horizontal.Draw(e.Graphics, new Point(37, 62));
            rect.Horizontal.Draw(e.Graphics, new Point(47, 62));
            rect.Horizontal.Draw(e.Graphics, new Point(57, 62));
            rect.Horizontal.Draw(e.Graphics, new Point(67, 62));
            rect.Horizontal.Draw(e.Graphics, new Point(77, 62));
            rect.Horizontal.Draw(e.Graphics, new Point(87, 62));
 
 
           // rect.LeftTop.Draw(e.Graphics, new Point(20, 0));
 
           rect.RightBottom.Draw(e.Graphics, new Point(100, 60));
 
            
 
            
 
           // rect.Diagonal.Image.Save("out.png", ImageFormat.Png);
 
           this.Text = string.Format("J={0}/{1}", j, k);
        }
 
        private AllRegions UpdateRectangle(Graphics gfx)
        {
            Rectangle[] rect = (Rectangle[])figures[3].GetFigure(gfx);
            Rectangle diagonal = (Rectangle)figures[0].GetFigure(gfx);
            Rectangle vertical = (Rectangle)figures[1].GetFigure(gfx);
            Rectangle horizontal = (Rectangle)figures[2].GetFigure(gfx);
 
            Rectangle[] ret = new Rectangle[]
            {
               diagonal, vertical, horizontal, rect[0], rect[1], rect[2], rect[3]
            };
 
            return new AllRegions(ret, image);
        }
 
        class AllRegions
        {
            Img[] img = new Img[7];
 
            public AllRegions(Rectangle[] rect, Bitmap bmp)
            {
                for (int i = 0; i < rect.Length; i++)
                    img[i] = new Img(GetBitmapRegion(rect[i],bmp), rect[i]);
            }
 
            public Img LeftTop
            {
                get { return img[3]; }
            }
 
            public Img RightTop
            {
                get { return img[4]; }
            }
 
            public Img LeftBottom
            {
                get { return img[5]; }
            }
 
            public Img RightBottom
            {
                get { return img[6]; }
            }
 
            public Img Diagonal
            {
                get { return img[0]; }
            }
 
            public Img Vertical
            {
                get { return img[1]; }
            }
 
            public Img Horizontal
            {
                get { return img[2]; }
            }
 
            
        }
 
        class Img
        {
            readonly Bitmap _bmp;
            readonly Rectangle _rect;
 
            public Img(Bitmap bmp, Rectangle rect)
            {
                this._bmp = bmp;
                this._rect = rect;
            }
 
            public void Draw(Graphics gfx, Point point)
            {
                gfx.DrawImage(_bmp, point.X - _rect.Left, point.Y - _rect.Top);
            }
 
            public Bitmap Image
            {
                get { return _bmp; }
            }
 
            public Rectangle Rect
            {
                get { return _rect; }
            }
        }
 
    }
}