Merge branch 'master' of https://github.com/prusa3d/PrusaSlicer into et_plater_thumbnail
This commit is contained in:
Enrico Turri
commit
2896e12a46
21 changed files with 867 additions and 447 deletions
|
|
@ -107,8 +107,7 @@ void AddOuterPolyNodeToExPolygons(ClipperLib::PolyNode& polynode, ExPolygons* ex
|
|||
}
|
||||
}
|
||||
|
||||
ExPolygons
|
||||
PolyTreeToExPolygons(ClipperLib::PolyTree& polytree)
|
||||
ExPolygons PolyTreeToExPolygons(ClipperLib::PolyTree& polytree)
|
||||
{
|
||||
ExPolygons retval;
|
||||
for (int i = 0; i < polytree.ChildCount(); ++i)
|
||||
|
|
@ -151,8 +150,7 @@ Slic3r::Polylines ClipperPaths_to_Slic3rPolylines(const ClipperLib::Paths &input
|
|||
return retval;
|
||||
}
|
||||
|
||||
ExPolygons
|
||||
ClipperPaths_to_Slic3rExPolygons(const ClipperLib::Paths &input)
|
||||
ExPolygons ClipperPaths_to_Slic3rExPolygons(const ClipperLib::Paths &input)
|
||||
{
|
||||
// init Clipper
|
||||
ClipperLib::Clipper clipper;
|
||||
|
|
@ -167,8 +165,7 @@ ClipperPaths_to_Slic3rExPolygons(const ClipperLib::Paths &input)
|
|||
return PolyTreeToExPolygons(polytree);
|
||||
}
|
||||
|
||||
ClipperLib::Path
|
||||
Slic3rMultiPoint_to_ClipperPath(const MultiPoint &input)
|
||||
ClipperLib::Path Slic3rMultiPoint_to_ClipperPath(const MultiPoint &input)
|
||||
{
|
||||
ClipperLib::Path retval;
|
||||
for (Points::const_iterator pit = input.points.begin(); pit != input.points.end(); ++pit)
|
||||
|
|
@ -176,8 +173,7 @@ Slic3rMultiPoint_to_ClipperPath(const MultiPoint &input)
|
|||
return retval;
|
||||
}
|
||||
|
||||
ClipperLib::Path
|
||||
Slic3rMultiPoint_to_ClipperPath_reversed(const Slic3r::MultiPoint &input)
|
||||
ClipperLib::Path Slic3rMultiPoint_to_ClipperPath_reversed(const Slic3r::MultiPoint &input)
|
||||
{
|
||||
ClipperLib::Path output;
|
||||
output.reserve(input.points.size());
|
||||
|
|
@ -521,7 +517,7 @@ T _clipper_do(const ClipperLib::ClipType clipType,
|
|||
|
||||
// Fix of #117: A large fractal pyramid takes ages to slice
|
||||
// The Clipper library has difficulties processing overlapping polygons.
|
||||
// Namely, the function Clipper::JoinCommonEdges() has potentially a terrible time complexity if the output
|
||||
// Namely, the function ClipperLib::JoinCommonEdges() has potentially a terrible time complexity if the output
|
||||
// of the operation is of the PolyTree type.
|
||||
// This function implmenets a following workaround:
|
||||
// 1) Peform the Clipper operation with the output to Paths. This method handles overlaps in a reasonable time.
|
||||
|
|
@ -918,4 +914,304 @@ Polygons top_level_islands(const Slic3r::Polygons &polygons)
|
|||
return out;
|
||||
}
|
||||
|
||||
// Outer offset shall not split the input contour into multiples. It is expected, that the solution will be non empty and it will contain just a single polygon.
|
||||
ClipperLib::Paths fix_after_outer_offset(const ClipperLib::Path &input, ClipperLib::PolyFillType filltype, bool reverse_result)
|
||||
{
|
||||
ClipperLib::Paths solution;
|
||||
if (! input.empty()) {
|
||||
ClipperLib::Clipper clipper;
|
||||
clipper.AddPath(input, ClipperLib::ptSubject, true);
|
||||
clipper.ReverseSolution(reverse_result);
|
||||
clipper.Execute(ClipperLib::ctUnion, solution, filltype, filltype);
|
||||
}
|
||||
return solution;
|
||||
}
|
||||
|
||||
// Inner offset may split the source contour into multiple contours, but one shall not be inside the other.
|
||||
ClipperLib::Paths fix_after_inner_offset(const ClipperLib::Path &input, ClipperLib::PolyFillType filltype, bool reverse_result)
|
||||
{
|
||||
ClipperLib::Paths solution;
|
||||
if (! input.empty()) {
|
||||
ClipperLib::Clipper clipper;
|
||||
clipper.AddPath(input, ClipperLib::ptSubject, true);
|
||||
ClipperLib::IntRect r = clipper.GetBounds();
|
||||
r.left -= 10; r.top -= 10; r.right += 10; r.bottom += 10;
|
||||
if (filltype == ClipperLib::pftPositive)
|
||||
clipper.AddPath({ ClipperLib::IntPoint(r.left, r.bottom), ClipperLib::IntPoint(r.left, r.top), ClipperLib::IntPoint(r.right, r.top), ClipperLib::IntPoint(r.right, r.bottom) }, ClipperLib::ptSubject, true);
|
||||
else
|
||||
clipper.AddPath({ ClipperLib::IntPoint(r.left, r.bottom), ClipperLib::IntPoint(r.right, r.bottom), ClipperLib::IntPoint(r.right, r.top), ClipperLib::IntPoint(r.left, r.top) }, ClipperLib::ptSubject, true);
|
||||
clipper.ReverseSolution(reverse_result);
|
||||
clipper.Execute(ClipperLib::ctUnion, solution, filltype, filltype);
|
||||
if (! solution.empty())
|
||||
solution.erase(solution.begin());
|
||||
}
|
||||
return solution;
|
||||
}
|
||||
|
||||
ClipperLib::Path mittered_offset_path_scaled(const Points &contour, const std::vector<float> &deltas, double miter_limit)
|
||||
{
|
||||
assert(contour.size() == deltas.size());
|
||||
#ifndef NDEBUG
|
||||
// Verify that the deltas are either all positive, or all negative.
|
||||
bool positive = false;
|
||||
bool negative = false;
|
||||
for (float delta : deltas)
|
||||
if (delta < 0.f)
|
||||
negative = true;
|
||||
else if (delta > 0.f)
|
||||
positive = true;
|
||||
assert(! (negative && positive));
|
||||
#endif /* NDEBUG */
|
||||
|
||||
ClipperLib::Path out;
|
||||
|
||||
if (deltas.size() > 2)
|
||||
{
|
||||
out.reserve(contour.size() * 2);
|
||||
|
||||
// Clamp miter limit to 2.
|
||||
miter_limit = (miter_limit > 2.) ? 2. / (miter_limit * miter_limit) : 0.5;
|
||||
|
||||
// perpenduclar vector
|
||||
auto perp = [](const Vec2d &v) -> Vec2d { return Vec2d(v.y(), - v.x()); };
|
||||
|
||||
// Add a new point to the output, scale by CLIPPER_OFFSET_SCALE and round to ClipperLib::cInt.
|
||||
auto add_offset_point = [&out](Vec2d pt) {
|
||||
pt *= double(CLIPPER_OFFSET_SCALE);
|
||||
pt += Vec2d(0.5 - (pt.x() < 0), 0.5 - (pt.y() < 0));
|
||||
out.emplace_back(ClipperLib::cInt(pt.x()), ClipperLib::cInt(pt.y()));
|
||||
};
|
||||
|
||||
// Minimum edge length, squared.
|
||||
double lmin = *std::max_element(deltas.begin(), deltas.end()) * CLIPPER_OFFSET_SHORTEST_EDGE_FACTOR;
|
||||
double l2min = lmin * lmin;
|
||||
// Minimum angle to consider two edges to be parallel.
|
||||
double sin_min_parallel = EPSILON + 1. / double(CLIPPER_OFFSET_SCALE);
|
||||
|
||||
// Find the last point further from pt by l2min.
|
||||
Vec2d pt = contour.front().cast<double>();
|
||||
size_t iprev = contour.size() - 1;
|
||||
Vec2d ptprev;
|
||||
for (; iprev > 0; -- iprev) {
|
||||
ptprev = contour[iprev].cast<double>();
|
||||
if ((ptprev - pt).squaredNorm() > l2min)
|
||||
break;
|
||||
}
|
||||
|
||||
if (iprev != 0) {
|
||||
size_t ilast = iprev;
|
||||
// Normal to the (pt - ptprev) segment.
|
||||
Vec2d nprev = perp(pt - ptprev).normalized();
|
||||
for (size_t i = 0; ; ) {
|
||||
// Find the next point further from pt by l2min.
|
||||
size_t j = i + 1;
|
||||
Vec2d ptnext;
|
||||
for (; j <= ilast; ++ j) {
|
||||
ptnext = contour[j].cast<double>();
|
||||
double l2 = (ptnext - pt).squaredNorm();
|
||||
if (l2 > l2min)
|
||||
break;
|
||||
}
|
||||
if (j > ilast)
|
||||
ptnext = contour.front().cast<double>();
|
||||
|
||||
// Normal to the (ptnext - pt) segment.
|
||||
Vec2d nnext = perp(ptnext - pt).normalized();
|
||||
|
||||
double delta = deltas[i];
|
||||
double sin_a = clamp(-1., 1., cross2(nprev, nnext));
|
||||
double convex = sin_a * delta;
|
||||
if (convex <= - sin_min_parallel) {
|
||||
// Concave corner.
|
||||
add_offset_point(pt + nprev * delta);
|
||||
add_offset_point(pt);
|
||||
add_offset_point(pt + nnext * delta);
|
||||
} else if (convex < sin_min_parallel) {
|
||||
// Nearly parallel.
|
||||
add_offset_point((nprev.dot(nnext) > 0.) ? (pt + nprev * delta) : pt);
|
||||
} else {
|
||||
// Convex corner
|
||||
double dot = nprev.dot(nnext);
|
||||
double r = 1. + dot;
|
||||
if (r >= miter_limit)
|
||||
add_offset_point(pt + (nprev + nnext) * (delta / r));
|
||||
else {
|
||||
double dx = std::tan(std::atan2(sin_a, dot) / 4.);
|
||||
Vec2d newpt1 = pt + (nprev - perp(nprev) * dx) * delta;
|
||||
Vec2d newpt2 = pt + (nnext + perp(nnext) * dx) * delta;
|
||||
#ifndef NDEBUG
|
||||
Vec2d vedge = 0.5 * (newpt1 + newpt2) - pt;
|
||||
double dist_norm = vedge.norm();
|
||||
assert(std::abs(dist_norm - delta) < EPSILON);
|
||||
#endif /* NDEBUG */
|
||||
add_offset_point(newpt1);
|
||||
add_offset_point(newpt2);
|
||||
}
|
||||
}
|
||||
|
||||
if (i == ilast)
|
||||
break;
|
||||
|
||||
ptprev = pt;
|
||||
nprev = nnext;
|
||||
pt = ptnext;
|
||||
i = j;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return out;
|
||||
}
|
||||
|
||||
Polygons variable_offset_inner(const ExPolygon &expoly, const std::vector<std::vector<float>> &deltas, double miter_limit)
|
||||
{
|
||||
#ifndef NDEBUG
|
||||
// Verify that the deltas are all non positive.
|
||||
for (const std::vector<float> &ds : deltas)
|
||||
for (float delta : ds)
|
||||
assert(delta <= 0.);
|
||||
assert(expoly.holes.size() + 1 == deltas.size());
|
||||
#endif /* NDEBUG */
|
||||
|
||||
// 1) Offset the outer contour.
|
||||
ClipperLib::Paths contours = fix_after_inner_offset(mittered_offset_path_scaled(expoly.contour.points, deltas.front(), miter_limit), ClipperLib::pftNegative, true);
|
||||
|
||||
// 2) Offset the holes one by one, collect the results.
|
||||
ClipperLib::Paths holes;
|
||||
holes.reserve(expoly.holes.size());
|
||||
for (const Polygon& hole : expoly.holes)
|
||||
append(holes, fix_after_outer_offset(mittered_offset_path_scaled(hole, deltas[1 + &hole - expoly.holes.data()], miter_limit), ClipperLib::pftPositive, false));
|
||||
|
||||
// 3) Subtract holes from the contours.
|
||||
ClipperLib::Paths output;
|
||||
if (holes.empty())
|
||||
output = std::move(contours);
|
||||
else {
|
||||
ClipperLib::Clipper clipper;
|
||||
clipper.Clear();
|
||||
clipper.AddPaths(contours, ClipperLib::ptSubject, true);
|
||||
clipper.AddPaths(holes, ClipperLib::ptClip, true);
|
||||
clipper.Execute(ClipperLib::ctDifference, output, ClipperLib::pftNonZero, ClipperLib::pftNonZero);
|
||||
}
|
||||
|
||||
// 4) Unscale the output.
|
||||
unscaleClipperPolygons(output);
|
||||
return ClipperPaths_to_Slic3rPolygons(output);
|
||||
}
|
||||
|
||||
Polygons variable_offset_outer(const ExPolygon &expoly, const std::vector<std::vector<float>> &deltas, double miter_limit)
|
||||
{
|
||||
#ifndef NDEBUG
|
||||
// Verify that the deltas are all non positive.
|
||||
for (const std::vector<float>& ds : deltas)
|
||||
for (float delta : ds)
|
||||
assert(delta >= 0.);
|
||||
assert(expoly.holes.size() + 1 == deltas.size());
|
||||
#endif /* NDEBUG */
|
||||
|
||||
// 1) Offset the outer contour.
|
||||
ClipperLib::Paths contours = fix_after_outer_offset(mittered_offset_path_scaled(expoly.contour.points, deltas.front(), miter_limit), ClipperLib::pftPositive, false);
|
||||
|
||||
// 2) Offset the holes one by one, collect the results.
|
||||
ClipperLib::Paths holes;
|
||||
holes.reserve(expoly.holes.size());
|
||||
for (const Polygon& hole : expoly.holes)
|
||||
append(holes, fix_after_inner_offset(mittered_offset_path_scaled(hole, deltas[1 + &hole - expoly.holes.data()], miter_limit), ClipperLib::pftPositive, true));
|
||||
|
||||
// 3) Subtract holes from the contours.
|
||||
ClipperLib::Paths output;
|
||||
if (holes.empty())
|
||||
output = std::move(contours);
|
||||
else {
|
||||
ClipperLib::Clipper clipper;
|
||||
clipper.Clear();
|
||||
clipper.AddPaths(contours, ClipperLib::ptSubject, true);
|
||||
clipper.AddPaths(holes, ClipperLib::ptClip, true);
|
||||
clipper.Execute(ClipperLib::ctDifference, output, ClipperLib::pftNonZero, ClipperLib::pftNonZero);
|
||||
}
|
||||
|
||||
// 4) Unscale the output.
|
||||
unscaleClipperPolygons(output);
|
||||
return ClipperPaths_to_Slic3rPolygons(output);
|
||||
}
|
||||
|
||||
ExPolygons variable_offset_outer_ex(const ExPolygon &expoly, const std::vector<std::vector<float>> &deltas, double miter_limit)
|
||||
{
|
||||
#ifndef NDEBUG
|
||||
// Verify that the deltas are all non positive.
|
||||
for (const std::vector<float>& ds : deltas)
|
||||
for (float delta : ds)
|
||||
assert(delta >= 0.);
|
||||
assert(expoly.holes.size() + 1 == deltas.size());
|
||||
#endif /* NDEBUG */
|
||||
|
||||
// 1) Offset the outer contour.
|
||||
ClipperLib::Paths contours = fix_after_outer_offset(mittered_offset_path_scaled(expoly.contour.points, deltas.front(), miter_limit), ClipperLib::pftPositive, false);
|
||||
|
||||
// 2) Offset the holes one by one, collect the results.
|
||||
ClipperLib::Paths holes;
|
||||
holes.reserve(expoly.holes.size());
|
||||
for (const Polygon& hole : expoly.holes)
|
||||
append(holes, fix_after_inner_offset(mittered_offset_path_scaled(hole, deltas[1 + &hole - expoly.holes.data()], miter_limit), ClipperLib::pftPositive, true));
|
||||
|
||||
// 3) Subtract holes from the contours.
|
||||
unscaleClipperPolygons(contours);
|
||||
ExPolygons output;
|
||||
if (holes.empty()) {
|
||||
output.reserve(contours.size());
|
||||
for (ClipperLib::Path &path : contours)
|
||||
output.emplace_back(ClipperPath_to_Slic3rPolygon(path));
|
||||
} else {
|
||||
ClipperLib::Clipper clipper;
|
||||
unscaleClipperPolygons(holes);
|
||||
clipper.AddPaths(contours, ClipperLib::ptSubject, true);
|
||||
clipper.AddPaths(holes, ClipperLib::ptClip, true);
|
||||
ClipperLib::PolyTree polytree;
|
||||
clipper.Execute(ClipperLib::ctDifference, polytree, ClipperLib::pftNonZero, ClipperLib::pftNonZero);
|
||||
output = PolyTreeToExPolygons(polytree);
|
||||
}
|
||||
|
||||
return output;
|
||||
}
|
||||
|
||||
|
||||
ExPolygons variable_offset_inner_ex(const ExPolygon &expoly, const std::vector<std::vector<float>> &deltas, double miter_limit)
|
||||
{
|
||||
#ifndef NDEBUG
|
||||
// Verify that the deltas are all non positive.
|
||||
for (const std::vector<float>& ds : deltas)
|
||||
for (float delta : ds)
|
||||
assert(delta <= 0.);
|
||||
assert(expoly.holes.size() + 1 == deltas.size());
|
||||
#endif /* NDEBUG */
|
||||
|
||||
// 1) Offset the outer contour.
|
||||
ClipperLib::Paths contours = fix_after_inner_offset(mittered_offset_path_scaled(expoly.contour.points, deltas.front(), miter_limit), ClipperLib::pftNegative, false);
|
||||
|
||||
// 2) Offset the holes one by one, collect the results.
|
||||
ClipperLib::Paths holes;
|
||||
holes.reserve(expoly.holes.size());
|
||||
for (const Polygon& hole : expoly.holes)
|
||||
append(holes, fix_after_outer_offset(mittered_offset_path_scaled(hole, deltas[1 + &hole - expoly.holes.data()], miter_limit), ClipperLib::pftNegative, true));
|
||||
|
||||
// 3) Subtract holes from the contours.
|
||||
unscaleClipperPolygons(contours);
|
||||
ExPolygons output;
|
||||
if (holes.empty()) {
|
||||
output.reserve(contours.size());
|
||||
for (ClipperLib::Path &path : contours)
|
||||
output.emplace_back(ClipperPath_to_Slic3rPolygon(path));
|
||||
} else {
|
||||
ClipperLib::Clipper clipper;
|
||||
unscaleClipperPolygons(holes);
|
||||
clipper.AddPaths(contours, ClipperLib::ptSubject, true);
|
||||
clipper.AddPaths(holes, ClipperLib::ptClip, true);
|
||||
ClipperLib::PolyTree polytree;
|
||||
clipper.Execute(ClipperLib::ctDifference, polytree, ClipperLib::pftNonZero, ClipperLib::pftNonZero);
|
||||
output = PolyTreeToExPolygons(polytree);
|
||||
}
|
||||
|
||||
return output;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
|||
|
|
@ -238,6 +238,11 @@ void safety_offset(ClipperLib::Paths* paths);
|
|||
|
||||
Polygons top_level_islands(const Slic3r::Polygons &polygons);
|
||||
|
||||
Polygons variable_offset_inner(const ExPolygon &expoly, const std::vector<std::vector<float>> &deltas, double miter_limit = 2.);
|
||||
Polygons variable_offset_outer(const ExPolygon &expoly, const std::vector<std::vector<float>> &deltas, double miter_limit = 2.);
|
||||
ExPolygons variable_offset_outer_ex(const ExPolygon &expoly, const std::vector<std::vector<float>> &deltas, double miter_limit = 2.);
|
||||
ExPolygons variable_offset_inner_ex(const ExPolygon &expoly, const std::vector<std::vector<float>> &deltas, double miter_limit = 2.);
|
||||
|
||||
}
|
||||
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -28,6 +28,8 @@ public:
|
|||
explicit ExPolygon(Polygon &&contour, Polygon &&hole) : contour(std::move(contour)) { holes.emplace_back(std::move(hole)); }
|
||||
explicit ExPolygon(const Points &contour, const Points &hole) : contour(contour) { holes.emplace_back(hole); }
|
||||
explicit ExPolygon(Points &&contour, Polygon &&hole) : contour(std::move(contour)) { holes.emplace_back(std::move(hole)); }
|
||||
ExPolygon(std::initializer_list<Point> contour) : contour(contour) {}
|
||||
ExPolygon(std::initializer_list<Point> contour, std::initializer_list<Point> hole) : contour(contour), holes({ hole }) {}
|
||||
|
||||
ExPolygon& operator=(const ExPolygon &other) { contour = other.contour; holes = other.holes; return *this; }
|
||||
ExPolygon& operator=(ExPolygon &&other) { contour = std::move(other.contour); holes = std::move(other.holes); return *this; }
|
||||
|
|
@ -77,6 +79,9 @@ public:
|
|||
Lines lines() const;
|
||||
};
|
||||
|
||||
inline bool operator==(const ExPolygon &lhs, const ExPolygon &rhs) { return lhs.contour == rhs.contour && lhs.holes == rhs.holes; }
|
||||
inline bool operator!=(const ExPolygon &lhs, const ExPolygon &rhs) { return lhs.contour != rhs.contour || lhs.holes != rhs.holes; }
|
||||
|
||||
// Count a nuber of polygons stored inside the vector of expolygons.
|
||||
// Useful for allocating space for polygons when converting expolygons to polygons.
|
||||
inline size_t number_polygons(const ExPolygons &expolys)
|
||||
|
|
@ -301,6 +306,15 @@ inline bool expolygons_contain(ExPolygons &expolys, const Point &pt)
|
|||
return false;
|
||||
}
|
||||
|
||||
inline ExPolygons expolygons_simplify(const ExPolygons &expolys, double tolerance)
|
||||
{
|
||||
ExPolygons out;
|
||||
out.reserve(expolys.size());
|
||||
for (const ExPolygon &exp : expolys)
|
||||
exp.simplify(tolerance, &out);
|
||||
return out;
|
||||
}
|
||||
|
||||
extern BoundingBox get_extents(const ExPolygon &expolygon);
|
||||
extern BoundingBox get_extents(const ExPolygons &expolygons);
|
||||
extern BoundingBox get_extents_rotated(const ExPolygon &poly, double angle);
|
||||
|
|
|
|||
|
|
@ -1,8 +1,8 @@
|
|||
#ifndef slic3r_SpiralVase_hpp_
|
||||
#define slic3r_SpiralVase_hpp_
|
||||
|
||||
#include "libslic3r.h"
|
||||
#include "GCodeReader.hpp"
|
||||
#include "../libslic3r.h"
|
||||
#include "../GCodeReader.hpp"
|
||||
|
||||
namespace Slic3r {
|
||||
|
||||
|
|
|
|||
|
|
@ -22,7 +22,8 @@ public:
|
|||
const Point& operator[](Points::size_type idx) const { return this->points[idx]; }
|
||||
|
||||
Polygon() {}
|
||||
explicit Polygon(const Points &points): MultiPoint(points) {}
|
||||
explicit Polygon(const Points &points) : MultiPoint(points) {}
|
||||
Polygon(std::initializer_list<Point> points) : MultiPoint(points) {}
|
||||
Polygon(const Polygon &other) : MultiPoint(other.points) {}
|
||||
Polygon(Polygon &&other) : MultiPoint(std::move(other.points)) {}
|
||||
static Polygon new_scale(const std::vector<Vec2d> &points) {
|
||||
|
|
@ -66,6 +67,10 @@ public:
|
|||
Point point_projection(const Point &point) const;
|
||||
};
|
||||
|
||||
inline bool operator==(const Polygon &lhs, const Polygon &rhs) { return lhs.points == rhs.points; }
|
||||
inline bool operator!=(const Polygon &lhs, const Polygon &rhs) { return lhs.points != rhs.points; }
|
||||
|
||||
|
||||
extern BoundingBox get_extents(const Polygon &poly);
|
||||
extern BoundingBox get_extents(const Polygons &polygons);
|
||||
extern BoundingBox get_extents_rotated(const Polygon &poly, double angle);
|
||||
|
|
@ -102,6 +107,15 @@ inline void polygons_append(Polygons &dst, Polygons &&src)
|
|||
}
|
||||
}
|
||||
|
||||
inline Polygons polygons_simplify(const Polygons &polys, double tolerance)
|
||||
{
|
||||
Polygons out;
|
||||
out.reserve(polys.size());
|
||||
for (const Polygon &p : polys)
|
||||
polygons_append(out, p.simplify(tolerance));
|
||||
return out;
|
||||
}
|
||||
|
||||
inline void polygons_rotate(Polygons &polys, double angle)
|
||||
{
|
||||
const double cos_angle = cos(angle);
|
||||
|
|
|
|||
89
t/clipper.t
89
t/clipper.t
|
|
@ -1,89 +0,0 @@
|
|||
use Test::More;
|
||||
use strict;
|
||||
use warnings;
|
||||
|
||||
plan tests => 6;
|
||||
|
||||
BEGIN {
|
||||
use FindBin;
|
||||
use lib "$FindBin::Bin/../lib";
|
||||
use local::lib "$FindBin::Bin/../local-lib";
|
||||
}
|
||||
|
||||
use List::Util qw(sum);
|
||||
use Slic3r;
|
||||
use Slic3r::Geometry::Clipper qw(intersection_ex union_ex diff_ex diff_pl);
|
||||
|
||||
{
|
||||
my $square = [ # ccw
|
||||
[10, 10],
|
||||
[20, 10],
|
||||
[20, 20],
|
||||
[10, 20],
|
||||
];
|
||||
my $hole_in_square = [ # cw
|
||||
[14, 14],
|
||||
[14, 16],
|
||||
[16, 16],
|
||||
[16, 14],
|
||||
];
|
||||
my $square2 = [ # ccw
|
||||
[5, 12],
|
||||
[25, 12],
|
||||
[25, 18],
|
||||
[5, 18],
|
||||
];
|
||||
my $intersection = intersection_ex([ $square, $hole_in_square ], [ $square2 ]);
|
||||
|
||||
is sum(map $_->area, @$intersection), Slic3r::ExPolygon->new(
|
||||
[
|
||||
[20, 18],
|
||||
[10, 18],
|
||||
[10, 12],
|
||||
[20, 12],
|
||||
],
|
||||
[
|
||||
[14, 16],
|
||||
[16, 16],
|
||||
[16, 14],
|
||||
[14, 14],
|
||||
],
|
||||
)->area, 'hole is preserved after intersection';
|
||||
}
|
||||
|
||||
#==========================================================
|
||||
|
||||
{
|
||||
my $contour1 = [ [0,0], [40,0], [40,40], [0,40] ]; # ccw
|
||||
my $contour2 = [ [10,10], [30,10], [30,30], [10,30] ]; # ccw
|
||||
my $hole = [ [15,15], [15,25], [25,25], [25,15] ]; # cw
|
||||
|
||||
my $union = union_ex([ $contour1, $contour2, $hole ]);
|
||||
|
||||
is_deeply [ map $_->pp, @$union ], [[ [ [40,40], [0,40], [0,0], [40,0] ] ]],
|
||||
'union of two ccw and one cw is a contour with no holes';
|
||||
|
||||
my $diff = diff_ex([ $contour1, $contour2 ], [ $hole ]);
|
||||
is sum(map $_->area, @$diff),
|
||||
Slic3r::ExPolygon->new([ [40,40], [0,40], [0,0], [40,0] ], [ [15,25], [25,25], [25,15], [15,15] ])->area,
|
||||
'difference of a cw from two ccw is a contour with one hole';
|
||||
}
|
||||
|
||||
#==========================================================
|
||||
|
||||
{
|
||||
my $square = Slic3r::Polygon->new_scale( # ccw
|
||||
[10, 10],
|
||||
[20, 10],
|
||||
[20, 20],
|
||||
[10, 20],
|
||||
);
|
||||
my $square_pl = $square->split_at_first_point;
|
||||
|
||||
my $res = diff_pl([$square_pl], []);
|
||||
is scalar(@$res), 1, 'no-op diff_pl returns the right number of polylines';
|
||||
isa_ok $res->[0], 'Slic3r::Polyline', 'no-op diff_pl result';
|
||||
is scalar(@{$res->[0]}), scalar(@$square_pl), 'no-op diff_pl returns the unmodified input polyline';
|
||||
}
|
||||
|
||||
__END__
|
||||
|
|
@ -6,6 +6,7 @@ add_executable(${_TEST_NAME}_tests
|
|||
test_extrusion_entity.cpp
|
||||
test_fill.cpp
|
||||
test_flow.cpp
|
||||
test_gcode.cpp
|
||||
test_gcodewriter.cpp
|
||||
test_model.cpp
|
||||
test_print.cpp
|
||||
|
|
|
|||
|
|
@ -95,7 +95,6 @@ SCENARIO(" Bridge flow specifics.", "[Flow]") {
|
|||
SCENARIO("Flow: Flow math for non-bridges", "[Flow]") {
|
||||
GIVEN("Nozzle Diameter of 0.4, a desired width of 1mm and layer height of 0.5") {
|
||||
ConfigOptionFloatOrPercent width(1.0, false);
|
||||
float spacing = 0.4f;
|
||||
float nozzle_diameter = 0.4f;
|
||||
float bridge_flow = 0.f;
|
||||
float layer_height = 0.5f;
|
||||
|
|
@ -119,7 +118,6 @@ SCENARIO("Flow: Flow math for non-bridges", "[Flow]") {
|
|||
}
|
||||
/// Check the min/max
|
||||
GIVEN("Nozzle Diameter of 0.25") {
|
||||
float spacing = 0.4f;
|
||||
float nozzle_diameter = 0.25f;
|
||||
float bridge_flow = 0.f;
|
||||
float layer_height = 0.5f;
|
||||
|
|
@ -161,7 +159,6 @@ SCENARIO("Flow: Flow math for non-bridges", "[Flow]") {
|
|||
SCENARIO("Flow: Flow math for bridges", "[Flow]") {
|
||||
GIVEN("Nozzle Diameter of 0.4, a desired width of 1mm and layer height of 0.5") {
|
||||
auto width = ConfigOptionFloatOrPercent(1.0, false);
|
||||
float spacing = 0.4f;
|
||||
float nozzle_diameter = 0.4f;
|
||||
float bridge_flow = 1.0f;
|
||||
float layer_height = 0.5f;
|
||||
|
|
|
|||
22
tests/fff_print/test_gcode.cpp
Normal file
22
tests/fff_print/test_gcode.cpp
Normal file
|
|
@ -0,0 +1,22 @@
|
|||
#include <catch2/catch.hpp>
|
||||
|
||||
#include <memory>
|
||||
|
||||
#include "libslic3r/GCode.hpp"
|
||||
|
||||
using namespace Slic3r;
|
||||
|
||||
SCENARIO("Origin manipulation", "[GCode]") {
|
||||
Slic3r::GCode gcodegen;
|
||||
WHEN("set_origin to (10,0)") {
|
||||
gcodegen.set_origin(Vec2d(10,0));
|
||||
REQUIRE(gcodegen.origin() == Vec2d(10, 0));
|
||||
}
|
||||
WHEN("set_origin to (10,0) and translate by (5, 5)") {
|
||||
gcodegen.set_origin(Vec2d(10,0));
|
||||
gcodegen.set_origin(gcodegen.origin() + Vec2d(5, 5));
|
||||
THEN("origin returns reference to point") {
|
||||
REQUIRE(gcodegen.origin() == Vec2d(15,5));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -14,8 +14,8 @@ using namespace Slic3r;
|
|||
/// Helper method to find the tool used for the brim (always the first extrusion)
|
||||
static int get_brim_tool(const std::string &gcode)
|
||||
{
|
||||
int brim_tool = -1;
|
||||
int tool = -1;
|
||||
int brim_tool = -1;
|
||||
int tool = -1;
|
||||
GCodeReader parser;
|
||||
parser.parse_buffer(gcode, [&tool, &brim_tool] (Slic3r::GCodeReader &self, const Slic3r::GCodeReader::GCodeLine &line)
|
||||
{
|
||||
|
|
@ -29,7 +29,7 @@ static int get_brim_tool(const std::string &gcode)
|
|||
return brim_tool;
|
||||
}
|
||||
|
||||
TEST_CASE("Skirt height is honored") {
|
||||
TEST_CASE("Skirt height is honored", "[Skirt]") {
|
||||
DynamicPrintConfig config = Slic3r::DynamicPrintConfig::full_print_config();
|
||||
config.set_deserialize({
|
||||
{ "skirts", 1 },
|
||||
|
|
@ -60,7 +60,7 @@ TEST_CASE("Skirt height is honored") {
|
|||
REQUIRE(layers_with_skirt.size() == (size_t)config.opt_int("skirt_height"));
|
||||
}
|
||||
|
||||
SCENARIO("Original Slic3r Skirt/Brim tests", "[!mayfail]") {
|
||||
SCENARIO("Original Slic3r Skirt/Brim tests", "[SkirtBrim]") {
|
||||
GIVEN("A default configuration") {
|
||||
DynamicPrintConfig config = Slic3r::DynamicPrintConfig::full_print_config();
|
||||
config.set_num_extruders(4);
|
||||
|
|
@ -73,7 +73,8 @@ SCENARIO("Original Slic3r Skirt/Brim tests", "[!mayfail]") {
|
|||
{ "first_layer_speed", "100%" },
|
||||
// remove noise from top/solid layers
|
||||
{ "top_solid_layers", 0 },
|
||||
{ "bottom_solid_layers", 1 }
|
||||
{ "bottom_solid_layers", 1 },
|
||||
{ "start_gcode", "T[initial_tool]\n" }
|
||||
});
|
||||
|
||||
WHEN("Brim width is set to 5") {
|
||||
|
|
@ -118,31 +119,39 @@ SCENARIO("Original Slic3r Skirt/Brim tests", "[!mayfail]") {
|
|||
}
|
||||
}
|
||||
|
||||
#if 0
|
||||
// This is a real error! One shall print the brim with the external perimeter extruder!
|
||||
WHEN("Perimeter extruder = 2 and support extruders = 3") {
|
||||
THEN("Brim is printed with the extruder used for the perimeters of first object") {
|
||||
std::string gcode = Slic3r::Test::slice({TestMesh::cube_20x20x20}, {
|
||||
config.set_deserialize({
|
||||
{ "skirts", 0 },
|
||||
{ "brim_width", 5 },
|
||||
{ "perimeter_extruder", 2 },
|
||||
{ "support_material_extruder", 3 }
|
||||
});
|
||||
{ "support_material_extruder", 3 },
|
||||
{ "infill_extruder", 4 }
|
||||
});
|
||||
std::string gcode = Slic3r::Test::slice({TestMesh::cube_20x20x20}, config);
|
||||
int tool = get_brim_tool(gcode);
|
||||
REQUIRE(tool == config.opt_int("perimeter_extruder") - 1);
|
||||
}
|
||||
}
|
||||
WHEN("Perimeter extruder = 2, support extruders = 3, raft is enabled") {
|
||||
THEN("brim is printed with same extruder as skirt") {
|
||||
std::string gcode = Slic3r::Test::slice({TestMesh::cube_20x20x20}, {
|
||||
{ "skirts", 0 },
|
||||
{ "brim_width", 5 },
|
||||
{ "perimeter_extruder", 2 },
|
||||
{ "support_material_extruder", 3 },
|
||||
{ "raft_layers", 1 }
|
||||
});
|
||||
config.set_deserialize({
|
||||
{ "skirts", 0 },
|
||||
{ "brim_width", 5 },
|
||||
{ "perimeter_extruder", 2 },
|
||||
{ "support_material_extruder", 3 },
|
||||
{ "infill_extruder", 4 },
|
||||
{ "raft_layers", 1 }
|
||||
});
|
||||
std::string gcode = Slic3r::Test::slice({TestMesh::cube_20x20x20}, config);
|
||||
int tool = get_brim_tool(gcode);
|
||||
REQUIRE(tool == config.opt_int("support_material_extruder") - 1);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
WHEN("brim width to 1 with layer_width of 0.5") {
|
||||
config.set_deserialize({
|
||||
{ "skirts", 0 },
|
||||
|
|
@ -200,6 +209,7 @@ SCENARIO("Original Slic3r Skirt/Brim tests", "[!mayfail]") {
|
|||
{ "infill_extruder", 3 }, // ensure that a tool command gets emitted.
|
||||
{ "cooling", false }, // to prevent speeds to be altered
|
||||
{ "first_layer_speed", "100%" }, // to prevent speeds to be altered
|
||||
{ "start_gcode", "T[initial_tool]\n" }
|
||||
});
|
||||
|
||||
THEN("overhang generates?") {
|
||||
|
|
@ -209,6 +219,8 @@ SCENARIO("Original Slic3r Skirt/Brim tests", "[!mayfail]") {
|
|||
|
||||
// config.set("support_material", true); // to prevent speeds to be altered
|
||||
|
||||
#if 0
|
||||
// This test is not finished.
|
||||
THEN("skirt length is large enough to contain object with support") {
|
||||
CHECK(config.opt_bool("support_material")); // test is not valid if support material is off
|
||||
std::string gcode = Slic3r::Test::slice({TestMesh::cube_20x20x20}, config);
|
||||
|
|
@ -242,6 +254,8 @@ SCENARIO("Original Slic3r Skirt/Brim tests", "[!mayfail]") {
|
|||
double hull_perimeter = unscale<double>(convex_hull.split_at_first_point().length());
|
||||
REQUIRE(skirt_length > hull_perimeter);
|
||||
}
|
||||
#endif
|
||||
|
||||
}
|
||||
WHEN("Large minimum skirt length is used.") {
|
||||
config.set("min_skirt_length", 20);
|
||||
|
|
|
|||
|
|
@ -2,7 +2,10 @@ get_filename_component(_TEST_NAME ${CMAKE_CURRENT_LIST_DIR} NAME)
|
|||
add_executable(${_TEST_NAME}_tests
|
||||
${_TEST_NAME}_tests.cpp
|
||||
test_3mf.cpp
|
||||
test_clipper_offset.cpp
|
||||
test_clipper_utils.cpp
|
||||
test_config.cpp
|
||||
# test_elephant_foot_compensation.cpp
|
||||
test_geometry.cpp
|
||||
test_polygon.cpp
|
||||
test_stl.cpp
|
||||
|
|
|
|||
214
tests/libslic3r/test_clipper_offset.cpp
Normal file
214
tests/libslic3r/test_clipper_offset.cpp
Normal file
|
|
@ -0,0 +1,214 @@
|
|||
#include <catch2/catch.hpp>
|
||||
|
||||
#include <iostream>
|
||||
#include <boost/filesystem.hpp>
|
||||
|
||||
#include "libslic3r/ClipperUtils.hpp"
|
||||
#include "libslic3r/ExPolygon.hpp"
|
||||
#include "libslic3r/SVG.hpp"
|
||||
|
||||
using namespace Slic3r;
|
||||
|
||||
// #define TESTS_EXPORT_SVGS
|
||||
|
||||
SCENARIO("Constant offset", "[ClipperUtils]") {
|
||||
coord_t s = 1000000;
|
||||
GIVEN("20mm box") {
|
||||
ExPolygon box20mm;
|
||||
box20mm.contour.points = { { 0, 0 }, { 20 * s, 0 }, { 20 * s, 20 * s}, { 0, 20 * s} };
|
||||
std::vector<float> deltas_plus(box20mm.contour.points.size(), 1. * s);
|
||||
std::vector<float> deltas_minus(box20mm.contour.points.size(), - 1. * s);
|
||||
Polygons output;
|
||||
WHEN("Slic3r::offset()") {
|
||||
for (double miter : { 2.0, 1.5, 1.2 }) {
|
||||
DYNAMIC_SECTION("plus 1mm, miter " << miter << "x") {
|
||||
output = Slic3r::offset(box20mm, 1. * s, ClipperLib::jtMiter, miter);
|
||||
#ifdef TESTS_EXPORT_SVGS
|
||||
{
|
||||
SVG svg(debug_out_path("constant_offset_box20mm_plus1mm_miter%lf.svg", miter).c_str(), get_extents(output));
|
||||
svg.draw(box20mm, "blue");
|
||||
svg.draw_outline(output, "black", coord_t(scale_(0.01)));
|
||||
}
|
||||
#endif
|
||||
THEN("Area is 22^2mm2") {
|
||||
REQUIRE(output.size() == 1);
|
||||
REQUIRE(output.front().area() == Approx(22. * 22. * s * s));
|
||||
}
|
||||
}
|
||||
DYNAMIC_SECTION("minus 1mm, miter " << miter << "x") {
|
||||
output = Slic3r::offset(box20mm, - 1. * s, ClipperLib::jtMiter, miter);
|
||||
#ifdef TESTS_EXPORT_SVGS
|
||||
{
|
||||
SVG svg(debug_out_path("constant_offset_box20mm_minus1mm_miter%lf.svg", miter).c_str(), get_extents(output));
|
||||
svg.draw(box20mm, "blue");
|
||||
svg.draw_outline(output, "black", coord_t(scale_(0.01)));
|
||||
}
|
||||
#endif
|
||||
THEN("Area is 18^2mm2") {
|
||||
REQUIRE(output.size() == 1);
|
||||
REQUIRE(output.front().area() == Approx(18. * 18. * s * s));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
WHEN("Slic3r::variable_offset_outer/inner") {
|
||||
for (double miter : { 2.0, 1.5, 1.2 }) {
|
||||
DYNAMIC_SECTION("plus 1mm, miter " << miter << "x") {
|
||||
output = Slic3r::variable_offset_outer(box20mm, { deltas_plus }, miter);
|
||||
#ifdef TESTS_EXPORT_SVGS
|
||||
{
|
||||
SVG svg(debug_out_path("variable_offset_box20mm_plus1mm_miter%lf.svg", miter).c_str(), get_extents(output));
|
||||
svg.draw(box20mm, "blue");
|
||||
svg.draw_outline(output, "black", coord_t(scale_(0.01)));
|
||||
}
|
||||
#endif
|
||||
THEN("Area is 22^2mm2") {
|
||||
REQUIRE(output.size() == 1);
|
||||
REQUIRE(output.front().area() == Approx(22. * 22. * s * s));
|
||||
}
|
||||
}
|
||||
DYNAMIC_SECTION("minus 1mm, miter " << miter << "x") {
|
||||
output = Slic3r::variable_offset_inner(box20mm, { deltas_minus }, miter);
|
||||
#ifdef TESTS_EXPORT_SVGS
|
||||
{
|
||||
SVG svg(debug_out_path("variable_offset_box20mm_minus1mm_miter%lf.svg", miter).c_str(), get_extents(output));
|
||||
svg.draw(box20mm, "blue");
|
||||
svg.draw_outline(output, "black", coord_t(scale_(0.01)));
|
||||
}
|
||||
#endif
|
||||
THEN("Area is 18^2mm2") {
|
||||
REQUIRE(output.size() == 1);
|
||||
REQUIRE(output.front().area() == Approx(18. * 18. * s * s));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
GIVEN("20mm box with 10mm hole") {
|
||||
ExPolygon box20mm;
|
||||
box20mm.contour.points = { { 0, 0 }, { 20 * s, 0 }, { 20 * s, 20 * s}, { 0, 20 * s} };
|
||||
box20mm.holes.emplace_back(Slic3r::Polygon({ { 5 * s, 5 * s }, { 5 * s, 15 * s}, { 15 * s, 15 * s}, { 15 * s, 5 * s } }));
|
||||
std::vector<float> deltas_plus(box20mm.contour.points.size(), 1. * s);
|
||||
std::vector<float> deltas_minus(box20mm.contour.points.size(), -1. * s);
|
||||
ExPolygons output;
|
||||
SECTION("Slic3r::offset()") {
|
||||
for (double miter : { 2.0, 1.5, 1.2 }) {
|
||||
DYNAMIC_SECTION("miter " << miter << "x") {
|
||||
WHEN("plus 1mm") {
|
||||
output = Slic3r::offset_ex(box20mm, 1. * s, ClipperLib::jtMiter, miter);
|
||||
#ifdef TESTS_EXPORT_SVGS
|
||||
{
|
||||
SVG svg(debug_out_path("constant_offset_box20mm_10mm_hole_plus1mm_miter%lf.svg", miter).c_str(), get_extents(output));
|
||||
svg.draw(box20mm, "blue");
|
||||
svg.draw_outline(to_polygons(output), "black", coord_t(scale_(0.01)));
|
||||
}
|
||||
#endif
|
||||
THEN("Area is 22^2-8^2 mm2") {
|
||||
REQUIRE(output.size() == 1);
|
||||
REQUIRE(output.front().area() == Approx((22. * 22. - 8. * 8.) * s * s));
|
||||
}
|
||||
}
|
||||
WHEN("minus 1mm") {
|
||||
output = Slic3r::offset_ex(box20mm, - 1. * s, ClipperLib::jtMiter, miter);
|
||||
#ifdef TESTS_EXPORT_SVGS
|
||||
{
|
||||
SVG svg(debug_out_path("constant_offset_box20mm_10mm_hole_minus1mm_miter%lf.svg", miter).c_str(), get_extents(output));
|
||||
svg.draw(box20mm, "blue");
|
||||
svg.draw_outline(to_polygons(output), "black", coord_t(scale_(0.01)));
|
||||
}
|
||||
#endif
|
||||
THEN("Area is 18^2-12^2 mm2") {
|
||||
REQUIRE(output.size() == 1);
|
||||
REQUIRE(output.front().area() == Approx((18. * 18. - 12. * 12.) * s * s));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
SECTION("Slic3r::variable_offset_outer()") {
|
||||
for (double miter : { 2.0, 1.5, 1.2 }) {
|
||||
DYNAMIC_SECTION("miter " << miter << "x") {
|
||||
WHEN("plus 1mm") {
|
||||
output = Slic3r::variable_offset_outer_ex(box20mm, { deltas_plus, deltas_plus }, miter);
|
||||
#ifdef TESTS_EXPORT_SVGS
|
||||
{
|
||||
SVG svg(debug_out_path("variable_offset_box20mm_10mm_hole_plus1mm_miter%lf.svg", miter).c_str(), get_extents(output));
|
||||
svg.draw(box20mm, "blue");
|
||||
svg.draw_outline(to_polygons(output), "black", coord_t(scale_(0.01)));
|
||||
}
|
||||
#endif
|
||||
THEN("Area is 22^2-8^2 mm2") {
|
||||
REQUIRE(output.size() == 1);
|
||||
REQUIRE(output.front().area() == Approx((22. * 22. - 8. * 8.) * s * s));
|
||||
}
|
||||
}
|
||||
WHEN("minus 1mm") {
|
||||
output = Slic3r::variable_offset_inner_ex(box20mm, { deltas_minus, deltas_minus }, miter);
|
||||
#ifdef TESTS_EXPORT_SVGS
|
||||
{
|
||||
SVG svg(debug_out_path("variable_offset_box20mm_10mm_hole_minus1mm_miter%lf.svg", miter).c_str(), get_extents(output));
|
||||
svg.draw(box20mm, "blue");
|
||||
svg.draw_outline(to_polygons(output), "black", coord_t(scale_(0.01)));
|
||||
}
|
||||
#endif
|
||||
THEN("Area is 18^2-12^2 mm2") {
|
||||
REQUIRE(output.size() == 1);
|
||||
REQUIRE(output.front().area() == Approx((18. * 18. - 12. * 12.) * s * s));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
GIVEN("20mm right angle triangle") {
|
||||
ExPolygon triangle20mm;
|
||||
triangle20mm.contour.points = { { 0, 0 }, { 20 * s, 0 }, { 0, 20 * s} };
|
||||
Polygons output;
|
||||
double offset = 1.;
|
||||
// Angle of the sharp corner bisector.
|
||||
double angle_bisector = M_PI / 8.;
|
||||
// Area tapered by mitering one sharp corner.
|
||||
double area_tapered = pow(offset * (1. / sin(angle_bisector) - 1.), 2.) * tan(angle_bisector);
|
||||
double l_triangle_side_offsetted = 20. + offset * (1. + 1. / tan(angle_bisector));
|
||||
double area_offsetted = (0.5 * l_triangle_side_offsetted * l_triangle_side_offsetted - 2. * area_tapered) * s * s;
|
||||
SECTION("Slic3r::offset()") {
|
||||
for (double miter : { 2.0, 1.5, 1.2 }) {
|
||||
DYNAMIC_SECTION("Outer offset 1mm, miter " << miter << "x") {
|
||||
output = Slic3r::offset(triangle20mm, offset * s, ClipperLib::jtMiter, 2.0);
|
||||
#ifdef TESTS_EXPORT_SVGS
|
||||
{
|
||||
SVG svg(debug_out_path("constant_offset_triangle20mm_plus1mm_miter%lf.svg", miter).c_str(), get_extents(output));
|
||||
svg.draw(triangle20mm, "blue");
|
||||
svg.draw_outline(output, "black", coord_t(scale_(0.01)));
|
||||
}
|
||||
#endif
|
||||
THEN("Area matches") {
|
||||
REQUIRE(output.size() == 1);
|
||||
REQUIRE(output.front().area() == Approx(area_offsetted));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
SECTION("Slic3r::variable_offset_outer()") {
|
||||
std::vector<float> deltas(triangle20mm.contour.points.size(), 1. * s);
|
||||
for (double miter : { 2.0, 1.5, 1.2 }) {
|
||||
DYNAMIC_SECTION("Outer offset 1mm, miter " << miter << "x") {
|
||||
output = Slic3r::variable_offset_outer(triangle20mm, { deltas }, 2.0);
|
||||
#ifdef TESTS_EXPORT_SVGS
|
||||
{
|
||||
SVG svg(debug_out_path("variable_offset_triangle20mm_plus1mm_miter%lf.svg", miter).c_str(), get_extents(output));
|
||||
svg.draw(triangle20mm, "blue");
|
||||
svg.draw_outline(output, "black", coord_t(scale_(0.01)));
|
||||
}
|
||||
#endif
|
||||
THEN("Area matches") {
|
||||
REQUIRE(output.size() == 1);
|
||||
REQUIRE(output.front().area() == Approx(area_offsetted));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
225
tests/libslic3r/test_clipper_utils.cpp
Normal file
225
tests/libslic3r/test_clipper_utils.cpp
Normal file
|
|
@ -0,0 +1,225 @@
|
|||
#include <catch2/catch.hpp>
|
||||
|
||||
#include <iostream>
|
||||
#include <boost/filesystem.hpp>
|
||||
|
||||
#include "libslic3r/ClipperUtils.hpp"
|
||||
#include "libslic3r/ExPolygon.hpp"
|
||||
#include "libslic3r/SVG.hpp"
|
||||
|
||||
using namespace Slic3r;
|
||||
|
||||
SCENARIO("Various Clipper operations - xs/t/11_clipper.t", "[ClipperUtils]") {
|
||||
// CCW oriented contour
|
||||
Slic3r::Polygon square{ { 200, 100 }, {200, 200}, {100, 200}, {100, 100} };
|
||||
// CW oriented contour
|
||||
Slic3r::Polygon hole_in_square{ { 160, 140 }, { 140, 140 }, { 140, 160 }, { 160, 160 } };
|
||||
Slic3r::ExPolygon square_with_hole(square, hole_in_square);
|
||||
GIVEN("square_with_hole") {
|
||||
WHEN("offset") {
|
||||
Polygons result = Slic3r::offset(square_with_hole, 5.f);
|
||||
THEN("offset matches") {
|
||||
REQUIRE(result == Polygons {
|
||||
{ { 205, 205 }, { 95, 205 }, { 95, 95 }, { 205, 95 }, },
|
||||
{ { 145, 145 }, { 145, 155 }, { 155, 155 }, { 155, 145 } } });
|
||||
}
|
||||
}
|
||||
WHEN("offset_ex") {
|
||||
ExPolygons result = Slic3r::offset_ex(square_with_hole, 5.f);
|
||||
THEN("offset matches") {
|
||||
REQUIRE(result == ExPolygons { {
|
||||
{ { 205, 205 }, { 95, 205 }, { 95, 95 }, { 205, 95 }, },
|
||||
{ { 145, 145 }, { 145, 155 }, { 155, 155 }, { 155, 145 } } } } );
|
||||
}
|
||||
}
|
||||
WHEN("offset2_ex") {
|
||||
ExPolygons result = Slic3r::offset2_ex(square_with_hole, 5.f, -2.f);
|
||||
THEN("offset matches") {
|
||||
REQUIRE(result == ExPolygons { {
|
||||
{ { 203, 203 }, { 97, 203 }, { 97, 97 }, { 203, 97 } },
|
||||
{ { 143, 143 }, { 143, 157 }, { 157, 157 }, { 157, 143 } } } } );
|
||||
}
|
||||
}
|
||||
}
|
||||
GIVEN("square_with_hole 2") {
|
||||
Slic3r::ExPolygon square_with_hole(
|
||||
{ { 20000000, 20000000 }, { 0, 20000000 }, { 0, 0 }, { 20000000, 0 } },
|
||||
{ { 5000000, 15000000 }, { 15000000, 15000000 }, { 15000000, 5000000 }, { 5000000, 5000000 } });
|
||||
WHEN("offset2_ex") {
|
||||
Slic3r::ExPolygons result = Slic3r::offset2_ex(ExPolygons { square_with_hole }, -1.f, 1.f);
|
||||
THEN("offset matches") {
|
||||
REQUIRE(result.size() == 1);
|
||||
REQUIRE(square_with_hole.area() == result.front().area());
|
||||
}
|
||||
}
|
||||
}
|
||||
GIVEN("square and hole") {
|
||||
WHEN("diff_ex") {
|
||||
ExPolygons result = Slic3r::diff_ex({ square }, { hole_in_square });
|
||||
THEN("hole is created") {
|
||||
REQUIRE(result.size() == 1);
|
||||
REQUIRE(square_with_hole.area() == result.front().area());
|
||||
}
|
||||
}
|
||||
}
|
||||
GIVEN("polyline") {
|
||||
Polyline polyline { { 50, 150 }, { 300, 150 } };
|
||||
WHEN("intersection_pl") {
|
||||
Polylines result = Slic3r::intersection_pl({ polyline }, { square, hole_in_square });
|
||||
THEN("correct number of result lines") {
|
||||
REQUIRE(result.size() == 2);
|
||||
}
|
||||
THEN("result lines have correct length") {
|
||||
// results are in no particular order
|
||||
REQUIRE(result[0].length() == 40);
|
||||
REQUIRE(result[1].length() == 40);
|
||||
}
|
||||
}
|
||||
WHEN("diff_pl") {
|
||||
Polylines result = Slic3r::diff_pl({ polyline }, { square, hole_in_square });
|
||||
THEN("correct number of result lines") {
|
||||
REQUIRE(result.size() == 3);
|
||||
}
|
||||
// results are in no particular order
|
||||
THEN("the left result line has correct length") {
|
||||
REQUIRE(std::count_if(result.begin(), result.end(), [](const Polyline &pl) { return pl.length() == 50; }) == 1);
|
||||
}
|
||||
THEN("the right result line has correct length") {
|
||||
REQUIRE(std::count_if(result.begin(), result.end(), [](const Polyline &pl) { return pl.length() == 100; }) == 1);
|
||||
}
|
||||
THEN("the central result line has correct length") {
|
||||
REQUIRE(std::count_if(result.begin(), result.end(), [](const Polyline &pl) { return pl.length() == 20; }) == 1);
|
||||
}
|
||||
}
|
||||
}
|
||||
GIVEN("Clipper bug #96 / Slic3r issue #2028") {
|
||||
Slic3r::Polyline subject{
|
||||
{ 44735000, 31936670 }, { 55270000, 31936670 }, { 55270000, 25270000 }, { 74730000, 25270000 }, { 74730000, 44730000 }, { 68063296, 44730000 }, { 68063296, 55270000 }, { 74730000, 55270000 },
|
||||
{ 74730000, 74730000 }, { 55270000, 74730000 }, { 55270000, 68063296 }, { 44730000, 68063296 }, { 44730000, 74730000 }, { 25270000, 74730000 }, { 25270000, 55270000 }, { 31936670, 55270000 },
|
||||
{ 31936670, 44730000 }, { 25270000, 44730000 }, { 25270000, 25270000 }, { 44730000, 25270000 }, { 44730000, 31936670 } };
|
||||
Slic3r::Polygon clip { {75200000, 45200000}, {54800000, 45200000}, {54800000, 24800000}, {75200000, 24800000} };
|
||||
Slic3r::Polylines result = Slic3r::intersection_pl({ subject }, { clip });
|
||||
THEN("intersection_pl - result is not empty") {
|
||||
REQUIRE(result.size() == 1);
|
||||
}
|
||||
}
|
||||
GIVEN("Clipper bug #122") {
|
||||
Slic3r::Polyline subject { { 1975, 1975 }, { 25, 1975 }, { 25, 25 }, { 1975, 25 }, { 1975, 1975 } };
|
||||
Slic3r::Polygons clip { { { 2025, 2025 }, { -25, 2025 } , { -25, -25 }, { 2025, -25 } },
|
||||
{ { 525, 525 }, { 525, 1475 }, { 1475, 1475 }, { 1475, 525 } } };
|
||||
Slic3r::Polylines result = Slic3r::intersection_pl({ subject }, clip);
|
||||
THEN("intersection_pl - result is not empty") {
|
||||
REQUIRE(result.size() == 1);
|
||||
REQUIRE(result.front().points.size() == 5);
|
||||
}
|
||||
}
|
||||
GIVEN("Clipper bug #126") {
|
||||
Slic3r::Polyline subject { { 200000, 19799999 }, { 200000, 200000 }, { 24304692, 200000 }, { 15102879, 17506106 }, { 13883200, 19799999 }, { 200000, 19799999 } };
|
||||
Slic3r::Polygon clip { { 15257205, 18493894 }, { 14350057, 20200000 }, { -200000, 20200000 }, { -200000, -200000 }, { 25196917, -200000 } };
|
||||
Slic3r::Polylines result = Slic3r::intersection_pl({ subject }, { clip });
|
||||
THEN("intersection_pl - result is not empty") {
|
||||
REQUIRE(result.size() == 1);
|
||||
}
|
||||
THEN("intersection_pl - result has same length as subject polyline") {
|
||||
REQUIRE(result.front().length() == Approx(subject.length()));
|
||||
}
|
||||
}
|
||||
|
||||
#if 0
|
||||
{
|
||||
# Clipper does not preserve polyline orientation
|
||||
my $polyline = Slic3r::Polyline->new([50, 150], [300, 150]);
|
||||
my $result = Slic3r::Geometry::Clipper::intersection_pl([$polyline], [$square]);
|
||||
is scalar(@$result), 1, 'intersection_pl - correct number of result lines';
|
||||
is_deeply $result->[0]->pp, [[100, 150], [200, 150]], 'clipped line orientation is preserved';
|
||||
}
|
||||
{
|
||||
# Clipper does not preserve polyline orientation
|
||||
my $polyline = Slic3r::Polyline->new([300, 150], [50, 150]);
|
||||
my $result = Slic3r::Geometry::Clipper::intersection_pl([$polyline], [$square]);
|
||||
is scalar(@$result), 1, 'intersection_pl - correct number of result lines';
|
||||
is_deeply $result->[0]->pp, [[200, 150], [100, 150]], 'clipped line orientation is preserved';
|
||||
}
|
||||
{
|
||||
# Disabled until Clipper bug #127 is fixed
|
||||
my $subject = [
|
||||
Slic3r::Polyline->new([-90000000, -100000000], [-90000000, 100000000]), # vertical
|
||||
Slic3r::Polyline->new([-100000000, -10000000], [100000000, -10000000]), # horizontal
|
||||
Slic3r::Polyline->new([-100000000, 0], [100000000, 0]), # horizontal
|
||||
Slic3r::Polyline->new([-100000000, 10000000], [100000000, 10000000]), # horizontal
|
||||
];
|
||||
my $clip = Slic3r::Polygon->new(# a circular, convex, polygon
|
||||
[99452190, 10452846], [97814760, 20791169], [95105652, 30901699], [91354546, 40673664], [86602540, 50000000],
|
||||
[80901699, 58778525], [74314483, 66913061], [66913061, 74314483], [58778525, 80901699], [50000000, 86602540],
|
||||
[40673664, 91354546], [30901699, 95105652], [20791169, 97814760], [10452846, 99452190], [0, 100000000],
|
||||
[-10452846, 99452190], [-20791169, 97814760], [-30901699, 95105652], [-40673664, 91354546],
|
||||
[-50000000, 86602540], [-58778525, 80901699], [-66913061, 74314483], [-74314483, 66913061],
|
||||
[-80901699, 58778525], [-86602540, 50000000], [-91354546, 40673664], [-95105652, 30901699],
|
||||
[-97814760, 20791169], [-99452190, 10452846], [-100000000, 0], [-99452190, -10452846],
|
||||
[-97814760, -20791169], [-95105652, -30901699], [-91354546, -40673664], [-86602540, -50000000],
|
||||
[-80901699, -58778525], [-74314483, -66913061], [-66913061, -74314483], [-58778525, -80901699],
|
||||
[-50000000, -86602540], [-40673664, -91354546], [-30901699, -95105652], [-20791169, -97814760],
|
||||
[-10452846, -99452190], [0, -100000000], [10452846, -99452190], [20791169, -97814760],
|
||||
[30901699, -95105652], [40673664, -91354546], [50000000, -86602540], [58778525, -80901699],
|
||||
[66913061, -74314483], [74314483, -66913061], [80901699, -58778525], [86602540, -50000000],
|
||||
[91354546, -40673664], [95105652, -30901699], [97814760, -20791169], [99452190, -10452846], [100000000, 0]
|
||||
);
|
||||
my $result = Slic3r::Geometry::Clipper::intersection_pl($subject, [$clip]);
|
||||
is scalar(@$result), scalar(@$subject), 'intersection_pl - expected number of polylines';
|
||||
is sum(map scalar(@$_), @$result), scalar(@$subject) * 2, 'intersection_pl - expected number of points in polylines';
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
SCENARIO("Various Clipper operations - t/clipper.t", "[ClipperUtils]") {
|
||||
GIVEN("square with hole") {
|
||||
// CCW oriented contour
|
||||
Slic3r::Polygon square { { 10, 10 }, { 20, 10 }, { 20, 20 }, { 10, 20 } };
|
||||
Slic3r::Polygon square2 { { 5, 12 }, { 25, 12 }, { 25, 18 }, { 5, 18 } };
|
||||
// CW oriented contour
|
||||
Slic3r::Polygon hole_in_square { { 14, 14 }, { 14, 16 }, { 16, 16 }, { 16, 14 } };
|
||||
WHEN("intersection_ex with another square") {
|
||||
ExPolygons intersection = Slic3r::intersection_ex({ square, hole_in_square }, { square2 });
|
||||
THEN("intersection area matches (hole is preserved)") {
|
||||
ExPolygon match({ { 20, 18 }, { 10, 18 }, { 10, 12 }, { 20, 12 } },
|
||||
{ { 14, 16 }, { 16, 16 }, { 16, 14 }, { 14, 14 } });
|
||||
REQUIRE(intersection.size() == 1);
|
||||
REQUIRE(intersection.front().area() == Approx(match.area()));
|
||||
}
|
||||
}
|
||||
}
|
||||
GIVEN("square with hole 2") {
|
||||
// CCW oriented contour
|
||||
Slic3r::Polygon square { { 0, 0 }, { 40, 0 }, { 40, 40 }, { 0, 40 } };
|
||||
Slic3r::Polygon square2 { { 10, 10 }, { 30, 10 }, { 30, 30 }, { 10, 30 } };
|
||||
// CW oriented contour
|
||||
Slic3r::Polygon hole { { 15, 15 }, { 15, 25 }, { 25, 25 }, {25, 15 } };
|
||||
WHEN("union_ex with another square") {
|
||||
ExPolygons union_ = Slic3r::union_ex({ square, square2, hole });
|
||||
THEN("union of two ccw and one cw is a contour with no holes") {
|
||||
REQUIRE(union_.size() == 1);
|
||||
REQUIRE(union_.front() == ExPolygon { { 40, 40 }, { 0, 40 }, { 0, 0 }, { 40, 0 } } );
|
||||
}
|
||||
}
|
||||
WHEN("diff_ex with another square") {
|
||||
ExPolygons diff = Slic3r::diff_ex({ square, square2 }, { hole });
|
||||
THEN("difference of a cw from two ccw is a contour with one hole") {
|
||||
REQUIRE(diff.size() == 1);
|
||||
REQUIRE(diff.front().area() == Approx(ExPolygon({ {40, 40}, {0, 40}, {0, 0}, {40, 0} }, { {15, 25}, {25, 25}, {25, 15}, {15, 15} }).area()));
|
||||
}
|
||||
}
|
||||
}
|
||||
GIVEN("yet another square") {
|
||||
Slic3r::Polygon square { { 10, 10 }, { 20, 10 }, { 20, 20 }, { 10, 20 } };
|
||||
Slic3r::Polyline square_pl = square.split_at_first_point();
|
||||
WHEN("no-op diff_pl") {
|
||||
Slic3r::Polylines res = Slic3r::diff_pl({ square_pl }, {});
|
||||
THEN("returns the right number of polylines") {
|
||||
REQUIRE(res.size() == 1);
|
||||
}
|
||||
THEN("returns the unmodified input polyline") {
|
||||
REQUIRE(res.front().points.size() == square_pl.points.size());
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -11,7 +11,7 @@
|
|||
|
||||
using namespace Slic3r;
|
||||
|
||||
TEST_CASE("Polygon::contains works properly", ""){
|
||||
TEST_CASE("Polygon::contains works properly", "[Geometry]"){
|
||||
// this test was failing on Windows (GH #1950)
|
||||
Slic3r::Polygon polygon(std::vector<Point>({
|
||||
Point(207802834,-57084522),
|
||||
|
|
@ -29,7 +29,7 @@ TEST_CASE("Polygon::contains works properly", ""){
|
|||
REQUIRE(polygon.contains(point));
|
||||
}
|
||||
|
||||
SCENARIO("Intersections of line segments"){
|
||||
SCENARIO("Intersections of line segments", "[Geometry]"){
|
||||
GIVEN("Integer coordinates"){
|
||||
Line line1(Point(5,15),Point(30,15));
|
||||
Line line2(Point(10,20), Point(10,10));
|
||||
|
|
@ -127,7 +127,7 @@ SCENARIO("polygon_is_convex works"){
|
|||
}*/
|
||||
|
||||
|
||||
TEST_CASE("Creating a polyline generates the obvious lines"){
|
||||
TEST_CASE("Creating a polyline generates the obvious lines", "[Geometry]"){
|
||||
Slic3r::Polyline polyline;
|
||||
polyline.points = std::vector<Point>({Point(0, 0), Point(10, 0), Point(20, 0)});
|
||||
REQUIRE(polyline.lines().at(0).a == Point(0,0));
|
||||
|
|
@ -136,7 +136,7 @@ TEST_CASE("Creating a polyline generates the obvious lines"){
|
|||
REQUIRE(polyline.lines().at(1).b == Point(20,0));
|
||||
}
|
||||
|
||||
TEST_CASE("Splitting a Polygon generates a polyline correctly"){
|
||||
TEST_CASE("Splitting a Polygon generates a polyline correctly", "[Geometry]"){
|
||||
Slic3r::Polygon polygon(std::vector<Point>({Point(0, 0), Point(10, 0), Point(5, 5)}));
|
||||
Slic3r::Polyline split = polygon.split_at_index(1);
|
||||
REQUIRE(split.points[0]==Point(10,0));
|
||||
|
|
@ -146,7 +146,7 @@ TEST_CASE("Splitting a Polygon generates a polyline correctly"){
|
|||
}
|
||||
|
||||
|
||||
TEST_CASE("Bounding boxes are scaled appropriately"){
|
||||
TEST_CASE("Bounding boxes are scaled appropriately", "[Geometry]"){
|
||||
BoundingBox bb(std::vector<Point>({Point(0, 1), Point(10, 2), Point(20, 2)}));
|
||||
bb.scale(2);
|
||||
REQUIRE(bb.min == Point(0,2));
|
||||
|
|
@ -154,13 +154,13 @@ TEST_CASE("Bounding boxes are scaled appropriately"){
|
|||
}
|
||||
|
||||
|
||||
TEST_CASE("Offseting a line generates a polygon correctly"){
|
||||
TEST_CASE("Offseting a line generates a polygon correctly", "[Geometry]"){
|
||||
Slic3r::Polyline tmp = { Point(10,10), Point(20,10) };
|
||||
Slic3r::Polygon area = offset(tmp,5).at(0);
|
||||
REQUIRE(area.area() == Slic3r::Polygon(std::vector<Point>({Point(10,5),Point(20,5),Point(20,15),Point(10,15)})).area());
|
||||
}
|
||||
|
||||
SCENARIO("Circle Fit, TaubinFit with Newton's method") {
|
||||
SCENARIO("Circle Fit, TaubinFit with Newton's method", "[Geometry]") {
|
||||
GIVEN("A vector of Vec2ds arranged in a half-circle with approximately the same distance R from some point") {
|
||||
Vec2d expected_center(-6, 0);
|
||||
Vec2ds sample {Vec2d(6.0, 0), Vec2d(5.1961524, 3), Vec2d(3 ,5.1961524), Vec2d(0, 6.0), Vec2d(3, 5.1961524), Vec2d(-5.1961524, 3), Vec2d(-6.0, 0)};
|
||||
|
|
@ -252,7 +252,7 @@ SCENARIO("Circle Fit, TaubinFit with Newton's method") {
|
|||
}
|
||||
}
|
||||
|
||||
TEST_CASE("Chained path working correctly"){
|
||||
TEST_CASE("Chained path working correctly", "[Geometry]"){
|
||||
// if chained_path() works correctly, these points should be joined with no diagonal paths
|
||||
// (thus 26 units long)
|
||||
std::vector<Point> points = {Point(26,26),Point(52,26),Point(0,26),Point(26,52),Point(26,0),Point(0,52),Point(52,52),Point(52,0)};
|
||||
|
|
@ -263,7 +263,7 @@ TEST_CASE("Chained path working correctly"){
|
|||
}
|
||||
}
|
||||
|
||||
SCENARIO("Line distances"){
|
||||
SCENARIO("Line distances", "[Geometry]"){
|
||||
GIVEN("A line"){
|
||||
Line line(Point(0, 0), Point(20, 0));
|
||||
THEN("Points on the line segment have 0 distance"){
|
||||
|
|
@ -279,7 +279,7 @@ SCENARIO("Line distances"){
|
|||
}
|
||||
}
|
||||
|
||||
SCENARIO("Polygon convex/concave detection"){
|
||||
SCENARIO("Polygon convex/concave detection", "[Geometry]"){
|
||||
GIVEN(("A Square with dimension 100")){
|
||||
auto square = Slic3r::Polygon /*new_scale*/(std::vector<Point>({
|
||||
Point(100,100),
|
||||
|
|
@ -365,11 +365,30 @@ SCENARIO("Polygon convex/concave detection"){
|
|||
}
|
||||
}
|
||||
|
||||
TEST_CASE("Triangle Simplification does not result in less than 3 points"){
|
||||
TEST_CASE("Triangle Simplification does not result in less than 3 points", "[Geometry]"){
|
||||
auto triangle = Slic3r::Polygon(std::vector<Point>({
|
||||
Point(16000170,26257364), Point(714223,461012), Point(31286371,461008)
|
||||
}));
|
||||
REQUIRE(triangle.simplify(250000).at(0).points.size() == 3);
|
||||
}
|
||||
|
||||
|
||||
SCENARIO("Ported from xs/t/14_geometry.t", "[Geometry]"){
|
||||
GIVEN(("square")){
|
||||
Slic3r::Points points { { 100, 100 }, {100, 200 }, { 200, 200 }, { 200, 100 }, { 150, 150 } };
|
||||
Slic3r::Polygon hull = Slic3r::Geometry::convex_hull(points);
|
||||
SECTION("convex hull returns the correct number of points") { REQUIRE(hull.points.size() == 4); }
|
||||
}
|
||||
SECTION("arrange returns expected number of positions") {
|
||||
Pointfs positions;
|
||||
Slic3r::Geometry::arrange(4, Vec2d(20, 20), 5, nullptr, positions);
|
||||
REQUIRE(positions.size() == 4);
|
||||
}
|
||||
SECTION("directions_parallel") {
|
||||
REQUIRE(Slic3r::Geometry::directions_parallel(0, 0, 0));
|
||||
REQUIRE(Slic3r::Geometry::directions_parallel(0, M_PI, 0));
|
||||
REQUIRE(Slic3r::Geometry::directions_parallel(0, 0, M_PI / 180));
|
||||
REQUIRE(Slic3r::Geometry::directions_parallel(0, M_PI, M_PI / 180));
|
||||
REQUIRE(! Slic3r::Geometry::directions_parallel(M_PI /2, M_PI, 0));
|
||||
REQUIRE(! Slic3r::Geometry::directions_parallel(M_PI /2, PI, M_PI /180));
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -25,7 +25,7 @@ Slic3r::Points collinear_circle({
|
|||
Slic3r::Point::new_scale(-5, 0)
|
||||
});
|
||||
|
||||
SCENARIO("Remove collinear points from Polygon") {
|
||||
SCENARIO("Remove collinear points from Polygon", "[Polygon]") {
|
||||
GIVEN("Polygon with collinear points"){
|
||||
Slic3r::Polygon p(collinear_circle);
|
||||
WHEN("collinear points are removed") {
|
||||
|
|
|
|||
|
|
@ -1,193 +0,0 @@
|
|||
#!/usr/bin/perl
|
||||
|
||||
use strict;
|
||||
use warnings;
|
||||
|
||||
use List::Util qw(sum);
|
||||
use Slic3r::XS;
|
||||
use Test::More tests => 16;
|
||||
|
||||
my $square = Slic3r::Polygon->new( # ccw
|
||||
[200, 100],
|
||||
[200, 200],
|
||||
[100, 200],
|
||||
[100, 100],
|
||||
);
|
||||
my $hole_in_square = Slic3r::Polygon->new( # cw
|
||||
[160, 140],
|
||||
[140, 140],
|
||||
[140, 160],
|
||||
[160, 160],
|
||||
);
|
||||
my $expolygon = Slic3r::ExPolygon->new($square, $hole_in_square);
|
||||
|
||||
{
|
||||
my $result = Slic3r::Geometry::Clipper::offset([ $square, $hole_in_square ], 5);
|
||||
is_deeply [ map $_->pp, @$result ], [ [
|
||||
[205, 205],
|
||||
[95, 205],
|
||||
[95, 95],
|
||||
[205, 95],
|
||||
], [
|
||||
[145, 145],
|
||||
[145, 155],
|
||||
[155, 155],
|
||||
[155, 145],
|
||||
] ], 'offset';
|
||||
}
|
||||
|
||||
{
|
||||
my $result = Slic3r::Geometry::Clipper::offset_ex([ @$expolygon ], 5);
|
||||
is_deeply $result->[0]->pp, [ [
|
||||
[205, 205],
|
||||
[95, 205],
|
||||
[95, 95],
|
||||
[205, 95],
|
||||
], [
|
||||
[145, 145],
|
||||
[145, 155],
|
||||
[155, 155],
|
||||
[155, 145],
|
||||
] ], 'offset_ex';
|
||||
}
|
||||
|
||||
{
|
||||
my $result = Slic3r::Geometry::Clipper::offset2_ex([ @$expolygon ], 5, -2);
|
||||
is_deeply $result->[0]->pp, [ [
|
||||
[203, 203],
|
||||
[97, 203],
|
||||
[97, 97],
|
||||
[203, 97],
|
||||
], [
|
||||
[143, 143],
|
||||
[143, 157],
|
||||
[157, 157],
|
||||
[157, 143],
|
||||
] ], 'offset2_ex';
|
||||
}
|
||||
|
||||
{
|
||||
my $expolygon2 = Slic3r::ExPolygon->new([
|
||||
[20000000, 20000000],
|
||||
[0, 20000000],
|
||||
[0, 0],
|
||||
[20000000, 0],
|
||||
], [
|
||||
[5000000, 15000000],
|
||||
[15000000, 15000000],
|
||||
[15000000, 5000000],
|
||||
[5000000, 5000000],
|
||||
]);
|
||||
my $result = Slic3r::Geometry::Clipper::offset2_ex([ @$expolygon2 ], -1, +1);
|
||||
is $result->[0]->area, $expolygon2->area, 'offset2_ex';
|
||||
}
|
||||
|
||||
{
|
||||
my $polygon1 = Slic3r::Polygon->new(@$square);
|
||||
my $polygon2 = Slic3r::Polygon->new(reverse @$hole_in_square);
|
||||
my $result = Slic3r::Geometry::Clipper::diff_ex([$polygon1], [$polygon2]);
|
||||
is $result->[0]->area, $expolygon->area, 'diff_ex';
|
||||
}
|
||||
|
||||
{
|
||||
my $polyline = Slic3r::Polyline->new([50,150], [300,150]);
|
||||
{
|
||||
my $result = Slic3r::Geometry::Clipper::intersection_pl([$polyline], [$square, $hole_in_square]);
|
||||
is scalar(@$result), 2, 'intersection_pl - correct number of result lines';
|
||||
# results are in no particular order
|
||||
is scalar(grep $_->length == 40, @$result), 2, 'intersection_pl - result lines have correct length';
|
||||
}
|
||||
{
|
||||
my $result = Slic3r::Geometry::Clipper::diff_pl([$polyline], [$square, $hole_in_square]);
|
||||
is scalar(@$result), 3, 'diff_pl - correct number of result lines';
|
||||
# results are in no particular order
|
||||
is scalar(grep $_->length == 50, @$result), 1, 'diff_pl - the left result line has correct length';
|
||||
is scalar(grep $_->length == 100, @$result), 1, 'diff_pl - two right result line has correct length';
|
||||
is scalar(grep $_->length == 20, @$result), 1, 'diff_pl - the central result line has correct length';
|
||||
}
|
||||
}
|
||||
|
||||
if (0) { # Clipper does not preserve polyline orientation
|
||||
my $polyline = Slic3r::Polyline->new([50,150], [300,150]);
|
||||
my $result = Slic3r::Geometry::Clipper::intersection_pl([$polyline], [$square]);
|
||||
is scalar(@$result), 1, 'intersection_pl - correct number of result lines';
|
||||
is_deeply $result->[0]->pp, [[100,150], [200,150]], 'clipped line orientation is preserved';
|
||||
}
|
||||
|
||||
if (0) { # Clipper does not preserve polyline orientation
|
||||
my $polyline = Slic3r::Polyline->new([300,150], [50,150]);
|
||||
my $result = Slic3r::Geometry::Clipper::intersection_pl([$polyline], [$square]);
|
||||
is scalar(@$result), 1, 'intersection_pl - correct number of result lines';
|
||||
is_deeply $result->[0]->pp, [[200,150], [100,150]], 'clipped line orientation is preserved';
|
||||
}
|
||||
|
||||
{
|
||||
# Clipper bug #96 (our issue #2028)
|
||||
my $subject = Slic3r::Polyline->new(
|
||||
[44735000,31936670],[55270000,31936670],[55270000,25270000],[74730000,25270000],[74730000,44730000],[68063296,44730000],[68063296,55270000],[74730000,55270000],[74730000,74730000],[55270000,74730000],[55270000,68063296],[44730000,68063296],[44730000,74730000],[25270000,74730000],[25270000,55270000],[31936670,55270000],[31936670,44730000],[25270000,44730000],[25270000,25270000],[44730000,25270000],[44730000,31936670]
|
||||
);
|
||||
my $clip = [
|
||||
Slic3r::Polygon->new([75200000,45200000],[54800000,45200000],[54800000,24800000],[75200000,24800000]),
|
||||
];
|
||||
my $result = Slic3r::Geometry::Clipper::intersection_pl([$subject], $clip);
|
||||
is scalar(@$result), 1, 'intersection_pl - result is not empty';
|
||||
}
|
||||
|
||||
{
|
||||
# Clipper bug #122
|
||||
my $subject = [
|
||||
Slic3r::Polyline->new([1975,1975],[25,1975],[25,25],[1975,25],[1975,1975]),
|
||||
];
|
||||
my $clip = [
|
||||
Slic3r::Polygon->new([2025,2025],[-25,2025],[-25,-25],[2025,-25]),
|
||||
Slic3r::Polygon->new([525,525],[525,1475],[1475,1475],[1475,525]),
|
||||
];
|
||||
my $result = Slic3r::Geometry::Clipper::intersection_pl($subject, $clip);
|
||||
is scalar(@$result), 1, 'intersection_pl - result is not empty';
|
||||
is scalar(@{$result->[0]}), 5, 'intersection_pl - result is not empty';
|
||||
}
|
||||
|
||||
{
|
||||
# Clipper bug #126
|
||||
my $subject = Slic3r::Polyline->new(
|
||||
[200000,19799999],[200000,200000],[24304692,200000],[15102879,17506106],[13883200,19799999],[200000,19799999],
|
||||
);
|
||||
my $clip = [
|
||||
Slic3r::Polygon->new([15257205,18493894],[14350057,20200000],[-200000,20200000],[-200000,-200000],[25196917,-200000]),
|
||||
];
|
||||
my $result = Slic3r::Geometry::Clipper::intersection_pl([$subject], $clip);
|
||||
is scalar(@$result), 1, 'intersection_pl - result is not empty';
|
||||
is $result->[0]->length, $subject->length, 'intersection_pl - result has same length as subject polyline';
|
||||
}
|
||||
|
||||
if (0) {
|
||||
# Disabled until Clipper bug #127 is fixed
|
||||
my $subject = [
|
||||
Slic3r::Polyline->new([-90000000,-100000000],[-90000000,100000000]), # vertical
|
||||
Slic3r::Polyline->new([-100000000,-10000000],[100000000,-10000000]), # horizontal
|
||||
Slic3r::Polyline->new([-100000000,0],[100000000,0]), # horizontal
|
||||
Slic3r::Polyline->new([-100000000,10000000],[100000000,10000000]), # horizontal
|
||||
];
|
||||
my $clip = Slic3r::Polygon->new( # a circular, convex, polygon
|
||||
[99452190,10452846],[97814760,20791169],[95105652,30901699],[91354546,40673664],[86602540,50000000],
|
||||
[80901699,58778525],[74314483,66913061],[66913061,74314483],[58778525,80901699],[50000000,86602540],
|
||||
[40673664,91354546],[30901699,95105652],[20791169,97814760],[10452846,99452190],[0,100000000],
|
||||
[-10452846,99452190],[-20791169,97814760],[-30901699,95105652],[-40673664,91354546],
|
||||
[-50000000,86602540],[-58778525,80901699],[-66913061,74314483],[-74314483,66913061],
|
||||
[-80901699,58778525],[-86602540,50000000],[-91354546,40673664],[-95105652,30901699],
|
||||
[-97814760,20791169],[-99452190,10452846],[-100000000,0],[-99452190,-10452846],
|
||||
[-97814760,-20791169],[-95105652,-30901699],[-91354546,-40673664],[-86602540,-50000000],
|
||||
[-80901699,-58778525],[-74314483,-66913061],[-66913061,-74314483],[-58778525,-80901699],
|
||||
[-50000000,-86602540],[-40673664,-91354546],[-30901699,-95105652],[-20791169,-97814760],
|
||||
[-10452846,-99452190],[0,-100000000],[10452846,-99452190],[20791169,-97814760],
|
||||
[30901699,-95105652],[40673664,-91354546],[50000000,-86602540],[58778525,-80901699],
|
||||
[66913061,-74314483],[74314483,-66913061],[80901699,-58778525],[86602540,-50000000],
|
||||
[91354546,-40673664],[95105652,-30901699],[97814760,-20791169],[99452190,-10452846],[100000000,0]
|
||||
);
|
||||
my $result = Slic3r::Geometry::Clipper::intersection_pl($subject, [$clip]);
|
||||
is scalar(@$result), scalar(@$subject), 'intersection_pl - expected number of polylines';
|
||||
is sum(map scalar(@$_), @$result), scalar(@$subject)*2,
|
||||
'intersection_pl - expected number of points in polylines';
|
||||
}
|
||||
|
||||
__END__
|
||||
|
|
@ -1,40 +0,0 @@
|
|||
#!/usr/bin/perl
|
||||
|
||||
use strict;
|
||||
use warnings;
|
||||
|
||||
use Slic3r::XS;
|
||||
use Test::More tests => 9;
|
||||
|
||||
use constant PI => 4 * atan2(1, 1);
|
||||
|
||||
{
|
||||
my @points = (
|
||||
Slic3r::Point->new(100,100),
|
||||
Slic3r::Point->new(100,200),
|
||||
Slic3r::Point->new(200,200),
|
||||
Slic3r::Point->new(200,100),
|
||||
Slic3r::Point->new(150,150),
|
||||
);
|
||||
my $hull = Slic3r::Geometry::convex_hull(\@points);
|
||||
isa_ok $hull, 'Slic3r::Polygon', 'convex_hull returns a Polygon';
|
||||
is scalar(@$hull), 4, 'convex_hull returns the correct number of points';
|
||||
}
|
||||
|
||||
# directions_parallel() and directions_parallel_within() are tested
|
||||
# also with Slic3r::Line::parallel_to() tests in 10_line.t
|
||||
{
|
||||
ok Slic3r::Geometry::directions_parallel_within(0, 0, 0), 'directions_parallel_within';
|
||||
ok Slic3r::Geometry::directions_parallel_within(0, PI, 0), 'directions_parallel_within';
|
||||
ok Slic3r::Geometry::directions_parallel_within(0, 0, PI/180), 'directions_parallel_within';
|
||||
ok Slic3r::Geometry::directions_parallel_within(0, PI, PI/180), 'directions_parallel_within';
|
||||
ok !Slic3r::Geometry::directions_parallel_within(PI/2, PI, 0), 'directions_parallel_within';
|
||||
ok !Slic3r::Geometry::directions_parallel_within(PI/2, PI, PI/180), 'directions_parallel_within';
|
||||
}
|
||||
|
||||
{
|
||||
my $positions = Slic3r::Geometry::arrange(4, Slic3r::Pointf->new(20, 20), 5);
|
||||
is scalar(@$positions), 4, 'arrange() returns expected number of positions';
|
||||
}
|
||||
|
||||
__END__
|
||||
|
|
@ -1,29 +0,0 @@
|
|||
#!/usr/bin/perl
|
||||
|
||||
use strict;
|
||||
use warnings;
|
||||
|
||||
use Slic3r::XS;
|
||||
use Test::More tests => 2;
|
||||
|
||||
{
|
||||
my $flow = Slic3r::Flow->new_from_width(
|
||||
role => Slic3r::Flow::FLOW_ROLE_PERIMETER,
|
||||
width => '1',
|
||||
nozzle_diameter => 0.5,
|
||||
layer_height => 0.3,
|
||||
bridge_flow_ratio => 1,
|
||||
);
|
||||
isa_ok $flow, 'Slic3r::Flow', 'new_from_width';
|
||||
}
|
||||
|
||||
{
|
||||
my $flow = Slic3r::Flow->new(
|
||||
width => 1,
|
||||
height => 0.4,
|
||||
nozzle_diameter => 0.5,
|
||||
);
|
||||
isa_ok $flow, 'Slic3r::Flow', 'new';
|
||||
}
|
||||
|
||||
__END__
|
||||
|
|
@ -1,22 +0,0 @@
|
|||
#!/usr/bin/perl
|
||||
|
||||
use strict;
|
||||
use warnings;
|
||||
|
||||
use Slic3r::XS;
|
||||
use Test::More tests => 3;
|
||||
|
||||
{
|
||||
my $model = Slic3r::Model->new;
|
||||
my $object = $model->_add_object;
|
||||
isa_ok $object, 'Slic3r::Model::Object::Ref';
|
||||
isa_ok $object->origin_translation, 'Slic3r::Pointf3::Ref';
|
||||
$object->origin_translation->translate(10,0,0);
|
||||
is_deeply \@{$object->origin_translation}, [10,0,0], 'origin_translation is modified by ref';
|
||||
|
||||
# my $lhr = [ [ 5, 10, 0.1 ] ];
|
||||
# $object->set_layer_height_ranges($lhr);
|
||||
# is_deeply $object->layer_height_ranges, $lhr, 'layer_height_ranges roundtrip';
|
||||
}
|
||||
|
||||
__END__
|
||||
|
|
@ -1,17 +0,0 @@
|
|||
#!/usr/bin/perl
|
||||
|
||||
use strict;
|
||||
use warnings;
|
||||
|
||||
use Slic3r::XS;
|
||||
use Test::More tests => 2;
|
||||
|
||||
{
|
||||
my $gcodegen = Slic3r::GCode->new;
|
||||
$gcodegen->set_origin(Slic3r::Pointf->new(10,0));
|
||||
is_deeply $gcodegen->origin->pp, [10,0], 'set_origin';
|
||||
$gcodegen->origin->translate(5,5);
|
||||
is_deeply $gcodegen->origin->pp, [15,5], 'origin returns reference to point';
|
||||
}
|
||||
|
||||
__END__
|
||||
|
|
@ -1,14 +0,0 @@
|
|||
#!/usr/bin/perl
|
||||
|
||||
use strict;
|
||||
use warnings;
|
||||
|
||||
use Slic3r::XS;
|
||||
use Test::More tests => 1;
|
||||
|
||||
eval {
|
||||
Slic3r::xspp_test_croak_hangs_on_strawberry();
|
||||
};
|
||||
is $@, "xspp_test_croak_hangs_on_strawberry: exception catched\n", 'croak from inside a C++ exception delivered';
|
||||
|
||||
__END__
|
||||
Loading…
Reference in a new issue