compix 0.1.1 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d31400ba7b637660ef09a34d8c45228d25811274
-  data.tar.gz: 2c5589a1b5da50cd87e2d4ad50a908168139acf7
+  metadata.gz: 573a0eea05badf4bd1964736361513caeed36ecb
+  data.tar.gz: 952fc5643ce5a5fd16b9f45d540f7bb101c14ca0
 SHA512:
-  metadata.gz: 6676275970f1c794242b386f74f0fc5fd419a96800e758db97d57ce7b79741092638098a9a15a36d683d3f2ebae9d9f589ebb23ebffa0e007db491e30ea13b04
-  data.tar.gz: 07740fd33ca945ab6c89c7d522ff284561823b3701696a62b45c7806c2b49420e4693715f701ccb34db94cb5cc7cd1960ee2650599139e9309e68a4899a69a9f
+  metadata.gz: a0fd67bdf4fbfb99f753aed312fea832dffe4fcb3713565b54cc2337ef115440226a8c5cba4e39e1138b39de9e277f3b04c56446198af423076a06910355d700
+  data.tar.gz: 98ec2b5321a0e51d7476db720fab5965afe10ffe691325f937abab55454b8f7dafeb5aed224594f671f7fc71f336ff2e778c47d41744c8d84228903132f033e7

data/ext/compix/compix.c

