seeklib 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 67101c1094ca597a68d498218b92b828f5e60e09
+  data.tar.gz: 29c5bb1e7a64e540d20e4ce004fa51dc56b1b299
+SHA512:
+  metadata.gz: ea0954aac3fed9eb35dda4333ca2d4b954979a578ca640385eba3924e88d4fb1e7fc45f34cd06a53b2740103c0eb140ef77b91e9904c40f578e4fb27f74f87ad
+  data.tar.gz: bd710b7b83790eb622bd5576573173ca68bd5e531d5da368151be6b30bd6d8933568b93a2392f8fef5a6156eb8cdf3d6400acfb40eeff9bc1d993744154e2275

data/ext/seeklib/cmp.cpp

@@ -0,0 +1,64 @@
+#include <cmath>
+#include <stdlib.h>
+#include <string.h>
+
+#include "cmp.h"
+#include "haar.h"
+
+unsigned char imgBin[NUM_PIXELS_SQUARED];
+int imgBinInited = 0;
+
+void initImgBin() {
+    imgBinInited = 1;
+
+    /* setup initial fixed weights that each coefficient represents */
+    int i, j;
+
+    /*
+      0 1 2 3 4 5 6 i
+      0 0 1 2 3 4 5 5
+      1 1 1 2 3 4 5 5
+      2 2 2 2 3 4 5 5
+      3 3 3 3 3 4 5 5
+      4 4 4 4 4 4 5 5
+      5 5 5 5 5 5 5 5
+      5 5 5 5 5 5 5 5
+      j
+    */
+
+    /* Every position has value 5, */
+    memset(imgBin, 5, NUM_PIXELS_SQUARED);
+
+    /* Except for the 5 by 5 upper-left quadrant: */
+    for (i = 0; i < 5; i++)
+        for (j = 0; j < 5; j++)
+            imgBin[i * NUM_PIXELS + j] = max(i, j);
+    // Note: imgBin[0] == 0
+}
+
+
+double calcDiff(SigStruct *siga, SigStruct *sigb) {
+    /* use it to tell the content-based difference between two images
+     */
+    if (!imgBinInited) {
+        initImgBin();
+    }
+    double diff = calcAvglDiff(siga, sigb);
+    Idx *corea[3] = { siga->sig1, siga->sig2, siga->sig3 };
+    Idx *coreb[3] = { sigb->sig1, sigb->sig2, sigb->sig3 };
+
+    for (int b = 0; b < NUM_COEFS; b++)
+        for (int c = 0; c < 3; c++)
+            for (int b2 = 0; b2 < NUM_COEFS; b2++)
+                if (coreb[c][b2] == corea[c][b])
+                    diff -= picture_weights[imgBin[abs(corea[c][b])]][c];
+
+    return diff;
+}
+
+double calcAvglDiff(SigStruct *siga, SigStruct *sigb) {
+	return fabs(siga->avgl[0] - sigb->avgl[0])
+            + fabs(siga->avgl[1] - sigb->avgl[1])
+            + fabs(siga->avgl[2] - sigb->avgl[2]);
+}
+

data/ext/seeklib/cmp.h

@@ -0,0 +1,19 @@
+#ifndef CMP_H
+#define CMP_H
+
+#include "sig.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+double calcDiff(SigStruct *siga, SigStruct *sigb);
+
+#ifdef __cplusplus
+}
+#endif
+
+// not api
+double calcAvglDiff(SigStruct *siga, SigStruct *sigb);
+
+#endif // CMP_H

data/ext/seeklib/extconf.rb

@@ -0,0 +1,5 @@
+require 'mkmf'
+
+$CPPFLAGS = "-fwrapv -pthread -fpic -O2 -ffast-math -Dcimg_display=0" 
+
+create_makefile 'seeklib/seeklib'

data/ext/seeklib/haar.cpp

