如何在android中将图像缩放到指定的坐标

我想将图像缩放到图像的特定部分（指定坐标）。 我有一个图像，我在android图像视图中全屏显示。当我点击一个按钮时，我想将图像缩放到指定的图像坐标。假设我的坐标是左：500，上：50，宽：60，高：20。我希望将整个图像缩放到指定的坐标，并将此子图像适配到图像视图的中心

目前，我是通过将图像裁剪到指定的坐标来实现的。我会得到小图像。我正在图像视图中显示它。但我认为这不是一个好的解决办法

---

有人能帮我找到实现缩放功能的方法吗

也许这就是你想要的：

/**
 * Set zoom to the specified scale. Image will be centered around the point
 * (focusX, focusY). These floats range from 0 to 1 and denote the focus point
 * as a fraction from the left and top of the view. For example, the top left 
 * corner of the image would be (0, 0). And the bottom right corner would be (1, 1).
 * @param scale
 * @param focusX
 * @param focusY
 * @param scaleType
 */
public void setZoom(float scale, float focusX, float focusY, ScaleType scaleType) {
    //
    // setZoom can be called before the image is on the screen, but at this point, 
    // image and view sizes have not yet been calculated in onMeasure. Thus, we should
    // delay calling setZoom until the view has been measured.
    //
    if (!onDrawReady) {
        delayedZoomVariables = new ZoomVariables(scale, focusX, focusY, scaleType);
        return;
    }

    if (scaleType != mScaleType) {
        setScaleType(scaleType);
    }
    resetZoom();
    scaleImage(scale, viewWidth / 2, viewHeight / 2, true);
    matrix.getValues(m);
    m[Matrix.MTRANS_X] = -((focusX * getImageWidth()) - (viewWidth * 0.5f));
    m[Matrix.MTRANS_Y] = -((focusY * getImageHeight()) - (viewHeight * 0.5f));
    matrix.setValues(m);
    fixTrans();
    setImageMatrix(matrix);
}

有关更多信息，请参阅：

编辑：

请参考以下内容，您将得到您的答案：

---

将此自定义ImageView类用于图像视图。然后，如果你想保持收缩缩放，那么你也可以使用它，否则删除它的所有手势。您可以在下面给出的类中看到“双击方法”。只需单击按钮即可调用此方法代码

import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.Matrix;
import android.graphics.PointF;
import android.view.GestureDetector;
import android.view.MotionEvent;
import android.view.ScaleGestureDetector;
import android.view.View;
import android.widget.ImageView;

