rays 0.1.46 → 0.1.47

data/src/polygon.cpp

@@ -4,7 +4,7 @@
 #include <math.h>
 #include <assert.h>
 #include <utility>
-#include <poly2tri.h>
+#include <earcut.hpp>
 #include <Splines.h>
 #include <xot/util.h>
 #include "rays/color.h"
@@ -17,21 +17,170 @@
 namespace clip = ClipperLib;
 
 
+namespace mapbox
+{
+
+	namespace util
+	{
+
+		template<>
+		struct nth<0, Rays::Point>
+		{
+			inline static auto get (const Rays::Point& p)
+			{
+				return p.x;
+			}
+		};
+
+		template<>
+		struct nth<1, Rays::Point>
+		{
+			inline static auto get (const Rays::Point& p)
+			{
+				return p.y;
+			}
+		};
+
+	}// util
+
+}// mapbox
+
+
 namespace Rays
 {
 
 
-	static inline p2t::Point
-	to_poly2tri (const Point& point)
+	class Triangulator
 	{
-		return p2t::Point(point.x, point.y);
-	}
 
-	static inline Point
-	from_poly2tri (const p2t::Point& point)
-	{
-		return Point(point.x, point.y);
-	}
+		public:
+
+			Triangulator (size_t npoints)
+			{
+				points.reserve(npoints);
+			}
+
+			size_t begin (bool hole = false)
+			{
+				segments.emplace_back(points.size(), 0, hole);
+				return segments.back().begin;
+			}
+
+			void end (size_t n)
+			{
+				if (segments.empty())
+					invalid_state_error(__FILE__, __LINE__);
+
+				auto& seg = segments.back();
+				if (n != seg.begin)
+					argument_error(__FILE__, __LINE__);
+
+				seg.end = points.size();
+
+				if (seg.empty()) segments.pop_back();
+			}
+
+			void append (const Point& point)
+			{
+				points.emplace_back(point);
+			}
+
+			void triangulate ()
+			{
+				if (segments.empty()) return;
+
+				PolylineList polylines;
+				size_t index_offset = 0;
+				for (const auto& seg : segments)
+				{
+					Polyline polyline(&points[0] + seg.begin, seg.end - seg.begin);
+					if (!seg.hole)
+					{
+						triangulate(polylines, index_offset);
+						polylines.clear();
+						index_offset = seg.begin;
+					}
+					polylines.emplace_back(polyline);
+				}
+				triangulate(polylines, index_offset);
+
+				segments.clear();
+				segments.shrink_to_fit();
+			}
+
+			bool get_triangles (Polygon::TrianglePointList* triangles) const
+			{
+				if (indices.empty()) return false;
+
+				triangles->reserve(triangles->size() + indices.size());
+				for (const auto& index : indices)
+					triangles->emplace_back(points[index]);
+				return true;
+			}
+
+		private:
+
+			struct Segment
+			{
+
+				size_t begin, end;
+
+				bool hole;
+
+				Segment (size_t begin, size_t end, bool hole = false)
+				:	begin(begin), end(end), hole(hole)
+				{
+				}
+
+				bool empty () const
+				{
+					return begin == end;
+				}
+
+			};// Segment
+
+			class Polyline
+			{
+
+				const Point* points;
+
+				size_t size_;
+
+				public:
+
+					typedef Point value_type;
+
+					Polyline (const Point* points, size_t size)
+					:	points(points), size_(size)
+					{
+					}
+
+					size_t size () const {return size_;}
+
+					bool empty () const {return size_ == 0;}
+
+					const Point& operator [] (size_t i) const {return points[i];}
+
+			};// Polyline
+
+			typedef std::vector<Polyline> PolylineList;
+
+			std::vector<Segment> segments;
+
+			std::vector<Point> points;
+
+			std::vector<uint32_t> indices;
+
+			void triangulate (const PolylineList& polylines, size_t index_offset)
+			{
+				if (polylines.empty()) return;
+
+				auto result = mapbox::earcut<uint32_t>(polylines);
+				for (const auto& index : result)
+					indices.emplace_back(index_offset + index);
+			}
+
+	};// Triangulator
 
 
 	struct Polygon::Data
@@ -39,16 +188,40 @@ namespace Rays
 
 		LineList lines;
 
