geo 0.1.2

data/README

@@ -0,0 +1,24 @@
+= This is geo, a 2D geometry library for ruby.
+
+It provides fast operations for points, lines, triangles, intersections and containers.
+
+== Dependencies:
+glib:: http://www.gtk.org/
+
+== Classes:
+Geo::Point:: A 2D point providing some common geometry operations.
+Geo::Line:: A 2D line consisting of 2 Geo::Points providing some common geometry operations.
+Geo::Triangle:: A 2D triangle consisting of 3 Geo::Points providing some common geometry operations.
+Geo::PointSet:: A Set-like container of Points.
+Geo::LineSet:: A Set-like container of Lines that provides optimized versions of some common geometry operations on lines.
+Geo::TriangleSet:: A Set-like container of Triangles that provides optimized versions of some common geometry operations on lines.
+
+== Usage:
+
+To use geo just install the gem.
+
+== Examples:
+
+To find if a given line intersects a set of 100 000 other lines:
+
+ :include:examples/intersects.rb

data/examples/intersects.rb

@@ -0,0 +1,26 @@
+
+require 'rubygems'
+require 'geo'
+require 'benchmark'
+
+puts "creating LineSet with 100 000 lines"
+STDOUT.flush
+ls = Geo::LineSet.new
+100000.times do |n|
+  l = Geo::Line.new(rand(1000), rand(1000), 1, 1)
+  l.abs = rand(20)
+  l.angle = rand * 2 * Math::PI
+  ls << Geo::Line.new(rand(1000), rand(1000), rand(1000), rand(1000))
+end
+print "reindexing LineSet..."
+STDOUT.flush
+ls._reindex
+puts "done!"
+l = Geo::Line.new(rand(1000), rand(1000), rand(1000), rand(1000))
+Benchmark.benchmark("LineSet#intersects?(#{l.inspect})") do |bm|
+  bm.report do
+    ls.intersects?(l)
+  end
+end
+
+

data/ext/common.c

@@ -0,0 +1,35 @@
+
+#include "common.h"
+
+#ifdef GEO_DEBUG
+// The indentation of DBEUG messages.
+gint DEBUG_indentation = 0;
+#endif
+
+gboolean
+rb_is_a(VALUE obj, VALUE c) {
+  VALUE cl = CLASS_OF(obj);
+  
+  switch (TYPE(c)) {
+  case T_MODULE:
+  case T_CLASS:
+  case T_ICLASS:
+    break;
+    
+  default:
+    return FALSE;
+  }
+  
+  while (cl) {
+    if (cl == c || RCLASS(cl)->m_tbl == RCLASS(c)->m_tbl)
+      return TRUE;
+    cl = RCLASS(cl)->super;
+  }
+  return FALSE;
+}
+
+gint
+gpointer_compare_as_uint(gconstpointer p1, gconstpointer p2) {
+  return GPOINTER_TO_UINT(p1) - GPOINTER_TO_UINT(p2);
+}
+

data/ext/common.h

