public class TextureDeformator
    {
        private bool test(Point[] polygon)
        {
            int min_x = int.MaxValue;
            int max_x = int.MinValue;
            int min_y = int.MaxValue;
            int max_y = int.MinValue;

            foreach (Point i in polygon)
            {
                if (i.X < min_x) min_x = i.X;
                if (i.X > max_x) max_x = i.X;
                if (i.Y < min_y) min_y = i.Y;
                if (i.Y > max_y) max_y = i.Y;
            }

            int size_x = max_x - min_x;
            int size_y = max_y - min_y;

            if (size_x == 0 || size_y == 0) return false;
            return true;
        }

        private Bitmap primary_fitting(Bitmap texture, Point[] polygon)
        {
            int min_x = int.MaxValue;
            int max_x = int.MinValue;
            int min_y = int.MaxValue;
            int max_y = int.MinValue;

            foreach (Point i in polygon)
            {
                if (i.X < min_x) min_x = i.X;
                if (i.X > max_x) max_x = i.X;
                if (i.Y < min_y) min_y = i.Y;
                if (i.Y > max_y) max_y = i.Y;
            }

            int size_x = max_x - min_x;
            int size_y = max_y - min_y;

            Bitmap res = new Bitmap(size_x, size_y);

            using (Graphics g = Graphics.FromImage(res))
            {
                g.DrawImage(texture, 0, 0, size_x, size_y);
            }

            return res;
        }

        private byte color_to_byte(Color color)
        {
            byte r = color.R;
            byte g = color.G;
            byte b = color.B;

            return (byte)((r + g + b) / 3);
        }

        private int[,] primary_digitization(Bitmap texture)
        {
            int w = texture.Width;
            int h = texture.Height;

            int[,] res = new int[w, h];
            Color c;

            for (int x = 0; x < w; x++)
            {
                for (int y = 0; y < h; y++)
                {
                    c = texture.GetPixel(x, y);
                    res[x, y] = color_to_byte(c);
                }
            }

            return res;
        }

        private void left_deformation(int width, int height, int[,] img, Point dp, Point tp)
        {
            int delta = Math.Abs(dp.X - tp.X); // Смещение
            if (delta == 0) return;

            double part_size = (double)((double)height / (double)delta);

            if (dp.X > tp.X)
            {
                for (int i = 1; i <= delta; i++)
                {
                    for (int y = (int)(i * part_size); y < height; y++)
                    {
                        for (int x = width - 1; x >= i; x--)
                        {
                            if (img[x, y] >= 0)
                            {
                                img[x, y] = (img[x, y] + img[x - 1, y]) / 2;
                            }
                        }
                        for (int x = i - 1; x >= 0; x--)
                        {
                            img[x, y] = -1;
                        }
                    }
                }
            }
            else
            {
                for (int i = 1; i <= delta; i++)
                {
                    for (int y = (int)(i * part_size); y < height; y++)
                    {
                        for (int x = width - 1; x >= i; x--)
                        {
                            img[x, height - y - 1] = (img[x, height - y - 1] + img[x - 1, height - y - 1]) / 2;
                        }
                        for (int x = i - 1; x >= 0; x--)
                        {
                            img[x, height - y - 1] = -1;
                        }
                    }
                }
            }
        }

        private void right_deformation(int width, int height, int[,] img, Point dp, Point tp)
        {
            int delta = Math.Abs(dp.X - tp.X); // Смещение
            if (delta == 0) return;

            double part_size = (double)((double)height / (double)delta);

            if (dp.X < tp.X)
            {
                for (int i = 1; i <= delta; i++)
                {
                    for (int y = (int)(i * part_size); y < height; y++)
                    {
                        for (int x = 0; x < width - i; x++)
                        {
                            if (img[x, y] >= 0)
                            {
                                img[x, y] = (img[x, y] + img[x + 1, y]) / 2;
                            }
                        }
                        for (int x = width - i; x < width; x++)
                        {
                            img[x, y] = -1;
                        }
                    }
                }
            }
            else
            {
                for (int i = 1; i <= delta; i++)
                {
                    for (int y = (int)(i * part_size); y < height; y++)
                    {
                        for (int x = 0; x < width - i; x++)
                        {
                            if (img[x, height - y - 1] >= 0)
                            {
                                img[x, height - y - 1] = (img[x, height - y - 1] + img[x + 1, height - y - 1]) / 2;
                            }
                        }
                        for (int x = width - i; x < width; x++)
                        {
                            img[x, height - y - 1] = -1;
                        }
                    }
                }
            }
        }

        private void top_deformation(int width, int height, int[,] img, Point lp, Point rp)
        {
            int delta = Math.Abs(lp.Y - rp.Y); // Смещение
            if (delta == 0) return;

            double part_size = (double)((double)width / (double)delta);

            if (lp.Y < rp.Y)
            {
                for (int i = 1; i <= delta; i++)
                {
                    for (int x = (int)(i * part_size); x < width; x++)
                    {
                        for (int y = height - 1; y >= i ; y--)
                        {
                            if (img[x, y] >= 0)
                            {
                                img[x, y] = (img[x, y] + img[x, y - 1]) / 2;
                            }
                        }
                        for (int y = i; y >= 0; y--)
                        {
                            img[x, y] = -1;
                        }
                    }
                }
            }
            else
            {
                for (int i = 1; i <= delta; i++)
                {
                    for (int x = (int)(i * part_size); x < width; x++)
                    {
                        for (int y = height - 1; y >= i; y--)
                        {
                            if (img[width - x - 1, y] >= 0)
                            {
                                img[width - x - 1, y] = (img[width - x - 1, y] + img[width - x - 1, y - 1]) / 2;
                            }
                        }
                        for (int y = i; y >= 0; y--)
                        {
                            img[width - x - 1, y] = -1;
                        }
                    }
                }
            }
        }

        private void down_deformation(int width, int height, int[,] img, Point lp, Point rp)
        {
            int delta = Math.Abs(lp.Y - rp.Y); // Смещение
            if (delta == 0) return;

            double part_size = (double)((double)width / (double)delta);

            if (lp.Y > rp.Y)
            {
                for (int i = 1; i <= delta; i++)
                {
                    for (int x = (int)(i * part_size); x < width; x++)
                    {
                        for (int y = 0; y < height - i; y++)
                        {
                            if (img[x, y] >= 0)
                            {
                                img[x, y] = (img[x, y] + img[x, y + 1]) / 2;
                            }
                        }
                        for (int y = height - i; y < height; y++)
                        {
                            img[x, y] = -1;
                        }
                    }
                }
            }
            else
            {
                for (int i = 1; i <= delta; i++)
                {
                    for (int x = (int)(i * part_size); x < width; x++)
                    {
                        for (int y = 0; y < height - i; y++)
                        {
                            if (img[width - x - 1, y] >= 0)
                            {
                                img[width - x - 1, y] = (img[width - x - 1, y] + img[width - x - 1, y + 1]) / 2;
                            }
                        }
                        for (int y = height - i; y < height; y++)
                        {
                            img[width - x - 1, y] = -1;
                        }
                    }
                }
            }
        }

        private Bitmap final_draw(int width, int height, int[,] img)
        {
            Bitmap res = new Bitmap(width, height);

            for (int x = 0; x < width; x++)
            {
                for (int y = 0; y < height; y++)
                {
                    if (img[x, y] < 0) res.SetPixel(x, y, Color.FromArgb(0, 0, 0, 0));
                    else res.SetPixel(x, y, Color.FromArgb(img[x, y], img[x, y], img[x, y]));
                }
            }

            return res;
        }

        public Bitmap Deformate(Bitmap texture, Point[] polygon)
        {
            if (!test(polygon)) return new Bitmap(1, 1);

            Bitmap res = primary_fitting(texture, polygon);
            int[,] img = primary_digitization(res);

            left_deformation(res.Width, res.Height, img, polygon[0], polygon[1]);
            right_deformation(res.Width, res.Height, img, polygon[3], polygon[2]);
            top_deformation(res.Width, res.Height, img, polygon[1], polygon[2]);
            down_deformation(res.Width, res.Height, img, polygon[0], polygon[3]);

            res = final_draw(res.Width, res.Height, img);

            return res;
        }
    }