geo 0.1.2

data/ext/intersection.h

@@ -0,0 +1,38 @@
+
+#ifndef INTERSECTION_H
+#define INTERSECTION_H
+
+#include "common.h"
+
+
+#define INTERSECTION_CLOSEST_POINT(intersection_pointer,point_pointer) ((intersection_pointer)->type == itPOINT ? \
+									(intersection_pointer)->point : \
+									(DISTANCE((intersection_pointer)->line->p1, \
+										  (point_pointer)) < DISTANCE((intersection_pointer)->line->p2, \
+													      (point_pointer)) ? \
+									 (intersection_pointer)->line->p1 : \
+									 (intersection_pointer)->line->p2))
+#define INTERSECTION_DISTANCE(intersection_pointer,point_pointer) ((intersection_pointer)->type == itPOINT ? \
+								   DISTANCE((intersection_pointer)->point, (point_pointer)) : \
+								   MIN(DISTANCE((intersection_pointer)->line->p1, (point_pointer)), \
+								       DISTANCE((intersection_pointer)->line->p2, (point_pointer))))
+
+
+void
+free_intersection(Intersection *intersection);
+
+Intersection*
+new_intersection_with_line(Line *l, Line *with);
+
+Intersection *
+new_intersection_with_point(Point *p, Line *with);
+
+VALUE
+rb_intersection(Intersection *intersection, Point *from);
+
+
+
+
+
+
+#endif

data/ext/line.c