@@ -0,0 +1,97 @@
+
+#ifndef COMMON_H
+#define COMMON_H
+
+#include "ruby.h"
+#include <stdlib.h>
+#include <math.h>
+#include <glib.h>
+#include "types.h"
+#include "point.h"
+#include "line.h"
+#include "intersection.h"
+#include "triangle.h"
+#include "geo_set.h"
+#include "line_set.h"
+#include "point_set.h"
+#include "triangle_set.h"
+
+//
+// Utility macros.
+//
+
+//
+// If we have debug turned on when compiling, lets do stuff with all these debug macros.
+//
+#ifdef GEO_DEBUG
+// The indentation of DBEUG messages.
+extern gint DEBUG_indentation;
+// Only execute s if debugging.
+#define IFDEBUG(s) s
+// Make the indentation of normal DEBUG messages one greater.
+#define INDENT indentation++;
+// Make the indentation of normal DEBUG messages one less.
+#define UNINDENT indentation--;
+// Warn if x is NULL.
+#define NULL_WARN(x) if ((x) == NULL) DEBUG("x is NULL!!!");
+// Indent DEBUG_indentation spaces and print the debug message.
+#define DEBUG(s, ...) {							\
+    gint indentation_tmp;						\
+    fprintf(stderr, "DEBUG: %s: ", __PRETTY_FUNCTION__);					\
+    for (indentation_tmp = 0; indentation_tmp < DEBUG_indentation; indentation_tmp++) fprintf(stderr, " "); \
+    fprintf(stderr, s, ## __VA_ARGS__);					\
+    fprintf(stderr, "\n");						\
+    fflush(NULL); }
+// Print out the text in str of length len as a ruby inspected string.
+#define STRING_DEBUG(msg,str,len) {					\
+    fprintf(stderr, "DEBUG: %s: ", (msg));				\
+    rb_funcall(rb_const_get(rb_cObject, rb_intern("Kernel")), rb_intern("print"), 1, rb_funcall(rb_str_new((gchar *) (str), (len)), rb_intern("inspect"), 0)); \
+    fprintf(stderr, "\n");						\
+    fflush(NULL); }
+//
+// If we dont have debug turned on while compiling, just replace them with empty semicolons so as not to confuse the compiler.
+//
+#else
+#define INDENT ;
+#define UNINDENT ;
+#define DEBUG(s, ...) ;
+#define BITSTRING_DEBUG(msg,str,len) ;
+#define IFDEBUG(s) ;
+#endif
+
+
+
+
+
+#define CLASS(value) (( (struct RBasic *) (value) )->klass)
+
+
+#define DBL_PREC 0.00001
+#define DBL_WITHIN(d1,d2,diff) (((d1) - (d2) < diff) && ((d2) - (d1) < diff))
+#define DBL_EQL(d1,d2) (((d1) - (d2) < DBL_PREC) && ((d2) - (d1) < DBL_PREC))
+#define DBL_EOG(object,subject) ((subject) - (object) < DBL_PREC)
+#define DBL_EOL(object,subject) ((object) - (subject) < DBL_PREC)
+#define DBL_GT(object,subject) ((object) - (subject) > DBL_PREC)
+#define DBL_LT(object,subject) ((subject) - (object) > DBL_PREC)
+#define IS_INTLIKE(x) (DBL_EQL((x), round((x))))
+#define CMP(a,b) ((a) - (b))
+
+#define GBOOL2RB(gbool) ((gbool) ? Qtrue : Qfalse)
+#define CHECK_NUMERICALITY(v) if (NIL_P((v)) || (TYPE((v)) != T_FIXNUM && TYPE((v)) != T_FLOAT)) rb_raise(rb_eTypeError, "Expected a Number!")
+
+
+
+gboolean 
+rb_is_a(VALUE obj, VALUE c);
+
+gint
+gpointer_compare_as_uint(gconstpointer p1, gconstpointer p2);
+
+
+
+
+
+
+#endif
+
+

data/ext/extconf.rb

@@ -0,0 +1,51 @@
+# Archipelago - a distributed computing toolkit for ruby
+# Copyright (C) 2006  Martin Kihlgren <zond at troja dot ath dot cx>
+#
+# 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+
+require 'mkmf'
+
+def crash(s)
+  puts "--------------------------------------------------"
+  puts " extconf failure: #{s}"
+  puts "--------------------------------------------------"
+  exit 1
+end
+
+unless find_executable("pkg-config")
+  crash("pkg-config needed")
+end
+
+unless have_library('glib-2.0')
+  crash "libglib-2.0 needed"
+end
+
+$CFLAGS += " -std=c99 -Wall " + `pkg-config --cflags glib-2.0`.strip
+
+if ARGV.include?("-d")
+  $CFLAGS += " -D GEO_DEBUG" 
+end
+
+if ARGV.include?("-O0")
+  $CFLAGS.gsub!(/-O./, "-O0")
+else
+  $CFLAGS.gsub!(/-O./, "-O3")
+end
+
+if ARGV.include?("-gdb")
+  $CFLAGS += " -g -gdwarf-2 -g3"
+end
+
+create_makefile("geo")

