自定义好用的裁剪功能

已于 2023-10-09 10:50:16 修改
阅读量72 收藏
点赞数
文章标签： android-studio
于 2023-10-09 10:45:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41620230/article/details/133696449
版权

裁剪效果

直接上代码：


import android.annotation.SuppressLint;
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Matrix;
import android.graphics.Rect;
import android.graphics.Region;
import android.graphics.drawable.BitmapDrawable;
import android.graphics.drawable.Drawable;
import android.util.AttributeSet;
import android.view.MotionEvent;
import android.view.View;

public class CropImageView extends View {
    // 在touch重要用到的点，
    private float mX_1 = 0;
    private float mY_1 = 0;
    // 触摸事件判断
    private final int STATUS_SINGLE = 1;
    private final int STATUS_MULTI_START = 2;
    private final int STATUS_MULTI_TOUCHING = 3;
    // 当前状态
    private int mStatus = STATUS_SINGLE;
    // 默认裁剪的宽高
    private int cropWidth;
    private int cropHeight;
    // 浮层Drawable的四个点
    private final int EDGE_LT = 1;
    private final int EDGE_RT = 2;
    private final int EDGE_LB = 3;
    private final int EDGE_RB = 4;
    private final int EDGE_MOVE_IN = 5;
    private final int EDGE_MOVE_OUT = 6;
    private final int EDGE_NONE = 7;

    public int currentEdge = EDGE_NONE;

    protected float oriRationWH = 0;

    protected Drawable mDrawable;
    protected FloatDrawable mFloatDrawable;

    protected Rect mDrawableSrc = new Rect();// 图片Rect变换时的Rect
    protected Rect mDrawableDst = new Rect();// 图片Rect
    protected Rect mDrawableFloat = new Rect();// 浮层的Rect
    protected boolean isFirst = true;
    private boolean isTouchInSquare = true;

    protected Context mContext;
    private Bitmap mBitmap;

    public CropImageView(Context context) {
        super(context);
        init(context);
    }

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

    public CropImageView(Context context, AttributeSet attrs, int defStyle) {
        super(context, attrs, defStyle);
        init(context);
    }

