android 利用canvas自由裁剪图片小工具

最新推荐文章于 2024-09-04 07:07:51 发布
最新推荐文章于 2024-09-04 07:07:51 发布
阅读量1.8k 收藏 2
点赞数 1
分类专栏： 图片 文章标签： android 图片 canvas

原文在这里哦~http://www.cnblogs.com/rossoneri/p/3988405.html

因为有个安卓项目需要用到图片裁剪的工具，所以上网查找了一下，发现这个博主写的还不错，但是就是博主太懒了233333，没有写注释，所以我就用了他的代码，理解了代码精髓部分，把我所了解到的代码写了注释，希望帮到大家哦~

原博主写的时可以运行的，但是因为它时原图显示的，太大了，所以我将博主写的一些方法给改了一下，将图片压缩到我想要的大小进行展示和裁剪，另外，原博主写的这个小工具中有个小问题，就是不能将裁剪框拉到最大，不然很容易就会报错，我也进行了一番修改啊，啊哈哈哈

来，上代码：

布局

将这段代码放到你想放的位置就可以啦，这个大小并非时图片显示的大小，但是要给足够的大小来显示图片，不然图片就会被“吃掉啦”。

<?xml version="1.0" encoding="utf-8"?>
<ScrollView xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    android:id="@+id/scrollview"
  >
<FrameLayout
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:layout_marginTop="270dp"
    android:layout_marginLeft="300dp"
    >
    <com.example.suxiaofang.view.MyCropView
        android:id="@+id/myCropView"
        android:layout_width="500dp"
        android:layout_height="200dp"
        />

</FrameLayout>
</ScrollView>

裁剪的代码

import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Matrix;
import android.graphics.Paint;
import android.graphics.Paint.Style;
import android.graphics.PointF;
import android.graphics.RectF;
import android.util.AttributeSet;
import android.util.Log;
import android.view.MotionEvent;
import android.view.View;
public class MyCropView extends View {
    private static final float BMP_LEFT = 0f;
    private static final float BMP_TOP = 20f;

    private static final float DEFAULT_BORDER_RECT_WIDTH = 100f;
    private static final float DEFAULT_BORDER_RECT_HEIGHT = 100f;

    private static final int POS_TOP_LEFT = 0;
    private static final int POS_TOP_RIGHT = 1;
    private static final int POS_BOTTOM_LEFT = 2;
    private static final int POS_BOTTOM_RIGHT = 3;
    private static final int POS_TOP = 4;
    private static final int POS_BOTTOM = 5;
    private static final int POS_LEFT = 6;
    private static final int POS_RIGHT = 7;
    private static final int POS_CENTER = 8;

    private static final float BORDER_LINE_WIDTH = 6f;
    private static final float BORDER_CORNER_LENGTH = 30f;
    private static final float TOUCH_FIELD = 10f;

    //图片路径
    private String mBmpPath;
    //图片（原图大小）
    private Bitmap mBmpToCrop, currentBmp;
    //经过缩小的图片
    private RectF mBmpBound;
    //画笔
    private Paint mBmpPaint;
    // 裁剪区边框（伸缩框）的笔
    private Paint mBorderPaint;
    private Paint mGuidelinePaint;
    private Paint mCornerPaint;
    private Paint mBgPaint;

    private RectF mDefaultBorderBound;
    private RectF mBorderBound;

    private PointF mLastPoint = new PointF();

    private float mBorderWidth;
    private float mBorderHeight;

    private int touchPos;


    public MyCropView(Context context) {
        super(context);
        // TODO Auto-generated constructor stub
        init(context);
    }

    public MyCropView(Context context, AttributeSet attrs) {
        super(context, attrs);
        init(context);
    }


    @Override
    protected void onSizeChanged(int w, int h, int oldw, int oldh) {
        // TODO Auto-generated method stub
        // super.onSizeChanged(w, h, oldw, oldh);
    }

    //Canvas 画布
    @Override
    protected void onDraw(Canvas canvas) {
        // TODO Auto-generated method stub
        // super.onDraw(canvas);
        if (mBmpPath != null) {
            //
            canvas.drawBitmap(mBmpToCrop, null, mBmpBound, mBmpPaint);
            //将画布变成方形
            canvas.drawRect(mBorderBound.left, mBorderBound.top, mBorderBound.right, mBorderBound.bottom, mBorderPaint);
            drawGuidlines(canvas);
            drawBackground(canvas);
        }
    }

