Bitmap 篇

关于bitmap 网上有太多的操作方法，这里收集了一些（比较杂），有需要的盆友可以根据需要再次封装。

import java.io.BufferedOutputStream; 
import java.io.ByteArrayOutputStream; 
import java.io.File; 
import java.io.FileInputStream; 
import java.io.FileNotFoundException; 
import java.io.FileOutputStream; 
import java.io.IOException; 
import java.io.InputStream; 
import java.sql.Timestamp; 
import java.text.SimpleDateFormat;
import android.R.dimen;
import android.app.Activity; 
import android.content.ContentResolver; 
import android.content.Context; 
import android.content.Intent; 
import android.database.Cursor; 
import android.graphics.Bitmap; 
import android.graphics.Bitmap.CompressFormat; 
import android.graphics.Bitmap.Config; 
import android.graphics.BitmapFactory; 
import android.graphics.Canvas;
import android.graphics.ColorMatrix;
import android.graphics.ColorMatrixColorFilter;
import android.graphics.LinearGradient; 
import android.graphics.Matrix; 
import android.graphics.Paint; 
import android.graphics.PixelFormat; 
import android.graphics.PorterDuff;
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.media.Image;
import android.net.Uri;
import android.os.Build;
import android.os.Environment; 
import android.provider.MediaStore; 
import android.util.DisplayMetrics; 
import android.util.Log;
import android.view.View;
import android.widget.ImageView;
import android.widget.TextView;
import android.widget.ImageView.ScaleType;

/**
 * 图片操作工具包
 */ 
public class BitmapUtilities { 

    public final static String SDCARD_MNT = "/mnt/sdcard"; 
    public final static String SDCARD = "/sdcard"; 

    /**
     * 写图片文件 在Android系统中，文件保存在 /data/data/PACKAGE_NAME/files 目录下
     * 
     * @throws IOException
     */ 
    public static void saveImage(Context context, String fileName, Bitmap bitmap) 
            throws IOException { 
        saveImage(context, fileName, bitmap, 100); 
    } 

