android 处理图片工具

 package com.wireme.activity;

import  java.io.ByteArrayOutputStream;
import  java.io.File;
import  java.io.FileNotFoundException;
import  java.io.FileOutputStream;
import  java.io.IOException;

import  android.graphics.Bitmap;
import  android.graphics.BitmapFactory;
import  android.graphics.Canvas;
import  android.graphics.ColorMatrix;
import  android.graphics.ColorMatrixColorFilter;
import  android.graphics.Paint;
import  android.graphics.PorterDuffXfermode;
import  android.graphics.Rect;
import  android.graphics.RectF;
import  android.graphics.Bitmap.Config;
import  android.graphics.PorterDuff.Mode;
import  android.graphics.drawable.BitmapDrawable;
import  android.graphics.drawable.Drawable;


public  class  imageTool  {
        public  static  final  int  LEFT  =  0;
        public  static  final  int  RIGHT  =  1;
        public  static  final  int  TOP  =  3;
        public  static  final  int  BOTTOM  =  4;

       
       
        public  static  Bitmap  toGrayscale(Bitmap  bmpOriginal)  {
                int  width,  height;
                height  =  bmpOriginal.getHeight();
                width  =  bmpOriginal.getWidth();
                Bitmap  bmpGrayscale  =  Bitmap.createBitmap(width,  height,
                                Bitmap.Config.RGB_565);
                Canvas  c  =  new  Canvas(bmpGrayscale);
                Paint  paint  =  new  Paint();
                ColorMatrix  cm  =  new  ColorMatrix();
                cm.setSaturation( 0);
                ColorMatrixColorFilter  f  =  new  ColorMatrixColorFilter(cm);
                paint.setColorFilter(f);
                c.drawBitmap(bmpOriginal,  0,  0,  paint);
                return  bmpGrayscale;
        }

       
       
        public  static  Bitmap  toGrayscale(Bitmap  bmpOriginal,  int  pixels)  {
                return  toRoundCorner(toGrayscale(bmpOriginal),  pixels);
        }

       
       
        public  static  Bitmap  toRoundCorner(Bitmap  bitmap,  int  pixels)  {
                Bitmap  output  =  Bitmap.createBitmap(bitmap.getWidth(),  bitmap
                                .getHeight(),  Config.ARGB_8888);
                Canvas  canvas  =  new  Canvas(output);
                final  int  color  =  0xff424242;
                final  Paint  paint  =  new  Paint();
                final  Rect  rect  =  new  Rect( 0,  0,  bitmap.getWidth(),  bitmap.getHeight());
                final  RectF  rectF  =  new  RectF(rect);
                final  float  roundPx  =  pixels;
                paint.setAntiAlias( true);
                canvas.drawARGB( 0,  0,  0,  0);
                paint.setColor(color);
                canvas.drawRoundRect(rectF,  roundPx,  roundPx,  paint);
                paint.setXfermode( new  PorterDuffXfermode(Mode.SRC_IN));
                canvas.drawBitmap(bitmap,  rect,  rect,  paint);
                return  output;
        }

       
       
        public  static  BitmapDrawable  toRoundCorner(BitmapDrawable  bitmapDrawable,
                        int  pixels)  {
                Bitmap  bitmap  =  bitmapDrawable.getBitmap();
                bitmapDrawable  =  new  BitmapDrawable(toRoundCorner(bitmap,  pixels));
                return  bitmapDrawable;
        }

       
        public  static  void  saveBefore(String  path)  {
                BitmapFactory.Options  options  =  new  BitmapFactory.Options();
                options.inJustDecodeBounds  =  true;
                //  获取这个图片的宽和高
                Bitmap  bitmap  =  BitmapFactory.decodeFile(path,  options);  //  此时返回bm为空
                options.inJustDecodeBounds  =  false;
                //  计算缩放比
                int  be  =  ( int)  (options.outHeight  /  ( float)  200);
                if  (be  <=  0)
                        be  =  1;
                options.inSampleSize  =  2;  //  图片长宽各缩小二分之一
         //  重新读入图片，注意这次要把options.inJustDecodeBounds 设为 false哦
                bitmap  =  BitmapFactory.decodeFile(path,  options);
                int  w  =  bitmap.getWidth();
                int  h  =  bitmap.getHeight();
                System. out.println(w  +  "   "  +  h);
                //  savePNG_After(bitmap,path);
                saveJPGE_After(bitmap,  path);
        }

       
        public  static  void  savePNG_After(Bitmap  bitmap,  String  name)  {
                File  file  =  new  File(name);
                try  {
                        FileOutputStream  out  =  new  FileOutputStream(file);
                        if  (bitmap.compress(Bitmap.CompressFormat.PNG,  100,  out))  {
                                out.flush();
                                out.close();
                        }
                }  catch  (FileNotFoundException  e)  {
                        e.printStackTrace();
                }  catch  (IOException  e)  {
                        e.printStackTrace();
                }
        }

       
        public  static  void  saveJPGE_After(Bitmap  bitmap,  String  path)  {
                File  file  =  new  File(path);
                try  {
                        FileOutputStream  out  =  new  FileOutputStream(file);
                        if  (bitmap.compress(Bitmap.CompressFormat.JPEG,  100,  out))  {
                                out.flush();
                                out.close();
                        }
                }  catch  (FileNotFoundException  e)  {
                        e.printStackTrace();
                }  catch  (IOException  e)  {
                        e.printStackTrace();
                }
        }

       
        public  static  Bitmap  createBitmapForWatermark (Bitmap  src,  Bitmap  watermark)  {
                if  (src  ==  null)  {
                        return  null;
                }
                int  w  =  src.getWidth();
                int  h  =  src.getHeight();
                int  ww  =  watermark.getWidth();
                int  wh  =  watermark.getHeight();
                //  create the new blank bitmap
                Bitmap  newb  =  Bitmap.createBitmap(w,  h,  Config.ARGB_8888); //  创建一个新的和SRC长度宽度一样的位图
                Canvas  cv  =  new  Canvas(newb);
                //  draw src into
                cv.drawBitmap(src,  0,  0,  null); //  在 0，0坐标开始画入src
         //  draw watermark into
                cv.drawBitmap(watermark,  w  -  ww  +  5,  h  -  wh  +  5,  null); //  在src的右下角画入水印
         //  save all clip
                cv.save(Canvas.ALL_SAVE_FLAG); //  保存
         //  store
                cv.restore(); //  存储
                return  newb;
        }

       
        public  static  Bitmap  potoMix( int  direction,  Bitmap...  bitmaps)  {
                if  (bitmaps.length  <=  0)  {
                        return  null;
                }
                if  (bitmaps.length  ==  1)  {
                        return  bitmaps[ 0];
                }
                Bitmap  newBitmap  =  bitmaps[ 0];
                //  newBitmap = createBitmapForFotoMix(bitmaps[0],bitmaps[1],direction);
                for  ( int  i  =  1;  i  <  bitmaps.length;  i++)  {
                        newBitmap  =  createBitmapForFotoMix(newBitmap,  bitmaps[i],  direction);
                }
                return  newBitmap;
        }

