android - programacion - Colocar algún indicador alrededor de la imagen en las operaciones de movimiento/cambio de tamaño/giro de la imagen

manual de programacion android pdf

Question

Me gustaría escalar, mover, cambiar el tamaño de la imagen. Me gustaría rodear la imagen con indicadores que guían al usuario sobre la operación que realizan estos indicadores, es decir, movimiento, rotación, escalado.

He intentado

• Escalado - pero sólo recorta. No hay posibilidad de aumentar la longitud y la altura de la imagen.
• Girar - logrado pero mediante la inserción de grados manuales. Esa no es una buena opción aquí.
• Moviéndome, ya que estoy logrando arrastrar Api <11. Tan poco difícil. Todavía no hay esperanza aquí.

¿Hay alguna biblioteca que me pueda hacer una simple edición de imagen [Mover, escalar, rotar]?

Answer 1

Creo que puedo ayudarte con la parte de rotación. Recientemente hice una biblioteca de menú de la rueda de Android. Rastrea el movimiento de la mano del usuario y gira la vista de la imagen en consecuencia Puedes ver la fuente para ver cómo lo hice aquí:

https://github.com/anupcowkur/Android-Wheel-Menu

Answer 2

Puede https://github.com/siddhpuraamitr/MultitouchWithDynamicAddandRemove probar este código en su proyecto

Answer 3

Puede utilizar la transaformación de Matrix para lograr rotación, escalado y movimiento ... Espero que esto le ayude ...

para rotar

Matrix matrix = new Matrix();
    matrix.postRotate(90);

para escalar

 matrix.postScale(scaleWidth, scaleHeight);

crear nuevo mapa de bits sin cambiar el original ... como este

Bitmap bmp2 = Bitmap.createBitmap(bmp1, 0, 0, pow2, pow2, matrix, true);

Answer 4

Recientemente intenté lo mismo pero terminé usando una biblioteca, ya que cubría muchos más casos de borde. Esta es una gran biblioteca, y bastante ampliamente utilizada:

http://code.google.com/p/android-multitouch-controller/

Answer 5

Sé que esto no es una respuesta pero vale la pena mencionarlo.

Echa un vistazo a este proyecto . Tengo la intención de ponerlo en GitHub pero aún no está hecho (en absoluto).

Hay un botón para rotar la imagen. Todavía estoy trabajando en el "guardar". Muchas de las clases están tomadas de la fuente de Android gracias al github.com/lvillani/android-cropimage

Agregue al manifiesto de su proyecto:

    <activity
        android:name="mobi.sherif.camera.CropImage"
        android:hardwareAccelerated="false"
        android:screenOrientation="portrait" >

Llame a la actividad usando:

Intent intent = new Intent(mContext, CropImage.class);
intent.setData(uri);
startActivityForResult(intent, S.request.cropimage);

Answer 6

Solo mira esta referencia de recorte de imagen:

http://www.londatiga.net/featured-articles/how-to-select-and-crop-image-on-android/

Para la rotación de la imagen, consulte este ejemplo; Este código de ejemplo representa la rotación de la imagen dinámicamente:

http://android-er.blogspot.in/2010/07/rotate-bitmap-image-using-matrix.html

Este enlace también es útil para recortar, rotar y escalar imágenes:

https://github.com/Yalantis/uCrop

Answer 7

Rotación de mapa de bits

Bitmap targetBitmap = Bitmap.createBitmap(targetWidth, targetHeight, config);
Canvas canvas = new Canvas(targetBitmap);
Matrix matrix = new Matrix();
matrix.setRotate(mRotation,source.getWidth()/2,source.getHeight()/2);
canvas.drawBitmap(source, matrix, new Paint());

Escalado de imágenes

AssetManager assetManager = context.getAssets();
InputStream imageIn;
String imgPath = "test.png";
Bitmap image;
try {
    imageIn = assetManager.open(imgPath, AssetManager.ACCESS_BUFFER);
    image = BitmapFactory.decodeStream(imageIn);
} catch (IOException e) {

}
//TODO: calculate width and height to fill or fit screen
image = Bitmap.createScaledBitmap(image, width, height, true);

Imagen en movimiento Imagen en lienzo con eventos táctiles.

import android.content.Context;
import android.graphics.Canvas;
import android.graphics.drawable.BitmapDrawable;
import android.util.AttributeSet;
import android.util.Log;
import android.view.MotionEvent;
import android.view.ScaleGestureDetector;
import android.view.View;

public class ImgView extends View {

private static final int INVALID_POINTER_ID = -1;

    private Drawable mImage;
    private float mPosX;
    private float mPosY;

    private float mLastTouchX;
    private float mLastTouchY;
    private int mActivePointerId = INVALID_POINTER_ID;

    private ScaleGestureDetector mScaleDetector;
    private float mScaleFactor = 1.f;

    public ImgView(Context context) {
        this(context, null, 0);
    mImage = getResources().getDrawable(R.drawable.imagename);

        mImage.setBounds(0, 0, mImage.getIntrinsicWidth(), mImage.getIntrinsicHeight());
    }

