Esempio n. 1
0
        public unsafe FastBitmap Blur(double sigma, int weight)
        {
            Kernel kernel = Kernel.Gaussian(sigma, weight);

            FastBitmap result = new FastBitmap(
                this.Content.Width - kernel.Dimension + 1,
                this.Content.Height - kernel.Dimension + 1);

            int height = result.Content.Height;
            int width  = result.Content.Width;

            this.PerformLockingOperation((readData, readScan0) =>
            {
                result.PerformLockingOperation((writeData, writeScan0) =>
                {
                    for (int yPos = 0; yPos < height; yPos++)
                    {
                        for (int xPos = 0; xPos < width; xPos++)
                        {
                            double sumR = 0D;
                            double sumG = 0D;
                            double sumB = 0D;

                            byte *writingTo = PixelPointer(
                                writeScan0,
                                xPos,
                                yPos,
                                writeData.Stride,
                                bpp);

                            for (int yKernel = 0; yKernel < kernel.Dimension; yKernel++)
                            {
                                for (int xKernel = 0; xKernel < kernel.Dimension; xKernel++)
                                {
                                    double scalar = kernel[xKernel, yKernel];

                                    byte *readingFrom = PixelPointer(
                                        readScan0,
                                        xPos + xKernel,
                                        yPos + yKernel,
                                        readData.Stride,
                                        bpp);

                                    sumR += (*readingFrom * scalar);
                                    sumG += (*(readingFrom + 1) * scalar);
                                    sumB += (*(readingFrom + 2) * scalar);
                                }
                            }

                            *(writingTo + 0) = (byte)(sumR);
                            *(writingTo + 1) = (byte)(sumG);
                            *(writingTo + 2) = (byte)(sumB);
                            *(writingTo + 3) = *PixelPointer(readScan0, xPos, yPos, readData.Stride, bpp);
                        }
                    }
                });
            });

            return(result);
        }
Esempio n. 2
0
        public unsafe FastBitmap Grayscale()
        {
            int height = this.Content.Height;
            int width  = this.Content.Width;

            FastBitmap result = new FastBitmap(width, height);

            this.PerformLockingOperation((readData, readScan0) =>
            {
                result.PerformLockingOperation((writeData, writeScan0) =>
                {
                    for (int yPos = 0; yPos < height; yPos++)
                    {
                        for (int xPos = 0; xPos < width; xPos++)
                        {
                            byte *readingFrom = PixelPointer(
                                readScan0,
                                xPos,
                                yPos,
                                readData.Stride,
                                bpp);
                            byte *writingTo = PixelPointer(
                                writeScan0,
                                xPos,
                                yPos,
                                writeData.Stride,
                                bpp);

                            byte average     = (byte)((*(readingFrom) + *(readingFrom + 1) + *(readingFrom + 2)) / 3);
                            *writingTo       = average;
                            *(writingTo + 1) = average;
                            *(writingTo + 2) = average;
                            *(writingTo + 3) = 255;
                        }
                    }
                });
            });

            return(result);
        }
Esempio n. 3
0
 public static void PerformLockingOperation(this FastBitmap bitmap, FastBitmap.LockingDataOperation operation)
 {
     FastBitmap.PerformLockingOperation(bitmap.Content, operation);
 }