java图像处理实例.docx

java图像处理实例.docx

《java图像处理实例.docx》由会员分享，可在线阅读，更多相关《java图像处理实例.docx（13页珍藏版）》请在冰豆网上搜索。

java图像处理实例

一读取bmp图片数据

// 获取待检测图像 ，数据保存在数组nData[]，nB[] ，nG[] ，nR[]中

 public voidgetBMPImage（Stringsource）throwsException{

        clearNData（）;                       //清除数据保存区

        FileInputStreamfs=null;

       try{

           fs=newFileInputStream（source）;

           intbfLen=14;

           bytebf[]=newbyte[bfLen];

           fs.read（bf,0,bfLen）;//读取14字节BMP文件头

           intbiLen=40;

           bytebi[]=newbyte[biLen];

           fs.read（bi,0,biLen）;//读取40字节BMP信息头

           //源图宽度

           nWidth=（（（int）bi[7]&0xff）<<24）

                   |（（（int）bi[6]&0xff）<<16）

                   |（（（int）bi[5]&0xff）<<8）|（int）bi[4]&0xff;

           //源图高度

           nHeight=（（（int）bi[11]&0xff）<<24）

                   |（（（int）bi[10]&0xff）<<16）

                   |（（（int）bi[9]&0xff）<<8）|（int）bi[8]&0xff;

           //位数

           nBitCount=（（（int）bi[15]&0xff）<<8）|（int）bi[14]&0xff;

           //源图大小

           intnSizeImage=（（（int）bi[23]&0xff）<<24）

                   |（（（int）bi[22]&0xff）<<16）

                   |（（（int）bi[21]&0xff）<<8）|（int）bi[20]&0xff;

           //对24位BMP进行解析

           if（nBitCount==24）{

               intnPad=（nSizeImage/nHeight）-nWidth*3;

               nData=newint[nHeight*nWidth];

               nB=newint[nHeight*nWidth];

               nR=newint[nHeight*nWidth];

               nG=newint[nHeight*nWidth];

               bytebRGB[]=newbyte[（nWidth+nPad）*3*nHeight];

               fs.read（bRGB,0,（nWidth+nPad）*3*nHeight）;

               intnIndex=0;

               for（intj=0;j

                   for（inti=0;i

                       nData[nWidth*（nHeight-j-1）+i]=（255&0xff）<<24

                               |（（（int）bRGB[nIndex+2]&0xff）<<16）

                                |（（（int）bRGB[nIndex+1]&0xff）<<8）

                               |（int）bRGB[nIndex]&0xff;                     

                       nB[nWidth*（nHeight-j-1）+i]=（int）bRGB[nIndex]&0xff;

                       nG[nWidth*（nHeight-j-1）+i]=（int）bRGB[nIndex+1]&0xff;

                       nR[nWidth*（nHeight-j-1）+i]=（int）bRGB[nIndex+2]&0xff;

                       nIndex+=3;

                   }

                   nIndex+=nPad;

               }

 //              Toolkitkit=Toolkit.getDefaultToolkit（）;

 //              image=kit.createImage（newMemoryImageSource（nWidth,nHeight,

 //                      nData,0,nWidth））;

/*              

//调试数据的读取

               FileWriterfw=newFileWriter（"C:

//DocumentsandSettings//Administrator//MyDocuments//nDataRaw.txt"）;//创建新文件

               PrintWriterout=newPrintWriter（fw）;

               for（intj=0;j

                for（inti=0;i

                 out.print（（65536*256+nData[nWidth*（nHeight-j-1）+i]）+"_"

                   +nR[nWidth*（nHeight-j-1）+i]+"_"

                   +nG[nWidth*（nHeight-j-1）+i]+"_"

                   +nB[nWidth*（nHeight-j-1）+i]+""）;

                }

                out.println（""）;

               }

               out.close（）;

*/         

           }

       }

       catch（Exceptione）{

           e.printStackTrace（）;

           thrownewException（e）;

       }

       finally{

           if（fs!

=null）{

               fs.close（）;

           }

       }

    //  returnimage;

   }

二 由rgb获取灰度数组

   public int[]getBrightnessData（intrData[],intgData[],intbData[]）{

    intbrightnessData[]=newint[rData.length];

    if（rData.length!

=gData.length||rData.length!

=bData.length

      ||bData.length!

=gData.length）{

     returnbrightnessData;

    }

    else{

     for（inti=0;i

      doubletemp=0.3*rData[i]+0.59*gData[i]+0.11*bData[i];

      brightnessData[i]=（int）（temp）+（（temp-（int）（temp））>0.5?

1:

0）;

     }

     returnbrightnessData;

    }

   }

三直方图均衡化

   publicint[]equilibrateGray（int[]PixelsGray,intwidth,intheight）

   {        

        intgray;

        intlength=PixelsGray.length;

        intFrequenceGray[]=newint[length];

        intSumGray[]=newint[256];

        intImageDestination[]=newint[length];

        for（inti=0;i

       {

         gray=PixelsGray[i];

             FrequenceGray[gray]++;

       }

         //   灰度均衡化

        SumGray[0]=FrequenceGray[0];

        for（inti=1;i<256;i++）{

              SumGray[i]=SumGray[i-1]+FrequenceGray[i]; 

        }

        for（inti=0;i<256;i++）{

              SumGray[i]=（int）（SumGray[i]*255/length）; 

        }