3DPrinting/PrusaSlicer-NonPlainar
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
c2e38fc6fe
PrusaSlicer-NonPlainar/xs/src/libslic3r/ClipperUtils.hpp

231 lines
12 KiB
C++
Raw Normal View History

Port offset_ex() and offset2_ex() to XS
2013-07-16 18:09:53 +00:00
#ifndef slic3r_ClipperUtils_hpp_
#define slic3r_ClipperUtils_hpp_
Remove any Perl related code from libslic3r
2015-12-07 23:39:54 +00:00
#include <libslic3r.h>
Port offset_ex() and offset2_ex() to XS
2013-07-16 18:09:53 +00:00
#include "clipper.hpp"
Ported Polygon->is_counter_clockwise() and rearranged code in .cpp files
2013-07-16 19:04:14 +00:00
#include "ExPolygon.hpp"
#include "Polygon.hpp"
Ported Surface->offset() to XS
2013-11-23 17:29:25 +00:00
#include "Surface.hpp"
Port offset_ex() and offset2_ex() to XS
2013-07-16 18:09:53 +00:00
Removed dependency on Math::Clipper
2013-08-26 23:26:44 +00:00
// import these wherever we're included
using ClipperLib::jtMiter;
using ClipperLib::jtRound;
using ClipperLib::jtSquare;
Bugfix: when the Voronoi diagram contained very large coordinates we need to check whether they are greater than our allowed range and consider the Voronoi edges infinite in those cases, in order to prevent overflows. https://github.com/alexrj/Slic3r/issues/3776 https://github.com/alexrj/Slic3r/commit/9ad1360e445cd3043c4dc30ccad64b82b914f952
2017-03-24 08:32:30 +00:00
// Factor to convert from coord_t (which is int32) to an int64 type used by the Clipper library
// for general offsetting (the offset(), offset2(), offset_ex() functions) and for the safety offset,
// which is optionally executed by other functions (union, intersection, diff).
Experimental feature, which may make the Clipper offsets run faster due to avoiding the 128bit multiply operations: A filtered predicate is tried to calculate SlopesEqual() to minimize the invocation of 128bit multiply operations.
2017-07-13 13:52:19 +00:00
// This scaling (cca 130t) is applied over the usual SCALING_FACTOR.
Bugfix: when the Voronoi diagram contained very large coordinates we need to check whether they are greater than our allowed range and consider the Voronoi edges infinite in those cases, in order to prevent overflows. https://github.com/alexrj/Slic3r/issues/3776 https://github.com/alexrj/Slic3r/commit/9ad1360e445cd3043c4dc30ccad64b82b914f952
2017-03-24 08:32:30 +00:00
// By the way, is the scalling for offset needed at all?
Experimental feature, which may make the Clipper offsets run faster due to avoiding the 128bit multiply operations: A filtered predicate is tried to calculate SlopesEqual() to minimize the invocation of 128bit multiply operations.
2017-07-13 13:52:19 +00:00
// The reason to apply this scaling may be to match the resolution of the double mantissa.
Bugfix: when the Voronoi diagram contained very large coordinates we need to check whether they are greater than our allowed range and consider the Voronoi edges infinite in those cases, in order to prevent overflows. https://github.com/alexrj/Slic3r/issues/3776 https://github.com/alexrj/Slic3r/commit/9ad1360e445cd3043c4dc30ccad64b82b914f952
2017-03-24 08:32:30 +00:00
#define CLIPPER_OFFSET_POWER_OF_2 17
// 2^17=131072
#define CLIPPER_OFFSET_SCALE (1 << CLIPPER_OFFSET_POWER_OF_2)
#define CLIPPER_OFFSET_SCALE_ROUNDING_DELTA ((1 << (CLIPPER_OFFSET_POWER_OF_2 - 1)) - 1)
#define CLIPPER_MAX_COORD_UNSCALED (ClipperLib::hiRange / CLIPPER_OFFSET_SCALE)
Port offset_ex() and offset2_ex() to XS
2013-07-16 18:09:53 +00:00
namespace Slic3r {
//-----------------------------------------------------------
// legacy code from Clipper documentation
Ported Polygon->is_counter_clockwise() and rearranged code in .cpp files
2013-07-16 19:04:14 +00:00
void AddOuterPolyNodeToExPolygons(ClipperLib::PolyNode& polynode, Slic3r::ExPolygons& expolygons);
void PolyTreeToExPolygons(ClipperLib::PolyTree& polytree, Slic3r::ExPolygons& expolygons);
Port offset_ex() and offset2_ex() to XS
2013-07-16 18:09:53 +00:00
//-----------------------------------------------------------
Had troubles with the template instantiation on OSX, so I reverted them to overloaded functions. This is certainly easier to read and work with anyway.
2016-12-13 20:30:56 +00:00
ClipperLib::Path Slic3rMultiPoint_to_ClipperPath(const Slic3r::MultiPoint &input);
ClipperLib::Paths Slic3rMultiPoints_to_ClipperPaths(const Polygons &input);
ClipperLib::Paths Slic3rMultiPoints_to_ClipperPaths(const Polylines &input);
Another take to get rid of the templates from the ClipperUtil.hpp to compile cleanly on OSX.
2016-12-13 21:13:02 +00:00
Slic3r::Polygon ClipperPath_to_Slic3rPolygon(const ClipperLib::Path &input);
Slic3r::Polyline ClipperPath_to_Slic3rPolyline(const ClipperLib::Path &input);
Had troubles with the template instantiation on OSX, so I reverted them to overloaded functions. This is certainly easier to read and work with anyway.
2016-12-13 20:30:56 +00:00
Slic3r::Polygons ClipperPaths_to_Slic3rPolygons(const ClipperLib::Paths &input);
Slic3r::Polylines ClipperPaths_to_Slic3rPolylines(const ClipperLib::Paths &input);
Adapted to the new ClipperUtils.hpp interface by @alexrj
2016-12-13 18:22:23 +00:00
Slic3r::ExPolygons ClipperPaths_to_Slic3rExPolygons(const ClipperLib::Paths &input);
Port offset_ex() and offset2_ex() to XS
2013-07-16 18:09:53 +00:00
Update Clipper to 6.0.0
2013-11-20 10:35:58 +00:00
// offset Polygons
VS2013 could compile this, let's hope GCC will as well.
2016-12-13 18:39:20 +00:00
ClipperLib::Paths _offset(ClipperLib::Path &&input, ClipperLib::EndType endType, const float delta, ClipperLib::JoinType joinType, double miterLimit);
ClipperLib::Paths _offset(ClipperLib::Paths &&input, ClipperLib::EndType endType, const float delta, ClipperLib::JoinType joinType, double miterLimit);
Adapted to the new ClipperUtils.hpp interface by @alexrj
2016-12-13 18:22:23 +00:00
inline Slic3r::Polygons offset(const Slic3r::Polygon &polygon, const float delta, ClipperLib::JoinType joinType = ClipperLib::jtMiter, double miterLimit = 3)
Had troubles with the template instantiation on OSX, so I reverted them to overloaded functions. This is certainly easier to read and work with anyway.
2016-12-13 20:30:56 +00:00
{ return ClipperPaths_to_Slic3rPolygons(_offset(Slic3rMultiPoint_to_ClipperPath(polygon), ClipperLib::etClosedPolygon, delta, joinType, miterLimit)); }
Adapted to the new ClipperUtils.hpp interface by @alexrj
2016-12-13 18:22:23 +00:00
inline Slic3r::Polygons offset(const Slic3r::Polygons &polygons, const float delta, ClipperLib::JoinType joinType = ClipperLib::jtMiter, double miterLimit = 3)
Had troubles with the template instantiation on OSX, so I reverted them to overloaded functions. This is certainly easier to read and work with anyway.
2016-12-13 20:30:56 +00:00
{ return ClipperPaths_to_Slic3rPolygons(_offset(Slic3rMultiPoints_to_ClipperPaths(polygons), ClipperLib::etClosedPolygon, delta, joinType, miterLimit)); }
Disabled asserts in the release build (-DNDEBUG). Added a safe variant of offset(const Slic3r::ExPolygon...), which offsets each loop separately. New functions "remove_sticks" to remove zero area parts of polygons. New functions "remove_small" and "remove_degenerate" for polygon clean up. Extended the C++ supports, those are not finalized yet though.
2016-10-20 11:04:23 +00:00
Update Clipper to 6.0.0
2013-11-20 10:35:58 +00:00
// offset Polylines
Adapted to the new ClipperUtils.hpp interface by @alexrj
2016-12-13 18:22:23 +00:00
inline Slic3r::Polygons offset(const Slic3r::Polyline &polyline, const float delta, ClipperLib::JoinType joinType = ClipperLib::jtSquare, double miterLimit = 3)
Had troubles with the template instantiation on OSX, so I reverted them to overloaded functions. This is certainly easier to read and work with anyway.
2016-12-13 20:30:56 +00:00
{ return ClipperPaths_to_Slic3rPolygons(_offset(Slic3rMultiPoint_to_ClipperPath(polyline), ClipperLib::etOpenButt, delta, joinType, miterLimit)); }
Adapted to the new ClipperUtils.hpp interface by @alexrj
2016-12-13 18:22:23 +00:00
inline Slic3r::Polygons offset(const Slic3r::Polylines &polylines, const float delta, ClipperLib::JoinType joinType = ClipperLib::jtSquare, double miterLimit = 3)
Had troubles with the template instantiation on OSX, so I reverted them to overloaded functions. This is certainly easier to read and work with anyway.
2016-12-13 20:30:56 +00:00
{ return ClipperPaths_to_Slic3rPolygons(_offset(Slic3rMultiPoints_to_ClipperPaths(polylines), ClipperLib::etOpenButt, delta, joinType, miterLimit)); }
Adapted to the new ClipperUtils.hpp interface by @alexrj
2016-12-13 18:22:23 +00:00
// offset expolygons and surfaces
ClipperLib::Paths _offset(const Slic3r::ExPolygon &expolygon, const float delta, ClipperLib::JoinType joinType, double miterLimit);
ClipperLib::Paths _offset(const Slic3r::ExPolygons &expolygons, const float delta, ClipperLib::JoinType joinType, double miterLimit);
inline Slic3r::Polygons offset(const Slic3r::ExPolygon &expolygon, const float delta, ClipperLib::JoinType joinType = ClipperLib::jtMiter, double miterLimit = 3)
Had troubles with the template instantiation on OSX, so I reverted them to overloaded functions. This is certainly easier to read and work with anyway.
2016-12-13 20:30:56 +00:00
{ return ClipperPaths_to_Slic3rPolygons(_offset(expolygon, delta, joinType, miterLimit)); }
Adapted to the new ClipperUtils.hpp interface by @alexrj
2016-12-13 18:22:23 +00:00
inline Slic3r::Polygons offset(const Slic3r::ExPolygons &expolygons, const float delta, ClipperLib::JoinType joinType = ClipperLib::jtMiter, double miterLimit = 3)
Had troubles with the template instantiation on OSX, so I reverted them to overloaded functions. This is certainly easier to read and work with anyway.
2016-12-13 20:30:56 +00:00
{ return ClipperPaths_to_Slic3rPolygons(_offset(expolygons, delta, joinType, miterLimit)); }
Adapted to the new ClipperUtils.hpp interface by @alexrj
2016-12-13 18:22:23 +00:00
inline Slic3r::ExPolygons offset_ex(const Slic3r::Polygon &polygon, const float delta, ClipperLib::JoinType joinType = ClipperLib::jtMiter, double miterLimit = 3)
{ return ClipperPaths_to_Slic3rExPolygons(_offset(Slic3rMultiPoint_to_ClipperPath(polygon), ClipperLib::etClosedPolygon, delta, joinType, miterLimit)); }
inline Slic3r::ExPolygons offset_ex(const Slic3r::Polygons &polygons, const float delta, ClipperLib::JoinType joinType = ClipperLib::jtMiter, double miterLimit = 3)
{ return ClipperPaths_to_Slic3rExPolygons(_offset(Slic3rMultiPoints_to_ClipperPaths(polygons), ClipperLib::etClosedPolygon, delta, joinType, miterLimit)); }
inline Slic3r::ExPolygons offset_ex(const Slic3r::ExPolygon &expolygon, const float delta, ClipperLib::JoinType joinType = ClipperLib::jtMiter, double miterLimit = 3)
{ return ClipperPaths_to_Slic3rExPolygons(_offset(expolygon, delta, joinType, miterLimit)); }
inline Slic3r::ExPolygons offset_ex(const Slic3r::ExPolygons &expolygons, const float delta, ClipperLib::JoinType joinType = ClipperLib::jtMiter, double miterLimit = 3)
{ return ClipperPaths_to_Slic3rExPolygons(_offset(expolygons, delta, joinType, miterLimit)); }
ClipperLib::Paths _offset2(const Slic3r::Polygons &polygons, const float delta1,
CLIPPER_OFFSET_SCALE was made a power of two, the scaling functions inside ClipperUtils are now using bit shifts instead of multiplication by doubles, which makes the scaling precise. Removed the scale parameter from all offset functions. Modified the safety offset to calculate offset per polygon instead of over all polygons at once. The old way was not safe and very slow, sometimes this meant a kiss of death for supports for example.
2016-11-28 16:33:17 +00:00
const float delta2, ClipperLib::JoinType joinType = ClipperLib::jtMiter,
Ported offset() and offset2()
2013-07-16 22:48:29 +00:00
double miterLimit = 3);
Finished porting PerimeterGenerator to C++
2015-07-23 13:53:02 +00:00
Slic3r::Polygons offset2(const Slic3r::Polygons &polygons, const float delta1,
CLIPPER_OFFSET_SCALE was made a power of two, the scaling functions inside ClipperUtils are now using bit shifts instead of multiplication by doubles, which makes the scaling precise. Removed the scale parameter from all offset functions. Modified the safety offset to calculate offset per polygon instead of over all polygons at once. The old way was not safe and very slow, sometimes this meant a kiss of death for supports for example.
2016-11-28 16:33:17 +00:00
const float delta2, ClipperLib::JoinType joinType = ClipperLib::jtMiter,
Finished porting PerimeterGenerator to C++
2015-07-23 13:53:02 +00:00
double miterLimit = 3);
Slic3r::ExPolygons offset2_ex(const Slic3r::Polygons &polygons, const float delta1,
CLIPPER_OFFSET_SCALE was made a power of two, the scaling functions inside ClipperUtils are now using bit shifts instead of multiplication by doubles, which makes the scaling precise. Removed the scale parameter from all offset functions. Modified the safety offset to calculate offset per polygon instead of over all polygons at once. The old way was not safe and very slow, sometimes this meant a kiss of death for supports for example.
2016-11-28 16:33:17 +00:00
const float delta2, ClipperLib::JoinType joinType = ClipperLib::jtMiter,
Finished porting PerimeterGenerator to C++
2015-07-23 13:53:02 +00:00
double miterLimit = 3);
Fix of extraneous infill over thin walls. Fixes https://github.com/prusa3d/Slic3r/issues/670 and some of https://github.com/prusa3d/Slic3r/issues/895 PerimeterGenerator was using an unsafe clipper offset function, which performed offset for both a contour and its holes together. With this commit the offsets were replaced with their safe counterparts, though these safe counterparts may be somehow slower (performing offset on ExPolygon or ExPolygons, piece by piece). Also there was a bug, where if the infill & gap fill consumed everything of the polygon, a polygon one onion shell above was still used for infill.
2018-05-18 07:52:09 +00:00
Slic3r::ExPolygons offset2_ex(const Slic3r::ExPolygons &expolygons, const float delta1,
const float delta2, ClipperLib::JoinType joinType = ClipperLib::jtMiter,
double miterLimit = 3);
Make offset_ex(), offset2_ex() and diff_ex() available to C++ code
2013-07-16 18:36:27 +00:00
Adapted to the new ClipperUtils.hpp interface by @alexrj
2016-12-13 18:22:23 +00:00
Slic3r::Polygons _clipper(ClipperLib::ClipType clipType,
const Slic3r::Polygons &subject, const Slic3r::Polygons &clip, bool safety_offset_ = false);
Slic3r::ExPolygons _clipper_ex(ClipperLib::ClipType clipType,
const Slic3r::Polygons &subject, const Slic3r::Polygons &clip, bool safety_offset_ = false);
Slic3r::Polylines _clipper_pl(ClipperLib::ClipType clipType,
const Slic3r::Polylines &subject, const Slic3r::Polygons &clip, bool safety_offset_ = false);
Slic3r::Polylines _clipper_pl(ClipperLib::ClipType clipType,
const Slic3r::Polygons &subject, const Slic3r::Polygons &clip, bool safety_offset_ = false);
Slic3r::Lines _clipper_ln(ClipperLib::ClipType clipType,
const Slic3r::Lines &subject, const Slic3r::Polygons &clip, bool safety_offset_ = false);
// diff
inline Slic3r::Polygons
diff(const Slic3r::Polygons &subject, const Slic3r::Polygons &clip, bool safety_offset_ = false)
{
return _clipper(ClipperLib::ctDifference, subject, clip, safety_offset_);
}
Ported diff() and intersection()
2013-07-16 23:21:30 +00:00
Adapted to the new ClipperUtils.hpp interface by @alexrj
2016-12-13 18:22:23 +00:00
inline Slic3r::ExPolygons
diff_ex(const Slic3r::Polygons &subject, const Slic3r::Polygons &clip, bool safety_offset_ = false)
{
return _clipper_ex(ClipperLib::ctDifference, subject, clip, safety_offset_);
}
Ported PrintObject::bridge_over_infill() to XS
2014-12-24 09:20:55 +00:00
Adapted to the new ClipperUtils.hpp interface by @alexrj
2016-12-13 18:22:23 +00:00
inline Slic3r::ExPolygons
diff_ex(const Slic3r::ExPolygons &subject, const Slic3r::ExPolygons &clip, bool safety_offset_ = false)
{
return _clipper_ex(ClipperLib::ctDifference, to_polygons(subject), to_polygons(clip), safety_offset_);
}
Finished porting LayerRegion to C++
2015-10-26 22:23:03 +00:00
Adapted to the new ClipperUtils.hpp interface by @alexrj
2016-12-13 18:22:23 +00:00
inline Slic3r::Polygons
diff(const Slic3r::ExPolygons &subject, const Slic3r::ExPolygons &clip, bool safety_offset_ = false)
{
return _clipper(ClipperLib::ctDifference, to_polygons(subject), to_polygons(clip), safety_offset_);
}
Finished porting PerimeterGenerator to C++
2015-07-23 13:53:02 +00:00
Adapted to the new ClipperUtils.hpp interface by @alexrj
2016-12-13 18:22:23 +00:00
inline Slic3r::Polylines
diff_pl(const Slic3r::Polygons &subject, const Slic3r::Polygons &clip, bool safety_offset_ = false)
Fixes after the merge of changes by @alexrj.
2016-12-08 18:02:16 +00:00
{
Adapted to the new ClipperUtils.hpp interface by @alexrj
2016-12-13 18:22:23 +00:00
return _clipper_pl(ClipperLib::ctDifference, subject, clip, safety_offset_);
Fixes after the merge of changes by @alexrj.
2016-12-08 18:02:16 +00:00
}
Adapted to the new ClipperUtils.hpp interface by @alexrj
2016-12-13 18:22:23 +00:00
inline Slic3r::Polylines
diff_pl(const Slic3r::Polylines &subject, const Slic3r::Polygons &clip, bool safety_offset_ = false)
Fixes after the merge of changes by @alexrj.
2016-12-08 18:02:16 +00:00
{
Adapted to the new ClipperUtils.hpp interface by @alexrj
2016-12-13 18:22:23 +00:00
return _clipper_pl(ClipperLib::ctDifference, subject, clip, safety_offset_);
Fixes after the merge of changes by @alexrj.
2016-12-08 18:02:16 +00:00
}
Adapted to the new ClipperUtils.hpp interface by @alexrj
2016-12-13 18:22:23 +00:00
inline Slic3r::Lines
diff_ln(const Slic3r::Lines &subject, const Slic3r::Polygons &clip, bool safety_offset_ = false)
{
return _clipper_ln(ClipperLib::ctDifference, subject, clip, safety_offset_);
}
Use Clipper for line clipping
2013-11-21 13:15:38 +00:00
Adapted to the new ClipperUtils.hpp interface by @alexrj
2016-12-13 18:22:23 +00:00
// intersection
inline Slic3r::Polygons
intersection(const Slic3r::Polygons &subject, const Slic3r::Polygons &clip, bool safety_offset_ = false)
Fixes after the merge of changes by @alexrj.
2016-12-08 18:02:16 +00:00
{
Adapted to the new ClipperUtils.hpp interface by @alexrj
2016-12-13 18:22:23 +00:00
return _clipper(ClipperLib::ctIntersection, subject, clip, safety_offset_);
Fixes after the merge of changes by @alexrj.
2016-12-08 18:02:16 +00:00
}
Adapted to the new ClipperUtils.hpp interface by @alexrj
2016-12-13 18:22:23 +00:00
inline Slic3r::ExPolygons
intersection_ex(const Slic3r::Polygons &subject, const Slic3r::Polygons &clip, bool safety_offset_ = false)
Fixes after the merge of changes by @alexrj.
2016-12-08 18:02:16 +00:00
{
Adapted to the new ClipperUtils.hpp interface by @alexrj
2016-12-13 18:22:23 +00:00
return _clipper_ex(ClipperLib::ctIntersection, subject, clip, safety_offset_);
Fixes after the merge of changes by @alexrj.
2016-12-08 18:02:16 +00:00
}
Adapted to the new ClipperUtils.hpp interface by @alexrj
2016-12-13 18:22:23 +00:00
inline Slic3r::ExPolygons
intersection_ex(const Slic3r::ExPolygons &subject, const Slic3r::ExPolygons &clip, bool safety_offset_ = false)
{
return _clipper_ex(ClipperLib::ctIntersection, to_polygons(subject), to_polygons(clip), safety_offset_);
}
Fixes and improvements to MotionPlanner, much smarter now
2015-12-21 13:46:35 +00:00
Adapted to the new ClipperUtils.hpp interface by @alexrj
2016-12-13 18:22:23 +00:00
inline Slic3r::Polygons
intersection(const Slic3r::ExPolygons &subject, const Slic3r::ExPolygons &clip, bool safety_offset_ = false)
{
return _clipper(ClipperLib::ctIntersection, to_polygons(subject), to_polygons(clip), safety_offset_);
}
Finished porting PerimeterGenerator to C++
2015-07-23 13:53:02 +00:00
Adapted to the new ClipperUtils.hpp interface by @alexrj
2016-12-13 18:22:23 +00:00
inline Slic3r::Polylines
intersection_pl(const Slic3r::Polygons &subject, const Slic3r::Polygons &clip, bool safety_offset_ = false)
{
return _clipper_pl(ClipperLib::ctIntersection, subject, clip, safety_offset_);
}
Ported Print::validate() to XS
2014-11-09 14:27:34 +00:00
Fixes after the merge of changes by @alexrj.
2016-12-08 18:02:16 +00:00
inline Slic3r::Polylines
intersection_pl(const Slic3r::Polylines &subject, const Slic3r::Polygons &clip, bool safety_offset_ = false)
{
Adapted to the new ClipperUtils.hpp interface by @alexrj
2016-12-13 18:22:23 +00:00
return _clipper_pl(ClipperLib::ctIntersection, subject, clip, safety_offset_);
}
Fixed the "avoid crossing perimeters" bug introduced in Slic3r 1.34.1.24 https://github.com/prusa3d/Slic3r/issues/311 https://github.com/prusa3d/Slic3r/issues/317 https://github.com/prusa3d/Slic3r/issues/323
2017-06-02 11:33:19 +00:00
inline Slic3r::Lines intersection_ln(const Slic3r::Lines &subject, const Slic3r::Polygons &clip, bool safety_offset_ = false)
Adapted to the new ClipperUtils.hpp interface by @alexrj
2016-12-13 18:22:23 +00:00
{
return _clipper_ln(ClipperLib::ctIntersection, subject, clip, safety_offset_);
Fixes after the merge of changes by @alexrj.
2016-12-08 18:02:16 +00:00
}
Fixed the "avoid crossing perimeters" bug introduced in Slic3r 1.34.1.24 https://github.com/prusa3d/Slic3r/issues/311 https://github.com/prusa3d/Slic3r/issues/317 https://github.com/prusa3d/Slic3r/issues/323
2017-06-02 11:33:19 +00:00
inline Slic3r::Lines intersection_ln(const Slic3r::Line &subject, const Slic3r::Polygons &clip, bool safety_offset_ = false)
{
Slic3r::Lines lines;
lines.emplace_back(subject);
return _clipper_ln(ClipperLib::ctIntersection, lines, clip, safety_offset_);
}
Adapted to the new ClipperUtils.hpp interface by @alexrj
2016-12-13 18:22:23 +00:00
// union
Ported PrintObject::prepare_infill & combine_infill from Perl to C++.
2017-08-02 12:24:32 +00:00
inline Slic3r::Polygons union_(const Slic3r::Polygons &subject, bool safety_offset_ = false)
Adapted to the new ClipperUtils.hpp interface by @alexrj
2016-12-13 18:22:23 +00:00
{
return _clipper(ClipperLib::ctUnion, subject, Slic3r::Polygons(), safety_offset_);
}
Ported diff() and intersection()
2013-07-16 23:21:30 +00:00
Ported PrintObject::prepare_infill & combine_infill from Perl to C++.
2017-08-02 12:24:32 +00:00
inline Slic3r::Polygons union_(const Slic3r::Polygons &subject, const Slic3r::Polygons &subject2, bool safety_offset_ = false)
Adapted to the new ClipperUtils.hpp interface by @alexrj
2016-12-13 18:22:23 +00:00
{
return _clipper(ClipperLib::ctUnion, subject, subject2, safety_offset_);
}
Ported PrintObject::prepare_infill & combine_infill from Perl to C++.
2017-08-02 12:24:32 +00:00
inline Slic3r::ExPolygons union_ex(const Slic3r::Polygons &subject, bool safety_offset_ = false)
Adapted to the new ClipperUtils.hpp interface by @alexrj
2016-12-13 18:22:23 +00:00
{
return _clipper_ex(ClipperLib::ctUnion, subject, Slic3r::Polygons(), safety_offset_);
}
Port offset_ex() and offset2_ex() to XS
2013-07-16 18:09:53 +00:00
Ported PrintObject::prepare_infill & combine_infill from Perl to C++.
2017-08-02 12:24:32 +00:00
inline Slic3r::ExPolygons union_ex(const Slic3r::ExPolygons &subject, bool safety_offset_ = false)
Adapted to the new ClipperUtils.hpp interface by @alexrj
2016-12-13 18:22:23 +00:00
{
return _clipper_ex(ClipperLib::ctUnion, to_polygons(subject), Slic3r::Polygons(), safety_offset_);
}
Ported PrintObject::prepare_infill & combine_infill from Perl to C++.
2017-08-02 12:24:32 +00:00
inline Slic3r::ExPolygons union_ex(const Slic3r::Surfaces &subject, bool safety_offset_ = false)
Adapted to the new ClipperUtils.hpp interface by @alexrj
2016-12-13 18:22:23 +00:00
{
return _clipper_ex(ClipperLib::ctUnion, to_polygons(subject), Slic3r::Polygons(), safety_offset_);
}
Finished porting PerimeterGenerator to C++
2015-07-23 13:53:02 +00:00
Ported Print::validate() to XS
2014-11-09 14:27:34 +00:00
Adapted to the new ClipperUtils.hpp interface by @alexrj
2016-12-13 18:22:23 +00:00
ClipperLib::PolyTree union_pt(const Slic3r::Polygons &subject, bool safety_offset_ = false);
Slic3r::Polygons union_pt_chained(const Slic3r::Polygons &subject, bool safety_offset_ = false);
void traverse_pt(ClipperLib::PolyNodes &nodes, Slic3r::Polygons* retval);
Ported union_pt() to XS
2013-08-26 16:37:19 +00:00
Adapted to the new ClipperUtils.hpp interface by @alexrj
2016-12-13 18:22:23 +00:00
/* OTHER */
Slic3r::Polygons simplify_polygons(const Slic3r::Polygons &subject, bool preserve_collinear = false);
Slic3r::ExPolygons simplify_polygons_ex(const Slic3r::Polygons &subject, bool preserve_collinear = false);
Merge branch 'master' into xsdata Conflicts: lib/Slic3r.pm lib/Slic3r/ExPolygon.pm lib/Slic3r/Fill.pm lib/Slic3r/Fill/Rectilinear.pm lib/Slic3r/GCode.pm lib/Slic3r/GUI/Plater.pm lib/Slic3r/Geometry/Clipper.pm lib/Slic3r/Layer/Region.pm lib/Slic3r/Print.pm lib/Slic3r/Print/Object.pm lib/Slic3r/TriangleMesh.pm t/shells.t xs/MANIFEST
2013-08-08 00:10:34 +00:00
New semantics for ExtrusionLoop objects. Early processing of perimeter overhangs for paralellizing such work and making G-code export lighter. Lots of refactoring. This should fix a number of minor bugs, including reversals of perimeter overhangs.
2014-05-08 09:07:37 +00:00
void safety_offset(ClipperLib::Paths* paths);
Fixed everything in the XS port
2013-08-26 15:58:37 +00:00
One step further to the C++ Supports.
2016-11-23 14:51:47 +00:00
Polygons top_level_islands(const Slic3r::Polygons &polygons);
Port offset_ex() and offset2_ex() to XS
2013-07-16 18:09:53 +00:00
}
Adapted to the new ClipperUtils.hpp interface by @alexrj
2016-12-13 18:22:23 +00:00
#endif
Reference in New Issue Copy Permalink