終於搞出來了：）

#include <iostream>
#include <opencv2/opencv.hpp>
#include <vector>
#include <algorithm>
using namespace cv;
using namespace std;
//下面的宏，定義了在矩陣src的第m行、n列，ks*ks覆蓋的矩形區域內的像素，並將像素壓到矢量v中
//該覆蓋區域的左上角坐標為（m，n），寬為ks，高為ks，要求src必須是單通道，數據類型為CV_8UC1
#define CV_ROI_ELEM(src,vector,m,n,ks)  \
    uchar
 
* kn;                             int st0=src.step[0];    int st1=src.step[1];    for(int k=0;k<(ks);k++)                {                                          for(int s=0;s<(ks);s++)                {                                          kn =src.data+(k+m)*st0+(s+n)*st1;               vector.push_back(
 
*kn);                               }                                               }                                               
#define CV_MAT_ELEM2(src,dtype,y,x) \
    (dtype*)(src.data+src.step[0]*(y)+src.step[1]*(x))
/*********************自適應中值濾波********************************/
void selfAdaptiveMedianBlur(Mat&src,Mat&dst,int
 
 kernal_size)
{
    uchar* pdst=dst.data;
    uchar Zmin,Zmax,Zmed,Zxy;
    int step0=src.step[0];
    int step1=src.step[1];
    for(int i=kernal_size/2;i<src.rows-kernal_size/2;i++)
    {
        for(int j=kernal_size/2;j<src.cols-kernal_size/2;j++)
        {
            int ks=3;//kernal_size;
            int count=0;
            Zxy=*CV_MAT_ELEM2(src,uchar,i,j);//Sxy覆蓋區域的中心點像素值，即錨點像素值
            vector<uchar> v;//將模板覆蓋區域的像素，壓入矢量v中
            do{
                if(cout==0)
                {//獲取模板ks*ks覆蓋區的像素，並壓入矢量v中
                    CV_ROI_ELEM(src,v,i-ks/2,j-ks/2,ks);
                }
               else
                {
               /********下面的for循環，將外擴的四個邊的像素添加到v中******************/
                    uchar* p=src.data+(i-ks/2)*step0+(j-ks/2)*step1;
                    for(int u=0;u<ks;u++)
                    {
                        v.push_back(*(p+u*step1));//向外擴展的四個邊的上邊
                        v.push_back(*(p+(ks-1)*step0+u*step1));//向外擴展的四個邊的下邊
                        if(u!=0&&u!=ks-1)
                        {
                          v.push_back( *(p+u*step0));//向外擴展的四個邊的左邊
                          v.push_back(*(p+u*step0+(ks-1)*step1));//向外擴展的四個邊的右邊
                        }
                    }
                }

                //對v的元素排序
                //排序後，Sxy覆蓋區域內，最大值為Zmax=v[v.size-1],最小值為Zmin=v[0]
                std::sort(v.begin(),v.end());
                Zmin=v[0],Zmax=v[v.size()-1],Zmed=v[ks*ks/2];
                pdst =CV_MAT_ELEM2(dst,uchar,i,j);
                if(Zmin<Zmed&&Zmed<Zmax)
                {
                    if(Zmin<Zxy&&Zxy<Zmax)
                    {*pdst=Zxy;break;}
                    else
                    {*pdst=Zmed;break;}
                }
                else
                {
                    ks +=2;
                }
                count++;
            }while(ks<=kernal_size);

            *pdst=Zmed;
        }
    }
}


int main()
{
    Mat src=imread("D:\\Qt\\MyImage\\Fig0335.tif",0);
    imshow("src image",src);

    Mat dst(src.rows,src.cols,src.type(),Scalar(0));
    selfAdaptiveMedianBlur(src,dst,7);

    imshow("adaptive median filter",dst);
    waitKey();
    return 0;
}

原圖像：

自適應中值濾波後的圖像：

基於Opencv的自適應中值濾波函數selfAdaptiveMedianBlur（）