clipper 2.9.0

data/ext/clipper/clipper.hpp

@@ -0,0 +1,247 @@
+/*******************************************************************************
+*                                                                              *
+* Author    :  Angus Johnson                                                   *
+* Version   :  2.9                                                             *
+* Date      :  7 December 2010                                                 *
+* Copyright :  Angus Johnson                                                   *
+*                                                                              *
+* License:                                                                     *
+* Use, modification & distribution is subject to Boost Software License Ver 1. *
+* http://www.boost.org/LICENSE_1_0.txt                                         *
+*                                                                              *
+* Attributions:                                                                *
+* The code in this library is an extension of Bala Vatti's clipping algorithm: *
+* "A generic solution to polygon clipping"                                     *
+* Communications of the ACM, Vol 35, Issue 7 (July 1992) pp 56-63.             *
+* http://portal.acm.org/citation.cfm?id=129906                                 *
+*                                                                              *
+* Computer graphics and geometric modeling: implementation and algorithms      *
+* By Max K. Agoston                                                            *
+* Springer; 1 edition (January 4, 2005)                                        *
+* Pages 98 - 106.                                                              *
+* http://books.google.com/books?q=vatti+clipping+agoston                       *
+*                                                                              *
+*******************************************************************************/
+
+/*******************************************************************************
+*                                                                              *
+* This is a translation of my Delphi clipper code and is the very first stuff  *
+* I've written in C++ (or C). My apologies if the coding style is unorthodox.  *
+* Please see the accompanying Delphi Clipper library (clipper.pas) for a more  *
+* detailed explanation of the code algorithms.                                 *
+*                                                                              *
+*******************************************************************************/
+
+#pragma once
+#ifndef clipper_hpp
+#define clipper_hpp
+
+#include <vector>
+#include <string>
+
+namespace clipper {
+
+typedef enum _ClipType { ctIntersection, ctUnion, ctDifference, ctXor } TClipType;
+typedef enum _PolyType { ptSubject, ptClip } TPolyType;
+typedef enum _PolyFillType { pftEvenOdd, pftNonZero} TPolyFillType;
+
+struct TDoublePoint { double X; double Y; };
+struct TDoubleRect { double left; double top; double right; double bottom; };
+typedef std::vector< TDoublePoint > TPolygon;
+typedef std::vector< TPolygon > TPolyPolygon;
+
+TDoublePoint DoublePoint(const double &X, const double &Y);
+TPolyPolygon OffsetPolygons(const TPolyPolygon &pts, const double &delta);
+double Area(const TPolygon &poly);
+TDoubleRect GetBounds(const TPolygon &poly);
+bool IsClockwise(const TPolygon &poly);
+
+//used internally ...
+typedef enum _EdgeSide { esLeft, esRight } TEdgeSide;
+typedef enum _IntersectProtects { ipNone = 0,
+  ipLeft = 1, ipRight = 2, ipBoth = 3 } TIntersectProtects;
+typedef enum _TriState { sFalse, sTrue, sUndefined} TTriState;
+
+struct TEdge {
+  double x;
+  double y;
+  double xbot;
+  double ybot;
+  double xtop;
+  double ytop;
+  double dx;
+  double tmpX;
+  bool nextAtTop;
+  TPolyType polyType;
+  TEdgeSide side;
+  int windDelta; //1 or -1 depending on winding direction
+  int windCnt;
+  int windCnt2; //winding count of the opposite polytype
+  int outIdx;
+  TEdge *next;
+  TEdge *prev;
+  TEdge *nextInLML;
+  TEdge *nextInAEL;
+  TEdge *prevInAEL;
+  TEdge *nextInSEL;
+  TEdge *prevInSEL;
+};
+
+struct TIntersectNode {
+  TEdge *edge1;
+  TEdge *edge2;
+  TDoublePoint pt;
+  TIntersectNode *next;
+  TIntersectNode *prev;
+};
+
+struct TLocalMinima {
+  double Y;
+  TEdge *leftBound;
+  TEdge *rightBound;
+  TLocalMinima *nextLm;
+};
+
+struct TScanbeam {
+  double Y;
+  TScanbeam *nextSb;
+};
+
+struct TPolyPt {
+  TDoublePoint pt;
+  TPolyPt *next;
+  TPolyPt *prev;
+  TTriState isHole;
+};
+
+struct TJoinRec {
+    TDoublePoint pt;
+    int idx1;
+    union {
+      int idx2;
+      TPolyPt* outPPt; //horiz joins only
+    };
+};
+
+typedef std::vector < TPolyPt * > PolyPtList;
+typedef std::vector < TJoinRec > JoinList;
+
+//ClipperBase is the ancestor to the Clipper class. It should not be
+//instantiated directly. This class simply abstracts the conversion of sets of
+//polygon coordinates into edge objects that are stored in a LocalMinima list.
+class ClipperBase
+{
+public:
+  ClipperBase();
+  virtual ~ClipperBase();
+  void AddPolygon(const TPolygon &pg, TPolyType polyType);
+  void AddPolyPolygon( const TPolyPolygon &ppg, TPolyType polyType);
+  virtual void Clear();
+  TDoubleRect GetBounds();
+protected:
+  void DisposeLocalMinimaList();
+  void InsertLocalMinima(TLocalMinima *newLm);
+  TEdge* AddBoundsToLML(TEdge *e);
+  void PopLocalMinima();
+  bool Reset();
+  TLocalMinima      *m_CurrentLM;
+private:
+  TLocalMinima      *m_localMinimaList;
+  std::vector< TEdge * >  m_edges;
+};
+
+class Clipper : public virtual ClipperBase
+{
+public:
+  Clipper();
+  ~Clipper();
+  bool Execute(TClipType clipType,
+  TPolyPolygon &solution,
+  TPolyFillType subjFillType = pftEvenOdd,
+  TPolyFillType clipFillType = pftEvenOdd);
+  //The ForceOrientation property ensures that polygons that result from a
+  //TClipper.Execute() calls will have clockwise 'outer' and counter-clockwise
+  //'inner' (or 'hole') polygons. If ForceOrientation == false, then the
+  //polygons returned in the solution will have undefined orientation.<br>
+  //Setting ForceOrientation = true results in a minor penalty (~10%) in
+  //execution speed. (Default == true) ***DEPRICATED***
+  bool ForceOrientation();
+  void ForceOrientation(bool value);
+private:
+  PolyPtList        m_PolyPts;
+  JoinList          m_Joins;
+  JoinList          m_CurrentHorizontals;
+  TClipType         m_ClipType;
+  TScanbeam        *m_Scanbeam;
+  TEdge            *m_ActiveEdges;
+  TEdge            *m_SortedEdges;
+  TIntersectNode   *m_IntersectNodes;
+  bool              m_ExecuteLocked;
+  bool              m_ForceOrientation;
+  TPolyFillType     m_ClipFillType;
+  TPolyFillType     m_SubjFillType;
+  double            m_IntersectTolerance;
+  void UpdateHoleStates();
+  void DisposeScanbeamList();
+  void SetWindingDelta(TEdge *edge);
+  void SetWindingCount(TEdge *edge);
+  bool IsNonZeroFillType(TEdge *edge);
+  bool IsNonZeroAltFillType(TEdge *edge);
+  bool InitializeScanbeam();
+  void InsertScanbeam( const double &Y);
+  double PopScanbeam();
+  void InsertLocalMinimaIntoAEL( const double &botY);
+  void InsertEdgeIntoAEL(TEdge *edge);
+  void AddEdgeToSEL(TEdge *edge);
+  void CopyAELToSEL();
+  void DeleteFromSEL(TEdge *e);
+  void DeleteFromAEL(TEdge *e);
+  void UpdateEdgeIntoAEL(TEdge *&e);
+  void SwapPositionsInSEL(TEdge *edge1, TEdge *edge2);
+  bool Process1Before2(TIntersectNode *Node1, TIntersectNode *Node2);
+  bool TestIntersections();
+  bool IsContributing(TEdge *edge);
+  bool IsTopHorz(TEdge *horzEdge, const double &XPos);
+  void SwapPositionsInAEL(TEdge *edge1, TEdge *edge2);
+  void DoMaxima(TEdge *e, const double &topY);
+  void ProcessHorizontals();
+  void ProcessHorizontal(TEdge *horzEdge);
+  void AddLocalMaxPoly(TEdge *e1, TEdge *e2, const TDoublePoint &pt);
+  void AddLocalMinPoly(TEdge *e1, TEdge *e2, const TDoublePoint &pt);
+  void AppendPolygon(TEdge *e1, TEdge *e2);
+  void DoEdge1(TEdge *edge1, TEdge *edge2, const TDoublePoint &pt);
+  void DoEdge2(TEdge *edge1, TEdge *edge2, const TDoublePoint &pt);
+  void DoBothEdges(TEdge *edge1, TEdge *edge2, const TDoublePoint &pt);
+  void IntersectEdges(TEdge *e1, TEdge *e2,
+     const TDoublePoint &pt, TIntersectProtects protects);
+  TPolyPt* AddPolyPt(TEdge *e, const TDoublePoint &pt);
+  TPolyPt* InsertPolyPtBetween(const TDoublePoint &pt, TPolyPt* pp1, TPolyPt* pp2);
+  void DisposeAllPolyPts();
+  void ProcessIntersections( const double &topY);
+  void AddIntersectNode(TEdge *e1, TEdge *e2, const TDoublePoint &pt);
+  void BuildIntersectList(const double &topY);
+  void ProcessIntersectList();
+  TEdge *BubbleSwap(TEdge *edge);
+  void ProcessEdgesAtTopOfScanbeam( const double &topY);
+  void BuildResult(TPolyPolygon &polypoly);
+  void DisposeIntersectNodes();
+  void FixupJoins(int oldIdx, int newIdx);
+  void MergePolysWithCommonEdges();
+  void FixupJoins(int joinIdx);
+};
+
+class clipperException : public std::exception
+{
+  public:
+    clipperException(const char* description = "Clipper exception")
+      throw(): std::exception(), m_description (description) {}
+    virtual ~clipperException() throw() {}
+    virtual const char* what() const throw() {return m_description.c_str();}
+  private:
+    std::string m_description;
+};
+
+} //clipper namespace
+#endif //clipper_hpp
+
+

