Gibt es eine einfache Möglichkeit zu vergleichen BufferedImage-Instanzen?

Arbeite ich an Teil einer Java-Anwendung, die nimmt ein Bild als byte-array aus, liest es in einem java.awt.image.BufferedImage Instanz und übergibt Sie an eine Drittanbieter-Bibliothek für die Verarbeitung.

Für einen unit-test, möchte ich ein Bild (aus einer Datei auf der Festplatte) und behaupten, dass es ist, gleich dem Bild, dass bearbeitet wurde, der code.

Meine erwartet BufferedImage gelesen wird aus einer PNG-Datei auf der Festplatte mithilfe ImageIO.read(URL).
Meine test code liest die gleiche Datei in ein BufferedImage und schreibt, dass ein byte-array als PNG zur Verfügung zu stellen, das system under test.

Wenn das system unter test schreibt das byte-array zu einem neuen BufferedImage ich möchte behaupten, dass die beiden Bilder gleich sind, in einer sinnvollen Art und Weise. Mit equals() (geerbt von Object) nicht funktioniert (natürlich). Vergleichen BufferedImage.toString() Werte auch nicht funktioniert, da der Ausgabe-string enthält die Objekt-Referenz Informationen.

Weiß jemand irgendwelche Tastenkombinationen? Ich würde es vorziehen, nicht, um in einer Drittanbieter-Bibliothek für eine einzelne unit test in einem kleinen Teil einer großen Anwendung.

Könnten Sie erklären, warum genau .equals() funktioniert nicht?
wenn es geerbt von Objekt, es wird nicht funktionieren, weil das tut nur Objekt-Identität.
können Sie vergleichen Sie einfach die byte-arrays (mit PNG)?
BufferedImage nicht überschreiben Object#equals(). docjar.com/html/api/java/awt/image/BufferedImage.java.html
Hab es, danke.

InformationsquelleAutor pharsicle | 2012-06-12

awt java

Dies ist der beste Ansatz. Keine Notwendigkeit, eine variable zu sagen, ob das Bild immer noch gleich. Schicken Sie einfach sofort falsch wenn die Bedingung, wenn "false". Short-circuit-evaluation hilft Zeit zu sparen Schleife über die Pixel, die nach dem Vergleich schlägt fehl, wie es der Fall in trumpetlick ist Antwort.

