come ingrandire l'immagine in coordinate specificate in Android

Question

Vorrei ingrandire l'immagine in una porzione particolare (a coordinate specificate) dell'immagine. Ho un'immagine, l'ho visualizzata nella visualizzazione di immagini Android a schermo intero. quando clicco su un pulsante vorrei ingrandire l'immagine con le coordinate specificate dell'immagine.le dire che le coordinate che ho sono lasciate: 500, in alto: 50, larghezza: 60 e altezza: 20. Voglio lo zoom completo dell'immagine alle coordinate specificate e adattare questa immagine secondaria al centro della vista dell'immagine.

Attualmente lo sto facendo ritagliando l'immagine alle coordinate specificate. Otterrò una piccola immagine. Lo sto visualizzando nella vista dell'immagine. Ma penso che non sia una buona soluzione.

Qualcuno può aiutarmi a trovare il modo di implementare la funzionalità di zoom.

Answer 1

può essere questo è quello che cerca:

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

per ulteriori informazioni è possibile consultare:

This link Github can help you more

enter link description here

Edit:

si rimanda questo avrai la tua risposta:

The Answer for your question

Answer 2

Utilizzare questa classe ImageView personalizzato per voi di vista. Quindi se si desidera mantenere Zoom pizzico, è possibile utilizzare anche quello altrimenti rimuoverà tutti i movimenti da esso. Puoi vedere un "Metodo doppio tocco" nella classe indicata di seguito. Basta chiamare questo codice metodo al clic del tuo pulsante.

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

} 

Spero che questo vi aiuterà!