@@ -0,0 +1,329 @@
+/***************************************************************************
+    imgSeek ::  Haar 2d transform implemented in C/C++ to speed things up
+                             -------------------
+    begin                : Fri Jan 17 2003
+    email                : ricardo.cabral|at|imgseek.net
+    Time-stamp:            <05/01/30 19:58:56 rnc>
+    ***************************************************************************
+    *    Wavelet algorithms, metric and query ideas based on the paper        *
+    *    Fast Multiresolution Image Querying                                  *
+    *    by Charles E. Jacobs, Adam Finkelstein and David H. Salesin.         *
+    *    <http://www.cs.washington.edu/homes/salesin/abstracts.html>          *
+    ***************************************************************************
+
+    Copyright (C) 2003 Ricardo Niederberger Cabral
+
+    Clean-up and speed-ups by Geert Janssen <geert at ieee.org>, Jan 2006:
+    - introduced names for various `magic' numbers
+    - made coding style suitable for Emacs c-mode
+    - expressly doing constant propagation by hand (combined scalings)
+    - preferring pointer access over indexed access of arrays
+    - introduced local variables to avoid expression re-evaluations
+    - took out all dynamic allocations
+    - completely rewrote calcHaar and eliminated truncq()
+    - better scheme of introducing sqrt(0.5) factors borrowed from
+      FXT package: author Joerg Arndt, email: arndt@jjj.de,
+      http://www.jjj.de/
+    - separate processing per array: better cache behavior
+    - do away with all scaling; not needed except for DC component
+
+    To do:
+    - the whole Haar transform should be done using fixpoints
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+/* C Includes */
+#include <math.h> 
+#include <stdio.h> 
+#include <stdlib.h> 
+#include <string.h>
+
+/* imgSeek Includes */
+#include "haar.h"
+
+// RGB -> YIQ colorspace conversion; Y luminance, I,Q chrominance.
+// If RGB in [0..255] then Y in [0..255] and I,Q in [-127..127].
+#define RGB_2_YIQ(a, b, c) \
+  do { \
+    int i; \
+    \
+    for (i = 0; i < NUM_PIXELS_SQUARED; i++) { \
+      Unit Y, I, Q; \
+      \
+      Y = 0.299 * a[i] + 0.587 * b[i] + 0.114 * c[i]; \
+      I = 0.596 * a[i] - 0.275 * b[i] - 0.321 * c[i]; \
+      Q = 0.212 * a[i] - 0.523 * b[i] + 0.311 * c[i]; \
+      a[i] = Y; \
+      b[i] = I; \
+      c[i] = Q; \
+    } \
+  } while(0)
+
+#if 0
+/* Haar 2D transform.
+   Not doing any scaling by 1/sqrt(128).
+   Better cache behaviour when processing array by array.
+
+   This version needs a different imgBin array! FIXME.
+*/
+static void
+haar2D(Unit a[])
+{
+  int i, i1;
+
+  /* scale by 1/sqrt(128) = 0.08838834764831843: */
+  /*
+  for (i = 0; i < NUM_PIXELS_SQUARED; i++)
+    a[i] *= 0.08838834764831843;
+  */
+
+  /* Decompose rows: */
+  for (i = 0; i < NUM_PIXELS_SQUARED; i = i1) {
+    Unit C = 1;
+    int l, l1;
+
+    i1 = i + NUM_PIXELS;	/* start of next row, next i */
+    for (l = 1; l < NUM_PIXELS; l = l1) {
+      int j;
+
+      C *= 0.7071;		/* 1/sqrt(2) */
+      l1 = l << 1;		/* l1 = 2*l, next l */
+      for (j = i; j < i1; j += l1) {
+        int j1 = j+l;
+	Unit t1;
+
+	t1 = (a[j] - a[j1]) * C;
+	a[j] += a[j1];
+	a[j1] = t1;
+      }
+    }
+    /* Fix first element of each row: */
+    a[i] *= C;	/* C = 1/sqrt(NUM_PIXELS) */
+  }
+
+  /* scale by 1/sqrt(128) = 0.08838834764831843: */
+  /*
+  for (i = 0; i < NUM_PIXELS_SQUARED; i++)
+    a[i] *= 0.08838834764831843;
+  */
+
+  /* Decompose columns: */
+  for (i = 0; i < NUM_PIXELS; i++) {
+    Unit C = 1;
+    int l, l1;
+
+    for (l = 1; l < NUM_PIXELS; l = l1) {
+      int j;
+
+      C *= 0.7071;		/* 1/sqrt(2) = 0.7071 */
+      l1 = l << 1;		/* l1 = 2*l, next l */
+      for (j = i; j < i+NUM_PIXELS_SQUARED; j += l1*NUM_PIXELS) {
+        int j1 = j+(l*NUM_PIXELS);
+	Unit t1;
+
+	t1 = (a[j] - a[j1]) * C;
+	a[j] += a[j1];
+	a[j1] = t1;
+      }
+    }
+    /* Fix first element of each column: */
+    a[i] *= C;
+  }
+}
+#else
+
+// Do the Haar tensorial 2d transform itself.
+// Here input is RGB data [0..255] in Unit arrays
+// Computation is (almost) in-situ.
+static void
+haar2D(Unit a[])
+{
+  int i;
+  Unit t[NUM_PIXELS >> 1];
+
+  // scale by 1/sqrt(128) = 0.08838834764831843:
+  /*
+  for (i = 0; i < NUM_PIXELS_SQUARED; i++)
+    a[i] *= 0.08838834764831843;
+  */
+
+  // Decompose rows:
+  for (i = 0; i < NUM_PIXELS_SQUARED; i += NUM_PIXELS) {
+    int h, h1;
+    Unit C = 1;
+
+    for (h = NUM_PIXELS; h > 1; h = h1) {
+      int j1, j2, k;
+
+      h1 = h >> 1;		// h = 2*h1
+      C *= 0.7071;		// 1/sqrt(2)
+      for (k = 0, j1 = j2 = i; k < h1; k++, j1++, j2 += 2) {
+        int j21 = j2+1;
+
+        t[k]  = (a[j2] - a[j21]) * C;
+        a[j1] = (a[j2] + a[j21]);
+      }
+      // Write back subtraction results:
+      memcpy(a+i+h1, t, h1*sizeof(a[0]));
+    }
+    // Fix first element of each row:
+    a[i] *= C;	// C = 1/sqrt(NUM_PIXELS)
+  }
+
+  // scale by 1/sqrt(128) = 0.08838834764831843:
+  /*
+  for (i = 0; i < NUM_PIXELS_SQUARED; i++)
+    a[i] *= 0.08838834764831843;
+  */
+
+  // Decompose columns:
+  for (i = 0; i < NUM_PIXELS; i++) {
+    Unit C = 1;
+    int h, h1;
+
+    for (h = NUM_PIXELS; h > 1; h = h1) {
+      int j1, j2, k;
+
+      h1 = h >> 1;
+      C *= 0.7071;		// 1/sqrt(2) = 0.7071
+      for (k = 0, j1 = j2 = i; k < h1;
+	   k++, j1 += NUM_PIXELS, j2 += 2*NUM_PIXELS) {
+        int j21 = j2+NUM_PIXELS;
+
+        t[k]  = (a[j2] - a[j21]) * C;
+        a[j1] = (a[j2] + a[j21]);
+      }
+      // Write back subtraction results:
+      for (k = 0, j1 = i+h1*NUM_PIXELS; k < h1; k++, j1 += NUM_PIXELS)
+        a[j1]=t[k];
+    }
+    // Fix first element of each column:
+    a[i] *= C;
+  }
+}
+#endif
+
+/* Do the Haar tensorial 2d transform itself.
+   Here input is RGB data [0..255] in Unit arrays.
+   Results are available in a, b, and c.
+   Fully inplace calculation; order of result is interleaved though,
+   but we don't care about that.
+*/
+void
+transform(Unit* a, Unit* b, Unit* c)
+{
+  RGB_2_YIQ(a, b, c);
+
+  haar2D(a);
+  haar2D(b);
+  haar2D(c);
+
+  /* Reintroduce the skipped scaling factors: */
+  a[0] /= 256 * 128;
+  b[0] /= 256 * 128;
+  c[0] /= 256 * 128;
+}
+
+// Do the Haar tensorial 2d transform itself.
+// Here input RGB data is in unsigned char arrays ([0..255])
+// Results are available in a, b, and c.
+void
+transformChar(unsigned char* c1, unsigned char* c2, unsigned char* c3,
+	      Unit* a, Unit* b, Unit* c)
+{
+  int i;
+  Unit *p = a;
+  Unit *q = b;
+  Unit *r = c;
+
+  for (i = 0; i < NUM_PIXELS_SQUARED; i++) {
+    *p++ = *c1++;
+    *q++ = *c2++;
+    *r++ = *c3++;
+  }
+  transform(a, b, c);
+}
+
+// Find the NUM_COEFS largest numbers in cdata[] (in magnitude that is)
+// and store their indices in sig[].
+inline static void
+get_m_largests(Unit *cdata, Idx *sig)
+{
+  int cnt, i;
+  valStruct val;
+  valqueue vq;			// dynamic priority queue of valStruct's
+
+  // Could skip i=0: goes into separate avgl
+
+  // Fill up the bounded queue. (Assuming NUM_PIXELS_SQUARED > NUM_COEFS)
+  for (i = 1; i < NUM_COEFS+1; i++) {
+    val.i = i;
+    val.d = ABS(cdata[i]);
+    vq.push(val);
+  }
+  // Queue is full (size is NUM_COEFS)
+
+  for (/*i = NUM_COEFS+1*/; i < NUM_PIXELS_SQUARED; i++) {
+    val.d = ABS(cdata[i]);
+
+    if (val.d > vq.top().d) {
+      // Make room by dropping smallest entry:
+      vq.pop();
+      // Insert val as new entry:
+      val.i = i;
+      vq.push(val);
+    }
+    // else discard: do nothing
+  }
+
+  // Empty the (non-empty) queue and fill-in sig:
+  cnt=0;
+  do {
+    int t;
+
+    val = vq.top();
+    t = (cdata[val.i] <= 0);	/* t = 0 if pos else 1 */
+    /* i - 0 ^ 0 = i; i - 1 ^ 0b111..1111 = 2-compl(i) = -i */
+    sig[cnt++] = (val.i - t) ^ -t; // never 0
+    vq.pop();
+  } while(!vq.empty());
+  // Must have cnt==NUM_COEFS here.
+}
+
+// Determines a total of NUM_COEFS positions in the image that have the
+// largest magnitude (absolute value) in color value. Returns linearized
+// coordinates in sig1, sig2, and sig3. avgl are the [0,0] values.
+// The order of occurrence of the coordinates in sig doesn't matter.
+// Complexity is 3 x NUM_PIXELS^2 x 2log(NUM_COEFS).
+int
+calcHaar(Unit *cdata1, Unit *cdata2, Unit *cdata3,
+	 Idx *sig1, Idx *sig2, Idx *sig3, double *avgl)
+{
+  avgl[0]=cdata1[0];
+  avgl[1]=cdata2[0];
+  avgl[2]=cdata3[0];
+
+  // Color channel 1:
+  get_m_largests(cdata1, sig1);
+
+  // Color channel 2:
+  get_m_largests(cdata2, sig2);
+
+  // Color channel 3:
+  get_m_largests(cdata3, sig3);
+
+  return 1;
+}

