From f297da0d0153c4dc032846ef3f927ff41899cfa9 Mon Sep 17 00:00:00 2001 From: tamasmeszaros Date: Thu, 16 Aug 2018 17:47:05 +0200 Subject: [PATCH] Working curve approximation of the concave hull with clipper offset. --- src/slabasebed.cpp | 49 +++ xs/CMakeLists.txt | 9 +- xs/src/libslic3r/ConcaveHull.cpp | 487 --------------------- xs/src/libslic3r/ConcaveHull.hpp | 49 --- xs/src/libslic3r/Rasterizer/Rasterizer.hpp | 4 +- xs/src/libslic3r/SLABasePool.cpp | 330 +++++++------- xs/src/libslic3r/SLABasePool.hpp | 7 +- xs/src/libslic3r/TriangleMesh.cpp | 2 +- 8 files changed, 243 insertions(+), 694 deletions(-) create mode 100644 src/slabasebed.cpp delete mode 100644 xs/src/libslic3r/ConcaveHull.cpp delete mode 100644 xs/src/libslic3r/ConcaveHull.hpp diff --git a/src/slabasebed.cpp b/src/slabasebed.cpp new file mode 100644 index 000000000..b11486f90 --- /dev/null +++ b/src/slabasebed.cpp @@ -0,0 +1,49 @@ +#include +#include + +#include +#include "TriangleMesh.hpp" +#include "SLABasePool.hpp" +#include "benchmark.h" + +const std::string USAGE_STR = { + "Usage: slabasebed stlfilename.stl" +}; + +void confess_at(const char * /*file*/, + int /*line*/, + const char * /*func*/, + const char * /*pat*/, + ...) {} + +int main(const int argc, const char *argv[]) { + using namespace Slic3r; + using std::cout; using std::endl; + + if(argc < 2) { + cout << USAGE_STR << endl; + return EXIT_SUCCESS; + } + + TriangleMesh model; + Benchmark bench; + + model.ReadSTLFile(argv[1]); + model.align_to_origin(); + + ExPolygons ground_slice; + TriangleMesh basepool; + + sla::ground_layer(model, ground_slice, 0.1f); + + bench.start(); + sla::create_base_pool(ground_slice, basepool); + bench.stop(); + + cout << "Base pool creation time: " << std::setprecision(10) + << bench.getElapsedSec() << " seconds." << endl; + + basepool.write_ascii("out.stl"); + + return EXIT_SUCCESS; +} diff --git a/xs/CMakeLists.txt b/xs/CMakeLists.txt index 0536eeacc..59022f66c 100644 --- a/xs/CMakeLists.txt +++ b/xs/CMakeLists.txt @@ -181,8 +181,6 @@ add_library(libslic3r STATIC ${LIBDIR}/libslic3r/TriangleMesh.hpp ${LIBDIR}/libslic3r/SLABasePool.hpp ${LIBDIR}/libslic3r/SLABasePool.cpp - ${LIBDIR}/libslic3r/ConcaveHull.hpp - ${LIBDIR}/libslic3r/ConcaveHull.cpp # ${LIBDIR}/libslic3r/utils.cpp ${LIBDIR}/libslic3r/Utils.hpp @@ -751,9 +749,14 @@ if(APPLE) endif() # Create a slic3r executable -add_executable(slic3r ${PROJECT_SOURCE_DIR}/src/slic3r.cpp) +add_executable(slic3r EXCLUDE_FROM_ALL ${PROJECT_SOURCE_DIR}/src/slic3r.cpp) target_include_directories(XS PRIVATE src src/libslic3r) target_link_libraries(slic3r libslic3r libslic3r_gui admesh miniz ${Boost_LIBRARIES} clipper ${EXPAT_LIBRARIES} ${GLEW_LIBRARIES} polypartition poly2tri ${TBB_LIBRARIES} ${wxWidgets_LIBRARIES}) + +#add_executable(slabasebed ${PROJECT_SOURCE_DIR}/src/slabasebed.cpp) +#target_include_directories(slabasebed PRIVATE src src/libslic3r) +#target_link_libraries(slabasebed libslic3r libslic3r_gui admesh miniz ${Boost_LIBRARIES} clipper ${EXPAT_LIBRARIES} ${GLEW_LIBRARIES} polypartition poly2tri ${TBB_LIBRARIES} ${wxWidgets_LIBRARIES}) + if(SLIC3R_PROFILE) target_link_libraries(Shiny) endif() diff --git a/xs/src/libslic3r/ConcaveHull.cpp b/xs/src/libslic3r/ConcaveHull.cpp deleted file mode 100644 index 8c8462267..000000000 --- a/xs/src/libslic3r/ConcaveHull.cpp +++ /dev/null @@ -1,487 +0,0 @@ -#include "ConcaveHull.hpp" - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#include -#include - -#pragma warning(push, 0) -#include -#pragma warning(pop) - -namespace Slic3r { namespace concavehull { - -const size_t stride = 24; // size in bytes of x, y, id - -namespace { - -// Floating point comparisons -auto Equal(double a, double b) -> bool; -auto Zero(double a) -> bool; -auto LessThan(double a, double b) -> bool; -auto LessThanOrEqual(double a, double b) -> bool; -auto GreaterThan(double a, double b) -> bool; - -// Algorithm-specific -auto NearestNeighboursFlann(flann::Index> &index, const Point &p, size_t k) -> PointValueVector; -auto SortByAngle(PointValueVector &values, const Point &p, double prevAngle) -> PointVector; -auto AddPoint(PointVector &points, const Point &p) -> void; - -// General maths -auto PointsEqual(const Point &a, const Point &b) -> bool; -auto Angle(const Point &a, const Point &b) -> double; -auto NormaliseAngle(double radians) -> double; -auto PointInPolygon(const Point &p, const PointVector &list) -> bool; -auto Intersects(const LineSegment &a, const LineSegment &b) -> bool; - -// Point list utilities -auto FindMinYPoint(const PointVector &points) -> Point; -auto RemoveDuplicates(PointVector &points) -> void; -auto IdentifyPoints(PointVector &points) -> void; -auto RemoveHull(PointVector &points, const PointVector &hull) -> PointVector::iterator; -auto MultiplePointInPolygon(PointVector::iterator begin, PointVector::iterator end, const PointVector &hull) -> bool; - -// Compare a and b for equality -auto Equal(double a, double b) -> bool -{ - return fabs(a - b) <= DBL_EPSILON; -} - -// Compare value to zero -auto Zero(double a) -> bool -{ - return fabs(a) <= DBL_EPSILON; -} - -// Compare for a < b -auto LessThan(double a, double b) -> bool -{ - return a < (b - DBL_EPSILON); -} - -// Compare for a <= b -auto LessThanOrEqual(double a, double b) -> bool -{ - return a <= (b + DBL_EPSILON); -} - -// Compare for a > b -auto GreaterThan(double a, double b) -> bool -{ - return a > (b + DBL_EPSILON); -} - -// Compare whether two points have the same x and y -auto PointsEqual(const Point &a, const Point &b) -> bool -{ - return Equal(a.x, b.x) && Equal(a.y, b.y); -} - -// Remove duplicates in a list of points -auto RemoveDuplicates(PointVector &points) -> void -{ - sort(begin(points), end(points), [](const Point & a, const Point & b) - { - if (Equal(a.x, b.x)) - return LessThan(a.y, b.y); - else - return LessThan(a.x, b.x); - }); - - auto newEnd = unique(begin(points), end(points), [](const Point & a, const Point & b) - { - return PointsEqual(a, b); - }); - - points.erase(newEnd, end(points)); -} - -// Uniquely id the points for binary searching -auto IdentifyPoints(PointVector &points) -> void -{ - uint64_t id = 0; - - for (auto itr = begin(points); itr != end(points); ++itr, ++id) - { - itr->id = id; - } -} - -// Find the point having the smallest y-value -auto FindMinYPoint(const PointVector &points) -> Point -{ - assert(!points.empty()); - - auto itr = min_element(begin(points), end(points), [](const Point & a, const Point & b) - { - if (Equal(a.y, b.y)) - return GreaterThan(a.x, b.x); - else - return LessThan(a.y, b.y); - }); - - return *itr; -} - -// Lookup by ID and remove a point from a list of points -auto RemovePoint(PointVector &list, const Point &p) -> void -{ - auto itr = std::lower_bound(begin(list), end(list), p, [](const Point & a, const Point & b) - { - return a.id < b.id; - }); - - assert(itr != end(list) && itr->id == p.id); - - if (itr != end(list)) - list.erase(itr); -} - -// Add a point to a list of points -auto AddPoint(PointVector &points, const Point &p) -> void -{ - points.push_back(p); -} - -// Return the k-nearest points in a list of points from the given point p (uses Flann library). -auto NearestNeighboursFlann(flann::Index> &index, const Point &p, size_t k) -> PointValueVector -{ - std::vector vIndices(k); - std::vector vDists(k); - double test[] = { p.x, p.y }; - - flann::Matrix query(test, 1, 2); - flann::Matrix mIndices(vIndices.data(), 1, static_cast(vIndices.size())); - flann::Matrix mDists(vDists.data(), 1, static_cast(vDists.size())); - - int count_ = index.knnSearch(query, mIndices, mDists, k, flann::SearchParams(128)); - size_t count = static_cast(count_); - - PointValueVector result(count); - - for (size_t i = 0; i < count; ++i) - { - int id = vIndices[i]; - const double *point = index.getPoint(id); - result[i].point.x = point[0]; - result[i].point.y = point[1]; - result[i].point.id = id; - result[i].distance = vDists[i]; - } - - return result; -} - -// Returns a list of points sorted in descending order of clockwise angle -auto SortByAngle(PointValueVector &values, const Point &from, double prevAngle) -> PointVector -{ - for_each(begin(values), end(values), [from, prevAngle](PointValue & to) - { - to.angle = NormaliseAngle(Angle(from, to.point) - prevAngle); - }); - - sort(begin(values), end(values), [](const PointValue & a, const PointValue & b) - { - return GreaterThan(a.angle, b.angle); - }); - - PointVector angled(values.size()); - - transform(begin(values), end(values), begin(angled), [](const PointValue & pv) - { - return pv.point; - }); - - return angled; -} - -// Get the angle in radians measured clockwise from +'ve x-axis -auto Angle(const Point &a, const Point &b) -> double -{ - double angle = -atan2(b.y - a.y, b.x - a.x); - - return NormaliseAngle(angle); -} - -// Return angle in range: 0 <= angle < 2PI -auto NormaliseAngle(double radians) -> double -{ - if (radians < 0.0) - return radians + M_PI + M_PI; - else - return radians; -} - -// Return the new logical end after removing points from dataset having ids belonging to hull -auto RemoveHull(PointVector &points, const PointVector &hull) -> PointVector::iterator -{ - std::vector ids(hull.size()); - - transform(begin(hull), end(hull), begin(ids), [](const Point & p) - { - return p.id; - }); - - sort(begin(ids), end(ids)); - - return remove_if(begin(points), end(points), [&ids](const Point & p) - { - return binary_search(begin(ids), end(ids), p.id); - }); -} - -//// Uses OpenMP to determine whether a condition exists in the specified range of elements. https://msdn.microsoft.com/en-us/library/ff521445.aspx -//template -//bool omp_parallel_any_of(InIt first, InIt last, const Predicate &pr) -//{ -// typedef typename std::iterator_traits::value_type item_type; - -// // A flag that indicates that the condition exists. -// bool found = false; - -// #pragma omp parallel for -// for (int i = 0; i < static_cast(last - first); ++i) -// { -// if (!found) -// { -// item_type &cur = *(first + i); - -// // If the element satisfies the condition, set the flag to cancel the operation. -// if (pr(cur)) -// { -// found = true; -// } -// } -// } - -// return found; -//} - -// Check whether all points in a begin/end range are inside hull. -auto MultiplePointInPolygon(PointVector::iterator begin, PointVector::iterator end, const PointVector &hull) -> bool -{ - auto test = [&hull](const Point & p) - { - return !PointInPolygon(p, hull); - }; - - bool anyOutside = true; - -#if defined USE_OPENMP - - anyOutside = omp_parallel_any_of(begin, end, test); // multi-threaded - -#else - - anyOutside = std::any_of(begin, end, test); // single-threaded - -#endif - - return !anyOutside; -} - -// Point-in-polygon test -auto PointInPolygon(const Point &p, const PointVector &list) -> bool -{ - if (list.size() <= 2) - return false; - - const double &x = p.x; - const double &y = p.y; - - int inout = 0; - auto v0 = list.begin(); - auto v1 = v0 + 1; - - while (v1 != list.end()) - { - if ((LessThanOrEqual(v0->y, y) && LessThan(y, v1->y)) || (LessThanOrEqual(v1->y, y) && LessThan(y, v0->y))) - { - if (!Zero(v1->y - v0->y)) - { - double tdbl1 = (y - v0->y) / (v1->y - v0->y); - double tdbl2 = v1->x - v0->x; - - if (LessThan(x, v0->x + (tdbl2 * tdbl1))) - inout++; - } - } - - v0 = v1; - v1++; - } - - if (inout == 0) - return false; - else if (inout % 2 == 0) - return false; - else - return true; -} - -// Test whether two line segments intersect each other -auto Intersects(const LineSegment &a, const LineSegment &b) -> bool -{ - // https://www.topcoder.com/community/data-science/data-science-tutorials/geometry-concepts-line-intersection-and-its-applications/ - - const double &ax1 = a.first.x; - const double &ay1 = a.first.y; - const double &ax2 = a.second.x; - const double &ay2 = a.second.y; - const double &bx1 = b.first.x; - const double &by1 = b.first.y; - const double &bx2 = b.second.x; - const double &by2 = b.second.y; - - double a1 = ay2 - ay1; - double b1 = ax1 - ax2; - double c1 = a1 * ax1 + b1 * ay1; - double a2 = by2 - by1; - double b2 = bx1 - bx2; - double c2 = a2 * bx1 + b2 * by1; - double det = a1 * b2 - a2 * b1; - - if (Zero(det)) - { - return false; - } - else - { - double x = (b2 * c1 - b1 * c2) / det; - double y = (a1 * c2 - a2 * c1) / det; - - bool on_both = true; - on_both = on_both && LessThanOrEqual(std::min(ax1, ax2), x) && LessThanOrEqual(x, std::max(ax1, ax2)); - on_both = on_both && LessThanOrEqual(std::min(ay1, ay2), y) && LessThanOrEqual(y, std::max(ay1, ay2)); - on_both = on_both && LessThanOrEqual(std::min(bx1, bx2), x) && LessThanOrEqual(x, std::max(bx1, bx2)); - on_both = on_both && LessThanOrEqual(std::min(by1, by2), y) && LessThanOrEqual(y, std::max(by1, by2)); - return on_both; - } -} - -} - -// The main algorithm from the Moreira-Santos paper. -auto ConcaveHull(PointVector &pointList, size_t k, PointVector &hull) -> bool -{ - hull.clear(); - - if (pointList.size() < 3) - { - return true; - } - if (pointList.size() == 3) - { - hull = pointList; - return true; - } - - // construct a randomized kd-tree index using 4 kd-trees - // 2 columns, but stride = 24 bytes in width (x, y, ignoring id) - flann::Matrix matrix(&(pointList.front().x), pointList.size(), 2, stride); - flann::Index> flannIndex(matrix, flann::KDTreeIndexParams(4)); - flannIndex.buildIndex(); - - std::cout << "\rFinal 'k' : " << k; - - // Initialise hull with the min-y point - Point firstPoint = FindMinYPoint(pointList); - AddPoint(hull, firstPoint); - - // Until the hull is of size > 3 we want to ignore the first point from nearest neighbour searches - Point currentPoint = firstPoint; - flannIndex.removePoint(firstPoint.id); - - double prevAngle = 0.0; - int step = 1; - - // Iterate until we reach the start, or until there's no points left to process - while ((!PointsEqual(currentPoint, firstPoint) || step == 1) && hull.size() != pointList.size()) - { - if (step == 4) - { - // Put back the first point into the dataset and into the flann index - firstPoint.id = pointList.size(); - flann::Matrix firstPointMatrix(&firstPoint.x, 1, 2, stride); - flannIndex.addPoints(firstPointMatrix); - } - - PointValueVector kNearestNeighbours = NearestNeighboursFlann(flannIndex, currentPoint, k); - PointVector cPoints = SortByAngle(kNearestNeighbours, currentPoint, prevAngle); - - bool its = true; - size_t i = 0; - - while (its && i < cPoints.size()) - { - size_t lastPoint = 0; - if (PointsEqual(cPoints[i], firstPoint)) - lastPoint = 1; - - size_t j = 2; - its = false; - - while (!its && j < hull.size() - lastPoint) - { - auto line1 = std::make_pair(hull[step - 1], cPoints[i]); - auto line2 = std::make_pair(hull[step - j - 1], hull[step - j]); - its = Intersects(line1, line2); - j++; - } - - if (its) - i++; - } - - if (its) - return false; - - currentPoint = cPoints[i]; - - AddPoint(hull, currentPoint); - - prevAngle = Angle(hull[step], hull[step - 1]); - - flannIndex.removePoint(currentPoint.id); - - step++; - } - - // The original points less the points belonging to the hull need to be fully enclosed by the hull in order to return true. - PointVector dataset = pointList; - - auto newEnd = RemoveHull(dataset, hull); - bool allEnclosed = MultiplePointInPolygon(begin(dataset), newEnd, hull); - - return allEnclosed; -} - -// Iteratively call the main algorithm with an increasing k until success -auto ConcaveHull(PointVector &dataset, size_t k, bool iterate) -> PointVector -{ - while (k < dataset.size()) - { - PointVector hull; - if (ConcaveHull(dataset, k, hull) || !iterate) - { - return hull; - } - k++; - } - - return{}; -} - -Point::Point(const Pointf & sp): x(sp.x), y(sp.y) {} - -} -} diff --git a/xs/src/libslic3r/ConcaveHull.hpp b/xs/src/libslic3r/ConcaveHull.hpp deleted file mode 100644 index 52e59e269..000000000 --- a/xs/src/libslic3r/ConcaveHull.hpp +++ /dev/null @@ -1,49 +0,0 @@ -#ifndef CONCAVEHULL_HPP -#define CONCAVEHULL_HPP - -#include -#include - -namespace Slic3r { - -class Pointf; - -namespace concavehull { - -using std::uint64_t; - -struct Point -{ - double x = 0.0; - double y = 0.0; - std::uint64_t id = 0; - - Point() = default; - - Point(double x, double y) - : x(x) - , y(y) - {} - - explicit Point(const Slic3r::Pointf&); -}; - -struct PointValue -{ - Point point; - double distance = 0.0; - double angle = 0.0; -}; - -extern const size_t stride; // size in bytes of x, y, id - -using PointVector = std::vector; -using PointValueVector = std::vector; -using LineSegment = std::pair; - -auto ConcaveHull(PointVector &dataset, size_t k, bool iterate) -> PointVector; - -} -} - -#endif // CONCAVEHULL_HPP diff --git a/xs/src/libslic3r/Rasterizer/Rasterizer.hpp b/xs/src/libslic3r/Rasterizer/Rasterizer.hpp index 96dc4402e..cbb39bc6b 100644 --- a/xs/src/libslic3r/Rasterizer/Rasterizer.hpp +++ b/xs/src/libslic3r/Rasterizer/Rasterizer.hpp @@ -9,9 +9,9 @@ namespace Slic3r { class ExPolygon; /** - * @brief Raster captures an antialiased monochrome canvas where vectorial + * @brief Raster captures an anti-aliased monochrome canvas where vectorial * polygons can be rasterized. Fill color is always white and the background is - * black. Countours are antialiased. + * black. Contours are anti-aliased. * * It also supports saving the raster data into a standard output stream in raw * or PNG format. diff --git a/xs/src/libslic3r/SLABasePool.cpp b/xs/src/libslic3r/SLABasePool.cpp index 6d498c715..385bcbbb9 100644 --- a/xs/src/libslic3r/SLABasePool.cpp +++ b/xs/src/libslic3r/SLABasePool.cpp @@ -3,63 +3,32 @@ #include "SLABasePool.hpp" #include "ExPolygon.hpp" #include "TriangleMesh.hpp" -#include "libnest2d/clipper_backend/clipper_backend.hpp" +#include #include "ClipperUtils.hpp" +#include "boost/log/trivial.hpp" -#include "ConcaveHull.hpp" - -using BoostPolygon = libnest2d::PolygonImpl; -using BoostPolygons = std::vector; +//#include "SVG.hpp" namespace Slic3r { namespace sla { namespace { using coord_t = Point::coord_type; +inline coord_t mm(double v) { return coord_t(v/SCALING_FACTOR); } -void reverse(Polygon& p) { - std::reverse(p.points.begin(), p.points.end()); -} - -inline BoostPolygon convert(const ExPolygon& exp) { - auto&& ctour = Slic3rMultiPoint_to_ClipperPath(exp.contour); - auto&& holes = Slic3rMultiPoints_to_ClipperPaths(exp.holes); - return {ctour, holes}; -} - -inline BoostPolygons convert(const ExPolygons& exps) { - BoostPolygons ret; - ret.reserve(exps.size()); - std::for_each(exps.begin(), exps.end(), [&ret](const ExPolygon p) { - ret.emplace_back(convert(p)); - }); - return ret; -} - -inline ExPolygon convert(const BoostPolygon& p) { - ExPolygon ret; - - auto&& ctour = ClipperPath_to_Slic3rPolygon(p.Contour); - ctour.points.pop_back(); - - auto&& holes = ClipperPaths_to_Slic3rPolygons(p.Holes); - for(auto&& h : holes) h.points.pop_back(); - - ret.contour = ctour; - ret.holes = holes; - return ret; -} +inline coord_t x(const Point& p) { return p.x; } +inline coord_t y(const Point& p) { return p.y; } struct Contour3D { Pointf3s points; std::vector indices; - void merge(const Contour3D& ctour) { + void merge(const Contour3D& ctr) { auto s3 = coord_t(points.size()); auto s = coord_t(indices.size()); - points.insert(points.end(), ctour.points.begin(), ctour.points.end()); - indices.insert(indices.end(), ctour.indices.begin(), ctour.indices.end()); + points.insert(points.end(), ctr.points.begin(), ctr.points.end()); + indices.insert(indices.end(), ctr.indices.begin(), ctr.indices.end()); for(auto n = s; n < indices.size(); n++) { auto& idx = indices[n]; idx.x += s3; idx.y += s3; idx.z += s3; @@ -79,7 +48,7 @@ inline Contour3D convert(const Polygons& triangles, coord_t z, bool dir) { if(dir) indices.emplace_back(a, b, c); else indices.emplace_back(c, b, a); for(auto& p : tr.points) { - points.emplace_back(Pointf3::new_unscale(p.x, p.y, z)); + points.emplace_back(Pointf3::new_unscale(x(p), y(p), z)); } } @@ -90,26 +59,26 @@ inline Contour3D roofs(const ExPolygon& poly, coord_t z_distance) { Polygons triangles; poly.triangulate_pp(&triangles); - auto lower = convert(triangles, 0, true); - auto upper = convert(triangles, z_distance, false); + auto lower = convert(triangles, 0, false); + auto upper = convert(triangles, z_distance, true); lower.merge(upper); return lower; } inline Contour3D inner_bed(const ExPolygon& poly, coord_t depth) { Polygons triangles; - poly.triangulate_pp(&triangles); + poly.triangulate_p2t(&triangles); auto bottom = convert(triangles, -depth, false); auto lines = poly.lines(); // Generate outer walls auto fp = [](const Point& p, Point::coord_type z) { - return Pointf3::new_unscale(p.x, p.y, z); + return Pointf3::new_unscale(x(p), y(p), z); }; for(auto& l : lines) { - auto s = bottom.points.size(); + auto s = coord_t(bottom.points.size()); bottom.points.emplace_back(fp(l.a, -depth)); bottom.points.emplace_back(fp(l.b, -depth)); @@ -131,94 +100,182 @@ inline TriangleMesh mesh(Contour3D&& ctour) { return {std::move(ctour.points), std::move(ctour.indices)}; } -inline void offset(BoostPolygon& sh, Point::coord_type distance) { +inline void offset(ExPolygon& sh, coord_t distance) { using ClipperLib::ClipperOffset; using ClipperLib::jtRound; using ClipperLib::etClosedPolygon; using ClipperLib::Paths; - using namespace libnest2d; + 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(sh.Contour.size() <= 3 || - std::any_of(sh.Holes.begin(), sh.Holes.end(), - [](const PathImpl& p) { return p.size() <= 3; }) - ) throw GeometryException(GeomErr::OFFSET); + 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.05*mm(1); Paths result; - offs.AddPath(sh.Contour, jtRound, etClosedPolygon); - offs.AddPaths(sh.Holes, jtRound, etClosedPolygon); + 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) { - sh.Contour = r; - ClipperLib::ReversePath(sh.Contour); - sh.Contour.push_back(sh.Contour.front()); + auto rr = ClipperPath_to_Slic3rPolygon(r); + sh.contour.points.swap(rr.points); found_the_contour = true; } else { - dout() << "Warning: offsetting result is invalid!"; - /* TODO warning */ + 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.push_back(r); - ClipperLib::ReversePath(sh.Holes.back()); - sh.Holes.back().push_back(sh.Holes.back().front()); + sh.holes.emplace_back(ClipperPath_to_Slic3rPolygon(r)); } } } +inline ExPolygons unify(const ExPolygons& shapes) { + ExPolygons retv; -inline ExPolygon concave_hull(const ExPolygons& polys) { - concavehull::PointVector pv; - size_t s = 0; + bool closed = true; + bool valid = true; - for(auto& ep : polys) s += ep.contour.points.size(); - pv.reserve(s); + ClipperLib::Clipper clipper; - std::cout << polys.size() << std::endl; + for(auto& path : shapes) { + auto clipperpath = Slic3rMultiPoint_to_ClipperPath(path.contour); + valid &= clipper.AddPath(clipperpath, ClipperLib::ptSubject, closed); -// for(const ExPolygon& ep : polys) { - auto& ep = polys.front(); - - for(auto& v : ep.contour.points) - pv.emplace_back(Pointf::new_unscale(v.x, v.y)); - - std::reverse(pv.begin(), pv.end()); - -// auto frontpoint = ep.contour.points.front(); -// pv.emplace_back(Pointf::new_unscale(frontpoint)); -// } - - auto result = concavehull::ConcaveHull(pv, 3, true); - - if(result.empty()) std::cout << "Empty concave hull!!!" << std::endl; - std::cout << "result size " << result.size() << std::endl; - - ExPolygon ret; - ret.contour.points.reserve(result.size() + 1); - - std::reverse(result.begin(), result.end()); - - for(auto& p : result) { - std::cout << p.x << " " << p.y << std::endl; - ret.contour.points.emplace_back(Point::new_scale(p.x, p.y)); + auto clipperholes = Slic3rMultiPoints_to_ClipperPaths(path.holes); + for(auto& hole : clipperholes) { + valid &= clipper.AddPath(hole, ClipperLib::ptSubject, closed); + } } - reverse(ret.contour); + if(!valid) BOOST_LOG_TRIVIAL(warning) << "Unification of invalid shapes!"; -// ret.contour.points.emplace_back(ret.contour.points.front()); + 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; +} + +inline Point centroid(Points& pp) { + Polygon p; + p.points.swap(pp); + Point c = p.centroid(); + pp.swap(p.points); + return c; +} + +inline Point centroid(const ExPolygon& poly) { + return poly.contour.centroid(); +} + +inline ExPolygon concave_hull(const ExPolygons& polys) { + if(polys.empty()) return ExPolygon(); + + ExPolygons punion = unify(polys); + + ExPolygon ret; + + if(punion.size() == 1) return punion.front(); + + // 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); }); + + // 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()); + + std::transform(centroids.begin(), centroids.end(), + std::back_inserter(punion), + [cc](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; + + 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); + + if(punion.size() != 1) + BOOST_LOG_TRIVIAL(error) << "Cannot generate correct SLA base pool!"; + + if(!punion.empty()) ret = punion.front(); return ret; } @@ -237,81 +294,54 @@ void ground_layer(const TriangleMesh &mesh, ExPolygons &output, float h) output = tmp.front(); } -void create_base_pool(const ExPolygons &ground_layer, TriangleMesh& out) +void create_base_pool(const ExPolygons &ground_layer, TriangleMesh& out, + double min_wall_thickness_mm, + double min_wall_height_mm) { - using libnest2d::PolygonImpl; - using boost::geometry::convex_hull; - using boost::geometry::is_valid; - - static const Point::coord_type INNER_OFFSET_DIST = 2000000; - static const Point::coord_type OFFSET_DIST = 5000000; - static const Point::coord_type HEIGHT = 10000000; - // 1: Offset the ground layer - auto concaveh = ground_layer.front(); //concave_hull(ground_layer); + auto concaveh = concave_hull(ground_layer); + if(concaveh.contour.points.empty()) return; concaveh.holes.clear(); -// BoostPolygon chull_boost; -// convex_hull(convert(ground_layer), chull_boost); -// auto concaveh = convert(chull_boost); + BoundingBox bb(concaveh); + coord_t w = bb.max.x - bb.min.x; + coord_t h = bb.max.y - bb.min.y; -// auto pool = roofs(concaveh, HEIGHT); + auto wall_thickness = coord_t(std::pow((w+h)*0.1, 0.8)); -// // Generate outer walls -// auto fp = [](const Point& p, Point::coord_type z) { -// return Pointf3::new_unscale(p.x, p.y, z); -// }; + const coord_t WALL_THICKNESS = mm(min_wall_thickness_mm) + wall_thickness; + const coord_t WALL_DISTANCE = coord_t(0.3*WALL_THICKNESS); + const coord_t HEIGHT = mm(min_wall_height_mm); -// auto lines = concaveh.lines(); -// std::cout << "lines: " << lines.size() << std::endl; -// for(auto& l : lines) { -// auto s = pool.points.size(); - -// pool.points.emplace_back(fp(l.a, 0)); -// pool.points.emplace_back(fp(l.b, 0)); -// pool.points.emplace_back(fp(l.a, HEIGHT)); -// pool.points.emplace_back(fp(l.b, HEIGHT)); - -// pool.indices.emplace_back(s, s + 3, s + 1); -// pool.indices.emplace_back(s, s + 2, s + 3); -// } - -// out = mesh(pool); - - BoostPolygon chull_boost = convert(concaveh); -// convex_hull(convert(ground_layer), chull_boost); - - offset(chull_boost, INNER_OFFSET_DIST); - auto chull_outer_boost = chull_boost; - offset(chull_outer_boost, OFFSET_DIST); - - - // Convert back to Slic3r format - ExPolygon chull_inner = convert(chull_boost); - ExPolygon chull_outer = convert(chull_outer_boost); + 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 = chull_outer.contour; - top_poly.holes.emplace_back(chull_inner.contour); - reverse(top_poly.holes.back()); + 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; Polygons top_triangles, bottom_triangles; - top_poly.triangulate_pp(&top_triangles); - chull_outer.triangulate_pp(&bottom_triangles); + top_poly.triangulate_p2t(&top_triangles); + outer_base.triangulate_p2t(&bottom_triangles); auto top_plate = convert(top_triangles, 0, false); auto bottom_plate = convert(bottom_triangles, -HEIGHT, true); - auto innerbed = inner_bed(chull_inner, HEIGHT/2); + auto innerbed = inner_bed(inner_base, HEIGHT/2); // Generate outer walls - auto fp = [](const Point& p, Point::coord_type z) { - return Pointf3::new_unscale(p.x, p.y, z); + auto fp = [](const Point& p, coord_t z) { + return Pointf3::new_unscale(x(p), y(p), z); }; - auto lines = chull_outer.lines(); + auto lines = outer_base.lines(); for(auto& l : lines) { - auto s = pool.points.size(); + auto s = coord_t(pool.points.size()); pool.points.emplace_back(fp(l.a, -HEIGHT)); pool.points.emplace_back(fp(l.b, -HEIGHT)); diff --git a/xs/src/libslic3r/SLABasePool.hpp b/xs/src/libslic3r/SLABasePool.hpp index 47bc0569d..52adabfbc 100644 --- a/xs/src/libslic3r/SLABasePool.hpp +++ b/xs/src/libslic3r/SLABasePool.hpp @@ -15,11 +15,14 @@ using ExPolygons = std::vector; /// Calculate the polygon representing the slice of the lowest layer of mesh void ground_layer(const TriangleMesh& mesh, ExPolygons& output, - float height = .1f); + float height = 0.1f); /// Calculate the pool for the mesh for SLA printing void create_base_pool(const ExPolygons& ground_layer, - TriangleMesh& output_mesh); + TriangleMesh& output_mesh, + double min_wall_thickness_mm = 4, + double min_wall_height_mm = 5 + ); } diff --git a/xs/src/libslic3r/TriangleMesh.cpp b/xs/src/libslic3r/TriangleMesh.cpp index 99e79da18..4c35e3a67 100644 --- a/xs/src/libslic3r/TriangleMesh.cpp +++ b/xs/src/libslic3r/TriangleMesh.cpp @@ -842,7 +842,7 @@ TriangleMeshSlicer::slice(const std::vector &z, std::vector* #ifdef SLIC3R_TRIANGLEMESH_DEBUG printf("Layer " PRINTF_ZU " (slice_z = %.2f):\n", layer_id, z[layer_id]); #endif - this->make_expolygons(layers_p[layer_id], &(*layers)[layer_id]); + this->make_expolygons(layers_p[layer_id], &(*layers)[layer_id]); } }); BOOST_LOG_TRIVIAL(debug) << "TriangleMeshSlicer::make_expolygons in parallel - end";