summaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/CGAL_Nef_polyhedron.h2
-rw-r--r--src/CGAL_Nef_polyhedron_DxfData.cc25
-rw-r--r--src/PolySetCGALEvaluator.cc203
-rw-r--r--src/PolySetCGALEvaluator.h2
-rw-r--r--src/context.cc6
-rw-r--r--src/csgtermnormalizer.cc43
-rw-r--r--src/csgtermnormalizer.h11
-rw-r--r--src/dxfdata.cc25
-rw-r--r--src/dxfdata.h1
-rw-r--r--src/dxftess-cgal.cc1
-rw-r--r--src/glview.cc4
-rw-r--r--src/lexer.l4
-rw-r--r--src/mainwin.cc10
-rw-r--r--src/openscad.cc1
-rw-r--r--src/parsersettings.cc31
-rw-r--r--src/parsersettings.h4
-rw-r--r--src/polyset.cc30
-rw-r--r--src/polyset.h2
18 files changed, 283 insertions, 122 deletions
diff --git a/src/CGAL_Nef_polyhedron.h b/src/CGAL_Nef_polyhedron.h
index f93905f..0b0784e 100644
--- a/src/CGAL_Nef_polyhedron.h
+++ b/src/CGAL_Nef_polyhedron.h
@@ -3,6 +3,7 @@
#include "cgalfwd.h"
#include "memory.h"
+#include <string>
class CGAL_Nef_polyhedron
{
@@ -18,6 +19,7 @@ public:
CGAL_Nef_polyhedron &operator-=(const CGAL_Nef_polyhedron &other);
CGAL_Nef_polyhedron &minkowski(const CGAL_Nef_polyhedron &other);
CGAL_Nef_polyhedron copy() const;
+ std::string dump_p2() const;
int weight() const;
class PolySet *convertToPolyset();
class DxfData *convertToDxfData() const;
diff --git a/src/CGAL_Nef_polyhedron_DxfData.cc b/src/CGAL_Nef_polyhedron_DxfData.cc
index fe58636..411a340 100644
--- a/src/CGAL_Nef_polyhedron_DxfData.cc
+++ b/src/CGAL_Nef_polyhedron_DxfData.cc
@@ -77,4 +77,29 @@ DxfData *CGAL_Nef_polyhedron::convertToDxfData() const
return dxfdata;
}
+// dump the 2 dimensional nef_poly.
+std::string CGAL_Nef_polyhedron::dump_p2() const
+{
+ std::stringstream out;
+ CGAL_Nef_polyhedron2::Explorer explorer = this->p2->explorer();
+ CGAL_Nef_polyhedron2::Explorer::Vertex_const_iterator i;
+ out << "CGAL_Nef_polyhedron::p2 Vertices";
+ for (i = explorer.vertices_begin(); i != explorer.vertices_end(); ++i) {
+ if ( explorer.is_standard( i ) ) {
+ CGAL_Nef_polyhedron2::Explorer::Point point = explorer.point( i );
+ out << "\n Point x y: "
+ << CGAL::to_double(point.x()) << " "
+ << CGAL::to_double(point.y());
+ } else {
+ CGAL_Nef_polyhedron2::Explorer::Ray ray = explorer.ray( i );
+ CGAL_Nef_polyhedron2::Explorer::Point point = ray.point( 0 );
+ out << "\n Ray x y dx dy: "
+ << CGAL::to_double(point.x()) << " " << CGAL::to_double(point.y()) << " "
+ << CGAL::to_double(ray.direction().dx()) << " " << CGAL::to_double(ray.direction().dy());
+ }
+ }
+ out << "\nCGAL_Nef_polyhedron::p2 Vertices end";
+ return out.str();
+}
+
#endif // ENABLE_CGAL
diff --git a/src/PolySetCGALEvaluator.cc b/src/PolySetCGALEvaluator.cc
index 1cc6b16..3b272d2 100644
--- a/src/PolySetCGALEvaluator.cc
+++ b/src/PolySetCGALEvaluator.cc
@@ -16,9 +16,88 @@
#include "openscad.h" // get_fragments_from_r()
#include <boost/foreach.hpp>
+/*
+
+This Visitor is used in the 'cut' process. Essentially, one or more of
+our 3d nef polyhedrons have been 'cut' by the xy-plane, forming a number
+of polygons that are essentially 'flat'. This Visitor object, when
+called repeatedly, collects those flat polygons together and forms a new
+2d nef polyhedron out of them. It keeps track of the 'holes' so that
+in the final resulting polygon, they are preserved properly.
+
+The output polygon is stored in the output_nefpoly2d variable.
+
+For more information on 3d + 2d nef polyhedrons, facets, halffacets,
+facet cycles, etc, please see these websites:
+
+http://www.cgal.org/Manual/latest/doc_html/cgal_manual/Nef_3/Chapter_main.html
+http://www.cgal.org/Manual/latest/doc_html/cgal_manual/Nef_3_ref/Class_Nef_polyhedron_3-Traits---Halffacet.html
+
+The halffacet iteration 'circulator' code is based on OGL_helper.h
+
+Why do we throw out all 'down' half-facets? Imagine a triangle in 3d
+space - it has one 'half face' for one 'side' and another 'half face' for the
+other 'side'. If we iterated over both half-faces we would get the same vertex
+coordinates twice. Instead, we only need one side, in our case, we
+chose the 'up' side.
+*/
+class NefShellVisitor_for_cut {
+public:
+ std::stringstream out;
+ CGAL_Nef_polyhedron2::Boundary boundary;
+ shared_ptr<CGAL_Nef_polyhedron2> tmpnef2d;
+ shared_ptr<CGAL_Nef_polyhedron2> output_nefpoly2d;
+ CGAL::Direction_3<CGAL_Kernel3> up;
+ bool debug;
+ NefShellVisitor_for_cut(bool debug=false)
+ {
+ output_nefpoly2d.reset( new CGAL_Nef_polyhedron2() );
+ boundary = CGAL_Nef_polyhedron2::INCLUDED;
+ up = CGAL::Direction_3<CGAL_Kernel3>(0,0,1);
+ this->debug = debug;
+ }
+ std::string dump()
+ {
+ return out.str();
+ }
+ void visit( CGAL_Nef_polyhedron3::Vertex_const_handle ) {}
+ void visit( CGAL_Nef_polyhedron3::Halfedge_const_handle ) {}
+ void visit( CGAL_Nef_polyhedron3::SHalfedge_const_handle ) {}
+ void visit( CGAL_Nef_polyhedron3::SHalfloop_const_handle ) {}
+ void visit( CGAL_Nef_polyhedron3::SFace_const_handle ) {}
+ void visit( CGAL_Nef_polyhedron3::Halffacet_const_handle hfacet ) {
+ if ( hfacet->plane().orthogonal_direction() != this->up ) {
+ if (debug) out << "down facing half-facet. skipping\n";
+ return;
+ }
+
+ int numcontours = 0;
+ CGAL_Nef_polyhedron3::Halffacet_cycle_const_iterator i;
+ CGAL_forall_facet_cycles_of( i, hfacet ) {
+ CGAL_Nef_polyhedron3::SHalfedge_around_facet_const_circulator c1(i), c2(c1);
+ std::list<CGAL_Nef_polyhedron2::Point> contour;
+ CGAL_For_all( c1, c2 ) {
+ CGAL_Nef_polyhedron3::Point_3 point3d = c1->source()->source()->point();
+ CGAL_Nef_polyhedron2::Point point2d( point3d.x(), point3d.y() );
+ contour.push_back( point2d );
+ }
+ tmpnef2d.reset( new CGAL_Nef_polyhedron2( contour.begin(), contour.end(), boundary ) );
+ if ( numcontours == 0 ) {
+ if (debug) out << " contour is a body. make union(). " << contour.size() << " points.\n" ;
+ *output_nefpoly2d += *tmpnef2d;
+ } else {
+ if (debug) out << " contour is a hole. make intersection(). " << contour.size() << " points.\n";
+ *output_nefpoly2d *= *tmpnef2d;
+ }
+ numcontours++;
+ } // next facet cycle (i.e. next contour)
+ } // visit()
+};
+
PolySetCGALEvaluator::PolySetCGALEvaluator(CGALEvaluator &cgalevaluator)
: PolySetEvaluator(cgalevaluator.getTree()), cgalevaluator(cgalevaluator)
{
+ this->debug = false;
}
PolySet *PolySetCGALEvaluator::evaluatePolySet(const ProjectionNode &node)
@@ -34,80 +113,46 @@ PolySet *PolySetCGALEvaluator::evaluatePolySet(const ProjectionNode &node)
}
}
if (sum.empty()) return NULL;
+ if (!sum.p3->is_simple()) {
+ if (!node.cut_mode) {
+ PRINT("WARNING: Body of projection(cut = false) isn't valid 2-manifold! Modify your design..");
+ return new PolySet();
+ }
+ }
- PolySet *ps = new PolySet();
- ps->convexity = node.convexity;
- ps->is2d = true;
+ CGAL_Nef_polyhedron nef_poly;
- // In cut mode, the model is intersected by a large but very thin box living on the
- // XY plane.
if (node.cut_mode)
{
- PolySet cube;
- double infval = 1e8, eps = 0.1;
- double x1 = -infval, x2 = +infval, y1 = -infval, y2 = +infval, z1 = 0, z2 = eps;
-
- cube.append_poly(); // top
- cube.append_vertex(x1, y1, z2);
- cube.append_vertex(x2, y1, z2);
- cube.append_vertex(x2, y2, z2);
- cube.append_vertex(x1, y2, z2);
-
- cube.append_poly(); // bottom
- cube.append_vertex(x1, y2, z1);
- cube.append_vertex(x2, y2, z1);
- cube.append_vertex(x2, y1, z1);
- cube.append_vertex(x1, y1, z1);
-
- cube.append_poly(); // side1
- cube.append_vertex(x1, y1, z1);
- cube.append_vertex(x2, y1, z1);
- cube.append_vertex(x2, y1, z2);
- cube.append_vertex(x1, y1, z2);
-
- cube.append_poly(); // side2
- cube.append_vertex(x2, y1, z1);
- cube.append_vertex(x2, y2, z1);
- cube.append_vertex(x2, y2, z2);
- cube.append_vertex(x2, y1, z2);
-
- cube.append_poly(); // side3
- cube.append_vertex(x2, y2, z1);
- cube.append_vertex(x1, y2, z1);
- cube.append_vertex(x1, y2, z2);
- cube.append_vertex(x2, y2, z2);
-
- cube.append_poly(); // side4
- cube.append_vertex(x1, y2, z1);
- cube.append_vertex(x1, y1, z1);
- cube.append_vertex(x1, y1, z2);
- cube.append_vertex(x1, y2, z2);
- CGAL_Nef_polyhedron Ncube = this->cgalevaluator.evaluateCGALMesh(cube);
-
- sum *= Ncube;
-
- // FIXME: Instead of intersecting with a thin volume, we could intersect
- // with a plane. This feels like a better solution. However, as the result
- // of such an intersection isn't simple, we cannot convert the resulting
- // Nef polyhedron to a Polyhedron using convertToPolyset() and we need
- // another way of extracting the result. kintel 20120203.
-// *sum.p3 = sum.p3->intersection(CGAL_Nef_polyhedron3::Plane_3(0, 0, 1, 0),
-// CGAL_Nef_polyhedron3::PLANE_ONLY);
-
-
- if (!sum.p3->is_simple()) {
- PRINT("WARNING: Body of projection(cut = true) isn't valid 2-manifold! Modify your design..");
- goto cant_project_non_simple_polyhedron;
+ // intersect 'sum' with the x-y plane
+ CGAL_Nef_polyhedron3::Plane_3 xy_plane = CGAL_Nef_polyhedron3::Plane_3( 0,0,1,0 );
+ *sum.p3 = sum.p3->intersection( xy_plane, CGAL_Nef_polyhedron3::PLANE_ONLY);
+
+ // Visit each polygon in sum.p3 and union/intersect into a 2d polygon (with holes)
+ // For info on Volumes, Shells, Facets, and the 'visitor' pattern, please see
+ // http://www.cgal.org/Manual/latest/doc_html/cgal_manual/Nef_3/Chapter_main.html
+ NefShellVisitor_for_cut shell_visitor;
+ CGAL_Nef_polyhedron3::Volume_const_iterator i;
+ CGAL_Nef_polyhedron3::Shell_entry_const_iterator j;
+ CGAL_Nef_polyhedron3::SFace_const_handle sface_handle;
+ for ( i = sum.p3->volumes_begin(); i != sum.p3->volumes_end(); ++i ) {
+ for ( j = i->shells_begin(); j != i->shells_end(); ++j ) {
+ sface_handle = CGAL_Nef_polyhedron3::SFace_const_handle( j );
+ sum.p3->visit_shell_objects( sface_handle , shell_visitor );
+ }
}
+ if (debug) std::cout << "shell visitor\n" << shell_visitor.dump() << "\nshell visitor end\n";
- PolySet *ps3 = sum.convertToPolyset();
- if (!ps3) return NULL;
+ nef_poly.p2 = shell_visitor.output_nefpoly2d;
+ nef_poly.dim = 2;
+ if (debug) std::cout << "--\n" << nef_poly.dump_p2() << "\n";
// Extract polygons in the XY plane, ignoring all other polygons
- // FIXME: If the polyhedron is really thin, there might be unwanted polygons
- // in the XY plane, causing the resulting 2D polygon to be self-intersection
- // and cause a crash in CGALEvaluator::PolyReducer. The right solution is to
- // filter these polygons here. kintel 20120203.
+ // FIXME: If the polyhedron is really thin, there might be unwanted polygons
+ // in the XY plane, causing the resulting 2D polygon to be self-intersection
+ // and cause a crash in CGALEvaluator::PolyReducer. The right solution is to
+ // filter these polygons here. kintel 20120203.
+ /*
Grid2d<unsigned int> conversion_grid(GRID_COARSE);
for (size_t i = 0; i < ps3->polygons.size(); i++) {
for (size_t j = 0; j < ps3->polygons[i].size(); j++) {
@@ -129,19 +174,13 @@ PolySet *PolySetCGALEvaluator::evaluatePolySet(const ProjectionNode &node)
}
next_ps3_polygon_cut_mode:;
}
- delete ps3;
+ */
}
// In projection mode all the triangles are projected manually into the XY plane
else
{
- if (!sum.p3->is_simple()) {
- PRINT("WARNING: Body of projection(cut = false) isn't valid 2-manifold! Modify your design..");
- goto cant_project_non_simple_polyhedron;
- }
-
PolySet *ps3 = sum.convertToPolyset();
if (!ps3) return NULL;
- CGAL_Nef_polyhedron np;
for (size_t i = 0; i < ps3->polygons.size(); i++)
{
int min_x_p = -1;
@@ -180,22 +219,22 @@ PolySet *PolySetCGALEvaluator::evaluatePolySet(const ProjectionNode &node)
plist.push_back(p);
}
// FIXME: Should the CGAL_Nef_polyhedron2 be cached?
- if (np.empty()) {
- np.dim = 2;
- np.p2.reset(new CGAL_Nef_polyhedron2(plist.begin(), plist.end(), CGAL_Nef_polyhedron2::INCLUDED));
+ if (nef_poly.empty()) {
+ nef_poly.dim = 2;
+ nef_poly.p2.reset(new CGAL_Nef_polyhedron2(plist.begin(), plist.end(), CGAL_Nef_polyhedron2::INCLUDED));
}
else {
- (*np.p2) += CGAL_Nef_polyhedron2(plist.begin(), plist.end(), CGAL_Nef_polyhedron2::INCLUDED);
+ (*nef_poly.p2) += CGAL_Nef_polyhedron2(plist.begin(), plist.end(), CGAL_Nef_polyhedron2::INCLUDED);
}
}
delete ps3;
- DxfData *dxf = np.convertToDxfData();
- dxf_tesselate(ps, *dxf, 0, true, false, 0);
- dxf_border_to_ps(ps, *dxf);
- delete dxf;
}
-cant_project_non_simple_polyhedron:
+ PolySet *ps = nef_poly.convertToPolyset();
+ assert( ps != NULL );
+ ps->convexity = node.convexity;
+ if (debug) std::cout << "--\n" << ps->dump() << "\n";
+
return ps;
}
diff --git a/src/PolySetCGALEvaluator.h b/src/PolySetCGALEvaluator.h
index dddcfc5..00e79f1 100644
--- a/src/PolySetCGALEvaluator.h
+++ b/src/PolySetCGALEvaluator.h
@@ -17,7 +17,7 @@ public:
virtual PolySet *evaluatePolySet(const RotateExtrudeNode &node);
virtual PolySet *evaluatePolySet(const CgaladvNode &node);
virtual PolySet *evaluatePolySet(const RenderNode &node);
-
+ bool debug;
protected:
PolySet *extrudeDxfData(const LinearExtrudeNode &node, class DxfData &dxf);
PolySet *rotateDxfData(const RotateExtrudeNode &node, class DxfData &dxf);
diff --git a/src/context.cc b/src/context.cc
index f96a45b..f71d2ac 100644
--- a/src/context.cc
+++ b/src/context.cc
@@ -32,7 +32,7 @@
#include "printutils.h"
#include <boost/foreach.hpp>
#include <boost/filesystem.hpp>
-using namespace boost::filesystem;
+namespace fs = boost::filesystem;
#include "boosty.h"
std::vector<const Context*> Context::ctx_stack;
@@ -179,8 +179,8 @@ AbstractNode *Context::evaluate_module(const ModuleInstantiation &inst) const
*/
std::string Context::getAbsolutePath(const std::string &filename) const
{
- if (!filename.empty()) {
- return boosty::absolute(path(this->document_path) / filename).string();
+ if (!filename.empty() && !boosty::is_absolute(fs::path(filename))) {
+ return boosty::absolute(fs::path(this->document_path) / filename).string();
}
else {
return filename;
diff --git a/src/csgtermnormalizer.cc b/src/csgtermnormalizer.cc
index 6600758..e2474e9 100644
--- a/src/csgtermnormalizer.cc
+++ b/src/csgtermnormalizer.cc
@@ -5,25 +5,29 @@
/*!
NB! for e.g. empty intersections, this can normalize a tree to nothing and return NULL.
*/
-shared_ptr<CSGTerm> CSGTermNormalizer::normalize(const shared_ptr<CSGTerm> &root,
- size_t limit)
+shared_ptr<CSGTerm> CSGTermNormalizer::normalize(const shared_ptr<CSGTerm> &root)
{
shared_ptr<CSGTerm> temp = root;
while (1) {
+ this->rootnode = temp;
+ this->nodecount = 0;
shared_ptr<CSGTerm> n = normalizePass(temp);
if (!n) return n; // If normalized to nothing
if (temp == n) break;
temp = n;
- unsigned int num = count(temp);
-#ifdef DEBUG
- PRINTB("Normalize count: %d\n", num);
-#endif
- if (num > limit) {
- PRINTB("WARNING: Normalized tree is growing past %d elements. Aborting normalization.\n", limit);
- return root;
+ if (this->nodecount > this->limit) {
+ PRINTB("WARNING: Normalized tree is growing past %d elements. Aborting normalization.\n", this->limit);
+ // Clean up any partially evaluated terms
+ shared_ptr<CSGTerm> newroot = root, tmproot;
+ while (newroot != tmproot) {
+ tmproot = newroot;
+ newroot = collapse_null_terms(tmproot);
+ }
+ return newroot;
}
}
+ this->rootnode.reset();
return temp;
}
@@ -42,7 +46,11 @@ shared_ptr<CSGTerm> CSGTermNormalizer::normalizePass(shared_ptr<CSGTerm> term)
}
do {
- while (term && normalize_tail(term)) { }
+ while (term && match_and_replace(term)) { }
+ this->nodecount++;
+ if (nodecount > this->limit) {
+ return shared_ptr<CSGTerm>();
+ }
if (!term || term->type == CSGTerm::TYPE_PRIMITIVE) return term;
if (term->left) term->left = normalizePass(term->left);
} while (term->type != CSGTerm::TYPE_UNION &&
@@ -51,6 +59,11 @@ shared_ptr<CSGTerm> CSGTermNormalizer::normalizePass(shared_ptr<CSGTerm> term)
term->right = normalizePass(term->right);
// FIXME: Do we need to take into account any transformation of item here?
+ return collapse_null_terms(term);
+}
+
+shared_ptr<CSGTerm> CSGTermNormalizer::collapse_null_terms(const shared_ptr<CSGTerm> &term)
+{
if (!term->right) {
if (term->type == CSGTerm::TYPE_UNION || term->type == CSGTerm::TYPE_DIFFERENCE) return term->left;
else return term->right;
@@ -59,13 +72,14 @@ shared_ptr<CSGTerm> CSGTermNormalizer::normalizePass(shared_ptr<CSGTerm> term)
if (term->type == CSGTerm::TYPE_UNION) return term->right;
else return term->left;
}
-
return term;
}
-bool CSGTermNormalizer::normalize_tail(shared_ptr<CSGTerm> &term)
+bool CSGTermNormalizer::match_and_replace(shared_ptr<CSGTerm> &term)
{
- if (term->type == CSGTerm::TYPE_UNION || term->type == CSGTerm::TYPE_PRIMITIVE) return false;
+ if (term->type == CSGTerm::TYPE_UNION || term->type == CSGTerm::TYPE_PRIMITIVE) {
+ return false;
+ }
// Part A: The 'x . (y . z)' expressions
@@ -149,8 +163,9 @@ bool CSGTermNormalizer::normalize_tail(shared_ptr<CSGTerm> &term)
return false;
}
+// Counts all non-leaf nodes
unsigned int CSGTermNormalizer::count(const shared_ptr<CSGTerm> &term) const
{
if (!term) return 0;
- return term->type == CSGTerm::TYPE_PRIMITIVE ? 1 : 0 + count(term->left) + count(term->right);
+ return term->type == CSGTerm::TYPE_PRIMITIVE ? 0 : 1 + count(term->left) + count(term->right);
}
diff --git a/src/csgtermnormalizer.h b/src/csgtermnormalizer.h
index e5a2eca..c331f11 100644
--- a/src/csgtermnormalizer.h
+++ b/src/csgtermnormalizer.h
@@ -6,15 +6,20 @@
class CSGTermNormalizer
{
public:
- CSGTermNormalizer() {}
+ CSGTermNormalizer(size_t limit) : limit(limit) {}
~CSGTermNormalizer() {}
- shared_ptr<class CSGTerm> normalize(const shared_ptr<CSGTerm> &term, size_t limit);
+ shared_ptr<class CSGTerm> normalize(const shared_ptr<CSGTerm> &term);
private:
shared_ptr<CSGTerm> normalizePass(shared_ptr<CSGTerm> term) ;
- bool normalize_tail(shared_ptr<CSGTerm> &term);
+ bool match_and_replace(shared_ptr<CSGTerm> &term);
+ shared_ptr<CSGTerm> collapse_null_terms(const shared_ptr<CSGTerm> &term);
unsigned int count(const shared_ptr<CSGTerm> &term) const;
+
+ size_t limit;
+ size_t nodecount;
+ shared_ptr<class CSGTerm> rootnode;
};
#endif
diff --git a/src/dxfdata.cc b/src/dxfdata.cc
index 2b84f7e..00b246f 100644
--- a/src/dxfdata.cc
+++ b/src/dxfdata.cc
@@ -38,6 +38,7 @@
#include <boost/lexical_cast.hpp>
#include <boost/algorithm/string.hpp>
#include <algorithm>
+#include <sstream>
#include <QDir>
#include "value.h"
@@ -555,3 +556,27 @@ int DxfData::addPoint(double x, double y)
return this->points.size()-1;
}
+std::string DxfData::dump() const
+{
+ std::stringstream out;
+ out << "DxfData"
+ << "\n num points: " << points.size()
+ << "\n num paths: " << paths.size()
+ << "\n num dims: " << dims.size()
+ << "\n points: ";
+ for ( size_t k = 0 ; k < points.size() ; k++ ) {
+ out << "\n x y: " << points[k].transpose();
+ }
+ out << "\n paths: ";
+ for ( size_t i = 0; i < paths.size(); i++ ) {
+ out << "\n path:" << i
+ << "\n is_closed: " << paths[i].is_closed
+ << "\n is_inner: " << paths[i].is_inner ;
+ DxfData::Path path = paths[i];
+ for ( size_t j = 0; j < path.indices.size(); j++ ) {
+ out << "\n index[" << j << "]==" << path.indices[j];
+ }
+ }
+ out << "\nDxfData end";
+ return out.str();
+}
diff --git a/src/dxfdata.h b/src/dxfdata.h
index 7eea6a9..64853dc 100644
--- a/src/dxfdata.h
+++ b/src/dxfdata.h
@@ -44,6 +44,7 @@ public:
int addPoint(double x, double y);
void fixup_path_direction();
+ std::string dump() const;
};
#endif
diff --git a/src/dxftess-cgal.cc b/src/dxftess-cgal.cc
index d1e79ad..f221e3a 100644
--- a/src/dxftess-cgal.cc
+++ b/src/dxftess-cgal.cc
@@ -131,6 +131,7 @@ void dxf_tesselate(PolySet *ps, DxfData &dxf, double rot, bool up, bool /* do_tr
// ..maybe it would be better to assert here. But this would
// break compatibility with the glu tesselator that handled such
// cases just fine.
+ PRINT( "WARNING: Duplicate vertex found during Tessellation. Render may be incorrect." );
continue;
}
diff --git a/src/glview.cc b/src/glview.cc
index aa2e746..bea5856 100644
--- a/src/glview.cc
+++ b/src/glview.cc
@@ -600,7 +600,11 @@ void GLView::mouseMoveEvent(QMouseEvent *event)
double mz = -(dy) * viewer_distance/1000;
double my = 0;
+#if (QT_VERSION < QT_VERSION_CHECK(4, 7, 0))
+ if (event->buttons() & Qt::MidButton) {
+#else
if (event->buttons() & Qt::MiddleButton) {
+#endif
my = mz;
mz = 0;
// actually lock the x-position
diff --git a/src/lexer.l b/src/lexer.l
index 188046f..f939330 100644
--- a/src/lexer.l
+++ b/src/lexer.l
@@ -118,7 +118,7 @@ use[ \t\r\n>]*"<" { BEGIN(cond_use); }
else {
usepath = sourcepath() / filename;
if (!fs::exists(usepath)) {
- usepath = boosty::absolute(fs::path(get_librarydir()) / filename);
+ usepath = locate_file(filename);
}
}
/* Only accept regular files which exists */
@@ -214,7 +214,7 @@ void includefile()
fs::path finfo = dirinfo / filename;
if (!exists(finfo)) {
- finfo = fs::path(get_librarydir()) / filepath / filename;
+ finfo = locate_file((fs::path(filepath) / filename).string());
}
filepath.clear();
diff --git a/src/mainwin.cc b/src/mainwin.cc
index 087cb30..22bc498 100644
--- a/src/mainwin.cc
+++ b/src/mainwin.cc
@@ -719,9 +719,9 @@ void MainWindow::compileCSG(bool procevents)
if (procevents)
QApplication::processEvents();
- CSGTermNormalizer normalizer;
size_t normalizelimit = 2 * Preferences::inst()->getValue("advanced/openCSGLimit").toUInt();
- this->root_norm_term = normalizer.normalize(this->root_raw_term, normalizelimit);
+ CSGTermNormalizer normalizer(normalizelimit);
+ this->root_norm_term = normalizer.normalize(this->root_raw_term);
if (this->root_norm_term) {
this->root_chain = new CSGChain();
this->root_chain->import(this->root_norm_term);
@@ -741,7 +741,7 @@ void MainWindow::compileCSG(bool procevents)
highlights_chain = new CSGChain();
for (unsigned int i = 0; i < highlight_terms.size(); i++) {
- highlight_terms[i] = normalizer.normalize(highlight_terms[i], normalizelimit);
+ highlight_terms[i] = normalizer.normalize(highlight_terms[i]);
highlights_chain->import(highlight_terms[i]);
}
}
@@ -754,7 +754,7 @@ void MainWindow::compileCSG(bool procevents)
background_chain = new CSGChain();
for (unsigned int i = 0; i < background_terms.size(); i++) {
- background_terms[i] = normalizer.normalize(background_terms[i], normalizelimit);
+ background_terms[i] = normalizer.normalize(background_terms[i]);
background_chain->import(background_terms[i]);
}
}
@@ -1359,7 +1359,7 @@ void MainWindow::actionExportSTLorOFF(bool)
}
if (!this->root_N->p3->is_simple()) {
- PRINT("Object isn't a valid 2-manifold! Modify your design..");
+ PRINT("Object isn't a valid 2-manifold! Modify your design. See http://en.wikibooks.org/wiki/OpenSCAD_User_Manual/STL_Import_and_Export");
clearCurrentOutput();
return;
}
diff --git a/src/openscad.cc b/src/openscad.cc
index 7fe054f..61ac162 100644
--- a/src/openscad.cc
+++ b/src/openscad.cc
@@ -294,6 +294,7 @@ int main(int argc, char **argv)
PRINTB("Can't open file \"%s\" for export", csg_output_file);
}
else {
+ fs::current_path(fparent); // Force exported filenames to be relative to document path
fstream << tree.getString(*root_node) << "\n";
fstream.close();
}
diff --git a/src/parsersettings.cc b/src/parsersettings.cc
index a3a02b7..53b34f4 100644
--- a/src/parsersettings.cc
+++ b/src/parsersettings.cc
@@ -1,27 +1,38 @@
#include "parsersettings.h"
#include <boost/filesystem.hpp>
+#include <boost/foreach.hpp>
+#include "boosty.h"
#include <qglobal.h> // Needed for Q_ defines - move the offending code somewhere else
-using namespace boost::filesystem;
-#include "boosty.h"
+namespace fs = boost::filesystem;
-std::string librarydir;
+std::vector<std::string> librarypath;
-void set_librarydir(const std::string &libdir)
+void add_librarydir(const std::string &libdir)
{
- librarydir = libdir;
+ librarypath.push_back(libdir);
}
-const std::string &get_librarydir()
+/*!
+ Searces for the given file in library paths and returns the full path if found.
+ Returns an empty path if file cannot be found.
+*/
+std::string locate_file(const std::string &filename)
{
- return librarydir;
+ BOOST_FOREACH(const std::string &dir, librarypath) {
+ fs::path usepath = fs::path(dir) / filename;
+ if (fs::exists(usepath)) return usepath.string();
+ }
+ return std::string();
}
void parser_init(const std::string &applicationpath)
{
+ // FIXME: Append paths from OPENSCADPATH before adding built-in paths
+
std::string librarydir;
- path libdir(applicationpath);
- path tmpdir;
+ fs::path libdir(applicationpath);
+ fs::path tmpdir;
#ifdef Q_WS_MAC
libdir /= "../Resources"; // Libraries can be bundled
if (!is_directory(libdir / "libraries")) libdir /= "../../..";
@@ -37,5 +48,5 @@ void parser_init(const std::string &applicationpath)
if (is_directory(tmpdir = libdir / "libraries")) {
librarydir = boosty::stringy( tmpdir );
}
- set_librarydir(librarydir);
+ if (!librarydir.empty()) add_librarydir(librarydir);
}
diff --git a/src/parsersettings.h b/src/parsersettings.h
index a5dc939..007aa9c 100644
--- a/src/parsersettings.h
+++ b/src/parsersettings.h
@@ -6,7 +6,7 @@
extern int parser_error_pos;
void parser_init(const std::string &applicationpath);
-void set_librarydir(const std::string &libdir);
-const std::string &get_librarydir();
+void add_librarydir(const std::string &libdir);
+std::string locate_file(const std::string &filename);
#endif
diff --git a/src/polyset.cc b/src/polyset.cc
index e5553aa..b412f5f 100644
--- a/src/polyset.cc
+++ b/src/polyset.cc
@@ -48,6 +48,36 @@ PolySet::~PolySet()
{
}
+std::string PolySet::dump() const
+{
+ std::stringstream out;
+ out << "PolySet:"
+ << "\n dimensions:" << std::string( this->is2d ? "2" : "3" )
+ << "\n convexity:" << this->convexity
+ << "\n num polygons: " << polygons.size()
+ << "\n num borders: " << borders.size()
+ << "\n polygons data:";
+ for (size_t i = 0; i < polygons.size(); i++) {
+ out << "\n polygon begin:";
+ const Polygon *poly = &polygons[i];
+ for (size_t j = 0; j < poly->size(); j++) {
+ Vector3d v = poly->at(j);
+ out << "\n vertex:" << v.transpose();
+ }
+ }
+ out << "\n borders data:";
+ for (size_t i = 0; i < borders.size(); i++) {
+ out << "\n border polygon begin:";
+ const Polygon *poly = &borders[i];
+ for (size_t j = 0; j < poly->size(); j++) {
+ Vector3d v = poly->at(j);
+ out << "\n vertex:" << v.transpose();
+ }
+ }
+ out << "\nPolySet end";
+ return out.str();
+}
+
void PolySet::append_poly()
{
polygons.push_back(Polygon());
diff --git a/src/polyset.h b/src/polyset.h
index 09a13cb..4ca57bf 100644
--- a/src/polyset.h
+++ b/src/polyset.h
@@ -5,6 +5,7 @@
#include "grid.h"
#include "linalg.h"
#include <vector>
+#include <string>
class PolySet
{
@@ -40,6 +41,7 @@ public:
void render_surface(csgmode_e csgmode, const Transform3d &m, GLint *shaderinfo = NULL) const;
void render_edges(csgmode_e csgmode) const;
+ std::string dump() const;
};
#endif
contact: Jan Huwald // Impressum