    public ImgView(Context context, AttributeSet attrs) {
        this(context, attrs, 0);
    }

    public ImgView(Context context, AttributeSet attrs, int defStyle) {
        super(context, attrs, defStyle);
        mScaleDetector = new ScaleGestureDetector(context, new ScaleListener());
    }

    @Override
    public boolean onTouchEvent(MotionEvent ev) {
        // Let the ScaleGestureDetector inspect all events.
        mScaleDetector.onTouchEvent(ev);

        final int action = ev.getAction();
        switch (action & MotionEvent.ACTION_MASK) {
        case MotionEvent.ACTION_DOWN: {
            final float x = ev.getX();
            final float y = ev.getY();

            mLastTouchX = x;
            mLastTouchY = y;
            mActivePointerId = ev.getPointerId(0);
            break;
        }

        case MotionEvent.ACTION_MOVE: {
            final int pointerIndex = ev.findPointerIndex(mActivePointerId);
            final float x = ev.getX(pointerIndex);
            final float y = ev.getY(pointerIndex);

            // Only move if the ScaleGestureDetector isn''t processing a gesture.
            if (!mScaleDetector.isInProgress()) {
                final float dx = x - mLastTouchX;
                final float dy = y - mLastTouchY;

                mPosX += dx;
                mPosY += dy;

                invalidate();
            }

            mLastTouchX = x;
            mLastTouchY = y;

            break;
        }

        case MotionEvent.ACTION_UP: {
            mActivePointerId = INVALID_POINTER_ID;
            break;
        }

        case MotionEvent.ACTION_CANCEL: {
            mActivePointerId = INVALID_POINTER_ID;
            break;
        }

        case MotionEvent.ACTION_POINTER_UP: {
            final int pointerIndex = (ev.getAction() & MotionEvent.ACTION_POINTER_INDEX_MASK) 
                    >> MotionEvent.ACTION_POINTER_INDEX_SHIFT;
            final int pointerId = ev.getPointerId(pointerIndex);
            if (pointerId == mActivePointerId) {
                // This was our active pointer going up. Choose a new
                // active pointer and adjust accordingly.
                final int newPointerIndex = pointerIndex == 0 ? 1 : 0;
                mLastTouchX = ev.getX(newPointerIndex);
                mLastTouchY = ev.getY(newPointerIndex);
                mActivePointerId = ev.getPointerId(newPointerIndex);
            }
            break;
        }
        }

        return true;
    }

    @Override
    public void onDraw(Canvas canvas) {
        super.onDraw(canvas);

        canvas.save();
        Log.d("DEBUG", "X: "+mPosX+" Y: "+mPosY);
        canvas.translate(mPosX, mPosY);
        canvas.scale(mScaleFactor, mScaleFactor);
        mImage.draw(canvas);
        canvas.restore();
    }

    private class ScaleListener extends ScaleGestureDetector.SimpleOnScaleGestureListener {
        @Override
        public boolean onScale(ScaleGestureDetector detector) {
            mScaleFactor *= detector.getScaleFactor();

            // Don''t let the object get too small or too large.
            mScaleFactor = Math.max(0.1f, Math.min(mScaleFactor, 10.0f));

            invalidate();
            return true;
        }
    }

}

Answer 8

Utilizando la biblioteca: StickerView

Es una biblioteca de terceros que ofrece exactamente lo que estaba buscando.

WorkAround:

Aún así, esta respuesta es la mitad de lo que he pedido en OP. Significa que no está rodeado por algún indicador específico. Todavía estoy buscando cómo envolver ImageView con indicadores y usarlos para Traducir y Cambiar Tamaño.

Iniciación de variables dentro de la Activity importante para traducir y redimensionar ImageView

public static final int DRAG = 1;
public static final int NONE = 0;
private static final String TAG = "Touch";
public static final int ZOOM = 2;
public static PointF mid = new PointF();
public static int mode = 0;
float d = 0.0F;
Matrix savedMatrix = new Matrix();
Matrix matrix = new Matrix();
PointF start = new PointF();

Configuración de ImageView a scaleType - Matrix

iv = new ImageView(this);
iv.setPadding(10, 10, 25, 25);
iv.setScaleType(ImageView.ScaleType.MATRIX);

iv.setOnTouchListener(t);

Agregar el servicio de escucha onTouch a ImageView que usa

• 1 dedo para traducir - arrastrar

• 2 dedos para zoom - Cambiar tamaño {Pellizcar para ampliar}

  View.OnTouchListener t = new View.OnTouchListener()
  {
  public boolean onTouch(View paramView, MotionEvent event)
  {
    ImageView view = (ImageView)paramView;
    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_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;
  
    case MotionEvent.ACTION_UP:
    case MotionEvent.ACTION_POINTER_UP:
  
        mode = NONE;
        Log.d(TAG, "mode=NONE" );
        break;
    }  
    view.setImageMatrix(matrix);
    return true;
  
  }
  
   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);
  }
  
        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);
        }
       };