+		mutable std::unique_ptr<Bounds> pbounds;
+
+		mutable std::unique_ptr<Triangulator> ptriangulator;
+
 		virtual ~Data ()
 		{
 		}
 
+		const Bounds& bounds () const
+		{
+			if (!pbounds)
+			{
+				if (lines.empty())
+					pbounds.reset(new Bounds(-1, -1, -1));
+				else
+				{
+					pbounds.reset(new Bounds(lines[0][0], 0));
+					for (const auto& line : lines)
+					{
+						for (const auto& point : line)
+							*pbounds |= point;
+					}
+				}
+			}
+			return *pbounds;
+		}
+
 		void append (const Polyline& polyline, bool hole = false)
 		{
 			if (polyline.empty())
 				return;
 
-			lines.emplace_back(Line(polyline, hole));
+			lines.emplace_back(polyline, hole);
+			pbounds.reset();
 		}
 
 		void append (const Line& line)
@@ -57,48 +230,30 @@ namespace Rays
 				return;
 
 			lines.emplace_back(line);
+			pbounds.reset();
 		}
 
 		bool triangulate (TrianglePointList* triangles) const
 		{
 			assert(triangles);
 
-			triangles->clear();
-
-			if (!can_triangulate())
-				return false;
-
-			size_t npoint = count_points();
-			if (npoint <= 0)
-				return true;
-
-			std::unique_ptr<p2t::CDT> cdt;
-			std::vector<p2t::Point> points;
-			std::vector<p2t::Point*> pointers;
-
-			points.reserve(npoint);
-			for (const auto& line : lines)
+			if (!ptriangulator)
 			{
-				pointers.clear();
-				pointers.reserve(line.size());
-				for (const auto& point : line)
-				{
-					points.emplace_back(to_poly2tri(point));
-					pointers.emplace_back(&points.back());
-				}
+				ptriangulator.reset(new Triangulator(count_points_for_triangulation()));
+				auto& t = *ptriangulator;
 
-				if (!line.hole())
+				for (const auto& line : lines)
 				{
-					if (cdt) triangulate(triangles, cdt.get());
-					cdt.reset(new p2t::CDT(pointers));
+					size_t n = t.begin(line.hole());
+					for (const auto& point : line)
+						t.append(point);
+					t.end(n);
 				}
-				else if (cdt)
-					cdt->AddHole(pointers);
+				t.triangulate();
 			}
 
-			if (cdt) triangulate(triangles, cdt.get());
-
-			return true;
+			triangles->clear();
+			return ptriangulator->get_triangles(triangles);
 		}
 
 		virtual void fill (Painter* painter, const Color& color) const = 0;
@@ -110,47 +265,35 @@ namespace Rays
 
 			coord stroke_width = painter->stroke_width();
 			if (stroke_width > 0)
-				stroke_with_width(polygon, painter, color, stroke_width);
+			{
+				stroke_with_width(
+					polygon, painter, color, stroke_width, painter->stroke_outset());
+			}
 			else
 				stroke_without_width(painter, color);
 		}
 
 		private:
 
-			bool can_triangulate () const
+			size_t count_points_for_triangulation () const
 			{
+				size_t count = 0;
 				for (const auto& line : lines)
 				{
-					if (line.loop() && !line.hole() && !line.empty())
-						return true;
+					if (can_triangulate(line))
+						count += line.size();
 				}
-				return false;
-			}
-
-			size_t count_points () const
-			{
-				size_t count = 0;
-				for (const auto& line : lines)
-					count += line.size();
 				return count;
 			}
 
