3D-printing/OrcaSlicer
1
0
Fork 0
mirror of https://github.com/SoftFever/OrcaSlicer.git synced 2025-07-21 21:58:03 -06:00
Code Issues Projects Releases Packages Wiki Activity Actions 3

EdgeGrid refactoring to support both open and closed contours.

Browse source 
Squashed commit of the following:

commit 4e13a8fe19abcc9aae39a9bc4c7953a743196504
Merge: 6ae766409 6f89da1f3
Author: Vojtech Bubnik <bubnikv@gmail.com>
Date:   Fri Feb 5 11:19:35 2021 +0100

    Merge remote-tracking branch 'remotes/origin/master' into vb_edgegrid_open_lines

commit 6ae76640942269993c942861f0444088843e3fa1
Author: Vojtech Bubnik <bubnikv@gmail.com>
Date:   Fri Feb 5 11:14:48 2021 +0100

    EdgeGrid enhancement to accept both the open and closed lines.

commit 36a5efcd558bd5fd5f46b5f561387a2c73221553
Author: Vojtech Bubnik <bubnikv@gmail.com>
Date:   Fri Feb 5 10:52:14 2021 +0100

    EdgeGrid improvements: Documentation, one bug fix after recent refactoring.

commit 6f89da1f39
Author: tamasmeszaros <meszaros.q@gmail.com>
Date:   Thu Feb 4 20:31:50 2021 +0100

    Disable libicu for boost-regex

    Should have been disabled from the beginning

commit ffc77b1a72a0be9b5622fd33defeebb24bf07b34
Author: Vojtech Bubnik <bubnikv@gmail.com>
Date:   Thu Feb 4 18:40:33 2021 +0100

    EdgeGrid: Annotated those methods that do not work with open contours.

commit 8039a645b4bf0c46c99b90a9c34e7189d7442f86
Author: Vojtech Bubnik <bubnikv@gmail.com>
Date:   Thu Feb 4 18:28:21 2021 +0100

    Refactoring of EdgeGrid structure to support both closed and open lines.
This commit is contained in:
Vojtech Bubnik 2021-02-05 11:20:04 +01:00
parent 6f89da1f39
commit 5f86d11c74
6 changed files with 272 additions and 187 deletions
Download patch file Download diff file Expand all files Collapse all files

95
src/libslic3r/EdgeGrid.hpp
View file

