Refactored some non-CGAL functionality into separate functions in PolySetCGALEvaluator

11 files changed, 87 insertions, 71 deletions

diff --git a/src/CGALEvaluator.cc b/src/CGALEvaluator.cc
index c67e1f5..31e5bcf 100644
--- a/src/CGALEvaluator.cc
+++ b/src/CGALEvaluator.cc
@@ -182,7 +182,7 @@ Response CGALEvaluator::visit(State &state, const TransformNode &node)
 				
 				PolySet ps;
 				ps.is2d = true;
-				dxf_tesselate(&ps, dd, 0, true, false, 0);
+				dxf_tesselate(&ps, *dd, 0, true, false, 0);
 				
 				N = evaluateCGALMesh(ps);
 				ps.refcount = 0;
diff --git a/src/CSGTermEvaluator.cc b/src/CSGTermEvaluator.cc
index 451929c..b3cc88e 100644
--- a/src/CSGTermEvaluator.cc
+++ b/src/CSGTermEvaluator.cc
@@ -263,7 +263,7 @@ CSGTerm *AbstractNode::evaluate_csg_term_from_nef(double m[20], QVector<CSGTerm*
 		DxfData dd(N);
 		ps = new PolySet();
 		ps->is2d = true;
-		dxf_tesselate(ps, &dd, 0, true, false, 0);
+		dxf_tesselate(ps, dd, 0, true, false, 0);
 		dxf_border_to_ps(ps, &dd);
 	}
 
diff --git a/src/PolySetCGALEvaluator.cc b/src/PolySetCGALEvaluator.cc
index 7e7e528..f556bcb 100644
--- a/src/PolySetCGALEvaluator.cc
+++ b/src/PolySetCGALEvaluator.cc
@@ -148,7 +148,7 @@ PolySet *PolySetCGALEvaluator::evaluatePolySet(const ProjectionNode &node, Abstr
 			(*np.p2) += CGAL_Nef_polyhedron2(plist.begin(), plist.end(), CGAL_Nef_polyhedron2::INCLUDED);
 		}
 		DxfData *dxf = np.convertToDxfData();
-		dxf_tesselate(ps, dxf, 0, true, false, 0);
+		dxf_tesselate(ps, *dxf, 0, true, false, 0);
 		dxf_border_to_ps(ps, dxf);
 		ps3->unlink();
 		delete dxf;
@@ -160,23 +160,23 @@ cant_project_non_simple_polyhedron:
 	return ps;
 }
 