data/ext/clipper/extconf.rb

@@ -0,0 +1,6 @@
+require 'mkmf'
+
+CONFIG['LDSHARED'] = "$(CXX) -shared"
+
+dir_config('clipper')
+create_makefile('clipper')

data/ext/clipper/rbclipper.cpp

@@ -0,0 +1,268 @@
+/* 
+ * Clipper Ruby Bindings
+ * Copyright 2010 Mike Owens <http://mike.filespanker.com/>
+ *
+ * Released under the same terms as Clipper.
+ *
+ */
+
+#include <clipper.hpp>
+#include <ruby.h>
+
+#ifndef DBL2NUM
+# define DBL2NUM rb_float_new
+#endif
+
+using namespace std;
+using namespace clipper;
+
+static ID id_even_odd;
+static ID id_non_zero;
+
+static inline Clipper*
+XCLIPPER(VALUE x)
+{
+  Clipper* clipper;
+  Data_Get_Struct(x, Clipper, clipper);
+  return clipper;
+}
+
+static inline TPolyFillType
+sym_to_filltype(VALUE sym)
+{
+  ID inp = rb_to_id(sym);
+
+  if (inp == id_even_odd) {
+    return pftEvenOdd;
+  } else if (inp == id_non_zero) {
+    return pftNonZero;
+  }
+
+  rb_raise(rb_eArgError, "%s", "Expected :even_odd or :non_zero");
+}
+
+extern "C" {
+
+static void
+ary_to_polygon(VALUE ary, TPolygon* poly)
+{
+  const char* earg =
+    "Polygons have format: [[p0_x, p0_y], [p1_x, p1_y], ...]";
+
+  Check_Type(ary, T_ARRAY);
+
+  for(long i = 0; i != RARRAY_LEN(ary); i++) {
+    VALUE sub = rb_ary_entry(ary, i);
+    Check_Type(sub, T_ARRAY);
+
+    if(RARRAY_LEN(sub) != 2) {
+      rb_raise(rb_eArgError, "%s", earg);
+    }
+
+    VALUE px = rb_ary_entry(sub, 0);
+    VALUE py = rb_ary_entry(sub, 1);
+    poly->push_back(DoublePoint(NUM2DBL(px), NUM2DBL(py)));
+  }
+}
+
+static void
+ary_to_polypolygon(VALUE ary, TPolyPolygon* polypoly)
+{
+  Check_Type(ary, T_ARRAY);
+  for(long i = 0; i != RARRAY_LEN(ary); i++) {
+    TPolygon p;
+    VALUE sub = rb_ary_entry(ary, i);
+    Check_Type(sub, T_ARRAY);
+    ary_to_polygon(sub, &p);
+    polypoly->push_back(p);
+  }
+}
+
+static void
+rbclipper_free(void* ptr)
+{
+  delete (Clipper*) ptr;
+}
+
+static VALUE
+rbclipper_new(VALUE klass)
+{
+  Clipper* ptr = new Clipper;
+  VALUE r = Data_Wrap_Struct(klass, 0, rbclipper_free, ptr);
+  rb_obj_call_init(r, 0, 0);
+  return r;
+}
+
+static VALUE
+rbclipper_add_polygon_internal(VALUE self, VALUE polygon,
+                               TPolyType polytype)
+{
+  TPolygon tmp;
+  ary_to_polygon(polygon, &tmp);
+  XCLIPPER(self)->AddPolygon(tmp, polytype);
+  return Qnil;
+}
+
+static VALUE
+rbclipper_add_subject_polygon(VALUE self, VALUE polygon)
+{
+  return rbclipper_add_polygon_internal(self, polygon, ptSubject);
+}
+
+static VALUE
+rbclipper_add_clip_polygon(VALUE self, VALUE polygon)
+{
+  return rbclipper_add_polygon_internal(self, polygon, ptClip);
+}
+
+
+static VALUE
+rbclipper_add_poly_polygon_internal(VALUE self, VALUE polypoly,
+                                    TPolyType polytype)
+{
+  TPolyPolygon tmp;
+  ary_to_polypolygon(polypoly, &tmp);
+  XCLIPPER(self)->AddPolyPolygon(tmp, polytype);
+  return Qnil;
+}
+
+static VALUE
+rbclipper_add_subject_poly_polygon(VALUE self, VALUE polygon)
+{
+  return rbclipper_add_poly_polygon_internal(self, polygon, ptSubject);
+}
+
+static VALUE
+rbclipper_add_clip_poly_polygon(VALUE self, VALUE polygon)
+{
+  return rbclipper_add_poly_polygon_internal(self, polygon, ptClip);
+}
+
+
+static VALUE
+rbclipper_clear(VALUE self)
+{
+  XCLIPPER(self)->Clear();
+  return Qnil;
+}
+
+static VALUE
+rbclipper_force_orientation(VALUE self)
+{
+  return XCLIPPER(self)->ForceOrientation() ? Qtrue : Qfalse;
+}
+
+static VALUE
+rbclipper_force_orientation_eq(VALUE self, VALUE b)
+{
+  XCLIPPER(self)->ForceOrientation(b == Qtrue);
+  return b;
+}
+
+static VALUE
+rbclipper_execute_internal(VALUE self, TClipType cliptype,
+                           VALUE subjfill, VALUE clipfill)
+{
+  if (NIL_P(subjfill))
+    subjfill = ID2SYM(id_even_odd);
+
+  if (NIL_P(clipfill))
+    clipfill = ID2SYM(id_even_odd);
+
+  TPolyPolygon solution;
+  XCLIPPER(self)->Execute((TClipType) cliptype,
+                          solution,
+                          sym_to_filltype(subjfill),
+                          sym_to_filltype(clipfill));
+  VALUE r = rb_ary_new();
+  for(TPolyPolygon::iterator i = solution.begin();
+                             i != solution.end();
+                             ++i) {
+    VALUE sub = rb_ary_new();
+    for(TPolygon::iterator p = i->begin(); p != i->end(); ++p) {
+      rb_ary_push(sub, rb_ary_new3(2, DBL2NUM(p->X), DBL2NUM(p->Y)));
+    }
+    rb_ary_push(r, sub);
+  }
+
+  return r;
+}
+
+static VALUE
+rbclipper_intersection(int argc, VALUE* argv, VALUE self)
+{
+  VALUE subjfill, clipfill;
+  rb_scan_args(argc, argv, "02", &subjfill, &clipfill);
+  return rbclipper_execute_internal(self, ctIntersection, subjfill, clipfill);
+}
+
+static VALUE
+rbclipper_union(int argc, VALUE* argv, VALUE self)
+{
+  VALUE subjfill, clipfill;
+
+  rb_scan_args(argc, argv, "02", &subjfill, &clipfill);
+
+  return rbclipper_execute_internal(self, ctUnion, subjfill, clipfill);
+}
+
+
+static VALUE
+rbclipper_difference(int argc, VALUE* argv, VALUE self)
+{
+  VALUE subjfill, clipfill;
+  rb_scan_args(argc, argv, "02", &subjfill, &clipfill);
+  return rbclipper_execute_internal(self, ctDifference, subjfill, clipfill);
+}
+
+
+static VALUE
+rbclipper_xor(int argc, VALUE* argv, VALUE self)
+{
+  VALUE subjfill, clipfill;
+  rb_scan_args(argc, argv, "02", &subjfill, &clipfill);
+  return rbclipper_execute_internal(self, ctXor, subjfill, clipfill);
+}
+
+
+typedef VALUE (*ruby_method)(...);
+
+void Init_clipper() {
+  id_even_odd = rb_intern("even_odd");
+  id_non_zero = rb_intern("non_zero");
+
+  VALUE mod   = rb_define_module("Clipper");
+
+  VALUE k = rb_define_class_under(mod, "Clipper", rb_cObject);
+  rb_define_singleton_method(k, "new",
+                             (ruby_method) rbclipper_new, 0);
+
+  rb_define_method(k, "add_subject_polygon",
+                   (ruby_method) rbclipper_add_subject_polygon, 1);
+  rb_define_method(k, "add_clip_polygon",
+                   (ruby_method) rbclipper_add_clip_polygon, 1);
+
+  rb_define_method(k, "add_subject_poly_polygon",
+                   (ruby_method) rbclipper_add_subject_poly_polygon, 1);
+  rb_define_method(k, "add_clip_poly_polygon",
+                   (ruby_method) rbclipper_add_clip_poly_polygon, 1);
+
+
+  rb_define_method(k, "clear!",
+                   (ruby_method) rbclipper_clear, 0);
+  rb_define_method(k, "force_orientation",
+                   (ruby_method) rbclipper_force_orientation, 0);
+  rb_define_method(k, "force_orientation=",
+                   (ruby_method) rbclipper_force_orientation_eq, 1);
+
+  rb_define_method(k, "intersection",
+                   (ruby_method) rbclipper_intersection, -1);
+  rb_define_method(k, "union",
+                   (ruby_method) rbclipper_union, -1);
+  rb_define_method(k, "difference",
+                   (ruby_method) rbclipper_difference, -1);
+  rb_define_method(k, "xor",
+                   (ruby_method) rbclipper_xor, -1);
+}
+
+} /* extern "C" */