    @SuppressLint("NewApi")
    private void init(Context context) {
        this.mContext = context;
        try {
            if (android.os.Build.VERSION.SDK_INT >= 11) {
                this.setLayerType(LAYER_TYPE_SOFTWARE, null);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        mFloatDrawable = new FloatDrawable(context);
    }

    public void setDrawable(Bitmap bitmap, int cropWidth, int cropHeight) {
        mBitmap = bitmap;
        this.mDrawable = new BitmapDrawable(bitmap);
        this.cropWidth = cropWidth;
        this.cropHeight = cropHeight;
        this.isFirst = true;
        invalidate();
    }

    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        super.onMeasure(widthMeasureSpec, heightMeasureSpec);

        int widthSize = MeasureSpec.getSize(widthMeasureSpec);
        int heightSize = MeasureSpec.getSize(heightMeasureSpec);

        if (mBitmap != null) {
            if ((mBitmap.getHeight() > heightSize) && (mBitmap.getHeight() > mBitmap.getWidth())) {
                widthSize = heightSize * mBitmap.getWidth() / mBitmap.getHeight();
            } else if ((mBitmap.getWidth() > widthSize) && (mBitmap.getWidth() > mBitmap.getHeight())) {
                heightSize = widthSize * mBitmap.getHeight() / mBitmap.getWidth();
            } else {
                heightSize = mBitmap.getHeight();
                widthSize = mBitmap.getWidth();
            }
        }
        setMeasuredDimension(widthSize, heightSize);
    }

    @SuppressLint("ClickableViewAccessibility")
    @Override
    public boolean onTouchEvent(MotionEvent event) {

        if (event.getPointerCount() > 1) {
            if (mStatus == STATUS_SINGLE) {
                mStatus = STATUS_MULTI_START;
            } else if (mStatus == STATUS_MULTI_START) {
                mStatus = STATUS_MULTI_TOUCHING;
            }
        } else {
            if (mStatus == STATUS_MULTI_START
                    || mStatus == STATUS_MULTI_TOUCHING) {
                mX_1 = event.getX();
                mY_1 = event.getY();
            }

            mStatus = STATUS_SINGLE;
        }

        switch (event.getAction()) {
            case MotionEvent.ACTION_DOWN:
                mX_1 = event.getX();
                mY_1 = event.getY();
                currentEdge = getTouch((int) mX_1, (int) mY_1);
                break;

            case MotionEvent.ACTION_UP:
                break;

            case MotionEvent.ACTION_POINTER_UP:
                currentEdge = EDGE_NONE;
                break;

            case MotionEvent.ACTION_MOVE:
                if (mStatus == STATUS_MULTI_TOUCHING) {

                } else if (mStatus == STATUS_SINGLE) {
                    int dx = (int) (event.getX() - mX_1);
                    int dy = (int) (event.getY() - mY_1);

                    mX_1 = event.getX();
                    mY_1 = event.getY();
                    // TODO 如果手指坐标超出view范围，则返回。
                    // 理论上应该写在这里，但会产生一个移动四个角过快的时候不容易移到到边界的现象
//                    if (mX_1 > getWidth() || mX_1 < 0 || mY_1 > getHeight() || mY_1 < 0) {
//                        break;
//                    }
                    // 根據得到的那一个角，并且变换Rect
                    if (!(dx == 0 && dy == 0)) {
                        switch (currentEdge) {
                            case EDGE_LT:
                                mDrawableFloat.set(mDrawableFloat.left + dx,
                                        mDrawableFloat.top + dy,
                                        mDrawableFloat.right,
                                        mDrawableFloat.bottom);
                                break;

                            case EDGE_RT:
                                mDrawableFloat.set(mDrawableFloat.left,
                                        mDrawableFloat.top + dy,
                                        mDrawableFloat.right + dx,
                                        mDrawableFloat.bottom);
                                break;

                            case EDGE_LB:
                                mDrawableFloat.set(mDrawableFloat.left + dx,
                                        mDrawableFloat.top,
                                        mDrawableFloat.right,
                                        mDrawableFloat.bottom + dy);
                                break;

                            case EDGE_RB:
                                mDrawableFloat.set(mDrawableFloat.left,
                                        mDrawableFloat.top,
                                        mDrawableFloat.right + dx,
                                        mDrawableFloat.bottom + dy);
                                break;

                            case EDGE_MOVE_IN:
                                // 因为手指一直在移动，应该实时判断是否超出裁剪框（手指移动到图片范围外）
                                isTouchInSquare = mDrawableFloat.contains((int) event.getX(),
                                        (int) event.getY());
                                if (isTouchInSquare) {
                                    mDrawableFloat.offset(dx, dy);
                                }
                                break;

                            case EDGE_MOVE_OUT:
                                break;
                        }
                        mDrawableFloat.sort();
                        invalidate();
                    }
                }
                break;
        }
        return true;
    }

    // 根据初触摸点判断是触摸的Rect哪一个角
    public int getTouch(int eventX, int eventY) {
        Rect mFloatDrawableRect = mFloatDrawable.getBounds();
        int mFloatDrawableWidth = mFloatDrawable.getBorderWidth();
        int mFloatDrawableHeight = mFloatDrawable.getBorderHeight();
        if (mFloatDrawableRect.left <= eventX
                && eventX < (mFloatDrawableRect.left + mFloatDrawableWidth)
                && mFloatDrawableRect.top <= eventY
                && eventY < (mFloatDrawableRect.top + mFloatDrawableHeight)) {
            return EDGE_LT;
        } else if ((mFloatDrawableRect.right - mFloatDrawableWidth) <= eventX
                && eventX < mFloatDrawableRect.right
                && mFloatDrawableRect.top <= eventY
                && eventY < (mFloatDrawableRect.top + mFloatDrawableHeight)) {
            return EDGE_RT;
        } else if (mFloatDrawableRect.left <= eventX
                && eventX < (mFloatDrawableRect.left + mFloatDrawableWidth)
                && (mFloatDrawableRect.bottom - mFloatDrawableHeight) <= eventY
                && eventY < mFloatDrawableRect.bottom) {
            return EDGE_LB;
        } else if ((mFloatDrawableRect.right - mFloatDrawableWidth) <= eventX
                && eventX < mFloatDrawableRect.right
                && (mFloatDrawableRect.bottom - mFloatDrawableHeight) <= eventY
                && eventY < mFloatDrawableRect.bottom) {
            return EDGE_RB;
        } else if (mFloatDrawableRect.contains(eventX, eventY)) {
            return EDGE_MOVE_IN;
        }
        return EDGE_MOVE_OUT;
    }

    @Override
    protected void onDraw(Canvas canvas) {

        if (mDrawable == null) {
            return;
        }

        if (mDrawable.getIntrinsicWidth() == 0 || mDrawable.getIntrinsicHeight() == 0) {
            return;
        }

        configureBounds();
        // 在画布上画图片
        mDrawable.draw(canvas);
        canvas.save();
        // 在画布上画浮层FloatDrawable,Region.Op.DIFFERENCE是表示Rect交集的补集
        canvas.clipRect(mDrawableFloat, Region.Op.DIFFERENCE);
        // 在交集的补集上画上灰色用来区分
        canvas.drawColor(Color.parseColor("#a0000000"));
        canvas.restore();
        // 画浮层
        mFloatDrawable.draw(canvas);
    }

    protected void configureBounds() {
        // configureBounds在onDraw方法中调用
        // isFirst的目的是下面对mDrawableSrc和mDrawableFloat只初始化一次，
        // 之后的变化是根据touch事件来变化的，而不是每次执行重新对mDrawableSrc和mDrawableFloat进行设置
        if (isFirst) {
            oriRationWH = ((float) mDrawable.getIntrinsicWidth())
                    / ((float) mDrawable.getIntrinsicHeight());

            final float scale = mContext.getResources().getDisplayMetrics().density;
            int mDrawableW = (int) (mDrawable.getIntrinsicWidth() * scale + 0.5f);
            if ((mDrawable.getIntrinsicHeight() * scale + 0.5f) > getHeight()) {
                mDrawableW = (int) ((mDrawable.getIntrinsicWidth() * scale + 0.5f)
                        * (getHeight() / (mDrawable.getIntrinsicHeight() * scale + 0.5f)));
            }
            int w = Math.min(getWidth(), mDrawableW);
            int h = (int) (w / oriRationWH);

            int left = (getWidth() - w) / 2;
            int top = (getHeight() - h) / 2;
            int right = left + w;
            int bottom = top + h;

            mDrawableSrc.set(left, top, right, bottom);
            mDrawableDst.set(mDrawableSrc);

            int floatWidth = dipToPx(mContext, cropWidth);
            int floatHeight = dipToPx(mContext, cropHeight);

            if (floatWidth > getWidth()) {
                floatWidth = getWidth();
                floatHeight = cropHeight * floatWidth / cropWidth;
            }

            if (floatHeight > getHeight()) {
                floatHeight = getHeight();
                floatWidth = cropWidth * floatHeight / cropHeight;
            }

            int floatLeft = (getWidth() - floatWidth) / 2;
            int floatTop = (getHeight() - floatHeight) / 2;
            mDrawableFloat.set(floatLeft, floatTop, floatLeft + floatWidth, floatTop + floatHeight);

            isFirst = false;
        } else if (getTouch((int) mX_1, (int) mY_1) == EDGE_MOVE_IN) {
            if (mDrawableFloat.left < 0) {
                mDrawableFloat.right = mDrawableFloat.width();
                mDrawableFloat.left = 0;
            }
            if (mDrawableFloat.top < 0) {
                mDrawableFloat.bottom = mDrawableFloat.height();
                mDrawableFloat.top = 0;
            }
            if (mDrawableFloat.right > getWidth()) {
                mDrawableFloat.left = getWidth() - mDrawableFloat.width();
                mDrawableFloat.right = getWidth();
            }
            if (mDrawableFloat.bottom > getHeight()) {
                mDrawableFloat.top = getHeight() - mDrawableFloat.height();
                mDrawableFloat.bottom = getHeight();
            }
            mDrawableFloat.set(mDrawableFloat.left, mDrawableFloat.top, mDrawableFloat.right,
                    mDrawableFloat.bottom);
        } else {
            if (mDrawableFloat.left < 0) {
                mDrawableFloat.left = 0;
            }
            if (mDrawableFloat.top < 0) {
                mDrawableFloat.top = 0;
            }
            if (mDrawableFloat.right > getWidth()) {
                mDrawableFloat.right = getWidth();
                mDrawableFloat.left = getWidth() - mDrawableFloat.width();
            }
            if (mDrawableFloat.bottom > getHeight()) {
                mDrawableFloat.bottom = getHeight();
                mDrawableFloat.top = getHeight() - mDrawableFloat.height();
            }
            mDrawableFloat.set(mDrawableFloat.left, mDrawableFloat.top, mDrawableFloat.right,
                    mDrawableFloat.bottom);
        }

        mDrawable.setBounds(mDrawableDst);
        mFloatDrawable.setBounds(mDrawableFloat);
    }

    // 进行图片的裁剪，所谓的裁剪就是根据Drawable的新的坐标在画布上创建一张新的图片
    public Bitmap getCropImage() {
        Bitmap tmpBitmap = Bitmap.createBitmap(getWidth(), getHeight(), Bitmap.Config.RGB_565);
        Canvas canvas = new Canvas(tmpBitmap);
        mDrawable.draw(canvas);

        Matrix matrix = new Matrix();
        float scale = (float) (mDrawableSrc.width())
                / (float) (mDrawableDst.width());
        matrix.postScale(scale, scale);

        Bitmap ret = Bitmap.createBitmap(tmpBitmap, mDrawableFloat.left,
                mDrawableFloat.top, mDrawableFloat.width(),
                mDrawableFloat.height(), matrix, true);
        tmpBitmap.recycle();
        return ret;
    }

    public int dipToPx(Context context, float dpValue) {
        final float scale = context.getResources().getDisplayMetrics().density;
        return (int) (dpValue * scale + 0.5f);
    }
}

import android.content.Context;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.ColorFilter;
import android.graphics.Paint;
import android.graphics.PixelFormat;
import android.graphics.Rect;
import android.graphics.drawable.Drawable;


public class FloatDrawable extends Drawable {

