Пример #1
0
        // Додавање тежина на распределените пиксели за да добиеме резултат на замаглена позадина
        public static bool gaussianBlur(Bitmap b, int nWeight)
        {
            ConversionMatrix m = new ConversionMatrix();

            m.SetAll(1);
            m.Pixel  = nWeight;
            m.TopMid = m.MidLeft = m.MidRight = m.BottomMid = 2;
            m.Factor = nWeight + 12;

            return(BitmapFilter.conversionMatrix3x3(b, m));
        }
Пример #2
0
        private static bool conversionMatrix3x3(Bitmap b, ConversionMatrix m)
        {
            // Да се избегне делење со нула,
            // бидејќи матрицата на почетокот има нули
            if (0 == m.Factor)
            {
                return(false);
            }

            // Дуплицирање на изворот којшто ќе се замаглува / на којшто ќе му се примени филтерот
            Bitmap bSrc = (Bitmap)b.Clone();

            // Вратената  слика(Bitmap) е во облик BGR, а не RGB
            BitmapData bmData = b.LockBits(new Rectangle(0, 0, b.Width, b.Height), ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb);
            BitmapData bmSrc  = bSrc.LockBits(new Rectangle(0, 0, bSrc.Width, bSrc.Height), ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb);

            int stride  = bmData.Stride;
            int stride2 = stride * 2;

            System.IntPtr Scan0    = bmData.Scan0;
            System.IntPtr SrcScan0 = bmSrc.Scan0;

            // Распределување на тежината на централниот пиксел од матрицата на околните пиксели
            // споменато во ConversionMatrix
            unsafe
            {
                byte *p    = (byte *)(void *)Scan0;
                byte *pSrc = (byte *)(void *)SrcScan0;

                int nOffset = stride + 6 - b.Width * 3;
                int nWidth  = b.Width - 2;
                int nHeight = b.Height - 2;

                int nPixel;

                // Изминување на матрицата т.е. пикселите на Bitmap-от или таргет сликата
                // по височина и широчина
                for (int y = 0; y < nHeight; ++y)
                {
                    for (int x = 0; x < nWidth; ++x)
                    {
                        nPixel = ((((pSrc[2] * m.TopLeft) + (pSrc[5] * m.TopMid) + (pSrc[8] * m.TopRight) +
                                    (pSrc[2 + stride] * m.MidLeft) + (pSrc[5 + stride] * m.Pixel) + (pSrc[8 + stride] * m.MidRight) +
                                    (pSrc[2 + stride2] * m.BottomLeft) + (pSrc[5 + stride2] * m.BottomMid) + (pSrc[8 + stride2] * m.BottomRight)) / m.Factor) + m.Offset);

                        if (nPixel < 0)
                        {
                            nPixel = 0;
                        }
                        if (nPixel > 255)
                        {
                            nPixel = 255;
                        }

                        p[5 + stride] = (byte)nPixel;

                        nPixel = ((((pSrc[1] * m.TopLeft) + (pSrc[4] * m.TopMid) + (pSrc[7] * m.TopRight) +
                                    (pSrc[1 + stride] * m.MidLeft) + (pSrc[4 + stride] * m.Pixel) + (pSrc[7 + stride] * m.MidRight) +
                                    (pSrc[1 + stride2] * m.BottomLeft) + (pSrc[4 + stride2] * m.BottomMid) + (pSrc[7 + stride2] * m.BottomRight)) / m.Factor) + m.Offset);

                        if (nPixel < 0)
                        {
                            nPixel = 0;
                        }
                        if (nPixel > 255)
                        {
                            nPixel = 255;
                        }

                        p[4 + stride] = (byte)nPixel;

                        nPixel = ((((pSrc[0] * m.TopLeft) + (pSrc[3] * m.TopMid) + (pSrc[6] * m.TopRight) +
                                    (pSrc[0 + stride] * m.MidLeft) + (pSrc[3 + stride] * m.Pixel) + (pSrc[6 + stride] * m.MidRight) +
                                    (pSrc[0 + stride2] * m.BottomLeft) + (pSrc[3 + stride2] * m.BottomMid) + (pSrc[6 + stride2] * m.BottomRight)) / m.Factor) + m.Offset);

                        if (nPixel < 0)
                        {
                            nPixel = 0;
                        }
                        if (nPixel > 255)
                        {
                            nPixel = 255;
                        }

                        p[3 + stride] = (byte)nPixel;

                        p    += 3;
                        pSrc += 3;
                    }

                    p    += nOffset;
                    pSrc += nOffset;
                }
            }

            b.UnlockBits(bmData);
            bSrc.UnlockBits(bmSrc);

            return(true);
        }