-			void triangulate (TrianglePointList* triangles, p2t::CDT* cdt) const
+			bool can_triangulate (const Line& line) const
 			{
-				assert(triangles && cdt);
-
-				cdt->Triangulate();
-
-				for (auto* triangle : cdt->GetTriangles())
-				{
-					for (int i = 0; i < 3; ++i)
-						triangles->emplace_back(from_poly2tri(*triangle->GetPoint(i)));
-				}
+				return (line.fill() || line.hole()) && line.size() >= 3;
 			}
 
 			void stroke_with_width (
 				const Polygon& polygon, Painter* painter,
-				const Color& color, coord stroke_width) const
+				const Color& color, coord stroke_width, float stroke_outset) const
 			{
 				assert(painter && color && stroke_width > 0);
 
@@ -163,30 +306,45 @@ namespace Rays
 				bool has_loop = false;
 				for (const auto& polyline : polygon)
 				{
-					if (!polyline || polyline.empty())
-						continue;
-
 					if (polyline.loop())
 					{
 						has_loop = true;
 						continue;
 					}
+					stroke_polyline(polyline, painter, color, stroke_width, cap, join, ml);
+				}
 
-					Polygon stroke;
-					if (!polyline.expand(&stroke, stroke_width / 2, cap, join, ml))
-						continue;
+				if (!has_loop) return;
 
-					Polygon_fill(stroke, painter, color);
-				}
+				coord inset = (-0.5 + stroke_outset) * stroke_width;
+				Polygon outline;
+				if (inset == 0)
+					outline = polygon;
+				else if (!polygon.expand(&outline, inset, cap, join, ml))
+					return;
 
-				if (has_loop)
+				for (const auto& polyline : outline)
 				{
-					Polygon hole;
-					if (polygon.expand(&hole, -stroke_width, cap, join, ml))
-						Polygon_fill(polygon - hole, painter, color);
+					if (polyline.loop())
+						stroke_polyline(polyline, painter, color, stroke_width, cap, join, ml);
 				}
 			}
 
+			void stroke_polyline (
+				const Polyline& polyline, Painter* painter,
+				const Color& color, coord stroke_width,
+				CapType cap, JoinType join, coord miter_limit) const
+			{
+				assert(stroke_width > 0);
+
+				if (!polyline || polyline.empty())
+					return;
+
+				Polygon stroke;
+				if (polyline.expand(&stroke, stroke_width / 2, cap, join, miter_limit))
+					Polygon_fill(stroke, painter, color);
+			}
+
 			void stroke_without_width (Painter* painter, const Color& color) const
 			{
 				assert(painter && color);
@@ -746,7 +904,7 @@ namespace Rays
 
 				if (!has_hole)
 				{
-					points.emplace_back(Point(x + width / 2, y + height / 2));
+					points.emplace_back(x + width / 2, y + height / 2);
 					mode = GL_TRIANGLE_FAN;
 				}
 
@@ -788,6 +946,130 @@ namespace Rays
 	};// EllipseData
 
 
