Android 图片Bitmap的剪切

最新推荐文章于 2024-01-26 23:40:26 发布

mengzhengjie

最新推荐文章于 2024-01-26 23:40:26 发布

阅读量2.8k

点赞数 1

分类专栏： android

android 专栏收录该内容

526 篇文章 1 订阅

订阅专栏

http://blog.csdn.net/stoppig/article/details/23202129

 版权声明：本文为博主原创文章，未经博主允许不得转载。

目录(?)[+]

一、什么是Android中的Bitmap

Bitmap是Android系统中的图像处理的最重要类之一。用它可以获取图像文件信息，进行图像剪切、旋转、缩放等操作，并可以指定格式保存图像文件。

二、Bitmap的剪切基本操作

public static Bitmap createBitmap (Bitmap source, int x, int y, int width, int height, Matrix m, boolean filter)
从原始位图剪切图像，这是一种高级的方式。可以用Matrix(矩阵)来实现旋转等高级方式截图
参数说明：
　　Bitmap source：要从中截图的原始位图
　　int x:起始x坐标
　　int y：起始y坐标
int width：要截的图的宽度
int height：要截的图的宽度
Bitmap.Config config：一个枚举类型的配置，可以定义截到的新位图的质量
返回值：返回一个剪切好的Bitmap

三、Bitmap剪切的封装

实际使用中，因为项目需要时常需要对基本功能进行封装，下面是一段封装的代码，仅供参考。

[java]view plaincopy 
    
