Android pinch zoom、ZoomOut和ZoomIn处于限制状态

我已经在这里搜索了很多，但还没有找到解决方案。问题是，我有一个3000*3000px的图像，我将它设置为缩放型矩阵。现在我只有图像的左角显示。现在我不希望人们在这个阶段放大，只希望缩小到最大“x”（还需要看有多大）。
必须缩放的是imageview“kaart”

问题：如何让人们只在开始时缩小，而不让他们通过x？然后，不要让他们放大到超过原始尺寸

我试过用负值，但没用

这是我的密码：

    // These matrices will be used to move and zoom image
Matrix matrix = new Matrix();
Matrix savedMatrix = new Matrix();

// max and min zoom
//private static final float MIN_ZOOM = 1.0f;
//private static final float MAX_ZOOM = 5.0f;
//scale = Math.max(MIN_ZOOM, Math.min(scale, MAX_ZOOM));

// We can be in one of these 3 states
static final int NONE = 0;
static final int DRAG = 1;
static final int ZOOM = 2;

int mode = NONE;

// Remember some things for zooming
PointF start = new PointF();
PointF mid = new PointF();
float oldDist = 1f;
String savedItemClicked;

ImageView view;

@Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.kaart);
   view = (ImageView) findViewById(R.id.kaart);
   view.setOnTouchListener(this);
}



public boolean onTouch(View v, MotionEvent event) {
    // TODO Auto-generated method stub

    ImageView view = (ImageView) v;
    dumpEvent(event);


    // Handle touch events here...
    switch (event.getAction() & MotionEvent.ACTION_MASK) {
    case MotionEvent.ACTION_DOWN:
        savedMatrix.set(matrix);
        start.set(event.getX(), event.getY());
        //Log.d(TAG, "mode=DRAG");
        mode = DRAG;
        break;
    case MotionEvent.ACTION_POINTER_DOWN:
        oldDist = spacing(event);
        //Log.d(TAG, "oldDist=" + oldDist);
        if (oldDist > 10f) {
            savedMatrix.set(matrix);
            midPoint(mid, event);
            mode = ZOOM;
            //Log.d(TAG, "mode=ZOOM");
        }
        break;
    case MotionEvent.ACTION_UP:
    case MotionEvent.ACTION_POINTER_UP:
        mode = NONE;
       // Log.d(TAG, "mode=NONE");
        break;
    case MotionEvent.ACTION_MOVE:
        if (mode == DRAG) {
            // ...
            matrix.set(savedMatrix);
            matrix.postTranslate(event.getX() - start.x, event.getY()
                    - start.y);
        } else if (mode == ZOOM) {
            float newDist = spacing(event);
           // Log.d(TAG, "newDist=" + newDist);

            if (newDist > 10f) {
                matrix.set(savedMatrix);
                float scale = newDist / oldDist;

                matrix.postScale(scale, scale, mid.x, mid.y);

            }
        }
        break;
    }
    limitZoom(matrix);
    limitDrag(matrix);
    view.setImageMatrix(matrix);
    return true;
}

@SuppressWarnings("deprecation")
private void dumpEvent(MotionEvent event) {
    String names[] = { "DOWN", "UP", "MOVE", "CANCEL", "OUTSIDE",
            "POINTER_DOWN", "POINTER_UP", "7?", "8?", "9?" };
    StringBuilder sb = new StringBuilder();
    int action = event.getAction();
    int actionCode = action & MotionEvent.ACTION_MASK;
    sb.append("event ACTION_").append(names[actionCode]);
    if (actionCode == MotionEvent.ACTION_POINTER_DOWN
            || actionCode == MotionEvent.ACTION_POINTER_UP) {
        sb.append("(pid ").append(
                action >> MotionEvent.ACTION_POINTER_ID_SHIFT);
        sb.append(")");
    }
    sb.append("[");
    for (int i = 0; i < event.getPointerCount(); i++) {
        sb.append("#").append(i);
        sb.append("(pid ").append(event.getPointerId(i));
        sb.append(")=").append((int) event.getX(i));
        sb.append(",").append((int) event.getY(i));
        if (i + 1 < event.getPointerCount())
            sb.append(";");
    }
    sb.append("]");
   // Log.d(TAG, sb.toString());
}

/** Determine the space between the first two fingers */
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);
}

/** Calculate the mid point of the first two fingers */
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);
}
}    