@@ -0,0 +1,436 @@
+
+#include "common.h"
+
+VALUE rb_line;
+
+/*
+ * Dont use this on lines that have been rubified (RB_LINE),
+ * since they will be freed by ruby. Make sure that they have
+ * rubified points (RB_POINT) as well though!
+ */
+static void
+line_free(Line *l) {
+  free(l->p1);
+  free(l->p2);
+  free(l);
+}
+
+void
+line_mark(Line *line) {
+  if (line->p1 != NULL)
+    rb_gc_mark(line->p1->rbPoint);
+  if (line->p2 != NULL)
+    rb_gc_mark(line->p2->rbPoint);
+}
+
+Line*
+new_line_with_points(Point *p1, Point *p2) {
+  Line *rval = ALLOC(Line);
+  rval->p1 = p1;
+  rval->p2 = p2;
+  rval->rbLine = 0;
+  return rval;
+}
+
+Line*
+new_line_with_coordinates(gdouble x1, gdouble y1, gdouble x2, gdouble y2) {
+  Line *rval = ALLOC(Line);
+  rval->p1 = new_point(x1, y1);
+  rval->p2 = new_point(x2, y2);
+  rval->rbLine = 0;
+  return rval;
+}
+
+void
+line_destroy_notify(gpointer l) {
+  line_free((Line *) l);
+}
+
+VALUE
+rb_line_alloc(VALUE class) {
+  Line *l = ALLOC(Line);
+  l->p1 = NULL;
+  l->p2 = NULL;
+  return RB_LINE(l, class);
+}
+
+VALUE
+rb_line_initialize(int argc, VALUE *argv, VALUE self) {
+  Line *l;
+  Point *p1;
+  Point *p2;
+  if (argc == 2) {
+    CHECK_POINT(argv[0]);
+    CHECK_POINT(argv[1]);
+    POINT(argv[0], p1);
+    POINT(argv[1], p2);
+  } else if (argc == 4) {
+    CHECK_NUMERICALITY(argv[0]);
+    CHECK_NUMERICALITY(argv[1]);
+    CHECK_NUMERICALITY(argv[2]);
+    CHECK_NUMERICALITY(argv[3]);
+    p1 = ALLOC(Point);
+    p1->x = NUM2DBL(argv[0]);
+    p1->y = NUM2DBL(argv[1]);
+    p2 = ALLOC(Point);
+    p2->x = NUM2DBL(argv[2]);
+    p2->y = NUM2DBL(argv[3]);
+    RB_POINT(p1, rb_point);
+    RB_POINT(p2, rb_point);
+  } else {
+    rb_raise(rb_eTypeError, "Arguments to %s#new have to be 2 Grueserve::Map::Points or 4 numbers.", rb_obj_classname(self));
+  }
+  LINE(self, l);
+  l->p1 = p1;
+  l->p2 = p2;
+  return self;
+}
+
+VALUE
+rb_line_inspect(VALUE self) {
+  gchar rval[1024];
+  Line *l;
+  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);
+}
+
+VALUE
+rb_line_set_p1(VALUE self, VALUE new_point) {
+  Line *l;
+  Point *p;
+  CHECK_POINT(new_point);
+  LINE(self, l);
+  POINT(new_point, p);
+  l->p1 = p;
+  return new_point;
+}
+
+VALUE
+rb_line_set_p2(VALUE self, VALUE new_point) {
+  Line *l;
+  Point *p;
+  CHECK_POINT(new_point);
+  LINE(self, l);
+  POINT(new_point, p);
+  l->p2 = p;
+  return new_point;
+}
+
+VALUE
+rb_line_p1(VALUE self) {
+  Line *l;
+  LINE(self, l);
+  return l->p1->rbPoint;
+}
+
+VALUE
+rb_line_p2(VALUE self) {
+  Line *l;
+  LINE(self, l);
+  return l->p2->rbPoint;
+}
+
+/*
+ * If argument is a point:
+ * Is the point between the endpoints of the line?
+ * If argument is a line:
+ * Is any of the endpoints of the subject within the endpoints of the object?
+ */
+VALUE
+rb_line_within(VALUE self, VALUE arg) {
+  Line *l;
+  Point *p;
+  Line *other;
+  if (CLASS(arg) == rb_point) {
+    LINE(self, l);
+    POINT(arg, p);
+    if (POINT_WITHIN_LINE(l, p)) {
+      return Qtrue;
+    } else {
+      return Qfalse;
+    }
+  } else if (CLASS(arg) == rb_line) {
+    LINE(self, l);
+    LINE(arg, other);
+    if (LINE_WITHIN_LINE(l, other)) {
+      return Qtrue;
+    } else {
+      return Qfalse;
+    }
+  } else {
+    rb_raise(rb_eTypeError, "Argument to %s#within? has to be either Grueserve::Map::Line or Grueserve::Map::Point.", rb_obj_classname(self));
+  }
+}
+
+/*
+ * If argument is a point:
+ * Is the point outside the rectangle described by the endpoints of the line?
+ * If argument is a line:
+ * Is both of the subjects endpoints outside the rectangle described by the endpoints of the object?
+ */
+VALUE
+rb_line_outside(VALUE self, VALUE arg) {
+  Line *l;
+  Point *p;
+  Line *other;
+  if (CLASS(arg) == rb_point) {
+    LINE(self, l);
+    POINT(arg, p);
+    if (POINT_OUTSIDE_LINE(l, p)) {
+      return Qtrue;
+    } else {
+      return Qfalse;
+    }
+  } else if (CLASS(arg) == rb_line) {
+    LINE(self, l);
+    LINE(arg, other);
+    if (LINE_OUTSIDE_LINE(l, other)) {
+      return Qtrue;
+    } else {
+      return Qfalse;
+    }
+  } else {
+    rb_raise(rb_eTypeError, "Argument to %s#outside? has to be either Grueserve::Map::Line or Grueserve::Map::Point.", rb_obj_classname(self));
+  }
+}
+
+VALUE
+rb_line_parallel(VALUE self, VALUE p) {
+  Line *me;
+  Line *rval;
+  Point *point;
+  CHECK_POINT(p);
+  LINE(self, me);
+  POINT(p, point);
+  rval = LINE_PARALLEL(me, point);
+  RB_POINT(rval->p1, CLASS(me->p1->rbPoint));
+  RB_POINT(rval->p2, CLASS(me->p2->rbPoint));
+  return RB_LINE(rval, CLASS(self));
+}
+
+gint
+line_side(Line *me, Point *point) {
+  if (LINE_VERTICAL(me)) {
+    if (DBL_EQL(me->p1->x, point->x)) {
+      return 0;
+    } else if (DBL_EOG(me->p1->x, point->x)) {
+      return 1;
+    } else if (DBL_EOL(me->p1->x, point->x)) {
+      return -1;
+    } else {
+      rb_raise(rb_eRuntimeError, "Weird! A point should be either on, left or right of a line!");
+    }
+  } else {
+    gdouble y = LINE_Y(me, point->x);
+    if (DBL_EQL(y, point->y)) {
+      return 0;
+    } else if (DBL_EOG(y, point->y)) {
+      return -1;
+    } else if (DBL_EOL(y, point->y)) {
+      return 1;
+    } else {
+      rb_raise(rb_eRuntimeError, "Weird! A point should be either on, above or below a line!");
+    }
+  }
+}
+
+/*
+ * See http://local.wasp.uwa.edu.au/~pbourke/geometry/lineline2d/
+ */
+Intersection*
+line_intersection(Line *l1, Line *l2) {
+  if (LINE_OUTSIDE_LINE(l1, l2)) {
+    return NULL;
+  } else {
+    gdouble x4_x3 = l2->p2->x - l2->p1->x;
+    gdouble y1_y3 = l1->p1->y - l2->p1->y;
+    gdouble y4_y3 = l2->p2->y - l2->p1->y;
+    gdouble x1_x3 = l1->p1->x - l2->p1->x;
+    gdouble x2_x1 = l1->p2->x - l1->p1->x;
+    gdouble y2_y1 = l1->p2->y - l1->p1->y;
+    gdouble denominator = y4_y3 * x2_x1 - x4_x3 * y2_y1;
+    if (denominator == 0) { 
+      gdouble numerator1 = x4_x3 * y1_y3 - y4_y3 * x1_x3;
+      if (numerator1 == 0) {
+	gdouble new_x1 = MAX(MIN(l1->p1->x, l1->p2->x), MIN(l2->p1->x, l2->p2->x));
+	gdouble new_y1 = MAX(MIN(l1->p1->y, l1->p2->y), MIN(l2->p1->y, l2->p2->y));
+	gdouble new_x2 = MIN(MAX(l1->p1->x, l1->p2->x), MAX(l2->p1->x, l2->p2->x));
+	gdouble new_y2 = MIN(MAX(l1->p1->y, l1->p2->y), MAX(l2->p1->y, l2->p2->y));
+	return new_intersection_with_line(new_line_with_coordinates(new_x1, new_y1, new_x2, new_y2), l1);
+      } else {
+	return NULL;
+      }
+    } else {
+      gdouble t1 = (x4_x3 * y1_y3 - y4_y3 * x1_x3) / denominator;
+      gdouble t2 = (x2_x1 * y1_y3 - y2_y1 * x1_x3) / denominator;
+      if (t1 < 0 || t1 > 1 || t2 < 0 || t2 > 1)
+	return NULL;
+      return new_intersection_with_point(new_point(l1->p1->x + t1 * (l1->p2->x - l1->p1->x),
+						   l1->p1->y + t1 * (l1->p2->y - l1->p1->y)), l1);
+    }    
+  }
+}
+
+VALUE
+rb_line_intersection(VALUE self, VALUE other_line) {
+  Line *me;
+  Line *other;
+  CHECK_LINE(other_line);
+  LINE(self, me);
+  LINE(other_line, other);
+  return rb_intersection(line_intersection(me, other), other->p1);
+}
+
+VALUE
+rb_line_dot(VALUE self, VALUE o) {
+  Line *me;
+  Line *line;
+  CHECK_LINE(o);
+  LINE(self, me);
+  LINE(o, line);
+  return rb_float_new(LINE_DOT(line, me));
+}
+
+VALUE
+rb_line_abs(VALUE self) {
+  Line *me;
+  LINE(self, me);
+  return rb_float_new(DISTANCE(me->p1, me->p2));
+}
+
+VALUE
+rb_line_equals(VALUE self, VALUE o) {
+  if (!LINE_P(o)) {
+    return Qfalse;
+  } else {
+    Line *me;
+    Line *other;
+    LINE(self, me);
+    LINE(o, other);
+    if (LINE_EQUALS(me, other)) {
+      return Qtrue;
+    } else {
+      return Qfalse;
+    }
+  }
+}
+
+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)
+    return CMP(my_length, other_length);
+  else if ((tmp = point_cmp(me->p1, other->p1)) != 0)
+    return tmp;
+  else
+    return point_cmp(me->p2, other->p2);
+}
+
+VALUE
+rb_line_cmp(VALUE self, VALUE o) {
+  if (!LINE_P(o)) {
+    return INT2NUM(CMP(CLASS(self), CLASS(o)));
+  } else {
+    Line *me;
+    Line *other;
+    LINE(self, me);
+    LINE(o, other);
+    return INT2NUM(line_cmp(me, other));
+  }
+}
+
+VALUE
+rb_line_reverse(VALUE self) {
+  Line *me;
+  LINE(self, me);
+  return RB_LINE(new_line_with_points(me->p2, me->p1), rb_line);
+}
+
+VALUE
+rb_line_set_angle(VALUE self, VALUE new_angle) {
+  Line *me;
+  gdouble length;
+  gdouble angle;
+  CHECK_NUMERICALITY(new_angle);
+  LINE(self, me);
+  angle = NUM2DBL(new_angle);
+  length = DISTANCE(me->p1, me->p2);
+  while (angle > M_PI * 2)
+    angle -= M_PI * 2;
+  me->p2->x = me->p1->x + length * cos(angle);
+  me->p2->y = me->p1->y + length * sin(angle);
+  return rb_float_new(angle);
+}
+
+VALUE
+rb_line_angle(VALUE self) {
+  Line *me;
+  LINE(self, me);
+  ZERO_DISTANCE_CHECK(me->p1, me->p2);
+  return rb_float_new(LINE_ANGLE(me));
+}
+
+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;
+  return new_abs;
+}
+
+VALUE
+rb_line_clone(VALUE self) {
+  Line *me;
+  Line *rval;
+  LINE(self, me);
+  rval = new_line_with_coordinates(me->p1->x, me->p1->y, me->p2->x, me->p2->y);
+  RB_POINT(rval->p1, CLASS(me->p1->rbPoint));
+  RB_POINT(rval->p2, CLASS(me->p2->rbPoint));
+  return RB_LINE(rval, CLASS(self));
+}
+
+VALUE
+rb_line_side(VALUE self, VALUE p) {
+  Line *me;
+  Point *point;
+  CHECK_POINT(p);
+  LINE(self, me);
+  POINT(p, point);
+  return INT2NUM(line_side(me, point));
+}
+
+VALUE
+rb_line_contains(VALUE self, VALUE p) {
+  Line *me;
+  Point *point;
+  gint side;
+  CHECK_POINT(p);
+  LINE(self,me);
+  POINT(p, point);
+  side = line_side(me, point);
+  if (side == 0) {
+    return Qtrue;
+  } else {
+    return Qfalse;
+  }
+}
+
+VALUE
+rb_line_from_gpointer(gpointer l) {
+  return ( (Line *) l)->rbLine;
+}
+
+