public class TouchImageView extends ImageView {

Matrix matrix = new Matrix();

// 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 last = new PointF();
PointF start = new PointF();
float minScale = 1f;
float maxScale = 3f;
float[] m;

float redundantXSpace, redundantYSpace, origRedundantXSpace, origRedundantYSpace;;

float width, height;
static final int CLICK = 3;
static final float SAVE_SCALE = 1f;
float saveScale = SAVE_SCALE;

float right, bottom, origWidth, origHeight, bmWidth, bmHeight, origScale, origBottom,origRight;

ScaleGestureDetector mScaleDetector;
GestureDetector mGestureDetector;

Context context;

public TouchImageView(Context context) {
    super(context);
    super.setClickable(true);
    this.context = context;
    mScaleDetector = new ScaleGestureDetector(context, new ScaleListener());

    matrix.setTranslate(1f, 1f);
    m = new float[9];
    setImageMatrix(matrix);
    setScaleType(ScaleType.MATRIX);

    setOnTouchListener(new OnTouchListener() {

        @Override
        public boolean onTouch(View v, MotionEvent event) {

            boolean onDoubleTapEvent = mGestureDetector.onTouchEvent(event);
            if (onDoubleTapEvent) {
                // Reset Image to original scale values
                mode = NONE;
                bottom = origBottom;
                right = origRight;
                last = new PointF();
                start = new PointF();
                m = new float[9];
                saveScale = SAVE_SCALE;
                matrix = new Matrix();
                matrix.setScale(origScale, origScale);
                matrix.postTranslate(origRedundantXSpace, origRedundantYSpace);
                setImageMatrix(matrix);
                invalidate();
                return true;
            } 


            mScaleDetector.onTouchEvent(event);

            matrix.getValues(m);
            float x = m[Matrix.MTRANS_X];
            float y = m[Matrix.MTRANS_Y];
            PointF curr = new PointF(event.getX(), event.getY());

            switch (event.getAction()) {
            case MotionEvent.ACTION_DOWN:
                last.set(event.getX(), event.getY());
                start.set(last);
                mode = DRAG;
                break;
            case MotionEvent.ACTION_MOVE:
                if (mode == DRAG) {
                    float deltaX = curr.x - last.x;
                    float deltaY = curr.y - last.y;
                    float scaleWidth = Math.round(origWidth * saveScale);
                    float scaleHeight = Math.round(origHeight * saveScale);
                    if (scaleWidth < width) {
                        deltaX = 0;
                        if (y + deltaY > 0)
                            deltaY = -y;
                        else if (y + deltaY < -bottom)
                            deltaY = -(y + bottom);
                    } else if (scaleHeight < height) {
                        deltaY = 0;
                        if (x + deltaX > 0)
                            deltaX = -x;
                        else if (x + deltaX < -right)
                            deltaX = -(x + right);
                    } else {
                        if (x + deltaX > 0)
                            deltaX = -x;
                        else if (x + deltaX < -right)
                            deltaX = -(x + right);

                        if (y + deltaY > 0)
                            deltaY = -y;
                        else if (y + deltaY < -bottom)
                            deltaY = -(y + bottom);
                    }
                    matrix.postTranslate(deltaX, deltaY);
                    last.set(curr.x, curr.y);
                }
                break;

            case MotionEvent.ACTION_UP:
                mode = NONE;
                int xDiff = (int) Math.abs(curr.x - start.x);
                int yDiff = (int) Math.abs(curr.y - start.y);
                if (xDiff < CLICK && yDiff < CLICK)
                    performClick();
                break;

            case MotionEvent.ACTION_POINTER_UP:
                mode = NONE;
                break;
            }

            setImageMatrix(matrix);
            invalidate();

            return true; // indicate event was handled
        }

    });

    mGestureDetector = new GestureDetector(context, new GestureDetector.SimpleOnGestureListener() {
        @Override
        public boolean onDoubleTapEvent(MotionEvent e) {
            return true;
        }
    });
}

@Override
public void setImageBitmap(Bitmap bm) {
    super.setImageBitmap(bm);
    bmWidth = bm.getWidth();
    bmHeight = bm.getHeight();
}

public void setMaxZoom(float x) {
    maxScale = x;
}

private class ScaleListener extends
        ScaleGestureDetector.SimpleOnScaleGestureListener {
    @Override
    public boolean onScaleBegin(ScaleGestureDetector detector) {
        mode = ZOOM;
        return true;
    }

    @Override
    public boolean onScale(ScaleGestureDetector detector) {
        float mScaleFactor = (float) Math.min(
                Math.max(.95f, detector.getScaleFactor()), 1.05);
        float origScale = saveScale;
        saveScale *= mScaleFactor;
        if (saveScale > maxScale) {
            saveScale = maxScale;
            mScaleFactor = maxScale / origScale;
        } else if (saveScale < minScale) {
            saveScale = minScale;
            mScaleFactor = minScale / origScale;
        }
        right = width * saveScale - width
                - (2 * redundantXSpace * saveScale);
        bottom = height * saveScale - height
                - (2 * redundantYSpace * saveScale);
        if (origWidth * saveScale <= width
                || origHeight * saveScale <= height) {
            matrix.postScale(mScaleFactor, mScaleFactor, width / 2,
                    height / 2);
            if (mScaleFactor < 1) {
                matrix.getValues(m);
                float x = m[Matrix.MTRANS_X];
                float y = m[Matrix.MTRANS_Y];
                if (mScaleFactor < 1) {
                    if (Math.round(origWidth * saveScale) < width) {
                        if (y < -bottom)
                            matrix.postTranslate(0, -(y + bottom));
                        else if (y > 0)
                            matrix.postTranslate(0, -y);
                    } else {
                        if (x < -right)
                            matrix.postTranslate(-(x + right), 0);
                        else if (x > 0)
                            matrix.postTranslate(-x, 0);
                    }
                }
            }
        } else {
            matrix.postScale(mScaleFactor, mScaleFactor,
                    detector.getFocusX(), detector.getFocusY());
            matrix.getValues(m);
            float x = m[Matrix.MTRANS_X];
            float y = m[Matrix.MTRANS_Y];
            if (mScaleFactor < 1) {
                if (x < -right)
                    matrix.postTranslate(-(x + right), 0);
                else if (x > 0)
                    matrix.postTranslate(-x, 0);
                if (y < -bottom)
                    matrix.postTranslate(0, -(y + bottom));
                else if (y > 0)
                    matrix.postTranslate(0, -y);
            }
        }
        return true;

    }
}

@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
    super.onMeasure(widthMeasureSpec, heightMeasureSpec);
    width = MeasureSpec.getSize(widthMeasureSpec);
    height = MeasureSpec.getSize(heightMeasureSpec);
    // Fit to screen.
    float scale;
    float scaleX = (float) width / (float) bmWidth;
    float scaleY = (float) height / (float) bmHeight;
    scale = Math.min(scaleX, scaleY);
    matrix.setScale(scale, scale);
    setImageMatrix(matrix);
    saveScale = SAVE_SCALE;
    origScale = scale;

