mirror of
https://github.com/SoftFever/OrcaSlicer.git
synced 2025-07-11 08:47:52 -06:00
Ported automatic hole to polyhole conversion from superslicer (#2336)
I've ported automatic polyhole conversion from super slicer. I'm happy to change the PR as required. Closes #626
This commit is contained in:
commit
cd17209516
10 changed files with 189 additions and 2 deletions
|
@ -152,6 +152,145 @@ std::vector<std::reference_wrapper<const PrintRegion>> PrintObject::all_regions(
|
|||
return out;
|
||||
}
|
||||
|
||||
Polygons create_polyholes(const Point center, const coord_t radius, const coord_t nozzle_diameter, bool multiple)
|
||||
{
|
||||
// n = max(round(2 * d), 3); // for 0.4mm nozzle
|
||||
size_t nb_edges = (int)std::max(3, (int)std::round(4.0 * unscaled(radius) * 0.4 / unscaled(nozzle_diameter)));
|
||||
// cylinder(h = h, r = d / cos (180 / n), $fn = n);
|
||||
//create x polyholes by rotation if multiple
|
||||
int nb_polyhole = 1;
|
||||
float rotation = 0;
|
||||
if (multiple) {
|
||||
nb_polyhole = 5;
|
||||
rotation = 2 * float(PI) / (nb_edges * nb_polyhole);
|
||||
}
|
||||
Polygons list;
|
||||
for (int i_poly = 0; i_poly < nb_polyhole; i_poly++)
|
||||
list.emplace_back();
|
||||
for (int i_poly = 0; i_poly < nb_polyhole; i_poly++) {
|
||||
Polygon& pts = (((i_poly % 2) == 0) ? list[i_poly / 2] : list[(nb_polyhole + 1) / 2 + i_poly / 2]);
|
||||
const float new_radius = radius / float(std::cos(PI / nb_edges));
|
||||
for (size_t i_edge = 0; i_edge < nb_edges; ++i_edge) {
|
||||
float angle = rotation * i_poly + (float(PI) * 2 * (float)i_edge) / nb_edges;
|
||||
pts.points.emplace_back(center.x() + new_radius * cos(angle), center.y() + new_radius * sin(angle));
|
||||
}
|
||||
pts.make_clockwise();
|
||||
}
|
||||
//alternate
|
||||
return list;
|
||||
}
|
||||
|
||||
// Detect and convert holes to polyholes, implementation is ported from SuperSlicer
|
||||
void PrintObject::_transform_hole_to_polyholes()
|
||||
{
|
||||
// get all circular holes for each layer
|
||||
// the id is center-diameter-extruderid
|
||||
//the tuple is Point center; float diameter_max; int extruder_id; coord_t max_variation; bool twist;
|
||||
std::vector<std::vector<std::pair<std::tuple<Point, float, int, coord_t, bool>, Polygon*>>> layerid2center;
|
||||
for (size_t i = 0; i < this->m_layers.size(); i++) layerid2center.emplace_back();
|
||||
tbb::parallel_for(
|
||||
tbb::blocked_range<size_t>(0, m_layers.size()),
|
||||
[this, &layerid2center](const tbb::blocked_range<size_t>& range) {
|
||||
for (size_t layer_idx = range.begin(); layer_idx < range.end(); ++layer_idx) {
|
||||
m_print->throw_if_canceled();
|
||||
Layer* layer = m_layers[layer_idx];
|
||||
for (size_t region_idx = 0; region_idx < layer->m_regions.size(); ++region_idx)
|
||||
{
|
||||
if (layer->m_regions[region_idx]->region().config().hole_to_polyhole) {
|
||||
for (Surface& surf : layer->m_regions[region_idx]->slices.surfaces) {
|
||||
for (Polygon& hole : surf.expolygon.holes) {
|
||||
//test if convex (as it's clockwise bc it's a hole, we have to do the opposite)
|
||||
if (hole.convex_points(PI).empty() && hole.points.size() > 8) {
|
||||
// Computing circle center
|
||||
Point center = hole.centroid();
|
||||
double diameter_min = std::numeric_limits<float>::max(), diameter_max = 0;
|
||||
double diameter_sum = 0;
|
||||
for (int i = 0; i < hole.points.size(); ++i) {
|
||||
double dist = hole.points[i].distance_to(center);
|
||||
diameter_min = std::min(diameter_min, dist);
|
||||
diameter_max = std::max(diameter_max, dist);
|
||||
diameter_sum += dist;
|
||||
}
|
||||
//also use center of lines to check it's not a rectangle
|
||||
double diameter_line_min = std::numeric_limits<float>::max(), diameter_line_max = 0;
|
||||
Lines hole_lines = hole.lines();
|
||||
for (Line l : hole_lines) {
|
||||
Point midline = (l.a + l.b) / 2;
|
||||
double dist = center.distance_to(midline);
|
||||
diameter_line_min = std::min(diameter_line_min, dist);
|
||||
diameter_line_max = std::max(diameter_line_max, dist);
|
||||
}
|
||||
|
||||
|
||||
// SCALED_EPSILON was a bit too harsh. Now using a config, as some may want some harsh setting and some don't.
|
||||
coord_t max_variation = std::max(SCALED_EPSILON, scale_(this->m_layers[layer_idx]->m_regions[region_idx]->region().config().hole_to_polyhole_threshold.get_abs_value(unscaled(diameter_sum / hole.points.size()))));
|
||||
bool twist = this->m_layers[layer_idx]->m_regions[region_idx]->region().config().hole_to_polyhole_twisted.value;
|
||||
if (diameter_max - diameter_min < max_variation * 2 && diameter_line_max - diameter_line_min < max_variation * 2) {
|
||||
layerid2center[layer_idx].emplace_back(
|
||||
std::tuple<Point, float, int, coord_t, bool>{center, diameter_max, layer->m_regions[region_idx]->region().config().wall_filament.value, max_variation, twist}, & hole);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
// for layer->slices, it will be also replaced later.
|
||||
}
|
||||
});
|
||||
//sort holes per center-diameter
|
||||
std::map<std::tuple<Point, float, int, coord_t, bool>, std::vector<std::pair<Polygon*, int>>> id2layerz2hole;
|
||||
|
||||
//search & find hole that span at least X layers
|
||||
const size_t min_nb_layers = 2;
|
||||
for (size_t layer_idx = 0; layer_idx < this->m_layers.size(); ++layer_idx) {
|
||||
for (size_t hole_idx = 0; hole_idx < layerid2center[layer_idx].size(); ++hole_idx) {
|
||||
//get all other same polygons
|
||||
std::tuple<Point, float, int, coord_t, bool>& id = layerid2center[layer_idx][hole_idx].first;
|
||||
float max_z = layers()[layer_idx]->print_z;
|
||||
std::vector<std::pair<Polygon*, int>> holes;
|
||||
holes.emplace_back(layerid2center[layer_idx][hole_idx].second, layer_idx);
|
||||
for (size_t search_layer_idx = layer_idx + 1; search_layer_idx < this->m_layers.size(); ++search_layer_idx) {
|
||||
if (layers()[search_layer_idx]->print_z - layers()[search_layer_idx]->height - max_z > EPSILON) break;
|
||||
//search an other polygon with same id
|
||||
for (size_t search_hole_idx = 0; search_hole_idx < layerid2center[search_layer_idx].size(); ++search_hole_idx) {
|
||||
std::tuple<Point, float, int, coord_t, bool>& search_id = layerid2center[search_layer_idx][search_hole_idx].first;
|
||||
if (std::get<2>(id) == std::get<2>(search_id)
|
||||
&& std::get<0>(id).distance_to(std::get<0>(search_id)) < std::get<3>(id)
|
||||
&& std::abs(std::get<1>(id) - std::get<1>(search_id)) < std::get<3>(id)
|
||||
) {
|
||||
max_z = layers()[search_layer_idx]->print_z;
|
||||
holes.emplace_back(layerid2center[search_layer_idx][search_hole_idx].second, search_layer_idx);
|
||||
layerid2center[search_layer_idx].erase(layerid2center[search_layer_idx].begin() + search_hole_idx);
|
||||
search_hole_idx--;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
//check if strait hole or first layer hole (cause of first layer compensation)
|
||||
if (holes.size() >= min_nb_layers || (holes.size() == 1 && holes[0].second == 0)) {
|
||||
id2layerz2hole.emplace(std::move(id), std::move(holes));
|
||||
}
|
||||
}
|
||||
}
|
||||
//create a polyhole per id and replace holes points by it.
|
||||
for (auto entry : id2layerz2hole) {
|
||||
Polygons polyholes = create_polyholes(std::get<0>(entry.first), std::get<1>(entry.first), scale_(print()->config().nozzle_diameter.get_at(std::get<2>(entry.first) - 1)), std::get<4>(entry.first));
|
||||
for (auto& poly_to_replace : entry.second) {
|
||||
Polygon polyhole = polyholes[poly_to_replace.second % polyholes.size()];
|
||||
//search the clone in layers->slices
|
||||
for (ExPolygon& explo_slice : m_layers[poly_to_replace.second]->lslices) {
|
||||
for (Polygon& poly_slice : explo_slice.holes) {
|
||||
if (poly_slice.points == poly_to_replace.first->points) {
|
||||
poly_slice.points = polyhole.points;
|
||||
}
|
||||
}
|
||||
}
|
||||
// copy
|
||||
poly_to_replace.first->points = polyhole.points;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// 1) Merges typed region slices into stInternal type.
|
||||
// 2) Increases an "extra perimeters" counter at region slices where needed.
|
||||
// 3) Generates perimeters, gap fills and fill regions (fill regions of type stInternal).
|
||||
|
@ -816,6 +955,9 @@ bool PrintObject::invalidate_state_by_config_options(
|
|||
|| opt_key == "max_bridge_length"
|
||||
|| opt_key == "support_interface_top_layers"
|
||||
|| opt_key == "support_critical_regions_only"
|
||||
|| opt_key == "hole_to_polyhole"
|
||||
|| opt_key == "hole_to_polyhole_threshold"
|
||||
|| opt_key == "hole_to_polyhole_twisted"
|
||||
) {
|
||||
steps.emplace_back(posSlice);
|
||||
} else if (opt_key == "enable_support") {
|
||||
|
|
Loading…
Add table
Add a link
Reference in a new issue