-static void add_slice(PolySet *ps, DxfData::Path *pt, double rot1, double rot2, double h1, double h2)
+static void add_slice(PolySet *ps, DxfData::Path &pt, double rot1, double rot2, double h1, double h2)
 {
-	for (int j = 1; j < pt->points.count(); j++)
+	for (int j = 1; j < pt.points.count(); j++)
 	{
 		int k = j - 1;
 
-		double jx1 = (*pt->points[j])[0] *  cos(rot1*M_PI/180) + (*pt->points[j])[1] * sin(rot1*M_PI/180);
-		double jy1 = (*pt->points[j])[0] * -sin(rot1*M_PI/180) + (*pt->points[j])[1] * cos(rot1*M_PI/180);
+		double jx1 = (*pt.points[j])[0] *  cos(rot1*M_PI/180) + (*pt.points[j])[1] * sin(rot1*M_PI/180);
+		double jy1 = (*pt.points[j])[0] * -sin(rot1*M_PI/180) + (*pt.points[j])[1] * cos(rot1*M_PI/180);
 
-		double jx2 = (*pt->points[j])[0] *  cos(rot2*M_PI/180) + (*pt->points[j])[1] * sin(rot2*M_PI/180);
-		double jy2 = (*pt->points[j])[0] * -sin(rot2*M_PI/180) + (*pt->points[j])[1] * cos(rot2*M_PI/180);
+		double jx2 = (*pt.points[j])[0] *  cos(rot2*M_PI/180) + (*pt.points[j])[1] * sin(rot2*M_PI/180);
+		double jy2 = (*pt.points[j])[0] * -sin(rot2*M_PI/180) + (*pt.points[j])[1] * cos(rot2*M_PI/180);
 
-		double kx1 = (*pt->points[k])[0] *  cos(rot1*M_PI/180) + (*pt->points[k])[1] * sin(rot1*M_PI/180);
-		double ky1 = (*pt->points[k])[0] * -sin(rot1*M_PI/180) + (*pt->points[k])[1] * cos(rot1*M_PI/180);
+		double kx1 = (*pt.points[k])[0] *  cos(rot1*M_PI/180) + (*pt.points[k])[1] * sin(rot1*M_PI/180);
+		double ky1 = (*pt.points[k])[0] * -sin(rot1*M_PI/180) + (*pt.points[k])[1] * cos(rot1*M_PI/180);
 
-		double kx2 = (*pt->points[k])[0] *  cos(rot2*M_PI/180) + (*pt->points[k])[1] * sin(rot2*M_PI/180);
-		double ky2 = (*pt->points[k])[0] * -sin(rot2*M_PI/180) + (*pt->points[k])[1] * cos(rot2*M_PI/180);
+		double kx2 = (*pt.points[k])[0] *  cos(rot2*M_PI/180) + (*pt.points[k])[1] * sin(rot2*M_PI/180);
+		double ky2 = (*pt.points[k])[0] * -sin(rot2*M_PI/180) + (*pt.points[k])[1] * cos(rot2*M_PI/180);
 
 		double dia1_len_sq = (jy1-ky2)*(jy1-ky2) + (jx1-kx2)*(jx1-kx2);
 		double dia2_len_sq = (jy2-ky1)*(jy2-ky1) + (jx2-kx1)*(jx2-kx1);
@@ -184,7 +184,7 @@ static void add_slice(PolySet *ps, DxfData::Path *pt, double rot1, double rot2,
 		if (dia1_len_sq > dia2_len_sq)
 		{
 			ps->append_poly();
-			if (pt->is_inner) {
+			if (pt.is_inner) {
 				ps->append_vertex(kx1, ky1, h1);
 				ps->append_vertex(jx1, jy1, h1);
 				ps->append_vertex(jx2, jy2, h2);
@@ -195,7 +195,7 @@ static void add_slice(PolySet *ps, DxfData::Path *pt, double rot1, double rot2,
 			}
 
 			ps->append_poly();
-			if (pt->is_inner) {
+			if (pt.is_inner) {
 				ps->append_vertex(kx2, ky2, h2);
 				ps->append_vertex(kx1, ky1, h1);
 				ps->append_vertex(jx2, jy2, h2);
@@ -208,7 +208,7 @@ static void add_slice(PolySet *ps, DxfData::Path *pt, double rot1, double rot2,
 		else
 		{
 			ps->append_poly();
-			if (pt->is_inner) {
+			if (pt.is_inner) {
 				ps->append_vertex(kx1, ky1, h1);
 				ps->append_vertex(jx1, jy1, h1);
 				ps->append_vertex(kx2, ky2, h2);
@@ -219,7 +219,7 @@ static void add_slice(PolySet *ps, DxfData::Path *pt, double rot1, double rot2,
 			}
 
 			ps->append_poly();
-			if (pt->is_inner) {
+			if (pt.is_inner) {
 				ps->append_vertex(jx2, jy2, h2);
 				ps->append_vertex(kx2, ky2, h2);
 				ps->append_vertex(jx1, jy1, h1);
@@ -232,7 +232,8 @@ static void add_slice(PolySet *ps, DxfData::Path *pt, double rot1, double rot2,
 	}
 }
 
-PolySet *PolySetCGALEvaluator::evaluatePolySet(const DxfLinearExtrudeNode &node, AbstractPolyNode::render_mode_e)
+PolySet *PolySetCGALEvaluator::evaluatePolySet(const DxfLinearExtrudeNode &node, 
+																							 AbstractPolyNode::render_mode_e)
 {
 	const string &cacheid = this->cgalevaluator.getTree().getString(node);
 	if (this->cache.contains(cacheid)) return this->cache[cacheid]->ps->link();
@@ -255,6 +256,14 @@ PolySet *PolySetCGALEvaluator::evaluatePolySet(const DxfLinearExtrudeNode &node,
 		dxf = new DxfData(node.fn, node.fs, node.fa, node.filename, node.layername, node.origin_x, node.origin_y, node.scale);
 	}
 
+	PolySet *ps = extrudeDxfData(node, *dxf);
+	this->cache.insert(cacheid, new cache_entry(ps->link()));
+	delete dxf;
+	return ps;
+}
+
+PolySet *PolySetCGALEvaluator::extrudeDxfData(const DxfLinearExtrudeNode &node, DxfData &dxf)
+{
 	PolySet *ps = new PolySet();
 	ps->convexity = node.convexity;
 
@@ -269,9 +278,9 @@ PolySet *PolySetCGALEvaluator::evaluatePolySet(const DxfLinearExtrudeNode &node,
 	}
 
 	bool first_open_path = true;
-	for (int i = 0; i < dxf->paths.count(); i++)
+	for (int i = 0; i < dxf.paths.count(); i++)
 	{
-		if (dxf->paths[i].is_closed)
+		if (dxf.paths[i].is_closed)
 			continue;
 		if (first_open_path) {
 			PRINTF("WARNING: Open paths in dxf_linear_extrude(file = \"%s\", layer = \"%s\"):",
@@ -279,10 +288,10 @@ PolySet *PolySetCGALEvaluator::evaluatePolySet(const DxfLinearExtrudeNode &node,
 			first_open_path = false;
 		}
 		PRINTF("   %9.5f %10.5f ... %10.5f %10.5f",
-					 (*dxf->paths[i].points.first())[0] / node.scale + node.origin_x,
-					 (*dxf->paths[i].points.first())[1] / node.scale + node.origin_y, 
-					 (*dxf->paths[i].points.last())[0] / node.scale + node.origin_x,
-					 (*dxf->paths[i].points.last())[1] / node.scale + node.origin_y);
+					 (*dxf.paths[i].points.first())[0] / node.scale + node.origin_x,
+					 (*dxf.paths[i].points.first())[1] / node.scale + node.origin_y, 
+					 (*dxf.paths[i].points.last())[0] / node.scale + node.origin_x,
+					 (*dxf.paths[i].points.last())[1] / node.scale + node.origin_y);
 	}
 
 
@@ -296,11 +305,11 @@ PolySet *PolySetCGALEvaluator::evaluatePolySet(const DxfLinearExtrudeNode &node,
 			double t2 = node.twist*(j+1) / node.slices;
 			double g1 = h1 + (h2-h1)*j / node.slices;
 			double g2 = h1 + (h2-h1)*(j+1) / node.slices;
-			for (int i = 0; i < dxf->paths.count(); i++)
+			for (int i = 0; i < dxf.paths.count(); i++)
 			{
-				if (!dxf->paths[i].is_closed)
+				if (!dxf.paths[i].is_closed)
 					continue;
-				add_slice(ps, &dxf->paths[i], t1, t2, g1, g2);
+				add_slice(ps, dxf.paths[i], t1, t2, g1, g2);
 			}
 		}
 	}
@@ -308,22 +317,19 @@ PolySet *PolySetCGALEvaluator::evaluatePolySet(const DxfLinearExtrudeNode &node,
 	{
 		dxf_tesselate(ps, dxf, 0, false, true, h1);
 		dxf_tesselate(ps, dxf, 0, true, true, h2);
-		for (int i = 0; i < dxf->paths.count(); i++)
+		for (int i = 0; i < dxf.paths.count(); i++)
 		{
-			if (!dxf->paths[i].is_closed)
+			if (!dxf.paths[i].is_closed)
 				continue;
-			add_slice(ps, &dxf->paths[i], 0, 0, h1, h2);
+			add_slice(ps, dxf.paths[i], 0, 0, h1, h2);
 		}
 	}
 
-	delete dxf;
-
-	this->cache.insert(cacheid, new cache_entry(ps->link()));
 	return ps;
 }
 
 PolySet *PolySetCGALEvaluator::evaluatePolySet(const DxfRotateExtrudeNode &node, 
-																						AbstractPolyNode::render_mode_e)
+																							 AbstractPolyNode::render_mode_e)
 {
 	const string &cacheid = this->cgalevaluator.getTree().getString(node);
 	if (this->cache.contains(cacheid)) return this->cache[cacheid]->ps->link();
@@ -346,14 +352,22 @@ PolySet *PolySetCGALEvaluator::evaluatePolySet(const DxfRotateExtrudeNode &node,
 		dxf = new DxfData(node.fn, node.fs, node.fa, node.filename, node.layername, node.origin_x, node.origin_y, node.scale);
 	}
 
+	PolySet *ps = rotateDxfData(node, *dxf);
+	this->cache.insert(cacheid, new cache_entry(ps->link()));
+	delete dxf;
+	return ps;
+}
+
+PolySet *PolySetCGALEvaluator::rotateDxfData(const DxfRotateExtrudeNode &node, DxfData &dxf)
+{
 	PolySet *ps = new PolySet();
 	ps->convexity = node.convexity;
 
-	for (int i = 0; i < dxf->paths.count(); i++)
+	for (int i = 0; i < dxf.paths.count(); i++)
 	{
 		double max_x = 0;
-		for (int j = 0; j < dxf->paths[i].points.count(); j++) {
-			max_x = fmax(max_x, (*dxf->paths[i].points[j])[0]);
+		for (int j = 0; j < dxf.paths[i].points.count(); j++) {
+			max_x = fmax(max_x, (*dxf.paths[i].points[j])[0]);
 		}
 
 		int fragments = get_fragments_from_r(max_x, node.fn, node.fs, node.fa);
@@ -361,29 +375,29 @@ PolySet *PolySetCGALEvaluator::evaluatePolySet(const DxfRotateExtrudeNode &node,
 		double ***points;
 		points = new double**[fragments];
 		for (int j=0; j < fragments; j++) {
-			points[j] = new double*[dxf->paths[i].points.count()];
-			for (int k=0; k < dxf->paths[i].points.count(); k++)
+			points[j] = new double*[dxf.paths[i].points.count()];
+			for (int k=0; k < dxf.paths[i].points.count(); k++)
 				points[j][k] = new double[3];
 		}
 
 		for (int j = 0; j < fragments; j++) {
 			double a = (j*2*M_PI) / fragments;
-			for (int k = 0; k < dxf->paths[i].points.count(); k++) {
-				if ((*dxf->paths[i].points[k])[0] == 0) {
+			for (int k = 0; k < dxf.paths[i].points.count(); k++) {
+				if ((*dxf.paths[i].points[k])[0] == 0) {
 					points[j][k][0] = 0;
 					points[j][k][1] = 0;
 				} else {
-					points[j][k][0] = (*dxf->paths[i].points[k])[0] * sin(a);
-					points[j][k][1] = (*dxf->paths[i].points[k])[0] * cos(a);
+					points[j][k][0] = (*dxf.paths[i].points[k])[0] * sin(a);
+					points[j][k][1] = (*dxf.paths[i].points[k])[0] * cos(a);
 				}
-				points[j][k][2] = (*dxf->paths[i].points[k])[1];
+				points[j][k][2] = (*dxf.paths[i].points[k])[1];
 			}
 		}
 
 		for (int j = 0; j < fragments; j++) {
 			int j1 = j + 1 < fragments ? j + 1 : 0;
-			for (int k = 0; k < dxf->paths[i].points.count(); k++) {
-				int k1 = k + 1 < dxf->paths[i].points.count() ? k + 1 : 0;
+			for (int k = 0; k < dxf.paths[i].points.count(); k++) {
+				int k1 = k + 1 < dxf.paths[i].points.count() ? k + 1 : 0;
 				if (points[j][k][0] != points[j1][k][0] ||
 						points[j][k][1] != points[j1][k][1] ||
 						points[j][k][2] != points[j1][k][2]) {
@@ -410,15 +424,12 @@ PolySet *PolySetCGALEvaluator::evaluatePolySet(const DxfRotateExtrudeNode &node,
 		}
 
 		for (int j=0; j < fragments; j++) {
-			for (int k=0; k < dxf->paths[i].points.count(); k++)
+			for (int k=0; k < dxf.paths[i].points.count(); k++)
 				delete[] points[j][k];
 			delete[] points[j];
 		}
 		delete[] points;
 	}
 
-	delete dxf;
-
-	this->cache.insert(cacheid, new cache_entry(ps->link()));
 	return ps;
 }
diff --git a/src/PolySetCGALEvaluator.h b/src/PolySetCGALEvaluator.h
index 5089e0e..a39e4ff 100644
--- a/src/PolySetCGALEvaluator.h
+++ b/src/PolySetCGALEvaluator.h
@@ -17,7 +17,10 @@ public:
 	virtual PolySet *evaluatePolySet(const DxfLinearExtrudeNode &node, AbstractPolyNode::render_mode_e);
 	virtual PolySet *evaluatePolySet(const DxfRotateExtrudeNode &node, AbstractPolyNode::render_mode_e);
 
-private:
+protected:
+	PolySet *extrudeDxfData(const DxfLinearExtrudeNode &node, class DxfData &dxf);
+	PolySet *rotateDxfData(const DxfRotateExtrudeNode &node, class DxfData &dxf);
+
 	CGALEvaluator &cgalevaluator;
 };
 
diff --git a/src/cgalrenderer.cc b/src/cgalrenderer.cc
index 352c03c..da5d859 100644
--- a/src/cgalrenderer.cc
+++ b/src/cgalrenderer.cc
@@ -41,7 +41,7 @@ CGALRenderer::CGALRenderer(const CGAL_Nef_polyhedron &root) : root(root)
 		this->polyhedron = NULL;
 		this->polyset = new PolySet();
 		this->polyset->is2d = true;
-		dxf_tesselate(this->polyset, dd, 0, true, false, 0);
+		dxf_tesselate(this->polyset, *dd, 0, true, false, 0);
 		delete dd;
 	}
 	else if (root.dim == 3) {
diff --git a/src/cgalrenderer.h b/src/cgalrenderer.h
index 4e8039a..5f854ea 100644
--- a/src/cgalrenderer.h
+++ b/src/cgalrenderer.h
@@ -11,7 +11,7 @@ public:
 	~CGALRenderer();
 	void draw(bool showfaces, bool showedges) const;
 
-private:
+public:
 	const CGAL_Nef_polyhedron &root;
 	class Polyhedron *polyhedron;
 	class PolySet *polyset;
diff --git a/src/dxftess-cgal.cc b/src/dxftess-cgal.cc
index 754d161..825132f 100644
--- a/src/dxftess-cgal.cc
+++ b/src/dxftess-cgal.cc
@@ -93,7 +93,7 @@ void mark_inner_outer(QList<struct triangle> &tri, Grid2d<point_info_t> &point_i
 	}
 }
 
-void dxf_tesselate(PolySet *ps, DxfData *dxf, double rot, bool up, bool /* do_triangle_splitting */, double h)
+void dxf_tesselate(PolySet *ps, DxfData &dxf, double rot, bool up, bool /* do_triangle_splitting */, double h)
 {
 	CDT cdt;
 
@@ -106,17 +106,17 @@ void dxf_tesselate(PolySet *ps, DxfData *dxf, double rot, bool up, bool /* do_tr
 	try {
 
 	// read path data and copy all relevant infos
-	for (int i = 0; i < dxf->paths.count(); i++)
+	for (int i = 0; i < dxf.paths.count(); i++)
 	{
-		if (!dxf->paths[i].is_closed)
+		if (!dxf.paths[i].is_closed)
 			continue;
 
 		Vertex_handle first, prev;
 		struct point_info_t *first_pi = NULL, *prev_pi = NULL;
-		for (int j = 1; j < dxf->paths[i].points.count(); j++)
+		for (int j = 1; j < dxf.paths[i].points.count(); j++)
 		{
-			double x = (*dxf->paths[i].points[j])[0];
-			double y = (*dxf->paths[i].points[j])[1];
+			double x = (*dxf.paths[i].points[j])[0];
+			double y = (*dxf.paths[i].points[j])[1];
 
 			if (point_info.has(x, y)) {
 				// FIXME: How can the same path set contain the same point twice?
@@ -127,7 +127,7 @@ void dxf_tesselate(PolySet *ps, DxfData *dxf, double rot, bool up, bool /* do_tr
 			}
 
 			struct point_info_t *pi = &point_info.align(x, y);
-			*pi = point_info_t(x, y, i, j, dxf->paths[i].points.count()-1);
+			*pi = point_info_t(x, y, i, j, dxf.paths[i].points.count()-1);
 
 			Vertex_handle vh = cdt.insert(CDTPoint(x, y));
 			if (first_pi == NULL) {
@@ -306,17 +306,17 @@ void dxf_tesselate(PolySet *ps, DxfData *dxf, double rot, bool up, bool /* do_tr
 		}
 
 		if (path[0] == path[1] && point[0] == 1 && point[1] == 2)
-			dxf->paths[path[0]].is_inner = up;
+			dxf.paths[path[0]].is_inner = up;
 		if (path[0] == path[1] && point[0] == 2 && point[1] == 1)
-			dxf->paths[path[0]].is_inner = !up;
+			dxf.paths[path[0]].is_inner = !up;
 		if (path[1] == path[2] && point[1] == 1 && point[2] == 2)
-			dxf->paths[path[1]].is_inner = up;
+			dxf.paths[path[1]].is_inner = up;
 		if (path[1] == path[2] && point[1] == 2 && point[2] == 1)
-			dxf->paths[path[1]].is_inner = !up;
+			dxf.paths[path[1]].is_inner = !up;
 
 		if (path[2] == path[0] && point[2] == 1 && point[0] == 2)
-			dxf->paths[path[2]].is_inner = up;
+			dxf.paths[path[2]].is_inner = up;
 		if (path[2] == path[0] && point[2] == 2 && point[0] == 1)
-			dxf->paths[path[2]].is_inner = !up;
+			dxf.paths[path[2]].is_inner = !up;
 	}
 }
diff --git a/src/dxftess.h b/src/dxftess.h
index 19fca7d..4aa47c2 100644
--- a/src/dxftess.h
+++ b/src/dxftess.h
@@ -3,7 +3,7 @@
 
 class DxfData;
 class PolySet;
-void dxf_tesselate(PolySet *ps, DxfData *dxf, double rot, bool up, bool do_triangle_splitting, double h);
+void dxf_tesselate(PolySet *ps, DxfData &dxf, double rot, bool up, bool do_triangle_splitting, double h);
 void dxf_border_to_ps(PolySet *ps, DxfData *dxf);
 
 #endif
diff --git a/src/import.cc b/src/import.cc
index 7435d4d..737ab31 100644
--- a/src/import.cc
+++ b/src/import.cc
@@ -198,7 +198,7 @@ PolySet *ImportNode::evaluate_polyset(render_mode_e, class PolySetEvaluator *) c
 	{
 		DxfData dd(this->fn, this->fs, this->fa, this->filename, this->layername, this->origin_x, this->origin_y, this->scale);
 		p->is2d = true;
-		dxf_tesselate(p, &dd, 0, true, false, 0);
+		dxf_tesselate(p, dd, 0, true, false, 0);
 		dxf_border_to_ps(p, &dd);
 	}
 
diff --git a/src/openscad.cc b/src/openscad.cc
index a13528e..5ec0659 100644
--- a/src/openscad.cc
+++ b/src/openscad.cc
@@ -33,8 +33,6 @@
 #include "export.h"
 #include "builtin.h"
 #include "nodedumper.h"
-#include "CGALEvaluator.h"
-#include "PolySetCGALEvaluator.h"
 #include "printutils.h"
 
 #include <string>
@@ -43,6 +41,8 @@
 #ifdef ENABLE_CGAL
 #include "CGAL_Nef_polyhedron.h"
 #include <CGAL/assertions_behaviour.h>
+#include "CGALEvaluator.h"
+#include "PolySetCGALEvaluator.h"
 #endif
 
 #include <QApplication>
@@ -259,10 +259,12 @@ int main(int argc, char **argv)
 	NodeCache nodecache;
 	NodeDumper dumper(nodecache);
 	Tree tree;
+#ifdef ENABLE_CGAL
 	// FIXME: enforce some maximum cache size (old version had 100K vertices as limit)
 	QHash<std::string, CGAL_Nef_polyhedron> cache;
 	CGALEvaluator cgalevaluator(cache, tree);
 	PolySetCGALEvaluator psevaluator(cgalevaluator);
+#endif
 
 	if (stl_output_file || off_output_file || dxf_output_file)
 	{
diff --git a/src/primitives.cc b/src/primitives.cc
index 4210e15..5502192 100644
--- a/src/primitives.cc
+++ b/src/primitives.cc
@@ -559,7 +559,7 @@ sphere_next_r2:
 
 		p->is2d = true;
 		p->convexity = convexity;
-		dxf_tesselate(p, &dd, 0, true, false, 0);
+		dxf_tesselate(p, dd, 0, true, false, 0);
 		dxf_border_to_ps(p, &dd);
 	}