Set Max and Min zoom on TouchEvent in Android

Question

I copied this kind of code to make a ImageView scrollable.

example.setOnTouchListener(new View.OnTouchListener() {
        @Override
        public boolean onTouch(View v, MotionEvent event) {
            ImageView view = (ImageView) v;
            view.setScaleType(ImageView.ScaleType.MATRIX);
            float scale;

            dumpEvent(event);
            //Handle touch events here...

            switch (event.getAction() & MotionEvent.ACTION_MASK) {
                case MotionEvent.ACTION_DOWN: //first finger down only
                    savedMatrix.set(matrix);
                    start.set(event.getX(), event.getY());
                    Log.d(TAG, "mode=DRAG");
                    mode = DRAG;
                    break;
                case MotionEvent.ACTION_UP://first finger lifted

                case MotionEvent.ACTION_POINTER_UP: //second finger lifted
                    mode = NONE;
                    Log.d(TAG, "mode=NONE");
                    break;
                case MotionEvent.ACTION_POINTER_DOWN: //first and second finger 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_MOVE:
                    if (mode == DRAG) {
                        matrix.set(savedMatrix);
                        matrix.postTranslate(event.getX() - start.x, event.getY() - start.y); //create the transformation in the matrix of points
                    } else if (mode == ZOOM) {
                        //pinch zooming
                        float newDist = spacing(event);
                        Log.d(TAG, "newDist=" + newDist);
                        if (newDist > 10f) {
                            matrix.set(savedMatrix);
                            scale = newDist / oldDist; //setting the scaling of the matrix...
                            //if scale > 1 means zoom in
                            // if scale < 1 means zoom out
                            matrix.postScale(scale, scale, mid.x, mid.y);
                        }
                    }
                    break;
            }
            view.setImageMatrix(matrix); //display the transformation on screen

            return true; //indicate event was handled
        }

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

        /*
         * --------------------------------------------------------------------------
         * Method: midPoint Parameters: PointF object, MotionEvent Returns: void
         * Description: calculates the midpoint between the 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);
        }

Where do I have to put a variable to set a max and min zoom.

At the Moment I can zoom in or out endless.

Kind Regards!

create a float min like : `private static final float MIN_ZOOM = 1.0f;` and a max :`private static final float MAX_ZOOM = WHAT_YOU_WANT;` and then declare a scale as follows : `float scale = Math.max(MIN_ZOOM, Math.min(scale, MAX_ZOOM));` — Skizo-ozᴉʞS ツ, Sep 21 '15 at 09:02
Thank you for your answer! Can you tell me where do i have to put this in? I have this kind of code already here = `scale = newDist / oldDist;` — korunos, Sep 21 '15 at 09:12
Check this [answer](http://stackoverflow.com/a/18395969/4385913) — Skizo-ozᴉʞS ツ, Sep 21 '15 at 09:30

score 3 · Accepted Answer · edited May 23 '17 at 12:15

3

You have to create a MIN_ZOOM, MAX_ZOOM, and then scale it as follows :

private static final float MIN_ZOOM = 1.0f; 
private static final float MAX_ZOOM = WHAT_YOU_WANT; 
float scale = Math.max(MIN_ZOOM, Math.min(scale, MAX_ZOOM));

For more information check this answer

edited May 23 '17 at 12:15

Community

1
1

answered Sep 21 '15 at 09:49

Skizo-ozᴉʞS ツ

19,464
18
81
148

score 0 · Answer 2 · answered Sep 21 '15 at 09:30

You should have variable for total scale, because your scale is just diff between current scale and previous scale. And normalize your local scale if you total out of bounds.

    // normalize scale
    if (scale * scaleAll > MAX_ZOOM) {
        scale = MAX_ZOOM / scaleAll;
    }
    if (scale * scaleAll < MIN_ZOOM) {
        scale = MIN_ZOOM / scaleAll;
    }

The all code would be:

private static final float MIN_ZOOM = 0.1f;
private static final float MAX_ZOOM = 4f;
private float scaleAll = 1;

boolean someMethod() {
    // Some code
    example.setOnTouchListener(new View.OnTouchListener()        {
        @Override
        public boolean onTouch(View v, MotionEvent event) {
            ImageView view = (ImageView) v;
            view.setScaleType(ImageView.ScaleType.MATRIX);
            float scale;

            dumpEvent(event);
            //Handle touch events here...

            switch (event.getAction() & MotionEvent.ACTION_MASK) {
                case MotionEvent.ACTION_DOWN: //first finger down only
                    savedMatrix.set(matrix);
                    start.set(event.getX(), event.getY());
                    Log.d(TAG, "mode=DRAG");
                    mode = DRAG;
                    break;
                case MotionEvent.ACTION_UP://first finger lifted

                case MotionEvent.ACTION_POINTER_UP: //second finger lifted
                    mode = NONE;
                    Log.d(TAG, "mode=NONE");
                    break;
                case MotionEvent.ACTION_POINTER_DOWN: //first and second finger 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_MOVE:
                    if (mode == DRAG) {
                        matrix.set(savedMatrix);
                        matrix.postTranslate(event.getX() - start.x, event.getY() - start.y); //create the transformation in the matrix of points
                    } else if (mode == ZOOM) {
                        //pinch zooming
                        float newDist = spacing(event);
                        Log.d(TAG, "newDist=" + newDist);
                        if (newDist > 10f) {
                            scale = newDist / oldDist; //setting the scaling of the matrix...

                            // normalize scale
                            if (scale * scaleAll > MAX_ZOOM) {
                                scale = MAX_ZOOM / scaleAll;
                            }
                            if (scale * scaleAll < MIN_ZOOM) {
                                scale = MIN_ZOOM / scaleAll;
                            }
                            scaleAll*=scale;
                            matrix.set(savedMatrix);
                            //if scale > 1 means zoom in
                            // if scale < 1 means zoom out
                            matrix.postScale(scale, scale, mid.x, mid.y);
                        }
                    }
                    break;
            }
            view.setImageMatrix(matrix); //display the transformation on screen

            return true; //indicate event was handled
        }
    }
}

score 0 · Answer 3 · answered Sep 21 '15 at 09:31

 case MotionEvent.ACTION_MOVE:
                    if (mode == DRAG) { 
                        matrix.set(savedMatrix); 
                        matrix.postTranslate(event.getX() - start.x, event.getY() - start.y); //create the transformation in the matrix of points
                    } else if (mode == ZOOM) { 
                        //pinch zooming 
                        float newDist = spacing(event);
                        Log.d(TAG, "newDist=" + newDist);
                        if (newDist > 10f) {
                            matrix.set(savedMatrix); 
                            scale = newDist / oldDist; //setting the scaling of the matrix...
                            //if scale > 1 means zoom in 
                            // if scale < 1 means zoom out

/* Here you can add some thing like this*/

                      if(scale >= 1 && scale < maxZoom || scale <1 && scale >= minZoom){

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

maxZoom = 5 or whatever value you want

minZoom = 0.25 or whatever value you want

This fix won't work. You apply zoom check for zoom delta, it is mean, that you cannot scale more than maxZoom or less than minZoom by one gesture, BUT NOT for all scale. — Oleksandr, Sep 21 '15 at 09:49

Set Max and Min zoom on TouchEvent in Android

3 Answers3