@@ -5,7 +5,7 @@
 
 void Init_compix(){
   VALUE CompixModule = rb_define_module("Compix");
-  rb_define_singleton_method(CompixModule, "find_subimage", find_subimage, 3);
+  rb_define_singleton_method(CompixModule, "find_subimage", find_subimage, -1);
 }
 
 bool compare_pixels(PIXEL pone, PIXEL ptwo, int threshold){
@@ -23,7 +23,7 @@ bool compare_pixels(PIXEL pone, PIXEL ptwo, int threshold){
   return true;
 }
 
-int compare_at(PIXEL *pixelsSmall, PIXEL *pixelsBig, int thres, int bigXoffset, int bigYoffset,
+int compare_at(PIXEL *pixelsSmall, PIXEL *pixelsBig, int color_threshold, int bigXoffset, int bigYoffset,
               int siwidth, int siheight, int sswidth, int ssheight){
   PIXEL firstPixel;
   PIXEL secPixel;
@@ -41,7 +41,7 @@ int compare_at(PIXEL *pixelsSmall, PIXEL *pixelsBig, int thres, int bigXoffset,
         break;
       }
       secPixel = pixelsBig[bigCoord];
-      if(compare_pixels(firstPixel, secPixel, thres)){
+      if(compare_pixels(firstPixel, secPixel, color_threshold)){
         match++;
       } 
       else {
@@ -55,57 +55,49 @@ int compare_at(PIXEL *pixelsSmall, PIXEL *pixelsBig, int thres, int bigXoffset,
   return match;
 }
 
-PIXEL* image_to_bytearray(PIXEL *bytearray_ptr, VALUE image){
-  VALUE pixels = rb_funcall(image, rb_intern("pixels"), 0);
-  int x, y;
-
-  int width = NUM2INT(rb_funcall(image, rb_intern("width"), 0));
-  int height = NUM2INT(rb_funcall(image, rb_intern("height"), 0));
+// (VALUE self, VALUE subimage, VALUE bigimage, VALUE options)
+VALUE find_subimage(int argc, VALUE* argv, VALUE self){
+  VALUE subimage = argv[0];
+  VALUE image = argv[1];
+  VALUE options_hash;
+  int color_threshold = 0;
+  double pixels_threshold = 0;
+  int xstart = 0;
+  int ystart = 0 ;
 
-  for(y = 0 ; y < height ; y++){
-    for(x = 0 ; x < width ; x++){
-      bytearray_ptr[y * width + x] = NUM2UINT(rb_ary_entry(pixels, y * width + x));
-    }
+  if(argc == 3){
+    options_hash = argv[2];
+    color_threshold = integer_from_hash(options_hash, "threshold", 0, 0, 255);
+    xstart = integer_from_hash(options_hash, "start_coordinate_x", 0, 0, INT_MAX);
+    ystart = integer_from_hash(options_hash, "start_coordinate_y", 0, 0, INT_MAX);
+    pixels_threshold = float_from_hash(options_hash, "pixels_threshold", 0.85, 0.0, 1.0);
   }
-  return bytearray_ptr;
-}
 
-VALUE find_subimage(VALUE self, VALUE subimage, VALUE bigimage, VALUE threshold){
   VALUE subimage_match_obj;
   
   int siwidth = NUM2INT(rb_funcall(subimage, rb_intern("width"), 0));
   int siheight = NUM2INT(rb_funcall(subimage, rb_intern("height"), 0));
-  int sswidth = NUM2INT(rb_funcall(bigimage, rb_intern("width"), 0));
-  int ssheight = NUM2INT(rb_funcall(bigimage, rb_intern("height"), 0));
+  int sswidth = NUM2INT(rb_funcall(image, rb_intern("width"), 0));
+  int ssheight = NUM2INT(rb_funcall(image, rb_intern("height"), 0));
   
   PIXEL *bytearray_subimg = malloc(siwidth * siheight * sizeof(PIXEL));
   PIXEL *bytearray_big_image = malloc(sswidth * ssheight * sizeof(PIXEL));
-  
-  int thres = NUM2UINT(threshold);
+
   int match = 0;
   int maxmatch = 0;
   int maxX = -1;
   int maxY = -1;
-  //int xLeftLimit = NUM2INT(rb_ary_entry(minCoord, 0));
-  //int yTopLimit = NUM2INT(rb_ary_entry(minCoord, 1));
-  //int xRightLimit = NUM2INT(rb_ary_entry(maxCoord, 0));
-  //int yBottomLimit = NUM2INT(rb_ary_entry(maxCoord, 1));
-  // I didn't want to break backwards compatibility, so while this is less legible
-  // and slower if old version of compix is used, it will still work.
-  // The third and fourth entry in the array specifies from where to start checking the big image.
-  // Used for e.g. findAllSubImages in rubypng
-  int xstart = 0; //NUM2INT(rb_ary_entry(minCoord, 2));
-  int ystart = 0 ; //NUM2INT(rb_ary_entry(minCoord, 3));
+
   int x, y;
   int compPix = siwidth * siheight;
   
   // Create bytearrays for pixels
   bytearray_subimg = image_to_bytearray(bytearray_subimg, subimage);
-  bytearray_big_image = image_to_bytearray(bytearray_big_image, bigimage);
+  bytearray_big_image = image_to_bytearray(bytearray_big_image, image);
   
   for(y = ystart ; y <= ssheight - siheight; y++){
     for(x = xstart ; x <= sswidth - siwidth; x++){
-      match = compare_at(bytearray_subimg, bytearray_big_image, thres, x, y,
+      match = compare_at(bytearray_subimg, bytearray_big_image, color_threshold, x, y,
                         siwidth, siheight, sswidth, ssheight);
       if(match > maxmatch){
         maxmatch = match;
@@ -113,20 +105,12 @@ VALUE find_subimage(VALUE self, VALUE subimage, VALUE bigimage, VALUE threshold)
         maxY = y;
       }      
     }
+    xstart = 0;
   }
 
   free(bytearray_subimg);
   free(bytearray_big_image);
 
-  subimage_match_obj = initialize_subimage_match_obj(maxX, maxY, compPix, maxmatch);
+  subimage_match_obj = initialize_subimage_match_obj(maxX, maxY, compPix, maxmatch, siwidth, siheight, pixels_threshold);
   return subimage_match_obj;
 }
-
-VALUE initialize_subimage_match_obj(int coord_x, int coord_y, int pixels_compared, int pixels_matched){
-  VALUE mCompixModule = rb_const_get(rb_cObject, rb_intern("Compix"));
-  VALUE cSubimageMatch = rb_const_get(mCompixModule, rb_intern("SubimageMatch"));
-
-  VALUE match_obj = rb_funcall(cSubimageMatch, rb_intern("new"), 4, INT2NUM(coord_x), INT2NUM(coord_y),
-                                         INT2NUM(pixels_compared), INT2NUM(pixels_matched));
-  return match_obj;
-}

data/ext/compix/compix.h

@@ -3,29 +3,16 @@
 
 #include <ruby.h>
 #include <stdbool.h>
+#include "compix_helpers.h"
 
 
-
-// Types and macros from OilyPNG for compatibility
-typedef uint32_t PIXEL; // Pixels use 32 bits unsigned integers
-typedef unsigned char BYTE; // Bytes use 8 bits unsigned integers
-#define R_BYTE(pixel)  ((BYTE) (((pixel) & (PIXEL) 0xff000000) >> 24))
-#define G_BYTE(pixel)  ((BYTE) (((pixel) & (PIXEL) 0x00ff0000) >> 16))
-#define B_BYTE(pixel)  ((BYTE) (((pixel) & (PIXEL) 0x0000ff00) >> 8))
-#define A_BYTE(pixel)  ((BYTE) (((pixel) & (PIXEL) 0x000000ff)))
-
 void Init_compix();
 
-VALUE find_subimage(VALUE self, VALUE subimage, VALUE bigimage, VALUE threshold);
-
-VALUE initialize_subimage_match_obj(int coord_x, int coord_y, int pixels_compared, int pixels_matched);
+VALUE find_subimage(int argc, VALUE* argv, VALUE self);
 
 int compare_at(PIXEL *pixelsSmall, PIXEL *pixelsBig, int thres, int bigXoffset, int bigYoffset,
               int siwidth, int siheight, int sswidth, int ssheight);
 
 bool compare_pixels(PIXEL pone, PIXEL ptwo, int threshold);
 
-// The bytearray_ptr should be allocated for the correct size.
-PIXEL* image_to_bytearray(PIXEL *bytearray_ptr, VALUE image);
-
 #endif

data/ext/compix/compix_helpers.c

@@ -0,0 +1,51 @@
+#include "compix_helpers.h"
+
+PIXEL* image_to_bytearray(PIXEL *bytearray_ptr, VALUE image){
+  VALUE pixels = rb_funcall(image, rb_intern("pixels"), 0);
+  int x, y;
+
+  int width = NUM2INT(rb_funcall(image, rb_intern("width"), 0));
+  int height = NUM2INT(rb_funcall(image, rb_intern("height"), 0));
+
+  for(y = 0 ; y < height ; y++){
+    for(x = 0 ; x < width ; x++){
+      bytearray_ptr[y * width + x] = NUM2UINT(rb_ary_entry(pixels, y * width + x));
+    }
+  }
+  return bytearray_ptr;
+}
+
+int integer_from_hash(VALUE hash, char* key, int default_value, int min_value, int max_value){
+  VALUE val = rb_hash_aref(hash, RB_SYM(key));
+  if( TYPE(val) != T_NIL ) {
+    int c_value = NUM2INT(val);
+    if ( c_value < min_value || c_value > max_value ){
+      rb_raise(rb_eArgError, "argument '%s' has value %d. Allowed range is %d..%d", key, c_value, min_value, max_value);
+    }
+    return c_value;
+  }
+  return default_value;
+}
+
+double float_from_hash(VALUE hash, char* key, double default_value, double min_value, double max_value){
+  VALUE val = rb_hash_aref(hash, RB_SYM(key));
+  if( TYPE(val) != T_NIL ) {
+    double c_value = NUM2DBL(val);
+    if ( c_value < min_value || c_value > max_value ){
+      rb_raise(rb_eArgError, "argument '%s' has value %d. Allowed range is %d..%d", key, c_value, min_value, max_value);
+    }
+    return c_value;
+  }
+  return default_value;
+}
+
+VALUE initialize_subimage_match_obj(int coord_x, int coord_y, int pixels_compared, int pixels_matched,
+                                    int subimage_width, int subimage_height, float limit_for_match) {
+  VALUE mCompixModule = rb_const_get(rb_cObject, rb_intern("Compix"));
+  VALUE cSubimageMatch = rb_const_get(mCompixModule, rb_intern("SubimageMatch"));
+
+  VALUE match_obj = rb_funcall(cSubimageMatch, rb_intern("new"), 7, INT2NUM(coord_x), INT2NUM(coord_y),
+                                         INT2NUM(pixels_compared), INT2NUM(pixels_matched),
+                                         INT2NUM(subimage_width), INT2NUM(subimage_height), DBL2NUM(limit_for_match));
+  return match_obj;
+}

data/ext/compix/compix_helpers.h

@@ -0,0 +1,32 @@
+#ifndef COMPIX_HELPERS_H
+#define COMPIX_HELPERS_H
+
+#include <ruby.h>
+#include <stdbool.h>
+
+
+// Types and macros from OilyPNG for compatibility
+typedef uint32_t PIXEL; // Pixels use 32 bits unsigned integers
+typedef unsigned char BYTE; // Bytes use 8 bits unsigned integers
+#define R_BYTE(pixel)  ((BYTE) (((pixel) & (PIXEL) 0xff000000) >> 24))
+#define G_BYTE(pixel)  ((BYTE) (((pixel) & (PIXEL) 0x00ff0000) >> 16))
+#define B_BYTE(pixel)  ((BYTE) (((pixel) & (PIXEL) 0x0000ff00) >> 8))
+#define A_BYTE(pixel)  ((BYTE) (((pixel) & (PIXEL) 0x000000ff)))
+
+// Symbols for options for method find_subimage
+#define RB_SYM(string) ID2SYM(rb_intern(string))
+
+
+
+// The bytearray_ptr should be allocated for the correct size.
+PIXEL* image_to_bytearray(PIXEL *bytearray_ptr, VALUE image);
+
+int integer_from_hash(VALUE hash, char* key, int default_value, int min_value, int max_value);
+
+double float_from_hash(VALUE hash, char* key, double default_value, double min_value, double max_value);
+
+VALUE initialize_subimage_match_obj(int coord_x, int coord_y, int pixels_compared, int pixels_matched,
+                                    int subimage_width, int subimage_height, float limit_for_match);
+
+
+#endif

data/lib/compix.rb

@@ -2,5 +2,25 @@ require 'compix.so'
 require 'compix/match.rb'
 
 module Compix
+  def self.find_all_instances_of_subimage(subimage, image, options={})
+    options[:start_coordinate_x] ||= 0
+    options[:start_coordinate_y] ||= 0
+    matches = []
 
+    subimage_match = self.find_subimage(subimage, image, options)
+    while subimage_match.match?
+      skip = false
+      matches.each do |match|
+        if match.overlaped_by?(subimage_match)
+          skip = true
+          break
+        end
+      end
+      matches << subimage_match unless skip
+      options[:start_coordinate_y] = subimage_match.coordinate_y
+      options[:start_coordinate_x] = subimage_match.coordinate_x + subimage.width
+      subimage_match = self.find_subimage(subimage, image, options)
+    end
+    matches
+  end
 end

data/lib/compix/match.rb

@@ -1,15 +1,19 @@
 require 'chunky_png'
 
+DEFAULT_PERCENT = 0.85
 
 class Compix::SubimageMatch
-  attr_reader :coordinate_x, :coordinate_y, :pixels_compared, :pixels_matched
+  attr_reader :coordinate_x, :coordinate_y, :pixels_compared, :pixels_matched, :width, :height
 
-  def initialize(coord_x, coord_y, pixels_compared, pixels_matched)
+  def initialize(coord_x, coord_y, pixels_compared, pixels_matched, width, height, limit_for_match=DEFAULT_PERCENT)
     raise ArgumentError.new("Matched more pixels ('#{pixels_matched}') than compared ('#{pixels_compared}')") if pixels_compared < pixels_matched
     @coordinate_x = coord_x
     @coordinate_y = coord_y
     @pixels_compared = pixels_compared
     @pixels_matched = pixels_matched
+    @width = width
+    @height = height
+    @match = limit_for_match <= self.match_percentage
   end
 
   def match_percentage
@@ -17,11 +21,29 @@ class Compix::SubimageMatch
     pixels_matched.to_f / pixels_compared
   end
 
+  def match?
+    @match
+  end
+
   def eql?(other)
     other.class.eql?(self.class) && other.state.eql?(self.state)
   end
 
+  def overlaped_by?(other)
+    return false if other.coordinate_x + other.width <= @coordinate_x
+    return false if other.coordinate_x >= @coordinate_x + @width
+    return false if other.coordinate_y + other.height <= @coordinate_y
+    return false if other.coordinate_y >= @coordinate_y + @height
+    true
+  end
+
   def state
     [@coordinate_x, @coordinate_y, @pixels_compared, @pixels_matched]
   end
+
+  def coordinate_middle
+    x = @coordinate_x + @width / 2
+    y = @coordinate_y + @height / 2
+    return [x, y]
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: compix
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.1
 platform: ruby
 authors:
 - Jon Appelberg
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-10-29 00:00:00.000000000 Z
+date: 2014-10-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler
@@ -75,6 +75,8 @@ extra_rdoc_files: []
 files:
 - ext/compix/compix.c
 - ext/compix/compix.h
+- ext/compix/compix_helpers.c
+- ext/compix/compix_helpers.h
 - ext/compix/extconf.rb
 - lib/compix.rb
 - lib/compix/match.rb