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 p_w_picpathTool {
     public  static final  int LEFT =  0;
     public  static final  int RIGHT =  1;
     public  static final  int TOP =  3;
     public  static final  int BOTTOM =  4;

     /* *  */
     /* *
     * 图片去色,返回灰度图片
     * 
     * @param bmpOriginal
     *            传入的图片
     * @return 去色后的图片
      */
     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;
    }

     /* *  */
     /* *
     * 去色同时加圆角
     * 
     * @param bmpOriginal
     *            原图
     * @param pixels
     *            圆角弧度
     * @return 修改后的图片
      */
     public  static Bitmap toGrayscale(Bitmap bmpOriginal,  int pixels) {
         return toRoundCorner(toGrayscale(bmpOriginal), pixels);
    }

     /* *  */
     /* *
     * 把图片变成圆角
     * 
     * @param bitmap
     *            须要修改的图片
     * @param pixels
     *            圆角的弧度
     * @return 圆角图片
      */
     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;
    }

     /* *  */
     /* *
     * 使圆角功能支持BitampDrawable
     * 
     * @param bitmapDrawable
     * @param pixels
     * @return
      */
     public  static BitmapDrawable toRoundCorner(BitmapDrawable bitmapDrawable,
             int pixels) {
        Bitmap bitmap = bitmapDrawable.getBitmap();
        bitmapDrawable =  new BitmapDrawable(toRoundCorner(bitmap, pixels));
         return bitmapDrawable;
    }

     /* *
     * 读取路径中的图片，而后将其转化为缩放后的bitmap
     * 
     * @param path
      */
     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);
    }

     /* *
     * 保存图片为PNG
     * 
     * @param bitmap
     * @param name
      */
     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();
        }
    }

     /* *
     * 保存图片为JPEG
     * 
     * @param bitmap
     * @param path
      */
     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();
        }
    }

     /* *
     * 水印
     * 
     * @param bitmap
     * @return
      */
     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;
    }

     /* *
     * 图片合成
     * 
     * @return
      */
     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;
    }

     /* *
     * 将Bitmap转换成指定大小
     * 
     * @param bitmap
     * @param width
     * @param height
     * @return
      */
     public  static Bitmap createBitmapBySize(Bitmap bitmap,  int width,  int height) {
         return Bitmap.createScaledBitmap(bitmap, width, height,  true);
    }

     /* *
     * Drawable 转 Bitmap
     * 
     * @param drawable
     * @return
      */
     public  static Bitmap drawableToBitmapByBD(Drawable drawable) {
        BitmapDrawable bitmapDrawable = (BitmapDrawable) drawable;
         return bitmapDrawable.getBitmap();
    }

     /* *
     * Bitmap 转 Drawable
     * 
     * @param bitmap
     * @return
      */
     public  static Drawable bitmapToDrawableByBD(Bitmap bitmap) {
        Drawable drawable =  new BitmapDrawable(bitmap);
         return drawable;
    }

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

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