dlib 1.0.0 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4ac7c861c594529f920bc52385e5f72d9a0b4fea
-  data.tar.gz: 039f3bbf0e4de6588d6c53f6fedd3fe59e274d0e
+  metadata.gz: de7377ee20f24dfad880d3c6ff16109fc80e8f87
+  data.tar.gz: adadbe9e0d6cd190fe998cd71e56bd1900233236
 SHA512:
-  metadata.gz: e47567572cbaa00db9c9510ce5e450cf029f8f353ac4175eaf02c82ddc95eee33d3bfde6eec5d9d2f2225df5e7935b9659c8dcc3775c6f9f4d85132805cac68b
-  data.tar.gz: f1ddbe4cee7f4ecb4103b5369f76f1e367e9a0cbc843bd8979f3902f7cd2a405896c22f42f07a8b7e07db1dd5a8ffca0bae10e2ed2d1fd5ca85a74f59ca72324
+  metadata.gz: 8539bb6d4128233ede76cbd266ea36962922244a56b9fb6177bccc898a45831d41cd73e9249ec8ccb4587fc58814d65f252477ba0e3e775239b8e94f7cfc61d3
+  data.tar.gz: 56a2fb4457ce28a6a3bacf875f083746d08d5a35cc9e181842a8b3d8cfd647c656af717d83512e8b81d1178c432f3125b420f5915e1afe82a2639a336bf27840

data/.rspec

@@ -0,0 +1,3 @@
+--color
+--require spec_helper
+--format Fuubar

data/Gemfile

@@ -2,3 +2,12 @@ source 'https://rubygems.org'
 
 # Specify your gem's dependencies in dlib.gemspec
 gemspec
+
+group :development do
+  gem 'rake-compiler'
+end
+
+group :test do
+  gem 'rspec'
+  gem 'fuubar'
+end

data/Rakefile

@@ -1,2 +1,10 @@
 require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+require "rake/extensiontask"
 
+Rake::ExtensionTask.new('dlib')
+
+RSpec::Core::RakeTask.new("spec")
+
+task default: :spec
+task spec: :compile

data/examples/find_candidate_object_locations.rb

@@ -7,5 +7,9 @@ rects = Dlib.find_candidate_object_locations(img, min_size: 500)
 
 puts "number of rectangles found #{rects.length}"
 rects.each.with_index do |rect, index|
-  puts "Detection #{index}: Left: #{rect.left} Top: #{rect.top} Right: #{rect.right} Bottom: #{rect.bottom}"
+  puts "Detection #{index}: Left: #{rect.left} Top: #{rect.top} Right: #{rect.right} Bottom: #{rect.bottom} Area: #{rect.area}"
+  img.draw_rectangle!(rect, [0, 0, 255]) if rect.area > 0
 end
+
+output_file = ARGV[1] || 'marked.jpg'
+img.save_jpeg(output_file)

data/ext/dlib/depend

@@ -8,5 +8,6 @@ DLIB_FUNCTIONS = \
 
 OBJS += $(DLIB_OJBS)
 
-dlib.o: dlib.cpp $(DLIB_FUNCTIONS)
+dlib.o: dlib.cpp $(DLIB_FUNCTIONS) missing.h
 dlib_deps.o: dlib_deps.cpp
+missing.o: missing.c missing.h

data/ext/dlib/dlib.cpp

@@ -5,6 +5,8 @@
 
 #include <iostream>
 
+#include "missing.h"
+
 static VALUE mDlib;
 
 static VALUE eDlibError;

data/ext/dlib/extconf.rb

@@ -18,4 +18,6 @@ $defs << '-DDLIB_PNG_SUPPORT'
 $defs << '-DDLIB_NO_GUI_SUPPORT'
 $CPPFLAGS << " -I#{DLIB_SRCDIR}"
 
+have_func('rb_get_kwargs')
+
 create_makefile('dlib')

data/ext/dlib/image.inc

@@ -86,6 +86,55 @@ dlib_rb_image_nc(VALUE image)
   return LONG2NUM(nc);
 }
 
