Add Hamming Distance functions

Author: kavu

README.md

@@ -16,7 +16,7 @@ package main
 import "github.com/kavu/go-phash"
 
 func main() {
-	hash, _ := phash.ImageHash("~/my_cat.jpg")
+	hash, _ := phash.ImageHashDCT("~/my_cat.jpg")
 	println(hash)
 }
 ```

phash.go

@@ -12,26 +12,43 @@ package phash
 
 #include <stdlib.h>
 
-#if defined( _MSC_VER) || defined(_BORLANDC_)
-  typedef unsigned _uint64 ulong64;
-  typedef signed _int64 long64;
-#else
-  typedef unsigned long long ulong64;
-  typedef signed long long long64;
-#endif
+typedef unsigned long long ulong64;
 
 extern ulong64 pc_dct_imagehash_Wrapper(const char *file);
+extern int ph_hamming_distance(ulong64 hasha, ulong64 hashb);
 */
 import "C"
 
 import "unsafe"
 
-// ImageHash gets a pHash for image with a given path.
-func ImageHash(file string) (uint64, error) {
+// ImageHash returns a DCT pHash for image with a given path.
+func ImageHashDCT(file string) (uint64, error) {
 	cs := C.CString(file)
 
 	h, err := C.pc_dct_imagehash_Wrapper(cs)
 	C.free(unsafe.Pointer(cs))
 
 	return uint64(h), err
 }
+
+// HammingDistanceForHashes returns a Hamming Distance between two images' DCT pHashes.
+func HammingDistanceForHashes(hasha uint64, hashb uint64) (int, error) {
+	d, err := C.ph_hamming_distance(C.ulong64(hasha), C.ulong64(hashb))
+
+	return int(d), err
+}
+
+// HammingDistanceForFiles returns a Hamming Distance between two images with a given paths.
+func HammingDistanceForFiles(filea string, fileb string) (interface{}, error) {
+	hasha, err := ImageHashDCT(filea)
+	if err != nil {
+		return nil, err
+	}
+
+	hashb, err := ImageHashDCT(fileb)
+	if err != nil {
+		return nil, err
+	}
+
+	return HammingDistanceForHashes(hasha, hashb)
+}

phash_test.go

@@ -18,9 +18,11 @@ var hashTestData = []struct {
 	// {"test_data/gif/animated_zebras.gif", 7086864532766789979},
 }
 
+// ImageHash
+
 func BenchmarkImageHash(b *testing.B) {
 	for i := 0; i < b.N; i++ {
-		_, err := ImageHash(hashTestData[0].file)
+		_, err := ImageHashDCT(hashTestData[0].file)
 		if err != nil {
 			b.Fatal(err)
 		}
@@ -29,7 +31,7 @@ func BenchmarkImageHash(b *testing.B) {
 
 func TestImageHash(t *testing.T) {
 	for _, test := range hashTestData {
-		hash, err := ImageHash(test.file)
+		hash, err := ImageHashDCT(test.file)
 		if err != nil {
 			t.Fatal(err)
 		}
@@ -41,10 +43,112 @@ func TestImageHash(t *testing.T) {
 }
 
 func ExampleImageHash() {
-	hash, err := ImageHash("test_data/jpg/cat.jpg")
+	hash, err := ImageHashDCT("test_data/jpg/cat.jpg")
 	if err != nil {
 		panic(err)
 	}
 	fmt.Println(hash)
 	// Output: 11220389026139797626
 }
+
+// HammingDistanceForHashes
+
+func BenchmarkHammingDistanceForHashesForSameImage(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		_, err := HammingDistanceForHashes(7086864532766789979, 7086864532766789979)
+		if err != nil {
+			b.Fatal(err)
+		}
+	}
+}
+
+func BenchmarkHammingDistanceForHashesForDifferentImages(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		_, err := HammingDistanceForHashes(7086864532766789979, 11220389026139797626)
+		if err != nil {
+			b.Fatal(err)
+		}
+	}
+}
+
+func TestHammingDistanceForHashesForSameImage(t *testing.T) {
+	d, err := HammingDistanceForHashes(7086864532766789979, 7086864532766789979)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if d != 0 {
+		t.Errorf("Distance Mismatch: expected 0, got %d", d)
+	}
+}
+
+func TestHammingDistanceForHashesForDifferentImages(t *testing.T) {
+	d, err := HammingDistanceForHashes(11220389026139797626, 4855808264951085874)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if d == 0 {
+		t.Error("Distance Mismatch: got unexpected 0")
+	}
+}
+
+func ExampleHammingDistanceForHashes() {
+	d, err := HammingDistanceForHashes(11220389026139797626, 4855808264951085874)
+	if err != nil {
+		panic(err)
+	}
+	fmt.Println(d)
+	// Output: 30
+}
+
+// HammingDistanceForFiles
+
+func BenchmarkHammingDistanceForFilesForSameImage(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		_, err := HammingDistanceForFiles("test_data/jpg/cat.jpg", "test_data/jpg/cat.jpg")
+		if err != nil {
+			b.Fatal(err)
+		}
+	}
+}
+
+func BenchmarkHammingDistanceForFilesForDifferentImages(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		_, err := HammingDistanceForFiles("test_data/jpg/cat.jpg", "test_data/png/gopher.png")
+		if err != nil {
+			b.Fatal(err)
+		}
+	}
+}
+
+func TestHammingDistanceForFilesForSameImage(t *testing.T) {
+	d, err := HammingDistanceForFiles("test_data/jpg/cat.jpg", "test_data/jpg/cat.jpg")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if d != 0 {
+		t.Errorf("Distance Mismatch: expected 0, got %d", d)
+	}
+}
+
+func TestHammingDistanceForFilesForDifferentImages(t *testing.T) {
+	d, err := HammingDistanceForFiles("test_data/jpg/cat.jpg", "test_data/png/gopher.png")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if d == 0 {
+		t.Error("Distance Mismatch: got unexpected 0")
+	}
+}
+
+func ExampleHammingDistanceForFiles() {
+	d, err := HammingDistanceForFiles("test_data/jpg/cat.jpg", "test_data/png/gopher.png")
+	if err != nil {
+		panic(err)
+	}
+	fmt.Println(d)
+	// Output: 30
+}