+	static const char*
+	get_draw_mode_name (DrawMode mode)
+	{
+		switch (mode)
+		{
+			case DRAW_POINTS:         return "DRAW_POINTS";
+			case DRAW_LINES:          return "DRAW_LINES";
+			case DRAW_LINE_STRIP:     return "DRAW_LINE_STRIP";
+			case DRAW_TRIANGLES:      return "DRAW_TRIANGLES";
+			case DRAW_TRIANGLE_STRIP: return "DRAW_TRIANGLE_STRIP";
+			case DRAW_TRIANGLE_FAN:   return "DRAW_TRIANGLE_FAN";
+			case DRAW_QUADS:          return "DRAW_QUADS";
+			case DRAW_QUAD_STRIP:     return "DRAW_QUAD_STRIP";
+			case DRAW_POLYGON:        return "DRAW_POLYGON";
+			default: argument_error(__FILE__, __LINE__, "unknown draw mode");
+		}
+	}
+
+	static void
+	create_polygon (Polygon* polygon, const Point* points, size_t size, bool loop)
+	{
+		polygon->self->append(Polyline(points, size, loop, true));
+	}
+
+	static void
+	create_points (Polygon* polygon, const Point* points, size_t size)
+	{
+		for (size_t i = 0; i < size; ++i)
+			polygon->self->append(Polyline(&points[i], 1, false, false));
+	}
+
+	static void
+	create_lines (Polygon* polygon, const Point* points, size_t size)
+	{
+		for (size_t i = 0; i + 1 < size; i += 2)
+			polygon->self->append(Polyline(&points[i], 2, false, false));
+	}
+
+	static void
+	create_line_strip (
+		Polygon* polygon, const Point* points, size_t size, bool loop)
+	{
+		if (!loop || size < 3)
+			polygon->self->append(Polyline(points, size, loop, false));
+		else
+		{
+			std::vector<Point> array;
+			array.reserve(size + 1);
+			array.insert(array.begin(), points, points + size);
+			array.emplace_back(points[0]);
+			polygon->self->append(Polyline(&array[0], array.size(), true, false));
+		}
+	}
+
+	static void
+	create_triangles (
+		Polygon* polygon, const Point* points, size_t size, bool loop)
+	{
+		for (size_t i = 0; i + 2 < size; i += 3)
+			polygon->self->append(Polyline(&points[i], 3, loop, true));
+	}
+
+	static void
+	create_triangle_strip (Polygon* polygon, const Point* points, size_t size)
+	{
+		if (size < 3) return;
+
+		size_t     last = size - 1;
+		size_t  in_last = last % 2 == 0 ? last - 1 : last;
+		size_t out_last = last % 2 == 0 ? last     : last - 1;
+
+		std::vector<Point> array;
+		array.emplace_back(points[0]);
+		for (size_t i = 1; i <= in_last; i += 2)
+			array.emplace_back(points[i]);
+		for (size_t i = out_last; i >= 2; i -= 2)
+			array.emplace_back(points[i]);
+
+		polygon->self->append(Polyline(&array[0], array.size(), true));
+		if (size >= 4)
+			polygon->self->append(Polyline(&points[1], size - 2));
+	}
+
+	static void
+	create_triangle_fan (Polygon* polygon, const Point* points, size_t size)
+	{
+		create_polygon(polygon, points, size, true);
+
+		Point array[2];
+		array[0] = points[0];
+		for (size_t i = 2; i < size - 1; ++i)
+		{
+			array[1] = points[i];
+			polygon->self->append(Polyline(&array[0], 2));
+		}
+	}
+
+	static void
+	create_quads (Polygon* polygon, const Point* points, size_t size, bool loop)
+	{
+		for (size_t i = 0; i + 3 < size; i += 4)
+			polygon->self->append(Polyline(&points[i], 4, loop, true));
+	}
+
+	static void
+	create_quad_strip (Polygon* polygon, const Point* points, size_t size)
+	{
+		if (size < 4) return;
+
+		if (size % 2 != 0) --size;
+		size_t  in_last = size - 2;
+		size_t out_last = size - 1;
+
+		std::vector<Point> array;
+		for (size_t i = 0; i <= in_last; i += 2)
+			array.emplace_back(points[i]);
+		for (int i = (int) out_last; i >= 1; i -= 2)
+			array.emplace_back(points[i]);
+
+		polygon->self->append(Polyline(&array[0], array.size(), true));
+		for (size_t i = 2; i < in_last; i += 2)
+			polygon->self->append(Polyline(&points[i], 2));
+	}
+
 	Polygon
 	create_line (coord x1, coord y1, coord x2, coord y2)
 	{
@@ -1069,7 +1351,30 @@ namespace Rays
 	{
 		if (!points || size <= 0) return;
 
-		self->append(Polyline(points, size, loop));
+		create_polygon(this, points, size, loop);
+	}
+
+	Polygon::Polygon (DrawMode mode, const Point* points, size_t size, bool loop)
+	:	self(new PolygonData())
+	{
+		if (!points || size <= 0) return;
+
+		switch (mode)
+		{
+			case DRAW_POINTS:         create_points(        this, points, size);       break;
+			case DRAW_LINES:          create_lines(         this, points, size);       break;
+			case DRAW_LINE_STRIP:     create_line_strip(    this, points, size, loop); break;
+			case DRAW_TRIANGLES:      create_triangles(     this, points, size, loop); break;
+			case DRAW_TRIANGLE_STRIP: create_triangle_strip(this, points, size);       break;
+			case DRAW_TRIANGLE_FAN:   create_triangle_fan(  this, points, size);       break;
+			case DRAW_QUADS:          create_quads(         this, points, size, loop); break;
+			case DRAW_QUAD_STRIP:     create_quad_strip(    this, points, size);       break;
+			case DRAW_POLYGON:        create_polygon(       this, points, size, loop); break;
+			default:
+				argument_error(
+					__FILE__, __LINE__,
+					Xot::stringf("unknown draw mode '%s'", get_draw_mode_name(mode)));
+		}
 	}
 
 	Polygon::Polygon (const Polyline& polyline)
@@ -1107,15 +1412,7 @@ namespace Rays
 	Bounds
 	Polygon::bounds () const
 	{
-		if (empty()) return Bounds(-1, -1, -1);
-
-		Bounds b(self->lines[0][0], 0);
-		for (const auto& line : *this)
-		{
-			for (const auto& point : line)
-				b |= point;
-		}
-		return b;
+		return self->bounds();
 	}
 
 	size_t
@@ -1248,10 +1545,7 @@ namespace Rays
 
 	Polygon::Line::operator bool () const
 	{
-		if (!Super::operator bool())
-			return false;
-
-		return loop() || !hole();
+		return Super::operator bool() && (loop() || !hole());
 	}
 
 	bool

data/src/polyline.cpp

@@ -17,21 +17,24 @@ namespace Rays
 
 		PointList points;
 
-		bool loop = false;
+		bool loop = false, fill = false;
 
 		template <typename I, typename FUN>
-		void reset (I begin, I end, bool loop_, FUN to_point_fun)
+		void reset (I begin, I end, bool loop_, bool fill_, FUN to_point_fun)
 		{
-			size_t size = end - begin;
-			if (0 < size && size < 3 && loop_)
+			if (begin > end)
 				argument_error(__FILE__, __LINE__);
 
 			points.clear();
+			loop = loop_;
+			fill = fill_;
+
+			size_t size = end - begin;
+			if (size <= 0) return;
+
 			points.reserve(size);
 			for (auto it = begin; it != end; ++it)
 				points.emplace_back(to_point_fun(*it));
-
-			loop = loop_ && size > 0;
 		}
 
 	};// Polyline::Data
