java數字圖像處理常用算法

     前些時候做畢業設計用java做的數字圖像處理方面的東西這方面的資料ms比較少發點東西上來大家共享一下主要就是些算法有自己寫的有人家的還有改人家的有的算法寫的不好大家不要見笑

　　一 讀取bmp圖片數據

　　

　　//  獲取待檢測圖像 數據保存在數組 nData[]nB[] nG[] nR[]中

　　public  void getBMPImage(String source) throws Exception {
          
         clearNData();                        //清除數據保存區
         FileInputStream fs = null;
       
        try {
            fs = new FileInputStream(source);
            int bfLen = ;
            byte bf[] = new byte[bfLen];
            fsread(bf bfLen); // 讀取字節BMP文件頭
            int biLen = ;
            byte bi[] = new byte[biLen];
            fsread(bi biLen); // 讀取字節BMP信息頭

　　// 源圖寬度
            nWidth = (((int) bi[] & xff) << )
                    | (((int) bi[] & xff) << )
                    | (((int) bi[] & xff) << ) | (int) bi[] & xff;

　　// 源圖高度
            nHeight = (((int) bi[] & xff) << )
                    | (((int) bi[] & xff) << )
                    | (((int) bi[] & xff) << ) | (int) bi[] & xff;

　　// 位數
            nBitCount = (((int) bi[] & xff) << ) | (int) bi[] & xff;

　　// 源圖大小
            int nSizeImage = (((int) bi[] & xff) << )
                    | (((int) bi[] & xff) << )
                    | (((int) bi[] & xff) << ) | (int) bi[] & xff;

　　// 對位BMP進行解析
            if (nBitCount == ){
                int nPad = (nSizeImage / nHeight) nWidth * ;
                nData = new int[nHeight * nWidth];
                nB=new int[nHeight * nWidth];
                nR=new int[nHeight * nWidth];
                nG=new int[nHeight * nWidth];
                byte bRGB[] = new byte[(nWidth + nPad) * * nHeight];
                fsread(bRGB (nWidth + nPad) * * nHeight);
                int nIndex = ;
                for (int j = ; j < nHeight; j++){
                    for (int i = ; i < nWidth; i++) {
                        nData[nWidth * (nHeight j ) + i] = ( & xff) <<
                                | (((int) bRGB[nIndex + ] & xff) << )
                                 | (((int) bRGB[nIndex + ] & xff) << )
                                | (int) bRGB[nIndex] & xff;                     
                        nB[nWidth * (nHeight j ) + i]=(int) bRGB[nIndex]& xff;
                        nG[nWidth * (nHeight j ) + i]=(int) bRGB[nIndex+]& xff;
                        nR[nWidth * (nHeight j ) + i]=(int) bRGB[nIndex+]& xff;
                        nIndex += ;
                    }
                    nIndex += nPad;
                }
 //               Toolkit kit = ToolkitgetDefaultToolkit();
 //               image = kitcreateImage(new MemoryImageSource(nWidth nHeight
 //                       nData nWidth));

　　/*              
//調試數據的讀取

　　FileWriter fw = new FileWriter(C:\\Documents and Settings\\Administrator\\My Documents\\nDataRawtxt);//創建新文件
                PrintWriter out = new PrintWriter(fw);
                for(int j=;j<nHeight;j++){
                 for(int i=;i<nWidth;i++){
                  outprint((*+nData[nWidth * (nHeight j ) + i])+_
                    +nR[nWidth * (nHeight j ) + i]+_
                    +nG[nWidth * (nHeight j ) + i]+_
                    +nB[nWidth * (nHeight j ) + i]+ );
                  
                 }
                 outprintln();
                }
                outclose();
*/         
            }
        }
        catch (Exception e) {
            eprintStackTrace();
            throw new Exception(e);
        }
        finally {
            if (fs != null) {
                fsclose();
            }
        }
     //   return image;
    } 

　　 

　　二 由r g b 獲取灰度數組

　　     public  int[] getBrightnessData(int rData[]int gData[]int bData[]){
     
     int brightnessData[]=new int[rDatalength];
     if(rDatalength!=gDatalength || rDatalength!=bDatalength
       || bDatalength!=gDatalength){
      return brightnessData;
     }
     else {
      for(int i=;i<bDatalength;i++){
       double temp=*rData[i]+*gData[i]+*bData[i];
       brightnessData[i]=(int)(temp)+((temp(int)(temp))>?:);
      }
      return brightnessData;
     }
     
    } 

　　三 直方圖均衡化