        private  static  Bitmap  createBitmapForFotoMix(Bitmap  first,  Bitmap  second,
                        int  direction)  {
                if  (first  ==  null)  {
                        return  null;
                }
                if  (second  ==  null)  {
                        return  first;
                }
                int  fw  =  first.getWidth();
                int  fh  =  first.getHeight();
                int  sw  =  second.getWidth();
                int  sh  =  second.getHeight();
                Bitmap  newBitmap  =  null;
                if  (direction  ==  LEFT)  {
                        newBitmap  =  Bitmap.createBitmap(fw  +  sw,  fh  >  sh  ?  fh  :  sh,
                                        Config.ARGB_8888);
                        Canvas  canvas  =  new  Canvas(newBitmap);
                        canvas.drawBitmap(first,  sw,  0,  null);
                        canvas.drawBitmap(second,  0,  0,  null);
                }  else  if  (direction  ==  RIGHT)  {
                        newBitmap  =  Bitmap.createBitmap(fw  +  sw,  fh  >  sh  ?  fh  :  sh,
                                        Config.ARGB_8888);
                        Canvas  canvas  =  new  Canvas(newBitmap);
                        canvas.drawBitmap(first,  0,  0,  null);
                        canvas.drawBitmap(second,  fw,  0,  null);
                }  else  if  (direction  ==  TOP)  {
                        newBitmap  =  Bitmap.createBitmap(sw  >  fw  ?  sw  :  fw,  fh  +  sh,
                                        Config.ARGB_8888);
                        Canvas  canvas  =  new  Canvas(newBitmap);
                        canvas.drawBitmap(first,  0,  sh,  null);
                        canvas.drawBitmap(second,  0,  0,  null);
                }  else  if  (direction  ==  BOTTOM)  {
                        newBitmap  =  Bitmap.createBitmap(sw  >  fw  ?  sw  :  fw,  fh  +  sh,
                                        Config.ARGB_8888);
                        Canvas  canvas  =  new  Canvas(newBitmap);
                        canvas.drawBitmap(first,  0,  0,  null);
                        canvas.drawBitmap(second,  0,  fh,  null);
                }
                return  newBitmap;
        }

       
        public  static  Bitmap  createBitmapBySize(Bitmap  bitmap,  int  width,  int  height)  {
                return  Bitmap.createScaledBitmap(bitmap,  width,  height,  true);
        }

       
        public  static  Bitmap  drawableToBitmapByBD(Drawable  drawable)  {
                BitmapDrawable  bitmapDrawable  =  (BitmapDrawable)  drawable;
                return  bitmapDrawable.getBitmap();
        }

       
        public  static  Drawable  bitmapToDrawableByBD(Bitmap  bitmap)  {
                Drawable  drawable  =  new  BitmapDrawable(bitmap);
                return  drawable;
        }

       
        public  static  Bitmap  bytesToBimap( byte[]  b)  {
                if  (b.length  !=  0)  {
                        return  BitmapFactory.decodeByteArray(b,  0,  b.length);
                }  else  {
                        return  null;
                }
        }

       
        public  static  byte[]  bitmapToBytes(Bitmap  bm)  {
                ByteArrayOutputStream  baos  =  new  ByteArrayOutputStream();
                bm.compress(Bitmap.CompressFormat.PNG,  100,  baos);
                return  baos.toByteArray();
        }
}