android Bitmap的一些操作

package com.example.androidimage;

import java.io.ByteArrayOutputStream;

import android.graphics.Bitmap;
import android.graphics.Bitmap.Config;
import android.graphics.BitmapFactory;
import android.graphics.Canvas;
import android.graphics.LinearGradient;
import android.graphics.Matrix;
import android.graphics.Paint;
import android.graphics.PixelFormat;
import android.graphics.PorterDuff.Mode;
import android.graphics.PorterDuffXfermode;
import android.graphics.Rect;
import android.graphics.RectF;
import android.graphics.Shader.TileMode;
import android.graphics.drawable.BitmapDrawable;
import android.graphics.drawable.Drawable;
import android.graphics.drawable.NinePatchDrawable;
import android.util.Log;

/**
 * 
 *
 */
public class ImageOperation {

	private static final String TAG = "ImageOperation";

	/**
	 * Zoom to specified size
	 * 
	 * @param original
	 *            bitmap
	 * @param specified
	 *            width
	 * @param specified
	 *            height
	 * @return zoomed bitmap
	 */
	public static Bitmap resizeImage(Bitmap bitmap, int w, int h) {
		if (bitmap != null) {
			Bitmap BitmapOrg = bitmap;

			int width = BitmapOrg.getWidth();
			int height = BitmapOrg.getHeight();

			Log.v(TAG, width + "");
			Log.v(TAG, height + "");

			int newWidth = w;
			int newHeight = h;

			float scaleWidth = ((float) newWidth) / width;
			float scaleHeight = ((float) newHeight) / height;

			Log.v(TAG, scaleWidth + "");
			Log.v(TAG, scaleHeight + "");

			if (scaleWidth >= scaleHeight) {
				scaleWidth = scaleHeight;
			} else {
				scaleHeight = scaleWidth;
			}

			Matrix matrix = new Matrix();

			matrix.postScale(scaleWidth, scaleHeight);
			// if you want to rotate the Bitmap
			// matrix.postRotate(45);

			// recreate the new Bitmap
			Bitmap resizedBitmap = Bitmap.createBitmap(BitmapOrg, 0, 0, width,
					height, matrix, true);

			return resizedBitmap;
		} 
		return null;
		
	}

	/**
	 * *
	 * 
	 * @param bitmap
	 * @return drawable
	 */
	public static Drawable BitmapToDrawable(Bitmap bitmap) {
		if (bitmap != null) {
			return new BitmapDrawable(bitmap);
		} 
		return null;
		

	}

	/**
	 * *drawable 转化为bitmap
	 * 
	 * @param drawable
	 * @return bitmap
	 */
	public static Bitmap drawableToBitmap(Drawable drawable) {
		if (drawable instanceof BitmapDrawable) {
			return ((BitmapDrawable) drawable).getBitmap();
		} else if (drawable instanceof NinePatchDrawable) {
			// 取 drawable 的长宽
			int w = drawable.getIntrinsicWidth();
			int h = drawable.getIntrinsicHeight();

			// 取 drawable 的颜色格式
			Bitmap.Config config = drawable.getOpacity() != PixelFormat.OPAQUE ? Bitmap.Config.ARGB_8888
					: Bitmap.Config.RGB_565;
			// 建立对应 bitmap
			Bitmap bitmap = Bitmap.createBitmap(w, h, config);

			// 建立对应 bitmap 的画布
			Canvas canvas = new Canvas(bitmap);
			drawable.setBounds(0, 0, w, h);
			// 把 drawable 内容画到画布中
			drawable.draw(canvas);

			return bitmap;
		} else {
			return null;
		}
	}

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

	/**
	 * 图片变圆角
	 * @param bitmap
	 * @param roundPx
	 * @return
	 */
	public static Bitmap getRoundedCornerBitmap(Bitmap bitmap, float roundPx) {

		if (bitmap != null) {
			int w = bitmap.getWidth();
			int h = bitmap.getHeight();
			Bitmap output = Bitmap.createBitmap(w, h, Config.ARGB_8888);
			Canvas canvas = new Canvas(output);
			final int color = 0xff424242;
			final Paint paint = new Paint();
			final Rect rect = new Rect(0, 0, w, h);
			final RectF rectF = new RectF(rect);
			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;
		}
		
		return null;
		
	}
	
	/**
	 * *图片设置倒影
	 * @param bitmap
	 * @return
	 */
	public static Bitmap createReflectionImageWithOrigin(Bitmap bitmap) {   
	    final int reflectionGap = 4;   
	    int w = bitmap.getWidth();   
	    int h = bitmap.getHeight();   
	  
	    Matrix matrix = new Matrix();   
	    matrix.preScale(1, -1);   
	  
	    Bitmap reflectionImage = Bitmap.createBitmap(bitmap, 0, h / 2, w,   
	            h / 2, matrix, false);   
	  
	    Bitmap bitmapWithReflection = Bitmap.createBitmap(w, (h + h / 2),   
	            Config.ARGB_8888);   
	  
	    Canvas canvas = new Canvas(bitmapWithReflection);   
	    canvas.drawBitmap(bitmap, 0, 0, null);   
	    Paint deafalutPaint = new Paint();   
	    canvas.drawRect(0, h, w, h + reflectionGap, deafalutPaint);   
	  
	    canvas.drawBitmap(reflectionImage, 0, h + reflectionGap, null);   
	  
	    Paint paint = new Paint();   
	    LinearGradient shader = new LinearGradient(0, bitmap.getHeight(), 0,   
	            bitmapWithReflection.getHeight() + reflectionGap, 0x70ffffff,   
	            0x00ffffff, TileMode.CLAMP);   
	    paint.setShader(shader);   
	    // Set the Transfer mode to be porter duff and destination in   
	    paint.setXfermode(new PorterDuffXfermode(Mode.DST_IN));   
	    // Draw a rectangle using the paint with our linear gradient   
	    canvas.drawRect(0, h, w, bitmapWithReflection.getHeight()   
	            + reflectionGap, paint);   
	  
	    return bitmapWithReflection;   
	}  


}