图片双指旋转（双指中心）

Hfengxiang

于 2021-09-24 01:10:54 发布

阅读量226

点赞数

分类专栏：自定义View 双指旋转缩放文章标签： android

本文链接：https://blog.csdn.net/Hfengxiang/article/details/120446689

版权

本文介绍如何在Android平台上实现图片的双指旋转功能，通过RotationInfo、Utils、RotateProcessor和ScaleCalculator等核心组件，详细阐述了双指中心旋转的逻辑，并提供了CanvasViewV3和RotateProcessorV3的具体实现细节。

摘要由CSDN通过智能技术生成

package com.hfengxiang.example.myphotoview;

import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.Canvas;
import android.graphics.Paint;
import android.graphics.PointF;
import android.graphics.RectF;
import android.os.Build;
import android.util.AttributeSet;
import android.util.Log;
import android.view.MotionEvent;
import android.view.View;

import androidx.annotation.Nullable;
import androidx.annotation.RequiresApi;

public class TestCanvasViewV2 extends View implements RotateProcessor.OnRotateListener {

    private Paint paint;
    private Bitmap bitmap;
    private int rotation = 0;
    private float currentScale = 1f;
    private RectF rectF;
    private RotateProcessor rotateProcessor;
    private boolean isRecover;
    private PointF translate = new PointF(100, 100);
    private PointF rotateCenter;
    private PointF recoverCenter;
    private RotateInfo mInfo;

    public TestCanvasViewV2 setTranslate(float x, float y) {
        translate.set(x, y);
        return this;
    }

    public TestCanvasViewV2(Context context) {
        this(context, null);
    }

    public TestCanvasViewV2(Context context, @Nullable AttributeSet attrs) {
        this(context, attrs, -1);
    }

    public TestCanvasViewV2(Context context, @Nullable AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
        init(context);
    }

    private void init(Context context) {
        paint = new Paint();
        paint.setAntiAlias(true);
        bitmap = Utils.getPhoto(getResources(), getResources().getDisplayMetrics().widthPixels);
        rectF = new RectF();
        rotateCenter = new PointF();
        recoverCenter = new PointF();
        rotateCenter.set(0f, 0f);
        rotateProcessor = new RotateProcessor();
        rotateProcessor.setRotateListener(this);
    }

    @Override
    protected void onSizeChanged(int w, int h, int oldw, int oldh) {
        super.onSizeChanged(w, h, oldw, oldh);
        currentScale = ScaleCalculator.calculateScale(getWidth(), getHeight(), bitmap.getWidth(), bitmap.getHeight(), 0);
    }

    @Override
    protected void onDraw(Canvas canvas) {
        super.onDraw(canvas);
        canvas.save();
        if (mInfo != null) {
            PointF center = mInfo.getRotateCenter();
            Log.i("CENTER", "center.x=" + center.x);
            Log.i("CENTER", "center.y=" + center.y);
            Log.i("CENTER", "getWidth() / 2f=" + getWidth() / 2f);
            Log.i("CENTER", "getHeight() / 2f=" + getHeight() / 2f);
            Log.i("CENTER", "rotateCenter.x=" + rotateCenter.x);
            Log.i("CENTER", "rotateCenter.y=" + rotateCenter.y);
        }
        int level = calculateLevel(rotation);
        canvas.translate(getWidth() / 2f, getHeight() / 2f);
        canvas.rotate(rotation, rotateCenter.x, rotateCenter.y);

        rectF.set(-currentWidth() / 2f, -currentHeight() / 2f,
                currentWidth() / 2f, currentHeight() / 2f);
        canvas.drawBitmap(bitmap, null, rectF, paint);
        canvas.restore();
    }

    @RequiresApi(api = Build.VERSION_CODES.Q)
    @Override
    public boolean onTouchEvent(MotionEvent event) {
        switch (event.getActionMasked()) {
            case MotionEvent.ACTION_DOWN:
            case MotionEvent.ACTION_POINTER_DOWN:
                rotateProcessor.handleActionDown(event);
                break;
            case MotionEvent.ACTION_MOVE:
                rotateProcessor.handleActionMove(event);
                break;
            case MotionEvent.ACTION_UP:
            case MotionEvent.ACTION_POINTER_UP:
                rotateProcessor.handleActionUp(event);
                break;
        }
        return true;
    }

    private float currentWidth() {
        return bitmap.getWidth() * currentScale;
    }

    private float currentHeight() {
        return bitmap.getHeight() * currentScale;
    }

    @Override
    public void onRotate(RotateInfo info) {
        mInfo = info;
        rotation = (int) info.getTotalDegree();
        if (info.isRecovering()) {
            currentScale = info.getScale();
            rotateCenter.set(recoverCenter.x * (1 - info.getProgress()), recoverCenter.y * (1 - info.getProgress()));
            Log.i("RECOVER", "rotateCenter.x=" + rotateCenter.x);
            Log.i("RECOVER", "rotateCenter.y=" + rotateCenter.y);
        } else {


        }
        invalidate();
    }

    @Override
    public void onRotateStart(RotateInfo info) {
        PointF center = info.getRotateCenter();
//            Log.i("CENTER", "center.x=" + center.x);
//            Log.i("CENTER", "center.y=" + center.y);
//            Log.i("CENTER", "getWidth() / 2f=" + getWidth() / 2f);
//            Log.i("CENTER", "getHeight() / 2f=" + getHeight() / 2f);
        int level = calculateLevel(info.getTotalDegree());
        Log.i("CENTER", "level=" + level);
        if (level % 2 == 0) {
            rotateCenter.set(center.x - getWidth() / 2f,
                    center.y - getHeight() / 2f);
        } else {
//            rotateCenter.set(center.y - getHeight() / 2f,
//                    center.x - getWidth() / 2f);
        }
        recoverCenter.set(rotateCenter);

    }

    @Override
    public void onRotateEnd() {
    }

    private int calculateLevel(float totalDegree) {
        float degree = totalDegree % 360;
        if (degree < 0) {
            degree = degree + 360;
        }
        return (int) (degree / 90);
    }

    @Override
    public float[] onCalculateScale(float targetDegree) {
        targetDegree = computeTargetDegree(targetDegree);
        Log.i("onCalculateScale", "targetScale=" + targetDegree);
        float targetScale = ScaleCalculator.calculateScale(getWidth(), getHeight(), bitmap.getWidth(), bitmap.getHeight(),
                (int) targetDegree);
        isRecover = true;
        return new float[]{currentScale, targetScale};
    }

    /**
     * 根据旋转的角度计算出图片复位应当到达的角度
     *
     * @param degree 旋转的角度
     * @return 目标角度
     */
    private int computeTargetDegree(double degree) {
        int[] degrees = {0, 90, 90, 180, 180, 270, 270, 360};
        degree = degree % 360;
        int index = (int) (degree / 45);
        if (index > 0) {
            return degrees[index];
        } else {
            return -1 * degrees[-1 * index];
        }
    }
}

RotationInfo

package com.hfengxiang.example.myphotoview;

import android.graphics.PointF;

public class RotateInfo {
    private float progress;
    private float scale;
    private float totalDegree;
    private float currentDegree;
    private PointF rotateCenter;
    private boolean isRotating;
    private boolean isRecovering;

    public RotateInfo() {
        rotateCenter = new PointF();
    }

    public float getProgress() {
        return progress;
    }

    public RotateInfo setProgress(float progress) {
        this.progress = progress;
        return this;
    }

    public float getScale() {
        retu