compix 0.0.5

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: cb42dd67dc46a435223d649a19c74494e9f6a920
+  data.tar.gz: 4608581180744a8fc6df686c71fdcc99df1fa673
+SHA512:
+  metadata.gz: 5861d769b5ee93c95c6811a931dd782e7f8def8117f04162b7c9150a7255e10648e2197bf843de3bc98e31466b9d20e4b3c157dee16ee42250474ef16822ac4f
+  data.tar.gz: a5328685d480d67477f3624b00e8a2c09648bdadf1c02f5ee0c835c2869ca0fbf5f7686e5733ae085acf6582884bcb23ca44e37bb9222629de1c677ba7a9752f

data/ext/compix/compix.c

@@ -0,0 +1,146 @@
+#include <ruby.h>
+#include <stdbool.h>
+
+// Types and macros from OilyPNG for compatibility
+typedef unsigned int 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 compix_compare_pixels(VALUE self, VALUE subimage, VALUE bigimage, 
+                            VALUE minCoord, VALUE maxCoord, VALUE threshold);
+                            
+void Init_compix(){
+  VALUE klass = rb_define_class("Compix", rb_cObject);
+  rb_define_singleton_method(klass, "compare_pixels", compix_compare_pixels, 5);
+}
+
+int getImgWidth(VALUE img){
+  int width = NUM2INT(rb_funcall(img, rb_intern("width"), 0));
+  return width;
+}
+
+int getImgHeight(VALUE img){
+  int height = NUM2INT(rb_funcall(img, rb_intern("height"), 0));
+  return height;
+}
+
+int comparePixels(PIXEL pone, PIXEL ptwo, int threshold){
+  unsigned char ored = R_BYTE(pone);
+  unsigned char ogreen = G_BYTE(pone);
+  unsigned char oblue = B_BYTE(pone);
+  unsigned char tred = R_BYTE(ptwo);
+  unsigned char tgreen = G_BYTE(ptwo);
+  unsigned char tblue = B_BYTE(ptwo);
+  if(ored - tred > threshold || tred - ored > threshold ||
+      ogreen - tgreen > threshold || tgreen - ogreen > threshold ||
+      oblue - tblue > threshold || tblue - oblue > threshold){
+      return false;
+  }
+  return true;
+}
+
+int compareAt(unsigned int *pixelsSmall, unsigned int *pixelsBig, int thres, int bigXoffset, int bigYoffset,
+              int siwidth, int siheight, int sswidth, int ssheight){
+  PIXEL firstPixel;
+  PIXEL secPixel;
+  int match = 0;
+  int unmatch = 0;
+  int x, y;
+  int small_image_coord;
+  int bigCoord = 0;
+  for(y = 0; y < siheight; y++){    
+    for(x = 0; x < siwidth; x++){
+      small_image_coord = y * siwidth + x;
+      firstPixel = pixelsSmall[small_image_coord];
+      bigCoord = sswidth*(y+bigYoffset)+(x+bigXoffset);
+      if(bigCoord >= (sswidth)*(ssheight) - 2 ){
+        break;
+      }
+      secPixel = pixelsBig[bigCoord];
+      if(comparePixels(firstPixel, secPixel, thres)){
+        match++;
+      } 
+      else {
+        unmatch++;
+      }
+    }
+    if(unmatch > match){
+      break;
+    }
+  }
+  return match;
+}
+
+VALUE compix_compare_pixels(VALUE self, VALUE subimage, VALUE bigimage, 
+                            VALUE minCoord, VALUE maxCoord, VALUE threshold){  
+  VALUE pixelsf = rb_funcall(subimage, rb_intern("pixels"), 0);
+  VALUE pixelss = rb_funcall(bigimage, rb_intern("pixels"), 0);    
+  
+  int siwidth = getImgWidth(subimage);
+  int siheight = getImgHeight(subimage);
+  int sswidth = getImgWidth(bigimage);
+  int ssheight = getImgHeight(bigimage);
+  
+  unsigned int *bytearray_subimg = malloc(siwidth * siheight * sizeof(unsigned int));
+  unsigned int *bytearray_screenshot = malloc(sswidth * ssheight * sizeof(unsigned int));
+  
+  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 pixels = 0;
+  int compPix = siwidth * siheight;
+  VALUE retArr;
+  int matchPercent;
+  
+  // Create bytearrays for pixels
+  for(y = 0 ; y < siheight ; y++){
+	  for(x = 0 ; x < siwidth ; x++){
+	    bytearray_subimg[y*siwidth + x] = NUM2UINT(rb_ary_entry(pixelsf,y*siwidth + x));
+	  }
+  }
+  for(y = 0 ; y < ssheight ; y++){
+	  for(x = 0 ; x < sswidth ; x++){
+	    bytearray_screenshot[y*sswidth + x] = NUM2UINT(rb_ary_entry(pixelss,y*sswidth + x));
+	  }
+  }
+  
+  
+  for(y = ystart ; y < yBottomLimit-siheight; y++){
+    for(x = xstart ; x < xRightLimit-siwidth; x++){
+      match = compareAt(bytearray_subimg, bytearray_screenshot, thres, x, y,
+                        siwidth, siheight, sswidth, ssheight);
+      if(match > maxmatch){
+        maxmatch = match;
+        maxX = x;
+        maxY = y;
+      }      
+    }
+  }
+  free(bytearray_subimg);
+  free(bytearray_screenshot);
+  pixels = x * ( ssheight - siheight ) + y;
+  matchPercent = (100 * maxmatch) / compPix;
+  retArr = rb_ary_new();
+  rb_ary_push(retArr, INT2NUM(matchPercent));
+  rb_ary_push(retArr, INT2NUM(maxX));
+  rb_ary_push(retArr, INT2NUM(maxY));
+  rb_ary_push(retArr, INT2NUM(pixels));
+  return retArr;
+}

data/ext/compix/extconf.rb

@@ -0,0 +1,6 @@
+# external/comparepixels/extconf.rb
+
+require 'mkmf'
+extension_name = 'compix'
+dir_config(extension_name)
+create_makefile(extension_name)

data/lib/compix.rb

@@ -0,0 +1,7 @@
+require 'compix.so'
+
+#class Compix
+#  module CompareImagePixels
+#  
+#  end
+#end

metadata

@@ -0,0 +1,61 @@
+--- !ruby/object:Gem::Specification
+name: compix
+version: !ruby/object:Gem::Version
+  version: 0.0.5
+platform: ruby
+authors:
+- Jon Appelberg
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-10-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email: 
+executables: []
+extensions:
+- ext/compix/extconf.rb
+extra_rdoc_files: []
+files:
+- ext/compix/compix.c
+- ext/compix/extconf.rb
+- lib/compix.rb
+homepage: 
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.2
+signing_key: 
+specification_version: 4
+summary: Compix for oilypng
+test_files: []
+has_rdoc: