public Bitmap[] Map(params PixelMap[] map)
        {
            var count  = map.Length;
            var result = new Bitmap[count];
            var write  = new FastBitmap[count];

            for (var i = 0; i < count; i++)
            {
                var b = new Bitmap(_bitmap.Width, _bitmap.Height);
                result[i] = b;
                write[i]  = new FastBitmap(b, ImageLockMode.WriteOnly, Data.PixelFormat);
            }

            var writeRows = new byte *[count];

            for (var y = 0; y < Data.Height; y++)
            {
                var row = Row(y);
                for (var i = 0; i < count; i++)
                {
                    writeRows[i] = write[i].Row(y);
                }
                for (var x = 0; x < Data.Width; x++)
                {
                    var pixel = row + x * Bpp;
                    for (var i = 0; i < count; i++)
                    {
                        map[i](Data.PixelFormat, pixel, writeRows[i] + x * write[i].Bpp);
                    }
                }
            }

            for (var i = 0; i < count; i++)
            {
                write[i].Dispose();
            }

            return(result);
        }
Exemple #2
0
 public void Start(FastBitmap bitmap)
 {
 }
Exemple #3
0
 public void MouseUp(int x, int y, FastBitmap bitmap)
 {
 }
Exemple #4
0
 public void MouseMove(int x, int y, FastBitmap bitmap)
 {
     MouseDown(x, y, bitmap);
 }
Exemple #5
0
 public void MouseDown(int x, int y, FastBitmap bitmap)
 {
     bitmap.SetPixel(x, y, Color);
 }
        private void BresenhamLine(int x0, int y0, FastBitmap bitmap)
        {
            int x1 = lastPoint.Value.X;
            int y1 = lastPoint.Value.Y;

            int dispX = x1 - x0;
            int dispY = y1 - y0;

            int dstepX, dstepY; //шаг по диагонали
            int stepX, stepY;   //шаг по прямой

            //Определяем, как лежит конечная точка от начальной (справа или слева)
            if (dispX < 0)
            {
                dispX  = -dispX;
                dstepX = -1;
            }
            else
            {
                dstepX = 1;
            }
            //Определяем, как лежит конечная точка от начальной (сверху или снизу)
            if (dispY < 0)
            {
                dispY  = -dispY;
                dstepY = -1;
            }
            else
            {
                dstepY = 1;
            }
            //Определяем октант, в котором находится конечная точка
            if (dispX < dispY)
            {
                Swap(ref dispX, ref dispY);
                stepX = 0;
                stepY = dstepY;
            }
            else
            {
                stepX = dstepX;
                stepY = 0;
            }

            int d         = 2 * dispY - dispX;
            int incd      = 2 * dispY;
            int diag_incd = d - dispX;

            for (int i = 0; i < dispX; i++)
            {
                bitmap.SetPixel(x0, y0, Color);
                if (d < 0)      //если середина находится над линией, то идем по диагонали, иначе - прямо
                {
                    x0 += stepX;
                    y0 += stepY;
                    d  += incd;
                }
                else
                {
                    x0 += dstepX;
                    y0 += dstepY;
                    d  += diag_incd;
                }
            }
        }
 public void Start(FastBitmap bitmap)
 {
     lastPoint = null;
 }
        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;
                }
            }
        }
Exemple #9
0
 public void MouseMove(int x, int y, FastBitmap bitmap)
 {
 }