    public static void saveImage(Context context, String fileName, 
            Bitmap bitmap, int quality) throws IOException { 
        if (bitmap == null || fileName == null || context == null) 
            return; 

        FileOutputStream fos = context.openFileOutput(fileName, 
                Context.MODE_PRIVATE); 
        ByteArrayOutputStream stream = new ByteArrayOutputStream(); 
        bitmap.compress(CompressFormat.JPEG, quality, stream); 
        byte[] bytes = stream.toByteArray(); 
        fos.write(bytes); 
        fos.close(); 
    } 
    /**
     * 获取图片大小
     * <br>
     * 在Android API（12）之前的版本和后来的版本是不一样
     * @param bitmap
     * @return
     */
    public int getBitmapSize(Bitmap bitmap){
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT){    //API 19
            return bitmap.getAllocationByteCount();
        }
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB_MR1){//API 12
            return bitmap.getByteCount();
        }
        return bitmap.getRowBytes() * bitmap.getHeight();                //earlier version
    }
    /**
     * convert Bitmap to byte array
     * 
     * @param b
     * @return
     */
    public static byte[] bitmapToByte(Bitmap b) {
        if (b == null) {
            return null;
        }

        ByteArrayOutputStream o = new ByteArrayOutputStream();
        b.compress(Bitmap.CompressFormat.PNG, 100, o);
        return o.toByteArray();
    }
    /**
     * convert Drawable to byte array
     * 
     * @param d
     * @return
     */
    public static byte[] drawableToByte(Drawable d) {
        return bitmapToByte(drawableToBitmap(d));
    }

    /**
     * convert byte array to Drawable
     * 
     * @param b
     * @return
     */
    public static Drawable byteToDrawable(byte[] b) {
        return bitmapToDrawable(byteToBitmap(b));
    }
    /**
     * convert byte array to Bitmap
     * 
     * @param b
     * @return
     */
    public static Bitmap byteToBitmap(byte[] b) {
        return (b == null || b.length == 0) ? null : BitmapFactory.decodeByteArray(b, 0, b.length);
    }
    /**
     * 写图片文件到SD卡
     * 
     * @throws IOException
     */ 
    public static void saveImageToSD(Context ctx, String filePath, 
            Bitmap bitmap, int quality) throws IOException { 
        if (bitmap != null) { 
            File file = new File(filePath.substring(0, 
                    filePath.lastIndexOf(File.separator))); 
            if (!file.exists()) { 
                file.mkdirs(); 
            } 
            BufferedOutputStream bos = new BufferedOutputStream( 
                    new FileOutputStream(filePath)); 
            bitmap.compress(CompressFormat.JPEG, quality, bos); 
            bos.flush(); 
            bos.close(); 
            if(ctx!=null){ 
                scanPhoto(ctx, filePath); 
            } 
        } 
    } 

    /**
     * 让Gallery上能马上看到该图片
     */ 
    private static void scanPhoto(Context ctx, String imgFileName) { 
        Intent mediaScanIntent = new Intent( 
                Intent.ACTION_MEDIA_SCANNER_SCAN_FILE); 
        File file = new File(imgFileName); 
        Uri contentUri = Uri.fromFile(file); 
        mediaScanIntent.setData(contentUri); 
        ctx.sendBroadcast(mediaScanIntent); 
    } 
    /**
     * 图片去色，返回黑白的图片
     * @param old
     * @return
     */
    public static Bitmap getGreyImage(Bitmap old) {     
        int width, height;     
        height = old.getHeight();     
        width = old.getWidth();         
        Bitmap newbitmap= Bitmap.createBitmap(width, height, Bitmap.Config.RGB_565);     
        Canvas c = new Canvas(old);     
        Paint paint = new Paint();     
        ColorMatrix cm = new ColorMatrix();     
        cm.setSaturation(0);     
        ColorMatrixColorFilter f = new ColorMatrixColorFilter(cm);     
        paint.setColorFilter(f);     
        c.drawBitmap(newbitmap, 0, 0, paint);     
        return newbitmap;     
    } 
    /**
     * 获取bitmap
     * 
     * @param context
     * @param fileName
     * @return
     */ 
    public static Bitmap getBitmap(Context context, String fileName) { 
        FileInputStream fis = null; 
        Bitmap bitmap = null; 
        try { 
            fis = context.openFileInput(fileName); 
            bitmap = BitmapFactory.decodeStream(fis); 
        } catch (FileNotFoundException e) { 
            e.printStackTrace(); 
        } catch (OutOfMemoryError e) { 
            e.printStackTrace(); 
        } finally { 
            try { 
                fis.close(); 
            } catch (Exception e) { 
            } 
        } 
        return bitmap; 
    } 

    /**
     * 获取bitmap
     * 
     * @param filePath
     * @return
     */ 
    public static Bitmap getBitmapByPath(String filePath) { 
        return getBitmapByPath(filePath, null); 
    } 

    public static Bitmap getBitmapByPath(String filePath, 
            BitmapFactory.Options opts) { 
        FileInputStream fis = null; 
        Bitmap bitmap = null; 
        try { 
            File file = new File(filePath); 
            fis = new FileInputStream(file); 
            bitmap = BitmapFactory.decodeStream(fis, null, opts); 
        } catch (FileNotFoundException e) { 
            e.printStackTrace(); 
        } catch (OutOfMemoryError e) { 
            e.printStackTrace(); 
        } finally { 
            try { 
                fis.close(); 
            } catch (Exception e) { 
            } 
        } 
        return bitmap; 
    } 

    /**
     * 获取bitmap
     * 
     * @param file
     * @return
     */ 
    public static Bitmap getBitmapByFile(File file) { 
        FileInputStream fis = null; 
        Bitmap bitmap = null; 
        try { 
            fis = new FileInputStream(file); 
            bitmap = BitmapFactory.decodeStream(fis); 
        } catch (FileNotFoundException e) { 
            e.printStackTrace(); 
        } catch (OutOfMemoryError e) { 
            e.printStackTrace(); 
        } finally { 
            try { 
                fis.close(); 
            } catch (Exception e) { 
            } 
        } 
        return bitmap; 
    } 
    /** 
     * 图片透明度处理 
     * 
     * @param sourceImg 
     *            原始图片 
     * @param number (0-100)
     *            透明度 
     * @return 
     */  
    public static Bitmap getTransparentBitmap(Bitmap sourceImg, int number){  
        int[] argb = new int[sourceImg.getWidth() * sourceImg.getHeight()];  
        sourceImg.getPixels(argb, 0, sourceImg.getWidth(), 0, 0, sourceImg  
                .getWidth(), sourceImg.getHeight());// 获得图片的ARGB值  
        number = number * 255 / 100;  
        for (int i = 0; i < argb.length; i++) {  
            argb[i] = (number << 24) | (argb[i] & 0x00FFFFFF);  
        }  
        sourceImg = Bitmap.createBitmap(argb, sourceImg.getWidth(), sourceImg  
                .getHeight(), Config.ARGB_8888);  
        return sourceImg;  
    }
    /**
     * 通过canvas改变bitmap 透明度
     * @param canvas
     * @param context
     * @param bitmapid
     * @param transparency  透明值 （0-255）
     */
    public static void SetTransByCanvas(Canvas canvas,Context context,int bitmapid,int transparency){

        // 取得Resource 图片的Bitmap  
        Bitmap vBitmap = BitmapFactory.decodeResource( context.getResources() , bitmapid );  
        // 建立Paint 物件  
        Paint vPaint = new Paint();  
        vPaint .setStyle( Paint.Style.STROKE );   //空心  
        vPaint .setAlpha(transparency);   //   
        //canvas.drawBitmap ( vBitmap , 50, 100, null );  //无透明  
        canvas.drawBitmap ( vBitmap , 50, 200, vPaint );  //有透明 
    }
    /*** 
     * 绘制带有边框的文字 
     * 
     * @param strMsg 
     * ：绘制内容 
     * @param g 
     * ：画布 
     * @param paint 
     * ：画笔 
     * @param setx 
     * ：：X轴起始坐标 
     * @param sety 
     * ：Y轴的起始坐标 
     * @param fg 
     * ：前景色 
     * @param bg 
     * ：背景色 
     */  
    public void drawText(String strMsg, Canvas g, Paint paint, int setx,  
            int sety, int fg, int bg) {  
        paint.setColor(bg);  
        g.drawText(strMsg, setx + 1, sety, paint);  
        g.drawText(strMsg, setx, sety -1, paint);  
        g.drawText(strMsg, setx, sety + 1, paint);  
        g.drawText(strMsg, setx -1, sety, paint);  
        paint.setColor(fg);  
        g.drawText(strMsg, setx, sety, paint);  
        g.restore();  
    }  
    /*** 
     * 图片分割  图片平均分割方法，将大图平均分割为N行N列，方便用户使用  
     * 
     * @param g 
     * ：画布 
     * @param paint 
     * ：画笔 
     * @param imgBit 
     * ：图片 
     * @param x 
     * ：X轴起点坐标 
     * @param y 
     * ：Y轴起点坐标 
     * @param w 
     * ：单一图片的宽度 
     * @param h 
     * ：单一图片的高度 
     * @param line 
     * ：第几列 
     * @param row 
     * ：第几行 
     */  
    public final void cuteImage(Canvas g, Paint paint, Bitmap imgBit, int x,  
            int y, int w, int h, int line, int row) {  
        g.clipRect(x, y, x + w, h + y);  
        g.drawBitmap(imgBit, x - line * w, y - row * h, paint);  
        g.restore();  
    }  
    /** 
     * 根据一张大图，返回切割后的图元数组 
     * @param resourseId:资源id 
     * @param row：总行数 
     * @param col：总列数 
     * multiple:图片缩放的倍数1:表示不变，2表示放大为原来的2倍 
     * @return 
     */  
    public static Bitmap[] getBitmaps(Context context,int resourseId,int row,int col,float multiple) {  
        Bitmap bitmaps[] = new Bitmap[row*col];  
        Bitmap source = decodeResource(context, resourseId);  
        int temp = 0;  
        for(int i=1; i<=row; i++) {  
            for(int j=1; j<=col; j++) {  
                bitmaps[temp] = getImage(context,source, i, j, row, col,multiple,false);  
                temp ++;  
            }  
        }  
        if(source != null && !source.isRecycled()) {  
            source.recycle();  
            source = null;  
        }  
        return bitmaps;  
    }  
    /** 
     * 从大图中截取小图 
     * @param r 
     * @param resourseId 
     * @param row 
     * @param col 
     * @param rowTotal 
     * @param colTotal 
     * @return 
     */  
    private static Bitmap getImage(Context context,Bitmap source,int row,int col,
            int rowTotal, int colTotal, float multiple,boolean isRecycle) {  
        Bitmap temp = Bitmap.createBitmap(source, (col-1)*source.getWidth()/colTotal, 
                (row-1)*source.getHeight()/rowTotal, source.getWidth()/colTotal, source.getHeight()/rowTotal);  
        if(isRecycle) {  
            if(source != null && !source.isRecycled()) {  
                source.recycle();  
                source = null;  
            }   
        }  
        if(multiple != 1.0) {  
            Matrix matrix = new Matrix();  
            matrix.postScale(multiple, multiple);  
            temp = Bitmap.createBitmap(temp, 0, 0,temp.getWidth(), temp.getHeight(), matrix, true);  
        }  
        return temp;  
    } 
    /**
     * 通过id加载bitmap
     * @param context
     * @param resourseId
     * @return
     */
    public static Bitmap decodeResource(Context context,int resourseId) {  
        BitmapFactory.Options opt = new BitmapFactory.Options();  
        opt.inPreferredConfig = Bitmap.Config.ARGB_8888;  
        opt.inPurgeable = true;  
        opt.inInputShareable = true; //需把 inPurgeable设置为true，否则被忽略  
        //获取资源图片  
        InputStream is = context.getResources().openRawResource(resourseId);  
        return BitmapFactory.decodeStream(is,null,opt);  //decodeStream直接调用JNI>>nativeDecodeAsset()来完成decode，无需再使用java层的createBitmap，从而节省了java层的空间  
    }  
    /** 
     * 从assets文件下解析图片 
     * @param resName 
     * @return 
     */  
    public static Bitmap decodeBitmapFromAssets(Context context,String resName) {  
        BitmapFactory.Options options = new BitmapFactory.Options();  
        options.inPreferredConfig = Bitmap.Config.ARGB_8888;  
        options.inPurgeable = true;  
        options.inInputShareable = true;  
        InputStream in = null;  
        try {  
            //in = AssetsResourcesUtil.openResource(resName);  
            in =context.getAssets().open(resName);  
        } catch (IOException e) {  
            e.printStackTrace();  
        }  
        return BitmapFactory.decodeStream(in, null, options);  
    } 
    /*** 
     * 加载本地图片 图片加载方法，方便用户加载图片
     * @param context：主运行函数实例 
     * @param bitAdress：图片地址，一般指向R下的drawable目录 
     * @return 
     */  
    public final Bitmap CreatImage(Context context, int bitAdress) {  
        Bitmap bitmaptemp = null;  
        bitmaptemp = BitmapFactory.decodeResource(context.getResources(),  
                bitAdress);  
        return bitmaptemp;  
    } 
    /**
     * 使用当前时间戳拼接一个唯一的文件名
     * 
     * @param format
     * @return
     */ 
    public static String getTempFileName() { 
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd_HH-mm-ss_SS"); 
        String fileName = format.format(new Timestamp(System 
                .currentTimeMillis())); 
        return fileName; 
    } 

    /**
     * 获取照相机使用的目录
     * 
     * @return
     */ 
    public static String getCamerPath() { 
        return Environment.getExternalStorageDirectory() + File.separator 
                + "FounderNews" + File.separator; 
    } 

    /**
     * 判断当前Url是否标准的content://样式，如果不是，则返回绝对路径
     * 
     * @param uri
     * @return
     */ 
    public static String getAbsolutePathFromNoStandardUri(Uri mUri) { 
        String filePath = null; 

        String mUriString = mUri.toString(); 
        mUriString = Uri.decode(mUriString); 

        String pre1 = "file://" + SDCARD + File.separator; 
        String pre2 = "file://" + SDCARD_MNT + File.separator; 

        if (mUriString.startsWith(pre1)) { 
            filePath = Environment.getExternalStorageDirectory().getPath() 
                    + File.separator + mUriString.substring(pre1.length()); 
        } else if (mUriString.startsWith(pre2)) { 
            filePath = Environment.getExternalStorageDirectory().getPath() 
                    + File.separator + mUriString.substring(pre2.length()); 
        } 
        return filePath; 
    } 

    /**
     * 通过uri获取文件的绝对路径
     * 
     * @param uri
     * @return
     */ 
    public static String getAbsoluteImagePath(Activity context, Uri uri) { 
        String imagePath = ""; 
        String[] proj = { MediaStore.Images.Media.DATA }; 
        @SuppressWarnings("deprecation")
        Cursor cursor = context.managedQuery(uri, proj, // Which columns to 
                // return 
                null, // WHERE clause; which rows to return (all rows) 
                null, // WHERE clause selection arguments (none) 
                null); // Order-by clause (ascending by name) 

        if (cursor != null) { 
            int column_index = cursor 
                    .getColumnIndexOrThrow(MediaStore.Images.Media.DATA); 
            if (cursor.getCount() > 0 && cursor.moveToFirst()) { 
                imagePath = cursor.getString(column_index); 
            } 
        } 

        return imagePath; 
    } 

    /**
     * 获取图片缩略图 只有Android2.1以上版本支持
     * 
     * @param imgName
     * @param kind
     *            MediaStore.Images.Thumbnails.MICRO_KIND
     * @return
     */ 
    /* public static Bitmap loadImgThumbnail(Activity context, String imgName, 
                int kind) { 
            Bitmap bitmap = null; 

            String[] proj = { MediaStore.Images.Media._ID, 
                    MediaStore.Images.Media.DISPLAY_NAME }; 

            Cursor cursor = context.managedQuery( 
                    MediaStore.Images.Media.EXTERNAL_CONTENT_URI, proj, 
                    MediaStore.Images.Media.DISPLAY_NAME + "='" + imgName + "'", 
                    null, null); 

            if (cursor != null && cursor.getCount() > 0 && cursor.moveToFirst()) { 
                ContentResolver crThumb = context.getContentResolver(); 
                BitmapFactory.Options options = new BitmapFactory.Options(); 
                options.inSampleSize = 1; 
                bitmap = MethodsCompat.getThumbnail(crThumb, cursor.getInt(0), 
                        kind, options); 
            } 
            return bitmap; 
        } 

        public static Bitmap loadImgThumbnail(String filePath, int w, int h) { 
            Bitmap bitmap = getBitmapByPath(filePath); 
            return zoomBitmap(bitmap, w, h); 
        } */

    /**
     * 获取SD卡中最新图片路径(用于查找最新图片)
     * 
     * @return
     */ 
    @SuppressWarnings("unused")
    public static String getLatestImage(Activity context) { 
        String latestImage = null; 
        String[] items = { MediaStore.Images.Media._ID, 
                MediaStore.Images.Media.DATA }; 
        @SuppressWarnings("deprecation")
        Cursor cursor = context.managedQuery( 
                MediaStore.Images.Media.EXTERNAL_CONTENT_URI, items, null, 
                null, MediaStore.Images.Media._ID + " desc"); 

        if (cursor != null && cursor.getCount() > 0) { 
            cursor.moveToFirst(); 
            for (cursor.moveToFirst(); !cursor.isAfterLast(); cursor 
                    .moveToNext()) { 
                latestImage = cursor.getString(1); 
                break; 
            } 
        } 
        return latestImage; 
    } 

    /**
     * 计算缩放图片的宽高
     * 
     * @param img_size
     * @param square_size
     * @return
     */ 
    public static int[] scaleImageSize(int[] img_size, int square_size) { 
        if (img_size[0] <= square_size && img_size[1] <= square_size) 
            return img_size; 
        double ratio = square_size 
                / (double) Math.max(img_size[0], img_size[1]); 
        return new int[] { (int) (img_size[0] * ratio), 
                (int) (img_size[1] * ratio) }; 
    } 

    /**
     * 创建缩略图
     * 
     * @param context
     * @param largeImagePath
     *            原始大图路径
     * @param thumbfilePath
     *            输出缩略图路径
     * @param square_size
     *            输出图片宽度
     * @param quality
     *            输出图片质量(0-100)
     * @throws IOException
     */ 
    public static void createImageThumbnail(Context context, 
            String largeImagePath, String thumbfilePath, int square_size, 
            int quality) throws IOException { 
        BitmapFactory.Options opts = new BitmapFactory.Options(); 
        opts.inSampleSize = 1; 
        // 原始图片bitmap 
        Bitmap cur_bitmap = getBitmapByPath(largeImagePath, opts); 

        if (cur_bitmap == null) 
            return; 

        // 原始图片的高宽 
        int[] cur_img_size = new int[] { cur_bitmap.getWidth(), 
                cur_bitmap.getHeight() }; 
        // 计算原始图片缩放后的宽高 
        int[] new_img_size = scaleImageSize(cur_img_size, square_size); 
        // 生成缩放后的bitmap 
        Bitmap thb_bitmap = zoomBitmap(cur_bitmap, new_img_size[0], 
                new_img_size[1]); 
        // 生成缩放后的图片文件 
        saveImageToSD(null,thumbfilePath, thb_bitmap, quality); 
    } 

    /**
     * 放大缩小图片
     * 
     * @param bitmap
     * @param w
     * @param h
     * @return
     */ 
    public static Bitmap zoomBitmap(Bitmap bitmap, int w, int h) { 
        Bitmap newbmp = null; 
        if (bitmap != null) { 
            int width = bitmap.getWidth(); 
            int height = bitmap.getHeight(); 
            Matrix matrix = new Matrix(); 
            float scaleWidht = ((float) w / width); 
            float scaleHeight = ((float) h / height); 
            matrix.postScale(scaleWidht, scaleHeight); 
            newbmp = Bitmap.createBitmap(bitmap, 0, 0, width, height, matrix, 
                    true); 
        } 
        return newbmp; 
    } 
    /**
     * 自定义缩放旋转图片角度
     * @param bitmap
     * @param Mwidth 
     * @param Mheight
     * @param angle 旋转角度
     * @return
     */
    public static Bitmap scaleBitmap(Bitmap bitmap,int Mwidth,int Mheight,int angle) { 
        // 获取这个图片的宽和高 
        int width = bitmap.getWidth(); 
        int height = bitmap.getHeight(); 
        // 定义预转换成的图片的宽度和高度 
        int newWidth = Mwidth; 
        int newHeight = Mheight; 
        // 计算缩放率，新尺寸除原始尺寸 
        float scaleWidth = ((float) newWidth) / width; 
        float scaleHeight = ((float) newHeight) / height; 
        // 创建操作图片用的matrix对象 
        Matrix matrix = new Matrix(); 
        // 缩放图片动作 
        matrix.postScale(scaleWidth, scaleHeight); 
        // 旋转图片 动作 
        matrix.postRotate(angle); 
        // 创建新的图片 
        Bitmap resizedBitmap = Bitmap.createBitmap(bitmap, 0, 0, width, height, 
                matrix, true); 
        return resizedBitmap; 
    } 

    /**
     * (缩放)根据手机界面宽高来重绘图片
     * 
     * @param context
     *            Activity
     * @param bitmap
     * @return
     */ 
    public static Bitmap reDrawBitMap(Activity context, Bitmap bitmap) { 
        DisplayMetrics dm = new DisplayMetrics(); 
        context.getWindowManager().getDefaultDisplay().getMetrics(dm); 
        int rHeight = dm.heightPixels; 
        int rWidth = dm.widthPixels; 
        // float rHeight=dm.heightPixels/dm.density+0.5f; 
        // float rWidth=dm.widthPixels/dm.density+0.5f; 
        // int height=bitmap.getScaledHeight(dm); 
        // int width = bitmap.getScaledWidth(dm); 
        int height = bitmap.getHeight(); 
        int width = bitmap.getWidth(); 
        float zoomScale; 
        /** 方式1 **/ 
        // if(rWidth/rHeight>width/height){//以高为准 
        // zoomScale=((float) rHeight) / height; 
        // }else{ 
        // //if(rWidth/rHeight<width/height)//以宽为准 
        // zoomScale=((float) rWidth) / width; 
        // } 
        /** 方式2 **/ 
        // if(width*1.5 >= height) {//以宽为准 
        // if(width >= rWidth) 
        // zoomScale = ((float) rWidth) / width; 
        // else 
        // zoomScale = 1.0f; 
        // }else {//以高为准 
        // if(height >= rHeight) 
        // zoomScale = ((float) rHeight) / height; 
        // else 
        // zoomScale = 1.0f; 
        // } 
        /** 方式3 **/ 
        if (width >= rWidth) 
            zoomScale = ((float) rWidth) / width; 
        else 
            zoomScale = 1.0f; 
        // 创建操作图片用的matrix对象 
        Matrix matrix = new Matrix(); 
        // 缩放图片动作 
        matrix.postScale(zoomScale, zoomScale); 
        Bitmap resizedBitmap = Bitmap.createBitmap(bitmap, 0, 0, 
                bitmap.getWidth(), bitmap.getHeight(), matrix, true); 
        return resizedBitmap; 
    } 

    /**
     * 将Drawable转化为Bitmap
     * 
     * @param drawable
     * @return
     */ 
    public static Bitmap drawableToBitmap(Drawable drawable) { 
        int width = drawable.getIntrinsicWidth(); 
        int height = drawable.getIntrinsicHeight(); 
        Bitmap bitmap = Bitmap.createBitmap(width, height, drawable 
                .getOpacity() != PixelFormat.OPAQUE ? Bitmap.Config.ARGB_8888 
                        : Bitmap.Config.RGB_565); 
        Canvas canvas = new Canvas(bitmap); 
        drawable.setBounds(0, 0, width, height); 
        drawable.draw(canvas); 
        return bitmap; 
    } 
    /**
     * 将bitmap转化为drawable
     * 
     * @param bitmap
     * @return
     */ 
    public static Drawable bitmapToDrawable(Bitmap bitmap) { 
        Drawable drawable = new BitmapDrawable(bitmap); 
        return drawable; 
    } 
    /**
     * 获得圆角图片的方法
     * 
     * @param bitmap
     * @param roundPx
     *            一般设成14
     * @return
     */ 
    public static Bitmap getRoundedCornerBitmap(Bitmap bitmap, float roundPx) { 

        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); 

        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; 
    } 

    /**
     * 获得带倒影的图片方法
     * 
     * @param bitmap
     * @return
     */ 
    public static Bitmap createReflectionImageWithOrigin(Bitmap bitmap) { 
        final int reflectionGap = 4; 
        int width = bitmap.getWidth(); 
        int height = bitmap.getHeight(); 

        Matrix matrix = new Matrix(); 
        matrix.preScale(1, -1); 

        Bitmap reflectionImage = Bitmap.createBitmap(bitmap, 0, height / 2, 
                width, height / 2, matrix, false); 

        Bitmap bitmapWithReflection = Bitmap.createBitmap(width, 
                (height + height / 2), Config.ARGB_8888); 

        Canvas canvas = new Canvas(bitmapWithReflection); 
        canvas.drawBitmap(bitmap, 0, 0, null); 
        Paint deafalutPaint = new Paint(); 
        canvas.drawRect(0, height, width, height + reflectionGap, deafalutPaint); 

        canvas.drawBitmap(reflectionImage, 0, height + 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, height, width, bitmapWithReflection.getHeight() 
                + reflectionGap, paint); 

        return bitmapWithReflection; 
    } 


    /**
     * 获取图片类型
     * 
     * @param file
     * @return
     */ 
    public static String getImageType(File file) { 
        if (file == null || !file.exists()) { 
            return null; 
        } 
        InputStream in = null; 
        try { 
            in = new FileInputStream(file); 
            String type = getImageType(in); 
            return type; 
        } catch (IOException e) { 
            return null; 
        } finally { 
            try { 
                if (in != null) { 
                    in.close(); 
                } 
            } catch (IOException e) { 
            } 
        } 
    } 

    /**
     * 获取图片的类型信息
     * 
     * @param in
     * @return
     * @see #getImageType(byte[])
     */ 
    public static String getImageType(InputStream in) { 
        if (in == null) { 
            return null; 
        } 
        try { 
            byte[] bytes = new byte[8]; 
            in.read(bytes); 
            return getImageType(bytes); 
        } catch (IOException e) { 
            return null; 
        } 
    } 

    /**
     * 获取图片的类型信息（jpg png ...）
     * 
     * @param bytes
     *            2~8 byte at beginning of the image file
     * @return image mimetype or null if the file is not image
     */ 
    public static String getImageType(byte[] bytes) { 
        if (isJPEG(bytes)) { 
            return "image/jpeg"; 
        } 
        if (isGIF(bytes)) { 
            return "image/gif"; 
        } 
        if (isPNG(bytes)) { 
            return "image/png"; 
        } 
        if (isBMP(bytes)) { 
            return "application/x-bmp"; 
        } 
        return null; 
    } 

    private static boolean isJPEG(byte[] b) { 
        if (b.length < 2) { 
            return false; 
        } 
        return (b[0] == (byte) 0xFF) && (b[1] == (byte) 0xD8); 
    } 

    private static boolean isGIF(byte[] b) { 
        if (b.length < 6) { 
            return false; 
        } 
        return b[0] == 'G' && b[1] == 'I' && b[2] == 'F' && b[3] == '8' 
                && (b[4] == '7' || b[4] == '9') && b[5] == 'a'; 
    } 

    private static boolean isPNG(byte[] b) { 
        if (b.length < 8) { 
            return false; 
        } 
        return (b[0] == (byte) 137 && b[1] == (byte) 80 && b[2] == (byte) 78 
                && b[3] == (byte) 71 && b[4] == (byte) 13 && b[5] == (byte) 10 
                && b[6] == (byte) 26 && b[7] == (byte) 10); 
    } 

    private static boolean isBMP(byte[] b) { 
        if (b.length < 2) { 
            return false; 
        } 
        return (b[0] == 0x42) && (b[1] == 0x4d); 
    } 

    /** 
     * create the bitmap from a byte array 
     * 生成水印图片 
     * @param src the bitmap object you want proecss 
     * @param watermark the water mark above the src  (水印标志的图片)
     * @return return a bitmap object ,if paramter's length is 0,return null 
     */  
    public static Bitmap createBitmap( Bitmap src,Bitmap watermark )  
    {  
        String tag = "createBitmap";  
        //          Log.d( tag, "create a new bitmap" );  
        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;  
    }  

    /** 重新编码Bitmap 
     *  
     * @param src 
     *          需要重新编码的Bitmap 
     * 
     * @param format 
     *          编码后的格式（目前只支持png和jpeg这两种格式） 
     * 
     * @param quality 
     *          重新生成后的bitmap的质量 
     * 
     * @return 
     *          返回重新生成后的bitmap 
     */  
    private static Bitmap codec(Bitmap src, Bitmap.CompressFormat format, int quality) {  
        ByteArrayOutputStream os = new ByteArrayOutputStream();  
        src.compress(format, quality, os);              

        byte[] array = os.toByteArray();  
        return BitmapFactory.decodeByteArray(array, 0, array.length);  
    }  

    /**
     * Stream转换成Byte  
     * @param is
     * @return
     */
    static byte[] streamToBytes(InputStream is) {  
        ByteArrayOutputStream os = new ByteArrayOutputStream(1024);  
        byte[] buffer = new byte[1024];  
        int len;  
        try {  
            while ((len = is.read(buffer)) >= 0) {  
                os.write(buffer, 0, len);  
            }  
        } catch (java.io.IOException e) {  

        }  
        return os.toByteArray();  
    }  

    /** 
     * 把一个View的对象转换成bitmap 
     * @param view 对象
     */  
    static Bitmap getViewBitmap(View v) {  

        v.clearFocus();  
        v.setPressed(false);  

        //能画缓存就返回false  
        boolean willNotCache = v.willNotCacheDrawing();  
        v.setWillNotCacheDrawing(false);   
        int color = v.getDrawingCacheBackgroundColor();  
        v.setDrawingCacheBackgroundColor(0);  
        if (color != 0) {  
            v.destroyDrawingCache();  
        }  
        v.buildDrawingCache();  
        Bitmap cacheBitmap = v.getDrawingCache();  
        if (cacheBitmap == null) {  
            //Log.e(TAG, "failed getViewBitmap(" + v + ")", new RuntimeException());  
            return null;  
        }  
        Bitmap bitmap = Bitmap.createBitmap(cacheBitmap);  
        // Restore the view  
        v.destroyDrawingCache();  
        v.setWillNotCacheDrawing(willNotCache);  
        v.setDrawingCacheBackgroundColor(color);  
        return bitmap;  
    }  
    /**
     * 圆形头像
     * @param bitmap
     * @param Myheadportrait
     */
    public static void SetCircleBitmap(Bitmap bitmap, ImageView Myheadportrait) {
        /*      Bitmap output = Bitmap.createBitmap(bitmap.getWidth(),  
                bitmap.getHeight(), Bitmap.Config.ARGB_4444); 
        int width=bitmap.getWidth();
        int height=bitmap.getHeight();
//      int squareWidth=Math.min(width,height);
        Canvas canvas = new Canvas(output); 
        final Paint paint = new Paint();  
        final Rect rect = new Rect(0, 0,width,height);  
        final RectF rectF = new RectF(rect);  
        paint.setAntiAlias(true);  
        canvas.drawARGB(0, 0, 0, 0);  
        canvas.drawRoundRect(rectF,width,height, paint);  
        paint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.SRC_IN));  
        canvas.drawBitmap(bitmap, rect, rect, paint);  
        Myheadportrait.setImageBitmap(output);
        Myheadportrait.setScaleType(ScaleType.FIT_XY);*/
        int width=bitmap.getWidth();
        int height=bitmap.getHeight();
        int diameter=Math.min(width,height);
        Bitmap backgroundBMP=Bitmap.createBitmap(diameter, diameter, Config.ARGB_4444);
        Canvas canvas=new Canvas(backgroundBMP);
        Paint paint=new Paint();
        paint.setAntiAlias(true);//设置边缘光滑
        canvas.drawARGB(0, 0, 0, 0);//以颜色ARBG填充整个控件的Canvas背景
        Rect rect=new Rect(0, 0,diameter,diameter); 
        RectF rectF=new RectF(0,0,diameter,diameter);//图片矩形
        canvas.drawCircle(diameter/2, diameter/2, diameter/2, paint);
        paint.setXfermode(new PorterDuffXfermode(Mode.SRC_IN));
        canvas.drawBitmap(bitmap, rect,rectF, paint);
        Myheadportrait.setImageBitmap(bitmap);
        Myheadportrait.setScaleType(ScaleType.FIT_XY);
        //  http://407827531.iteye.com/blog/1470519
        //      1.PorterDuff.Mode.CLEAR
        //         所绘制不会提交到画布上。
        //      2.PorterDuff.Mode.SRC
        //         显示上层绘制图片
        //      3.PorterDuff.Mode.DST
        //        显示下层绘制图片
        //      4.PorterDuff.Mode.SRC_OVER
        //        正常绘制显示，上下层绘制叠盖。
        //      5.PorterDuff.Mode.DST_OVER
        //        上下层都显示。下层居上显示。
        //      6.PorterDuff.Mode.SRC_IN
        //         取两层绘制交集。显示上层。
        //      7.PorterDuff.Mode.DST_IN
        //        取两层绘制交集。显示下层。
        //      8.PorterDuff.Mode.SRC_OUT
        //       取上层绘制非交集部分。
        //      9.PorterDuff.Mode.DST_OUT
        //       取下层绘制非交集部分。
        //      10.PorterDuff.Mode.SRC_ATOP
        //       取下层非交集部分与上层交集部分
        //      11.PorterDuff.Mode.DST_ATOP
        //        取上层非交集部分与下层交集部分
        //      12.PorterDuff.Mode.XOR
        //       中间隐藏  显示其余的
        //      13.PorterDuff.Mode.DARKEN
        //        中间交汇处加深
        //      14.PorterDuff.Mode.LIGHTEN
        //      显示中间交汇处 隐藏其余
        //      15.PorterDuff.Mode.MULTIPLY
        //
        //      16.PorterDuff.Mode.SCREEN
    }


    /*      //Android Matrix类实现镜像方法
          public void drawRegion(Image image_src,

          int x_src, int y_src,

          int width, int height,

          int transform,

          int x_dest, int y_dest,

          int anchor){

          if((anchor&VCENTER) != 0){

          y_dest -= height/2;

          }else if((anchor&BOTTOM) != 0){

          y_dest -= height;

          }

          if((anchor&RIGHT) != 0){

          x_dest -= width;

          }else if((anchor&HCENTER) != 0){

          x_dest -= width/2;

          }

          Bitmap newMap = Bitmap.createBitmap(image_src.getBitmap(), x_src, y_src, width, height);

          Matrix mMatrix = new Matrix();

          Matrix temp = new Matrix();

          Matrix temp2 = new Matrix();

          float[] mirrorY = {

          -1, 0, 0,
          0, 1, 0,
          0, 0, 1

          };

          temp.setValues(mirrorY);

          switch(transform){

          case Sprite.TRANS_NONE:

          break;

          case Sprite.TRANS_ROT90:

          mMatrix.setRotate(90,width/2, height/2);

          break;

          case Sprite.TRANS_ROT180:

          mMatrix.setRotate(180,width/2, height/2);

          break;

          case Sprite.TRANS_ROT270:

          mMatrix.setRotate(270,width/2, height/2);

          break;

          case Sprite.TRANS_MIRROR:

          mMatrix.postConcat(temp);

          break;

          case Sprite.TRANS_MIRROR_ROT90:

          mMatrix.postConcat(temp);

          mMatrix.setRotate(90,width/2, height/2);

          break;

          case Sprite.TRANS_MIRROR_ROT180:

          mMatrix.postConcat(temp);

          mMatrix.setRotate(180,width/2, height/2);

          break;

          case Sprite.TRANS_MIRROR_ROT270:

          mMatrix.postConcat(temp);

          mMatrix.setRotate(270,width/2, height/2);

          break;

          }

          mMatrix.setTranslate(x_dest, y_dest);

          canvas.drawBitmap(newMap, mMatrix, mPaint);

          }
     */
}