    //识别裁剪框的伸缩位置
    @Override
    public boolean onTouchEvent(MotionEvent event) {
        // TODO Auto-generated method stub
        // super.onTouchEvent(event);
        switch (event.getAction()) {
            case MotionEvent.ACTION_DOWN:
                setLastPosition(event);
                getParent().requestDisallowInterceptTouchEvent(true);
                // onActionDown(event.getX(), event.getY());
                touchPos = detectTouchPosition(event.getX(), event.getY());
                break;
            case MotionEvent.ACTION_MOVE:
                onActionMove(event.getX(), event.getY());
                setLastPosition(event);
                break;
            case MotionEvent.ACTION_UP:
                break;
        }

        return true;
    }

    public String getBmpPath() {
        return mBmpPath;
    }

    public void setBmpPath(String picPath) {
        this.mBmpPath = picPath;
        setBmp();
    }

    //缩小原图bitmap，将传来的大小不一致的图片缩小成规定大小
    private static Bitmap smallBitmap(Bitmap bitmap) {
        Matrix matrix = new Matrix();
        //将原图片按照一定的大小比例缩小
        matrix.postScale(0.3f, 0.2f);
        Bitmap resizeBmp = Bitmap.createBitmap(bitmap, 0, 0, bitmap.getWidth(), bitmap.getHeight(), matrix, true);
        return resizeBmp;
    }


    //得到经过裁剪的图片
    public Bitmap getCroppedImage() {
        Bitmap b = MyCropView.smallBitmap(mBmpToCrop);
        return Bitmap.createBitmap(b, (int) mBorderBound.left, (int) mBorderBound.top, (int) mBorderWidth,
                (int) mBorderHeight);
    }


    //初始化，对各类画笔的初始化
    private void init(Context context) {

        mBmpPaint = new Paint();
        // 以下是抗锯齿
        mBmpPaint.setAntiAlias(true);// 防止边缘的锯齿
        mBmpPaint.setFilterBitmap(true);// 对位图进行滤波处理

        mBorderPaint = new Paint();
        mBorderPaint.setStyle(Style.STROKE);
        mBorderPaint.setColor(Color.parseColor("#AAFFFFFF"));
        mBorderPaint.setStrokeWidth(BORDER_LINE_WIDTH);

        mGuidelinePaint = new Paint();
        mGuidelinePaint.setColor(Color.parseColor("#AAFFFFFF"));
        mGuidelinePaint.setStrokeWidth(1f);

        mCornerPaint = new Paint();

        mBgPaint = new Paint();
        mBgPaint.setColor(Color.parseColor("#B0000000"));
        mBgPaint.setAlpha(150);

    }

    //将要裁剪的图片放置到com.example.suxiaofang.view.MyCropView组件的布局里面，这里需要足够的耐心调哦
    private void setBmp() {
       //这个是原图
        mBmpToCrop = BitmapFactory.decodeFile(mBmpPath);
        //这个就是经过缩小的图片
        currentBmp = MyCropView.smallBitmap(mBmpToCrop);

        //接下来都是设置原图显示的大小
        mBmpBound = new RectF();
        //图片左边距离com.example.suxiaofang.view.MyCropView组件左边边的距离
        mBmpBound.left = BMP_LEFT;
        //图片的上边距离com.example.suxiaofang.view.MyCropView组件上边边的距离
        mBmpBound.top = BMP_TOP;
        //图片的右边距离com.example.suxiaofang.view.MyCropView组件左边边的距离
        mBmpBound.right = currentBmp.getWidth();
        //图片的下边距离com.example.suxiaofang.view.MyCropView组件上边边的距离
        mBmpBound.bottom = currentBmp.getHeight();

        // 使裁剪框一开始出现在图片内自设定的位置，如果裁剪框不在被裁剪的图片内，容易报错
        //其实这也是设定裁剪框的大小
        mDefaultBorderBound = new RectF();
        mDefaultBorderBound.left = (mBmpBound.left + mBmpBound.right) / 3;
        mDefaultBorderBound.top = (mBmpBound.top + mBmpBound.bottom) / 4;
        mDefaultBorderBound.right = mDefaultBorderBound.left + DEFAULT_BORDER_RECT_WIDTH;
        mDefaultBorderBound.bottom = mDefaultBorderBound.top + DEFAULT_BORDER_RECT_HEIGHT;

        mBorderBound = new RectF();
        mBorderBound.left = mDefaultBorderBound.left;
        mBorderBound.top = mDefaultBorderBound.top;
        mBorderBound.right = mDefaultBorderBound.right;
        mBorderBound.bottom = mDefaultBorderBound.bottom;

        getBorderEdgeLength();
        invalidate();
    }