　　     public int [] equilibrateGray(int[] PixelsGrayint widthint height)
    {         
         int gray;
         int length=PixelsGraylength;
         int FrequenceGray[]=new int[length];
         int SumGray[]=new int[];
         int ImageDestination[]=new int[length];
         for(int i = ; i <length ;i++)
        {
           gray=PixelsGray[i];
              FrequenceGray[gray]++;
        }
          //    灰度均衡化
         SumGray[]=FrequenceGray[];
         for(int i=;i<;i++){
               SumGray[i]=SumGray[i]+FrequenceGray[i]; 
         }
         for(int i=;i<;i++) {
               SumGray[i]=(int)(SumGray[i]*/length); 
         }
         for(int i=;i<height;i++)
         {
               for(int j=;j<width;j++)
              {
                  int k=i*width+j;
                  ImageDestination[k]=xFF | ((SumGray[PixelsGray[k]]<<
                            ) | (SumGray[PixelsGray[k]]<< ) | SumGray[PixelsGray[k]]);
               }
          }
         return ImageDestination;
      } 

　　四 laplace階濾波增強邊緣圖像銳化

　　     public int[] laplaceDFileter(int []dataint widthint height){
   
     int filterData[]=new int[datalength];
     int min=;
     int max=;
     for(int i=;i<height;i++){
      for(int j=;j<width;j++){
       if(i== || i==height || j== || j==width)
               filterData[i*width+j]=data[i*width+j];
       else
        filterData[i*width+j]=*data[i*width+j]data[i*width+j]data[i*width+j+]
                             data[(i)*width+j]data[(i)*width+j]data[(i)*width+j+]
                             data[(i+)*width+j]data[(i+)*width+j]data[(i+)*width+j+];       
       if(filterData[i*width+j]<min)
        min=filterData[i*width+j];
       if(filterData[i*width+j]>max)
        max=filterData[i*width+j];
      }  
     }
//     Systemoutprintln(max: +max);
//     Systemoutprintln(min: +min);
     
     for(int i=;i<width*height;i++){
      filterData[i]=(filterData[i]min)*/(maxmin);
     }
     return filterData;
    } 

　　 

　　五 laplace階增強濾波增強邊緣增強系數delt

　　     public int[] laplaceHighDFileter(int []dataint widthint heightdouble delt){
     
     int filterData[]=new int[datalength];
     int min=;
     int max=;
     for(int i=;i<height;i++){
      for(int j=;j<width;j++){
       if(i== || i==height || j== || j==width)
               filterData[i*width+j]=(int)((+delt)*data[i*width+j]);
       else
        filterData[i*width+j]=(int)((+delt)*data[i*width+j]data[i*width+j])data[i*width+j+]
                             data[(i)*width+j]data[(i)*width+j]data[(i)*width+j+]
                             data[(i+)*width+j]data[(i+)*width+j]data[(i+)*width+j+];       
       if(filterData[i*width+j]<min)
        min=filterData[i*width+j];
       if(filterData[i*width+j]>max)
        max=filterData[i*width+j];
      }  
     }
     for(int i=;i<width*height;i++){
      filterData[i]=(filterData[i]min)*/(maxmin);
     }
     return filterData;
    } 
六 局部阈值處理值化

　　     //   局部阈值處理值化niblacks   method
    /*原理  
         T(xy)=m(xy)   +   k*s(xy)  
         取一個寬度為w的矩形框(xy)為這個框的中心
         統計框內數據T(xy)為阈值m(xy)為均值s(xy)為均方差k為參數(推薦)計算出t再對(xy)進行切割/  
         這個算法的優點是     速度快效果好  
         缺點是     niblacks   method會產生一定的噪聲 
     */
   
    public int[] localThresholdProcess(int []dataint widthint heightint wint hdouble coefficientsdouble gate){
     int[] processData=new int[datalength];
     for(int i=;i<datalength;i++){
      processData[i]=;
     }
     
     if(datalength!=width*height)
      return processData;
     
     int wNum=width/w;
     int hNum=height/h;
     int delt[]=new int[w*h];
     
     //Systemoutprintln(w; +w+  h:+h+  wNum:+wNum+ hNum:+hNum);
     
     for(int j=;j<hNum;j++){
      for(int i=;i<wNum;i++){
     //for(int j=;j<;j++){
     // for(int i=;i<;i++){ 
        for(int n=;n<h;n++)
               for(int k=;k<w;k++){
                delt[n*w+k]=data[(j*h+n)*width+i*w+k];
                //Systemoutprint(delt[+(n*w+k)+]: +delt[n*w+k]+ );
               }
        //Systemoutprintln();
        /*
        for(int n=;n<h;n++)
               for(int k=;k<w;k++){
                Systemoutprint(data[+((j*h+n)*width+i*w+k)+]: +data[(j*h+n)*width+i*w+k]+ );
               }
        Systemoutprintln();
        */
        delt=thresholdProcess(deltwhcoefficientsgate);
        for(int n=;n<h;n++)
               for(int k=;k<w;k++){
                processData[(j*h+n)*width+i*w+k]=delt[n*w+k];
               // Systemoutprint(delt[+(n*w+k)+]: +delt[n*w+k]+ );
               }
        //Systemoutprintln();
        /*
        for(int n=;n<h;n++)
               for(int k=;k<w;k++){
                Systemoutprint(processData[+((j*h+n)*width+i*w+k)+]: +processData[(j*h+n)*width+i*w+k]+ );
               }
        Systemoutprintln();
        */
      }
     }
     
     return processData;
    } 