data/ext/seeklib/haar.h

@@ -0,0 +1,70 @@
+/***************************************************************************
+    imgSeek ::  This file is the haar 2d transform implemented in C/C++ to speed things up
+                             -------------------
+    begin                : Fri Jan 17 2003
+    email                : nieder|at|mail.ru
+    Time-stamp:            <03/05/09 21:29:35 rnc>
+
+    Copyright (C) 2003 Ricardo Niederberger Cabral
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+#ifndef HAAR_H
+#define HAAR_H
+
+/* STL Includes */
+#include <queue>
+
+/* Number of pixels on one side of image; required to be a power of 2. */
+#define	NUM_PIXELS		128
+/* Totals pixels in a square image. */
+#define NUM_PIXELS_SQUARED	(NUM_PIXELS * NUM_PIXELS)
+/* Number of Haar coeffients we retain as signature for an image. */
+#define NUM_COEFS		40
+
+#define UNIT_IS_DOUBLE
+
+#undef ABS
+#ifdef UNIT_IS_DOUBLE
+#define ABS(x)	fabs(x)
+typedef double	Unit;
+#else
+#define UNIT_IS_INT
+#define ABS(x)	abs(x)
+typedef int	Unit;
+#endif
+
+typedef int Idx;
+
+/* signature structure */
+typedef struct valStruct_{
+    Unit d;			/* [f]abs(a[i]) */
+    int i;			/* index i of a[i] */
+    // warning: order is inverse so valqueue is ordered smallest->biggest
+    bool operator< (const valStruct_ &right) const {
+        return d > right.d;
+    }
+} valStruct;
+
+typedef std::priority_queue < valStruct > valqueue;
+
+#define max(a, b)  (((a) > (b)) ? (a) : (b))
+#define min(a, b)  (((a) > (b)) ? (b) : (a))
+
+void initImgBin();
+void transform(Unit* a, Unit* b, Unit* c);
+void transformChar(unsigned char* c1, unsigned char* c2, unsigned char* c3, Unit* a, Unit* b, Unit* c);
+int calcHaar(Unit* cdata1, Unit* cdata2, Unit* cdata3, Idx* sig1, Idx* sig2, Idx* sig3, double * avgl);
+
+#endif

