tamaño - resolucion de imagenes en android studio

Android: redimensionamiento/escalado de imagen de alta calidad

Question

Necesito reducir las imágenes provenientes de una transmisión en red sin perder calidad.

Estoy al tanto de esta solución. Extraño problema de memoria al cargar una imagen en un objeto Bitmap, pero es demasiado gruesa - inSampleSize es un número entero y no permite un control más inSampleSize sobre las dimensiones resultantes. Es decir, necesito escalar imágenes a dimensiones h / w específicas (y mantener la relación de aspecto).

No me importa tener un algoritmo de bricolaje bicúbico / lancoz en mi código, pero no puedo encontrar ningún ejemplo que funcione en Android, ya que todos confían en Java2D (JavaSE).

EDITAR: He adjuntado una fuente rápida. El original es una captura de pantalla de 720x402 HD. Por favor ignore las 2 mejores miniaturas. La imagen principal superior se redimensiona automáticamente por android (como parte del diseño) a aproximadamente 130x72. Es lindo y fresco. La imagen inferior se redimensiona con API y tiene artefactos severos

También intenté usar BitmapFactory y, como dije antes, tiene dos problemas: no hay forma de escalar al tamaño exacto y la imagen escalada es borrosa.

¿Alguna idea sobre cómo arreglar el artefacto?

¡Gracias!

 package qp.test;
import android.app.Activity;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Matrix;
import android.os.Bundle;
import android.widget.ImageView;
public class imgview extends Activity {
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
Bitmap original = BitmapFactory.decodeResource(getResources(), R.drawable.a000001570402);
Bitmap resized = getResizedBitmap(original, 130);
//Bitmap resized = getResizedBitmap2(original, 0.3f);
System.err.println(resized.getWidth() + "x" + resized.getHeight());
ImageView image = (ImageView) findViewById(R.id.ImageViewFullManual);
image.setImageBitmap(resized);
}
private Bitmap getResizedBitmap(Bitmap bm, int newWidth) {
int width = bm.getWidth();
int height = bm.getHeight();
float aspect = (float)width / height;
float scaleWidth = newWidth;
float scaleHeight = scaleWidth / aspect; // yeah!
// create a matrix for the manipulation
Matrix matrix = new Matrix();
// resize the bit map
matrix.postScale(scaleWidth / width, scaleHeight / height);
// recreate the new Bitmap
Bitmap resizedBitmap = Bitmap.createBitmap(bm, 0, 0, width, height, matrix, true);
bm.recycle();
return resizedBitmap;
}
private Bitmap getResizedBitmap2(Bitmap bm, float scale) {
/* float aspect = bm.getWidth() / bm.getHeight();
int scaleWidth = (int) (bm.getWidth() * scale);
int scaleHeight = (int) (bm.getHeight() * scale);
*/
// original image is 720x402 and SampleSize=4 produces 180x102, which is
// still too large
BitmapFactory.Options bfo = new BitmapFactory.Options();
bfo.inSampleSize = 4;
return BitmapFactory.decodeResource(getResources(), R.drawable.a000001570402, bfo);
}
}

Y el diseño

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:orientation="vertical"
android:layout_width="fill_parent"
android:layout_height="wrap_content"
>
<!-- <TextView
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:text="hullo" android:background="#00ff00"
/>
-->
<ImageView android:id="@+id/ImageViewThumbAuto"
android:layout_width="130dip" android:layout_height="72dip"
android:src="@drawable/a000001570402" />
<ImageView android:id="@+id/ImageViewThumbManual"
android:layout_width="130dip" android:layout_height="72dip"
android:src="@drawable/a000001570402"
android:layout_toRightOf="@id/ImageViewThumbAuto"
/>
<ImageView android:id="@+id/ImageViewFullAuto" android:layout_width="300dip"
android:layout_height="169dip"
android:scaleType="fitXY"
android:src="@drawable/a000001570402"
android:layout_below="@id/ImageViewThumbAuto"
/>
<ImageView android:id="@+id/ImageViewFullManual" android:layout_width="300dip"
android:layout_height="169dip"
android:scaleType="fitXY"
android:src="@drawable/a000001570402"
android:layout_below="@id/ImageViewFullAuto"
/>
</RelativeLayout>

Answer 1

La imagen grande superior simplemente se reduce a 450px por el diseño para que no haya artefactos.

Los artefactos de la imagen grande de abajo resultan de reducirlos a 130px de ancho y luego subir nuevamente a aproximadamente 450px por el diseño. Entonces los artefactos están hechos por su escala. Tratar

Bitmap resized = getResizedBitmap(original, 450);

en tu código y debería estar bien. Sin embargo, también debe adaptarlo al ancho de la pantalla actual del teléfono.

Answer 2

En resumen, un buen algoritmo de reducción de escala (no como el vecino más cercano) consta de 2 pasos:

1. downscale utilizando BitmapFactory.Options :: inSampleSize-> BitmapFactory.decodeResource () lo más cerca posible de la resolución que necesita, pero no menos que
2. obtener la resolución exacta reduciendo la escala un poco usando Canvas :: drawBitmap ()

Aquí hay una explicación detallada de cómo SonyMobile resolvió esta tarea: http://developer.sonymobile.com/2011/06/27/how-to-scale-images-for-your-android-application/

Aquí está el código fuente de utilidades de escala de SonyMobile: http://developer.sonymobile.com/downloads/code-example-module/image-scaling-code-example-for-android/

Answer 3

Puede usar BitmapFactory.Options con la (s) función (es) BitmapFactory.decode ,
usando inDensity y inTargetDensity

Ejemplo: tiene un tamaño de imagen de 1600x1200 y desea cambiar el tamaño a 640x480
luego ''inDensity''=5 y ''inTargetDensity''=2 (1600x2 igual a 640x5).

Esperando esta ayuda.