data/ext/geo.c

@@ -0,0 +1,163 @@
+
+#include "common.h"
+
+VALUE
+rb_float_intlike(VALUE self) {
+  if (IS_INTLIKE(NUM2DBL(self)))
+    return Qtrue;
+  else
+    return Qfalse;
+}
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+  void Init_geo() {
+    rb_funcall(rb_cObject, rb_intern("require"), 1, rb_str_new2("set"));
+
+    rb_define_method(rb_cFloat, "intlike?", rb_float_intlike, 0);
+
+    VALUE rb_geo = rb_define_module("Geo");
+    rb_define_const(rb_geo, "VERSION", rb_str_new2("0.1.2"));
+
+    rb_triangle_set = rb_define_class_under(rb_geo,
+					    "TriangleSet",
+					    rb_cObject);
+    rb_triangle = rb_define_class_under(rb_geo,
+					"Triangle",
+					rb_cObject);
+    rb_line = rb_define_class_under(rb_geo,
+				    "Line",
+				    rb_cObject);
+    rb_point = rb_define_class_under(rb_geo,
+				     "Point",
+				     rb_cObject);
+    rb_line_set = rb_define_class_under(rb_geo,
+					  "LineSet",
+					  rb_cObject);
+    rb_point_set = rb_define_class_under(rb_geo,
+					  "PointSet",
+					  rb_cObject);
+
+    rb_define_alloc_func(rb_triangle_set, rb_triangle_set_alloc);
+    rb_define_method(rb_triangle_set, "<<", rb_triangle_set_insert, 1);
+    rb_define_method(rb_triangle_set, "each", rb_triangle_set_each, 0);
+    rb_define_method(rb_triangle_set, "size", rb_geo_set_size, 0);
+    rb_define_method(rb_triangle_set, "inspect", rb_geo_set_inspect, 0);
+    rb_define_method(rb_triangle_set, "include?", rb_triangle_set_include, 1);
+    rb_define_method(rb_triangle_set, "delete!", rb_triangle_set_delete, 1);
+    rb_define_method(rb_triangle_set, "contains?", rb_triangle_set_contains, 1);
+    rb_define_method(rb_triangle_set, "first_container", rb_triangle_set_first_container, 1);
+    rb_define_method(rb_triangle_set, "intersectors", rb_triangle_set_intersectors, 1);
+    rb_define_method(rb_triangle_set, "intersects?", rb_triangle_set_intersects, 1);
+    rb_define_method(rb_triangle_set, "clone", rb_triangle_set_clone, 0);
+    rb_define_method(rb_triangle_set, "_segment_side", rb_geo_set_segment_side, 0);
+    rb_define_method(rb_triangle_set, "_segment_lines", rb_geo_set_segment_lines, 0);
+    rb_define_method(rb_triangle_set, "_bottom_left", rb_geo_set_bottom_left, 0);
+    rb_define_method(rb_triangle_set, "_top_right", rb_geo_set_top_right, 0);
+    rb_define_method(rb_triangle_set, "_width", rb_geo_set_width, 0);
+    rb_define_method(rb_triangle_set, "_height", rb_geo_set_height, 0);
+    rb_define_method(rb_triangle_set, "_reindex", rb_triangle_set_reindex, 0);
+    rb_define_method(rb_triangle_set, "_segments_for", rb_triangle_set_segment_ids_for_triangle, 1);
+    rb_define_method(rb_triangle_set, "_with_common_segment", rb_triangle_set_triangles_with_common_segment_id, 1);
+    rb_define_method(rb_triangle_set, "_in_segment", rb_triangle_set_structures_in_segment, 2);
+
+    rb_define_alloc_func(rb_point_set, rb_point_set_alloc);
+    rb_define_method(rb_point_set, "<<", rb_point_set_insert, 1);
+    rb_define_method(rb_point_set, "each", rb_point_set_each, 0);
+    rb_define_method(rb_point_set, "size", rb_geo_set_size, 0);
+    rb_define_method(rb_point_set, "inspect", rb_geo_set_inspect, 0);
+    rb_define_method(rb_point_set, "include?", rb_point_set_include, 1);
+    rb_define_method(rb_point_set, "delete!", rb_point_set_delete, 1);
+    rb_define_method(rb_point_set, "clone", rb_point_set_clone, 0);
+
+    rb_define_alloc_func(rb_line_set, rb_line_set_alloc);
+    rb_define_method(rb_line_set, "<<", rb_line_set_insert, 1);
+    rb_define_method(rb_line_set, "each", rb_line_set_each, 0);
+    rb_define_method(rb_line_set, "size", rb_geo_set_size, 0);
+    rb_define_method(rb_line_set, "inspect", rb_geo_set_inspect, 0);
+    rb_define_method(rb_line_set, "intersects?", rb_line_set_intersects, 1);
+    rb_define_method(rb_line_set, "closest_intersection", rb_line_set_closest_intersection, 1);
+    rb_define_method(rb_line_set, "slide", rb_line_set_slide, 1);
+    rb_define_method(rb_line_set, "include?", rb_line_set_include, 1);
+    rb_define_method(rb_line_set, "delete!", rb_line_set_delete, 1);
+    rb_define_method(rb_line_set, "intersections", rb_line_set_intersections, 1);
+    rb_define_method(rb_line_set, "nr_of_intersections", rb_line_set_n_intersections, 1);
+    rb_define_method(rb_line_set, "intersection_free_endpoints", rb_line_set_intersection_free_endpoints, -1);
+    rb_define_method(rb_line_set, "clone", rb_line_set_clone, 0);
+    rb_define_method(rb_line_set, "_segment_side", rb_geo_set_segment_side, 0);
+    rb_define_method(rb_line_set, "_reindex", rb_line_set_reindex, 0);
+    rb_define_method(rb_line_set, "_in_segment", rb_line_set_structures_in_segment, 2);
+    rb_define_method(rb_line_set, "_segments_for", rb_line_set_segment_ids_for_line, 1);
+    rb_define_method(rb_line_set, "_segment_lines", rb_geo_set_segment_lines, 0);
+    rb_define_method(rb_line_set, "_bottom_left", rb_geo_set_bottom_left, 0);
+    rb_define_method(rb_line_set, "_top_right", rb_geo_set_top_right, 0);
+    rb_define_method(rb_line_set, "_width", rb_geo_set_width, 0);
+    rb_define_method(rb_line_set, "_height", rb_geo_set_height, 0);
+    rb_define_method(rb_line_set, "_with_common_segment", rb_line_set_lines_with_common_segment_id, 1);
+
+    rb_define_alloc_func(rb_triangle, rb_triangle_alloc);
+    rb_define_method(rb_triangle, "initialize", rb_triangle_initialize, -1);
+    rb_define_method(rb_triangle, "inspect", rb_triangle_inspect, 0);
+    rb_define_method(rb_triangle, "==", rb_triangle_equals, 1);
+    rb_define_method(rb_triangle, "p1", rb_triangle_p1, 0);
+    rb_define_method(rb_triangle, "p2", rb_triangle_p2, 0);
+    rb_define_method(rb_triangle, "p3", rb_triangle_p3, 0);
+    rb_define_method(rb_triangle, "p1=", rb_triangle_set_p1, 0);
+    rb_define_method(rb_triangle, "p2=", rb_triangle_set_p2, 0);
+    rb_define_method(rb_triangle, "p3=", rb_triangle_set_p3, 0);
+    rb_define_method(rb_triangle, "clone", rb_triangle_clone, 0);
+    rb_define_method(rb_triangle, "area", rb_triangle_area, 0);
+    rb_define_method(rb_triangle, "contains?", rb_triangle_contains, 1);
+    rb_define_method(rb_triangle, "intersects?", rb_triangle_intersects, 1);
+    rb_define_method(rb_triangle, "overlap", rb_triangle_overlap, 1);
+    rb_define_method(rb_triangle, "<=>", rb_triangle_cmp, 1);
+
+    rb_define_alloc_func(rb_line, rb_line_alloc);
+    rb_define_method(rb_line, "initialize", rb_line_initialize, -1);
+    rb_define_method(rb_line, "inspect", rb_line_inspect, 0);
+    rb_define_method(rb_line, "reverse", rb_line_reverse, 0);
+    rb_define_method(rb_line, "p1", rb_line_p1, 0);
+    rb_define_method(rb_line, "p2", rb_line_p2, 0);
+    rb_define_method(rb_line, "p1=", rb_line_set_p1, 1);
+    rb_define_method(rb_line, "p2=", rb_line_set_p2, 1);
+    rb_define_method(rb_line, "outside?", rb_line_outside, 1);
+    rb_define_method(rb_line, "within?", rb_line_within, 1);
+    rb_define_method(rb_line, "intersection", rb_line_intersection, 1);
+    rb_define_method(rb_line, "==", rb_line_equals, 1);
+    rb_define_method(rb_line, "*", rb_line_dot, 1);
+    rb_define_method(rb_line, "abs", rb_line_abs, 0);
+    rb_define_method(rb_line, "abs=", rb_line_set_abs, 1);
+    rb_define_method(rb_line, "angle", rb_line_angle, 0);
+    rb_define_method(rb_line, "angle=", rb_line_set_angle, 1);
+    rb_define_method(rb_line, "clone", rb_line_clone, 0);
+    rb_define_method(rb_line, "side", rb_line_side, 1);
+    rb_define_method(rb_line, "contains?", rb_line_contains, 1);
+    rb_define_method(rb_line, "parallel", rb_line_parallel, 1);
+    rb_define_method(rb_line, "<=>", rb_line_cmp, 1);
+
+    rb_define_alloc_func(rb_point, rb_point_alloc);
+    rb_define_method(rb_point, "initialize", rb_point_initialize, 2);
+    rb_define_method(rb_point, "inspect", rb_point_inspect, 0);
+    rb_define_method(rb_point, "x", rb_point_x, 0);
+    rb_define_method(rb_point, "y", rb_point_y, 0);
+    rb_define_method(rb_point, "x=", rb_point_set_x, 1);
+    rb_define_method(rb_point, "y=", rb_point_set_y, 1);
+    rb_define_method(rb_point, "*", rb_point_dot, 1);
+    rb_define_method(rb_point, "==", rb_point_equals, 1);
+    rb_define_method(rb_point, "abs", rb_point_abs, 0);
+    rb_define_method(rb_point, "angle", rb_point_angle, 0);
+    rb_define_method(rb_point, "angle=", rb_point_set_angle, 1);
+    rb_define_method(rb_point, "abs=", rb_point_set_abs, 1);
+    rb_define_method(rb_point, "to", rb_point_to, -1);
+    rb_define_method(rb_point, "clone", rb_point_clone, 0);
+    rb_define_method(rb_point, "on?", rb_point_on, 1);
+    rb_define_method(rb_point, "in?", rb_point_in, 1);
+    rb_define_method(rb_point, "<=>", rb_point_cmp, 1);
+    rb_define_method(rb_point, "+", rb_point_plus, 1);
+    rb_define_method(rb_point, "-", rb_point_minus, 1);
+  }
+#ifdef __cplusplus
+}
+#endif
+