    private void drawBackground(Canvas canvas) {

        /*-
          -------------------------------------
          |                top                |
          -------------------------------------
          |      |                    |       |<——————————mBmpBound
          |      |                    |       |
          | left |                    | right |
          |      |                    |       |
          |      |                  <─┼───────┼────mBorderBound
          -------------------------------------
          |              bottom               |
          -------------------------------------
         */

        // Draw "top", "bottom", "left", then "right" quadrants.
        // because the border line width is larger than 1f, in order to draw a complete border rect ,
        // i have to change zhe rect coordinate to draw
        float delta = BORDER_LINE_WIDTH / 2;
        float left = mBorderBound.left - delta;
        float top = mBorderBound.top - delta;
        float right = mBorderBound.right + delta;
        float bottom = mBorderBound.bottom + delta;

        // -------------------------------------------------------------------------------移动到上下两端会多出来阴影
        canvas.drawRect(mBmpBound.left, mBmpBound.top, mBmpBound.right, top, mBgPaint);
        canvas.drawRect(mBmpBound.left, bottom, mBmpBound.right, mBmpBound.bottom, mBgPaint);
        canvas.drawRect(mBmpBound.left, top, left, bottom, mBgPaint);
        canvas.drawRect(right, top, mBmpBound.right, bottom, mBgPaint);
    }

    // 画裁剪区域中间的参考线
    private void drawGuidlines(Canvas canvas) {
        // Draw vertical guidelines.
        final float oneThirdCropWidth = mBorderBound.width() / 3;

        final float x1 = mBorderBound.left + oneThirdCropWidth;
        canvas.drawLine(x1, mBorderBound.top, x1, mBorderBound.bottom, mGuidelinePaint);
        final float x2 = mBorderBound.right - oneThirdCropWidth;
        canvas.drawLine(x2, mBorderBound.top, x2, mBorderBound.bottom, mGuidelinePaint);

        // Draw horizontal guidelines.
        final float oneThirdCropHeight = mBorderBound.height() / 3;

        final float y1 = mBorderBound.top + oneThirdCropHeight;
        canvas.drawLine(mBorderBound.left, y1, mBorderBound.right, y1, mGuidelinePaint);
        final float y2 = mBorderBound.bottom - oneThirdCropHeight;
        canvas.drawLine(mBorderBound.left, y2, mBorderBound.right, y2, mGuidelinePaint);
    }

    private void onActionDown(float x, float y) {

    }

    //移动裁剪框时定位到的位置大小
    private void onActionMove(float x, float y) {
        Log.e("mBmpBound.right~~~~~~~", String.valueOf(mBmpBound.right));
        Log.e("(mBorderBound.right~~~~~~~", String.valueOf(mBorderBound.right));
        float deltaX = x - mLastPoint.x;
        float deltaY = y - mLastPoint.y;
        // 这里先不考虑裁剪框放最大的情况【这个就是原博主没有考虑到将裁剪框放置到最大】
        switch (touchPos) {
            case POS_CENTER:
                mBorderBound.left += deltaX;
                // fix border position
                if (mBorderBound.left < mBmpBound.left) {
                    mBorderBound.left = mBmpBound.left;
                }

                if ((mBorderBound.left > mBmpBound.right - mBorderWidth) || (mBorderBound.left == mBmpBound.right - mBorderWidth)) {
                    mBorderBound.left = mBmpBound.right - mBorderWidth;
                }


                mBorderBound.top += deltaY;
                if (mBorderBound.top < mBmpBound.top)
                    mBorderBound.top = mBmpBound.top;

                if (mBorderBound.top > mBmpBound.bottom - mBorderHeight)
                    mBorderBound.top = mBmpBound.bottom - mBorderHeight;

                mBorderBound.right = mBorderBound.left + mBorderWidth;
                mBorderBound.bottom = mBorderBound.top + mBorderHeight;

                break;

            case POS_TOP:
                resetTop(deltaY);
                break;
            case POS_BOTTOM:
                resetBottom(deltaY);
                break;
            case POS_LEFT:
                resetLeft(deltaX);
                break;
            case POS_RIGHT:
                resetRight(deltaX);
                break;
            case POS_TOP_LEFT:
                resetTop(deltaY);
                resetLeft(deltaX);
                break;
            case POS_TOP_RIGHT:
                resetTop(deltaY);
                resetRight(deltaX);
                break;
            case POS_BOTTOM_LEFT:
                resetBottom(deltaY);
                resetLeft(deltaX);
                break;
            case POS_BOTTOM_RIGHT:
                resetBottom(deltaY);
                resetRight(deltaX);
                break;
            default:

                break;
        }
        invalidate();
    }