//这些矩阵将用于移动和缩放图像
矩阵=新矩阵（）；
矩阵savedMatrix=新矩阵（）；
//最大和最小变焦
//专用静态最终浮点最小值\缩放=1.0f；
//专用静态最终浮动最大缩放=5.0f；
//scale=Math.max（最小缩放，数学最小（缩放，最大缩放））；
//我们可能处于这三种状态之一
静态最终int NONE=0；
静态最终整数阻力=1；
静态最终整数缩放=2；
int模式=无；
//记住一些关于缩放的事情
PointF start=新的PointF（）；
PointF mid=新的PointF（）；
浮动oldDist=1f；
字符串savedItemClicked；
图像视图；
@凌驾
创建时的公共void（Bundle savedInstanceState）{
super.onCreate（savedInstanceState）；
setContentView（R.layout.kaart）；
视图=（ImageView）findViewById（R.id.kaart）；
view.setOnTouchListener（这个）；
}
公共布尔onTouch（视图v，运动事件）{
//TODO自动生成的方法存根
ImageView视图=（ImageView）v；
dumpEvent（事件）；
//在这里处理触摸事件。。。
开关（event.getAction（）&MotionEvent.ACTION\u掩码）{
case MotionEvent.ACTION\u DOWN：
savedMatrix.set（矩阵）；
set（event.getX（），event.getY（））；
//Log.d（标记“mode=DRAG”）；
模式=拖动；
打破
case MotionEvent.ACTION\u指针\u向下：
oldDist=间距（事件）；
//Log.d（标记“oldDist=“+oldDist”）；
如果（旧区>10f）{
savedMatrix.set（矩阵）；
中点（中点，事件）；
模式=缩放；
//Log.d（标记“mode=ZOOM”）；
}
打破
case MotionEvent.ACTION\u UP：
case MotionEvent.ACTION\u指针\u向上：
模式=无；
//Log.d（标记“mode=NONE”）；
打破
case MotionEvent.ACTION\u移动：
如果（模式==拖动）{
// ...
矩阵集（savedMatrix）；
postTranslate（event.getX（）-start.x，event.getY（））
-开始（y）；
}else if（模式==缩放）{
float newDist=间距（事件）；
//Log.d（标记“newDist=“+newDist”）；
如果（新距离>10f）{
矩阵集（savedMatrix）；
浮动比例=新距离/旧距离；
矩阵。后标度（标度、标度、中x、中y）；
}
}
打破
}
limitZoom（矩阵）；
极限阻力（矩阵）；
视图.setImageMatrix（矩阵）；
返回true；
}
@抑制警告（“弃用”）
私有void转储事件（MotionEvent事件）{
字符串名称[]={“向下”、“向上”、“移动”、“取消”、“外部”，
“指针向下”、“指针向上”、“7？”、“8？”、“9？”；
StringBuilder sb=新的StringBuilder（）；
int action=event.getAction（）；
int actionCode=action&MotionEvent.action\u掩码；
附加（名称[动作代码]）；
如果（actionCode==MotionEvent.ACTION\u指针\u向下
||actionCode==MotionEvent.ACTION（指针向上）{
某人追加（“（pid”）。追加(
动作>>MotionEvent.action\u指针\u ID\u移位）；
某人加上（“）”；
}
某人加上（“[”）；
for（int i=0；i

希望有人能帮助我。我真的很感激

编辑

我添加了我在某处找到的两个函数

    private void limitZoom(Matrix m) {

    float[] values = new float[9];
    m.getValues(values);
    float scaleX = values[Matrix.MSCALE_X];
    float scaleY = values[Matrix.MSCALE_Y];
    if(scaleX > MAX_ZOOM) {
        scaleX = MAX_ZOOM;
    } else if(scaleX < MIN_ZOOM) {
        scaleX = MIN_ZOOM;
    }

    if(scaleY > MAX_ZOOM) {
        scaleY = MAX_ZOOM;
    } else if(scaleY < MIN_ZOOM) {
        scaleY = MIN_ZOOM;
    }

    values[Matrix.MSCALE_X] = scaleX;
    values[Matrix.MSCALE_Y] = scaleY; 
    m.setValues(values);
}

private void limitZoom（矩阵m）{
浮点[]值=新浮点[9]；
m、 获取值（值）；
float scaleX=值[Matrix.MSCALE_X]；
float scaleY=值[Matrix.MSCALE_Y]；
如果（缩放>最大缩放）{
scaleX=最大缩放；
}else if（scaleX最大缩放）{
scaleY=最大缩放；
}else if（缩放<最小缩放）{
scaleY=最小缩放；
}
值[Matrix.MSCALE_X]=scaleX；
值[Matrix.MSCALE_Y]=scaleY；
m、 设置值（值）；
}

及

private void limitDrag（矩阵m）{
浮点[]值=新浮点[9]；
m、 获取值（值）；
float transX=值[Matrix.MTRANS_X]；
float transY=值[Matrix.MTRANS_Y]；
float scaleX=值[Matrix.MSCALE_X]；
float scaleY=值[Matrix.MSCALE_Y]；
ImageView iv=（ImageView）findViewById（R.id.kaart）；
Rect-bounds=iv.getDrawable（）.getBounds（）；
int viewWidth=getResources（）.getDisplayMetrics（）.widthPixels；
int viewHeight=getResources（）.getDisplayMetrics（）.heightPixels；
int width=bounds.right-bounds.left；
int height=bounds.bottom-bounds.top；
浮动最小值=（-width+20）*scaleX；
浮雕肉末=（-height+20）*鳞片；
如果（tr
private void limitDrag(Matrix m) {
    float[] values = new float[9];
    m.getValues(values);
    float transX = values[Matrix.MTRANS_X];
    float transY = values[Matrix.MTRANS_Y];
    float scaleX = values[Matrix.MSCALE_X];
    float scaleY = values[Matrix.MSCALE_Y];

    ImageView iv = (ImageView)findViewById(R.id.kaart);
    Rect bounds = iv.getDrawable().getBounds();
    int viewWidth = getResources().getDisplayMetrics().widthPixels;
    int viewHeight = getResources().getDisplayMetrics().heightPixels;

    int width = bounds.right - bounds.left;
    int height = bounds.bottom - bounds.top;

    float minX = (-width + 20) * scaleX; 
    float minY = (-height + 20) * scaleY;

    if(transX > (viewWidth - 20)) {
        transX = viewWidth - 20;
    } else if(transX < minX) {
        transX = minX;
    }

    if(transY > (viewHeight - 80)) {
        transY = viewHeight - 80;
    } else if(transY < minY) {
        transY = minY;
    }

    values[Matrix.MTRANS_X] = transX;
    values[Matrix.MTRANS_Y] = transY; 
    m.setValues(values);
}