+extern "C" VALUE
+dlib_rb_image_save_jpeg(VALUE image, VALUE filename)
+{
+  rgb_image_container *image_container = dlib_rb_image_get_rgb_image_container(image);
+
+  dlib::save_jpeg(image_container->image, StringValueCStr(filename) /*, quality */);
+
+  return image;
+}
+
+extern "C" VALUE
+dlib_rb_image_draw_rectangle(int argc, VALUE *argv, VALUE image)
+{
+  rgb_image_container *image_container = dlib_rb_image_get_rgb_image_container(image);
+
+  VALUE rect, pixel, thickness_v;
+  rb_scan_args(argc, argv, "21", &rect, &pixel, &thickness_v);
+
+  if (!is_obj_dlib_rectangle(rect)) {
+    rb_raise(rb_eTypeError, "Invalid rectangle is given: %"PRIsVALUE, rect);
+  }
+
+  rectangle_container *rectcont = dlib_rb_rectangle_get_rectangle_container(rect);
+
+  Check_Type(pixel, T_ARRAY);
+  if (RARRAY_LEN(pixel) != 3) {
+    rb_raise(rb_eArgError, "Invalid pixel value is given: %"PRIsVALUE, pixel);
+  }
+
+  unsigned char red   = static_cast<unsigned char>(NUM2UINT(RARRAY_AREF(pixel, 0)));
+  unsigned char green = static_cast<unsigned char>(NUM2UINT(RARRAY_AREF(pixel, 1)));
+  unsigned char blue  = static_cast<unsigned char>(NUM2UINT(RARRAY_AREF(pixel, 2)));
+
+  unsigned int thickness = 1;
+  if (!NIL_P(thickness_v)) {
+    Check_Type(thickness_v, T_FIXNUM);
+    thickness = FIX2UINT(thickness_v);
+  }
+
+  dlib::draw_rectangle(
+    image_container->image,
+    rectcont->rect,
+    dlib::rgb_pixel(red, green, blue),
+    thickness
+  );
+
+  return image;
+}
+
 static void
 Init_dlib_image()
 {
@@ -98,4 +147,8 @@ Init_dlib_image()
 
   rb_define_method(cDlibImage, "nr", RUBY_METHOD_FUNC(dlib_rb_image_nr), 0);
   rb_define_method(cDlibImage, "nc", RUBY_METHOD_FUNC(dlib_rb_image_nc), 0);
+
+  rb_define_method(cDlibImage, "save_jpeg", RUBY_METHOD_FUNC(dlib_rb_image_save_jpeg), 1);
+
+  rb_define_method(cDlibImage, "draw_rectangle!", RUBY_METHOD_FUNC(dlib_rb_image_draw_rectangle), -1);
 }

data/ext/dlib/missing.c