    // Center the image
    redundantYSpace = (float) height - (scale * (float) bmHeight);
    redundantXSpace = (float) width - (scale * (float) bmWidth);
    redundantYSpace /= (float) 2;
    redundantXSpace /= (float) 2;

    origRedundantXSpace = redundantXSpace;
    origRedundantYSpace = redundantYSpace;

    matrix.postTranslate(redundantXSpace, redundantYSpace);

    origWidth = width - 2 * redundantXSpace;
    origHeight = height - 2 * redundantYSpace;
    right = width * saveScale - width - (2 * redundantXSpace * saveScale);
    bottom = height * saveScale - height
            - (2 * redundantYSpace * saveScale);
    origRight = right;
    origBottom = bottom;
    setImageMatrix(matrix);
}

}

导入android.content.Context；
导入android.graphics.Bitmap；
导入android.graphics.Matrix；
导入android.graphics.PointF；
导入android.view.GestureDetector；
导入android.view.MotionEvent；
导入android.view.scalegestruedetector；
导入android.view.view；
导入android.widget.ImageView；
公共类TouchImageView扩展了ImageView{
矩阵=新矩阵（）；
//我们可能处于这三种状态之一
静态最终int NONE=0；
静态最终整数阻力=1；
静态最终整数缩放=2；
int模式=无；
//记住一些关于缩放的事情
PointF last=新的PointF（）；
PointF start=新的PointF（）；
浮动最小刻度=1f；
浮点最大刻度=3f；
浮动[]m；
浮点redundantXSpace，redundantYSpace，origRedundantXSpace，origRedundantYSpace；；
浮动宽度、高度；
静态最终int CLICK=3；
静态最终浮点数保存比例=1f；
浮动保存比例=保存比例；
右浮动、底部、原点宽度、原点光、BM宽度、BM高度、原点刻度、原点底部、原点光；
scalegestruedetector mScaleDetector；
手势检测器mGestureDetector；
语境；
公共TouchImageView（上下文）{
超级（上下文）；
super.setClickable（true）；
this.context=上下文；
mScaleDetector=新的scalegestruedetector（上下文，新的ScaleListener（））；
矩阵.setTranslate（1f，1f）；
m=新浮点数[9]；
setImageMatrix（矩阵）；
setScaleType（ScaleType.MATRIX）；
setOnTouchListener（新的OnTouchListener（）{
@凌驾
公共布尔onTouch（视图v，运动事件）{
布尔OnDoubleTapeEvent=mGestureDetector.onTouchEvent（事件）；
如果（onDoubleTapEvent）{
//将图像重置为原始比例值
模式=无；
底部=起始底部；
右=原点；
last=新点f（）；
开始=新的点f（）；
m=新浮点数[9]；
saveScale=保存比例；
矩阵=新矩阵（）；
矩阵。设置刻度（初始刻度，初始刻度）；
后翻译（origRedundantXSpace，origRedundantYSpace）；
setImageMatrix（矩阵）；
使无效（）；
返回true；
} 
mScaleDetector.onTouchEvent（事件）；
矩阵值（m）；
float x=m[矩阵MTRANS_x]；
浮点y=m[矩阵MTRANS_y]；
PointF curr=新的PointF（event.getX（），event.getY（））；
开关（event.getAction（））{
case MotionEvent.ACTION\u DOWN：
set（event.getX（），event.getY（））；
开始。设置（最后）；
模式=拖动；
打破
case MotionEvent.ACTION\u移动：
如果（模式==拖动）{
浮动deltaX=当前x-最后x；
浮动三角洲=当前y-最后y；
float scaleWidth=Math.round（origWidth*saveScale）；
float scalehHeight=数学圆整（origHeight*saveScale）；
if（标度宽度<宽度）{
deltaX=0；
如果（y+deltaY>0）
deltaY=-y；
否则如果（y+deltaY<-底部）
三角洲=-（y+底部）；
}else if（刻度高度<高度）{
deltaY=0；
如果（x+deltaX>0）
deltaX=-x；
否则如果（x+deltaX<-右）
deltaX=-（x+右侧）；
}否则{
如果（x+deltaX>0）
deltaX=-x；
否则如果（x+deltaX<-右）
deltaX=-（x+右侧）；
如果（y+deltaY>0）
deltaY=-y；
否则如果（y+deltaY<-底部）
三角洲=-（y+底部）；
}
矩阵。后翻译（deltaX、deltaY）；
最后一组（当前x、当前y）；
}
打破
case MotionEvent.ACTION\u UP：
模式=无；
intxdiff=（int）Math.abs（curr.x-start.x）；
int yDiff=（int）Math.abs（curr.y-start.y）；
if（xDiff