similie 0.1.0

data/README.rdoc

@@ -0,0 +1,30 @@
+= Similie
+
+Similie is a simple DCT based image hashing interface that,
+
+* computes a fingerprint based on low frequencies of an image.
+* computes hamming distance between 2 fingerprints.
+
+== Example
+    
+    require 'similie'
+
+    img1 = Similie.new("test/lena1.jpg") 
+    img2 = Similie.new("test/lena2.png") # lena1.jpg cropped and scaled
+    img3 = Similie.new("test/lena5.png") # a different image
+
+    img1.hash #=> unsigned 64bit int
+
+    img1.distance(img2) #=> 1
+    img1.distance(img5) #=> 5
+
+    Similie.distance("test/lena1.jpg", "test/lena5.jpg") #=> 5
+
+== Dependencies
+
+* ruby 1.9.1+
+* opencv 2.1+  (libcv-dev and libhighgui-dev on debian systems)
+
+= License
+
+{CC BY-SA 3.0}[http://creativecommons.org/licenses/by-sa/3.0/]

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/ext/extconf.rb

@@ -0,0 +1,25 @@
+require 'mkmf'
+
+$CFLAGS  = "-I/usr/include/opencv -Wall"
+$LDFLAGS = "-lhighgui -lcxcore"
+
+dir_config("libcv", ["/usr/local", "/opt/local", "/usr"])
+
+headers = [ 'stdio.h', 'stdlib.h', 'string.h', 'opencv/cxcore.h', 'opencv/highgui.h' ]
+lib_1   = [ 'cxcore', 'cvInitFont', headers ]
+lib_2   = [ 'highgui', 'cvEncodeImage', headers ]
+
+if have_header('opencv/cxcore.h') && have_library(*lib_1) && have_library(*lib_2)
+  create_makefile 'similie'
+else
+  puts %q{
+    Cannot find opencv headers or libraries.
+
+    On debian based systems you can install it from apt as,
+      sudo apt-get install libcv-dev libhighgui-dev
+
+    Refer to http://opencv.willowgarage.com/wiki/InstallGuide for other platforms or operating systems.
+  }
+
+  exit 1
+end

data/ext/similie.c

@@ -0,0 +1,165 @@
+/*
+    (c) Bharanee Rathna 2011
+
+    CC BY-SA 3.0
+    http://creativecommons.org/licenses/by-sa/3.0/
+
+    Free for every type of use. The author cannot be legally held responsible for
+    any damages resulting from the use of this work. All modifications or derivatives
+    need to be attributed.
+*/
+
+#include <ruby.h>
+#include <ruby/encoding.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include <unistd.h>
+#include <opencv/cv.h>
+#include <opencv/cxcore.h>
+#include <opencv/highgui.h>
+
+#define TO_S(v)                    rb_funcall(v, rb_intern("to_s"), 0)
+#define CSTRING(v)                 RSTRING_PTR(TO_S(v))
+#define ID_CONST_GET               rb_intern("const_get")
+#define CONST_GET(scope, constant) (rb_funcall(scope, ID_CONST_GET, 1, rb_str_new2(constant)))
+#define cvGetMonoPixel(img,y,x)    ((uchar *)(img->imageData + x*img->widthStep))[y*img->nChannels]
+
+#undef SIZET2NUM
+#ifdef HAVE_LONG_LONG
+  #define SIZET2NUM(x) ULL2NUM(x)
+#else
+  #define SIZET2NUM(x) ULONG2NUM(x)
+#endif
+
+// http://en.wikipedia.org/wiki/Hamming_weight
+
+const uint64 m1  = 0x5555555555555555; //binary: 0101...
+const uint64 m2  = 0x3333333333333333; //binary: 00110011..
+const uint64 m4  = 0x0f0f0f0f0f0f0f0f; //binary:  4 zeros,  4 ones ...
+const uint64 m8  = 0x00ff00ff00ff00ff; //binary:  8 zeros,  8 ones ...
+const uint64 m16 = 0x0000ffff0000ffff; //binary: 16 zeros, 16 ones ...
+const uint64 m32 = 0x00000000ffffffff; //binary: 32 zeros, 32 ones
+const uint64 hff = 0xffffffffffffffff; //binary: all ones
+const uint64 h01 = 0x0101010101010101; //the sum of 256 to the power of 0,1,2,3...
+
+int popcount(uint64 x) {
+    x -= (x >> 1) & m1;             //put count of each 2 bits into those 2 bits
+    x = (x & m2) + ((x >> 2) & m2); //put count of each 4 bits into those 4 bits
+    x = (x + (x >> 4)) & m4;        //put count of each 8 bits into those 8 bits
+    return (x * h01)>>56;           //returns left 8 bits of x + (x<<8) + (x<<16) + (x<<24) + ...
+}
+
+uint64_t image_phash(IplImage *img) {
+    uint64_t phash = 0;
+    int x, y;
+    double avg;
+
+    IplImage *small = cvCreateImage(cvSize(32, 32), 8, img->nChannels);
+    IplImage *mono  = cvCreateImage(cvSize(32, 32), 8, 1);
+
+    cvResize(img, small, CV_INTER_CUBIC);
+    cvCvtColor(small, mono, CV_RGB2GRAY);
+
+    CvMat *dct = cvCreateMat(8, 8, CV_32FC1);
+    for (x = 0; x < 8; x++) {
+        for (y = 0; y < 8; y++) {
+            cvSet2D(dct, x, y, cvScalarAll(cvGetMonoPixel(mono, x, y)));
+        }
+    }
+
+    cvDCT(dct, dct, CV_DXT_ROWS);
+    cvSet2D(dct, 0, 0, cvScalarAll(0));
+
+    avg = (double)cvAvg(dct, 0).val[0] * 64.0 / 63.0;
+
+    uint64_t mask = 1;
+    for (x = 0; x < 8; x++) {
+        for (y = 0; y < 8; y++) {
+            if (cvGet2D(dct, x, y).val[0] > avg) phash |= mask;
+            mask = mask << 1;
+        }
+    }
+
+    cvReleaseMat(&dct);
+    cvReleaseImage(&mono);
+    cvReleaseImage(&small);
+    return phash;
+}
+
+static void rb_image_free(IplImage *handle) {
+  if (handle)
+    cvReleaseImage(&handle);
+}
+
+VALUE rb_image_alloc(VALUE klass) {
+  IplImage *handle = 0;
+  return Data_Wrap_Struct(klass, 0, rb_image_free, handle);
+}
+
+IplImage* rb_image_handle(VALUE self) {
+  IplImage *handle = 0;
+  Data_Get_Struct(self, IplImage, handle);
+  if (!handle)
+    rb_raise(rb_eRuntimeError, "Invalid object, did you forget to call super() ?");
+
+  return handle;
+}
+
+VALUE rb_image_hash(VALUE self) {
+    VALUE hash = rb_iv_get(self, "@hash");
+    if (NIL_P(hash)) {
+        hash = SIZET2NUM(image_phash(rb_image_handle(self)));
+        rb_iv_set(self, "@hash", hash);
+    }
+    return hash;
+}
+
+VALUE rb_image_initialize(VALUE self, VALUE file) {
+    IplImage *img = cvLoadImage(CSTRING(file), -1);
+    if (!img)
+        rb_raise(rb_eArgError, "Invalid image or unsupported format: %s", CSTRING(file));
+
+    DATA_PTR(self) = img;
+    return self;
+}
+
+
+VALUE rb_image_distance(VALUE self, VALUE other) {
+    VALUE hash1 = rb_image_hash(self);
+    VALUE hash2 = rb_image_hash(other);
+    int dist    = popcount(NUM2ULONG(hash1) ^ NUM2ULONG(hash2));
+    return INT2NUM(dist);
+}
+
+VALUE rb_image_distance_func(VALUE self, VALUE file1, VALUE file2) {
+    IplImage *img1, *img2;
+    img1 = cvLoadImage(CSTRING(file1), -1);
+    if (!img1)
+        rb_raise(rb_eArgError, "Invalid image or unsupported format: %s", CSTRING(file1));
+
+    img2 = cvLoadImage(CSTRING(file2), -1);
+    if (!img2) {
+        cvReleaseImage(&img1);
+        rb_raise(rb_eArgError, "Invalid image or unsupported format: %s", CSTRING(file2));
+    }
+
+    int dist = popcount(image_phash(img1) ^ image_phash(img2));
+
+    cvReleaseImage(&img1);
+    cvReleaseImage(&img2);
+
+    return INT2NUM(dist);
+}
+
+void Init_similie() {
+    VALUE cSimilie = rb_define_class("Similie", rb_cObject);
+    rb_define_alloc_func(cSimilie, rb_image_alloc);
+    rb_define_method(cSimilie, "initialize", RUBY_METHOD_FUNC(rb_image_initialize), 1);
+    rb_define_method(cSimilie, "hash",       RUBY_METHOD_FUNC(rb_image_hash),       0);
+    rb_define_method(cSimilie, "distance",   RUBY_METHOD_FUNC(rb_image_distance),   1);
+
+    rb_define_singleton_method(cSimilie, "distance", RUBY_METHOD_FUNC(rb_image_distance_func), 2);
+}

data/test/test_basic.rb

@@ -0,0 +1,17 @@
+require_relative 'helper'
+
+describe 'Similie image load' do
+  it 'should load image' do
+    assert Similie.new(File.join($testdir, 'lena1.jpg'))
+  end
+
+  it 'should barf on invalid path' do
+    assert_raises(ArgumentError) { Similie.new(File.join($testdir, 'lena2.jpg')) }
+  end
+
+  it 'should hash image' do
+    img = Similie.new(File.join($testdir, 'lena1.jpg'))
+    assert img
+    assert_equal 216455360913932544, img.hash
+  end
+end

data/test/test_distance.rb

@@ -0,0 +1,16 @@
+require_relative 'helper'
+
+describe 'Similie image distance' do
+  it 'should work for similar images' do
+    images = %w(lena1.jpg lena2.png lena3.png lena4.png lena5.jpg).map {|file| Similie.new(File.join($testdir, file))}
+
+    assert_equal 1, images[0].distance(images[1])
+    assert_equal 2, images[1].distance(images[2])
+    assert_equal 0, images[2].distance(images[3])
+    assert_equal 6, images[3].distance(images[4])
+  end
+
+  it 'should work using the singleton method' do
+    assert_equal 6, Similie.distance(File.join($testdir, 'lena4.png'), File.join($testdir, 'lena5.jpg'))
+  end
+end

metadata

@@ -0,0 +1,70 @@
+--- !ruby/object:Gem::Specification 
+name: similie
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Bharanee Rathna
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-06-04 00:00:00 +10:00
+default_executable: 
+dependencies: []
+
+description: "\n    Similie does image fingerprinting using discrete cosine transform\n    and similarity comparison using Hamming distance on fingerprints.\n  "
+email: deepfryed@gmail.com
+executables: []
+
+extensions: 
+- ext/extconf.rb
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- VERSION
+- ext/similie.c
+- README.rdoc
+- test/test_basic.rb
+- test/test_distance.rb
+- ext/extconf.rb
+has_rdoc: true
+homepage: http://github.com/deepfryed/similie
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Compute image fingerprints and similarity
+test_files: 
+- test/test_basic.rb
+- test/test_distance.rb