[快速阅读九] 自适应中值滤波及保守滤波在去除椒盐噪音或脉冲噪音上的应用。

for (int j = maxSize / 2; j < im1.rows - maxSize / 2; j++)
    {
        for (int i = maxSize / 2; i < im1.cols * im1.channels() - maxSize / 2; i++)
        {
            im1.at<uchar>(j, i) = adaptiveProcess(im1, j, i, minSize, maxSize);
        }
    }

/// <summary>
/// 实现图像的自使用中值模糊。更新时间2015.3.11。
/// 参考：Adaptive Median Filtering Seminar Report By: PENG Lei (ID: 03090345)
/// </summary>
/// <param name="Src">需要处理的源图像的数据结构。</param>
/// <param name="Dest">保存处理后的图像的数据结构。</param>
/// <param name="Radius">滤波的半径，有效范围[1,127]。</param>
/// <remarks> 1: 能处理8位灰度和24位及32位图像。</remarks>
/// <remarks> 2: 半径大于10以后基本没区别了。</remarks>
int IM_AdaptiveMedianFilter(unsigned char* Src, unsigned char* Dest, int Width, int Height, int Stride, int MinRadius, int MaxRadius)
{
    int Channel = Stride / Width;
    if ((Src == NULL) || (Dest == NULL))                    return IM_STATUS_NULLREFRENCE;
    if ((Width <= 0) || (Height <= 0))                        return IM_STATUS_INVALIDPARAMETER;
    if ((MinRadius <= 0) || (MaxRadius <= 0))                return IM_STATUS_INVALIDPARAMETER;
    if ((Channel != 1) && (Channel != 3))                    return IM_STATUS_NOTSUPPORTED;
    int Status = IM_STATUS_OK;
    
    int Threshold = 10;
    if (MinRadius > MaxRadius)    IM_Swap(MinRadius, MaxRadius);

    bool AllProcessed = false;
    unsigned char* MinValue = (unsigned char*)malloc(Height * Stride * sizeof(unsigned char));
    unsigned char* MaxValue = (unsigned char*)malloc(Height * Stride * sizeof(unsigned char));
    unsigned char* MedianValue = (unsigned char*)malloc(Height * Stride * sizeof(unsigned char));
    unsigned char* Flag = (unsigned char*)malloc(Height * Width * sizeof(unsigned char));
    if ((MinValue == NULL) || (MaxValue == NULL) || (MedianValue == NULL) || (Flag == NULL))
    {
        Status = IM_STATUS_OUTOFMEMORY;
        goto FreeMemory;
    }
    memset(Flag, 0, Height * Width * sizeof(unsigned char));

    if (Channel == 1)
    {
        //    The median filter starts at size 3-by-3 and iterates up to size MaxRadius-by-MaxRadius
        for (int Z = MinRadius; Z <= MaxRadius; Z++)
        {
            Status = IM_MinFilter(Src, MinValue, Width, Height, Stride, Z);
            if (Status != IM_STATUS_OK)        goto FreeMemory;
            Status = IM_MaxFilter(Src, MaxValue, Width, Height, Stride, Z);
            if (Status != IM_STATUS_OK)        goto FreeMemory;        
            Status = IM_MedianBlur(Src, MedianValue, Width, Height, Stride, Z, 50);
            if (Status != IM_STATUS_OK)        goto FreeMemory;
        
            for (int Y = 0; Y < Height; Y++)
            {
                int Index = Y * Stride;
                int Pos = Y * Width;
                for (int X = 0; X < Width; X++, Index++, Pos++)
                {
                    if (Flag[Pos] == 0)
                    {
                        int Min = MinValue[Index], Max = MaxValue[Index], Median = MedianValue[Index];
                        if ((Median > Min + Threshold) && (Median < Max - Threshold))
                        {
                            int Value = Src[Index];
                            if ((Value > Min + Threshold) && (Value < Max- Threshold))
                            {
                                Dest[Index] = Value;
                            }
                            else
                            {
                                Dest[Index] = Median;
                            }
                            Flag[Pos] = 1;
                        }
                    }
                }
            }
            AllProcessed = true;
            for (int Y = 0; Y < Height; Y++)
            {
                int Pos = Y * Width;
                for (int X = 0; X < Width; X++)
                {
                    if (Flag[Pos + X] == 0)        //    检测是否每个点都已经处理好了
                    {
                        AllProcessed = false;
                        break;
                    }
                }
                if (AllProcessed == false) break;
            }
            if (AllProcessed == true) break;
        }

        /*    Output zmed for any remaining unprocessed pixels. Note that this
            zmed was computed using a window of size Smax-by-Smax, which is
            the final value of k in the loop.*/

        if (AllProcessed == false)
        {
            for (int Y = 0; Y < Height; Y++)
            {
                int Index = Y * Stride;
                int Pos = Y * Width;
                for (int X = 0; X < Width; X++)
                {
                    if (Flag[Pos + X] == 0)    Dest[Index + X] = Src[Index + X];
                }
            }
        }
    }
    else
    {

    }
FreeMemory:
    if (MinValue != NULL)        free(MinValue);
    if (MaxValue != NULL)        free(MaxValue);
    if (MedianValue != NULL)    free(MedianValue);
    if (Flag != NULL)            free(Flag);
    return Status;
}

　　　　for (int X = 0; X < Width * Channel; X++, LinePD++)
        {
            int P0 = First[X], P1 = First[X + Channel], P2 = First[X + 2 * Channel];
            int P3 = Second[X], P4 = Second[X + Channel], P5 = Second[X + 2 * Channel];
            int P6 = Third[X], P7 = Third[X + Channel], P8 = Third[X + 2 * Channel];

            int Max0 = IM_Max(P0, P1);
            int Min0 = IM_Min(P0, P1);

            int Max1 = IM_Max(P2, P3);
            int Min1 = IM_Min(P2, P3);

            int Max2 = IM_Max(P5, P6);
            int Min2 = IM_Min(P5, P6);

            int Max3 = IM_Max(P7, P8);
            int Min3 = IM_Min(P7, P8);

            int Max = IM_Max(IM_Max(Max0, Max1), IM_Max(Max2, Max3));
            int Min = IM_Min(IM_Min(Min0, Min1), IM_Min(Min2, Min3));

            if (P4 > Max)
                P4 = Max;
            else if (P4 < Min)
                P4 = Min;
            LinePD[0] = P4;
        }