2011-07-31 03:58:51 +04:00
|
|
|
#include "PolySetCGALEvaluator.h"
|
2011-09-01 06:09:06 +04:00
|
|
|
#include "cgal.h"
|
2011-09-09 07:53:05 +04:00
|
|
|
#include "cgalutils.h"
|
2012-10-16 05:17:12 +04:00
|
|
|
#include <CGAL/convex_hull_3.h>
|
2012-10-24 13:14:52 +04:00
|
|
|
|
2010-03-29 05:31:47 +04:00
|
|
|
#include "polyset.h"
|
2011-07-31 03:58:51 +04:00
|
|
|
#include "CGALEvaluator.h"
|
2010-03-29 05:31:47 +04:00
|
|
|
#include "projectionnode.h"
|
2011-09-30 05:11:28 +04:00
|
|
|
#include "linearextrudenode.h"
|
|
|
|
#include "rotateextrudenode.h"
|
2011-09-06 16:57:24 +04:00
|
|
|
#include "cgaladvnode.h"
|
2011-09-06 20:31:22 +04:00
|
|
|
#include "rendernode.h"
|
2010-03-29 05:31:47 +04:00
|
|
|
#include "dxfdata.h"
|
|
|
|
#include "dxftess.h"
|
|
|
|
#include "module.h"
|
|
|
|
|
2012-10-28 21:14:34 +04:00
|
|
|
#include "svg.h"
|
2010-03-29 05:31:47 +04:00
|
|
|
#include "printutils.h"
|
|
|
|
#include "openscad.h" // get_fragments_from_r()
|
2011-09-04 22:35:23 +04:00
|
|
|
#include <boost/foreach.hpp>
|
2012-10-16 05:17:12 +04:00
|
|
|
#include <vector>
|
2010-03-29 05:31:47 +04:00
|
|
|
|
2012-10-16 05:17:12 +04:00
|
|
|
/*
|
2012-05-28 20:48:46 +04:00
|
|
|
|
2012-10-28 17:56:23 +04:00
|
|
|
ZRemover
|
|
|
|
|
2012-10-28 21:14:34 +04:00
|
|
|
This class converts one or more already 'flat' Nef3 polyhedra into a Nef2
|
2012-10-28 21:40:16 +04:00
|
|
|
polyhedron by stripping off the 'z' coordinates from the vertices. The
|
|
|
|
resulting Nef2 poly is accumulated in the 'output_nefpoly2d' member variable.
|
2012-05-28 20:48:46 +04:00
|
|
|
|
2012-10-28 21:43:53 +04:00
|
|
|
The 'z' coordinates will either be all 0s, for an xy-plane intersected Nef3,
|
|
|
|
or, they will be a mixture of -eps and +eps, for a thin-box intersected Nef3.
|
|
|
|
|
2012-10-28 21:40:16 +04:00
|
|
|
Notes on CGAL's Nef Polyhedron2:
|
2012-10-24 14:45:40 +04:00
|
|
|
|
2012-10-28 17:56:23 +04:00
|
|
|
1. The 'mark' on a 2d Nef face is important when doing unions/intersections.
|
|
|
|
If the 'mark' of a face is wrong the resulting nef2 poly will be unexpected.
|
|
|
|
2. The 'mark' can be dependent on the points fed to the Nef2 constructor.
|
|
|
|
This is why we iterate through the 3d faces using the halfedge cycle
|
|
|
|
source()->target() instead of the ordinary source()->source(). The
|
|
|
|
the latter can generate sequences of points that will fail the
|
|
|
|
the CGAL::is_simple_2() test, resulting in improperly marked nef2 polys.
|
2012-10-28 21:14:34 +04:00
|
|
|
3. 3d facets have 'two sides'. we throw out the 'down' side to prevent dups.
|
2012-10-24 13:14:52 +04:00
|
|
|
|
2012-10-28 21:40:16 +04:00
|
|
|
The class uses the 'visitor' pattern from the CGAL manual. See also
|
2012-05-28 20:48:46 +04:00
|
|
|
http://www.cgal.org/Manual/latest/doc_html/cgal_manual/Nef_3/Chapter_main.html
|
2012-10-16 05:17:12 +04:00
|
|
|
http://www.cgal.org/Manual/latest/doc_html/cgal_manual/Nef_3_ref/Class_Nef_polyhedron3.html
|
|
|
|
OGL_helper.h
|
2012-05-28 20:48:46 +04:00
|
|
|
*/
|
2012-02-11 06:15:16 +04:00
|
|
|
|
2012-10-28 17:56:23 +04:00
|
|
|
class ZRemover {
|
2012-10-23 08:44:54 +04:00
|
|
|
public:
|
2012-10-28 17:56:23 +04:00
|
|
|
logstream log;
|
2012-10-23 08:44:54 +04:00
|
|
|
CGAL_Nef_polyhedron2::Boundary boundary;
|
|
|
|
shared_ptr<CGAL_Nef_polyhedron2> tmpnef2d;
|
|
|
|
shared_ptr<CGAL_Nef_polyhedron2> output_nefpoly2d;
|
|
|
|
CGAL::Direction_3<CGAL_Kernel3> up;
|
2012-10-28 17:56:23 +04:00
|
|
|
ZRemover()
|
2012-10-23 08:44:54 +04:00
|
|
|
{
|
|
|
|
output_nefpoly2d.reset( new CGAL_Nef_polyhedron2() );
|
|
|
|
boundary = CGAL_Nef_polyhedron2::INCLUDED;
|
|
|
|
up = CGAL::Direction_3<CGAL_Kernel3>(0,0,1);
|
2012-10-28 17:56:23 +04:00
|
|
|
log = logstream(5);
|
2012-10-23 08:44:54 +04:00
|
|
|
}
|
|
|
|
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 ) {
|
2012-10-28 17:56:23 +04:00
|
|
|
log << " <!-- Halffacet visit. Mark: " << hfacet->mark() << " -->\n";
|
2012-10-23 08:44:54 +04:00
|
|
|
if ( hfacet->plane().orthogonal_direction() != this->up ) {
|
2012-10-28 17:56:23 +04:00
|
|
|
log << " <!-- down-facing half-facet. skipping -->\n";
|
|
|
|
log << " <!-- Halffacet visit end-->\n";
|
2012-10-23 08:44:54 +04:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2012-10-28 17:56:23 +04:00
|
|
|
// possible optimization - throw out facets that are 'side facets' between
|
|
|
|
// the top & bottom of the big thin box. (i.e. mixture of z=-eps and z=eps)
|
|
|
|
|
|
|
|
CGAL_Nef_polyhedron3::Halffacet_cycle_const_iterator fci;
|
2012-10-23 08:44:54 +04:00
|
|
|
int contour_counter = 0;
|
2012-10-28 17:56:23 +04:00
|
|
|
CGAL_forall_facet_cycles_of( fci, hfacet ) {
|
|
|
|
if ( fci.is_shalfedge() ) {
|
|
|
|
CGAL_Nef_polyhedron3::SHalfedge_around_facet_const_circulator c1(fci), cend(c1);
|
2012-10-24 13:14:52 +04:00
|
|
|
std::vector<CGAL_Nef_polyhedron2::Explorer::Point> contour;
|
2012-10-28 17:56:23 +04:00
|
|
|
CGAL_For_all( c1, cend ) {
|
2012-10-24 13:14:52 +04:00
|
|
|
CGAL_Nef_polyhedron3::Point_3 point3d = c1->source()->target()->point();
|
|
|
|
CGAL_Nef_polyhedron2::Explorer::Point point2d( point3d.x(), point3d.y() );
|
|
|
|
contour.push_back( point2d );
|
|
|
|
}
|
|
|
|
|
2012-10-28 21:37:27 +04:00
|
|
|
if (contour.size()==0) continue;
|
2012-10-24 13:14:52 +04:00
|
|
|
|
2012-10-28 17:56:23 +04:00
|
|
|
log << " <!-- is_simple_2:" << CGAL::is_simple_2( contour.begin(), contour.end() ) << " --> \n";
|
|
|
|
|
|
|
|
tmpnef2d.reset( new CGAL_Nef_polyhedron2( contour.begin(), contour.end(), boundary ) );
|
2012-10-24 13:14:52 +04:00
|
|
|
|
|
|
|
if ( contour_counter == 0 ) {
|
2012-10-28 17:56:23 +04:00
|
|
|
log << " <!-- contour is a body. make union(). " << contour.size() << " points. -->\n" ;
|
2012-10-24 13:14:52 +04:00
|
|
|
*(output_nefpoly2d) += *(tmpnef2d);
|
|
|
|
} else {
|
2012-10-28 17:56:23 +04:00
|
|
|
log << " <!-- contour is a hole. make intersection(). " << contour.size() << " points. -->\n";
|
2012-10-28 21:14:34 +04:00
|
|
|
*(output_nefpoly2d) *= *(tmpnef2d);
|
2012-10-24 13:14:52 +04:00
|
|
|
}
|
|
|
|
|
2012-10-28 22:01:10 +04:00
|
|
|
log << "\n<!-- ======== output tmp nef: ==== -->\n"
|
|
|
|
<< OpenSCAD::dump_svg( *tmpnef2d ) << "\n"
|
|
|
|
<< "\n<!-- ======== output accumulator: ==== -->\n"
|
|
|
|
<< OpenSCAD::dump_svg( *output_nefpoly2d ) << "\n";
|
2012-10-24 13:14:52 +04:00
|
|
|
|
|
|
|
contour_counter++;
|
2012-10-23 08:44:54 +04:00
|
|
|
} else {
|
2012-10-28 17:56:23 +04:00
|
|
|
log << " <!-- trivial facet cycle skipped -->\n";
|
2012-10-23 08:44:54 +04:00
|
|
|
}
|
|
|
|
} // next facet cycle (i.e. next contour)
|
2012-10-28 17:56:23 +04:00
|
|
|
log << " <!-- Halffacet visit end -->\n";
|
2012-10-23 08:44:54 +04:00
|
|
|
} // visit()
|
|
|
|
};
|
|
|
|
|
2011-09-09 07:53:05 +04:00
|
|
|
PolySetCGALEvaluator::PolySetCGALEvaluator(CGALEvaluator &cgalevaluator)
|
|
|
|
: PolySetEvaluator(cgalevaluator.getTree()), cgalevaluator(cgalevaluator)
|
2010-03-29 05:31:47 +04:00
|
|
|
{
|
2011-09-09 07:53:05 +04:00
|
|
|
}
|
2010-04-12 04:16:36 +04:00
|
|
|
|
2011-09-09 07:53:05 +04:00
|
|
|
PolySet *PolySetCGALEvaluator::evaluatePolySet(const ProjectionNode &node)
|
|
|
|
{
|
2012-10-28 17:56:23 +04:00
|
|
|
//openscad_loglevel = 6;
|
|
|
|
logstream log(5);
|
|
|
|
|
2011-09-06 22:37:07 +04:00
|
|
|
// Before projecting, union all children
|
|
|
|
CGAL_Nef_polyhedron sum;
|
|
|
|
BOOST_FOREACH (AbstractNode * v, node.getChildren()) {
|
2011-12-26 19:34:47 +04:00
|
|
|
if (v->modinst->isBackground()) continue;
|
2011-09-06 22:37:07 +04:00
|
|
|
CGAL_Nef_polyhedron N = this->cgalevaluator.evaluateCGALMesh(*v);
|
2011-09-07 04:33:16 +04:00
|
|
|
if (N.dim == 3) {
|
|
|
|
if (sum.empty()) sum = N.copy();
|
|
|
|
else sum += N;
|
|
|
|
}
|
2011-09-06 22:37:07 +04:00
|
|
|
}
|
2011-09-07 02:10:21 +04:00
|
|
|
if (sum.empty()) return NULL;
|
2012-05-28 20:48:46 +04:00
|
|
|
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();
|
|
|
|
}
|
|
|
|
}
|
2010-03-29 05:31:47 +04:00
|
|
|
|
2012-10-28 20:51:43 +04:00
|
|
|
//std::cout << sum.dump();
|
|
|
|
//std::cout.flush();
|
|
|
|
|
2012-05-28 20:48:46 +04:00
|
|
|
CGAL_Nef_polyhedron nef_poly;
|
2010-03-29 05:31:47 +04:00
|
|
|
|
2012-10-09 05:05:23 +04:00
|
|
|
if (node.cut_mode) {
|
|
|
|
CGAL::Failure_behaviour old_behaviour = CGAL::set_error_behaviour(CGAL::THROW_EXCEPTION);
|
|
|
|
try {
|
|
|
|
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);
|
2012-10-16 05:17:12 +04:00
|
|
|
}
|
|
|
|
catch (const CGAL::Failure_exception &e) {
|
|
|
|
PRINTB("CGAL error in projection node during plane intersection: %s", e.what());
|
|
|
|
try {
|
|
|
|
PRINT("Trying alternative intersection using very large thin box: ");
|
2012-10-28 21:14:34 +04:00
|
|
|
std::vector<CGAL_Point_3> pts;
|
2012-10-24 14:45:40 +04:00
|
|
|
// dont use z of 0. there are bugs in CGAL.
|
2012-10-28 21:43:53 +04:00
|
|
|
double inf = 1e8;
|
|
|
|
double eps = 0.001;
|
|
|
|
CGAL_Point_3 minpt( -inf, -inf, -eps );
|
|
|
|
CGAL_Point_3 maxpt( inf, inf, eps );
|
2012-10-28 21:14:34 +04:00
|
|
|
CGAL_Iso_cuboid_3 bigcuboid( minpt, maxpt );
|
|
|
|
for ( int i=0;i<8;i++ ) pts.push_back( bigcuboid.vertex(i) );
|
2012-10-16 05:17:12 +04:00
|
|
|
CGAL_Polyhedron bigbox;
|
|
|
|
CGAL::convex_hull_3( pts.begin(), pts.end(), bigbox );
|
|
|
|
CGAL_Nef_polyhedron3 nef_bigbox( bigbox );
|
|
|
|
*sum.p3 = nef_bigbox.intersection( *sum.p3 );
|
|
|
|
}
|
|
|
|
catch (const CGAL::Failure_exception &e) {
|
|
|
|
PRINTB("CGAL error in projection node during bigbox intersection: %s", e.what());
|
2012-10-29 14:46:40 +04:00
|
|
|
sum.p3->clear();
|
2012-10-16 05:17:12 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-10-29 14:46:40 +04:00
|
|
|
if ( sum.p3->is_empty() ) {
|
|
|
|
CGAL::set_error_behaviour(old_behaviour);
|
|
|
|
PRINT("WARNING: projection() failed.");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2012-10-16 05:17:12 +04:00
|
|
|
// remove z coordinates to make CGAL_Nef_polyhedron2
|
2012-10-28 20:51:43 +04:00
|
|
|
log << OpenSCAD::svg_header( 480, 100000 ) << "\n";
|
2012-10-16 05:17:12 +04:00
|
|
|
try {
|
2012-10-28 17:56:23 +04:00
|
|
|
ZRemover zremover;
|
2012-10-09 05:05:23 +04:00
|
|
|
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 ) {
|
2012-10-28 17:56:23 +04:00
|
|
|
log << "<!-- volume. mark: " << i->mark() << " -->\n";
|
2012-10-09 05:05:23 +04:00
|
|
|
for ( j = i->shells_begin(); j != i->shells_end(); ++j ) {
|
2012-10-28 17:56:23 +04:00
|
|
|
log << "<!-- shell. mark: " << i->mark() << " -->\n";
|
|
|
|
sface_handle = CGAL_Nef_polyhedron3::SFace_const_handle( j );
|
|
|
|
sum.p3->visit_shell_objects( sface_handle , zremover );
|
|
|
|
log << "<!-- shell. end. -->\n";
|
2012-10-09 05:05:23 +04:00
|
|
|
}
|
2012-10-28 17:56:23 +04:00
|
|
|
log << "<!-- volume end. -->\n";
|
2012-02-14 05:31:11 +04:00
|
|
|
}
|
2012-10-28 17:56:23 +04:00
|
|
|
nef_poly.p2 = zremover.output_nefpoly2d;
|
2012-10-09 05:05:23 +04:00
|
|
|
nef_poly.dim = 2;
|
2012-10-16 05:17:12 +04:00
|
|
|
} catch (const CGAL::Failure_exception &e) {
|
|
|
|
PRINTB("CGAL error in projection node while flattening: %s", e.what());
|
2012-02-14 05:31:11 +04:00
|
|
|
}
|
2012-10-28 22:01:10 +04:00
|
|
|
log << "</svg>\n";
|
2012-02-04 02:05:42 +04:00
|
|
|
|
2012-10-16 05:17:12 +04:00
|
|
|
CGAL::set_error_behaviour(old_behaviour);
|
|
|
|
|
2012-02-04 02:05:42 +04:00
|
|
|
// Extract polygons in the XY plane, ignoring all other polygons
|
2012-02-14 04:43:38 +04:00
|
|
|
// 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.
|
2012-02-14 05:22:11 +04:00
|
|
|
/*
|
2012-02-15 03:13:07 +04:00
|
|
|
Grid2d<unsigned int> conversion_grid(GRID_COARSE);
|
2011-08-05 04:11:20 +04:00
|
|
|
for (size_t i = 0; i < ps3->polygons.size(); i++) {
|
|
|
|
for (size_t j = 0; j < ps3->polygons[i].size(); j++) {
|
|
|
|
double x = ps3->polygons[i][j][0];
|
|
|
|
double y = ps3->polygons[i][j][1];
|
|
|
|
double z = ps3->polygons[i][j][2];
|
2010-03-29 05:31:47 +04:00
|
|
|
if (z != 0)
|
|
|
|
goto next_ps3_polygon_cut_mode;
|
|
|
|
if (conversion_grid.align(x, y) == i+1)
|
|
|
|
goto next_ps3_polygon_cut_mode;
|
|
|
|
conversion_grid.data(x, y) = i+1;
|
|
|
|
}
|
|
|
|
ps->append_poly();
|
2011-08-05 04:11:20 +04:00
|
|
|
for (size_t j = 0; j < ps3->polygons[i].size(); j++) {
|
|
|
|
double x = ps3->polygons[i][j][0];
|
|
|
|
double y = ps3->polygons[i][j][1];
|
2010-03-29 05:31:47 +04:00
|
|
|
conversion_grid.align(x, y);
|
|
|
|
ps->insert_vertex(x, y);
|
|
|
|
}
|
|
|
|
next_ps3_polygon_cut_mode:;
|
|
|
|
}
|
2012-02-14 05:22:11 +04:00
|
|
|
*/
|
2010-03-29 05:31:47 +04:00
|
|
|
}
|
2012-02-04 02:05:42 +04:00
|
|
|
// In projection mode all the triangles are projected manually into the XY plane
|
2010-03-29 05:31:47 +04:00
|
|
|
else
|
|
|
|
{
|
2011-09-06 22:37:07 +04:00
|
|
|
PolySet *ps3 = sum.convertToPolyset();
|
2012-02-03 06:19:56 +04:00
|
|
|
if (!ps3) return NULL;
|
2011-08-05 04:11:20 +04:00
|
|
|
for (size_t i = 0; i < ps3->polygons.size(); i++)
|
2010-03-29 05:31:47 +04:00
|
|
|
{
|
|
|
|
int min_x_p = -1;
|
|
|
|
double min_x_val = 0;
|
2011-08-05 04:11:20 +04:00
|
|
|
for (size_t j = 0; j < ps3->polygons[i].size(); j++) {
|
|
|
|
double x = ps3->polygons[i][j][0];
|
2010-03-29 05:31:47 +04:00
|
|
|
if (min_x_p < 0 || x < min_x_val) {
|
|
|
|
min_x_p = j;
|
|
|
|
min_x_val = x;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
int min_x_p1 = (min_x_p+1) % ps3->polygons[i].size();
|
|
|
|
int min_x_p2 = (min_x_p+ps3->polygons[i].size()-1) % ps3->polygons[i].size();
|
2011-08-05 04:11:20 +04:00
|
|
|
double ax = ps3->polygons[i][min_x_p1][0] - ps3->polygons[i][min_x_p][0];
|
|
|
|
double ay = ps3->polygons[i][min_x_p1][1] - ps3->polygons[i][min_x_p][1];
|
2010-03-29 05:31:47 +04:00
|
|
|
double at = atan2(ay, ax);
|
2011-08-05 04:11:20 +04:00
|
|
|
double bx = ps3->polygons[i][min_x_p2][0] - ps3->polygons[i][min_x_p][0];
|
|
|
|
double by = ps3->polygons[i][min_x_p2][1] - ps3->polygons[i][min_x_p][1];
|
2010-03-29 05:31:47 +04:00
|
|
|
double bt = atan2(by, bx);
|
|
|
|
|
|
|
|
double eps = 0.000001;
|
|
|
|
if (fabs(at - bt) < eps || (fabs(ax) < eps && fabs(ay) < eps) ||
|
|
|
|
(fabs(bx) < eps && fabs(by) < eps)) {
|
|
|
|
// this triangle is degenerated in projection
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
std::list<CGAL_Nef_polyhedron2::Point> plist;
|
2011-08-05 04:11:20 +04:00
|
|
|
for (size_t j = 0; j < ps3->polygons[i].size(); j++) {
|
|
|
|
double x = ps3->polygons[i][j][0];
|
|
|
|
double y = ps3->polygons[i][j][1];
|
2010-03-29 05:31:47 +04:00
|
|
|
CGAL_Nef_polyhedron2::Point p = CGAL_Nef_polyhedron2::Point(x, y);
|
|
|
|
if (at > bt)
|
|
|
|
plist.push_front(p);
|
|
|
|
else
|
|
|
|
plist.push_back(p);
|
|
|
|
}
|
2011-09-02 23:37:43 +04:00
|
|
|
// FIXME: Should the CGAL_Nef_polyhedron2 be cached?
|
2012-05-28 20:48:46 +04:00
|
|
|
if (nef_poly.empty()) {
|
|
|
|
nef_poly.dim = 2;
|
|
|
|
nef_poly.p2.reset(new CGAL_Nef_polyhedron2(plist.begin(), plist.end(), CGAL_Nef_polyhedron2::INCLUDED));
|
2011-09-02 23:37:43 +04:00
|
|
|
}
|
|
|
|
else {
|
2012-05-28 20:48:46 +04:00
|
|
|
(*nef_poly.p2) += CGAL_Nef_polyhedron2(plist.begin(), plist.end(), CGAL_Nef_polyhedron2::INCLUDED);
|
2011-09-02 23:37:43 +04:00
|
|
|
}
|
2010-03-29 05:31:47 +04:00
|
|
|
}
|
2011-09-09 07:53:05 +04:00
|
|
|
delete ps3;
|
2010-03-29 05:31:47 +04:00
|
|
|
}
|
|
|
|
|
2012-05-28 20:48:46 +04:00
|
|
|
PolySet *ps = nef_poly.convertToPolyset();
|
|
|
|
assert( ps != NULL );
|
|
|
|
ps->convexity = node.convexity;
|
2012-10-28 17:56:23 +04:00
|
|
|
logstream(9) << ps->dump() << "\n";
|
2012-05-28 20:48:46 +04:00
|
|
|
|
2010-03-29 05:31:47 +04:00
|
|
|
return ps;
|
|
|
|
}
|
|
|
|
|
2011-09-04 00:44:41 +04:00
|
|
|
static void add_slice(PolySet *ps, const DxfData &dxf, DxfData::Path &path, double rot1, double rot2, double h1, double h2)
|
2010-03-29 05:31:47 +04:00
|
|
|
{
|
2011-10-27 17:23:55 +04:00
|
|
|
bool splitfirst = sin(rot2 - rot1) >= 0.0;
|
2011-09-04 00:44:41 +04:00
|
|
|
for (size_t j = 1; j < path.indices.size(); j++)
|
2010-03-29 05:31:47 +04:00
|
|
|
{
|
|
|
|
int k = j - 1;
|
|
|
|
|
2011-09-04 00:44:41 +04:00
|
|
|
double jx1 = dxf.points[path.indices[j]][0] * cos(rot1*M_PI/180) + dxf.points[path.indices[j]][1] * sin(rot1*M_PI/180);
|
|
|
|
double jy1 = dxf.points[path.indices[j]][0] * -sin(rot1*M_PI/180) + dxf.points[path.indices[j]][1] * cos(rot1*M_PI/180);
|
2010-03-29 05:31:47 +04:00
|
|
|
|
2011-09-04 00:44:41 +04:00
|
|
|
double jx2 = dxf.points[path.indices[j]][0] * cos(rot2*M_PI/180) + dxf.points[path.indices[j]][1] * sin(rot2*M_PI/180);
|
|
|
|
double jy2 = dxf.points[path.indices[j]][0] * -sin(rot2*M_PI/180) + dxf.points[path.indices[j]][1] * cos(rot2*M_PI/180);
|
2010-03-29 05:31:47 +04:00
|
|
|
|
2011-09-04 00:44:41 +04:00
|
|
|
double kx1 = dxf.points[path.indices[k]][0] * cos(rot1*M_PI/180) + dxf.points[path.indices[k]][1] * sin(rot1*M_PI/180);
|
|
|
|
double ky1 = dxf.points[path.indices[k]][0] * -sin(rot1*M_PI/180) + dxf.points[path.indices[k]][1] * cos(rot1*M_PI/180);
|
2010-03-29 05:31:47 +04:00
|
|
|
|
2011-09-04 00:44:41 +04:00
|
|
|
double kx2 = dxf.points[path.indices[k]][0] * cos(rot2*M_PI/180) + dxf.points[path.indices[k]][1] * sin(rot2*M_PI/180);
|
|
|
|
double ky2 = dxf.points[path.indices[k]][0] * -sin(rot2*M_PI/180) + dxf.points[path.indices[k]][1] * cos(rot2*M_PI/180);
|
2010-03-29 05:31:47 +04:00
|
|
|
|
2011-10-27 17:23:55 +04:00
|
|
|
if (splitfirst)
|
2010-03-29 05:31:47 +04:00
|
|
|
{
|
|
|
|
ps->append_poly();
|
2011-09-04 00:44:41 +04:00
|
|
|
if (path.is_inner) {
|
2010-03-29 05:31:47 +04:00
|
|
|
ps->append_vertex(kx1, ky1, h1);
|
|
|
|
ps->append_vertex(jx1, jy1, h1);
|
|
|
|
ps->append_vertex(jx2, jy2, h2);
|
|
|
|
} else {
|
|
|
|
ps->insert_vertex(kx1, ky1, h1);
|
|
|
|
ps->insert_vertex(jx1, jy1, h1);
|
|
|
|
ps->insert_vertex(jx2, jy2, h2);
|
|
|
|
}
|
|
|
|
|
|
|
|
ps->append_poly();
|
2011-09-04 00:44:41 +04:00
|
|
|
if (path.is_inner) {
|
2010-03-29 05:31:47 +04:00
|
|
|
ps->append_vertex(kx2, ky2, h2);
|
|
|
|
ps->append_vertex(kx1, ky1, h1);
|
|
|
|
ps->append_vertex(jx2, jy2, h2);
|
|
|
|
} else {
|
|
|
|
ps->insert_vertex(kx2, ky2, h2);
|
|
|
|
ps->insert_vertex(kx1, ky1, h1);
|
|
|
|
ps->insert_vertex(jx2, jy2, h2);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
ps->append_poly();
|
2011-09-04 00:44:41 +04:00
|
|
|
if (path.is_inner) {
|
2010-03-29 05:31:47 +04:00
|
|
|
ps->append_vertex(kx1, ky1, h1);
|
|
|
|
ps->append_vertex(jx1, jy1, h1);
|
|
|
|
ps->append_vertex(kx2, ky2, h2);
|
|
|
|
} else {
|
|
|
|
ps->insert_vertex(kx1, ky1, h1);
|
|
|
|
ps->insert_vertex(jx1, jy1, h1);
|
|
|
|
ps->insert_vertex(kx2, ky2, h2);
|
|
|
|
}
|
|
|
|
|
|
|
|
ps->append_poly();
|
2011-09-04 00:44:41 +04:00
|
|
|
if (path.is_inner) {
|
2010-03-29 05:31:47 +04:00
|
|
|
ps->append_vertex(jx2, jy2, h2);
|
|
|
|
ps->append_vertex(kx2, ky2, h2);
|
|
|
|
ps->append_vertex(jx1, jy1, h1);
|
|
|
|
} else {
|
|
|
|
ps->insert_vertex(jx2, jy2, h2);
|
|
|
|
ps->insert_vertex(kx2, ky2, h2);
|
|
|
|
ps->insert_vertex(jx1, jy1, h1);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-09-30 05:11:28 +04:00
|
|
|
PolySet *PolySetCGALEvaluator::evaluatePolySet(const LinearExtrudeNode &node)
|
2010-03-29 05:31:47 +04:00
|
|
|
{
|
|
|
|
DxfData *dxf;
|
|
|
|
|
2011-09-03 08:10:36 +04:00
|
|
|
if (node.filename.empty())
|
2010-03-29 05:31:47 +04:00
|
|
|
{
|
2010-11-03 21:26:06 +03:00
|
|
|
// Before extruding, union all (2D) children nodes
|
|
|
|
// to a single DxfData, then tesselate this into a PolySet
|
2011-09-02 22:19:17 +04:00
|
|
|
CGAL_Nef_polyhedron sum;
|
2011-09-04 22:35:23 +04:00
|
|
|
BOOST_FOREACH (AbstractNode * v, node.getChildren()) {
|
2011-12-26 19:34:47 +04:00
|
|
|
if (v->modinst->isBackground()) continue;
|
2011-09-02 22:19:17 +04:00
|
|
|
CGAL_Nef_polyhedron N = this->cgalevaluator.evaluateCGALMesh(*v);
|
2012-02-19 16:09:02 +04:00
|
|
|
if (!N.empty()) {
|
|
|
|
if (N.dim != 2) {
|
|
|
|
PRINT("ERROR: linear_extrude() is not defined for 3D child objects!");
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
if (sum.empty()) sum = N.copy();
|
|
|
|
else sum += N;
|
|
|
|
}
|
2011-09-07 01:59:08 +04:00
|
|
|
}
|
2010-11-03 21:26:06 +03:00
|
|
|
}
|
|
|
|
|
2011-09-07 01:59:08 +04:00
|
|
|
if (sum.empty()) return NULL;
|
2011-09-02 22:19:17 +04:00
|
|
|
dxf = sum.convertToDxfData();;
|
2010-03-29 05:31:47 +04:00
|
|
|
} else {
|
2011-09-04 00:44:41 +04:00
|
|
|
dxf = new DxfData(node.fn, node.fs, node.fa, node.filename, node.layername, node.origin_x, node.origin_y, node.scale);
|
2010-03-29 05:31:47 +04:00
|
|
|
}
|
|
|
|
|
2011-09-01 19:03:34 +04:00
|
|
|
PolySet *ps = extrudeDxfData(node, *dxf);
|
|
|
|
delete dxf;
|
|
|
|
return ps;
|
|
|
|
}
|
|
|
|
|
2011-09-30 05:11:28 +04:00
|
|
|
PolySet *PolySetCGALEvaluator::extrudeDxfData(const LinearExtrudeNode &node, DxfData &dxf)
|
2011-09-01 19:03:34 +04:00
|
|
|
{
|
2010-03-29 05:31:47 +04:00
|
|
|
PolySet *ps = new PolySet();
|
|
|
|
ps->convexity = node.convexity;
|
|
|
|
|
|
|
|
double h1, h2;
|
|
|
|
|
|
|
|
if (node.center) {
|
|
|
|
h1 = -node.height/2.0;
|
|
|
|
h2 = +node.height/2.0;
|
|
|
|
} else {
|
|
|
|
h1 = 0;
|
|
|
|
h2 = node.height;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool first_open_path = true;
|
2011-09-04 00:44:41 +04:00
|
|
|
for (size_t i = 0; i < dxf.paths.size(); i++)
|
2010-03-29 05:31:47 +04:00
|
|
|
{
|
2011-09-01 19:03:34 +04:00
|
|
|
if (dxf.paths[i].is_closed)
|
2010-03-29 05:31:47 +04:00
|
|
|
continue;
|
|
|
|
if (first_open_path) {
|
2012-01-25 06:11:12 +04:00
|
|
|
PRINTB("WARNING: Open paths in dxf_linear_extrude(file = \"%s\", layer = \"%s\"):",
|
|
|
|
node.filename % node.layername);
|
2010-03-29 05:31:47 +04:00
|
|
|
first_open_path = false;
|
|
|
|
}
|
2012-01-25 06:11:12 +04:00
|
|
|
PRINTB(" %9.5f %10.5f ... %10.5f %10.5f",
|
|
|
|
(dxf.points[dxf.paths[i].indices.front()][0] / node.scale + node.origin_x) %
|
|
|
|
(dxf.points[dxf.paths[i].indices.front()][1] / node.scale + node.origin_y) %
|
|
|
|
(dxf.points[dxf.paths[i].indices.back()][0] / node.scale + node.origin_x) %
|
|
|
|
(dxf.points[dxf.paths[i].indices.back()][1] / node.scale + node.origin_y));
|
2010-03-29 05:31:47 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
if (node.has_twist)
|
|
|
|
{
|
|
|
|
dxf_tesselate(ps, dxf, 0, false, true, h1);
|
|
|
|
dxf_tesselate(ps, dxf, node.twist, true, true, h2);
|
|
|
|
for (int j = 0; j < node.slices; j++)
|
|
|
|
{
|
|
|
|
double t1 = node.twist*j / node.slices;
|
|
|
|
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;
|
2011-09-04 00:44:41 +04:00
|
|
|
for (size_t i = 0; i < dxf.paths.size(); i++)
|
2010-03-29 05:31:47 +04:00
|
|
|
{
|
2011-09-01 19:03:34 +04:00
|
|
|
if (!dxf.paths[i].is_closed)
|
2010-03-29 05:31:47 +04:00
|
|
|
continue;
|
2011-09-04 00:44:41 +04:00
|
|
|
add_slice(ps, dxf, dxf.paths[i], t1, t2, g1, g2);
|
2010-03-29 05:31:47 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
dxf_tesselate(ps, dxf, 0, false, true, h1);
|
|
|
|
dxf_tesselate(ps, dxf, 0, true, true, h2);
|
2011-09-04 00:44:41 +04:00
|
|
|
for (size_t i = 0; i < dxf.paths.size(); i++)
|
2010-03-29 05:31:47 +04:00
|
|
|
{
|
2011-09-01 19:03:34 +04:00
|
|
|
if (!dxf.paths[i].is_closed)
|
2010-03-29 05:31:47 +04:00
|
|
|
continue;
|
2011-09-04 00:44:41 +04:00
|
|
|
add_slice(ps, dxf, dxf.paths[i], 0, 0, h1, h2);
|
2010-03-29 05:31:47 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return ps;
|
|
|
|
}
|
|
|
|
|
2011-09-30 05:11:28 +04:00
|
|
|
PolySet *PolySetCGALEvaluator::evaluatePolySet(const RotateExtrudeNode &node)
|
2010-03-29 05:31:47 +04:00
|
|
|
{
|
|
|
|
DxfData *dxf;
|
|
|
|
|
2011-09-03 08:10:36 +04:00
|
|
|
if (node.filename.empty())
|
2010-03-29 05:31:47 +04:00
|
|
|
{
|
2010-11-03 21:26:06 +03:00
|
|
|
// Before extruding, union all (2D) children nodes
|
|
|
|
// to a single DxfData, then tesselate this into a PolySet
|
2011-09-02 22:19:17 +04:00
|
|
|
CGAL_Nef_polyhedron sum;
|
2011-09-04 22:35:23 +04:00
|
|
|
BOOST_FOREACH (AbstractNode * v, node.getChildren()) {
|
2011-12-26 19:34:47 +04:00
|
|
|
if (v->modinst->isBackground()) continue;
|
2011-09-02 22:19:17 +04:00
|
|
|
CGAL_Nef_polyhedron N = this->cgalevaluator.evaluateCGALMesh(*v);
|
2012-02-19 16:09:02 +04:00
|
|
|
if (!N.empty()) {
|
|
|
|
if (N.dim != 2) {
|
|
|
|
PRINT("ERROR: rotate_extrude() is not defined for 3D child objects!");
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
if (sum.empty()) sum = N.copy();
|
|
|
|
else sum += N;
|
|
|
|
}
|
2011-09-07 01:59:08 +04:00
|
|
|
}
|
2010-11-03 21:26:06 +03:00
|
|
|
}
|
|
|
|
|
2011-09-07 01:59:08 +04:00
|
|
|
if (sum.empty()) return NULL;
|
2011-09-02 22:19:17 +04:00
|
|
|
dxf = sum.convertToDxfData();
|
2010-03-29 05:31:47 +04:00
|
|
|
} else {
|
2011-09-04 00:44:41 +04:00
|
|
|
dxf = new DxfData(node.fn, node.fs, node.fa, node.filename, node.layername, node.origin_x, node.origin_y, node.scale);
|
2010-03-29 05:31:47 +04:00
|
|
|
}
|
|
|
|
|
2011-09-01 19:03:34 +04:00
|
|
|
PolySet *ps = rotateDxfData(node, *dxf);
|
|
|
|
delete dxf;
|
|
|
|
return ps;
|
|
|
|
}
|
|
|
|
|
2011-09-09 07:53:05 +04:00
|
|
|
PolySet *PolySetCGALEvaluator::evaluatePolySet(const CgaladvNode &node)
|
2011-09-06 16:57:24 +04:00
|
|
|
{
|
|
|
|
CGAL_Nef_polyhedron N = this->cgalevaluator.evaluateCGALMesh(node);
|
|
|
|
PolySet *ps = NULL;
|
2011-11-08 06:38:18 +04:00
|
|
|
if (!N.empty()) {
|
|
|
|
ps = N.convertToPolyset();
|
2012-02-03 06:19:56 +04:00
|
|
|
if (ps) ps->convexity = node.convexity;
|
2011-11-08 06:38:18 +04:00
|
|
|
}
|
2011-09-09 07:53:05 +04:00
|
|
|
|
2011-09-06 16:57:24 +04:00
|
|
|
return ps;
|
|
|
|
}
|
|
|
|
|
2011-09-09 07:53:05 +04:00
|
|
|
PolySet *PolySetCGALEvaluator::evaluatePolySet(const RenderNode &node)
|
2011-09-06 20:31:22 +04:00
|
|
|
{
|
|
|
|
CGAL_Nef_polyhedron N = this->cgalevaluator.evaluateCGALMesh(node);
|
|
|
|
PolySet *ps = NULL;
|
2011-11-08 06:38:18 +04:00
|
|
|
if (!N.empty()) {
|
2011-12-21 21:03:23 +04:00
|
|
|
if (N.dim == 3 && !N.p3->is_simple()) {
|
2012-01-25 06:11:12 +04:00
|
|
|
PRINT("WARNING: Body of render() isn't valid 2-manifold!");
|
2011-12-12 03:48:07 +04:00
|
|
|
}
|
|
|
|
else {
|
|
|
|
ps = N.convertToPolyset();
|
2012-02-03 06:19:56 +04:00
|
|
|
if (ps) ps->convexity = node.convexity;
|
2011-12-12 03:48:07 +04:00
|
|
|
}
|
2011-11-08 06:38:18 +04:00
|
|
|
}
|
2011-09-06 20:31:22 +04:00
|
|
|
return ps;
|
|
|
|
}
|
2011-09-06 16:57:24 +04:00
|
|
|
|
2011-09-30 05:11:28 +04:00
|
|
|
PolySet *PolySetCGALEvaluator::rotateDxfData(const RotateExtrudeNode &node, DxfData &dxf)
|
2011-09-01 19:03:34 +04:00
|
|
|
{
|
2010-03-29 05:31:47 +04:00
|
|
|
PolySet *ps = new PolySet();
|
|
|
|
ps->convexity = node.convexity;
|
|
|
|
|
2011-09-04 22:35:23 +04:00
|
|
|
for (size_t i = 0; i < dxf.paths.size(); i++)
|
2010-03-29 05:31:47 +04:00
|
|
|
{
|
|
|
|
double max_x = 0;
|
2011-09-04 22:35:23 +04:00
|
|
|
for (size_t j = 0; j < dxf.paths[i].indices.size(); j++) {
|
2011-09-04 00:44:41 +04:00
|
|
|
max_x = fmax(max_x, dxf.points[dxf.paths[i].indices[j]][0]);
|
2010-03-29 05:31:47 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
int fragments = get_fragments_from_r(max_x, node.fn, node.fs, node.fa);
|
|
|
|
|
2011-04-12 22:35:44 +04:00
|
|
|
double ***points;
|
|
|
|
points = new double**[fragments];
|
|
|
|
for (int j=0; j < fragments; j++) {
|
2011-09-04 00:44:41 +04:00
|
|
|
points[j] = new double*[dxf.paths[i].indices.size()];
|
2011-09-04 22:35:23 +04:00
|
|
|
for (size_t k=0; k < dxf.paths[i].indices.size(); k++)
|
2011-04-12 22:35:44 +04:00
|
|
|
points[j][k] = new double[3];
|
|
|
|
}
|
2010-03-29 05:31:47 +04:00
|
|
|
|
|
|
|
for (int j = 0; j < fragments; j++) {
|
2012-04-23 03:31:23 +04:00
|
|
|
double a = (j*2*M_PI) / fragments - M_PI/2; // start on the X axis
|
2011-09-04 22:35:23 +04:00
|
|
|
for (size_t k = 0; k < dxf.paths[i].indices.size(); k++) {
|
2012-04-23 03:31:23 +04:00
|
|
|
points[j][k][0] = dxf.points[dxf.paths[i].indices[k]][0] * sin(a);
|
|
|
|
points[j][k][1] = dxf.points[dxf.paths[i].indices[k]][0] * cos(a);
|
2011-09-04 00:44:41 +04:00
|
|
|
points[j][k][2] = dxf.points[dxf.paths[i].indices[k]][1];
|
2010-03-29 05:31:47 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
for (int j = 0; j < fragments; j++) {
|
|
|
|
int j1 = j + 1 < fragments ? j + 1 : 0;
|
2011-09-04 00:44:41 +04:00
|
|
|
for (size_t k = 0; k < dxf.paths[i].indices.size(); k++) {
|
|
|
|
int k1 = k + 1 < dxf.paths[i].indices.size() ? k + 1 : 0;
|
2010-03-29 05:31:47 +04:00
|
|
|
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]) {
|
|
|
|
ps->append_poly();
|
|
|
|
ps->append_vertex(points[j ][k ][0],
|
|
|
|
points[j ][k ][1], points[j ][k ][2]);
|
|
|
|
ps->append_vertex(points[j1][k ][0],
|
|
|
|
points[j1][k ][1], points[j1][k ][2]);
|
|
|
|
ps->append_vertex(points[j ][k1][0],
|
|
|
|
points[j ][k1][1], points[j ][k1][2]);
|
|
|
|
}
|
|
|
|
if (points[j][k1][0] != points[j1][k1][0] ||
|
|
|
|
points[j][k1][1] != points[j1][k1][1] ||
|
|
|
|
points[j][k1][2] != points[j1][k1][2]) {
|
|
|
|
ps->append_poly();
|
|
|
|
ps->append_vertex(points[j ][k1][0],
|
|
|
|
points[j ][k1][1], points[j ][k1][2]);
|
|
|
|
ps->append_vertex(points[j1][k ][0],
|
|
|
|
points[j1][k ][1], points[j1][k ][2]);
|
|
|
|
ps->append_vertex(points[j1][k1][0],
|
|
|
|
points[j1][k1][1], points[j1][k1][2]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2011-04-12 22:35:44 +04:00
|
|
|
|
|
|
|
for (int j=0; j < fragments; j++) {
|
2011-09-04 00:44:41 +04:00
|
|
|
for (size_t k=0; k < dxf.paths[i].indices.size(); k++)
|
2011-04-12 22:35:44 +04:00
|
|
|
delete[] points[j][k];
|
|
|
|
delete[] points[j];
|
|
|
|
}
|
|
|
|
delete[] points;
|
2010-03-29 05:31:47 +04:00
|
|
|
}
|
2011-09-09 07:53:05 +04:00
|
|
|
|
2010-03-29 05:31:47 +04:00
|
|
|
return ps;
|
|
|
|
}
|