标签：
图片的裁剪方式有很多种,最常见的有两种吧.
但不管是哪什么类型的裁剪方式,至少需要处理的有以下两个点:
- 图片显示
- 裁剪框显示
裁剪方式的不同在于以上两部分的处理方式不同而不同.
以上两种方式并没很大的差别.但第二种方式可能会更好.因为在裁剪一个比较大的图片时,想更细节地裁剪一部分图片时,第二种方式更容易也更好地做到这一点.
第一种方式(系统默认的)只能是裁剪框缩放,当裁剪的范围很小时,就不容易控制了.
这里我们使用第二种裁剪方式(微信的裁剪方式).
裁剪原理其实在上面裁剪方式中也基本提及了,主要是通过图片或者裁剪框的缩放来确定裁剪的区域.
我们使用微信的裁剪方式,则是通过图片缩放来确定裁剪区域.
这里图片需要完成的操作有移动和缩放.因此我们使用之前处理触摸事件的类进行处理.
AbsTouchEventHandle,触摸事件处理类
TouchUtils,移动与缩放辅助工具类
关于以上两个类的使用,查看相关的文章即可.
关于流程,我们从图片加载开始到图片裁剪结束并保存做一个完整的流程进行分析.
- 图片加载
- 图片绘制
- 裁剪框绘制(裁剪框使用正方形)
- 图片移动或者缩放(从而改变裁剪区域)
- 裁剪图片
- 保存图片
这里我们确定需要使用的一些变量.
//图片来源路径
String inputPath;
//图片输出存放路径
String outputPath;
//裁剪框
RectF mCropRectf;
//图片绘制区域
RectF mBitmapRectf;
//裁剪的源图片
Bitmap mBitmap;图片的加载并没有什么特别的,通过图片的路径inputPath加载出裁剪的源图片即可;
这里需要注意的是,某些情况下,需要裁剪后的图片的质量和大小并不是很高(如头像),这种情况下如果源图片很大的话,加载到内存是很容易导致一些问题的.所以建议:
在不必要的情况下,尽量不要加载源图片进行裁剪,而是加载出适当的缩略图进行裁剪
图片绘制和裁剪框的绘制是一个重点.当然图片的移动与缩放也是重点,但使用之前的两个触摸事件处理类已经处理了这些事件,所以在这里我们并不需要去担心这个问题.
首先,确定图片初始化时绘制的区域.在裁剪中,我们希望达到的效果是:
默认情况下,裁剪的图片全屏显示,并且裁剪框应该居中同时也全屏显示.
因此图片的绘制就很明确了.我们需要全屏显示图片.
全屏显示我们需要获取到当前屏幕的大小.
//存放屏幕宽高大小的全局变量
PointF mViewParmas;
//获取屏幕宽高大小
private void getViewParams() {
if (mIsFirstGetViewParams) {
mViewParams.x = mDrawView.getWidth();
mViewParams.y = mDrawView.getHeight();
}
}其中使用变量mIsFirstGetViewParams检测是因为屏幕的大小不会改变,我们只需要获取一次就够了.避免了反复获取.
获取了屏幕的大小,接下来就是计算图片绘制的区域并绘制图片了.
计算图片的绘制区域是一个比较复杂的过程.因为初始状态图片必须是全屏显示.
事实上我们并不需要去拉伸图片以填充屏幕,我们需要做的只是放大或者缩放图片以适应整个屏幕.
基于这个原则,我们需要考虑图片本身大小与屏幕宽高大小的关系.
由于图片可以缩放,我们现在假设图片与屏幕宽高在同一个等级.则可能有以下情况:
由于图片需要填充屏幕,
当出现某一边主导的情况时,我们需要以该边为基础填充屏幕,剩下的另一边只能是小于屏幕对应边;但我们可以让图片保持居中,这样会看起来更合理正常.
此处的计算方式如下:
//计算最大绘制宽高
//此处不使用屏幕大小是为了四边留空白
float largeDrawWidth = mViewParams.x * 0.9f;
float largeDrawHeight = mViewParams.y * 0.9f;
//获取图片宽高,也作为最终图片绘制的宽高
int width = mBitmap.getWidth();
int height = mBitmap.getHeight();
//以图片高填充屏幕,计算填充的宽度
int tempDrawWidth = (int) ((largeDrawHeight / height) * width);
//以图片宽填充屏幕,计算填充的高度
int tempDrawHeight = (int) ((largeDrawWidth / width) * height);
//若填充宽度小于最大绘制宽度时
if (tempDrawWidth < largeDrawWidth) {
//以高填充(填充后的宽不超过屏幕宽,图片可以完全显示)
width = tempDrawWidth;
height = (int) largeDrawHeight;
} else {
//否则,以宽填充,填充后的高不超过屏幕宽,图片可以完全显示
height = tempDrawHeight;
width = (int) largeDrawWidth;
}
//不存在以下的情况:
//不管以高填充还是宽填充,填充后的另一边都超过屏幕的长度,数学证明略计算完图片的绘制区域后必然是绘制图片了.绘制图片时有一个需要注意的地方就是之前在TouchUtils类的使用中提及的,拖动本身的偏移量处理由TouchUtils类管理,而绘制元素只保持自身的属性.
因此在绘制时需要将偏移量添加到绘制区域中,生成一个实际的(带偏移参数)绘制区域.
//以图片绘制区域为基础创建实际的绘制区域
RectF moveRectf = new RectF(src);
//X/Y添加上偏移量
moveRectf.left += mTouch.getDrawOffsetX();
moveRectf.top += mTouch.getDrawOffsetY();
moveRectf.right += mTouch.getDrawOffsetX();
moveRectf.bottom += mTouch.getDrawOffsetY();
//返回带偏移参数的绘制区域
return moveRectf;首先,裁剪框使用一个RectF对象来保存需要显示可裁剪的区域(透明区域,可以直接显示后面的图片);
关于裁剪框的位置与大小是比较好确定的.
- 裁剪框是正方形
- 裁剪框屏幕居中
- 裁剪框以屏幕最小边为边长
由于前面我们已经得到了图片的绘制区域(默认)的大小,此时图片绘制区域是填充整个屏幕的(严格来说是某一边填充屏幕),其中的mBitmapRectf.width()与mBitmapRectf.height()分别是填充后的图片的宽高的缩放长度(与图片实际的宽高比例是一致的).
因此可以取其中最小的一边作为屏幕裁剪框的边长大小.
//计算绘制区域的最小边,与裁剪区域的大小进行比较
float smallDrawSize = 0;
if (mBitmapRecf.width() > mBitmapRecf.height()) {
smallDrawSize = mBitmapRecf.height();
} else {
smallDrawSize = mBitmapRecf.width();
}
//创建裁剪区域对象
if (mCropRecf == null) {
mCropRecf = new RectF();
}
//以屏幕中心创建裁剪框区域坐标
float centerX = mViewParams.x / 2;
float centerY = mViewParams.y / 2;
mCropRecf.left = centerX - smallDrawSize / 2;
mCropRecf.top = centerY - smallDrawSize / 2;
mCropRecf.right = mCropRecf.left + smallDrawSize;
mCropRecf.bottom =mCropRecf.top + smallDrawSize;这里需要注意的是,使用默认的图片绘制区域的宽/高中最小边作为裁剪框的边长而不是屏幕的最小边作为裁剪框的边长的原因:
可能存在一种情况,图片的宽高比例达到100:1(类似的极致性比例),这种情况下必定以图片的长为填充边,所得的高将很小很小;
如果裁剪以屏幕最小边为边长,则会裁剪到图片以外的区域(不存在数据,根本无法裁剪);
以图片绘制区域最小边确保了裁剪框裁剪的区域必定在图片范围内,也不造成裁剪到图片以外的区域从而导致某些异常
裁剪框的绘制并不是直接绘制裁剪框,因为我们需要保持裁剪区域的透明以明确裁剪的范围.
裁剪框以外的区域使用半透明的黑色覆盖达到表示该部分区域不属于裁剪范围的效果.
因此,绘制裁剪区域实际上是
以半透明黑色绘制裁剪框以外的区域,保持裁剪框的透明以达到裁剪框的效果.
//将裁剪框以外的区域分为四个矩形,并分别计算四个无效区域的坐标
RectF topRecf = new RectF(0, 0, mViewParams.x, mCropRecf.top);
RectF bottomRecf = new RectF(0, mCropRecf.bottom, mViewParams.x, mViewParams.y);
RectF leftRecf = new RectF(0, mCropRecf.top, mCropRecf.left, mCropRecf.bottom);
RectF rightRecf = new RectF(mCropRecf.right, mCropRecf.top, mViewParams.x, mCropRecf.bottom);
//设置半透明画笔并绘制无效区域
mPaint.setColor(Color.BLACK);
mPaint.setAlpha((int) (255 * 0.6));
canvas.drawRect(topRecf, mPaint);
canvas.drawRect(bottomRecf, mPaint);
canvas.drawRect(leftRecf, mPaint);
canvas.drawRect(rightRecf,mPaint);图片的裁剪操作其实就是在图片上指定区域的像素保存下来.因此裁剪一张图片必须保证:
裁剪的区域在图片的有效范围内(不可以超出图片区域)
裁剪的是基于图片本身的像素裁剪,所以需要将裁剪区域缩放到以图片自身大小等级从而确定裁剪区域
由于图片是被缩放过的,对应的裁剪框中的位置也是不是真实图片中的裁剪位置.需要缩放裁剪框从而得到真实的裁剪区域.
计算裁剪框的实际位置时,需要
- 计算裁剪框实际的宽高(裁剪框为正方形,仅计算一边即可)
- 计算裁剪框在真实图片中的位置
//图片实际宽高
int bmpWidth = bitmap.getWidth();
int bmpHeight = bitmap.getHeight();
//图片绘制的区域宽高
float drawWidth = bmpRectF.width();
float drawHeight = bmpRectF.height();
//当前需要裁剪图片区域的宽高
float cropWidth = cropRectF.width();
float cropHeight = cropRectF.height();
//计算实际的裁剪宽高
float realCropWidth = (cropWidth / drawWidth) * bmpWidth;
float realCropHeight = realCropWidth;
//计算实际裁剪区域的坐标
//以当前左上角坐标在缩放图片的相对位置,计算出等比情况下在真实图片中的相对位置
float realCropTop = ((cropRectF.top - bmpRectF.top) / drawHeight) * bmpHeight;
float realCropLeft = ((cropRectF.left - bmpRectF.left) / drawWidth) * bmpWidth;
//创建实际裁剪区域
Rect srcRect = new Rect();
srcRect.top = (int) realCropTop;
srcRect.left = (int) realCropLeft;
srcRect.bottom = srcRect.top + (int) realCropWidth;
srcRect.right = srcRect.left + (int) realCropHeight;
//返回实际的裁剪区域坐标
return srcRect;裁剪图片的很简单,通过系统方法从图片中保存下裁剪区域的像素即可.
//裁剪当前的图片
Bitmap cropBmp = Bitmap.createBitmap(mBitmap, cropRect.left, cropRect.top, cropRect.width(), cropRect.height());图片的保存通过Bitmap提供的方法即可通过流保存到文件中.同时保存时还可以指定输出图片的质量,图片格式.
cropBitmap.compress(Bitmap.CompressFormat.PNG, 50, out);图片的大小由质量.大小及格式决定,压缩率更高,质量越低,图片宽高越小的,图片大小也就越小.
前面使用TouchUtils时已经提到提供了回调接口用于确定是否允许界面移动.往往在实际的操作也功能需求中这是需要限定的条件.
在此处也是需要限定的.
图片的移动不可以超过裁剪框所在的区域.
必须确保任何时候裁剪框都在图片的范围内
否则在裁剪时就可能出现裁剪到图片以外的区域,这会造成某些异常的抛出.
检测方式也很简单,由于裁剪框必须在图片内部,所以保证:
裁剪框的左边界永远在图片的左边界右边;
裁剪框的右边界永远在图片的右边界左边;
裁剪框的上边界永远在图片上边界的下边;
裁剪框的下边界永远在图片下边界的上边;
//此处仅列出 是否允许移动 的回调判断
@Override
public boolean isCanMovedOnX(float moveDistanceX, float newOffsetX) {
float moveDistance = Math.abs(moveDistanceX);
RectF drawRectf = this.getRectfAfterMove(mBitmapRecf);
//moveDistance正负值代表了移动的方向
if (moveDistanceX > 0) {
return moveDistance <= (mCropRecf.left - drawRectf.left);
} else {
return moveDistance <= (drawRectf.right - mCropRecf.right);
}
}
@Override
public boolean isCanMovedOnY(float moveDistacneY, float newOffsetY) {
float moveDistance = Math.abs(moveDistacneY);
RectF drawRectf = this.getRectfAfterMove(mBitmapRecf);
if (moveDistacneY > 0) {
return moveDistance <= (mCropRecf.top - drawRectf.top);
} else {
return moveDistance <= (drawRectf.bottom - mCropRecf.bottom);
}
}图片允许进行缩放,但裁剪框必须在图片内部.而裁剪框大小是固定的(在创建并显示初始图片时已经确定了).
因此图片缩放是有限制的,图片放大可以由用户自定义,此裁剪View中也没有限制;但是缩小的极限是不能小于裁剪框.
图片在缩小时需要保持图片的最小边要永远大于裁剪框,这样才能确保裁剪框内的区域是有效的图片区域.
//获取图片的宽高
float oldWidth = mTempBmpRectF.width();
float oldHeigh = mTempBmpRectF.height();
//计算新缩放的宽高
float newWidth = oldWidth * newScaleRate;
float newHeight = oldHeigh * newScaleRate;
//获取新缩放图片的最短边
float smallSize = newWidth > newHeight ? newHeight : newWidth;
//最短边必须大于裁剪区域的边
//否则不允许缩放
return smallSize >mCropRecf.width();以上是缩放图片时的限制,需要注意的这里使用的绘制区域mTempBmpRectf,实际绘制时使用的变量是mBmpRectf.
此处是TouchUtils中提及的,每次一次缩放时,都会保存缩放前的图片大小,缩放时不断重绘界面使用的是mBmpRectf,此变量值会在缩放期间不断改变.mTempBmpRectf为暂存值,暂存了每一次缩放前图片的大小.在缩放结束之后会保存此次缩放后的大小.(详见TouchUtils)
关于此类的使用方式,后面会有一个专门使用此类进行裁剪图片的Activity详解,在一般情况下只要调用该Activity就可以进行正常的图片裁剪了.
当然不管是此类还是裁剪的Activity,都可以根据自己的需要进行修改.
以下附上简单的使用方式:
//将 CropView 添加到xml界面中
//加载一张图片,略
Bitmap mphoto;
//直接设置图片即可(在onCreate中)
mCropView.setImageBitmap(mphoto);
//若是在其它情况下需要修改图片时,应该手动调用一次重绘操作,裁剪View才会更新界面图片
//mCropView.postInvalidate();
//裁剪并保存当前裁剪框中的图片
//outputPath为裁剪后图片输出路径(完整的文件名哦,不只是文件夹)
//如:/storage/cropBmp.png
mCropView.restoreBitmap(outputPath);
//图片回收
//当裁剪完确定不再需要裁剪时,回收图片,请注意需要不再裁剪并不显示图片时才回收(基本上是 Activity 退出时再回收)
mCropView.recycleBitmap();关于图片的回收工作,其实由于裁剪View中使用的是赋值时图片的引用对象,所以在外部直接回收图片也是可以的.
mPhoto.recycle();
但是CropView中作了安全处理,所以建议还不管有没有回收图片,都进行一次cropView.recycleBitmap();
源码是裁剪工具View的源码.需要注意View本身只是个间接处理对象,仅仅是用于将界面显示给用户.实际的绘制和操作是在内部类CropDrawUtils处理
关于使用的接口并不需要特别关注,只是为了方便View的部分方法与此裁剪处理类的方法签名统一而使用的.
不使用接口的直接删除接口及 @Override 即可
/**
* Created by taro on 16/4/8.
*/
public class CropDraw extends AbsTouchEventHandle implements TouchUtils.IMoveEvent, TouchUtils.IScaleEvent, ICropDrawAction {
//创建工具类
private TouchUtils mTouch = new TouchUtils();
private View mDrawView = null;
public static final float DEFAULT_CROP_WIDTH = 0;
public static final float DEFAULT_CROP_HEIGHT = 0;
private Paint mPaint = null;
private Bitmap mBitmap = null;
private RectF mCropRecf = null;
private RectF mBitmapRecf = null;
private PointF mViewParams = null;
private float mCropWidth = DEFAULT_CROP_WIDTH;
private float mCropHeight = DEFAULT_CROP_HEIGHT;
//暂时性保存的半径(同理在绘制时也需要一个暂时性存放的数据)
private RectF mTempBmpRectF = null;
private boolean mIsFirstGetViewParams = true;
//针对构造函数,可有不同的需求,在此例中,其实并不需要context
//此参数是可有可无的,有时自定义绘制界面需要加载一些资源什么的需要用到context,
//这个时候就有用了,这个看需要
public CropDraw(View drawView) {
this.mDrawView = drawView;
//设置工具类的监听事件
mTouch.setMoveEvent(this);
mTouch.setScaleEvent(this);
//绑定view与触摸事件
this.mDrawView.setOnTouchListener(this);
initial();
}
/**
* 绘制界面
*
* @param canvas
*/
public void onDraw(Canvas canvas) {
getViewParams();
drawBitmap(canvas);
drawCropRecf(canvas);
mPaint.setAlpha(255);
}
@Override
public void setImageBitmap(Bitmap src) {
if (src == null) {
return;
} else {
mBitmap = src;
mBitmapRecf.setEmpty();
mDrawView.postInvalidate();
}
}
/**
* 设置裁剪区域的宽高大小,此方法应该在界面绘制之前调用有效
*
* @param eachSize 边长
* @return
*/
public boolean setCropWidthAndHeight(int eachSize) {
mCropWidth = eachSize;
mCropHeight = eachSize;
//调整裁剪区域宽高大小
//若调整了返回true,否则返回false
//此处返回相反的值是因为:使用指定参数设置成功的话返回true,若调整过了则使用不到参数,返回False
return !isAdjustCropWidthAndHeight();
}
/**
* 初始化数据及对象
*/
private void initial() {
mPaint = new Paint();
mBitmapRecf = new RectF();
mViewParams = new PointF();
this.setIsShowLog(false, null);
}
/**
* 调整裁剪区域的宽高大小
*
* @return
*/
private boolean isAdjustCropWidthAndHeight() {
boolean isChanged = false;
//默认裁剪区域的大小与图片最大边大小相同,都是90%
float largeCropSizeX = mViewParams.x * 0.9f;
float largeCropSizeY = mViewParams.y * 0.9f;
float largeCropSize = largeCropSizeX < largeCropSizeY ? largeCropSizeX : largeCropSizeY;
if (mCropWidth > largeCropSize || mCropWidth <= 0) {
mCropWidth = largeCropSize;
isChanged = true;
}
if (mCropHeight > largeCropSize || mCropHeight <= 0) {
mCropHeight = largeCropSize;
isChanged = true;
}
return isChanged;
}
/**
* 获取当前view的宽高等参数
*/
private void getViewParams() {
if (mIsFirstGetViewParams) {
mViewParams.x = mDrawView.getWidth();
mViewParams.y = mDrawView.getHeight();
}
}
/**
* 绘制图片
*
* @param canvas
* @return
*/
private boolean drawBitmap(Canvas canvas) {
if (mBitmap != null && !mBitmap.isRecycled() && canvas != null) {
//第一次绘制先计算图片的绘制大小
if (mBitmapRecf == null || mBitmapRecf.isEmpty()) {
//计算图片缩放显示的绘制区域
int width = mBitmap.getWidth();
int height = mBitmap.getHeight();
//计算最大绘制区域
//此处不使用屏幕大小是为了四边留空白
float largeDrawWidth = mViewParams.x * 0.9f;
float largeDrawHeight = mViewParams.y * 0.9f;
//以图片高填充屏幕,计算填充的宽度
int tempDrawWidth = (int) ((largeDrawHeight / height) * width);
//以图片宽填充屏幕,计算填充的高度
int tempDrawHeight = (int) ((largeDrawWidth / width) * height);
//若填充宽度小于最大绘制宽度时
if (tempDrawWidth < largeDrawWidth) {
//以高填充(填充后的宽不超过屏幕宽,图片可以完全显示)
width = tempDrawWidth;
height = (int) largeDrawHeight;
} else {
//否则,以宽填充,填充后的高不超过屏幕宽,图片可以完全显示
height = tempDrawHeight;
width = (int) largeDrawWidth;
}
//不存在以下的情况:
//不管以高填充还是宽填充,填充后的另一边都超过屏幕的长度,数学证明略
//创建绘制区域
mBitmapRecf.left = (mViewParams.x - width) / 2;
mBitmapRecf.right = mBitmapRecf.left + width;
mBitmapRecf.top = (mViewParams.y - height) / 2;
mBitmapRecf.bottom = mBitmapRecf.top + height;
//计算绘制区域的最小边,与裁剪区域的大小进行比较
float smallDrawSize = 0;
if (mBitmapRecf.width() > mBitmapRecf.height()) {
smallDrawSize = mBitmapRecf.height();
} else {
smallDrawSize = mBitmapRecf.width();
}
//创建裁剪区域对象
if (mCropRecf == null) {
mCropRecf = new RectF();
}
float centerX = mViewParams.x / 2;
float centerY = mViewParams.y / 2;
mCropRecf.left = centerX - smallDrawSize / 2;
mCropRecf.top = centerY - smallDrawSize / 2;
mCropRecf.right = mCropRecf.left + smallDrawSize;
mCropRecf.bottom = mCropRecf.top + smallDrawSize;
//更新裁剪区域的边大小
mCropWidth = mCropRecf.width();
mCropHeight = mCropRecf.height();
}
canvas.drawBitmap(mBitmap, null, getRectfAfterMove(mBitmapRecf), mPaint);
return true;
} else {
return false;
}
}
/**
* 获取移动后的实际绘制区域
*
* @param src 默认的绘制区域
* @return 返回新的绘制区域对象
*/
private RectF getRectfAfterMove(RectF src) {
if (src != null) {
RectF moveRectf = new RectF(src);
//X/Y添加上偏移量
moveRectf.left += mTouch.getDrawOffsetX();
moveRectf.top += mTouch.getDrawOffsetY();
moveRectf.right += mTouch.getDrawOffsetX();
moveRectf.bottom += mTouch.getDrawOffsetY();
return moveRectf;
} else {
return null;
}
}
/**
* 获取当前裁剪图片区域在实际图片中的裁剪区域
*
* @param bitmap 原始图片对象
* @param cropRectF 当前裁剪区域
* @param bmpRectF 图片绘制区域
* @return 返回实际图片中的裁剪区域大小
*/
private Rect getBitmapScaleRect(Bitmap bitmap, RectF cropRectF, RectF bmpRectF) {
//图片存在且相应的区域都有效的情况下才能进行计算
if (bitmap != null && cropRectF != null && bmpRectF != null) {
//图片实际宽高
int bmpWidth = bitmap.getWidth();
int bmpHeight = bitmap.getHeight();
//图片绘制的区域宽高
float drawWidth = bmpRectF.width();
float drawHeight = bmpRectF.height();
//当前需要裁剪图片区域的宽高
float cropWidth = cropRectF.width();
float cropHeight = cropRectF.height();
//计算实际的裁剪宽高
float realCropWidth = (cropWidth / drawWidth) * bmpWidth;
float realCropHeight = realCropWidth;
//计算实际裁剪区域的坐标
float realCropTop = ((cropRectF.top - bmpRectF.top) / drawHeight) * bmpHeight;
float realCropLeft = ((cropRectF.left - bmpRectF.left) / drawWidth) * bmpWidth;
//创建实际裁剪区域
Rect srcRect = new Rect();
srcRect.top = (int) realCropTop;
srcRect.left = (int) realCropLeft;
srcRect.bottom = srcRect.top + (int) realCropWidth;
srcRect.right = srcRect.left + (int) realCropHeight;
return srcRect;
} else {
return null;
}
}
@Override
public boolean restoreBitmap(String filePath, boolean isRecycleBmp) {
if (!TextUtils.isEmpty(filePath) && !mBitmap.isRecycled()) {
//获取图片裁剪区域
Rect srcRect = getBitmapScaleRect(mBitmap, mCropRecf, getRectfAfterMove(mBitmapRecf));
//裁剪当前的图片
Bitmap cropBmp = Bitmap.createBitmap(mBitmap, srcRect.left, srcRect.top, srcRect.width(), srcRect.height());
try {
File bitmapFile = new File(filePath);
if (!bitmapFile.exists()) {
bitmapFile.createNewFile();
}
//将图片保存到文件中
FileOutputStream out = new FileOutputStream(bitmapFile);
cropBmp.compress(Bitmap.CompressFormat.PNG, 50, out);
if (isRecycleBmp) {
//回收图片
mBitmap.recycle();
}
return true;
} catch (FileNotFoundException e) {
e.printStackTrace();
return false;
} catch (IOException e) {
e.printStackTrace();
return false;
} finally {
//不管是否裁剪成功,都回收裁剪后的图片,因为这部分是用不到的
if (cropBmp != null && !cropBmp.isRecycled()) {
cropBmp.recycle();
}
}
} else {
return false;
}
}
@Override
public void recycleBitmap() {
if (mBitmap != null && !mBitmap.isRecycled()) {
mBitmap.recycle();
}
}
/**
* 绘制图片裁剪界面,实际上只是绘制一个透明的蒙层
*
* @param canvas
* @return
*/
private boolean drawCropRecf(Canvas canvas) {
if (canvas != null) {
RectF topRecf = new RectF(0, 0, mViewParams.x, mCropRecf.top);
RectF bottomRecf = new RectF(0, mCropRecf.bottom, mViewParams.x, mViewParams.y);
RectF leftRecf = new RectF(0, mCropRecf.top, mCropRecf.left, mCropRecf.bottom);
RectF rightRecf = new RectF(mCropRecf.right, mCropRecf.top, mViewParams.x, mCropRecf.bottom);
mPaint.setColor(Color.BLACK);
mPaint.setAlpha((int) (255 * 0.6));
canvas.drawRect(topRecf, mPaint);
canvas.drawRect(bottomRecf, mPaint);
canvas.drawRect(leftRecf, mPaint);
canvas.drawRect(rightRecf, mPaint);
return true;
} else {
return false;
}
}
@Override
public void onSingleTouchEventHandle(MotionEvent event, int extraMotionEvent) {
//工具类默认处理的单点触摸事件
mTouch.singleTouchEvent(event, extraMotionEvent);
}
@Override
public void onMultiTouchEventHandle(MotionEvent event, int extraMotionEvent) {
//工具类默认处理的多点(实际只处理了两点事件)触摸事件
mTouch.multiTouchEvent(event, extraMotionEvent);
}
@Override
public void onSingleClickByTime(MotionEvent event) {
//基于时间的单击事件
//按下与抬起时间不超过500ms
}
@Override
public void onSingleClickByDistance(MotionEvent event) {
//基于距离的单击事件
//按下与抬起的距离不超过20像素(与时间无关，若按下不动几小时后再放开只要距离在范围内都可以触发)
}
@Override
public void onDoubleClickByTime() {
//基于时间的双击事件
//单击事件基于clickByTime的两次单击
//两次单击之间的时间不超过250ms
}
@Override
public boolean isCanMovedOnX(float moveDistanceX, float newOffsetX) {
float moveDistance = Math.abs(moveDistanceX);
RectF drawRectf = this.getRectfAfterMove(mBitmapRecf);
if (moveDistanceX > 0) {
return moveDistance <= (mCropRecf.left - drawRectf.left);
} else {
return moveDistance <= (drawRectf.right - mCropRecf.right);
}
}
@Override
public boolean isCanMovedOnY(float moveDistacneY, float newOffsetY) {
float moveDistance = Math.abs(moveDistacneY);
RectF drawRectf = this.getRectfAfterMove(mBitmapRecf);
if (moveDistacneY > 0) {
return moveDistance <= (mCropRecf.top - drawRectf.top);
} else {
return moveDistance <= (drawRectf.bottom - mCropRecf.bottom);
}
}
@Override
public void onMove(int suggestEventAction) {
mDrawView.postInvalidate();
}
@Override
public void onMoveFail(int suggetEventAction) {
}
@Override
public boolean isCanScale(float newScaleRate) {
if (mTempBmpRectF == null) {
mTempBmpRectF = new RectF(mBitmapRecf);
}
float oldWidth = mTempBmpRectF.width();
float oldHeigh = mTempBmpRectF.height();
float newWidth = oldWidth * newScaleRate;
float newHeight = oldHeigh * newScaleRate;
//获取绘制区域的最短边
float smallSize = newWidth > newHeight ? newHeight : newWidth;
//最短边必须大于裁剪区域的边
return smallSize > mCropRecf.width();
}
@Override
public void setScaleRate(float newScaleRate, boolean isNeedStoreValue) {
//更新当前的数据
//newScaleRate缩放比例一直是相对于按下时的界面的相对比例,所以在移动过程中
//每一次都是要与按下时的界面进行比例缩放,而不是针对上一次的结果
//使用这种方式一方面在缩放时的思路处理是比较清晰的
//另一方面是缩放的比例不会数据很小(若相对于上一次,每一次move移动几个像素,
//这种情况下缩放的比例相对上一次肯定是0.0XXXX,数据量一小很容易出现一些不必要的问题)
if (mTempBmpRectF == null) {
mTempBmpRectF = new RectF(mBitmapRecf);
}
float lastWidth = mTempBmpRectF.width();
float lastHeight = mTempBmpRectF.height();
float newWidth = lastWidth * newScaleRate;
float newHeight = lastHeight * newScaleRate;
mBitmapRecf.left = mTempBmpRectF.centerX() - newWidth / 2;
mBitmapRecf.top = mTempBmpRectF.centerY() - newHeight / 2;
mBitmapRecf.right = mBitmapRecf.left + newWidth;
mBitmapRecf.bottom = mBitmapRecf.top + newHeight;
//当返回的标志为true时,提醒为已经到了up事件
//此时应该把最后一次缩放的比例当做最终的数据保存下来
if (isNeedStoreValue) {
mTempBmpRectF.set(mBitmapRecf);
}
}
@Override
public void onScale(int suggestEventAction) {
if (suggestEventAction == MotionEvent.ACTION_POINTER_UP) {
//调整缩放后图片的位置必须在裁剪框中
RectF drawRectf = this.getRectfAfterMove(mBitmapRecf);
float offsetX = mTouch.getDrawOffsetX();
float offsetY = mTouch.getDrawOffsetY();
if (drawRectf.left > mCropRecf.left) {
offsetX += mCropRecf.left - drawRectf.left;
}
if (drawRectf.top > mCropRecf.top) {
offsetY += mCropRecf.top - drawRectf.top;
}
if (drawRectf.right < mCropRecf.right) {
offsetX += mCropRecf.right - drawRectf.right;
}
if (drawRectf.bottom < mCropRecf.bottom) {
offsetY += mCropRecf.bottom - drawRectf.bottom;
}
mTouch.setOffsetX(offsetX);
mTouch.setOffsetY(offsetY);
}
mDrawView.postInvalidate();
}
@Override
public void onScaleFail(int suggetEventAction) {
}
}/**
* Created by taro on 16/1/22.
*/
public class CropView extends View implements ICropDrawAction {
private CropDraw mCropDraw = null;
public CropView(Context context, AttributeSet attrs, int defStyleAttr) {
super(context, attrs, defStyleAttr);
initial();
}
public CropView(Context context) {
super(context);
initial();
}
public CropView(Context context, AttributeSet attrs) {
super(context, attrs);
initial();
}
/**
* 初始化
*/
private void initial() {
mCropDraw = new CropDraw(this);
}
@Override
public void setImageBitmap(Bitmap src) {
mCropDraw.setImageBitmap(src);
}
@Override
public boolean setCropWidthAndHeight(int width) {
return mCropDraw.setCropWidthAndHeight(width);
}
@Override
public boolean restoreBitmap(String filePath, boolean isRecycleBitmap) {
return mCropDraw.restoreBitmap(filePath, isRecycleBitmap);
}
@Override
public void recycleBitmap() {
mCropDraw.recycleBitmap();
}
@Override
protected void onDraw(Canvas canvas) {
mCropDraw.onDraw(canvas);
}
}另附上接口文件
/**
* Created by taro on 16/4/8.
*/
public interface ICropDrawAction {
/**
* 保存图片
*
* @param filePath 保存路径
* @param isRecycleBmp 是否回收图片,若true则回收图片,若false则不回收图片
* @return
*/
public boolean restoreBitmap(String filePath, boolean isRecycleBmp);
/**
* 回收图片
*/
public void recycleBitmap();
/**
* 设置裁剪区域的宽高大小,此方法应该在界面绘制之前调用有效
*
* @param eachSize 边长
* @return
*/
public boolean setCropWidthAndHeight(int eachSize);
/**
* 设置imageBitmap
*
* @param src
*/
public void setImageBitmap(Bitmap src);
}
以上为裁剪View的代码,项目中CropView是使用于Activity中,后面会详细说明该Activity并附带简单的图片辅助功能.
Android触摸事件(四)-CropView裁剪工具的使用
标签：
原文地址：http://blog.csdn.net/u011374875/article/details/51117902
