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

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