@@ -0,0 +1,107 @@
+#ifndef HAVE_RB_GET_KWARGS
+
+#include "missing.h"
+
+static VALUE
+rb_keyword_error_new(const char *error, VALUE keys)
+{
+    const char *msg = "";
+    VALUE error_message;
+
+    if (RARRAY_LEN(keys) == 1) {
+	keys = RARRAY_AREF(keys, 0);
+    }
+    else {
+	keys = rb_ary_join(keys, rb_usascii_str_new2(", "));
+	msg = "s";
+    }
+
+    error_message = rb_sprintf("%s keyword%s: %"PRIsVALUE, error, msg, keys);
+
+    return rb_exc_new_str(rb_eArgError, error_message);
+}
+
+NORETURN(static void rb_keyword_error(const char *error, VALUE keys));
+static void
+rb_keyword_error(const char *error, VALUE keys)
+{
+    rb_exc_raise(rb_keyword_error_new(error, keys));
+}
+
+NORETURN(static void unknown_keyword_error(VALUE hash, const ID *table, int keywords));
+static void
+unknown_keyword_error(VALUE hash, const ID *table, int keywords)
+{
+    st_table *tbl = rb_hash_tbl(hash);
+    VALUE keys;
+    int i;
+    for (i = 0; i < keywords; i++) {
+	st_data_t key = ID2SYM(table[i]);
+	st_delete(tbl, &key, NULL);
+    }
+    keys = rb_funcall(hash, rb_intern("keys"), 0, 0);
+    if (!RB_TYPE_P(keys, T_ARRAY)) rb_raise(rb_eArgError, "unknown keyword");
+    rb_keyword_error("unknown", keys);
+}
+
+int
+rb_get_kwargs(VALUE keyword_hash, const ID *table, int required, int optional, VALUE *values)
+{
+    int i = 0, j;
+    int rest = 0;
+    VALUE missing = Qnil;
+    st_data_t key;
+
+#define extract_kwarg(keyword, val) \
+    (key = (st_data_t)(keyword), values ? \
+     st_delete(rb_hash_tbl(keyword_hash), &key, (val)) : \
+     st_lookup(rb_hash_tbl(keyword_hash), key, (val)))
+
+    if (NIL_P(keyword_hash)) keyword_hash = 0;
+
+    if (optional < 0) {
+	rest = 1;
+	optional = -1-optional;
+    }
+    if (values) {
+	for (j = 0; j < required + optional; j++) {
+	    values[j] = Qundef;
+	}
+    }
+    if (required) {
+	for (; i < required; i++) {
+	    VALUE keyword = ID2SYM(table[i]);
+	    if (keyword_hash) {
+		st_data_t val;
+		if (extract_kwarg(keyword, &val)) {
+		    if (values) values[i] = (VALUE)val;
+		    continue;
+		}
+	    }
+	    if (NIL_P(missing)) missing = rb_ary_tmp_new(1);
+	    rb_ary_push(missing, keyword);
+	}
+	if (!NIL_P(missing)) {
+	    rb_keyword_error("missing", missing);
+	}
+    }
+    j = i;
+    if (optional && keyword_hash) {
+	for (i = 0; i < optional; i++) {
+	    st_data_t val;
+	    if (extract_kwarg(ID2SYM(table[required+i]), &val)) {
+		if (values) values[required+i] = (VALUE)val;
+		j++;
+	    }
+	}
+    }
+    if (!rest && keyword_hash) {
+	if (RHASH_SIZE(keyword_hash) > (unsigned int)j) {
+	    unknown_keyword_error(keyword_hash, table, required+optional);
+	}
+    }
+    return j;
+#undef extract_kwarg
+}
+
+#endif /* HAVE_RB_GET_KWARGS */

data/ext/dlib/missing.h

@@ -0,0 +1,26 @@
+#ifndef DLIB_MISSING_H
+#define DLIB_MISSING_H
+
+#include <ruby/ruby.h>
+
+#if defined(__cplusplus)
+extern "C" {
+#if 0
+} /* satisfy cc-mode */
+#endif
+#endif
+
+
+#ifndef HAVE_RB_GET_KWARGS
+int rb_get_kwargs(VALUE keyword_hash, const ID *table, int required, int optional, VALUE *values);
+#endif
+
+
+#if defined(__cplusplus)
+#if 0
+{ /* satisfy cc-mode */
+#endif
+}  /* extern "C" { */
+#endif
+
+#endif /* DLIB_MISSING_H */

data/ext/dlib/rectangle.inc

@@ -30,6 +30,9 @@ static const rb_data_type_t rectangle_container_data_type = {
 #endif
 };
 
+#define is_data_rectangle(obj) (RTYPEDDATA_P((obj)) && RTYPEDDATA_TYPE((obj)) == &rectangle_container_data_type)
+#define is_obj_dlib_rectangle(obj) (RB_TYPE_P((obj), T_DATA) && is_data_rectangle(obj))
+
 static rectangle_container *
 dlib_rb_rectangle_get_rectangle_container(VALUE rect)
 {
@@ -49,14 +52,66 @@ dlib_rb_rectangle_alloc(VALUE klass)
 }
 
 static VALUE