　　七 全局阈值處理值化

　　     public int[] thresholdProcess(int []dataint widthint heightdouble coefficientsdouble gate){
     int [] processData=new int[datalength];
     if(datalength!=width*height)
      return processData;
     else{
      double sum=;
      double average=;
      double variance=;
      double threshold;
      
      if( gate!=){
       threshold=gate; 
      }
      else{
            for(int i=;i<width*height;i++){
            sum+=data[i];
            }
            average=sum/(width*height);
      
            for(int i=;i<width*height;i++){
              variance+=(data[i]average)*(data[i]average);
            }
            variance=Mathsqrt(variance);
            threshold=averagecoefficients*variance;
      }
      
         for(int i=;i<width*height;i++){
          if(data[i]>threshold)
             processData[i]=;
          else
                processData[i]=;
         }
      
         return processData;
       }
    } 

　　 

　　八  垂直邊緣檢測sobel算子

　　     public int[] verticleEdgeCheck(int []dataint widthint heightint sobelCoefficients) throws Exception{
     int filterData[]=new int[datalength];
     int min=;
     int max=;
     if(datalength!=width*height)
      return filterData;
     
     try{
     
       for(int i=;i<height;i++){
       for(int j=;j<width;j++){
        if(i== || i== || i==height || i==height
           ||j== || j== || j==width || j==width){
               filterData[i*width+j]=data[i*width+j];
         }
         else{
          double average;
            //中心的九個像素點
             //average=data[i*width+j]Mathsqrt()*data[i*width+j]+Mathsqrt()*data[i*width+j+]
          average=data[i*width+j]sobelCoefficients*data[i*width+j]+sobelCoefficients*data[i*width+j+]      
                  data[(i)*width+j]+data[(i)*width+j+]
                     data[(i+)*width+j]+data[(i+)*width+j+];
             filterData[i*width+j]=(int)(average);
         }      
        if(filterData[i*width+j]<min)
         min=filterData[i*width+j];
         if(filterData[i*width+j]>max)
         max=filterData[i*width+j];
        }
        }
       for(int i=;i<width*height;i++){
        filterData[i]=(filterData[i]min)*/(maxmin);
         }
     
     }
     catch (Exception e)
     {
            eprintStackTrace();
            throw new Exception(e);
        } 
     
     return filterData;
    } 

　　九  圖像平滑*掩模處理（平均處理）降低噪聲   

　　     public int[] filter(int []dataint widthint height) throws Exception{
     
     int filterData[]=new int[datalength];
     int min=;
     int max=;
     if(datalength!=width*height)
      return filterData;
     
     try{
     
       for(int i=;i<height;i++){
       for(int j=;j<width;j++){
        if(i== || i== || i==height || i==height
           ||j== || j== || j==width || j==width){
               filterData[i*width+j]=data[i*width+j];
         }
         else{
          double average;
            //中心的九個像素點
             average=(data[i*width+j]+data[i*width+j]+data[i*width+j+]
                     +data[(i)*width+j]+data[(i)*width+j]+data[(i)*width+j+]
                     +data[(i+)*width+j]+data[(i+)*width+j]+data[(i+)*width+j+])/;
             filterData[i*width+j]=(int)(average);
         }      
        if(filterData[i*width+j]<min)
         min=filterData[i*width+j];
         if(filterData[i*width+j]>max)
         max=filterData[i*width+j];
        }
        }
       for(int i=;i<width*height;i++){
        filterData[i]=(filterData[i]min)*/(maxmin);
         }
     
     }
     catch (Exception e)
     {
            eprintStackTrace();
            throw new Exception(e);
        } 
     
     return filterData;
    } 

From:http://tw.wingwit.com/Article/program/Java/hx/201311/26286.html