geo 0.1.4 → 0.1.5

data/ext/common.c

@@ -16,12 +16,10 @@
 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 
 
-#include "common.h"
+#include <common.h>
 
-#ifdef GEO_DEBUG
-// The indentation of DBEUG messages.
+// The indentation of DEBUG messages.
 gint DEBUG_indentation = 0;
-#endif
 
 gboolean
 rb_is_a(VALUE obj, VALUE c) {
@@ -50,3 +48,6 @@ gpointer_compare_as_uint(gconstpointer p1, gconstpointer p2) {
   return GPOINTER_TO_UINT(p1) - GPOINTER_TO_UINT(p2);
 }
 
+void
+init_common_o() {
+}

data/ext/common.h

@@ -23,15 +23,15 @@
 #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"
+#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>
 
 #ifndef M_PI
 #define M_PI           3.14159265358979323846  /* pi */

data/ext/extconf.rb

@@ -28,12 +28,13 @@ unless find_executable("pkg-config")
   crash("pkg-config needed")
 end
 
+$CFLAGS += " -std=c99 -Wall -I. " + `pkg-config --cflags glib-2.0`.strip
+$LIBS += " " + `pkg-config --libs glib-2.0`
+
 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

data/ext/geo.c

@@ -16,7 +16,7 @@
 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 
 
-#include "common.h"
+#include <common.h>
 
 VALUE
 rb_float_intlike(VALUE self) {
@@ -30,12 +30,10 @@ rb_float_intlike(VALUE self) {
 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.4"));
+    rb_define_const(rb_geo, "VERSION", rb_str_new2("0.1.5"));
 
     rb_triangle_set = rb_define_class_under(rb_geo,
 					    "TriangleSet",
@@ -78,6 +76,8 @@ extern "C" {
     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_method(rb_triangle_set, "indexed", rb_geo_set_get_indexed, 0);
+    rb_define_method(rb_triangle_set, "indexed=", rb_geo_set_set_indexed, 1);
 
     rb_define_alloc_func(rb_point_set, rb_point_set_alloc);
     rb_define_method(rb_point_set, "<<", rb_point_set_insert, 1);
@@ -112,6 +112,8 @@ extern "C" {
     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_method(rb_line_set, "indexed", rb_geo_set_get_indexed, 0);
+    rb_define_method(rb_line_set, "indexed=", rb_geo_set_set_indexed, 1);
 
     rb_define_alloc_func(rb_triangle, rb_triangle_alloc);
     rb_define_method(rb_triangle, "initialize", rb_triangle_initialize, -1);
@@ -178,3 +180,7 @@ extern "C" {
 }
 #endif
 
+void
+init_geo_o() {
+}
+

data/ext/geo_set.c

@@ -16,7 +16,7 @@
 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 
 
-#include "common.h"
+#include <common.h>
 
 VALUE
 rb_geo_set_inspect(VALUE self) {
@@ -39,19 +39,6 @@ g_hash_table_destroy_notify(gpointer p) {
   g_hash_table_destroy((GHashTable *) p);
 }
 
-static GeoSet*
-new_geo_set_without_table() {
-  GeoSet *rval = ALLOC(GeoSet);
-  rval->iterating = FALSE;
-  rval->bottom_left = new_point(0,0);
-  rval->top_right = new_point(0,0);
-  rval->segment_side = 0;
-  rval->segments = g_hash_table_new_full(g_direct_hash, g_direct_equal, NULL, g_hash_table_destroy_notify);
-  rval->segment_lines = g_hash_table_new_full(g_direct_hash, g_direct_equal, NULL, line_destroy_notify);
-  rval->index_dirty = TRUE;
-  return rval;
-}
-
 void
 geo_set_free(GeoSet *t) {
   free(t->bottom_left);
@@ -62,17 +49,19 @@ geo_set_free(GeoSet *t) {
   free(t);
 }
 
-GeoSet*
-new_geo_set_with_destroy_notifier(GDestroyNotify destroy_notify) {
-  GeoSet *rval = new_geo_set_without_table();
-  rval->table = g_hash_table_new_full(g_direct_hash, g_direct_equal, destroy_notify, NULL);
-  return rval;
-}
-
 GeoSet*
 new_geo_set() {
-  GeoSet *rval = new_geo_set_without_table();
+  GeoSet *rval = ALLOC(GeoSet);
+  rval->iterating = FALSE;
+  rval->bottom_left = new_point(0,0);
+  rval->top_right = new_point(0,0);
+  rval->segment_side = 0;
+  rval->segments = g_hash_table_new_full(g_direct_hash, g_direct_equal, NULL, g_hash_table_destroy_notify);
+  rval->segment_lines = g_hash_table_new_full(g_direct_hash, g_direct_equal, NULL, line_destroy_notify);
+  rval->index_dirty = TRUE;
+  rval->indexed = TRUE;
   rval->table = g_hash_table_new(g_direct_hash, g_direct_equal);
+  rval->rbGeoSet = 0;
   return rval;
 }
 
@@ -141,11 +130,11 @@ geo_set_find_bounds(GeoSet *set, geo_set_bound_finder bound_finder) {
   set->bottom_left = NULL;
   set->top_right = NULL;
   bound_finder(set);
-  set->segment_side = sqrt(GEO_SET_WIDTH(set) * GEO_SET_HEIGHT(set) / g_hash_table_size(set->table));
+  set->segment_side = sqrt(MAX(1, GEO_SET_WIDTH(set)) * MAX(1, GEO_SET_HEIGHT(set)) / g_hash_table_size(set->table));
   if (GEO_SET_HORIZONTAL_SEGMENTS(set) > MAX_GEO_SET_SEGMENTS)
-    set->segment_side = GEO_SET_WIDTH(set) / MAX_GEO_SET_SEGMENTS;
+    set->segment_side = MAX(1, GEO_SET_WIDTH(set)) / MAX_GEO_SET_SEGMENTS;
   if (GEO_SET_VERTICAL_SEGMENTS(set) > MAX_GEO_SET_SEGMENTS)
-    set->segment_side = GEO_SET_HEIGHT(set) / MAX_GEO_SET_SEGMENTS;
+    set->segment_side = MAX(1, GEO_SET_HEIGHT(set)) / MAX_GEO_SET_SEGMENTS;
 }
 
 static void
@@ -199,7 +188,7 @@ rb_geo_set_structures_in_segment(VALUE self, VALUE xV, VALUE yV, geo_structure_t
 }
 
 static gboolean
-g_hash_table_call_handler_for_structure_in_id_until(gpointer key, gpointer value, gpointer user_data) {
+g_hash_table_call_handler_for_unique_structure_until(gpointer key, gpointer value, gpointer user_data) {
   gpointer *args = (gpointer *) user_data;
   GeoSet *set = (GeoSet *) args[0];
   geo_set_structure_handler handler = (geo_set_structure_handler) args[1];
@@ -232,7 +221,7 @@ geo_set_each_structure_in_segment_id_until(GeoSet *set, guint32 segment_id, gpoi
   if (structures_in_id != NULL) {
     gpointer rval = NULL;
     gpointer args[5] = { set, handler, seen_structures, &rval, handler_args };
-    g_hash_table_find(structures_in_id, g_hash_table_call_handler_for_structure_in_id_until, args);
+    g_hash_table_find(structures_in_id, g_hash_table_call_handler_for_unique_structure_until, args);
     return rval;
   } else {
     return NULL;
@@ -427,7 +416,7 @@ geo_set_find_segments(GeoSet *set, geo_set_segment_finder segment_finder) {
 
 gboolean
 geo_set_reindex(GeoSet *set, geo_set_bound_finder bound_finder, geo_set_segment_finder segment_finder) {
-  if (set->index_dirty && g_hash_table_size(set->table) > 0) {
+  if (set->indexed && set->index_dirty && g_hash_table_size(set->table) > 0) {
     set->index_dirty = FALSE;
     geo_set_find_bounds(set, bound_finder);
     if (set->segment_side > 0) {
@@ -442,13 +431,46 @@ geo_set_reindex(GeoSet *set, geo_set_bound_finder bound_finder, geo_set_segment_
   }
 }
 
-void
-geo_set_foreach(GeoSet *set, GHFunc func) {
-  set->iterating = TRUE;
-  g_hash_table_foreach(set->table, func, NULL);
-  set->iterating = FALSE;
+VALUE
+rb_geo_set_set_indexed(VALUE self, VALUE new_indexed) {
+  GeoSet *set;
+  GEO_SET(self, set);
+  if (new_indexed == Qtrue)
+    set->indexed = TRUE;
+  else 
+    set->indexed = FALSE;
+  return GBOOL2RB(set->indexed);
+}
+
+VALUE
+rb_geo_set_get_indexed(VALUE self) {
+  GeoSet *set;
+  GEO_SET(self, set);
+  return GBOOL2RB(set->indexed);
+}
+
+static gboolean
+g_hash_table_call_handler_for_structure_until(gpointer key, gpointer value, gpointer user_data) {
+  gpointer *args = (gpointer *) user_data;
+  GeoSet *set = (GeoSet *) args[0];
+  geo_set_structure_handler handler = (geo_set_structure_handler) args[1];
+  gpointer *rval = (gpointer *) args[2];
+  if ((*rval = handler(set, key, args[3])) != NULL) {
+    return TRUE;
+  } else {
+    return FALSE;
+  }
+  return FALSE;
 }
 
+gpointer
+geo_set_each_structure_until(GeoSet *set, geo_set_structure_handler handler, gpointer handler_args) {
+  gpointer rval;
+  gpointer args[5] = { set, handler, &rval, handler_args };
+  g_hash_table_find(set->table, g_hash_table_call_handler_for_structure_until, args);
+  return rval;
+} 
+
 VALUE
 geo_set_delete(GeoSet *set, gpointer p, VALUE rval) {
   CHECK_ITERATING(set);
@@ -479,15 +501,19 @@ rb_geo_set_segment_lines(VALUE self) {
 VALUE
 rb_geo_set_bottom_left(VALUE self) {
   GeoSet *set;
+  Point *point;
   GEO_SET(self, set);
-  return RB_POINT(new_point(set->bottom_left->x, set->bottom_left->y), rb_point);
+  point = new_point(set->bottom_left->x, set->bottom_left->y);
+  return RB_POINT(point, rb_point);
 }
 
 VALUE
 rb_geo_set_top_right(VALUE self) {
   GeoSet *set;
+  Point *point;
   GEO_SET(self, set);
-  return RB_POINT(new_point(set->top_right->x, set->top_right->y), rb_point);
+  point = new_point(set->top_right->x, set->top_right->y);
+  return RB_POINT(point, rb_point);
 }
 
 VALUE
@@ -503,3 +529,8 @@ rb_geo_set_height(VALUE self) {
   GEO_SET(self, set);
   return rb_float_new(GEO_SET_HEIGHT(set));
 }
+
+void
+init_geo_set_o() {
+}
+

data/ext/geo_set.h

@@ -19,7 +19,7 @@
 #ifndef GEO_SET_H
 #define GEO_SET_H
 
-#include "common.h"
+#include <common.h>
 
 struct IntersectionStruct;
 enum IntersectionTypeEnum;
@@ -75,9 +75,6 @@ rb_geo_set_inspect(VALUE self);
 VALUE
 rb_geo_set_size(VALUE self);
 
-GeoSet*
-new_geo_set_with_destroy_notifier(GDestroyNotify destroy_notify);
-
 GeoSet*
 new_geo_set();
 
@@ -90,9 +87,6 @@ geo_set_clone(GeoSet *set);
 gboolean
 geo_set_reindex(GeoSet *set, geo_set_bound_finder bound_finder, geo_set_segment_finder segment_finder);
 
-void
-geo_set_foreach(GeoSet *set, GHFunc func);
-
 VALUE
 geo_set_delete(GeoSet *set, gpointer p, VALUE rval);
 
@@ -169,5 +163,13 @@ geo_set_each_structure_in_segment_id_until(GeoSet *set, guint32 segment_id, gpoi
 gpointer
 geo_set_insert_structure_into_rb_ary(GeoSet *set, gpointer structure, gpointer user_data);
 
+VALUE
+rb_geo_set_set_indexed(VALUE self, VALUE new_indexed);
+
+VALUE
+rb_geo_set_get_indexed(VALUE self);
+
+gpointer
+geo_set_each_structure_until(GeoSet *set, geo_set_structure_handler handler, gpointer handler_args);
 
 #endif

data/ext/intersection.c

@@ -16,7 +16,7 @@
 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 
 
-#include "common.h"
+#include <common.h>
 
 
 void
@@ -24,7 +24,7 @@ free_intersection(Intersection *intersection) {
   if (intersection->type == itPOINT)
     free(intersection->point);
   else if (intersection->type == itLINE)
-    free(intersection->line);
+    line_free(intersection->line);
   free(intersection);
 }
 
@@ -73,3 +73,7 @@ rb_intersection(Intersection *intersection, Point *from) {
   }
 }
 
+void
+init_intersection_o() {
+}
+

data/ext/intersection.h

@@ -19,7 +19,7 @@
 #ifndef INTERSECTION_H
 #define INTERSECTION_H
 
-#include "common.h"
+#include <common.h>
 
 
 #define INTERSECTION_CLOSEST_POINT(intersection_pointer,point_pointer) ((intersection_pointer)->type == itPOINT ? \

data/ext/line.c

@@ -16,7 +16,7 @@
 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 
 
-#include "common.h"
+#include <common.h>
 
 VALUE rb_line;
 
@@ -25,7 +25,7 @@ VALUE rb_line;
  * since they will be freed by ruby. Make sure that they have
  * rubified points (RB_POINT) as well though!
  */
-static void
+void
 line_free(Line *l) {
   free(l->p1);
   free(l->p2);
@@ -103,16 +103,30 @@ rb_line_initialize(int argc, VALUE *argv, VALUE self) {
   return self;
 }
 
+gchar *
+line_inspect(Line *l) {
+  gchar *rval = calloc(1024, sizeof(gchar));
+  gchar *p1 = point_inspect(l->p1);
+  gchar *p2 = point_inspect(l->p2);
+  snprintf(rval, 1024, "<%s:%p p1=%s p2=%s>",
+	   rb_obj_classname(l->rbLine), l, 
+	   p1,
+	   p2);
+  free(p1);
+  free(p2);
+  return rval;
+}
+
 VALUE
 rb_line_inspect(VALUE self) {
-  gchar rval[1024];
+  gchar *str;
   Line *l;
+  VALUE rval;
   LINE(self, l);
-  snprintf(rval, 1024, "<%s:%p p1=<%s:%p x=%f y=%f> p2=<%s:%p x=%f y=%f>>", 
-	   rb_obj_classname(self), l, 
-	   rb_obj_classname(l->p1->rbPoint), l->p1, l->p1->x, l->p1->y, 
-	   rb_obj_classname(l->p2->rbPoint), l->p2, l->p2->x, l->p2->y);
-  return rb_str_new2(rval);
+  str = line_inspect(l);
+  rval = rb_str_new2(str);
+  free(str);
+  return rval;
 }
 
 VALUE
@@ -319,6 +333,11 @@ rb_line_abs(VALUE self) {
   return rb_float_new(DISTANCE(me->p1, me->p2));
 }
 
+gboolean
+line_equals(gconstpointer l1, gconstpointer l2) {
+  return LINE_EQUALS(l1, l2);
+}
+
 VALUE
 rb_line_equals(VALUE self, VALUE o) {
   if (!LINE_P(o)) {
@@ -336,14 +355,14 @@ rb_line_equals(VALUE self, VALUE o) {
   }
 }
 
-gint
+static gint
 line_cmp(Line *me, Line *other) {
   gint tmp;
   gdouble my_length;
   gdouble other_length;
   my_length = DISTANCE(me->p1, me->p2);
   other_length = DISTANCE(other->p1, other->p2);
-  if (my_length != other_length)
+  if (!DBL_EQL(my_length, other_length))
     return CMP(my_length, other_length);
   else if ((tmp = point_cmp(me->p1, other->p1)) != 0)
     return tmp;
@@ -395,16 +414,20 @@ rb_line_angle(VALUE self) {
   return rb_float_new(LINE_ANGLE(me));
 }
 
+void
+line_set_abs(Line *me, double new_abs) {
+  double ratio = new_abs / DISTANCE(me->p1, me->p2);
+  me->p2->x = me->p2->x * ratio;
+  me->p2->y = me->p2->y * ratio;
+}
+
 VALUE
 rb_line_set_abs(VALUE self, VALUE new_abs) {
   Line *me;
-  gdouble ratio;
   CHECK_NUMERICALITY(new_abs);
   LINE(self, me);
   ZERO_DISTANCE_CHECK(me->p1, me->p2);
-  ratio = NUM2DBL(new_abs) / DISTANCE(me->p1, me->p2);
-  me->p2->x = me->p2->x * ratio;
-  me->p2->y = me->p2->y * ratio;
+  line_set_abs(me, NUM2DBL(new_abs));
   return new_abs;
 }
 
@@ -450,4 +473,131 @@ rb_line_from_gpointer(gpointer l) {
   return ( (Line *) l)->rbLine;
 }
 
+gboolean
+line_slide_point(Intersection *intersection, Line *line, gint ttl) {
+  Point touchPoint;
+  Point destOne;
+  Point destTwo;
+  gdouble distanceLeft;
+  gdouble errorOne;
+  gdouble errorTwo;
+  /*
+   * The line we want to adjust against. If the intersection is with a line of zero
+   * length, then it is against ourselves. Otherwise with the intersecting line.
+   */
+  gboolean zero_intersection = intersection->type == itLINE && ZERO_DISTANCE_P(intersection->with->p1, intersection->with->p2);
+  gdouble adjustment_length = zero_intersection ? DISTANCE(line->p1, line->p2) : DISTANCE(intersection->with->p1, intersection->with->p2);
+  gdouble adjustment_xunit = zero_intersection ?	\
+    (line->p2->x - line->p1->x) / adjustment_length :			\
+    (intersection->with->p2->x - intersection->with->p1->x) / adjustment_length;
+  gdouble adjustment_yunit = zero_intersection ?	\
+    (line->p2->y - line->p1->y) / adjustment_length :			\
+    (intersection->with->p2->y - intersection->with->p1->y) / adjustment_length;
+  /*
+   * Calculate where we actually touch the other line.
+   */
+  if (intersection->type == itLINE) {
+    if (DISTANCE(intersection->line->p1, line->p1) <
+	DISTANCE(intersection->line->p2, line->p1)) {
+      touchPoint = *(intersection->line->p1);
+    } else {
+      touchPoint = *(intersection->line->p2);
+    }
+  } else {
+    touchPoint = *(intersection->point);
+  }
+  if (intersection->type == itPOINT) {
+    /*
+     * If we intersected with a point, move the touch point back towards the start point to not actually touch the other line.
+     */
+    if (line->p1->x > touchPoint.x) 
+      touchPoint.x += MIN(1, line->p1->x - touchPoint.x);
+    if (line->p1->x < touchPoint.x)
+      touchPoint.x -= MIN(1, touchPoint.x - line->p1->x);
+    if (line->p1->y > touchPoint.y)
+      touchPoint.y += MIN(1, line->p1->y - touchPoint.y);
+    if (line->p1->y < touchPoint.y)
+      touchPoint.y -= MIN(1, touchPoint.y - line->p1->y);
+  } else {
+    /*
+     * If we intersected with a line, move perpendicular to our adjustment-line.
+     */
+    if (rand() < RAND_MAX / 2) {
+      touchPoint.x += adjustment_yunit;
+      touchPoint.y -= adjustment_xunit;
+    } else {
+      touchPoint.x -= adjustment_yunit;
+      touchPoint.y += adjustment_xunit;
+    }
+  }
+  /*
+   * If the ttl is reached then we just set the line's p2 to the touchPoint.
+   */
+  if (ttl < 1) {
+    line->p2->x = touchPoint.x;
+    line->p2->y = touchPoint.y;
+    /*
+     * We are done here, no more sliding.
+     */
+    return TRUE;
+  } else {
+    /*
+     * Otherwise we calculate two alternate destinations.
+     *
+     * If we intersected with a zero length line, then we just go ahead in our 
+     * original direction, otherwise we follow the intersecting line.
+     *
+     */
+    destOne = touchPoint;
+    destTwo = touchPoint;
+    distanceLeft = DISTANCE(line->p1, line->p2) - DISTANCE(&touchPoint, line->p1);
+    if (zero_intersection) {
+      destOne.x += adjustment_xunit * distanceLeft;
+      destOne.y += adjustment_yunit * distanceLeft;
+      destTwo.x += adjustment_xunit * distanceLeft;
+      destTwo.y += adjustment_yunit * distanceLeft;
+    } else {
+      destOne.x += adjustment_xunit * distanceLeft;
+      destOne.y += adjustment_yunit * distanceLeft;
+      destTwo.x -= adjustment_xunit * distanceLeft;
+      destTwo.y -= adjustment_yunit * distanceLeft;
+    }
+    /*
+     * And select the one with the least error.
+     */
+    errorOne = DISTANCE(line->p2, &destOne);
+    errorTwo = DISTANCE(line->p2, &destTwo);
+    if (DBL_EQL(errorOne, errorTwo)) {
+      line->p2->x = touchPoint.x;
+      line->p2->y = touchPoint.y;
+      /*
+       * We are done here, no more sliding.
+       */
+      return TRUE;
+    } else {
+      if (errorOne < errorTwo) {
+	line->p2->x = destOne.x;
+	line->p2->y = destOne.y;
+      } else if (errorOne > errorTwo) {
+	line->p2->x = destTwo.x;
+	line->p2->y = destTwo.y;
+      }
+      line->p1->x = touchPoint.x;
+      line->p1->y = touchPoint.y;
+      /*
+       * We are possibly not done, return FALSE.
+       */
+      return FALSE;
+    }
+  }
+}
 
+guint
+line_hash(gconstpointer l) {
+  Line *line = (Line *) l;
+  return (guint) (line->p1->x + line->p1->y + line->p2->x + line->p2->y);
+}
+
+void
+init_line_o() {
+}

data/ext/line.h

@@ -19,7 +19,7 @@
 #ifndef LINE_H
 #define LINE_H
 
-#include "common.h"
+#include <common.h>
 
 extern VALUE rb_line;
 
@@ -30,7 +30,7 @@ extern VALUE rb_line;
 #define LINE_Y(line,v) (LINE_VERTICAL((line)) ? \
 			(line)->p1->y : \
 			(line)->p1->y + ((line)->p2->y - (line)->p1->y) * ((v - (line)->p1->x) / ((line)->p2->x - (line)->p1->x)))
-#define LINE_EQUALS(l1,l2) (POINT_EQUALS((l1)->p1, (l2)->p1) && POINT_EQUALS((l1)->p2, (l2)->p2))
+#define LINE_EQUALS(l1,l2) (POINT_EQUALS(((Line *) (l1))->p1, ((Line *) (l2))->p1) && POINT_EQUALS(((Line *) (l1))->p2, ((Line *) (l2))->p2))
 /*
  * Is the point outside the rectangle described by the endpoints of the line?
  */
@@ -74,7 +74,7 @@ extern VALUE rb_line;
 #define POINT_BETWEEN_PARALLEL_LINES(l1,l2,p) ((line_side((l1),(p)) >= 0 && line_side((l2),(p)) <= 0) || \
 					       (line_side((l1),(p)) <= 0 && line_side((l2),(p)) >= 0))
 #define LINE_P(l) (!NIL_P((l)) && rb_is_a((l), rb_line))
-#define CHECK_LINE(l) if (!LINE_P((l))) rb_raise(rb_eTypeError, "Expected Grueserve::Map::Line!")
+#define CHECK_LINE(l) if (!LINE_P((l))) rb_raise(rb_eTypeError, "Expected Geo::Line!")
 #define LINE_PARALLEL(l,p) (new_line_with_coordinates((p)->x, (p)->y, (p)->x + (l)->p2->x - (l)->p1->x, (p)->y + (l)->p2->y - (l)->p1->y))
 #define LINE_BOUNDS(line,bottom_left,top_right) (bottom_left)->x = MIN(line->p1->x, line->p2->x); \
   (bottom_left)->y = MIN(line->p1->y, line->p2->y);			\
@@ -178,10 +178,25 @@ rb_line_side(VALUE self, VALUE p);
 VALUE
 rb_line_contains(VALUE self, VALUE p);
 
-gint
-line_cmp(Line *me, Line *other);
-
 VALUE
 rb_line_from_gpointer(gpointer l);
 
+void
+line_set_abs(Line *me, double new_abs);
+
+gboolean
+line_slide_point(Intersection *intersection, Line *line, gint ttl);
+
+gchar *
+line_inspect(Line *l);
+
+guint
+line_hash(gconstpointer l);
+
+gboolean
+line_equals(gconstpointer a, gconstpointer b);
+
+void
+line_free(Line *l);
+
 #endif