-dlib_rb_rectangle_new(dlib::rectangle const &dlib_rect)
+dlib_rb_rectangle_s_new(VALUE klass, dlib::rectangle const &dlib_rect)
 {
-  VALUE rect = dlib_rb_rectangle_alloc(cDlibRectangle);
+  VALUE rect = dlib_rb_rectangle_alloc(klass);
   rectangle_container *rectcont = dlib_rb_rectangle_get_rectangle_container(rect);
   rectcont->rect = dlib_rect;
   return rect;
 }
 
+static VALUE
+dlib_rb_rectangle_new(dlib::rectangle const &dlib_rect)
+{
+  return dlib_rb_rectangle_s_new(cDlibRectangle, dlib_rect);
+}
+
+static VALUE
+dlib_rb_rectangle_initialize(int argc, VALUE* argv, VALUE rect)
+{
+  rectangle_container *rectcont = dlib_rb_rectangle_get_rectangle_container(rect);
+
+  switch (argc) {
+    case 4: {
+      long left, top, right, bottom;
+      left = NUM2LONG(argv[0]);
+      top = NUM2LONG(argv[1]);
+      right = NUM2LONG(argv[2]);
+      bottom = NUM2LONG(argv[3]);
+      rectcont->rect = dlib::rectangle(left, top, right, bottom);
+      break;
+    }
+
+    case 2: {
+      unsigned long width, height;
+      width  = NUM2ULONG(argv[0]);
+      height = NUM2ULONG(argv[1]);
+      rectcont->rect = dlib::rectangle(width, height);
+      break;
+    }
+
+    case 0:
+      // Nothing to do.
+      break;
+
+    default:
+      rb_raise(rb_eArgError, "Irregal number of arguments are given");
+  }
+
+  return rect;
+}
+
+extern "C" VALUE
+dlib_rb_rectangle_eq(VALUE rect, VALUE other)
+{
+  rectangle_container *rectcont = dlib_rb_rectangle_get_rectangle_container(rect);
+  if (is_obj_dlib_rectangle(other)) {
+    rectangle_container *rectcont_other = dlib_rb_rectangle_get_rectangle_container(other);
+    return rectcont->rect == rectcont_other->rect ? Qtrue : Qfalse;
+  }
+  return Qfalse;
+}
+
 extern "C" VALUE
 dlib_rb_rectangle_left(VALUE rect)
 {
@@ -85,6 +140,105 @@ dlib_rb_rectangle_bottom(VALUE rect)
   return LONG2NUM(rectcont->rect.bottom());
 }
 
