Golang generiert konsistente Hashes für JPEG-Bilder, ohne auf die Festplatte zu schreiben

Während des Entwicklungsprozesses müssen wir häufig die Ähnlichkeit von Bilddateien für Bilderkennung, Deduplizierung und andere Vorgänge vergleichen. Das Generieren eines Hash eines Bildes ist ein gängiger Ansatz. Normalerweise müssen wir das Image auf die Festplatte schreiben und es dann zur Hash-Berechnung auslesen. Mit der Programmiersprache Golang können wir jedoch problemlos direkt konsistente Hash-Werte berechnen und gleichzeitig JPEG-Bilder generieren, ohne auf die Festplatte schreiben zu müssen. Das spart uns Zeit und Speicherplatz und erhöht die Effizienz. In diesem Artikel wird detailliert beschrieben, wie diese Funktion in Golang implementiert wird.

Frageninhalt

Neu bei Golang Imaging

Ich versuche, konsistente Hashes für JPEG-Bilder zu generieren. Wenn ich das Bild neu lade, nachdem ich es als JPEG auf die Festplatte geschrieben habe (was erwartet wird), erzeugt das Laden des Bildes und das Generieren des Hashs für die Rohbytes einen anderen Hash. Sobald ich das RBGA als JPEG auf die Festplatte schreibe, werden die Pixel geändert, wodurch der zuvor berechnete Hash beschädigt wird.

Nur das Hashen der Datei hash("abc.jpeg") bedeutet, dass ich Hashes auf die Festplatte schreiben muss, usw.

• Gibt es eine Einstellung, mit der ich das Verhalten der ausgegebenen JPEG-Pixel beim Lesen/Schreiben steuern kann?
Soll ich *image.RGBA verwenden? Das Eingabebild ist *image.YCbCr?

// Open the input image file
inputFile, _ := os.Open("a.jpg")
defer inputFile.Close()

// Decode the input image
inputImage, _, _ := image.Decode(inputFile)

// Get the dimensions of the input image
width := inputImage.Bounds().Dx()
height := inputImage.Bounds().Dy()
subWidth := width / 4
subHeight := height / 4

// Create a new image
subImg := image.NewRGBA(image.Rect(0, 0, subWidth, subHeight))
draw.Draw(subImg, subImg.Bounds(), inputImage, image.Point{0, 0}, draw.Src)

// id want the hashes to be the same for read / write but they will always differ
hash1 := sha256.Sum256(imageToBytes(subImg))
fmt.Printf("<---OUT [%s] %x\n", filename, hash1)
jpg, _ := os.Create("mytest.jpg")
_ = jpeg.Encode(jpg, subImg, nil)
jpg.Close()

// upon reading it back in the pixels are ever so slightly diff
f, _ := os.Open("mytest.jpg")
img, _, _ := image.Decode(f)
jpg_input := image.NewRGBA(img.Bounds())
draw.Draw(jpg_input, img.Bounds(), img, image.Point{0, 0}, draw.Src)
hash2 := sha256.Sum256(imageToBytes(jpg_input))
fmt.Printf("--->IN  [%s] %x\n", filename, hash2)

            // real world use case is..
            // generate subtile of large image plus hash
            // if hash in a dbase
            //    pixel walk to see if hash collision occurred
            //    if pixels are different
            //       deal with it...
            ///   else
            //      object.filename = dbaseb.filename
            // else
            //     add filename to dbase with hash as the lookup
            //     write to jpeg to disk

Workaround

Sie können einen Hash als Ziel des Autors verwenden und

verwenden, um den Hash beim Schreiben der Datei zu berechnen: io.MultiWriter

hash:=sha256.New()
jpeg.Encode(io.MultiWriter(file,hash),img,nil)
hashValue:=hash.Sum(nil)

Das obige ist der detaillierte Inhalt vonGolang generiert konsistente Hashes für JPEG-Bilder, ohne auf die Festplatte zu schreiben. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!