Mezclar píxeles de Dos mapas de bits

Question

Me estoy golpeando la cabeza contra una pared aquí, y estoy bastante seguro de que estoy haciendo algo estúpido, por lo que es hora de hacer pública mi estupidez.

Estoy tratando de tomar dos imágenes, mezclarlas en una tercera imagen usando algoritmos de mezcla estándar (luz fuerte, luz suave, superposición, multiplicar, etc.).

Como Android no tiene esas propiedades de mezcla incorporadas, he ido por el camino de tomar cada píxel y combinarlos usando un algoritmo. Sin embargo, los resultados son basura. A continuación se muestran los resultados de una mezcla simple y múltiple (imágenes utilizadas y resultado esperado).

BASE:

BLEND: RESULTADO

ESPERADO:

BASURA RESULTADO:

sería apreciada Cualquier ayuda. A continuación está el código, que he tratado de eliminar toda la "basura", pero algunos pueden haberlo superado. Lo limpiaré si algo no está claro.

ImageView imageView = (ImageView) findViewById(R.id.ImageView01); 
    Bitmap base = BitmapFactory.decodeResource(getResources(), R.drawable.base); 
    Bitmap result = base.copy(Bitmap.Config.RGB_565, true); 
    Bitmap blend = BitmapFactory.decodeResource(getResources(), R.drawable.blend); 

    IntBuffer buffBase = IntBuffer.allocate(base.getWidth() * base.getHeight()); 
    base.copyPixelsToBuffer(buffBase); 
    buffBase.rewind(); 

    IntBuffer buffBlend = IntBuffer.allocate(blend.getWidth() * blend.getHeight()); 
    blend.copyPixelsToBuffer(buffBlend); 
    buffBlend.rewind(); 

    IntBuffer buffOut = IntBuffer.allocate(base.getWidth() * base.getHeight()); 
    buffOut.rewind(); 

    while (buffOut.position() < buffOut.limit()) { 
     int filterInt = buffBlend.get(); 
     int srcInt = buffBase.get(); 

     int redValueFilter = Color.red(filterInt); 
     int greenValueFilter = Color.green(filterInt); 
     int blueValueFilter = Color.blue(filterInt); 

     int redValueSrc = Color.red(srcInt); 
     int greenValueSrc = Color.green(srcInt); 
     int blueValueSrc = Color.blue(srcInt); 

     int redValueFinal = multiply(redValueFilter, redValueSrc); 
     int greenValueFinal = multiply(greenValueFilter, greenValueSrc); 
     int blueValueFinal = multiply(blueValueFilter, blueValueSrc); 

     int pixel = Color.argb(255, redValueFinal, greenValueFinal, blueValueFinal); 

     buffOut.put(pixel); 
    } 

    buffOut.rewind(); 

    result.copyPixelsFromBuffer(buffOut); 

    BitmapDrawable drawable = new BitmapDrawable(getResources(), result); 
    imageView.setImageDrawable(drawable); 
} 

int multiply(int in1, int in2) { 
    return in1 * in2/255; 
} 

Answer 1

Después de la reproducción, creo que su problema tiene que ver con la manipulación de las imágenes en modo RGB565. Como se discutió en this post, parece que los mapas de bits deben estar en modo ARGB8888 para manipularse correctamente. Llegué por primera vez el resultado esperado de una mezcla multiplican haciendo lo siguiente:

Resources res = getResources(); 
BitmapFactory.Options options = new BitmapFactory.Options(); 
options.inPreferredConfig = Bitmap.Config.ARGB_8888; 
Bitmap base = BitmapFactory.decodeResource(res, R.drawable.base, options); 
Bitmap blend = BitmapFactory.decodeResource(res, R.drawable.blend, options); 

// now base and blend are in ARGB8888 mode, which is what you want 

Bitmap result = base.copy(Config.ARGB_8888, true); 
// Continue with IntBuffers as before... 

la conversión de los mapas de bits a modo de ARGB8888 parecen funcionar para mí, al menos con los patrones de prueba de gradiente. Sin embargo, sólo tiene que hacer de pantalla o múltiple, puede probar esto, así:

// Same image creation/reading as above, then: 
Paint p = new Paint(); 
p.setXfermode(new PorterDuffXfermode(Mode.MULTIPLY)); 
p.setShader(new BitmapShader(blend, TileMode.CLAMP, TileMode.CLAMP)); 

Canvas c = new Canvas(); 
c.setBitmap(result); 
c.drawBitmap(base, 0, 0, null); 
c.drawRect(0, 0, base.getWidth(), base.getHeight(), p); 

Con esto, usted no está haciendo los cálculos por píxel, sino que se limitan a los preestablecidos PorterDuff.Mode s. En mi prueba rápida (y sucia), esta fue la única forma en que pude hacer que la mezcla funcionara en imágenes que no son de gradiente.

Answer 2

superposición simple que puede hacer de esta manera (por simplicidad se supone que BMP1 es igual o más grande que la BMP-2):

private Bitmap bitmapOverlay(Bitmap bmp1, Bitmap bmp2) 
{ 
    Bitmap bmOverlay = Bitmap.createBitmap(bmp1.getWidth(), bmp1.getHeight(), bmp1.getConfig()); 
    Canvas canvas = new Canvas(bmOverlay); 
    canvas.drawBitmap(bmp1, 0, 0, null); 
    canvas.drawBitmap(bmp2, 0, 0, null); 
    return bmOverlay; 
} 

Para algoritmos de fusión más complejas, tal vez usted puede ayudarse a sí mismo con un poco de funciones disponibles de mapa de bits/lienzo.