    private void onActionUp(float x, float y) {

    }

    private int detectTouchPosition(float x, float y) {
        if (x > mBorderBound.left + TOUCH_FIELD && x < mBorderBound.right - TOUCH_FIELD
                && y > mBorderBound.top + TOUCH_FIELD && y < mBorderBound.bottom - TOUCH_FIELD)
            return POS_CENTER;

        if (x > mBorderBound.left + BORDER_CORNER_LENGTH && x < mBorderBound.right - BORDER_CORNER_LENGTH) {
            if (y > mBorderBound.top - TOUCH_FIELD && y < mBorderBound.top + TOUCH_FIELD)
                return POS_TOP;
            if (y > mBorderBound.bottom - TOUCH_FIELD && y < mBorderBound.bottom + TOUCH_FIELD)
                return POS_BOTTOM;
        }

        if (y > mBorderBound.top + BORDER_CORNER_LENGTH && y < mBorderBound.bottom - BORDER_CORNER_LENGTH) {
            if (x > mBorderBound.left - TOUCH_FIELD && x < mBorderBound.left + TOUCH_FIELD)
                return POS_LEFT;
            if (x > mBorderBound.right - TOUCH_FIELD && x < mBorderBound.right + TOUCH_FIELD)
                return POS_RIGHT;
        }

        // 前面的逻辑已经排除掉了几种情况 所以后面的 ┏ ┓ ┗ ┛ 边角就按照所占区域的方形来判断就可以了
        if (x > mBorderBound.left - TOUCH_FIELD && x < mBorderBound.left + BORDER_CORNER_LENGTH) {
            if (y > mBorderBound.top - TOUCH_FIELD && y < mBorderBound.top + BORDER_CORNER_LENGTH)
                return POS_TOP_LEFT;
            if (y > mBorderBound.bottom - BORDER_CORNER_LENGTH && y < mBorderBound.bottom + TOUCH_FIELD)
                return POS_BOTTOM_LEFT;
        }

        if (x > mBorderBound.right - BORDER_CORNER_LENGTH && x < mBorderBound.right + TOUCH_FIELD) {
            if (y > mBorderBound.top - TOUCH_FIELD && y < mBorderBound.top + BORDER_CORNER_LENGTH)
                return POS_TOP_RIGHT;
            if (y > mBorderBound.bottom - BORDER_CORNER_LENGTH && y < mBorderBound.bottom + TOUCH_FIELD)
                return POS_BOTTOM_RIGHT;
        }

        return -1;
    }

    private void setLastPosition(MotionEvent event) {
        mLastPoint.x = event.getX();
        mLastPoint.y = event.getY();
    }

    private void getBorderEdgeLength() {
        mBorderWidth = mBorderBound.width();
        mBorderHeight = mBorderBound.height();

    }
//接下来，这里的设置可以让裁剪框拉伸到最大而且不报错哦
    /**
     * 这里设置的是mBorderWidth（裁剪框的宽度），但是会出现将裁剪框左右拉到最大的时候，会出现裁剪框上的白边有些超出图片，所以会出现mBorderWidth>mBmpBound.width而报错，
     * 所以设置一下的if条件来设置当左右拉伸为最大时，裁剪框的宽度和图片宽度一致
     */

    private void getBorderEdgeWidth() {
        mBorderWidth = mBorderBound.width();
        if (mBorderWidth > mBmpBound.width()) {
            mBorderWidth = mBmpBound.width();
        }
    }
    /**
     * 这里设置的是mBorderHeight（裁剪框的高度），但是会出现将裁剪框上下拉到最大的时候，会出现裁剪框上的白边有些超出图片，所以会出现mBorderHeight>mBmpBound.height()而报错，
     * 所以设置一下的if条件来设置当上下拉伸为最大时，裁剪框的高度和图片高度一致
     */
    private void getBorderEdgeHeight() {
        mBorderHeight = mBorderBound.height();
        if (mBorderHeight > mBmpBound.height()) {
            mBorderHeight = mBmpBound.height();
        }
    }

    private void resetLeft(float delta) {
        mBorderBound.left += delta;
        getBorderEdgeWidth();
        fixBorderLeft();
    }

    private void resetTop(float delta) {
        mBorderBound.top += delta;
        getBorderEdgeHeight();
        fixBorderTop();
    }

    private void resetRight(float delta) {
        //这句话，如果注销，就不能够左右伸缩裁剪框，只能上下伸缩
        mBorderBound.right += delta;
        getBorderEdgeWidth();
        fixBorderRight();

    }

    private void resetBottom(float delta) {
        //这句话，如果注销，就不能够上下伸缩裁剪框，只能左右伸缩
        mBorderBound.bottom += delta;
        getBorderEdgeHeight();
        fixBorderBottom();
    }

    private void fixBorderLeft() {
        // fix left
        if (mBorderBound.left < mBmpBound.left)
            mBorderBound.left = mBmpBound.left;
        if (mBorderWidth < 2 * BORDER_CORNER_LENGTH)
            mBorderBound.left = mBorderBound.right - 2 * BORDER_CORNER_LENGTH;
    }

    private void fixBorderTop() {
        // fix top
        if (mBorderBound.top < mBmpBound.top)
            mBorderBound.top = mBmpBound.top;
        if (mBorderHeight < 2 * BORDER_CORNER_LENGTH)
            mBorderBound.top = mBorderBound.bottom - 2 * BORDER_CORNER_LENGTH;
    }

    private void fixBorderRight() {
        // fix right
        if (mBorderBound.right > mBmpBound.right) {

            mBorderBound.right = mBmpBound.right;
        }

        if (mBorderWidth < 2 * BORDER_CORNER_LENGTH) {
            mBorderBound.right = mBorderBound.left + 2 * BORDER_CORNER_LENGTH;
        }

    }

    private void fixBorderBottom() {
        // fix bottom
        if (mBorderBound.bottom > mBmpBound.bottom)
            mBorderBound.bottom = mBmpBound.bottom;
        if (mBorderHeight < 2 * BORDER_CORNER_LENGTH)
            mBorderBound.bottom = mBorderBound.top + 2 * BORDER_CORNER_LENGTH;
    }
}

最终得到裁剪图片

//将图片路径传进去
 myCropView.setBmpPath(path);


//得到的是裁剪后的图片
 Bitmap croppedImage = myCropView.getCroppedImage();


//大家记得在得到裁剪图片的那个方法里面写上这段代码哦
 sv = (ScrollView) findViewById(R.id.scrollview);

   //移动或变化 裁剪窗口  和  scrollview不冲突，这个写在onCreate方法里面的哦
        sv.setOnTouchListener(new View.OnTouchListener() {

            @Override
            public boolean onTouch(View v, MotionEvent event) {
                // TODO Auto-generated method stub
                myCropView.getParent().requestDisallowInterceptTouchEvent(false);
                return false;
            }
        });

@Override
    public boolean onCreateOptionsMenu(Menu menu) {
        // Inflate the menu; this adds items to the action bar if it is present.
        getMenuInflater().inflate(R.menu.menu_main, menu);
        return true;
    }

附上两张图：

这个就是刚运行起来的样子哦~
这里写图片描述

这个就是拉伸到最大的样子，用原博主的会报异常哦，但是经过我的修改，现在不会啦
这里写图片描述

哈哈哈，大家可能发现了，怎么还是有一部分代码没有写注释呢，额。。这个嘛，因为本人比较懒而且笨哦，所以只注释了我需要的，其他的代码嘛，就有劳各位聪明人去明白啦~
哦~，对了，大家可以看看这个来帮助理解canvas
http://blog.csdn.net/iispring/article/details/49770651#comments