data/ext/seeklib/sig.cpp

@@ -0,0 +1,67 @@
+#include <stdio.h>
+
+#include <CImg.h>
+
+#include "sig.h"
+
+using namespace cimg_library;
+
+SigStruct *pathSig(char *path) {
+    CImg<unsigned char> img(path);
+    SigStruct *sig = imgSig(&img);
+    return sig;
+}
+
+SigStruct *imgSig(CImg<unsigned char> *img) {
+    img->resize(NUM_PIXELS, NUM_PIXELS);
+    static Unit cdata1[NUM_PIXELS_SQUARED];
+    static Unit cdata2[NUM_PIXELS_SQUARED];
+    static Unit cdata3[NUM_PIXELS_SQUARED];
+    unsigned char rchan[NUM_PIXELS_SQUARED];
+    unsigned char gchan[NUM_PIXELS_SQUARED];
+    unsigned char bchan[NUM_PIXELS_SQUARED];
+    int i = 0;
+    cimg_for(img->get_shared_channel(0), p, unsigned char) {
+        rchan[i] = *p;
+        i++;
+    }
+    i = 0;
+    cimg_for(img->get_shared_channel(1), p, unsigned char) {
+        gchan[i] = *p;
+        i++;
+    }
+    i = 0;
+    cimg_for(img->get_shared_channel(2), p, unsigned char) {
+        bchan[i] = *p;
+        i++;
+    }
+    transformChar(rchan, gchan, bchan, cdata1, cdata2, cdata3);
+    SigStruct *nsig = new SigStruct();
+    calcHaar(cdata1, cdata2, cdata3,
+             nsig->sig1, nsig->sig2, nsig->sig3, nsig->avgl);
+
+    return nsig;
+}
+
+void printSig(SigStruct *sig) {
+    printSigSect(sig->sig1);
+    printSigSect(sig->sig2);
+    printSigSect(sig->sig3);
+}
+
+void printSigObj(SigStruct *sig) {
+    printSig(sig);
+    // avg lum
+    for (int i=0; i<3; i++) {
+        printf("%e ", sig->avgl[i]);
+    }
+    printf("\n");
+}
+
+void printSigSect(Idx *sigSect) {
+    for (int i=0; i<NUM_COEFS; i++) {
+        // typedef int Idx
+        printf("%d ", sigSect[i]);
+    }
+    printf("\n");
+}

