#include "SLABasePool.hpp" #include "SLABoilerPlate.hpp" #include "boost/log/trivial.hpp" #include "SLABoostAdapter.hpp" #include "ClipperUtils.hpp" //#include "SVG.hpp" //#include "benchmark.h" namespace Slic3r { namespace sla { /// Convert the triangulation output to an intermediate mesh. Contour3D convert(const Polygons& triangles, coord_t z, bool dir) { Pointf3s points; points.reserve(3*triangles.size()); Indices indices; indices.reserve(points.size()); for(auto& tr : triangles) { auto c = coord_t(points.size()), b = c++, a = c++; if(dir) indices.emplace_back(a, b, c); else indices.emplace_back(c, b, a); for(auto& p : tr.points) { points.emplace_back(unscale(x(p), y(p), z)); } } return {points, indices}; } Contour3D walls(const ExPolygon& floor_plate, const ExPolygon& ceiling, double floor_z_mm, double ceiling_z_mm) { using std::transform; using std::back_inserter; ExPolygon poly; poly.contour.points = floor_plate.contour.points; poly.holes.emplace_back(ceiling.contour); auto& h = poly.holes.front(); std::reverse(h.points.begin(), h.points.end()); Polygons tri = triangulate(poly); Contour3D ret; ret.points.reserve(tri.size() * 3); double fz = floor_z_mm; double cz = ceiling_z_mm; auto& rp = ret.points; auto& rpi = ret.indices; ret.indices.reserve(tri.size() * 3); coord_t idx = 0; auto hlines = h.lines(); auto is_upper = [&hlines](const Point& p) { return std::any_of(hlines.begin(), hlines.end(), [&p](const Line& l) { return l.distance_to(p) < mm(1e-6); }); }; std::for_each(tri.begin(), tri.end(), [&rp, &rpi, &poly, &idx, is_upper, fz, cz](const Polygon& pp) { for(auto& p : pp.points) if(is_upper(p)) rp.emplace_back(unscale(x(p), y(p), mm(cz))); else rp.emplace_back(unscale(x(p), y(p), mm(fz))); coord_t a = idx++, b = idx++, c = idx++; if(fz > cz) rpi.emplace_back(c, b, a); else rpi.emplace_back(a, b, c); }); return ret; } /// Offsetting with clipper and smoothing the edges into a curvature. void offset(ExPolygon& sh, coord_t distance) { using ClipperLib::ClipperOffset; using ClipperLib::jtRound; using ClipperLib::etClosedPolygon; using ClipperLib::Paths; using ClipperLib::Path; auto&& ctour = Slic3rMultiPoint_to_ClipperPath(sh.contour); auto&& holes = Slic3rMultiPoints_to_ClipperPaths(sh.holes); // If the input is not at least a triangle, we can not do this algorithm if(ctour.size() < 3 || std::any_of(holes.begin(), holes.end(), [](const Path& p) { return p.size() < 3; }) ) { BOOST_LOG_TRIVIAL(error) << "Invalid geometry for offsetting!"; return; } ClipperOffset offs; offs.ArcTolerance = 0.01*mm(1); Paths result; offs.AddPath(ctour, jtRound, etClosedPolygon); offs.AddPaths(holes, jtRound, etClosedPolygon); offs.Execute(result, static_cast(distance)); // Offsetting reverts the orientation and also removes the last vertex // so boost will not have a closed polygon. bool found_the_contour = false; sh.holes.clear(); for(auto& r : result) { if(ClipperLib::Orientation(r)) { // We don't like if the offsetting generates more than one contour // but throwing would be an overkill. Instead, we should warn the // caller about the inability to create correct geometries if(!found_the_contour) { auto rr = ClipperPath_to_Slic3rPolygon(r); sh.contour.points.swap(rr.points); found_the_contour = true; } else { BOOST_LOG_TRIVIAL(warning) << "Warning: offsetting result is invalid!"; } } else { // TODO If there are multiple contours we can't be sure which hole // belongs to the first contour. (But in this case the situation is // bad enough to let it go...) sh.holes.emplace_back(ClipperPath_to_Slic3rPolygon(r)); } } } /// Unification of polygons (with clipper) preserving holes as well. ExPolygons unify(const ExPolygons& shapes) { using ClipperLib::ptSubject; ExPolygons retv; bool closed = true; bool valid = true; ClipperLib::Clipper clipper; for(auto& path : shapes) { auto clipperpath = Slic3rMultiPoint_to_ClipperPath(path.contour); if(!clipperpath.empty()) valid &= clipper.AddPath(clipperpath, ptSubject, closed); auto clipperholes = Slic3rMultiPoints_to_ClipperPaths(path.holes); for(auto& hole : clipperholes) { if(!hole.empty()) valid &= clipper.AddPath(hole, ptSubject, closed); } } if(!valid) BOOST_LOG_TRIVIAL(warning) << "Unification of invalid shapes!"; ClipperLib::PolyTree result; clipper.Execute(ClipperLib::ctUnion, result, ClipperLib::pftNonZero); retv.reserve(static_cast(result.Total())); // Now we will recursively traverse the polygon tree and serialize it // into an ExPolygon with holes. The polygon tree has the clipper-ish // PolyTree structure which alternates its nodes as contours and holes // A "declaration" of function for traversing leafs which are holes std::function processHole; // Process polygon which calls processHoles which than calls processPoly // again until no leafs are left. auto processPoly = [&retv, &processHole](ClipperLib::PolyNode *pptr) { ExPolygon poly; poly.contour.points = ClipperPath_to_Slic3rPolygon(pptr->Contour); for(auto h : pptr->Childs) { processHole(h, poly); } retv.push_back(poly); }; // Body of the processHole function processHole = [&processPoly](ClipperLib::PolyNode *pptr, ExPolygon& poly) { poly.holes.emplace_back(); poly.holes.back().points = ClipperPath_to_Slic3rPolygon(pptr->Contour); for(auto c : pptr->Childs) processPoly(c); }; // Wrapper for traversing. auto traverse = [&processPoly] (ClipperLib::PolyNode *node) { for(auto ch : node->Childs) { processPoly(ch); } }; // Here is the actual traverse traverse(&result); return retv; } /// Only a debug function to generate top and bottom plates from a 2D shape. /// It is not used in the algorithm directly. inline Contour3D roofs(const ExPolygon& poly, coord_t z_distance) { Polygons triangles = triangulate(poly); auto lower = convert(triangles, 0, false); auto upper = convert(triangles, z_distance, true); lower.merge(upper); return lower; } template Contour3D round_edges(const ExPolygon& base_plate, double radius_mm, double degrees, double ceilheight_mm, bool dir, ExP&& last_offset = ExP(), D&& last_height = D()) { auto ob = base_plate; auto ob_prev = ob; double wh = ceilheight_mm, wh_prev = wh; Contour3D curvedwalls; int steps = 15; // int(std::ceil(10*std::pow(radius_mm, 1.0/3))); double stepx = radius_mm / steps; coord_t s = dir? 1 : -1; degrees = std::fmod(degrees, 180); if(degrees >= 90) { for(int i = 1; i <= steps; ++i) { ob = base_plate; double r2 = radius_mm * radius_mm; double xx = i*stepx; double x2 = xx*xx; double stepy = std::sqrt(r2 - x2); offset(ob, s*mm(xx)); wh = ceilheight_mm - radius_mm + stepy; Contour3D pwalls; pwalls = walls(ob, ob_prev, wh, wh_prev); curvedwalls.merge(pwalls); ob_prev = ob; wh_prev = wh; } } double tox = radius_mm - radius_mm*std::sin(degrees * PI / 180); int tos = int(tox / stepx); for(int i = 1; i <= tos; ++i) { ob = base_plate; double r2 = radius_mm * radius_mm; double xx = radius_mm - i*stepx; double x2 = xx*xx; double stepy = std::sqrt(r2 - x2); offset(ob, s*mm(xx)); wh = ceilheight_mm - radius_mm - stepy; Contour3D pwalls; pwalls = walls(ob_prev, ob, wh_prev, wh); curvedwalls.merge(pwalls); ob_prev = ob; wh_prev = wh; } last_offset = std::move(ob); last_height = wh; return curvedwalls; } /// Generating the concave part of the 3D pool with the bottom plate and the /// side walls. Contour3D inner_bed(const ExPolygon& poly, double depth_mm, double begin_h_mm = 0) { Polygons triangles = triangulate(poly); coord_t depth = mm(depth_mm); coord_t begin_h = mm(begin_h_mm); auto bottom = convert(triangles, -depth + begin_h, false); auto lines = poly.lines(); // Generate outer walls auto fp = [](const Point& p, Point::coord_type z) { return unscale(x(p), y(p), z); }; for(auto& l : lines) { auto s = coord_t(bottom.points.size()); bottom.points.emplace_back(fp(l.a, -depth + begin_h)); bottom.points.emplace_back(fp(l.b, -depth + begin_h)); bottom.points.emplace_back(fp(l.a, begin_h)); bottom.points.emplace_back(fp(l.b, begin_h)); bottom.indices.emplace_back(s + 3, s + 1, s); bottom.indices.emplace_back(s + 2, s + 3, s); } return bottom; } inline Point centroid(Points& pp) { Point c; switch(pp.size()) { case 0: break; case 1: c = pp.front(); break; case 2: c = (pp[0] + pp[1]) / 2; break; default: { auto MAX = std::numeric_limits::max(); auto MIN = std::numeric_limits::min(); Point min = {MAX, MAX}, max = {MIN, MIN}; for(auto& p : pp) { if(p(0) < min(0)) min(0) = p(0); if(p(1) < min(1)) min(1) = p(1); if(p(0) > max(0)) max(0) = p(0); if(p(1) > max(1)) max(1) = p(1); } c(0) = min(0) + (max(0) - min(0)) / 2; c(1) = min(1) + (max(1) - min(1)) / 2; // TODO: fails for non convex cluster // c = std::accumulate(pp.begin(), pp.end(), Point{0, 0}); // x(c) /= coord_t(pp.size()); y(c) /= coord_t(pp.size()); break; } } return c; } inline Point centroid(const ExPolygon& poly) { return poly.contour.centroid(); } /// A fake concave hull that is constructed by connecting separate shapes /// with explicit bridges. Bridges are generated from each shape's centroid /// to the center of the "scene" which is the centroid calculated from the shape /// centroids (a star is created...) ExPolygons concave_hull(const ExPolygons& polys, double max_dist_mm = 50) { namespace bgi = boost::geometry::index; using SpatElement = std::pair; using SpatIndex = bgi::rtree< SpatElement, bgi::rstar<16, 4> >; if(polys.empty()) return ExPolygons(); ExPolygons punion = unify(polys); // could be redundant if(punion.size() == 1) return punion; // We get the centroids of all the islands in the 2D slice Points centroids; centroids.reserve(punion.size()); std::transform(punion.begin(), punion.end(), std::back_inserter(centroids), [](const ExPolygon& poly) { return centroid(poly); }); SpatIndex boxindex; unsigned idx = 0; std::for_each(punion.begin(), punion.end(), [&boxindex, &idx](const ExPolygon& expo) { BoundingBox bb(expo); boxindex.insert(std::make_pair(bb, idx++)); }); // Centroid of the centroids of islands. This is where the additional // connector sticks are routed. Point cc = centroid(centroids); punion.reserve(punion.size() + centroids.size()); idx = 0; std::transform(centroids.begin(), centroids.end(), std::back_inserter(punion), [&punion, &boxindex, cc, max_dist_mm, &idx](const Point& c) { double dx = x(c) - x(cc), dy = y(c) - y(cc); double l = std::sqrt(dx * dx + dy * dy); double nx = dx / l, ny = dy / l; double max_dist = mm(max_dist_mm); ExPolygon& expo = punion[idx++]; BoundingBox querybb(expo); querybb.offset(max_dist); std::vector result; boxindex.query(bgi::intersects(querybb), std::back_inserter(result)); if(result.size() <= 1) return ExPolygon(); ExPolygon r; auto& ctour = r.contour.points; ctour.reserve(3); ctour.emplace_back(cc); Point d(coord_t(mm(1)*nx), coord_t(mm(1)*ny)); ctour.emplace_back(c + Point( -y(d), x(d) )); ctour.emplace_back(c + Point( y(d), -x(d) )); offset(r, mm(1)); return r; }); punion = unify(punion); return punion; } void base_plate(const TriangleMesh &mesh, ExPolygons &output, float h, float layerh) { TriangleMesh m = mesh; TriangleMeshSlicer slicer(&m); auto bb = mesh.bounding_box(); float gnd = float(bb.min(Z)); std::vector heights = {float(bb.min(Z))}; for(float hi = gnd + layerh; hi <= gnd + h; hi += layerh) heights.emplace_back(hi); std::vector out; out.reserve(size_t(std::ceil(h/layerh))); slicer.slice(heights, &out, [](){}); size_t count = 0; for(auto& o : out) count += o.size(); ExPolygons tmp; tmp.reserve(count); for(auto& o : out) for(auto& e : o) tmp.emplace_back(std::move(e)); output = unify(tmp); for(auto& o : output) o = o.simplify(0.1/SCALING_FACTOR).front(); } void create_base_pool(const ExPolygons &ground_layer, TriangleMesh& out, const PoolConfig& cfg) { double mdist = 2*(1.8*cfg.min_wall_thickness_mm + 4*cfg.edge_radius_mm) + cfg.max_merge_distance_mm; auto concavehs = concave_hull(ground_layer, mdist); for(ExPolygon& concaveh : concavehs) { if(concaveh.contour.points.empty()) return; concaveh.holes.clear(); const coord_t WALL_THICKNESS = mm(cfg.min_wall_thickness_mm); const coord_t WALL_DISTANCE = mm(2*cfg.edge_radius_mm) + coord_t(0.8*WALL_THICKNESS); const coord_t HEIGHT = mm(cfg.min_wall_height_mm); auto outer_base = concaveh; offset(outer_base, WALL_THICKNESS+WALL_DISTANCE); auto inner_base = outer_base; offset(inner_base, -WALL_THICKNESS); inner_base.holes.clear(); outer_base.holes.clear(); ExPolygon top_poly; top_poly.contour = outer_base.contour; top_poly.holes.emplace_back(inner_base.contour); auto& tph = top_poly.holes.back().points; std::reverse(tph.begin(), tph.end()); Contour3D pool; ExPolygon ob = outer_base; double wh = 0; // now we will calculate the angle or portion of the circle from // pi/2 that will connect perfectly with the bottom plate. // this is a tangent point calculation problem and the equation can // be found for example here: // http://www.ambrsoft.com/TrigoCalc/Circles2/CirclePoint/CirclePointDistance.htm // the y coordinate would be: // y = cy + (r^2*py - r*px*sqrt(px^2 + py^2 - r^2) / (px^2 + py^2) // where px and py are the coordinates of the point outside the circle // cx and cy are the circle center, r is the radius // to get the angle we use arcsin function and subtract 90 degrees then // flip the sign to get the right input to the round_edge function. double r = cfg.edge_radius_mm; double cy = 0; double cx = 0; double px = cfg.min_wall_thickness_mm; double py = r - cfg.min_wall_height_mm; double pxcx = px - cx; double pycy = py - cy; double b_2 = pxcx*pxcx + pycy*pycy; double r_2 = r*r; double D = std::sqrt(b_2 - r_2); double vy = (r_2*pycy - r*pxcx*D) / b_2; double phi = -(std::asin(vy/r) * 180 / PI - 90); auto curvedwalls = round_edges(ob, r, phi, // 170 degrees 0, // z position of the input plane true, ob, wh); pool.merge(curvedwalls); ExPolygon ob_contr = ob; ob_contr.holes.clear(); auto pwalls = walls(ob_contr, inner_base, wh, -cfg.min_wall_height_mm); pool.merge(pwalls); Polygons top_triangles, bottom_triangles; triangulate(top_poly, top_triangles); triangulate(inner_base, bottom_triangles); auto top_plate = convert(top_triangles, 0, false); auto bottom_plate = convert(bottom_triangles, -HEIGHT, true); ob = inner_base; wh = 0; // rounded edge generation for the inner bed curvedwalls = round_edges(ob, cfg.edge_radius_mm, 90, // 90 degrees 0, // z position of the input plane false, ob, wh); pool.merge(curvedwalls); auto innerbed = inner_bed(ob, cfg.min_wall_height_mm/2 + wh, wh); pool.merge(top_plate); pool.merge(bottom_plate); pool.merge(innerbed); out.merge(mesh(pool)); } } } }