    private Context mContext;
    private int offset = 50;
    private Paint mLinePaint = new Paint();
    private Paint mLinePaint2 = new Paint();

    {
        mLinePaint.setARGB(200, 50, 50, 50);
        mLinePaint.setStrokeWidth(3F);
        mLinePaint.setStyle(Paint.Style.STROKE);
        mLinePaint.setAntiAlias(true);
        mLinePaint.setColor(Color.parseColor("#3388FF"));
        //
        mLinePaint2.setARGB(200, 50, 50, 50);
        mLinePaint2.setStrokeWidth(8F);
        mLinePaint2.setStyle(Paint.Style.STROKE);
        mLinePaint2.setAntiAlias(true);
        mLinePaint2.setColor(Color.parseColor("#3388FF"));
    }

    public FloatDrawable(Context context) {
        super();
        this.mContext = context;

    }

    public int getBorderWidth() {
        return dipToPx(mContext, offset);//根据dip计算的像素值，做适配用的
    }

    public int getBorderHeight() {
        return dipToPx(mContext, offset);
    }

    @Override
    public void draw(Canvas canvas) {

        int left = getBounds().left;
        int top = getBounds().top;
        int right = getBounds().right;
        int bottom = getBounds().bottom;

        Rect mRect = new Rect(left + dipToPx(mContext, offset) / 2+3,
                top + dipToPx(mContext, offset) / 2+3,
                right - dipToPx(mContext, offset) / 2-3,
                bottom - dipToPx(mContext, offset) / 2-3);
        //画默认的选择框
        canvas.drawRect(mRect, mLinePaint);
        //画四个角的四个粗拐角、也就是八条粗线
        canvas.drawLine((left + dipToPx(mContext, offset) / 2 - 3.5f),
                top + dipToPx(mContext, offset) / 2+2,
                left + dipToPx(mContext, offset) - 8f,
                top + dipToPx(mContext, offset) / 2+2, mLinePaint2);
        canvas.drawLine(left + dipToPx(mContext, offset) / 2+2,
                top + dipToPx(mContext, offset) / 2,
                left + dipToPx(mContext, offset) / 2+2,
                top + dipToPx(mContext, offset) / 2 + 30, mLinePaint2);

        canvas.drawLine(right - dipToPx(mContext, offset) + 8f,
                top + dipToPx(mContext, offset) / 2+2,
                right - dipToPx(mContext, offset) / 2,
                top + dipToPx(mContext, offset) / 2+2, mLinePaint2);
        canvas.drawLine(right - dipToPx(mContext, offset) / 2-2,
                top + dipToPx(mContext, offset) / 2 - 3.5f,
                right - dipToPx(mContext, offset) / 2-2,
                top + dipToPx(mContext, offset) / 2 + 30, mLinePaint2);

        canvas.drawLine((left + dipToPx(mContext, offset) / 2 - 3.5f),
                bottom - dipToPx(mContext, offset) / 2-2,
                left + dipToPx(mContext, offset) - 8f,
                bottom - dipToPx(mContext, offset) / 2-2, mLinePaint2);
        canvas.drawLine((left + dipToPx(mContext, offset) / 2+2),
                bottom - dipToPx(mContext, offset) / 2,
                left + dipToPx(mContext, offset) / 2+2,
                bottom - dipToPx(mContext, offset) / 2 - 30f, mLinePaint2);

        canvas.drawLine((right - dipToPx(mContext, offset) + 8f),
                bottom - dipToPx(mContext, offset) / 2-2,
                right - dipToPx(mContext, offset) / 2,
                bottom - dipToPx(mContext, offset) / 2-2, mLinePaint2);
        canvas.drawLine((right - dipToPx(mContext, offset) / 2-2),
                bottom - dipToPx(mContext, offset) / 2 - 30f,
                right - dipToPx(mContext, offset) / 2-2,
                bottom - dipToPx(mContext, offset) / 2 + 3.5f, mLinePaint2);
    }