@@ -39,18 +42,16 @@ namespace Rays
 
 	void
 	Polyline_create (
-		Polyline* polyline, const Path& path, bool loop, bool reverse)
+		Polyline* polyline, const Path& path, bool loop, bool hole)
 	{
-		assert(polyline);
-
 		Path cleaned;
 		ClipperLib::CleanPolygon(path, cleaned);
 
-		auto to_point = [](const IntPoint& point) {return from_clipper(point);};
-		if (reverse)
-			polyline->self->reset(cleaned.rbegin(), cleaned.rend(), loop, to_point);
+		auto fun = [](const IntPoint& point) {return from_clipper(point);};
+		if (hole)
+			polyline->self->reset(cleaned.rbegin(), cleaned.rend(), loop, loop, fun);
 		else
-			polyline->self->reset(cleaned. begin(), cleaned. end(), loop, to_point);
+			polyline->self->reset(cleaned. begin(), cleaned. end(), loop, loop, fun);
 	}
 
 	template <typename I>
@@ -63,12 +64,12 @@ namespace Rays
 	}
 
 	void
-	Polyline_get_path (Path* path, const Polyline& polyline, bool reverse)
+	Polyline_get_path (Path* path, const Polyline& polyline, bool hole)
 	{
 		assert(path);
 
 		const auto& points = polyline.self->points;
-		if (reverse)
+		if (hole)
 			reset_path(path, points.rbegin(), points.rend());
 		else
 			reset_path(path, points. begin(), points. end());
@@ -81,7 +82,16 @@ namespace Rays
 
 	Polyline::Polyline (const Point* points, size_t size, bool loop)
 	{
-		self->reset(points, points + size, loop, [](const Point& p) {return p;});
+		self->reset(
+			points, points + size, loop, loop,
+			[](const Point& p) {return p;});
+	}
+
+	Polyline::Polyline (const Point* points, size_t size, bool loop, bool fill)
+	{
+		self->reset(
+			points, points + size, loop, fill,
+			[](const Point& p) {return p;});
 	}
 
 	Polyline::~Polyline ()
@@ -114,6 +124,12 @@ namespace Rays
 		return self->loop;
 	}
 
+	bool
+	Polyline::fill () const
+	{
+		return self->fill;
+	}
+
 	size_t
 	Polyline::size () const
 	{
@@ -146,8 +162,7 @@ namespace Rays
 
 	Polyline::operator bool () const
 	{
-		size_t s = size();
-		return !((s == 1 || s == 2) && self->loop);
+		return true;
 	}
 
 	bool