此文件中,主要有图片,以及数字图像处理的源代码,及实验

  函数名称：  
 *      MedianFilter()  
 *  
 *  参数:  
 *      LPSTR  lpDIBBits                        -  指向源DIB图像指针  
 *      LONG    lWidth                                    -  源图像宽度（象素数）  
 *      LONG    lHeight                                    -  源图像高度（象素数）  
 *      int      iFilterH                                    -  滤波器的高度  
 *      int      iFilterW                                    -  滤波器的宽度  
 *      int      iFilterMX                        -  滤波器的中心元素X坐标  
 *      int      iFilterMY                        -  滤波器的中心元素Y坐标  
 *  
 *  返回值:  
 *      BOOL                                                            -  成功返回TRUE，否则返回FALSE。  
 *  
 *  说明:  
 *      该函数对DIB图像进行中值滤波。  
 *  
 ************************************************************************/  
 
BOOL  WINAPI  MedianFilter(LPSTR  lpDIBBits,  LONG  lWidth,  LONG  lHeight,    
                                                                         int  iFilterH,  int  iFilterW,    
                                                                         int  iFilterMX,  int  iFilterMY)  
{  
             
           //  指向源图像的指针  
           unsigned  char*            lpSrc;  
             
           //  指向要复制区域的指针  
           unsigned  char*            lpDst;  
             
           //  指向复制图像的指针  
           LPSTR                                    lpNewDIBBits;  
           HLOCAL                                    hNewDIBBits;  
             
           //  指向滤波器数组的指针  
           unsigned  char            *  avalue;  
           HLOCAL                                    hArray;  
             
           //  循环变量  
           LONG                                    i;  
           LONG                                    j;  
           LONG                                   
 LONG                                    l;  
             
           //  图像每行的字节数  
           LONG                                    lLineBytes;  
             
           //  计算图像每行的字节数  
           lLineBytes  =  WIDTHBYTES(lWidth  *  8);  
             
           //  暂时分配内存，以保存新图像  
           hNewDIBBits  =  LocalAlloc(LHND,  lLineBytes  *  lHeight);  
             
           //  判断是否内存分配失败  
           if  (hNewDIBBits  ==  NULL)  
           {  
                       //  分配内存失败  
                       return  FALSE;  
           }  
             
           //  锁定内存  
           lpNewDIBBits  =  (char  *  )LocalLock(hNewDIBBits);  
             
           //  初始化图像为原始图像  
           memcpy(lpNewDIBBits,  lpDIBBits,  lLineBytes  *  lHeight);  
             
           //  暂时分配内存，以保存滤波器数组  
           hArray  =  LocalAlloc(LHND,  iFilterH  *  iFilterW);  
             
           //  判断是否内存分配失败  
           if  (hArray  ==  NULL)  
           {  
                       //  释放内存  
                       LocalUnlock(hNewDIBBits);  
                       LocalFree(hNewDIBBits);  
                         
                       //  分配内存失败  
                       return  FALSE;  
           }  
             
           //  锁定内存  
           avalue  =  (unsigned  char  *  )LocalLock(hArray);  
             
           //  开始中值滤波  
           //  行(除去边缘几行)  
           for(i  =  iFilterMY;  i  <  lHeight  -  iFilterH  +  iFilterMY  +  1;  i++)  
           {  
                       //  列(除去边缘几列)  
                       for(j  =  iFilterMX;  j  <  lWidth  -  iFilterW  +  iFilterMX  +  1;  j++)  
                       {  
                                   //  指向新DIB第i行，第j个象素的指针  
                                   lpDst  =  (unsigned  char*)
                              for  (k  =  0;  k  <  iFilterH;  k++)  
                                   {  
                                               for  (l  =  0;  l  <  iFilterW;  l++)  
                                               {  
                                                           //  指向DIB第i  -  iFilterMY  +  k行，第j  -  iFilterMX  +  l个象素的指针  
                                                           lpSrc  =  (unsigned  char*)lpDIBBits  +  lLineBytes  *  (lHeight  -  1  -  i  +  iFilterMY  -  k)  +  j  -  iFilterMX  +  l;  
                                                             
                                                           //  保存象素值  
                                                           avalue[k  *  iFilterW  +  l]  =  *lpSrc;  
                                               }  
                                   }  
                                     
                                   //  获取中值  
                                   *  lpDst  =  GetMedianNum(avalue,  iFilterH  *  iFilterW);  
                       }  
           }  
             
           //  复制变换后的图像  
           memcpy(lpDIBBits,  lpNewDIBBits,  lLineBytes  *  lHeight);  
             
           //  释放内存  
           LocalUnlock(hNewDIBBits);  
           LocalFree(hNewDIBBits);  
           LocalUnlock(hArray);  
           LocalFree(hArray);  
             
           //  返回  
           return  TRUE;  
}  
 
/*************************************************************************  
 *  
 *  函数名称：  
 *      GetMedianNum()  
 *  
 *  参数:  
 *      unsigned  char  *  bpArray            -  指向要获取中值的数组指针  
 *      int      iFilterLen                                    -  数组长度  
 *  
 *  返回值:  
 *      unsigned  char            -  返回指定数组的中值。  
 *  
 *  说明:  
 *      该函数用冒泡法对一维数组进行排序，并返回数组元素的中值。  
 *  
 *************************************************************
unsigned  char  WINAPI  GetMedianNum(unsigned  char  *  bArray,  int  iFilterLen)  
{  
           //  循环变量  
           int                        i;  
           int                        j;  
             
           //  中间变量  
           unsigned  char  bTemp;  
             
           //  用冒泡法对数组进行排序  
           for  (j  =  0;  j  <  iFilterLen  -  1;  j  ++)  
           {  
                       for  (i  =  0;  i  <  iFilterLen  -  j  -  1;  i  ++)  
                       {  
                                   if  (bArray[i]  >  bArray[i  +  1])  
                                   {  
                                               //  互换  
                                               bTemp  =  bArray[i];  
                                               bArray[i]  =  bArray[i  +  1];  
                                               bArray[i  +  1]  =  bTemp;  
                                   }  
                       }  
           }  
             
           //  计算中值  
           if  ((iFilterLen  &  1)  >  0)  
           {  
                       //  数组有奇数个元素，返回中间一个元素  
                       bTemp  =  bArray[(iFilterLen  +  1)  /  2];  
           }  
           else  
           {  
                       //  数组有偶数个元素，返回中间两个元素平均值  
                       bTemp  =  (bArray[iFilterLen  /  2]  +  bArray[iFilterLen  /  2  +  1])  /  2;  
           }  
             
           //  返回中值  
           return  bTemp;  
}