AForge.Imaging.Filters.ThresholdedEuclideanDifference.ProcessFilter C# (CSharp) Метод

        protected override unsafe void ProcessFilter( UnmanagedImage sourceData, UnmanagedImage overlay, UnmanagedImage destinationData )
        {
            whitePixelsCount = 0;

            // get source image size
            int width  = sourceData.Width;
            int height = sourceData.Height;
            int pixelSize = Bitmap.GetPixelFormatSize( sourceData.PixelFormat ) / 8;

            byte* src = (byte*) sourceData.ImageData.ToPointer( );
            byte* ovr = (byte*) overlay.ImageData.ToPointer( );
            byte* dst = (byte*) destinationData.ImageData.ToPointer( );

            if ( pixelSize == 1 )
            {
                // grayscale image
                int srcOffset = sourceData.Stride - width;
                int ovrOffset = overlay.Stride - width;
                int dstOffset = destinationData.Stride - width;

                // for each line
                for ( int y = 0; y < height; y++ )
                {
                    // for each pixel
                    for ( int x = 0; x < width; x++, src++, ovr++, dst++ )
                    {
                        int diff = *src - *ovr;

                        if ( diff < 0 )
                            diff = -diff;

                        if ( diff > threshold )
                        {
                            *dst = (byte) 255;
                            whitePixelsCount++;
                        }
                        else
                        {
                            *dst = 0;
                        }
                    }
                    src += srcOffset;
                    ovr += ovrOffset;
                    dst += dstOffset;
                }
            }
            else
            {
                // color image
                int srcOffset = sourceData.Stride - pixelSize * width;
                int ovrOffset = overlay.Stride - pixelSize * width;
                int dstOffset = destinationData.Stride - width;

                int squaredThreshold = threshold * threshold;

                // for each line
                for ( int y = 0; y < height; y++ )
                {
                    // for each pixel
                    for ( int x = 0; x < width; x++, src += pixelSize, ovr += pixelSize, dst++ )
                    {
                        int diffR = src[RGB.R] - ovr[RGB.R];
                        int diffG = src[RGB.G] - ovr[RGB.G];
                        int diffB = src[RGB.B] - ovr[RGB.B];

                        if ( diffR * diffR + diffG * diffG + diffB * diffB > squaredThreshold )
                        {
                            *dst = (byte) 255;
                            whitePixelsCount++;
                        }
                        else
                        {
                            *dst = 0;
                        }
                    }
                    src += srcOffset;
                    ovr += ovrOffset;
                    dst += dstOffset;
                }
            }
        }
    }