data/ext/line.h

@@ -0,0 +1,170 @@
+
+#ifndef LINE_H
+#define LINE_H
+
+#include "common.h"
+
+extern VALUE rb_line;
+
+#define RB_LINE(line_pointer,klass) ((line_pointer)->rbLine = Data_Wrap_Struct(klass, line_mark, free, (line_pointer)))
+#define LINE(rb_line,line_pointer) Data_Get_Struct((rb_line), Line, (line_pointer))
+#define LINE_ANGLE(me) (ANGLE((me)->p2->x - (me)->p1->x,(me)->p2->y - (me)->p1->y))
+#define LINE_VERTICAL(line) ((line)->p1->x == (line)->p2->x)
+#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))
+/*
+ * Is the point outside the rectangle described by the endpoints of the line?
+ */
+#define POINT_OUTSIDE_LINE(l,p) (((DBL_GT((p)->x, (l)->p1->x) && DBL_GT((p)->x, (l)->p2->x)) || \
+				  (DBL_LT((p)->x, (l)->p1->x) && DBL_LT((p)->x, (l)->p2->x))) && \
+				 ((DBL_GT((p)->y, (l)->p1->y) && DBL_GT((p)->y, (l)->p2->y)) || \
+				  (DBL_LT((p)->y, (l)->p1->y) && DBL_LT((p)->y, (l)->p2->y))))
+
+#define POINT_RIGHT_OF_LINE(l,p) (DBL_GT((p)->x, (l)->p1->x) && DBL_GT((p)->x, (l)->p2->x))
+#define POINT_LEFT_OF_LINE(l,p) (DBL_LT((p)->x, (l)->p1->x) && DBL_LT((p)->x, (l)->p2->x))
+#define POINT_ABOVE_LINE(l,p) (DBL_LT((p)->y, (l)->p1->y) && DBL_LT((p)->y, (l)->p2->y))
+#define POINT_BELOW_LINE(l,p) (DBL_GT((p)->y, (l)->p1->y) && DBL_GT((p)->y, (l)->p2->y))
+#define LINE_RIGHT_OF_LINE(subject,object) (POINT_RIGHT_OF_LINE((object), (subject)->p1) && POINT_RIGHT_OF_LINE((object), (subject)->p2))
+#define LINE_LEFT_OF_LINE(subject,object) (POINT_LEFT_OF_LINE((object), (subject)->p1) && POINT_LEFT_OF_LINE((object), (subject)->p2))
+#define LINE_ABOVE_LINE(subject,object) (POINT_ABOVE_LINE((object), (subject)->p1) && POINT_ABOVE_LINE((object), (subject)->p2))
+#define LINE_BELOW_LINE(subject,object) (POINT_BELOW_LINE((object), (subject)->p1) && POINT_BELOW_LINE((object), (subject)->p2))
+/*
+ * Is both of the subjects endpoints outside the rectangle described by the endpoints of the object?
+ */
+#define LINE_OUTSIDE_LINE(subject,object) (LINE_RIGHT_OF_LINE((subject), (object)) || \
+					   LINE_LEFT_OF_LINE((subject), (object)) || \
+					   LINE_ABOVE_LINE((subject), (object)) || \
+					   LINE_BELOW_LINE((subject), (object)))
+
+/*
+ * Is the point between the endpoints of the line?
+ */
+#define POINT_WITHIN_LINE(line_pointer,point_pointer) (DBL_EOG((point_pointer)->x, MIN((line_pointer)->p1->x, (line_pointer)->p2->x)) && \
+						       DBL_EOL((point_pointer)->x, MAX((line_pointer)->p1->x, (line_pointer)->p2->x)) && \
+						       DBL_EOG((point_pointer)->y, MIN((line_pointer)->p1->y, (line_pointer)->p2->y)) && \
+						       DBL_EOL((point_pointer)->y, MAX((line_pointer)->p1->y, (line_pointer)->p2->y)))
+
+#define POINT_ON_LINE(line_pointer,point_pointer) (DBL_EQL((point_pointer)->y, LINE_Y((line_pointer), (point_pointer)->x)) && \
+						   POINT_WITHIN_LINE((line_pointer), (point_pointer))
+/*
+ * Is any of the endpoints of the subject within the endpoints of the object?
+ */
+#define LINE_WITHIN_LINE(subject,object) (POINT_WITHIN_LINE((subject), (object)->p1) || \
+					  POINT_WITHIN_LINE((subject), (object)->p2))
+#define LINE_DOT(l1,l2) ((((l1)->p2->x - (l1)->p1->x) * ((l2)->p2->x - (l2)->p1->x)) + (((l1)->p2->y - (l1)->p1->y) * ((l2)->p2->y - (l2)->p1->y)))
+#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 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);			\
+  (top_right)->x = MAX(line->p1->x, line->p2->x);			\
+  (top_right)->y = MAX(line->p1->y, line->p2->y)
+
+void
+line_mark(Line *line);
+
+Line*
+new_line_with_points(Point *p1, Point *p2);
+
+Line*
+new_line_with_coordinates(gdouble x1, gdouble y1, gdouble x2, gdouble y2);
+
+void
+line_destroy_notify(gpointer l);
+
+VALUE
+rb_line_alloc(VALUE class);
+
+VALUE
+rb_line_initialize(int argc, VALUE *argv, VALUE self);
+
+VALUE
+rb_line_inspect(VALUE self);
+
+VALUE
+rb_line_set_p1(VALUE self, VALUE new_point);
+
+VALUE
+rb_line_set_p2(VALUE self, VALUE new_point);
+
+VALUE
+rb_line_p1(VALUE self);
+
+VALUE
+rb_line_p2(VALUE self);
+
+/*
+ * If argument is a point:
+ * Is the point between the endpoints of the line?
+ * If argument is a line:
+ * Is any of the endpoints of the subject within the endpoints of the object?
+ */
+VALUE
+rb_line_within(VALUE self, VALUE arg);
+
+/*
+ * If argument is a point:
+ * Is the point outside the rectangle described by the endpoints of the line?
+ * If argument is a line:
+ * Is both of the subjects endpoints outside the rectangle described by the endpoints of the object?
+ */
+VALUE
+rb_line_outside(VALUE self, VALUE arg);
+
+
+VALUE
+rb_line_parallel(VALUE self, VALUE p);
+
+gint
+line_side(Line *me, Point *point);
+
+Intersection*
+line_intersection(Line *l1, Line *l2);
+
+VALUE
+rb_line_intersection(VALUE self, VALUE other_line);
+
+VALUE
+rb_line_dot(VALUE self, VALUE o);
+
+VALUE
+rb_line_abs(VALUE self);
+
+VALUE
+rb_line_equals(VALUE self, VALUE o);
+
+VALUE
+rb_line_cmp(VALUE self, VALUE o);
+
+VALUE
+rb_line_reverse(VALUE self);
+
+VALUE
+rb_line_set_angle(VALUE self, VALUE new_angle);
+
+VALUE
+rb_line_angle(VALUE self);
+
+VALUE
+rb_line_set_abs(VALUE self, VALUE new_abs);
+
+VALUE
+rb_line_clone(VALUE self);
+
+VALUE
+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);
+
+#endif