+extern "C" VALUE
+dlib_rb_rectangle_width(VALUE rect)
+{
+  rectangle_container *rectcont = dlib_rb_rectangle_get_rectangle_container(rect);
+  return ULONG2NUM(rectcont->rect.width());
+}
+
+extern "C" VALUE
+dlib_rb_rectangle_height(VALUE rect)
+{
+  rectangle_container *rectcont = dlib_rb_rectangle_get_rectangle_container(rect);
+  return ULONG2NUM(rectcont->rect.height());
+}
+
+extern "C" VALUE
+dlib_rb_rectangle_area(VALUE rect)
+{
+  rectangle_container *rectcont = dlib_rb_rectangle_get_rectangle_container(rect);
+  return ULONG2NUM(rectcont->rect.area());
+}
+
+extern "C" VALUE
+dlib_rb_rectangle_is_empty(VALUE rect)
+{
+  rectangle_container *rectcont = dlib_rb_rectangle_get_rectangle_container(rect);
+  return rectcont->rect.is_empty() ? Qtrue : Qfalse;
+}
+
+extern "C" VALUE
+dlib_rb_rectangle_set_left(VALUE rect, VALUE val)
+{
+  rectangle_container *rectcont = dlib_rb_rectangle_get_rectangle_container(rect);
+  rectcont->rect.set_left(NUM2LONG(val));
+  return val;
+}
+
+extern "C" VALUE
+dlib_rb_rectangle_set_top(VALUE rect, VALUE val)
+{
+  rectangle_container *rectcont = dlib_rb_rectangle_get_rectangle_container(rect);
+  rectcont->rect.set_top(NUM2LONG(val));
+  return val;
+}
+
+extern "C" VALUE
+dlib_rb_rectangle_set_right(VALUE rect, VALUE val)
+{
+  rectangle_container *rectcont = dlib_rb_rectangle_get_rectangle_container(rect);
+  rectcont->rect.set_right(NUM2LONG(val));
+  return val;
+}
+
+extern "C" VALUE
+dlib_rb_rectangle_set_bottom(VALUE rect, VALUE val)
+{
+  rectangle_container *rectcont = dlib_rb_rectangle_get_rectangle_container(rect);
+  rectcont->rect.set_bottom(NUM2LONG(val));
+  return val;
+}
+
+extern "C" VALUE
+dlib_rb_rectangle_union(VALUE rect1, VALUE rect2)
+{
+  rectangle_container *rectcont1 = dlib_rb_rectangle_get_rectangle_container(rect1);
+  rectangle_container *rectcont2 = dlib_rb_rectangle_get_rectangle_container(rect2);
+  dlib::rectangle dlib_rect3 = rectcont1->rect + rectcont2->rect;
+  return dlib_rb_rectangle_s_new(CLASS_OF(rect1), dlib_rect3);
+}
+
+extern "C" VALUE
+dlib_rb_rectangle_intersect(VALUE rect1, VALUE rect2)
+{
+  rectangle_container *rectcont1 = dlib_rb_rectangle_get_rectangle_container(rect1);
+  rectangle_container *rectcont2 = dlib_rb_rectangle_get_rectangle_container(rect2);
+  dlib::rectangle dlib_rect3 = rectcont1->rect.intersect(rectcont2->rect);
+  return dlib_rb_rectangle_s_new(CLASS_OF(rect1), dlib_rect3);
+}
+
+extern "C" VALUE
+dlib_rb_rectangle_inspect(VALUE rect)
+{
+  rectangle_container *rectcont = dlib_rb_rectangle_get_rectangle_container(rect);
+
+  VALUE cname = rb_class_name(CLASS_OF(rect));
+  VALUE str = rb_sprintf(
+    "#<%"PRIsVALUE" (%ld, %ld)-(%ld, %ld) %lux%lu%s>",
+    cname,
+    rectcont->rect.left(),
+    rectcont->rect.top(),
+    rectcont->rect.right(),
+    rectcont->rect.bottom(),
+    rectcont->rect.width(),
+    rectcont->rect.height(),
+    (rectcont->rect.is_empty() ? " empty" : "")
+  );
+
+  return str;
+}
+
 static void
 Init_dlib_rectangle()
 {
@@ -92,8 +246,26 @@ Init_dlib_rectangle()
 
   rb_define_alloc_func(cDlibRectangle, dlib_rb_rectangle_alloc);
 
+  rb_define_method(cDlibRectangle, "initialize", RUBY_METHOD_FUNC(dlib_rb_rectangle_initialize), -1);
+
+  rb_define_method(cDlibRectangle, "==", RUBY_METHOD_FUNC(dlib_rb_rectangle_eq), 1);
+
   rb_define_method(cDlibRectangle, "left", RUBY_METHOD_FUNC(dlib_rb_rectangle_left), 0);
   rb_define_method(cDlibRectangle, "top", RUBY_METHOD_FUNC(dlib_rb_rectangle_top), 0);
   rb_define_method(cDlibRectangle, "right", RUBY_METHOD_FUNC(dlib_rb_rectangle_right), 0);
   rb_define_method(cDlibRectangle, "bottom", RUBY_METHOD_FUNC(dlib_rb_rectangle_bottom), 0);
+  rb_define_method(cDlibRectangle, "width", RUBY_METHOD_FUNC(dlib_rb_rectangle_width), 0);
+  rb_define_method(cDlibRectangle, "height", RUBY_METHOD_FUNC(dlib_rb_rectangle_height), 0);
+  rb_define_method(cDlibRectangle, "area", RUBY_METHOD_FUNC(dlib_rb_rectangle_area), 0);
+  rb_define_method(cDlibRectangle, "empty?", RUBY_METHOD_FUNC(dlib_rb_rectangle_is_empty), 0);
+
+  rb_define_method(cDlibRectangle, "left=", RUBY_METHOD_FUNC(dlib_rb_rectangle_set_left), 1);
+  rb_define_method(cDlibRectangle, "top=", RUBY_METHOD_FUNC(dlib_rb_rectangle_set_top), 1);
+  rb_define_method(cDlibRectangle, "right=", RUBY_METHOD_FUNC(dlib_rb_rectangle_set_right), 1);
+  rb_define_method(cDlibRectangle, "bottom=", RUBY_METHOD_FUNC(dlib_rb_rectangle_set_bottom), 1);
+
+  rb_define_method(cDlibRectangle, "+", RUBY_METHOD_FUNC(dlib_rb_rectangle_union), 1);
+  rb_define_method(cDlibRectangle, "intersect", RUBY_METHOD_FUNC(dlib_rb_rectangle_intersect), 1);
+
+  rb_define_method(cDlibRectangle, "inspect", RUBY_METHOD_FUNC(dlib_rb_rectangle_inspect), 0);
 }