/**
 * 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()) {
    return false;
  }

  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;
      }
    }
  }

  return true;
}

schöne und einfache Lösung! Genau das, was ich gesucht habe!

InformationsquelleAutor Mr. Polywhirl

5

Wenn Geschwindigkeit ein Problem ist, und beide BufferedImages sind von der gleichen bit-Tiefe, Anordnung, etc. (das scheint wie es muss wahr sein hier) können Sie dies tun:
```
DataBuffer dbActual = myBufferedImage.getRaster().getDataBuffer();
DataBuffer dbExpected = bufferImageReadFromAFile.getRaster().getDataBuffer();
```
herauszufinden, welche Art es ist, z.B. eine DataBufferInt
```
DataBufferInt actualDBAsDBInt = (DataBufferInt) dbActual ;
DataBufferInt expectedDBAsDBInt = (DataBufferInt) dbExpected ;
```
tun, ein paar "sanity-checks" für gleich auf die Größen und die Banken von der DataBuffers, dann Schleife
```
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));
}
```
Dies ist in der Nähe so schnell wie Sie bekommen können, verursachen Sie schnappen sich ein Stück der Daten zu einer Zeit, nicht nacheinander.

Die gleiche bit-Tiefe, Anordnung, etc... ist ein ziemlich großes. Antwortete nur eine Jungs Frage gestern, wo er die Tat im wesentlichen ein Vergleich von Bildern, und er fand heraus, dass war der ARGB_8888 und ein anderer war RGB_565. Diese sind groß Annahmen. Sie sind in der Tat richtig, wenn diese Parameter erfüllt sind, wäre dies die Schnellste Methode aber nicht 🙂
Denn es ist ein unit-test es scheint, wie seine test-Bild sollte die gleiche bit-Tiefe, etc. Aber mit Ihnen überein, dass in der Regel, dass ist ein bisschen eine Annahme.
dein code funktioniert nicht java.lang.Classcastexception-Fehler: java.das awt.Bild.DataBufferByte nicht cast auf java.das awt.Bild.DataBufferInt

InformationsquelleAutor user949300
3

Könnten Sie schreiben Ihre eigene routine für den Vergleich!
```
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;
}
```
Wäre dies ein Weg!!!

muss auch falsch sein, wenn die Größen nicht übereinstimmen. Legen Sie die boolean auf true, die nur innerhalb der if block.
Guter Punkt, Ive bearbeitet!
Auch, dass break Aussage nicht viel tun, Sie haben geschachtelt for Schleifen.
Jetzt ist es noch schlimmer: Sie sind weiterhin für die Iteration über die Bilder nach, die Sie bereits wissen, Sie sind nicht gleich. labelled break.
Sie brauchen nicht imagesEqual == true nur imagesEqual sollte ausreichen. Das neue baby muss unter einer großen Tribut.

InformationsquelleAutor trumpetlicks

Änderte ich Funktion, die gleich der durch die Pixel in Groovy, die hilfreich sein können:

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
}

InformationsquelleAutor stokito

0

Ich kann nicht an nichts denken, außer einer brute-force "do-Schleife":
```
  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);
  }
```
gute Antwort, aber dieses nicht zweimal verwenden die Erinnerung, wie es kopiert das ganze Bild in einem anderen Puffer! Vielleicht eine chance, schneller zu tun, um weniger die tatsächliche routine ruft 🙂 Keine Möglichkeit zu wissen, ohne zu testen!!!
für die "Keine Möglichkeit zu wissen, ohne zu testen!!!" ich vermute, das wird schneller als getRGB() pro pixel, aber die Tests werden es Sortieren.
Nicht sicher, tatsächlich, er ruft "db1".getSize jeder iteration, sowie potenziell 4 Daten kopiert. 1 für die Erstellung von r1, eine für die db1, und die gleichen 2 für r2 und db2. Dann hat er auch "db1".getElem(i). Eigentlich wird in der Tat langsamer, weil er auch den Aufruf einer routine zu bekommen, beide Elemente innerhalb des arrays. db1.getSize() return (width*height) des Bildes. Er ist also nicht nur das kopieren der Daten, aber ruft die gleiche Menge von Routinen innerhalb der Schleife. Er ist auch nicht sogar die compare-operation an alle!!!
siehe meine Antwort aus einem ähnlichen Ansatz sollte schneller sein (obwohl mehr Speicher intensiv).

InformationsquelleAutor

Können Sie schreiben, dass Bild über imageio durch eine OutputStream zu einem byte[].
In meinem code sieht es mehr oder weniger so:

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

InformationsquelleAutor comonad

arbeiten gut, aber nicht effizient

public static boolean compareImage(File fileA, File fileB) {        
    try {
        //take buffer data from botm image files //
        BufferedImage biA = ImageIO.read(fileA);
        DataBuffer dbA = biA.getData().getDataBuffer();
        int sizeA = dbA.getSize();                      
        BufferedImage biB = ImageIO.read(fileB);
        DataBuffer dbB = biB.getData().getDataBuffer();
        int sizeB = dbB.getSize();
        //compare data-buffer objects //
        if(sizeA == sizeB) {
            for(int i=0; i<sizeA; i++) { 
                if(dbA.getElem(i) != dbB.getElem(i)) {
                    return false;
                }
            }
            return true;
        }
        else {
            return false;
        }
    } 
    catch (Exception e) { 
        e.printStackTrace();
        return  false;
    }
}

InformationsquelleAutor cyril

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.