data/ext/seeklib/sig.h

@@ -0,0 +1,56 @@
+#ifndef SIG_H
+#define SIG_H
+
+#include "haar.h"
+
+// Weights for the Haar coefficients.
+// Straight from the referenced paper:
+
+const float picture_weights[6][3] = {
+    // For scanned picture (sketch=0):
+    //    Y      I      Q       idx total occurs
+    { 5.00f, 19.21f, 34.37f},  // 0   58.58      1 (`DC' component)
+    { 0.83f,  1.26f,  0.36f},  // 1    2.45      3
+    { 1.01f,  0.44f,  0.45f},  // 2    1.90      5
+    { 0.52f,  0.53f,  0.14f},  // 3    1.19      7
+    { 0.47f,  0.28f,  0.18f},  // 4    0.93      9
+    { 0.30f,  0.14f,  0.27f}   // 5    0.71      16384-25=16359
+};
+
+// Global typedefs
+typedef long int imageId;
+
+namespace cimg_library {
+    template<typename T> struct CImg;
+};
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct _SigStruct {
+    Idx sig1[NUM_COEFS];		/* Y positions with largest magnitude */
+    Idx sig2[NUM_COEFS];		/* I positions with largest magnitude */
+    Idx sig3[NUM_COEFS];		/* Q positions with largest magnitude */
+    double avgl[3];		/* YIQ for position [0,0] */
+    /* image properties extracted when opened for the first time */
+} SigStruct;
+
+
+
+SigStruct *pathSig(char *path);
+SigStruct *imgSig(cimg_library::CImg<unsigned char> *img);
+// TODO: blob -> cimg
+// SigStruct *blobSig(const char *blob, const long length);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+void printSig(SigStruct *sig);
+
+// not api
+void printSigSect(Idx *sigSect);
+
+#endif // SIG_H