撤啦，bye~

androidla~
关注
专栏目录
炫酷的小红书图片裁剪控件
01-02
这个"炫酷的小红书图片裁剪控件"便是其中的一个关键组件，它允许用户根据需要自由调整图片尺寸，以适应平台的展示需求或者个人审美。 图片裁剪控件在IT领域涉及到的知识点主要包括以下几个方面： 1. 图像处理：...
android 利用canvas 获取裁切或者合并后的bitmap对象
zs20082012的博客
12-05 2176
1  图片裁切     备注：创建图片还是很耗内存的，所以不论是图片的和平还是裁切都比较耗内存，利用canvas还是可以以节       约内存的方式实现        mBitWidth 为原图宽度，mBitheight为原图高度        mSrcbmp = bitmap;  //原图bitmap对象        mBitWidth = mSrcbmp.getWidth();
Android实现对图片的缩放、剪切、旋转、存储
qq_25330791的博客
04-06 1595
Bitmap
Android 图片选择与裁剪教程
最新发布
gitblog_00465的博客
09-04 834
Android 图片选择与裁剪教程 Android-Image-Picker-and-CroppingAndroid choosing image from camera or gallery with Crop functionality项目地址:https://gitcode.com/gh_mirrors/an/Android-Image-Picker-and-Cropping 项目介绍 A...
web功能实例 - Canvas裁剪工具
本郡主是喵
12-25 1104
嗯,手撸官方文档2天，发现没啥用，尤其是动画,那种计算出来的，根本想不到。因此学着学了抱着要做个东西的想法,去网上找相关案例,最终做出了这个裁剪工具。针对部分核心功能进行思路讲解。
【canvas】canvas的综合运用：图片裁剪
qq_2511276124的博客
04-12 2408
使用canvas实现图片裁剪功能。有一些边界情况要处理。例如，裁剪框边界情况，图片过小缩放后模糊情况等。
[前端javascript] canvas 学习笔记，实现图片剪裁
qq_31894095的博客
07-21 299
/ 替换为你要剪裁的图像的URL。记得根据实际需求替换代码中的图像URL、剪裁区域的坐标和尺寸，以及处理剪裁后图像的方式。
Canvas中的裁剪师讲解与实战——Android高级UI，字节跳动面试官
2401_84152317的博客
04-07 427
的公有方法，用于裁剪画布的内容。我们抽取比较好玩的参数类型为Path的方法来分享，其余的都可以一一映射进来。的画布区域，而处于path范围之内的则不显示。上一小节我们已经了解了这几些API的作用就是裁剪，这小节我们就把它使用起来。，换而言之，我们可以使用以下代码代替，解决在API26 以下无法使用的问题。从画布中将此路径之外的区域 “裁剪” 下来，最后为了我们观察，使用。从画布中将此路径内的区域 “裁剪” 下来，最后为了我们观察，使用。的画布区域，而处于path范围之外的则不显示。
仿微信图片编辑涂鸦、马赛克、裁剪
06-27
其中，微信的图片编辑功能尤其受到用户喜爱，特别是涂鸦、马赛克和裁剪等工具，使得用户可以方便地对图片进行个性化处理。下面将详细探讨这些功能的实现原理和相关知识点。 1. 图片编辑基础 在图像处理领域，编辑...
Android应用源码之(Canvas画布).zip
12-17
- 自定义View：在自定义View时，我们常常重写`onDraw()`方法，利用Canvas进行绘制。 - 图形编辑器：例如涂鸦应用，用户可以自由绘制图形。 - 动画制作：通过在连续的帧上改变Canvas的绘图内容，可以实现动画效果...
Android应用源码之100种图片处理效果大全项目.zip
09-04
应用中可能会有裁剪图片的需求，这需要利用Bitmap的createBitmap方法创建新的Bitmap，并使用Canvas进行绘制。Android也提供了CropImageActivity，简化了裁剪界面的实现。 4. **滤镜效果**： 在源码中，可能会有...
android_canvas的裁剪功能
07-29
Region.Op.DIFFERENCE 显示第一次不同于第二次的部分 Region.Op.REVERSE_DIFFERENCE 显示第二次不同于第一次的部分 Region.Op.REPLACE 显示第二次的部分 Region.Op.UNION 显示第一次和第二次的所有部分(并集) Region.Op.XOR 显示第一次和第二次的交集以外的部分(异或集) Region.Op.INTERSECT 显示第一次和第二次的交集部分(交集)
安卓头像制作图片圆角剪裁相关-CropImageView图片裁剪的小控件.rar
07-29
本资源“安卓头像制作图片圆角剪裁相关-CropImageView图片裁剪的小控件.rar”提供了一个名为CropImageView的小型图片裁剪控件，它允许用户对图片进行自由裁剪并实现圆角效果。下面我们将详细探讨这个控件及其相关...
android 画布控件,Android canvas画图操作之切割画布实现方法(clipRect)
weixin_32744285的博客
05-25 459
本文实例讲述了Android canvas画图操作之切割画布实现方法。分享给大家供大家参考，具体如下：android切割画布的历程不算很难，可是理解起来也比较麻烦，这里写一下我的理解 但是不一定正确：canvas.clipRect(30,30,70,Region.Op.XOR);最后一个参数有多个选择分别是：//DIFFERENCE是第一次不同于第二次的部分显示出来//REPLACE是显示第二次的...
【Android】【屏幕截图】通过Canvas缓存进行屏幕截图
天天向上 Up Up Up (*^▽^*)
02-18 854
我们知道，控件都是通过Canvas进行绘制而呈现出来的 如果我们将Canvas的绘制过程缓存起来，再将其写入到位图中，那么就可以得到这个控件的图像 如果我们对DecorView（Window布局的根节点）的Canvas进行缓存捕捉，那么就可以得到整个界面的图像 Bitmap对象本身带有裁剪的功能，我们只要知道屏幕坐标，按坐标对Bitmap进行裁剪，就可以得到屏幕任意区域的图像 这个方法适合绝大多数...
使用canvas对图片进行裁切
热门推荐
苛学加记事
06-15 1万+
canvas canvas 又叫做画布，是 HTML5 新增内容，可以使用js脚本在其中绘制图像的元素。 常用于制作网页上的一些毕竟炫酷的前端特效。 可以完成图片处理、动画渲染、图表渲染等操作。 最近用uni-app的推流组件做了个已证件照拍摄的相机，但是拍照完成后还需要对图片进行裁切，才能真正使用。 今天就来看看如何使用canvas对图片进行剪切。 ...
android 图片上加蒙层,Android图片裁剪，裁剪外的区域添加蒙层
weixin_32540969的博客
05-30 1054
对图片的裁剪主要就是使用canvas进行处理，使用canvas.drawBitmapdrawBitmap(Bitmap bitmap, Rect src, RectF dst, Paint paint)；Rect src: 是对图片进行裁截，若是空null则显示整个图片RectF dst：是图片在Canvas画布中显示的区域，大于src则把src的裁截区放大，小于src则把src的裁截区缩小。加蒙...
android Canvas 裁剪
Waiting !
12-31 3731
今天由于要对图片进行裁剪，即裁剪图片的某一部分，或者说一个特定的闭合图形。 首先想到是canvas 的 slip方法，其提供了很多样式的裁剪，这里就不一一指出。 要弄清的是，这里canvas裁剪，是对bitmap的裁剪吗，我的回答 ：NO 。 个人理解：canvas只是画布，其slip方法就像创建一个裁剪选区，只有该画布上的这个选区才能可见。就像你通过圆形的孔去看世界，那么世界也是圆的。
Android Bitmap 图片裁剪
guibao513的专栏
01-26 483
/ 设置画布透明度为完全不透明（默认值）// 调用 drawBitmap() 函数进行剪切操作。// 创建新的画布大小为550X452位图对象。// 创建画布并将其与新的位图关联起来。// 左上角到右下角的矩形区域。// 显示或保存剪切后的图片。// 创建新的空白画布对象。// 创建原始位图对象。// 定义要剪切的区域。
Cuter Android图片裁剪工具：拍照与图片编辑功能
Android提供了Bitmap类和Canvas类来对图片进行操作，裁剪图片时会涉及到这些类的使用。 4. 显示图片大小: 在cuter应用程序中，显示图片大小是指向用户提供图片的分辨率和文件大小等信息。这可以通过编程获取图片...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值