示例#1
0
        private void Fill(int x, int y, FastBitmap bitmap, Func <int, int, Color> func)
        {
            int width  = bitmap.Width;
            int height = bitmap.Height;

            bool[,] flags = new bool[width, height];
            Color         replaced = bitmap.GetPixel(x, y);
            Stack <Point> points   = new Stack <Point>();

            points.Push(new Point(x, y));
            while (points.Count > 0)
            {
                Point p = points.Pop();
                if (flags[p.X, p.Y])
                {
                    continue;
                }
                flags[p.X, p.Y] = true;
                if (bitmap.GetPixel(p.X, p.Y) != replaced)
                {
                    continue;
                }
                bitmap.SetPixel(p.X, p.Y, func(p.X, p.Y));
                Push(points, new Point(p.X, p.Y + 1), width, height);
                Push(points, new Point(p.X, p.Y - 1), width, height);
                Push(points, new Point(p.X + 1, p.Y), width, height);
                Push(points, new Point(p.X - 1, p.Y), width, height);
            }
        }
示例#2
0
        public static Point?StartOutline(int x, int y, FastBitmap bitmap)
        {
            for (var innerColor = bitmap.GetPixel(x, y); x != bitmap.Width; ++x)
            {
                if (bitmap.GetPixel(x, y) != innerColor)
                {
                    return(new Point(x, y));
                }
            }

            return(null);
        }
示例#3
0
        public static LinkedList <Point> Outline(Point start, FastBitmap bitmap)
        {
            var outline      = new LinkedList <Point>();
            var currentPoint = outline.AddLast(start);
            var color        = bitmap.GetPixel(start.X, start.Y);
            var direction    = Direction.Down;

            while (true)
            {
                Point?nextPoint;
                (direction, nextPoint) = NextPoint(color, currentPoint.Value, bitmap, direction.Clockwise90Degree());
                if (!nextPoint.HasValue)
                {
                    throw new IncompleteOutlineException(outline);
                }

                if (nextPoint == start)
                {
                    break;
                }

                currentPoint = outline.AddLast(nextPoint.Value);
            }

            return(outline);
        }
示例#4
0
        private static (Direction, Point?) NextPoint(Color color, Point p, FastBitmap bitmap, Direction direction)
        {
            foreach (var(shift, nextPoint) in Neighbors(p, direction))
            {
                if (nextPoint.X < 0 || nextPoint.X >= bitmap.Width || nextPoint.Y < 0 || nextPoint.Y >= bitmap.Height)
                {
                    continue;
                }

                if (bitmap.GetPixel(nextPoint.X, nextPoint.Y) == color)
                {
                    return(shift, nextPoint);
                }
            }

            return(direction, null);
        }