@ -12,6 +12,63 @@
namespace Slic3r {
namespace EdgeGrid {
class Contour {
public:
Contour() = default;
Contour(const Slic3r::Point *begin, const Slic3r::Point *end, bool open) : m_begin(begin), m_end(end), m_open(open) {}
Contour(const Slic3r::Point *data, size_t size, bool open) : Contour(data, data + size, open) {}
Contour(const std::vector<Slic3r::Point> &pts, bool open) : Contour(pts.data(), pts.size(), open) {}
const Slic3r::Point *begin() const { return m_begin; }
const Slic3r::Point *end() const { return m_end; }
bool open() const { return m_open; }
bool closed() const { return ! m_open; }
// Start point of a segment idx.
const Slic3r::Point& segment_start(size_t idx) const {
assert(idx < this->num_segments());
return m_begin[idx];
}
// End point of a segment idx.
const Slic3r::Point& segment_end(size_t idx) const {
assert(idx < this->num_segments());
const Slic3r::Point *ptr = m_begin + idx + 1;
return ptr == m_end ? *m_begin : *ptr;
}
// Start point of a segment preceding idx.
const Slic3r::Point& segment_prev(size_t idx) const {
assert(idx < this->num_segments());
assert(idx > 0 || ! m_open);
return idx == 0 ? m_end[-1] : m_begin[idx - 1];
}
// Index of a segment preceding idx.
const size_t segment_idx_prev(size_t idx) const {
assert(idx < this->num_segments());
assert(idx > 0 || ! m_open);
return (idx == 0 ? this->size() : idx) - 1;
}
// Index of a segment preceding idx.
const size_t segment_idx_next(size_t idx) const {
assert(idx < this->num_segments());
++ idx;
return m_begin + idx == m_end ? 0 : idx;
}
size_t num_segments() const { return this->size() - (m_open ? 1 : 0); }
private:
size_t size() const { return m_end - m_begin; }
const Slic3r::Point *m_begin { nullptr };
const Slic3r::Point *m_end { nullptr };
bool m_open { false };
};
class Grid
{
public:
@ -21,14 +78,24 @@ public:
void set_bbox(const BoundingBox &bbox) { m_bbox = bbox; }
// Fill in the grid with open polylines or closed contours.
// If open flag is indicated, then polylines_or_polygons are considered to be open by default.
// Only if the first point of a polyline is equal to the last point of a polyline,
// then the polyline is considered to be closed and the last repeated point is removed when
// inserted into the EdgeGrid.
// Most of the Grid functions expect all the contours to be closed, you have been warned!
void create(const std::vector<Points> &polylines_or_polygons, coord_t resolution, bool open);
void create(const Polygons &polygons, const Polylines &polylines, coord_t resolution);
// Fill in the grid with closed contours.
void create(const Polygons &polygons, coord_t resolution);
void create(const std::vector<const Polygon*> &polygons, coord_t resolution);
void create(const std::vector<Points> &polygons, coord_t resolution);
void create(const std::vector<Points> &polygons, coord_t resolution) { this->create(polygons, resolution, false); }
void create(const ExPolygon &expoly, coord_t resolution);
void create(const ExPolygons &expolygons, coord_t resolution);
void create(const ExPolygonCollection &expolygons, coord_t resolution);
const std::vector<const Slic3r::Points*>& contours() const { return m_contours; }
const std::vector<Contour>& contours() const { return m_contours; }
#if 0
// Test, whether the edges inside the grid intersect with the polygons provided.
@ -45,12 +112,14 @@ public:
// Fill in a rough m_signed_distance_field from the edge grid.
// The rough SDF is used by signed_distance() for distances outside of the search_radius.
// Only call this function for closed contours!
void calculate_sdf();
// Return an estimate of the signed distance based on m_signed_distance_field grid.
float signed_distance_bilinear(const Point &pt) const;
// Calculate a signed distance to the contours in search_radius from the point.
// Only call this function for closed contours!
struct ClosestPointResult {
size_t contour_idx = size_t(-1);
size_t start_point_idx = size_t(-1);
@ -61,12 +130,14 @@ public:
bool valid() const { return contour_idx != size_t(-1); }
};
ClosestPointResult closest_point(const Point &pt, coord_t search_radius) const;
ClosestPointResult closest_point_signed_distance(const Point &pt, coord_t search_radius) const;
// Only call this function for closed contours!
bool signed_distance_edges(const Point &pt, coord_t search_radius, coordf_t &result_min_dist, bool *pon_segment = nullptr) const;
// Calculate a signed distance to the contours in search_radius from the point. If no edge is found in search_radius,
// return an interpolated value from m_signed_distance_field, if it exists.
// Only call this function for closed contours!
bool signed_distance(const Point &pt, coord_t search_radius, coordf_t &result_min_dist) const;
const BoundingBox& bbox() const { return m_bbox; }
@ -77,8 +148,8 @@ public:
// For supports: Contours enclosing the rasterized edges.
Polygons contours_simplified(coord_t offset, bool fill_holes) const;
typedef std::pair<const Slic3r::Points*, size_t> ContourPoint;
typedef std::pair<const Slic3r::Points*, size_t> ContourEdge;
typedef std::pair<const Contour*, size_t> ContourPoint;
typedef std::pair<const Contour*, size_t> ContourEdge;
std::vector<std::pair<ContourEdge, ContourEdge>> intersecting_edges() const;
bool has_intersecting_edges() const;
@ -256,16 +327,16 @@ public:
std::pair<const Slic3r::Point&, const Slic3r::Point&> segment(const std::pair<size_t, size_t> &contour_and_segment_idx) const
{
const Slic3r::Points &ipts = *m_contours[contour_and_segment_idx.first];
size_t ipt = contour_and_segment_idx.second;
return std::pair<const Slic3r::Point&, const Slic3r::Point&>(ipts[ipt], ipts[ipt + 1 == ipts.size() ? 0 : ipt + 1]);
const Contour &contour = m_contours[contour_and_segment_idx.first];
size_t iseg = contour_and_segment_idx.second;
return std::pair<const Slic3r::Point&, const Slic3r::Point&>(contour.segment_start(iseg), contour.segment_end(iseg));
}
Line line(const std::pair<size_t, size_t> &contour_and_segment_idx) const
{
const Slic3r::Points &ipts = *m_contours[contour_and_segment_idx.first];
size_t ipt = contour_and_segment_idx.second;
return Line(ipts[ipt], ipts[ipt + 1 == ipts.size() ? 0 : ipt + 1]);
const Contour &contour = m_contours[contour_and_segment_idx.first];
size_t iseg = contour_and_segment_idx.second;
return Line(contour.segment_start(iseg), contour.segment_end(iseg));
}
protected:
@ -302,7 +373,7 @@ protected:
// Referencing the source contours.
// This format allows one to work with any Slic3r fixed point contour format
// (Polygon, ExPolygon, ExPolygonCollection etc).
std::vector<const Slic3r::Points*> m_contours;
std::vector<Contour> m_contours;
// Referencing a contour and a line segment of m_contours.
std::vector<std::pair<size_t, size_t> > m_cell_data;