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

163 lines
8.3 KiB
C++
Raw Normal View History

Port offset_ex() and offset2_ex() to XS
2013-07-16 20:09:53 +02:00
#ifndef slic3r_ClipperUtils_hpp_
#define slic3r_ClipperUtils_hpp_
Remove any Perl related code from libslic3r
2015-12-08 00:39:54 +01:00
#include <libslic3r.h>
Port offset_ex() and offset2_ex() to XS
2013-07-16 20:09:53 +02:00
#include "clipper.hpp"
Ported Polygon->is_counter_clockwise() and rearranged code in .cpp files
2013-07-16 21:04:14 +02:00
#include "ExPolygon.hpp"
#include "Polygon.hpp"
Ported Surface->offset() to XS
2013-11-23 18:29:25 +01:00
#include "Surface.hpp"
Port offset_ex() and offset2_ex() to XS
2013-07-16 20:09:53 +02:00
Removed dependency on Math::Clipper
2013-08-27 01:26:44 +02:00
// import these wherever we're included
using ClipperLib::jtMiter;
using ClipperLib::jtRound;
using ClipperLib::jtSquare;
Port offset_ex() and offset2_ex() to XS
2013-07-16 20:09:53 +02:00
namespace Slic3r {
//-----------------------------------------------------------
// legacy code from Clipper documentation
Ported Polygon->is_counter_clockwise() and rearranged code in .cpp files
2013-07-16 21:04:14 +02: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 20:09:53 +02:00
//-----------------------------------------------------------
Refactored ClipperUtils API for a more consistent arguments convention
2014-11-15 23:44:03 +01:00
void Slic3rMultiPoint_to_ClipperPath(const Slic3r::MultiPoint &input, ClipperLib::Path* output);
Update Clipper to 6.0.0
2013-11-20 11:35:58 +01:00
template <class T>
Refactored ClipperUtils API for a more consistent arguments convention
2014-11-15 23:44:03 +01:00
void Slic3rMultiPoints_to_ClipperPaths(const T &input, ClipperLib::Paths* output);
Use Clipper for line clipping
2013-11-21 14:15:38 +01:00
template <class T>
Refactored ClipperUtils API for a more consistent arguments convention
2014-11-15 23:44:03 +01:00
void ClipperPath_to_Slic3rMultiPoint(const ClipperLib::Path &input, T* output);
Use Clipper for line clipping
2013-11-21 14:15:38 +01:00
template <class T>
Refactored ClipperUtils API for a more consistent arguments convention
2014-11-15 23:44:03 +01:00
void ClipperPaths_to_Slic3rMultiPoints(const ClipperLib::Paths &input, T* output);
void ClipperPaths_to_Slic3rExPolygons(const ClipperLib::Paths &input, Slic3r::ExPolygons* output);
Port offset_ex() and offset2_ex() to XS
2013-07-16 20:09:53 +02:00
Support the new Clipper API
2013-11-20 15:59:19 +01:00
void scaleClipperPolygons(ClipperLib::Paths &polygons, const double scale);
Port offset_ex() and offset2_ex() to XS
2013-07-16 20:09:53 +02:00
Update Clipper to 6.0.0
2013-11-20 11:35:58 +01:00
// offset Polygons
Refactored ClipperUtils API for a more consistent arguments convention
2014-11-15 23:44:03 +01:00
void offset(const Slic3r::Polygons &polygons, ClipperLib::Paths* retval, const float delta,
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 17:33:17 +01:00
ClipperLib::JoinType joinType = ClipperLib::jtMiter,
Ported offset() and offset2()
2013-07-17 00:48:29 +02:00
double miterLimit = 3);
Refactored ClipperUtils API for a more consistent arguments convention
2014-11-15 23:44:03 +01:00
void offset(const Slic3r::Polygons &polygons, Slic3r::Polygons* retval, const float delta,
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 17:33:17 +01:00
ClipperLib::JoinType joinType = ClipperLib::jtMiter,
Ported offset() and offset2()
2013-07-17 00:48:29 +02:00
double miterLimit = 3);
Finished porting PerimeterGenerator to C++
2015-07-23 15:53:02 +02:00
Slic3r::Polygons offset(const Slic3r::Polygons &polygons, const float delta,
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 17:33:17 +01:00
ClipperLib::JoinType joinType = ClipperLib::jtMiter,
Finished porting PerimeterGenerator to C++
2015-07-23 15:53:02 +02:00
double miterLimit = 3);
Update Clipper to 6.0.0
2013-11-20 11:35:58 +01:00
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 13:04:23 +02:00
// This is a safe variant of the polygon offset, tailored for a single ExPolygon:
// a single polygon with multiple non-overlapping holes.
// Each contour and hole is offsetted separately, then the holes are subtracted from the outer contours.
void offset(const Slic3r::ExPolygon &expolygon, ClipperLib::Paths* retval, const float delta,
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 17:33:17 +01:00
ClipperLib::JoinType joinType = ClipperLib::jtMiter,
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 13:04:23 +02:00
double miterLimit = 3);
Implemented utility functions to operate over lines, polylines, polygons, surfaces.
2016-11-07 22:49:11 +01:00
void offset(const Slic3r::ExPolygons &expolygons, ClipperLib::Paths* retval, const float delta,
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 17:33:17 +01:00
ClipperLib::JoinType joinType = ClipperLib::jtMiter,
Implemented utility functions to operate over lines, polylines, polygons, surfaces.
2016-11-07 22:49:11 +01:00
double miterLimit = 3);
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 13:04:23 +02:00
Slic3r::Polygons offset(const Slic3r::ExPolygon &expolygon, const float delta,
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 17:33:17 +01:00
ClipperLib::JoinType joinType = ClipperLib::jtMiter,
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 13:04:23 +02:00
double miterLimit = 3);
Implemented utility functions to operate over lines, polylines, polygons, surfaces.
2016-11-07 22:49:11 +01:00
Slic3r::Polygons offset(const Slic3r::ExPolygons &expolygons, const float delta,
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 17:33:17 +01:00
ClipperLib::JoinType joinType = ClipperLib::jtMiter,
Implemented utility functions to operate over lines, polylines, polygons, surfaces.
2016-11-07 22:49:11 +01:00
double miterLimit = 3);
Slic3r::ExPolygons offset_ex(const Slic3r::ExPolygon &expolygon, const float delta,
double scale, ClipperLib::JoinType joinType, double miterLimit);
Slic3r::ExPolygons offset_ex(const Slic3r::ExPolygons &expolygons, const float delta,
double scale, ClipperLib::JoinType joinType, double 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 13:04:23 +02:00
Update Clipper to 6.0.0
2013-11-20 11:35:58 +01:00
// offset Polylines
Refactored ClipperUtils API for a more consistent arguments convention
2014-11-15 23:44:03 +01:00
void offset(const Slic3r::Polylines &polylines, ClipperLib::Paths* retval, const float delta,
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 17:33:17 +01:00
ClipperLib::JoinType joinType = ClipperLib::jtSquare,
Update Clipper to 6.0.0
2013-11-20 11:35:58 +01:00
double miterLimit = 3);
Refactored ClipperUtils API for a more consistent arguments convention
2014-11-15 23:44:03 +01:00
void offset(const Slic3r::Polylines &polylines, Slic3r::Polygons* retval, const float delta,
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 17:33:17 +01:00
ClipperLib::JoinType joinType = ClipperLib::jtSquare,
Update Clipper to 6.0.0
2013-11-20 11:35:58 +01:00
double miterLimit = 3);
Refactored ClipperUtils API for a more consistent arguments convention
2014-11-15 23:44:03 +01:00
void offset(const Slic3r::Surface &surface, Slic3r::Surfaces* retval, const float delta,
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 17:33:17 +01:00
ClipperLib::JoinType joinType = ClipperLib::jtSquare,
Ported Surface->offset() to XS
2013-11-23 18:29:25 +01:00
double miterLimit = 3);
Update Clipper to 6.0.0
2013-11-20 11:35:58 +01:00
Refactored ClipperUtils API for a more consistent arguments convention
2014-11-15 23:44:03 +01:00
void offset(const Slic3r::Polygons &polygons, Slic3r::ExPolygons* retval, const float delta,
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 17:33:17 +01:00
ClipperLib::JoinType joinType = ClipperLib::jtMiter,
Ported Polygon->is_counter_clockwise() and rearranged code in .cpp files
2013-07-16 21:04:14 +02:00
double miterLimit = 3);
Finished porting LayerRegion to C++
2015-10-26 23:23:03 +01:00
Slic3r::ExPolygons offset_ex(const Slic3r::Polygons &polygons, const float delta,
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 17:33:17 +01:00
ClipperLib::JoinType joinType = ClipperLib::jtMiter,
Finished porting LayerRegion to C++
2015-10-26 23:23:03 +01:00
double miterLimit = 3);
Make offset_ex(), offset2_ex() and diff_ex() available to C++ code
2013-07-16 20:36:27 +02:00
Refactored ClipperUtils API for a more consistent arguments convention
2014-11-15 23:44:03 +01:00
void offset2(const Slic3r::Polygons &polygons, ClipperLib::Paths* retval, 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 17:33:17 +01:00
const float delta2, ClipperLib::JoinType joinType = ClipperLib::jtMiter,
Ported offset() and offset2()
2013-07-17 00:48:29 +02:00
double miterLimit = 3);
Refactored ClipperUtils API for a more consistent arguments convention
2014-11-15 23:44:03 +01:00
void offset2(const Slic3r::Polygons &polygons, Slic3r::Polygons* retval, 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 17:33:17 +01:00
const float delta2, ClipperLib::JoinType joinType = ClipperLib::jtMiter,
Ported offset() and offset2()
2013-07-17 00:48:29 +02:00
double miterLimit = 3);
Finished porting PerimeterGenerator to C++
2015-07-23 15:53:02 +02: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 17:33:17 +01:00
const float delta2, ClipperLib::JoinType joinType = ClipperLib::jtMiter,
Finished porting PerimeterGenerator to C++
2015-07-23 15:53:02 +02:00
double miterLimit = 3);
Refactored ClipperUtils API for a more consistent arguments convention
2014-11-15 23:44:03 +01:00
void offset2(const Slic3r::Polygons &polygons, Slic3r::ExPolygons* retval, 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 17:33:17 +01:00
const float delta2, ClipperLib::JoinType joinType = ClipperLib::jtMiter,
Ported Polygon->is_counter_clockwise() and rearranged code in .cpp files
2013-07-16 21:04:14 +02:00
double miterLimit = 3);
Finished porting PerimeterGenerator to C++
2015-07-23 15:53:02 +02:00
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 17:33:17 +01:00
const float delta2, ClipperLib::JoinType joinType = ClipperLib::jtMiter,
Finished porting PerimeterGenerator to C++
2015-07-23 15:53:02 +02:00
double miterLimit = 3);
Make offset_ex(), offset2_ex() and diff_ex() available to C++ code
2013-07-16 20:36:27 +02:00
Ported diff() and intersection()
2013-07-17 01:21:30 +02:00
template <class T>
Ported contains_line() to XS
2013-11-21 15:12:06 +01:00
void _clipper_do(ClipperLib::ClipType clipType, const Slic3r::Polygons &subject,
Refactored ClipperUtils API for a more consistent arguments convention
2014-11-15 23:44:03 +01:00
const Slic3r::Polygons &clip, T* retval, bool safety_offset_);
Ported contains_line() to XS
2013-11-21 15:12:06 +01:00
void _clipper_do(ClipperLib::ClipType clipType, const Slic3r::Polylines &subject,
Refactored ClipperUtils API for a more consistent arguments convention
2014-11-15 23:44:03 +01:00
const Slic3r::Polygons &clip, ClipperLib::Paths* retval, bool safety_offset_);
Ported contains_line() to XS
2013-11-21 15:12:06 +01:00
void _clipper(ClipperLib::ClipType clipType, const Slic3r::Polygons &subject,
Refactored ClipperUtils API for a more consistent arguments convention
2014-11-15 23:44:03 +01:00
const Slic3r::Polygons &clip, Slic3r::Polygons* retval, bool safety_offset_);
Ported contains_line() to XS
2013-11-21 15:12:06 +01:00
void _clipper(ClipperLib::ClipType clipType, const Slic3r::Polygons &subject,
Refactored ClipperUtils API for a more consistent arguments convention
2014-11-15 23:44:03 +01:00
const Slic3r::Polygons &clip, Slic3r::ExPolygons* retval, bool safety_offset_);
Ported contains_line() to XS
2013-11-21 15:12:06 +01:00
void _clipper(ClipperLib::ClipType clipType, const Slic3r::Polylines &subject,
Refactored ClipperUtils API for a more consistent arguments convention
2014-11-15 23:44:03 +01:00
const Slic3r::Polygons &clip, Slic3r::Polylines* retval);
Ported Slic3r::BridgeDetector to XS
2014-11-15 22:41:22 +01:00
void _clipper(ClipperLib::ClipType clipType, const Slic3r::Lines &subject,
Refactored ClipperUtils API for a more consistent arguments convention
2014-11-15 23:44:03 +01:00
const Slic3r::Polygons &clip, Slic3r::Lines* retval);
Ported diff() and intersection()
2013-07-17 01:21:30 +02: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 11:07:37 +02:00
template <class SubjectType, class ResultType>
Refactored ClipperUtils API for a more consistent arguments convention
2014-11-15 23:44:03 +01:00
void diff(const SubjectType &subject, const Slic3r::Polygons &clip, ResultType* retval, bool safety_offset_ = false);
Ported diff() and intersection()
2013-07-17 01:21:30 +02:00
Ported PrintObject::bridge_over_infill() to XS
2014-12-24 10:20:55 +01:00
template <class SubjectType, class ResultType>
void diff(const SubjectType &subject, const Slic3r::ExPolygons &clip, ResultType* retval, bool safety_offset_ = false);
Finished porting PerimeterGenerator to C++
2015-07-23 15:53:02 +02:00
Slic3r::Polygons diff(const Slic3r::Polygons &subject, const Slic3r::Polygons &clip, bool safety_offset_ = false);
Finished porting LayerRegion to C++
2015-10-26 23:23:03 +01:00
template <class SubjectType, class ClipType>
Slic3r::ExPolygons diff_ex(const SubjectType &subject, const ClipType &clip, bool safety_offset_ = false);
Finished porting PerimeterGenerator to C++
2015-07-23 15:53:02 +02: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 11:07:37 +02:00
template <class SubjectType, class ResultType>
Refactored ClipperUtils API for a more consistent arguments convention
2014-11-15 23:44:03 +01:00
void intersection(const SubjectType &subject, const Slic3r::Polygons &clip, ResultType* retval, bool safety_offset_ = false);
Use Clipper for line clipping
2013-11-21 14:15:38 +01:00
Fixes and improvements to MotionPlanner, much smarter now
2015-12-21 14:46:35 +01:00
template <class SubjectType>
SubjectType intersection(const SubjectType &subject, const Slic3r::Polygons &clip, bool safety_offset_ = false);
Slic3r::ExPolygons
intersection_ex(const Slic3r::Polygons &subject, const Slic3r::Polygons &clip, bool safety_offset_ = false);
Finished porting PerimeterGenerator to C++
2015-07-23 15:53:02 +02:00
Ported Print::validate() to XS
2014-11-09 15:27:34 +01:00
template <class SubjectType>
bool intersects(const SubjectType &subject, const Slic3r::Polygons &clip, bool safety_offset_ = false);
Refactored ClipperUtils API for a more consistent arguments convention
2014-11-15 23:44:03 +01:00
void xor_(const Slic3r::Polygons &subject, const Slic3r::Polygons &clip, Slic3r::ExPolygons* retval,
Fixed everything in the XS port
2013-08-26 17:58:37 +02:00
bool safety_offset_ = false);
Ported diff() and intersection()
2013-07-17 01:21:30 +02:00
Ported union() to XS
2013-08-17 12:24:04 +02:00
template <class T>
Refactored ClipperUtils API for a more consistent arguments convention
2014-11-15 23:44:03 +01:00
void union_(const Slic3r::Polygons &subject, T* retval, bool safety_offset_ = false);
Port offset_ex() and offset2_ex() to XS
2013-07-16 20:09:53 +02:00
Finished porting PerimeterGenerator to C++
2015-07-23 15:53:02 +02:00
Slic3r::Polygons union_(const Slic3r::Polygons &subject, bool safety_offset = false);
Slic3r::ExPolygons union_ex(const Slic3r::Polygons &subject, bool safety_offset = false);
Ported Layer::maker_perimeters() to XS
2015-12-02 19:32:57 +01:00
Slic3r::ExPolygons union_ex(const Slic3r::Surfaces &subject, bool safety_offset = false);
Finished porting PerimeterGenerator to C++
2015-07-23 15:53:02 +02:00
Refactored ClipperUtils API for a more consistent arguments convention
2014-11-15 23:44:03 +01:00
void union_(const Slic3r::Polygons &subject1, const Slic3r::Polygons &subject2, Slic3r::Polygons* retval, bool safety_offset = false);
by alexrj: Fixes in GCodeSender to reset the connection after it breaks. by alexrj: Fix in mouse handling of 2DBed. by alexrj: ClipperUtils for ExPolygon vs. ExPolygon
2016-10-24 14:07:38 +02:00
Slic3r::Polygons union_(const Slic3r::ExPolygons &subject1, const Slic3r::ExPolygons &subject2, bool safety_offset = false);
Ported Print::validate() to XS
2014-11-09 15:27:34 +01:00
Refactored ClipperUtils API for a more consistent arguments convention
2014-11-15 23:44:03 +01:00
void union_pt(const Slic3r::Polygons &subject, ClipperLib::PolyTree* retval, bool safety_offset_ = false);
void union_pt_chained(const Slic3r::Polygons &subject, Slic3r::Polygons* retval, bool safety_offset_ = false);
static void traverse_pt(ClipperLib::PolyNodes &nodes, Slic3r::Polygons* retval);
Ported union_pt() to XS
2013-08-26 18:37:19 +02:00
Refactored ClipperUtils API for a more consistent arguments convention
2014-11-15 23:44:03 +01:00
void simplify_polygons(const Slic3r::Polygons &subject, Slic3r::Polygons* retval, bool preserve_collinear = false);
void simplify_polygons(const Slic3r::Polygons &subject, Slic3r::ExPolygons* retval, 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 02:10:34 +02: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 11:07:37 +02:00
void safety_offset(ClipperLib::Paths* paths);
Fixed everything in the XS port
2013-08-26 17:58:37 +02:00
One step further to the C++ Supports.
2016-11-23 15:51:47 +01:00
Polygons top_level_islands(const Slic3r::Polygons &polygons);
Port offset_ex() and offset2_ex() to XS
2013-07-16 20:09:53 +02:00
}
#endif
Reference in a new issue Copy permalink