print?
 import java.io.ByteArrayOutputStream;  
 import java.io.File;  
 import java.io.FileInputStream;  
 import java.io.FileNotFoundException;  
 import java.io.IOException;  
 import java.io.InputStream;  
 import java.util.ArrayList;  
   
 import android.content.Context;  
 import android.graphics.Bitmap;  
 import android.graphics.Bitmap.Config;  
 import android.graphics.BitmapFactory;  
 import android.graphics.Canvas;  
 import android.graphics.Paint;  
 import android.graphics.PorterDuff;  
 import android.graphics.PorterDuff.Mode;  
 import android.graphics.PorterDuffXfermode;  
 import android.graphics.Rect;  
 import android.graphics.RectF;  
   
   
 public class BitmapCut  
 {  
   
     /** 
      * 通过资源id转化成Bitmap 
      *  
      * @param context 
      * @param resId 
      * @return 
      */  
     public static Bitmap ReadBitmapById(Context context, int resId)  
     {  
         BitmapFactory.Options opt = new BitmapFactory.Options();  
         opt.inPreferredConfig = Bitmap.Config.RGB_565;  
         opt.inPurgeable = true;  
         opt.inInputShareable = true;  
   
         InputStream is = context.getResources().openRawResource(resId);  
         return BitmapFactory.decodeStream(is, null, opt);  
     }  
   
       
   
     /** 
      * 设置背景为圆角 
      *  
      * @param bitmap 
      * @param pixels 
      * @return 
      */  
     public static Bitmap removeYuanjiao(Bitmap bitmap, int pixels)  
     {  
         int width = bitmap.getWidth();  
         int height = bitmap.getHeight();  
   
         Bitmap creBitmap = Bitmap.createBitmap(width, height,  
                 android.graphics.Bitmap.Config.ARGB_8888);  
         Canvas canvas = new Canvas(creBitmap);  
   
         Paint paint = new Paint();  
         float roundPx = pixels;  
         RectF rectF = new RectF(0, 0, bitmap.getWidth() - pixels,  
                 bitmap.getHeight() - pixels);  
         paint.setAntiAlias(true);  
   
         canvas.drawARGB(0, 0, 0, 0);  
         canvas.drawRoundRect(rectF, roundPx, roundPx, paint);  
         paint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.SRC_IN));  
   
         canvas.drawBitmap(bitmap, 0, 0, paint);  
         if (!bitmap.isRecycled())  
             bitmap.recycle();  
   
         return creBitmap;  
     }  
   
     /** 
      * 按正方形裁切图片 
      */  
     public static Bitmap ImageCrop(Bitmap bitmap, boolean isRecycled)  
     {  
   
         if (bitmap == null)  
         {  
             return null;  
         }  
   
         int w = bitmap.getWidth(); // 得到图片的宽，高  
         int h = bitmap.getHeight();  
   
         int wh = w > h ? h : w;// 裁切后所取的正方形区域边长  
   
         int retX = w > h ? (w - h) / 2 : 0;// 基于原图，取正方形左上角x坐标  
         int retY = w > h ? 0 : (h - w) / 2;  
   
         Bitmap bmp = Bitmap.createBitmap(bitmap, retX, retY, wh, wh, null,  
                 false);  
         if (isRecycled && bitmap != null && !bitmap.equals(bmp)  
                 && !bitmap.isRecycled())  
         {  
             bitmap.recycle();  
             bitmap = null;  
         }  
   
         // 下面这句是关键  
         return bmp;// Bitmap.createBitmap(bitmap, retX, retY, wh, wh, null,  
                     // false);  
     }  
   
     /** 
      * 按长方形裁切图片 
      *  
      * @param bitmap 
      * @return 
      */  
     public static Bitmap ImageCropWithRect(Bitmap bitmap)  
     {  
         if (bitmap == null)  
         {  
             return null;  
         }  
   
         int w = bitmap.getWidth(); // 得到图片的宽，高  
         int h = bitmap.getHeight();  
   
         int nw, nh, retX, retY;  
         if (w > h)  
         {  
             nw = h / 2;  
             nh = h;  
             retX = (w - nw) / 2;  
             retY = 0;  
         } else  
         {  
             nw = w / 2;  
             nh = w;  
             retX = w / 4;  
             retY = (h - w) / 2;  
         }  
   
         // 下面这句是关键  
         Bitmap bmp = Bitmap.createBitmap(bitmap, retX, retY, nw, nh, null,  
                 false);  
         if (bitmap != null && !bitmap.equals(bmp) && !bitmap.isRecycled())  
         {  
             bitmap.recycle();  
             bitmap = null;  
         }  
         return bmp;// Bitmap.createBitmap(bitmap, retX, retY, nw, nh, null,  
                     // false);  
     }  
   
     /** 
      * Bitmap --> byte[] 
      *  
      * @param bmp 
      * @return 
      */  
     public static byte[] readBitmap(Bitmap bmp)  
     {  
         ByteArrayOutputStream baos = new ByteArrayOutputStream();  
         bmp.compress(Bitmap.CompressFormat.JPEG, 60, baos);  
         try  
         {  
             baos.flush();  
             baos.close();  
         } catch (IOException e)  
         {  
             e.printStackTrace();  
         }  
         return baos.toByteArray();  
     }  
   
       
     /** 
      * 将图像裁剪成圆形 
      *  
      * @param bitmap 
      * @return 
      */  
     public static Bitmap toRoundBitmap(Bitmap bitmap)  
     {  
         if (bitmap == null)  
         {  
             return null;  
         }  
   
         int width = bitmap.getWidth();  
         int height = bitmap.getHeight();  
         float roundPx;  
         float left, top, right, bottom, dst_left, dst_top, dst_right, dst_bottom;  
         if (width <= height)  
         {  
             roundPx = width / 2;  
             top = 0;  
             bottom = width;  
             left = 0;  
             right = width;  
             height = width;  
             dst_left = 0;  
             dst_top = 0;  
             dst_right = width;  
             dst_bottom = width;  
         } else  
         {  
             roundPx = height / 2;  
             float clip = (width - height) / 2;  
             left = clip;  
             right = width - clip;  
             top = 0;  
             bottom = height;  
             width = height;  
             dst_left = 0;  
             dst_top = 0;  
             dst_right = height;  
             dst_bottom = height;  
         }  
   
         Bitmap output = Bitmap.createBitmap(width, height, Config.ARGB_8888);  
         Canvas canvas = new Canvas(output);  
   
         final int color = 0xff424242;  
         final Paint paint = new Paint();  
         final Rect src = new Rect((int) left, (int) top, (int) right,  
                 (int) bottom);  
         final Rect dst = new Rect((int) dst_left, (int) dst_top,  
                 (int) dst_right, (int) dst_bottom);  
         final RectF rectF = new RectF(dst);  
   
         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, src, dst, paint);  
         if (bitmap != null && !bitmap.isRecycled())  
         {  
             bitmap.recycle();  
             bitmap = null;  
         }  
         return output;  
     }  
   
     // 将图片变成带圆边的圆形图片  
     public static Bitmap getRoundBitmap(Bitmap bitmap, int width, int height)  
     {  
         if (bitmap == null)  
         {  
             return null;  
         }  
         // 将图片变成圆角  
         Bitmap roundBitmap = Bitmap.createBitmap(width, height,  
                 Config.ARGB_8888);  
         Canvas canvas = new Canvas(roundBitmap);  
         Paint paint = new Paint(Paint.ANTI_ALIAS_FLAG);  
         int len = (width > height) ? height : width;  
         canvas.drawCircle(width / 2, height / 2, len / 2 - 8, paint);  
         paint.setXfermode(new PorterDuffXfermode(Mode.SRC_IN));  
         Bitmap scaledBitmap = Bitmap.createScaledBitmap(bitmap, len, len, true);  
         canvas.drawBitmap(scaledBitmap, 0, 0, paint);  
         // 将图片加圆边  
         Bitmap outBitmap = Bitmap.createBitmap(width, height, Config.ARGB_8888);  
         canvas = new Canvas(outBitmap);  
         paint = new Paint(Paint.ANTI_ALIAS_FLAG);  
         paint.setColor(0xffffffff);  
         canvas.drawCircle(width / 2, height / 2, len / 2 - 4, paint);  
         paint.setXfermode(new PorterDuffXfermode(Mode.SRC_OVER));  
         canvas.drawBitmap(roundBitmap, 0, 0, paint);  
         bitmap.recycle();  
         bitmap = null;  
         roundBitmap.recycle();  
         roundBitmap = null;  
         scaledBitmap.recycle();  
         scaledBitmap = null;  
         return outBitmap;  
     }  
   
     // 将图片变成带圆边的圆形图片  
     public static Bitmap getRoundBitmap(Bitmap bitmap, int width, int height,  
             int color)  
     {  
         if (bitmap == null)  
         {  
             return null;  
         }  
         // 将图片变成圆角  
         Bitmap roundBitmap = Bitmap.createBitmap(width, height,  
                 Config.ARGB_8888);  
         Canvas canvas = new Canvas(roundBitmap);  
         Paint paint = new Paint(Paint.ANTI_ALIAS_FLAG);  
         int len = (width > height) ? height : width;  
         canvas.drawCircle(width / 2, height / 2, len / 2 - 8, paint);  
         paint.setXfermode(new PorterDuffXfermode(Mode.SRC_IN));  
         Bitmap scaledBitmap = Bitmap.createScaledBitmap(bitmap, len, len, true);  
         canvas.drawBitmap(scaledBitmap, 0, 0, paint);  
         // 将图片加圆边  
         Bitmap outBitmap = Bitmap.createBitmap(width, height, Config.ARGB_8888);  
         canvas = new Canvas(outBitmap);  
         paint = new Paint(Paint.ANTI_ALIAS_FLAG);  
         paint.setColor(color);  
         canvas.drawCircle(width / 2, height / 2, len / 2 - 4, paint);  
         paint.setXfermode(new PorterDuffXfermode(Mode.SRC_OVER));  
         canvas.drawBitmap(roundBitmap, 0, 0, paint);  
         bitmap.recycle();  
         bitmap = null;  
         roundBitmap.recycle();  
         roundBitmap = null;  
         scaledBitmap.recycle();  
         scaledBitmap = null;  
         return outBitmap;  
     }  
   
     /** 
      * function:图片转圆角 
      *  
      * @param bitmap 
      *            需要转的bitmap 
      * @param pixels 
      *            转圆角的弧度 
      * @return 转圆角的bitmap 
      */  
     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);  
         if (bitmap != null && !bitmap.isRecycled())  
         {  
             bitmap.recycle();  
         }  
         return output;  
     }  
   
     /** 
      * 获取指定的圆角图片 
      *  
      * @param bitmap 
      * @return 
      */  
     public static Bitmap getRadiusBitmap(Bitmap bitmap)  
     {  
         Paint paint = new Paint(Paint.ANTI_ALIAS_FLAG);  
         paint.setColor(0xffffffff);  
         Bitmap radiusBitmap = Bitmap.createBitmap(bitmap.getWidth(),  
                 bitmap.getHeight(), Config.ARGB_8888);  
         Canvas canvas = new Canvas(radiusBitmap);  
         RectF rectF = new RectF(0, 0, bitmap.getWidth(), bitmap.getHeight());  
         canvas.drawRoundRect(rectF, 7, 7, paint);  
         paint.setXfermode(new PorterDuffXfermode(Mode.SRC_IN));  
         canvas.drawBitmap(bitmap, 0, 0, paint);  
         if (bitmap != null && !bitmap.isRecycled())  
         {  
             bitmap.recycle();  
         }  
         return radiusBitmap;  
     }  
   
     // 获得指定大小的圆边的bitmap数组  
     public static ArrayList<Bitmap> getRadiusBitmapList(String[] pathArray,  
             int size, int len, float radius, int color)  
     {  
         Bitmap canvasBitmap = null;  
         Canvas canvas = null;  
         Paint paint = null;  
         RectF rectF = new RectF(0, 0, len - radius, len - radius);  
         File file = null;  
         FileInputStream fis = null;  
         Bitmap bitmap = null;  
         Bitmap scaledBitmap = null;  
   
         ArrayList<Bitmap> list = new ArrayList<Bitmap>();  
         for (int i = 0; i < pathArray.length; i++)  
         {  
             file = new File(pathArray[i]);  
             if (!file.exists())  
                 continue;  
             try  
             {  
                 fis = new FileInputStream(file);  
                 bitmap = BitmapFactory.decodeStream(fis);  
                 if (bitmap != null)  
                 {  
                     canvasBitmap = Bitmap.createBitmap(len, len,  
                             Config.ARGB_8888);  
                     canvas = new Canvas(canvasBitmap);  
                     paint = new Paint(Paint.ANTI_ALIAS_FLAG);  
                     paint.setColor(color);  
                     canvas.drawRoundRect(rectF, radius, radius, paint);  
                     paint.setXfermode(new PorterDuffXfermode(Mode.SRC_IN));  
   
                     scaledBitmap = Bitmap.createScaledBitmap(bitmap, len, len,  
                             true);  
                     canvas.drawBitmap(scaledBitmap, 0, 0, paint);  
                     list.add(canvasBitmap);  
                 }  
             } catch (FileNotFoundException e)  
             {  
             } finally  
             {  
                 if (fis != null)  
                 {  
                     try  
                     {  
                         fis.close();  
                     } catch (IOException e1)  
                     {  
                     }  
                 }  
             }  
             if (list.size() == size)  
                 break;  
         }  
         if (scaledBitmap != null && !scaledBitmap.isRecycled())  
         {  
             scaledBitmap.recycle();  
             scaledBitmap = null;  
         }  
         if (bitmap != null && !bitmap.isRecycled())  
         {  
             bitmap.recycle();  
             bitmap = null;  
         }  
         return list;  
     }  
   
       
   
       
   
     /** 
      * 按照一定的宽高比例裁剪图片 
      *  
      * @param bitmap 
      * @param num1 
      *            长边的比例 
      * @param num2 
      *            短边的比例 
      * @return 
      */  
     public static Bitmap ImageCrop(Bitmap bitmap, int num1, int num2,  
             boolean isRecycled)  
     {  
         if (bitmap == null)  
         {  
             return null;  
         }  
         int w = bitmap.getWidth(); // 得到图片的宽，高  
         int h = bitmap.getHeight();  
         int retX, retY;  
         int nw, nh;  
         if (w > h)  
         {  
             if (h > w * num2 / num1)  
             {  
                 nw = w;  
                 nh = w * num2 / num1;  
                 retX = 0;  
                 retY = (h - nh) / 2;  
             } else  
             {  
                 nw = h * num1 / num2;  
                 nh = h;  
                 retX = (w - nw) / 2;  
                 retY = 0;  
             }  
         } else  
         {  
             if (w > h * num2 / num1)  
             {  
                 nh = h;  
                 nw = h * num2 / num1;  
                 retY = 0;  
                 retX = (w - nw) / 2;  
             } else  
             {  
                 nh = w * num1 / num2;  
                 nw = w;  
                 retY = (h - nh) / 2;  
                 retX = 0;  
             }  
         }  
         Bitmap bmp = Bitmap.createBitmap(bitmap, retX, retY, nw, nh, null,  
                 false);  
         if (isRecycled && bitmap != null && !bitmap.equals(bmp)  
                 && !bitmap.isRecycled())  
         {  
             bitmap.recycle();  
             bitmap = null;  
         }  
         return bmp;// Bitmap.createBitmap(bitmap, retX, retY, nw, nh, null,  
                     // false);  
     }  
 }  

示例代码：http://download.csdn.net/detail/stop_pig/7162695

上一篇Android中图片Bitmap的缩放
下一篇android 图片Bitmap的旋转

mengzhengjie

关注

1
点赞
踩
4

收藏

觉得还不错? 一键收藏
0
评论
Android 图片Bitmap的剪切

http://blog.csdn.net/stoppig/article/details/23202129版权声明：本文为博主原创文章，未经博主允许不得转载。目录(?)[+]一、什么是Android中的BitmapBitmap是Android系统中的图像处理的最重要类之一。用它可以获取图像文件信息，进行图像剪切、旋转、缩放等操
复制链接

扫一扫