Android 在按矩阵缩放imageview时，如何定义最大和最小缩放lvl

霍伊， 这是我的班级：

public class MultiTouchHandler implements OnTouchListener {
private static final int NONE = 0;
private static final int DRAG = 1;
private static final int ZOOM = 2;
private static final float MIN_ZOOM = 0.5f;
private static final float MAX_ZOOM = 2.0f;

private int mode = NONE;
private float oldDist;
private PointF mid;
private PointF start;
private Matrix matrix;
private Matrix savedMatrix;
private ImageView reticle;
private int imageWidth;
private int imageHeight;
private float[] values;
private boolean isTouched;
private float width;
private float height;
private float scale;

public MultiTouchHandler(ImageView v) {
    reticle = v;
    v.setOnTouchListener(this);
    mid = new PointF();
    start = new PointF();

    imageWidth = v.getDrawable().getIntrinsicWidth();
    imageHeight = v.getDrawable().getIntrinsicHeight();

    matrix = new Matrix();
    savedMatrix = new Matrix();
    values = new float[9];

}

public boolean onTouch(View v, MotionEvent event) {
    synchronized (this) {
        if(reticle.getScaleType() != ScaleType.MATRIX){
            reticle.setScaleType(ScaleType.MATRIX);
            matrix.postTranslate(reticle.getWidth()/2 - imageWidth/2, reticle.getHeight()/2 - imageHeight/2);
            reticle.setImageMatrix(matrix);
        }

        matrix.getValues(values);
        width = values[0]*imageWidth;
        height = values[4]*imageHeight;

        switch (event.getAction() & MotionEvent.ACTION_MASK) {
           case MotionEvent.ACTION_DOWN:
              savedMatrix.set(matrix);
              if(event.getX() > values[2] && event.getX() < values[2] + width &&
                  event.getY() > values[5] && event.getY() < values[5] + height){
                  start.set(event.getX(), event.getY());
                  isTouched = true;
              }
              mode = DRAG;
              break;

           case MotionEvent.ACTION_POINTER_DOWN:
               oldDist = spacing(event);
               if (oldDist > 10f) {
                  savedMatrix.set(matrix);
                  midPoint(mid, event);
                  mode = ZOOM;
               }
               break;

           case MotionEvent.ACTION_UP:
           case MotionEvent.ACTION_POINTER_UP:
              mode = NONE;
              isTouched = false;
              break;

           case MotionEvent.ACTION_MOVE:
              if (mode == DRAG && isTouched) {
                 matrix.set(savedMatrix);
                 matrix.postTranslate(event.getX() - start.x, event.getY() - start.y);
              }
              else if (mode == ZOOM) {
                  float newDist = spacing(event);
                  if (newDist > 10f) {
                     matrix.set(savedMatrix);
                     scale = newDist / oldDist;

                     Log.v("scale", "" + scale);

                     scale = Math.max(MIN_ZOOM, Math.min(scale, MAX_ZOOM));

                     Log.v("new scale", "" + scale);

                     matrix.postScale(scale, scale, mid.x, mid.y);
                  }
              }
              break;
        }
        reticle.setImageMatrix(matrix);
        return true;
    }
}

private float spacing(MotionEvent event) {
       float x = event.getX(0) - event.getX(1);
       float y = event.getY(0) - event.getY(1);
       return FloatMath.sqrt(x * x + y * y);
}

private void midPoint(PointF point, MotionEvent event) {
       float x = event.getX(0) + event.getX(1);
       float y = event.getY(0) + event.getY(1);
       point.set(x / 2, y / 2);
}

公共类多点触控处理器实现OnTouchListener{
私有静态final int NONE=0；
专用静态最终整数拖动=1；
私有静态最终整数缩放=2；
专用静态最终浮动最小值（放大倍数=0.5f）；
专用静态最终浮点最大缩放=2.0f；
私有int模式=无；
私人浮动区；
私有点f-mid；
专用点启动；
私有矩阵；
私有矩阵存储矩阵；
专用图像视图十字线；
私有整数图像宽度；
私人内部图像高度；
私有浮动[]值；
私有布尔值被触发；
私有浮动宽度；
私人浮动高度；
私人浮动比例；
公共多点触控处理器（ImageView v）{
十字线=v；
v、 setOnTouchListener（这个）；
mid=新点F（）；
开始=新的点f（）；
imageWidth=v.getDrawable（）.getIntrinsicWidth（）；
imageHeight=v.getDrawable（）.getIntrinsicHeight（）；
矩阵=新矩阵（）；
savedMatrix=新矩阵（）；
数值=新的浮动[9]；
}
公共布尔onTouch（视图v，运动事件）{
已同步（此）{
if（十字线.getScaleType（）！=ScaleType.MATRIX）{
十字线.设置刻度类型（刻度类型.矩阵）；
postTranslate（retile.getWidth（）/2-imageWidth/2，retile.getHeight（）/2-imageHeight/2）；
十字线。setImageMatrix（矩阵）；
}
矩阵。获取值（值）；
宽度=值[0]*imageWidth；
高度=值[4]*图像高度；
开关（event.getAction（）&MotionEvent.ACTION\u掩码）{
case MotionEvent.ACTION\u DOWN：
savedMatrix.set（矩阵）；
if（event.getX（）>values[2]&&event.getX（）值[5]&&event.getY（）{
set（event.getX（），event.getY（））；
isTouched=true；
}
模式=拖动；
打破
case MotionEvent.ACTION\u指针\u向下：
oldDist=间距（事件）；
如果（旧区>10f）{
savedMatrix.set（矩阵）；
中点（中点，事件）；
模式=缩放；
}
打破
case MotionEvent.ACTION\u UP：
case MotionEvent.ACTION\u指针\u向上：
模式=无；
isTouched=false；
打破
case MotionEvent.ACTION\u移动：
如果（模式==拖动并触摸（&I）{
矩阵集（savedMatrix）；
postTranslate（event.getX（）-start.x，event.getY（）-start.y）；
}
else if（模式==缩放）{
float newDist=间距（事件）；
如果（新距离>10f）{
矩阵集（savedMatrix）；
比例=新距离/旧距离；
对数v（“刻度”，“刻度+刻度”）；
scale=Math.max（最小缩放，数学最小（缩放，最大缩放））；
对数v（“新标度”、“标度+标度”）；
矩阵。后标度（标度、标度、中x、中y）；
}
}
打破
}
十字线。setImageMatrix（矩阵）；
返回true；
}
}
专用浮动间距（MotionEvent事件）{
float x=event.getX（0）-event.getX（1）；
float y=event.getY（0）-event.getY（1）；
返回FloatMath.sqrt（x*x+y*y）；
}
专用空心中点（点F点、MotionEvent事件）{
float x=event.getX（0）+event.getX（1）；
float y=event.getY（0）+event.getY（1）；
点集（x/2，y/2）；
}

}

---

问题是，它只适用于实际的收缩/缩放，而不适用于全局缩放。。。我试图保存全局比例，每次我缩放时，我将实际比例乘以全局比例，但这是有用的。。。从矩阵中得到的比例a是全局的，但它的行为不像一。我做错了什么？有人能帮忙吗？谢谢你的回答。

我就是这样解决的。。。它不是很优雅，但很管用

else if (mode == ZOOM) {
                  float newDist = spacing(event);
                  if (newDist > 10f) {
                     matrix.set(savedMatrix);
                     matrix.getValues(values);

                     if(values[0] < MAX_ZOOM && values[0] > MIN_ZOOM){
                         scale = newDist / oldDist;
                         scale = Math.max(MIN_ZOOM, Math.min(scale, MAX_ZOOM));                          
                         matrix.postScale(scale, scale, mid.x, mid.y);

                         reticle.setImageMatrix(matrix);
                     } else if(values[0] >= MAX_ZOOM){
                         newScale = newDist / oldDist;
                         if(newScale < scale){
                             scale = newScale;
                             scale = Math.max(MIN_ZOOM, Math.min(scale, MAX_ZOOM));                          
                             matrix.postScale(scale, scale, mid.x, mid.y);

                             reticle.setImageMatrix(matrix);
                         }
                     } else if(values[0] <= MIN_ZOOM){
                         newScale = newDist / oldDist;
                         if(newScale > scale){
                             scale = newScale;
                             scale = Math.max(MIN_ZOOM, Math.min(scale, MAX_ZOOM));                          
                             matrix.postScale(scale, scale, mid.x, mid.y);

                             reticle.setImageMatrix(matrix);
                         }
                     }
                  }
              }

else if（模式==缩放）{
float newDist=间距（事件）；
如果（新距离>10f）{
矩阵集（savedMatrix）；
矩阵。获取值（值）；
if（值[0]MIN\u缩放）{
比例=新距离/旧距离；
scale=Math.max（最小缩放，数学最小（缩放，最大缩放））；
矩阵。后标度（标度、标度、中x、中y）；
十字线。setImageMatrix（矩阵）；
}else if（值[0]>=最大缩放）{
newScale=newDist/oldDist；
if（新闻规模<规模）{
规模=新闻规模；
scale=Math.max（最小缩放，数学最小（缩放，最大缩放））；
矩阵。后标度（标度、标度、中x、中y）；
十字线。setImageMatrix（矩阵）；
}
}else if（值[0]比例）{
规模=新闻规模；
scale=Math.max（最小缩放，数学最小（缩放，最大缩放））；
矩阵。后标度（标度、标度、中x、中y）；
十字线。setImageMatrix（矩阵）；
}
}
}
}

---

这是我编辑的代码中唯一的和平

为什么没有人使用

scalegestruedetector

？我正在做一些非常类似的工作，并使用一个扩展了

ScaleGestureDetector.SimpleOnScaleListener

的小助手类

class ScaleListener extends
    ScaleGestureDetector.SimpleOnScaleGestureListener {

    float scaleFactor;
    Matrix matrix;

    public ScaleListener(){
        super();
        scaleFactor = 1.0f;
        matrix = new Matrix();
    }

    public boolean onScale(ScaleGestureDetector detector){
        //updating the scalefactor after the current gesture
        scaleFactor *= detector.getScaleFactor();

        //making sure the scale is within the limits
        scaleFactor = Math.max(MIN_ZOOM, Math.min(scaleFactor, MAX_ZOOM));

        //applying the scale via a matrix to the imageview
        matrix.setScale(scaleFactor, scaleFactor);
        imageview.setImageMatrix(matrix)
    }
}

您关于全局比例的问题让我有点困惑，但是矩阵/比例因子包含imageview的全局比例。希望这有帮助，尽管这是一个