data/lib/seeklib.rb

@@ -0,0 +1,54 @@
+require 'ffi'
+
+module SeekLib
+  extend FFI::Library
+  local_lib_path = File.join File.dirname(__FILE__), '..', 'ext', 'seeklib', 'seeklib.so'
+  if File.exists? local_lib_path
+    ffi_lib local_lib_path
+  else
+    ffi_lib 'seek'
+  end
+
+  class Sig < FFI::Struct
+    layout \
+    :sig1, [:int, 40],
+    :sig2, [:int, 40],
+    :sig3, [:int, 40],
+    :avgl, [:double, 3]
+    def get_data
+      [
+        self[:sig1].to_a,
+        self[:sig2].to_a,
+        self[:sig3].to_a,
+        self[:avgl].to_a
+      ]
+    end
+    def inspect
+      data = get_data.map {|x| x.inspect}
+      "#<Sig: #{data.join ' '}>"
+    end
+    # these methods might not be fast enough, but whatever
+    def marshal_dump
+      Marshal.dump get_data
+    end
+    def marshal_load str
+      array = Marshal.load str
+      fields = [:sig1, :sig2, :sig3, :avgl]
+      fields.zip(array).each do |field, data|
+        data.each_index do |i|
+          self[field][i] = data[i]
+        end
+      end
+    end
+  end
+
+  attach_function :calcDiff, [:pointer, :pointer], :double
+  attach_function :pathSig, [:string], :pointer
+
+  def self.path_sig path
+    Sig.new pathSig(path)
+  end
+  def self.calc_diff a, b
+    calcDiff a, b
+  end
+end

metadata

@@ -0,0 +1,67 @@
+--- !ruby/object:Gem::Specification
+name: seeklib
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Daniel Radetsky
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-02-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ffi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+description: ffi bindings for seeklib, the fingerprint algorithm of imgseek
+email:
+- dradetsky@gmail.com
+executables: []
+extensions:
+- ext/seeklib/extconf.rb
+extra_rdoc_files: []
+files:
+- ext/seeklib/cmp.cpp
+- ext/seeklib/cmp.h
+- ext/seeklib/extconf.rb
+- ext/seeklib/haar.cpp
+- ext/seeklib/haar.h
+- ext/seeklib/sig.cpp
+- ext/seeklib/sig.h
+- lib/seeklib.rb
+homepage: https://bitbucket.org/dradetsky/seeklib/
+licenses:
+- WTFPL
+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.7
+signing_key: 
+specification_version: 4
+summary: seeklib ffi bindings
+test_files: []