wie man das Bild zu den angegebenen Koordinaten in Android

Question

zoomen Ich möchte das Bild zu bestimmten Teil (zu angegebenen Koordinaten) des Bildes zu vergrößern. Ich habe ein Bild, ich habe es in Android-Bildansicht mit Vollbild angezeigt. wenn ich auf einen Knopf klicke, möchte ich das Bild zu den spezifizierten Koordinaten des Bildes zoomen. lets sagen Koordinaten, die ich habe, ist gelassen: 500, Spitze: 50, Breite: 60 und Höhe: 20. Ich möchte, dass das Vollbild auf die angegebenen Koordinaten zoomt und dieses Teilbild in die Mitte der Bildansicht passt.

Momentan mache ich es, indem ich das Bild auf bestimmte Koordinaten zuschneide. Ich werde ein kleines Bild bekommen. Ich zeige es in der Bildansicht an. Aber ich denke, es ist keine so gute Lösung.

Kann mir jemand helfen, die Zoomfunktionalität zu implementieren?

Answer 1

Kann sein, das ist, was Sie suchen:

/** 
* 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); 
} 

für weitere Informationen können Sie sich beziehen:

This link Github can help you more

enter link description here

Edit:

bitte diese beziehen Du bekommst deine Antwort:

The Answer for your question

Answer 2

Verwenden Sie diese Gewohnheit Image Klasse für Sie Bildansicht. Wenn Sie Pinch Zoom beibehalten möchten, können Sie das auch verwenden, ansonsten entfernen Sie alle Gesten. Sie können eine "Double Tap-Methode" in der unten angegebenen Klasse sehen. Rufen Sie einfach diesen Methodencode mit einem Klick auf Ihre Schaltfläche auf.

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); 
} 

} 

Hoffe, das wird helfen!