示例#5
0
        public void MouseDown(int x, int y, FastBitmap bitmap)
        {
            if (!usePicture.Checked)
            {
                Fill(x, y, bitmap, (X, Y) => Color);
                return;
            }
            if (bmp == null)
            {
                MessageBox.Show("Вы не выбрали картинку!", "Окошко-всплывашка", MessageBoxButtons.OK,
                                MessageBoxIcon.Error);
                return;
            }
            FastBitmap fastBitmap = new FastBitmap(bmp, ImageLockMode.ReadOnly, PixelFormat.Format24bppRgb);
            int        addX       = fastBitmap.Width + bitmap.Width - x;
            int        addY       = fastBitmap.Height + bitmap.Height - y;

            Fill(x, y, bitmap, (X, Y) => fastBitmap.GetPixel((X + addX) % fastBitmap.Width,
                                                             (Y + addY) % fastBitmap.Height));
            fastBitmap.Dispose();
        }
        public void WuLine(int x0, int y0, FastBitmap bitmap)
        {
            int x1 = lastPoint.Value.X;
            int y1 = lastPoint.Value.Y;

            bool angle = Math.Abs(y1 - y0) > Math.Abs(x1 - x0); // проверка угла наклона

            if (angle)
            {
                Swap(ref x0, ref y0);
                Swap(ref x1, ref y1);
            }
            if (x0 > x1) //направление по ox
            {
                Swap(ref x0, ref x1);
                Swap(ref y0, ref y1);
            }

            //закрашиваем пиксель для начальной точки
            double deltax   = x1 - x0;
            double deltay   = y1 - y0;
            double gradient = deltay / deltax;

            double xEnd    = Round(x0);
            double yEnd    = y0 + gradient * (xEnd - x0);
            double xGap    = 1 - getFracPart(x0 + 0.5);
            double xPixel1 = xEnd;
            double yPixel1 = (int)yEnd;

            if (angle)
            {
                if (xPixel1 < bitmap.Width && yPixel1 < bitmap.Height - 1 &&
                    xPixel1 > 0 && yPixel1 > 0)
                {
                    bitmap.SetPixel((int)yPixel1, (int)xPixel1, getColor((1 - getFracPart(yEnd)) * xGap, bitmap.GetPixel((int)yPixel1, (int)xPixel1)));
                    bitmap.SetPixel((int)yPixel1 + 1, (int)xPixel1, getColor(getFracPart(yEnd) * xGap, bitmap.GetPixel((int)yPixel1 + 1, (int)xPixel1)));
                }
            }
            else
            {
                if (xPixel1 < bitmap.Width && yPixel1 < bitmap.Height - 1 &&
                    xPixel1 > 0 && yPixel1 > 0)
                {
                    bitmap.SetPixel((int)xPixel1, (int)yPixel1, getColor((1 - getFracPart(yEnd)) * xGap, bitmap.GetPixel((int)xPixel1, (int)yPixel1)));
                    bitmap.SetPixel((int)xPixel1, (int)yPixel1 + 1, getColor(getFracPart(yEnd) * xGap, bitmap.GetPixel((int)xPixel1, (int)yPixel1 + 1)));
                }
            }
            double y = yEnd + gradient;

            //закрашиваем пиксель для конечной точки
            xEnd = Round(x1);
            yEnd = y1 + gradient * (xEnd - x1);
            xGap = getFracPart(x1 + 0.5);
            double xPixel2 = xEnd;
            double yPixel2 = (int)yEnd;

            if (angle)
            {
                if (yPixel2 < bitmap.Width - 1 && xPixel2 < bitmap.Height &&
                    xPixel2 >= 0 && yPixel2 >= 0)
                {
                    bitmap.SetPixel((int)yPixel2, (int)xPixel2, getColor((1 - getFracPart(yEnd)) * xGap, bitmap.GetPixel((int)yPixel2, (int)xPixel2)));
                    bitmap.SetPixel((int)yPixel2 + 1, (int)xPixel2, getColor(getFracPart(yEnd) * xGap, bitmap.GetPixel((int)yPixel2 + 1, (int)xPixel2)));
                }
            }
            else
            {
                if (xPixel2 < bitmap.Width && yPixel2 < bitmap.Height - 1 &&
                    xPixel2 >= 0 && yPixel2 >= 0)
                {
                    bitmap.SetPixel((int)xPixel2, (int)yPixel2, getColor((1 - getFracPart(yEnd)) * xGap, bitmap.GetPixel((int)xPixel2, (int)yPixel2)));
                    bitmap.SetPixel((int)xPixel2, (int)yPixel2 + 1, getColor(getFracPart(yEnd) * xGap, bitmap.GetPixel((int)xPixel2, (int)yPixel2 + 1)));
                }
            }

            //закрашиваем пиксели от начала до конца
            if (angle)
            {
                for (int x = (int)(xPixel1 + 1); x <= xPixel2 - 1; x++)
                {
                    if (y < bitmap.Width - 1 && x < bitmap.Height &&
                        x >= 0 && y >= 0)
                    {
                        bitmap.SetPixel((int)y, x, getColor(1 - (y - (int)y), bitmap.GetPixel((int)y, x)));
                        bitmap.SetPixel((int)y + 1, x, getColor(y - (int)y, bitmap.GetPixel((int)y + 1, x)));
                    }
                    y += gradient;
                }
            }
            else
            {
                for (int x = (int)(xPixel1 + 1); x <= xPixel2 - 1; x++)
                {
                    if (x < bitmap.Width && y < bitmap.Height - 1 &&
                        x >= 0 && y >= 0)
                    {
                        bitmap.SetPixel(x, (int)y, getColor(1 - (y - (int)y), bitmap.GetPixel(x, (int)y)));
                        bitmap.SetPixel(x, (int)y + 1, getColor(y - (int)y, bitmap.GetPixel((int)x, (int)y + 1)));
                    }
                    y += gradient;
                }
            }
        }