    @Override
    public void setBounds(Rect bounds) {
        super.setBounds(new Rect(bounds.left - dipToPx(mContext, offset) / 2,
                bounds.top - dipToPx(mContext, offset) / 2,
                bounds.right + dipToPx(mContext, offset) / 2,
                bounds.bottom + dipToPx(mContext, offset) / 2));
    }

    @Override
    public void setAlpha(int alpha) {

    }

    @Override
    public void setColorFilter(ColorFilter cf) {

    }

    @Override
    public int getOpacity() {
        return PixelFormat.UNKNOWN;
    }

    public int dipToPx(Context context, float dpValue) {
        final float scale = context.getResources().getDisplayMetrics().density;
        return (int) (dpValue * scale + 0.5f);
    }
}

用法

    private fun initData() {
        var data = BitmapHelper.getLogoBitmap(imgName) //获取对应的bitmap
        if (data == null) {
            ToastUtils.showToast("数据异常，请重试")
            return
        }
        val num =
            data.width.toFloat() / (DensityUtil.getPhoneWidth(this@CropBrandActivity) * 0.8)
        val params = mBinding.cropimage.layoutParams
        if (data.width < DensityUtil.getPhoneWidth(this@CropBrandActivity) * 0.5 || data.height < 100) {
            val bei =
                (DensityUtil.getPhoneWidth(this@CropBrandActivity) * 0.8) / data.width.toFloat()
            data = Bitmap.createScaledBitmap(
                data, (DensityUtil.getPhoneWidth(this@CropBrandActivity) * 0.8).toInt(),
                (data.height * bei).toInt(), true
            )
            params.height = (data.height * bei).toInt()
            params.width = (DensityUtil.getPhoneWidth(this@CropBrandActivity) * 0.8).toInt()
        } else {
            params.height = (data.height.toFloat() / num).toInt()
            params.width = (DensityUtil.getPhoneWidth(this@CropBrandActivity) * 0.8).toInt()
        }
        mBinding.cropimage.layoutParams = params
        mBinding.cropimage.setDrawable(data, data.width, data.height)
    }

qq_41620230
关注
android 自定义比例裁剪图片(拍照 相册)方式 自定义比例
12-16
android 自定义比例裁剪图片(拍照 相册)方式 16:9 10:7 自定义 默认宽度是屏幕宽度
Android 自定义控件——图片剪裁
weixin_30877755的博客
12-16 249
本文介绍一个自定义的图片剪裁控件 该控件由另一篇博文：Android 图片拖拽、放大缩小的自定义控件扩展而来 如图： 思路：在一个自定义View上绘制一张图片（参照前面提到的另一篇博文），在该自定义View上绘制一个自定义的FloatDrawable，也就是图中的浮层。绘制图片和FloatDrawable的交集的补集部分灰色阴影（这个其实很简单，就一句...
（UI）Android自定义图片裁剪
AC1992的专栏
06-01 1160
Android图片裁剪框绘制，可手势控制
android 自定义图片裁剪,Android自定义View实现照片裁剪框与照片裁剪功能
weixin_39776239的博客
05-25 710
本文所需要实现的就是这样一种有逼格的效果：右上角加了个图片框，按下确定可以裁剪正方形区域里的图片并显示在右上角。实现思路：1：首先需要自定义一个ZoomImageView来显示我们需要的图片，这个View需要让图片能够以合适的位置展现在当前布局的图片展示区域内(合适的位置值的是：如果图片长度大于屏幕，则压缩图片长度至屏幕宽度，高度等比压缩并居中显示，如果图片高度大于屏幕，则压缩图片高度至屏幕高度，...
创造一款安卓自定义控件_裁剪原理介绍
最新发布
轮子初级玩家
07-10 543
裁剪框中裁剪部分的代码原理大概讲解。
jquery实现自定义图片裁剪功能【推荐】
10-20
接下来，需要通过jQuery创建一个裁剪插件，实现图片的自定义裁剪功能。 ```javascript (function($) { $.fn.photoCrop = function(option) { // 默认参数 var opt = { img: '', fixedScale: 9/5, isHead: ...
Android自定义View实现照片裁剪框与照片裁剪功能
09-01
本篇文章将探讨如何实现一个自定义的照片裁剪框与照片裁剪功能，这在许多应用程序中，如社交应用或者图像编辑工具，都是必不可少的特性。 首先，为了显示可缩放的图片，我们需要创建一个`ZoomImageView`。这个...
实现图片自定义裁剪功能ios
04-01
在iOS开发中，实现图片自定义裁剪功能是一项常见的需求，尤其在用户头像设置、海报编辑等场景中。这个源码提供了一种方法来实现图片的自定义多边形区域裁剪，允许用户根据自己的需求调整裁剪的形状和大小。以下是...
arcmap自定义范围裁剪栅格数据.doc
07-10
本文将详细探讨如何在ArcMap中利用自定义范围裁剪栅格数据，这是一个非常实用的操作，尤其在数据清理、区域分析或者地图制作时。 首先，我们从创建一个新的要素开始。在ArcMap界面中，点击“ArcToolbox”（工具箱）...
android-cropImage:android自定义图片裁剪功能
03-27
Android CropImage 一，说明 Android 图片裁剪 1.底图缩放，浮层不变2.底图不变，浮层不变3.底图不变，浮层缩放 二，效果展示 图片依次：（主界面------>裁切图片------>剪后回到主界面预览图片）
Android 自定义图片裁剪框功能
qq_37159335的博客
11-28 4028
Android自定义图片裁剪框功能 大体的功能如上gif所示，最后蓝色裁剪框中的矩形图片区域可以进行截取并返回一个Bitmap对象。整个裁剪功能由两个自定义的View组件完成，首先是图片显示控件DragScaleView，主要完成图片的双指触碰缩放和单指触碰滑动，以及根据裁剪框的变化对图片进行对应的平移和缩放；然后就是裁剪框控件DrawBoxView，他俩的父布局是FrameLayout，所...
android 自定义裁切,【Android开发经验】设置用户头像并裁剪，仅仅是这么简单？...
weixin_35462903的博客
05-25 375
转载请注明出处：http://blog.csdn.net/zhaokaiqiang1992在做APP的时候，如果有用户系统功能，那末1般都逃不了这个需求，就是给用户设置头像，而设置头像，又包括从拍照和从相册选取两个方式，而且选择了以后，1般又都会要求对图象进行裁剪，让用户设置头像。今天这篇文章就是介绍如何完成这个需求的。我们首先分析1下需求。关于拍照和从相册选取，都可以向系统发送特定的Intent...
Android自定义View实现图片裁剪功能（一）
金戈鐡馬
02-18 823
Android自定义View实现图片裁剪功能
Android自定义View实现图片裁剪功能（二）
金戈鐡馬
02-19 867
1.首先创建一个自定义View，实现图片裁剪功能； 2.在自定义View中，获取到图片，并绘制出来； 3.利用Canvas中的矩阵变换方法，实现图片裁剪； 4.根据裁剪的位置，绘制出裁剪框，并且实时跟随移动； 5.利用Canvas的save和restore方法，实现裁剪框的限制，即裁剪框不能超出图片边界； 6.实现裁剪框触摸事件，让裁剪框可以拖动； 7.获取裁剪框的位置，对图片进行裁剪，生成新的图片。
Android 自定义View实现照片裁剪框与照片裁剪
化身孤岛的瓜
07-23 8987
大部分的软件， 但凡包含登录注册的， 基本都会有选择头像功能， 而其中做的比较有逼格的， 一般会有一个选择框可以裁剪照片。 本文所需要实现的就是这样一种有逼格的效果： 右上角加了个图片框，按下确定可以裁剪正方形区域里的图片并显示在右上角。 实现思路： 1：首先需要自定义一个ZoomImageView来显示我们需要的图片，这个View需要让图片能够以合适的位置展现在当前布局的
android 自定义剪裁,Android自定义View实现照片裁剪框与照片裁剪功能
weixin_28825959的博客
05-25 1415
本文所需要实现的就是这样一种有逼格的效果：右上角加了个图片框，按下确定可以裁剪正方形区域里的图片并显示在右上角。实现思路：1：首先需要自定义一个ZoomImageView来显示我们需要的图片，这个View需要让图片能够以合适的位置展现在当前布局的图片展示区域内(合适的位置值的是：如果图片长度大于屏幕，则压缩图片长度至屏幕宽度，高度等比压缩并居中显示，如果图片高度大于屏幕，则压缩图片高度至屏幕高度，...
Android实现自定义相机系列(1)—自定义view裁剪控件
renzhongrui的博客
07-25 2500
目标 本系列文章主要记录自定义相机拍照系列，包括： 1、使用Android的Camera API自定义拍照模式，例如人脸拍照，OCR拍照等； 2、对拍完的照片进行裁剪； 3、自定义图片伸缩view，使用手势对图片进行放大缩小操作； 本人写博客也是为了自己学习和分享，也会参考网络上许多文章和开源项目，希望大家一块学习进步。这一篇文章主要介绍自定义裁剪view控件。 ...
Android自定义 view之图片裁剪从设计到实现
热门推荐
菜鸟博客
12-21 2万+
图片裁剪从设计到实现
Android自定义图片裁剪实现
在Android开发中，有时我们需要自定义图片裁剪功能，而不是简单地调用系统自带的裁剪工具。这通常是因为系统裁剪功能不能满足特定的需求，或者为了提供更为个性化的用户体验。本文将介绍一种不依赖系统功能的图片...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

qq_41620230

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值