data/lib/dlib/version.rb

@@ -1,3 +1,3 @@
 module Dlib
-  VERSION = "1.0.0"
+  VERSION = "1.0.1"
 end

data/spec/dlib/rectangle_spec.rb

@@ -0,0 +1,120 @@
+require 'spec_helper'
+
+module Dlib
+  describe Rectangle do
+    def rectangle(*args)
+      described_class.new(*args)
+    end
+
+    subject { rectangle(1, 2, 3, 4) }
+
+    describe '#initialize' do
+      context 'with left, top, right, and bottom positions' do
+        it 'has correct values' do
+          expect(subject.left).to   eq(1)
+          expect(subject.top).to    eq(2)
+          expect(subject.right).to  eq(3)
+          expect(subject.bottom).to eq(4)
+          expect(subject.width).to  eq(3)
+          expect(subject.height).to eq(3)
+        end
+      end
+
+      context 'with width and height' do
+        subject { rectangle(2, 3) }
+
+        it 'has correct values' do
+          expect(subject.left).to   eq(0)
+          expect(subject.top).to    eq(0)
+          expect(subject.right).to  eq(1)
+          expect(subject.bottom).to eq(2)
+          expect(subject.width).to  eq(2)
+          expect(subject.height).to eq(3)
+        end
+      end
+
+      context 'without arguments' do
+        subject { rectangle() }
+
+        it 'has correct values' do
+          expect(subject.left).to   eq(0)
+          expect(subject.top).to    eq(0)
+          expect(subject.right).to  eq(-1)
+          expect(subject.bottom).to eq(-1)
+          expect(subject.width).to  eq(0)
+          expect(subject.height).to eq(0)
+        end
+      end
+    end
+
+    describe '#left=' do
+      it 'set left value' do
+        subject.left = 42
+        expect(subject.left).to eq(42)
+      end
+    end
+
+    describe '#top=' do
+      it 'set top value' do
+        subject.top = 42
+        expect(subject.top).to eq(42)
+      end
+    end
+
+    describe '#right=' do
+      it 'set right value' do
+        subject.right = 42
+        expect(subject.right).to eq(42)
+      end
+    end
+
+    describe '#bottom=' do
+      it 'set bottom value' do
+        subject.bottom = 42
+        expect(subject.bottom).to eq(42)
+      end
+    end
+
+    describe '#area' do
+      it 'returns collect values' do
+        expect(rectangle(1, 2, 3, 4).area).to eq(9)
+        expect(rectangle(4, 4).area).to eq(16)
+        expect(rectangle().area).to eq(0)
+      end
+    end
+
+    describe '#empty?' do
+      it 'returns collect values' do
+        expect(rectangle(1, 2, 3, 4)).not_to be_empty
+        expect(rectangle(4, 4)).not_to be_empty
+        expect(rectangle()).to be_empty
+      end
+
+      specify 'There are different empty rectangles not to be equal' do
+        r1 = rectangle(1, 1, 3, 3).intersect(rectangle())
+        r2 = rectangle()
+        expect(r1).not_to eq(r2)
+      end
+    end
+
+    describe '#+' do
+      it 'returns union of two rectangles' do
+        expect(rectangle(1, 1, 3, 3) + rectangle(2, 2, 5, 5)).to eq(rectangle(1, 1, 5, 5))
+        expect(rectangle(1, 2, 3, 5) + rectangle(2, 1, 5, 3)).to eq(rectangle(1, 1, 5, 5))
+        expect(rectangle(1, 1, 3, 3) + rectangle()).to eq(rectangle(1, 1, 3, 3))
+        expect(rectangle() + rectangle(1, 1, 3, 3)).to eq(rectangle(1, 1, 3, 3))
+        expect(rectangle() + rectangle()).to eq(rectangle())
+      end
+    end
+
+    describe '#intersect' do
+      it 'returns intersection of two rectangles' do
+        expect(rectangle(1, 1, 5, 5).intersect(rectangle(2, 2, 3, 3))).to eq(rectangle(2, 2, 3, 3))
+        expect(rectangle(1, 1, 3, 3).intersect(rectangle(2, 2, 5, 5))).to eq(rectangle(2, 2, 3, 3))
+        expect(rectangle(1, 1, 3, 3).intersect(rectangle())).to be_empty
+        expect(rectangle().intersect(rectangle(1, 1, 3, 3))).to be_empty
+        expect(rectangle().intersect(rectangle())).to be_empty
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,94 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# The generated `.rspec` file contains `--require spec_helper` which will cause
+# this file to always be loaded, without a need to explicitly require it in any
+# files.
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, consider making
+# a separate helper file that requires the additional dependencies and performs
+# the additional setup, and require it from the spec files that actually need
+# it.
+#
+# The `.rspec` file also contains a few flags that are not defaults but that
+# users commonly want.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+
+require 'dlib'
+
+RSpec.configure do |config|
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    #     be_bigger_than(2).and_smaller_than(4).description
+    #     # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #     # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+# The settings below are suggested to provide a good initial experience
+# with RSpec, but feel free to customize to your heart's content.
+=begin
+  # These two settings work together to allow you to limit a spec run
+  # to individual examples or groups you care about by tagging them with
+  # `:focus` metadata. When nothing is tagged with `:focus`, all examples
+  # get run.
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+
+  # Limits the available syntax to the non-monkey patched syntax that is
+  # recommended. For more details, see:
+  #   - http://myronmars.to/n/dev-blog/2012/06/rspecs-new-expectation-syntax
+  #   - http://teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   - http://myronmars.to/n/dev-blog/2014/05/notable-changes-in-rspec-3#new__config_option_to_disable_rspeccore_monkey_patching
+  config.disable_monkey_patching!
+
+  # This setting enables warnings. It's recommended, but in some cases may
+  # be too noisy due to issues in dependencies.
+  config.warnings = true
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = 'doc'
+  end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  config.profile_examples = 10
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+=end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dlib
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.0.1
 platform: ruby
 authors:
 - Kenta Murata
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-25 00:00:00.000000000 Z
+date: 2015-03-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -47,6 +47,7 @@ extensions:
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".rspec"
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -2938,8 +2939,12 @@ files:
 - ext/dlib/find_candidate_object_locations.inc
 - ext/dlib/geometry.inc
 - ext/dlib/image.inc
+- ext/dlib/missing.c
+- ext/dlib/missing.h
 - ext/dlib/rectangle.inc
 - lib/dlib/version.rb
+- spec/dlib/rectangle_spec.rb
+- spec/spec_helper.rb
 homepage: ''
 licenses:
 - MIT
@@ -2964,4 +2969,6 @@ rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: Ruby bindings of dlib C++ library.
-test_files: []
+test_files:
+- spec/dlib/rectangle_spec.rb
+- spec/spec_helper.rb