la comparación de imágenes de mapa de bits en Android

Question

¿Hay alguna manera de de verificación si los mapas de bits son los mismos? ¿Alguien me puede ayudar?

Answer 1

Dependiendo de cómo se defina el mismo. Si quiere decir exactamente el mismo archivo, puede hacer un md5sum de los archivos. Eso será lo mismo para cada tipo de archivo, supongo.

Debido a que específicamente hacer la distinción para los archivos de mapa de bits, que podría estar interesado en los archivos que difieren en tamaño. Eso es un poco mas dificil Si son del mismo tamaño, pero no por completo el mismo (pero se ven realmente muy similar entre si) puede comparar cada píxel separada, y si suficientes píxeles (umbral 1) son lo bastante cerca uno del otro en el color (umbral 2) puede declarar ellos como siendo lo mismo.

Puede getPixel(int,int) para obtener el color, consulte this page

Answer 2

clase Bitmap tiene método "sameAs", puede utilizar este método para comparar dos mapas de bits

http://developer.android.com/reference/android/graphics/Bitmap.html#sameAs%28android.graphics.Bitmap%29

Answer 3

Debe ser algo como esto:

public boolean equals(Bitmap bitmap1, Bitmap bitmap2) { 
    ByteBuffer buffer1 = ByteBuffer.allocate(bitmap1.getHeight() * bitmap1.getRowBytes()); 
    bitmap1.copyPixelsToBuffer(buffer1); 

    ByteBuffer buffer2 = ByteBuffer.allocate(bitmap2.getHeight() * bitmap2.getRowBytes()); 
    bitmap2.copyPixelsToBuffer(buffer2); 

    return Arrays.equals(buffer1.array(), buffer2.array()); 
} 

Answer 4

esta pregunta parece viejo pero pasó algún tiempo en este tema hoy y aquí está lo que yo hizo.

private static boolean compare(Bitmap b1, Bitmap b2) { 
    if (b1.getWidth() == b2.getWidth() && b1.getHeight() == b2.getHeight()) { 
     int[] pixels1 = new int[b1.getWidth() * b1.getHeight()]; 
     int[] pixels2 = new int[b2.getWidth() * b2.getHeight()]; 
     b1.getPixels(pixels1, 0, b1.getWidth(), 0, 0, b1.getWidth(), b1.getHeight()); 
     b2.getPixels(pixels2, 0, b2.getWidth(), 0, 0, b2.getWidth(), b2.getHeight()); 
     if (Arrays.equals(pixels1, pixels2)) { 
      return true; 
     } else { 
      return false; 
     } 
    } else { 
     return false; 
    } 
} 

Answer 5

El principal problema para las API de menos de 12 es que obtenemos OutOfMemory error para resoluciones de grandes archivos. Lo resuelto por escupir mapas de bits en piezas (10 en el ejemplo) y luego compararlos por Bytes:

private boolean compareBitmaps(Bitmap bitmap1, Bitmap bitmap2) 
{ 
    if (Build.VERSION.SDK_INT > 11) 
    { 
     return bitmap1.sameAs(bitmap2); 
    } 

    int chunkNumbers = 10; 
    int rows, cols; 
    int chunkHeight, chunkWidth; 
    rows = cols = (int) Math.sqrt(chunkNumbers); 
    chunkHeight = bitmap1.getHeight()/rows; 
    chunkWidth = bitmap1.getWidth()/cols; 

    int yCoord = 0; 
    for (int x = 0; x < rows; x++) 
    { 
     int xCoord = 0; 
     for (int y = 0; y < cols; y++) 
     { 
      try 
      { 
       Bitmap bitmapChunk1 = Bitmap.createBitmap(bitmap1, xCoord, yCoord, chunkWidth, chunkHeight); 
       Bitmap bitmapChunk2 = Bitmap.createBitmap(bitmap2, xCoord, yCoord, chunkWidth, chunkHeight); 

       if (!sameAs(bitmapChunk1, bitmapChunk2)) 
       { 
        recycleBitmaps(bitmapChunk1, bitmapChunk2); 
        return false; 
       } 

       recycleBitmaps(bitmapChunk1, bitmapChunk2); 

       xCoord += chunkWidth; 
      } 
      catch (Exception e) 
      { 
       return false; 
      } 
     } 
     yCoord += chunkHeight; 
    } 

    return true; 
} 

private boolean sameAs(Bitmap bitmap1, Bitmap bitmap2) 
{ 
    // Different types of image 
    if (bitmap1.getConfig() != bitmap2.getConfig()) 
     return false; 

    // Different sizes 
    if (bitmap1.getWidth() != bitmap2.getWidth()) 
     return false; 

    if (bitmap1.getHeight() != bitmap2.getHeight()) 
     return false; 

    int w = bitmap1.getWidth(); 
    int h = bitmap1.getHeight(); 

    int[] argbA = new int[w * h]; 
    int[] argbB = new int[w * h]; 

    bitmap1.getPixels(argbA, 0, w, 0, 0, w, h); 
    bitmap2.getPixels(argbB, 0, w, 0, 0, w, h); 

    // Alpha channel special check 
    if (bitmap1.getConfig() == Bitmap.Config.ALPHA_8) 
    { 
     final int length = w * h; 
     for (int i = 0; i < length; i++) 
     { 
      if ((argbA[i] & 0xFF000000) != (argbB[i] & 0xFF000000)) 
      { 
       return false; 
      } 
     } 
     return true; 
    } 

    return Arrays.equals(argbA, argbB); 
} 

private void recycleBitmaps(Bitmap bitmap1, Bitmap bitmap2) 
{ 
    bitmap1.recycle(); 
    bitmap2.recycle(); 
    bitmap1 = null; 
    bitmap2 = null; 
}