Procesamiento de imágenes, iniciamos de nuevo #2

[zero_master]

Gente saludos, disculpen que me tardara en poner un tema nuevo y darle seguimiento a esto, algunos que me conocen cof cof solo 2 personas en el foro (Ivar666 y aailil_os), sabrán que estoy en mi maestría y como en todas las escuela siempre la recta final es la mas cabrona.

Bueno, iniciemos con la parte 2; para iniciar en el tema anterior http://www.forosdelweb.com/f165/proc...-nuevo-956858/ vimos como esta compuesta una imagen, pero estamos en una sección sobre Android, como vamos a leer una imagen desde android o como vamos a desplegar la imagen, como rayos voy a sacar la información de la imagen en este caso los valores ARGB.

Iniciemos creando un nuevo proyecto, si no saben hacer esta parte no me pregunten jaja ya deberían saber, la versión que normalmente utilice es para android 2.2 muchas de las razones es que mi celular esta en esa versión aunque tenga mi tablet Asus pero pff jeje dependiendo de la complejidad que vayas a realizar un proyecto es la versión que deberías utilizar por que utilizar la versión mas nueva cuando solo vas a utilizar librerías "comunes".

Como buen amante del procesamiento de imagenes debemos seleccionar una imagen con la cual vamos a trabajar, yo te elijo LENAAAA

Por que esta imagen? fácil es una imagen muy común donde tenemos una gran variedad de colores y formas, ademas de que tiene una dimensión de 512x512 que son de las imágenes mas cotidianas cuando hacemos procesamiento de imágenes... sobre todo que ta bonita no lo creen jeje bueno esta imagen lo vamos a guardar en la carpeta de nuestro workspace.

Actualizamos nuestro proyecto para que aparezca la imagen en nuestra Package Explorer del Eclipse. Ya en nuestro proyecto vamos a empezar con adquirir la imagen y mostrarla. Lo primero es declarar nuestras variables globales en este caso serán el ImageView y nuestro Bitmap que sera nuestra imagen lena.

public class ForoImagProActivity extends Activity {
ImageView view; Bitmap Imag;
/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
}
}

De igual forma nuestras librerias que utilizaremos por el momento son las siguientes:

import android.app.Activity;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.os.Bundle;
import android.widget.ImageView;

Nuestro layout quedara de la siguiente forma, solo necesitamos un ImageView cosa que es fácil de declarar.

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:orientation="vertical"
android:layout_width="fill_parent"
android:layout_height="fill_parent"
>
<ImageView
android:src="@drawable/icon"
android:layout_height="wrap_content"
android:layout_width="wrap_content"
android:id="@+id/imageView1"></ImageView>
</LinearLayout>

Si corremos nuestro programa solo vamos a ver el icono de android, ahora falta adquirir la imagen de lena y mostrarla. Tenemos 2 formas de hacerlo la forma fácil y la forma profesional jeje. Para la forma fácil, en nuestro layout podemos hacer lo siguiente, en el apartado del ImageView donde dice [android:src="@drawable/icon" ] en vez de icon ponemos el nombre de nuestra imagen, en mi caso es lena [android:src="@drawable/lena" ] y automáticamente nos despliega la imagen lena.

La manera profesional es la siguiente:

public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
Imag = BitmapFactory.decodeResource(getResources(), R.drawable.lena); //1
view = (ImageView)findViewById(R.id.imageView1); //2
view.setImageBitmap(Imag); //3
}

Donde en la parte donde tengo indicado //1 estamos cargando nuestra variable Bitmap con la información del drawable lena; en la parte //2 estamos cargando nuestra variable ImageView con el id del ImageView del layout en el cual vamos a desplegar las imágenes. Y para finalizar con el comando setImageBitmap estamos cargando al ImageView la imagen que cargamos en la parte //1.

Ok, ahora podemos crear una función en la cual vamos a leer los datos de la imagen Bitmap y pasarlo como si fuera una matriz, por razones de facilidades en manejo de sus datos; ademas de que la mayoría de los libros usan una matriz de datos.

public static int[][][] BitToMat(Bitmap bmp, boolean format)
{
int picw = bmp.getWidth(); int pich = bmp.getHeight();
int[] pix = new int[picw * pich];
bmp.getPixels(pix, 0, picw, 0, 0, picw, pich);
int matriz[][][] = new int[picw][pich][4];
for (int y = 0; y < pich; y++)
for (int x = 0; x < picw; x++)
{
int index = y * picw + x;
matriz[x][y][0] = (pix[index] >> 24) & 0xff;
matriz[x][y][1] = (pix[index] >> 16) & 0xff;
matriz[x][y][2] = (pix[index] >> 8) & 0xff;
matriz[x][y][3] = pix[index] & 0xff;
if(format)
{
int R = (int)(0.299*matriz[x][y][1] + 0.587*matriz[x][y][2] + 0.114*matriz[x][y][3]);
matriz[x][y][1] = R; matriz[x][y][2] = R; matriz[x][y][3] = R;
}
}
matriz[1][1][0] = picw; matriz[2][2][0] = pich;
return matriz;
}

En esta función dejo un valor booleano en el cual puedo decirle si solo quiero sacar la información en ARGB o pasarlo en sus valores de escala de grises.

Ahora debemos crear una nueva función en la cual le llegara la matriz y lo convertirla en Bitmap para mostrarla.

public void MatToBit(int mat[][][])
{
int picw = mat[1][1][0]; int pich = mat[2][2][0];
int[] pix = new int[picw * pich];
for (int y = 0; y < pich; y++)
for (int x = 0; x < picw; x++)
{
int index = y * picw + x;
pix[index] = 0xff000000 | (mat[x][y][1] << 16) | (mat[x][y][2] << 8) | mat[x][y][3];
}
Bitmap bm = Bitmap.createBitmap(picw, pich, Bitmap.Config.ARGB_4444);
bm.setPixels(pix, 0, picw, 0, 0, picw, pich);
view.setImageBitmap(bm);
}

Listoooo!!! ahora como vamos a utilizarlo y cuando llamarlos, tenemos varias opciones una de ellas es agregar un boton que cuando lo pulsemos nos haga la conversión de RGB a Gray; si nos queremos ver bien podemos usar Menus
http://www.forosdelweb.com/f165/hey-...comida-928526/

Como me da flojera solo voy a utilizar lo siguiente:
MatToBit(BitToMat(Imag, true));

Aquí tenemos los resultados:


Que podemos hacer como algo diferentes a lo casual, si conocen el dichoso efecto que muchos hacen en esos programitas que se encuentran en internet para hacer "retoques" donde podemos dejar todo en escala de grises y dejar solo ya sea los ojos o alguna sección de la imagen a color y lo demás en gris; android nos da algunas propiedades muy útiles para los ImageView, uno de estos es el OnTouch.

Pues los reto a que hagan el simulado de eso en android veamos que tan buenos programadores somos con retos y publiquemos nuestros resultados

Les doy un poco de ayuda, http://www.forosdelweb.com/f165/rgb-...endido-932580/
http://www.forosdelweb.com/f165/veam...enadas-932269/

Nos tamos viendo gente.