java实现图像的直方图均衡以及灰度线性变化，灰度拉伸

写了四个方法，分别实现图片的灰度化，直方图均衡，灰度线性变化，灰度拉伸，其中好多地方特别是灰度拉伸这一块觉得自己实现的有问题，请大大们多多指教。

 import java.awt.Image;
 import java.awt.image.BufferedImage;
 import java.awt.image.PixelGrabber;
 import java.io.File;
 import java.io.IOException;
 import java.util.Iterator;
 import java.util.Scanner;

 import javax.imageio.ImageIO;
 import javax.imageio.ImageReader;
 import javax.imageio.stream.ImageInputStream;
 import javax.swing.filechooser.FileNameExtensionFilter;

 public class ImageProcessing {

     /**
      * @param args
      */

     static Image tmp;
     static int iwidth,iheight;//图像宽度，高度
     static double ma,mi;//线性变化灰度上下限
     static int[] pixels;//图像所有像素点
     static int[] pixels2;//备份pixels，用于灰度线性变化
     static int[] pixels3;//备份pixels，用于灰度拉伸
     static int[] histogram=new int[256];
     static String filename=null,directory=null,fileFormat=null;//要变换的图像路径名+文件名
     public static void main(String[] args) throws IOException, InterruptedException {
         // TODO Auto-generated method stub
         System.out.println("请输入文件路径");
         Scanner in=new Scanner(System.in);
         directory=in.next();//读入文件路径
         System.out.println("请输入文件名");
         filename=in.next();//读入文件名
         System.out.println("请输入文件格式");
         fileFormat=in.next();//读入文件格式
         grayImage();//灰度化
         histogramEqualization();//均衡化并输出
         System.out.println("请输入线性变换的灰度下限");
         mi=in.nextInt();
         System.out.println("请输入线性变换的灰度上限");
         ma=in.nextInt();
         linearConversion();
         grayStretch();
     }

     //灰度化
     public static void grayImage() throws IOException, InterruptedException
     {
         File input=new File(directory+"\\"+filename+"."+fileFormat);
         BufferedImage reader=ImageIO.read(input);//图片文件读入流

         iwidth=reader.getWidth();
         iheight=reader.getHeight();
         pixels=new int[iwidth*iheight];
         pixels2=new int[iwidth*iheight];
         pixels3=new int[iwidth*iheight];

         BufferedImage grayImage=new BufferedImage(iwidth,iheight,BufferedImage.TYPE_BYTE_GRAY);//无符号 byte 灰度级图像
         for(int i=0;i<iwidth;i++)
             for(int j=0;j<iheight;j++)
             {
                 int rgb=reader.getRGB(i, j);
                 int grey=(int) ((0.3*((rgb&0xff0000)>>16)+0.59*((rgb&0xff00)>>8))+0.11*((rgb&0xff)));
                 rgb=255<<24|grey<<16|grey<<8|grey;
                 grayImage.setRGB(i, j, rgb);
             }//读入所有像素，转换图像信号,使其灰度化
         tmp=grayImage;
         PixelGrabber pg=new PixelGrabber(tmp, 0, 0, iwidth, iheight, pixels,0,iwidth);
         pg.grabPixels();//将该灰度化后的图片所有像素点读入pixels数组
         PixelGrabber pg2=new PixelGrabber(tmp, 0, 0, iwidth, iheight, pixels2,0,iwidth);
         pg2.grabPixels();
         PixelGrabber pg3=new PixelGrabber(tmp, 0, 0, iwidth, iheight, pixels3,0,iwidth);
         pg3.grabPixels();//
     }

     //直方图均衡
     public static void histogramEqualization() throws InterruptedException, IOException
     {
         //PixelGrabber pg=new PixelGrabber(tmp, 0, 0, iwidth, iheight, pixels,0,iwidth);
         //pg.grabPixels();
         BufferedImage greyImage=new BufferedImage(iwidth, iheight, BufferedImage.TYPE_BYTE_GRAY);

         for(int i=0;i<iheight-1;i++)
             for(int j=0;j<iwidth-1;j++)
             {
                 int grey=pixels[i*iwidth+j]&0xff;
                 histogram[grey]++;
             }//计算每一个灰度级的像素数
         double a=(double)255/(iwidth*iheight);
         double[] c=new double[256];
         c[0]=(a*histogram[0]);
         for(int i=1;i<256;i++)
             c[i]=c[i-1]+(int)(a*histogram[i]);//直方图均衡化(离散情况)
         for(int i=0;i<iheight;i++)
             for(int j=0;j<iwidth;j++)
             {
                 int grey=pixels[i*iwidth+j]&0x0000ff;
                 int hist=(int)c[grey];
                 pixels[i*iwidth+j]=255<<24|hist<<16|hist<<8|hist;
                 greyImage.setRGB(j, i, pixels[i*iwidth+j]);
             }
         tmp=greyImage;
         File f=new File(directory+"\\"+"均衡化.jpg");
         ImageIO.write(greyImage, "jpg", f);//在原路径下输出均衡化后的图像
     }

     //灰度线性变换
     public static void linearConversion() throws IOException
     {
         int min=255,max=0;
         for(int i=0;i<256;i++)
         {
             if(histogram[i]>0)
             {
                 if(i<min)
                     min=i;
                 if(i>max)
                     max=i;
             }
         }//找出灰度的最大级和最小级
         double k=(ma-mi)/(max-min);//计算变换比
         BufferedImage greyImage=new BufferedImage(iwidth, iheight, BufferedImage.TYPE_BYTE_GRAY);
         for(int i=0;i<iheight;i++)
             for(int j=0;j<iwidth;j++)
             {
                 int grey=pixels2[i*iwidth+j]&0xff;
                 grey=(int)(k*(grey-min)+mi);
                 if(grey>255)
                     grey=255;
                 if(grey<0)
                     grey=0;
                 pixels2[i*iwidth+j]=255<<24|grey<<16|grey<<8|grey;
                 greyImage.setRGB(j, i, pixels2[i*iwidth+j]);
             }//灰度线性变换
         File f=new File(directory+"\\"+"线性变换.jpg");
         ImageIO.write(greyImage, "jpg", f);//在原路径下输出均衡化后的图像
     }

     //灰度拉伸
     public static void grayStretch() throws IOException
     {
         int min = 0,max = 1;
         int sum=0;
         for(int i=0;i<256;i++)
         {
             sum+=histogram[i];
             if(sum>iwidth*iheight*0.05)
             {
                 min=i;
                 break;
             }
         }//找出灰度的大部分像素范围的最小级
         sum=0;
         for(int i=255;i>=0;i--)
         {
             sum+=histogram[i];
             if(sum>iwidth*iheight*0.05)
             {
                 max=i;
                 break;
             }
         }//找出灰度的大部分像素范围的最大级
         double k=(ma-mi)/(max-min);
         BufferedImage greyImage=new BufferedImage(iwidth, iheight, BufferedImage.TYPE_BYTE_GRAY);
         for(int i=0;i<iheight;i++)
             for(int j=0;j<iwidth;j++)
             {
                 int grey=pixels3[i*iwidth+j]&0xff;
                 if(grey<min)
                     grey=(int) mi;//小于min部分设为下限
                 else if(grey>=max)
                     grey=(int) ma;//大于max部分设为上限
                 else
                 {
                     grey=(int)(k*(grey-min)+mi);
                     if(grey>255)
                         grey=255;
                     if(grey<0)
                         grey=0;
                 }//大部分区域线性变换

                 pixels3[i*iwidth+j]=255<<24|grey<<16|grey<<8|grey;
                 greyImage.setRGB(j, i, pixels3[i*iwidth+j]);
             }//灰度拉伸
         File f=new File(directory+"\\"+"灰度拉伸.jpg");
         ImageIO.write(greyImage, "jpg", f);//在原路径下输出拉伸后的图像
     }
 }