mirror of
https://github.com/SoftFever/OrcaSlicer.git
synced 2025-10-24 17:21:11 -06:00
Rough base pool geometry can be generated from convex hull or from the ground slice itself.
This commit is contained in:
tamasmeszaros
parent
e8616b6a35
commit
fbe415f88e
8 changed files with 1016 additions and 126 deletions
333
xs/src/libslic3r/SLABasePool.cpp
Normal file
333
xs/src/libslic3r/SLABasePool.cpp
Normal file
|
|
@ -0,0 +1,333 @@
|
|||
#include <functional>
|
||||
|
||||
#include "SLABasePool.hpp"
|
||||
#include "ExPolygon.hpp"
|
||||
#include "TriangleMesh.hpp"
|
||||
#include "libnest2d/clipper_backend/clipper_backend.hpp"
|
||||
#include "ClipperUtils.hpp"
|
||||
|
||||
#include "ConcaveHull.hpp"
|
||||
|
||||
using BoostPolygon = libnest2d::PolygonImpl;
|
||||
using BoostPolygons = std::vector<libnest2d::PolygonImpl>;
|
||||
|
||||
namespace Slic3r { namespace sla {
|
||||
|
||||
namespace {
|
||||
|
||||
using coord_t = Point::coord_type;
|
||||
|
||||
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;
|
||||
}
|
||||
|
||||
struct Contour3D {
|
||||
Pointf3s points;
|
||||
std::vector<Point3> indices;
|
||||
|
||||
void merge(const Contour3D& ctour) {
|
||||
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());
|
||||
|
||||
for(auto n = s; n < indices.size(); n++) {
|
||||
auto& idx = indices[n]; idx.x += s3; idx.y += s3; idx.z += s3;
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
inline Contour3D convert(const Polygons& triangles, coord_t z, bool dir) {
|
||||
|
||||
Pointf3s points;
|
||||
points.reserve(3*triangles.size());
|
||||
std::vector<Point3> 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(Pointf3::new_unscale(p.x, p.y, z));
|
||||
}
|
||||
}
|
||||
|
||||
return {points, indices};
|
||||
}
|
||||
|
||||
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);
|
||||
lower.merge(upper);
|
||||
return lower;
|
||||
}
|
||||
|
||||
inline Contour3D inner_bed(const ExPolygon& poly, coord_t depth) {
|
||||
Polygons triangles;
|
||||
poly.triangulate_pp(&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);
|
||||
};
|
||||
|
||||
for(auto& l : lines) {
|
||||
auto s = bottom.points.size();
|
||||
|
||||
bottom.points.emplace_back(fp(l.a, -depth));
|
||||
bottom.points.emplace_back(fp(l.b, -depth));
|
||||
bottom.points.emplace_back(fp(l.a, 0));
|
||||
bottom.points.emplace_back(fp(l.b, 0));
|
||||
|
||||
bottom.indices.emplace_back(s, s + 1, s + 3);
|
||||
bottom.indices.emplace_back(s, s + 3, s + 2);
|
||||
}
|
||||
|
||||
return bottom;
|
||||
}
|
||||
|
||||
inline TriangleMesh mesh(const Contour3D& ctour) {
|
||||
return {ctour.points, ctour.indices};
|
||||
}
|
||||
|
||||
inline TriangleMesh mesh(Contour3D&& ctour) {
|
||||
return {std::move(ctour.points), std::move(ctour.indices)};
|
||||
}
|
||||
|
||||
inline void offset(BoostPolygon& sh, Point::coord_type distance) {
|
||||
using ClipperLib::ClipperOffset;
|
||||
using ClipperLib::jtRound;
|
||||
using ClipperLib::etClosedPolygon;
|
||||
using ClipperLib::Paths;
|
||||
using namespace libnest2d;
|
||||
|
||||
// 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);
|
||||
|
||||
ClipperOffset offs;
|
||||
Paths result;
|
||||
offs.AddPath(sh.Contour, jtRound, etClosedPolygon);
|
||||
offs.AddPaths(sh.Holes, jtRound, etClosedPolygon);
|
||||
offs.Execute(result, static_cast<double>(distance));
|
||||
|
||||
// Offsetting reverts the orientation and also removes the last vertex
|
||||
// so boost will not have a closed polygon.
|
||||
|
||||
bool found_the_contour = false;
|
||||
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());
|
||||
found_the_contour = true;
|
||||
} else {
|
||||
dout() << "Warning: offsetting result is invalid!";
|
||||
/* TODO warning */
|
||||
}
|
||||
} 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());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
inline ExPolygon concave_hull(const ExPolygons& polys) {
|
||||
concavehull::PointVector pv;
|
||||
size_t s = 0;
|
||||
|
||||
for(auto& ep : polys) s += ep.contour.points.size();
|
||||
pv.reserve(s);
|
||||
|
||||
std::cout << polys.size() << std::endl;
|
||||
|
||||
// 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));
|
||||
}
|
||||
|
||||
reverse(ret.contour);
|
||||
|
||||
// ret.contour.points.emplace_back(ret.contour.points.front());
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
void ground_layer(const TriangleMesh &mesh, ExPolygons &output, float h)
|
||||
{
|
||||
TriangleMesh m = mesh;
|
||||
TriangleMeshSlicer slicer(&m);
|
||||
|
||||
std::vector<ExPolygons> tmp;
|
||||
|
||||
slicer.slice({h}, &tmp);
|
||||
|
||||
output = tmp.front();
|
||||
}
|
||||
|
||||
void create_base_pool(const ExPolygons &ground_layer, TriangleMesh& out)
|
||||
{
|
||||
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);
|
||||
concaveh.holes.clear();
|
||||
|
||||
// BoostPolygon chull_boost;
|
||||
// convex_hull(convert(ground_layer), chull_boost);
|
||||
// auto concaveh = convert(chull_boost);
|
||||
|
||||
// auto pool = roofs(concaveh, HEIGHT);
|
||||
|
||||
// // Generate outer walls
|
||||
// auto fp = [](const Point& p, Point::coord_type z) {
|
||||
// return Pointf3::new_unscale(p.x, p.y, z);
|
||||
// };
|
||||
|
||||
// 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);
|
||||
|
||||
ExPolygon top_poly;
|
||||
top_poly.contour = chull_outer.contour;
|
||||
top_poly.holes.emplace_back(chull_inner.contour);
|
||||
reverse(top_poly.holes.back());
|
||||
|
||||
Contour3D pool;
|
||||
|
||||
Polygons top_triangles, bottom_triangles;
|
||||
top_poly.triangulate_pp(&top_triangles);
|
||||
chull_outer.triangulate_pp(&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);
|
||||
|
||||
// Generate outer walls
|
||||
auto fp = [](const Point& p, Point::coord_type z) {
|
||||
return Pointf3::new_unscale(p.x, p.y, z);
|
||||
};
|
||||
|
||||
auto lines = chull_outer.lines();
|
||||
for(auto& l : lines) {
|
||||
auto s = pool.points.size();
|
||||
|
||||
pool.points.emplace_back(fp(l.a, -HEIGHT));
|
||||
pool.points.emplace_back(fp(l.b, -HEIGHT));
|
||||
pool.points.emplace_back(fp(l.a, 0));
|
||||
pool.points.emplace_back(fp(l.b, 0));
|
||||
|
||||
pool.indices.emplace_back(s, s + 3, s + 1);
|
||||
pool.indices.emplace_back(s, s + 2, s + 3);
|
||||
}
|
||||
|
||||
pool.merge(top_plate);
|
||||
pool.merge(bottom_plate);
|
||||
pool.merge(innerbed);
|
||||
|
||||
out = mesh(pool);
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue