¿Existe una manera simple de comparar instancias de BufferedImage?

Question

Estoy trabajando en una aplicación Java que toma una imagen como una matriz de bytes, la lee en una instancia java.awt.image.BufferedImage y la pasa a una biblioteca de terceros para su procesamiento.

Para una prueba de unidad, quiero tomar una imagen (de un archivo en el disco) y afirmar que es igual a la misma imagen que ha sido procesada por el código.

• Mi esperaBufferedImage se lee de un archivo PNG en el disco utilizando ImageIO.read(URL).
• Mi prueba código lee el mismo archivo en un BufferedImage y lo escribe en una matriz de bytes como PNG para proporcionar al sistema bajo prueba.

Cuando el sistema bajo prueba escribe el conjunto de bytes en un nuevo BufferedImage, deseo afirmar que las dos imágenes son iguales de manera significativa. Usar equals() (heredado de Object) no funciona (por supuesto). La comparación de los valores BufferedImage.toString() tampoco funciona porque la cadena de salida incluye información de referencia del objeto.

¿Alguien sabe algún atajo? Preferiría no traer una biblioteca de terceros para una prueba de unidad única en una pequeña parte de una aplicación grande.

Answer 1

Este es el mejor enfoque. No es necesario mantener una variable para saber si la imagen es igual. Simplemente devuelva falso inmediatamente cuando la condición sea falsa.La evaluación de cortocircuito ayuda a ahorrar tiempo al pasar por encima de los píxeles después de que la comparación falla, como es el caso en answer de trumpetlick.

/** 
* Compares two images pixel by pixel. 
* 
* @param imgA the first image. 
* @param imgB the second image. 
* @return whether the images are both the same or not. 
*/ 
public static boolean compareImages(BufferedImage imgA, BufferedImage imgB) { 
    // The images must be the same size. 
    if (imgA.getWidth() == imgB.getWidth() && imgA.getHeight() == imgB.getHeight()) { 
    int width = imgA.getWidth(); 
    int height = imgA.getHeight(); 

    // Loop over every pixel. 
    for (int y = 0; y < height; y++) { 
     for (int x = 0; x < width; x++) { 
     // Compare the pixels for equality. 
     if (imgA.getRGB(x, y) != imgB.getRGB(x, y)) { 
      return false; 
     } 
     } 
    } 
    } else { 
    return false; 
    } 

    return true; 
} 

Answer 2

¡Podrías escribir tu propia rutina para comparar!

int width; 
int height; 
boolean imagesEqual = true; 

if(image1.getWidth() == (width = image2.getWidth()) && 
    image1.getHeight() == (height = image2.getHeight())){ 

    for(int x = 0;imagesEqual == true && x < width; x++){ 
     for(int y = 0;imagesEqual == true && y < height; y++){ 
      if(image1.getRGB(x, y) != image2.getRGB(x, y)){ 
       imagesEqual = false; 
      } 
     } 
    } 
}else{ 
    imagesEqual = false; 
} 

¡Esto sería de una sola manera!

Answer 3

No puedo pensar en nada, además de una fuerza bruta "hacer bucle":

BufferedImage bi1, bi2, ... 
    ... 
    Raster r1 = bi1.getData(); 
    DataBuffer db1 = r1.getDataBuffer(); 
    if (db1.getSize() != db2.getSize()) 
    ... 
    for (int i = 0; i < db1.getSize(); i++) { 
    int px = db1.getElem(i); 
    } 

Answer 4

Si la velocidad es un problema, y ​​ambos BufferedImages son de la misma profundidad de bits, arreglo, etc. (que parece que debe ser cierto aquí) puede hacer esto:

DataBuffer dbActual = myBufferedImage.getRaster().getDataBuffer(); 
DataBuffer dbExpected = bufferImageReadFromAFile.getRaster().getDataBuffer(); 

averiguar de qué tipo es, por ejemplo un DataBufferInt

DataBufferInt actualDBAsDBInt = (DataBufferInt) dbActual ; 
DataBufferInt expectedDBAsDBInt = (DataBufferInt) dbExpected ; 

hacer algunos "chequeos" de igual a igual en los tamaños y los bancos de los DataBuffers, entonces bucle

for (int bank = 0; bank < actualDBAsDBInt.getNumBanks(); bank++) { 
    int[] actual = actualDBAsDBInt.getData(bank); 
    int[] expected = expectedDBAsDBInt.getData(bank); 

    // this line may vary depending on your test framework 
    assertTrue(Arrays.equals(actual, expected)); 
} 

Esto está cerca tan rápido como usted puede conseguir causa que está agarrando una parte de los datos a la vez, no de a uno por vez.

Answer 5

Puede escribir esa imagen a través de imageio a través de OutputStream a byte[]. En mi código, se ve más o menos así:

byte[] encodeJpegLossless(BufferedImage img){...using imageio...} 
... 
Assert.assertTrue(Arrays.equals(encodeJpegLossless(img1) 
           ,encodeJpegLossless(img2) 
           ) 
       ); 

Answer 6

me cambió function that equals by pixels en Groovy, pueden ser útiles:

boolean imagesAreEqual(BufferedImage image1, BufferedImage image2) { 
    if (image1.width != image2.width || image1.height != image2.height) { 
     return false 
    } 
    for (int x = 1; x < image2.width; x++) { 
     for (int y = 1; y < image2.height; y++) { 
      if (image1.getRGB(x, y) != image2.getRGB(x, y)) { 
       return false 
      } 
     } 
    } 
    return true 
}