diff --git a/src/libslic3r/Fill/Fill.cpp b/src/libslic3r/Fill/Fill.cpp index 4f5c839da..60c34db7c 100644 --- a/src/libslic3r/Fill/Fill.cpp +++ b/src/libslic3r/Fill/Fill.cpp @@ -61,6 +61,7 @@ struct SurfaceFillParams : FillParams RETURN_COMPARE_NON_EQUAL(flow.nozzle_diameter); RETURN_COMPARE_NON_EQUAL_TYPED(unsigned, flow.bridge); RETURN_COMPARE_NON_EQUAL_TYPED(unsigned, role); + RETURN_COMPARE_NON_EQUAL_TYPED(int32_t, priority); return false; } @@ -79,7 +80,8 @@ struct SurfaceFillParams : FillParams this->anchor_length_max == rhs.anchor_length_max&& this->fill_exactly == rhs.fill_exactly && this->flow == rhs.flow && - this->role == rhs.role; + this->role == rhs.role && + this->priority == rhs.priority; } }; @@ -117,6 +119,7 @@ std::vector group_fills(const Layer &layer) params.density = float(region_config.fill_density) / 100.f; params.dont_adjust = false; params.connection = region_config.infill_connection.value; + params.priority = 0; if (surface.has_fill_solid()) { params.density = 1.f; @@ -142,6 +145,7 @@ std::vector group_fills(const Layer &layer) is_denser = true; is_bridge = true; params.pattern = ipRectiWithPerimeter; + params.priority = surface.priority; params.connection = InfillConnection::icConnected; } if (params.density <= 0 && !is_denser) @@ -256,7 +260,9 @@ std::vector group_fills(const Layer &layer) Polygons all_polygons; for (SurfaceFill &fill : surface_fills) if (! fill.expolygons.empty()) { - if (fill.expolygons.size() > 1 || ! all_polygons.empty()) { + if (fill.params.priority > 0) { + append(all_polygons, to_polygons(fill.expolygons)); + }else if (fill.expolygons.size() > 1 || !all_polygons.empty()) { Polygons polys = to_polygons(std::move(fill.expolygons)); // Make a union of polygons, use a safety offset, subtract the preceding polygons. // Bridges are processed first (see SurfaceFill::operator<()) @@ -390,14 +396,46 @@ void Layer::make_fills(FillAdaptive::Octree* adaptive_fill_octree, FillAdaptive: std::vector surface_fills = group_fills(*this); const Slic3r::BoundingBox bbox = this->object()->bounding_box(); + std::sort(surface_fills.begin(), surface_fills.end(), [](SurfaceFill& s1, SurfaceFill& s2) { + if (s1.region_id == s2.region_id) + return s1.params.priority < s2.params.priority; + return s1.region_id < s2.region_id; + }); + #ifdef SLIC3R_DEBUG_SLICE_PROCESSING { static int iRun = 0; export_group_fills_to_svg(debug_out_path("Layer-fill_surfaces-10_fill-final-%d.svg", iRun ++).c_str(), surface_fills); } #endif /* SLIC3R_DEBUG_SLICE_PROCESSING */ - + std::vector fills_by_priority; + auto store_fill = [&fills_by_priority, this](size_t region_id) { + if (fills_by_priority.size() == 1) { + m_regions[region_id]->fills.append(fills_by_priority[0]->entities); + delete fills_by_priority[0]; + } else { + m_regions[region_id]->fills.no_sort = true; + ExtrusionEntityCollection* eec = new ExtrusionEntityCollection(); + eec->no_sort = true; + m_regions[region_id]->fills.entities.push_back(eec); + for (ExtrusionEntityCollection* per_priority : fills_by_priority) { + if (!per_priority->entities.empty()) + eec->entities.push_back(per_priority); + else + delete per_priority; + } + } + fills_by_priority.clear(); + }; + //surface_fills is sorted by region_id + size_t current_region_id = -1; for (SurfaceFill &surface_fill : surface_fills) { + // store the region fill when changing region. + if (current_region_id != size_t(-1) && current_region_id != surface_fill.region_id) { + store_fill(current_region_id); + } + current_region_id = surface_fill.region_id; + // Create the filler object. std::unique_ptr f = std::unique_ptr(Fill::new_from_type(surface_fill.params.pattern)); f->set_bounding_box(bbox); @@ -471,10 +509,14 @@ void Layer::make_fills(FillAdaptive::Octree* adaptive_fill_octree, FillAdaptive: surface_fill.surface.expolygon = std::move(expoly); //make fill - f->fill_surface_extrusion(&surface_fill.surface, surface_fill.params, m_regions[surface_fill.region_id]->fills.entities); + while ((size_t)surface_fill.params.priority >= fills_by_priority.size()) + fills_by_priority.push_back(new ExtrusionEntityCollection()); + f->fill_surface_extrusion(&surface_fill.surface, surface_fill.params, fills_by_priority[(size_t)surface_fill.params.priority]->entities); } } } + if(current_region_id != size_t(-1)) + store_fill(current_region_id); // add thin fill regions // Unpacks the collection, creates multiple collections per path. @@ -482,15 +524,35 @@ void Layer::make_fills(FillAdaptive::Octree* adaptive_fill_octree, FillAdaptive: // Why the paths are unpacked? for (LayerRegion *layerm : m_regions) for (const ExtrusionEntity *thin_fill : layerm->thin_fills.entities) { - ExtrusionEntityCollection &collection = *(new ExtrusionEntityCollection()); - layerm->fills.entities.push_back(&collection); - collection.entities.push_back(thin_fill->clone()); + ExtrusionEntityCollection *collection = new ExtrusionEntityCollection(); + if (layerm->fills.no_sort && layerm->fills.entities.size() > 0 && layerm->fills.entities[0]->is_collection()) { + ExtrusionEntityCollection* no_sort_fill = static_cast(layerm->fills.entities[0]); + if (no_sort_fill->no_sort && no_sort_fill->entities.size() > 0 && no_sort_fill->entities[0]->is_collection()) + static_cast(no_sort_fill->entities[0])->entities.push_back(collection); + } else + layerm->fills.entities.push_back(collection); + collection->entities.push_back(thin_fill->clone()); } #ifndef NDEBUG for (LayerRegion *layerm : m_regions) - for (size_t i = 0; i < layerm->fills.entities.size(); ++ i) - assert(dynamic_cast(layerm->fills.entities[i]) != nullptr); + for (size_t i1 = 0; i1 < layerm->fills.entities.size(); ++i1) { + assert(dynamic_cast(layerm->fills.entities[i1]) != nullptr); + if (layerm->fills.no_sort && layerm->fills.entities.size() > 0 && i1 == 0){ + ExtrusionEntityCollection* no_sort_fill = static_cast(layerm->fills.entities[0]); + assert(no_sort_fill != nullptr); + assert(!no_sort_fill->empty()); + for (size_t i2 = 0; i2 < no_sort_fill->entities.size(); ++i2) { + ExtrusionEntityCollection* priority_fill = dynamic_cast(no_sort_fill->entities[i2]); + assert(priority_fill != nullptr); + assert(!priority_fill->empty()); + if (no_sort_fill->no_sort) { + for (size_t i3 = 0; i3 < priority_fill->entities.size(); ++i3) + assert(dynamic_cast(priority_fill->entities[i3]) != nullptr); + } + } + } + } #endif } diff --git a/src/libslic3r/Fill/FillBase.hpp b/src/libslic3r/Fill/FillBase.hpp index afdcf833a..0fee1fe56 100644 --- a/src/libslic3r/Fill/FillBase.hpp +++ b/src/libslic3r/Fill/FillBase.hpp @@ -71,8 +71,11 @@ struct FillParams // if role == erNone or ERCustom, this method have to choose the best role itself, else it must use the argument's role. ExtrusionRole role { erNone }; - //flow to use - Flow flow = Flow(0.f, 0.f, 0.f, 1.f, false); + // flow to use + Flow flow = Flow(0.f, 0.f, 0.f, 1.f, false); + + // to order the fills by priority + int32_t priority = 0; //full configuration for the region, to avoid copying every bit that is needed. Use this for process-specific parameters. PrintRegionConfig const *config{ nullptr }; diff --git a/src/libslic3r/PrintObject.cpp b/src/libslic3r/PrintObject.cpp index 126db9a2c..4dcb35599 100644 --- a/src/libslic3r/PrintObject.cpp +++ b/src/libslic3r/PrintObject.cpp @@ -1044,23 +1044,33 @@ namespace Slic3r { return polygon_reduced; } - // find one of the smallest polygon, growing polygon_to_check, only using point into allowedPoints and covering polygon_to_cover. - ExPolygons dense_fill_fit_to_size(const ExPolygon& polygon_to_cover, const ExPolygons& allowedPoints_todel, + // find one of the smallest polygon, growing polygon_to_cover, only using point into growing_area and covering polygon_to_cover. + ExPolygons dense_fill_fit_to_size(const ExPolygon& bad_polygon_to_cover, const ExPolygon& growing_area, const coord_t offset, float coverage) { + //fix uncoverable area + ExPolygons polygons_to_cover = intersection_ex(bad_polygon_to_cover, growing_area); + if (polygons_to_cover.size() != 1) + return { bad_polygon_to_cover }; + const ExPolygon polygon_to_cover = polygons_to_cover.front(); + //grow the polygon_to_check enough to cover polygon_to_cover float current_coverage = coverage; coord_t previous_offset = 0; coord_t current_offset = offset; - //ExPolygon polygon_reduced = try_fit_to_size(polygon_to_cover, allowedPoints); ExPolygon polygon_reduced = try_fit_to_size2(polygon_to_cover, growing_area); - ExPolygon polygon_check; - ExPolygons polygon_checks = offset_ex(intersection(ExPolygons{ polygon_to_cover }, allowedPoints_todel), -SCALED_RESOLUTION); - if (polygon_checks.empty()) - polygon_check = polygon_to_cover; - else - polygon_check = polygon_checks[0]; - while (!diff_ex(polygon_check, polygon_reduced).empty()) { + while (polygon_reduced.empty()) { + current_offset *= 2; + ExPolygons bigger_polygon = offset_ex(polygon_to_cover, double(current_offset)); + if (bigger_polygon.size() != 1) break; + bigger_polygon = intersection_ex(bigger_polygon[0], growing_area); + if (bigger_polygon.size() != 1) break; + polygon_reduced = try_fit_to_size2(bigger_polygon[0], growing_area); + } + //ExPolygons to_check = offset_ex(polygon_to_cover, -offset); + int idx = 0; + ExPolygons not_covered = diff_ex(polygon_to_cover, polygon_reduced, true); + while (!not_covered.empty()) { //not enough, use a bigger offset float percent_coverage = (float)(polygon_reduced.area() / growing_area.area()); float next_coverage = percent_coverage + (percent_coverage - current_coverage) * 4; @@ -1083,6 +1093,7 @@ namespace Slic3r { } //polygon_reduced = try_fit_to_size(bigger_polygon[0], allowedPoints); polygon_reduced = try_fit_to_size2(bigger_polygon[0], growing_area); + not_covered = diff_ex(polygon_to_cover, polygon_reduced, true); } //ok, we have a good one, now try to optimise (unless there are almost no growth) if (current_offset > offset * 3) { @@ -1102,7 +1113,8 @@ namespace Slic3r { } //ExPolygon polygon_test = try_fit_to_size(bigger_polygon[0], allowedPoints); ExPolygon polygon_test = try_fit_to_size2(bigger_polygon[0], growing_area); - if (!diff_ex(polygon_to_cover, polygon_test).empty()) { + not_covered = diff_ex(polygon_to_cover, polygon_test, true); + if (!not_covered.empty()) { //bad, not enough, use a bigger offset previous_offset = new_offset; } else { @@ -1114,7 +1126,16 @@ namespace Slic3r { } //return the area which cover the growing_area. Intersect it to retreive the holes. - return intersection_ex(polygon_reduced, growing_area); + ExPolygons to_print = intersection_ex(polygon_reduced, growing_area); + + //remove polygon not in intersectino with polygon_to_cover + for (int i = 0; i < (int)to_print.size(); i++) { + if (intersection_ex(to_print[i], polygon_to_cover).empty()) { + to_print.erase(to_print.begin() + i); + i--; + } + } + return to_print; } void PrintObject::tag_under_bridge() { @@ -1140,99 +1161,140 @@ namespace Slic3r { previousOne = layerm; continue; } - Surfaces surf_to_add; - for (Surface& surf : layerm->fill_surfaces.surfaces) { - surf.maxNbSolidLayersOnTop = -1; - if (!surf.has_fill_solid()) { + Surfaces surfs_to_add; + for (Surface& surface : layerm->fill_surfaces.surfaces) { + surface.maxNbSolidLayersOnTop = -1; + if (!surface.has_fill_solid()) { + Surfaces surf_to_add; ExPolygons dense_polys; - ExPolygons sparse_polys = { surf.expolygon }; - //find the surface which intersect with the smallest maxNb possible - for (Surface& upp : previousOne->fill_surfaces.surfaces) { - if (upp.has_fill_solid()) { - // i'm using intersection_ex because the result different than - // upp.expolygon.overlaps(surf.expolygon) or surf.expolygon.overlaps(upp.expolygon) - //and a little offset2 to remove the almost supported area - ExPolygons intersect = - offset2_ex( - intersection_ex(sparse_polys, { upp.expolygon }, true) - , (float)-layerm->flow(frInfill).scaled_width(), (float)layerm->flow(frInfill).scaled_width()); - if (!intersect.empty()) { - double area_intersect = 0; - // calculate area to decide if area is small enough for autofill - if (layerm->region()->config().infill_dense_algo.value == dfaAutoNotFull || layerm->region()->config().infill_dense_algo.value == dfaAutoOrEnlarged) - for (ExPolygon poly_inter : intersect) - area_intersect += poly_inter.area(); + std::vector dense_priority; + ExPolygons surfs_with_overlap = { surface.expolygon }; + ////create a surface with overlap to allow the dense thing to bond to the infill + coord_t scaled_width = layerm->flow(frInfill, true).scaled_width(); + coord_t overlap = scaled_width / 4; + for (const ExPolygon& surf_with_overlap : surfs_with_overlap) { + ExPolygons sparse_polys = { surf_with_overlap }; + //find the surface which intersect with the smallest maxNb possible + for (Surface& upp : previousOne->fill_surfaces.surfaces) { + if (upp.has_fill_solid()) { + // i'm using intersection_ex because the result different than + // upp.expolygon.overlaps(surf.expolygon) or surf.expolygon.overlaps(upp.expolygon) + //and a little offset2 to remove the almost supported area + ExPolygons intersect = + offset2_ex( + intersection_ex(sparse_polys, { upp.expolygon }, true) + , (float)-layerm->flow(frInfill).scaled_width() / 4, (float)layerm->flow(frInfill).scaled_width() / 4); + if (!intersect.empty()) { + double area_intersect = 0; + // calculate area to decide if area is small enough for autofill + if (layerm->region()->config().infill_dense_algo.value == dfaAutoNotFull || layerm->region()->config().infill_dense_algo.value == dfaAutoOrEnlarged) + for (ExPolygon poly_inter : intersect) + area_intersect += poly_inter.area(); - if (layerm->region()->config().infill_dense_algo.value == dfaEnlarged - || (layerm->region()->config().infill_dense_algo.value == dfaAutoOrEnlarged && surf.area() <= area_intersect * COEFF_SPLIT)) { - //expand the area a bit - intersect = offset_ex(intersect, double(scale_(layerm->region()->config().external_infill_margin.get_abs_value( - region->config().perimeters == 0 ? 0 : (layerm->flow(frExternalPerimeter).width + layerm->flow(frPerimeter).spacing() * (region->config().perimeters - 1)))))); - } else if (layerm->region()->config().infill_dense_algo.value == dfaAutoNotFull - || layerm->region()->config().infill_dense_algo.value == dfaAutomatic) { + double surf_with_overlap_area = surf_with_overlap.area(); + if (layerm->region()->config().infill_dense_algo.value == dfaEnlarged + || (layerm->region()->config().infill_dense_algo.value == dfaAutoOrEnlarged && surf_with_overlap_area <= area_intersect * COEFF_SPLIT)) { + //expand the area a bit + intersect = offset_ex(intersect, double(scale_(layerm->region()->config().external_infill_margin.get_abs_value( + region->config().perimeters == 0 ? 0 : (layerm->flow(frExternalPerimeter).width + layerm->flow(frPerimeter).spacing() * (region->config().perimeters - 1)))))); + } else if (layerm->region()->config().infill_dense_algo.value == dfaAutoNotFull + || layerm->region()->config().infill_dense_algo.value == dfaAutomatic) { - //like intersect.empty() but more resilient - if (layerm->region()->config().infill_dense_algo.value == dfaAutomatic - || surf.area() > area_intersect * COEFF_SPLIT) { - ExPolygons cover_intersect; + //like intersect.empty() but more resilient + if (layerm->region()->config().infill_dense_algo.value == dfaAutomatic + || surf_with_overlap_area > area_intersect * COEFF_SPLIT) { + ExPolygons cover_intersect; - // it will be a dense infill, split the surface if needed - //ExPolygons cover_intersect; - for (ExPolygon& expoly_tocover : intersect) { - ExPolygons temp = dense_fill_fit_to_size( - expoly_tocover, - diff_ex(offset_ex(layerm->fill_no_overlap_expolygons, double(layerm->flow(frInfill).scaled_width())), offset_ex(layerm->fill_no_overlap_expolygons, double(-layerm->flow(frInfill).scaled_width()))), - surf.expolygon, - 4 * layerm->flow(frInfill).scaled_width(), - 0.01f); - cover_intersect.insert(cover_intersect.end(), temp.begin(), temp.end()); + // it will be a dense infill, split the surface if needed + //ExPolygons cover_intersect; + for (ExPolygon& expoly_tocover : intersect) { + ExPolygons temp = dense_fill_fit_to_size( + expoly_tocover, + surf_with_overlap, + 4 * layerm->flow(frInfill).scaled_width(), + 0.01f); + cover_intersect.insert(cover_intersect.end(), temp.begin(), temp.end()); + } + intersect = cover_intersect; + } else { + intersect.clear(); } - intersect = cover_intersect; - } else { - intersect.clear(); + } + if (!intersect.empty()) { + + ExPolygons sparse_surfaces = diff_ex(sparse_polys, intersect, true); + ExPolygons dense_surfaces = diff_ex(sparse_polys, sparse_surfaces, true); + for (ExPolygon& poly : intersect) { + uint16_t priority = 1; + ExPolygons dense = { poly }; + for (size_t idx_dense = 0; idx_dense < dense_polys.size(); idx_dense++) { + ExPolygons dense_test = diff_ex(dense, { dense_polys[idx_dense] }, true); + if (dense_test != dense) { + priority = std::max(priority, uint16_t(dense_priority[idx_dense] + 1)); + } + dense = dense_test; + } + dense_polys.insert(dense_polys.end(), dense.begin(), dense.end()); + for (int i = 0; i < dense.size(); i++) + dense_priority.push_back(priority); + } + //assign (copy) + sparse_polys = std::move(sparse_surfaces); + } } - if (!intersect.empty()) { - ExPolygons sparse_surfaces = diff_ex(sparse_polys, intersect, true); - ExPolygons dense_surfaces = diff_ex(sparse_polys, sparse_surfaces, true); - //assign (copy) - sparse_polys = std::move(sparse_surfaces); - dense_polys.insert(dense_polys.end(), dense_surfaces.begin(), dense_surfaces.end()); - } } + //check if we are full-dense + if (sparse_polys.empty()) break; } - //check if we are full-dense - if (sparse_polys.empty()) break; - } - //check if we need to split the surface - if (!dense_polys.empty()) { - double area_dense = 0; - for (ExPolygon poly_inter : dense_polys) area_dense += poly_inter.area(); - double area_sparse = 0; - for (ExPolygon poly_inter : sparse_polys) area_sparse += poly_inter.area(); - if (area_sparse > area_dense * 0.1) { - //split - dense_polys = union_ex(dense_polys); - for (ExPolygon dense_poly : dense_polys) { - Surface dense_surf(surf, dense_poly); - dense_surf.maxNbSolidLayersOnTop = 1; - surf_to_add.push_back(dense_surf); + //check if we need to split the surface + if (!dense_polys.empty()) { + double area_dense = 0; + for (ExPolygon poly_inter : dense_polys) area_dense += poly_inter.area(); + double area_sparse = 0; + for (ExPolygon poly_inter : sparse_polys) area_sparse += poly_inter.area(); + // if almost no empty space, simplify by filling everything (else) + if (area_sparse > area_dense * 0.1) { + //split + //dense_polys = union_ex(dense_polys); + for (int idx_dense = 0; idx_dense < dense_polys.size(); idx_dense++) { + ExPolygon dense_poly = dense_polys[idx_dense]; + //remove overlap with perimeter + ExPolygons offseted_dense_polys = intersection_ex({ dense_poly }, layerm->fill_no_overlap_expolygons); + //add overlap with everything + offseted_dense_polys = offset_ex(offseted_dense_polys, overlap); + for (ExPolygon offseted_dense_poly : offseted_dense_polys) { + Surface dense_surf(surface, offseted_dense_poly); + dense_surf.maxNbSolidLayersOnTop = 1; + dense_surf.priority = dense_priority[idx_dense]; + surf_to_add.push_back(dense_surf); + } + } + sparse_polys = union_ex(sparse_polys); + for (ExPolygon sparse_poly : sparse_polys) { + Surface sparse_surf(surface, sparse_poly); + surf_to_add.push_back(sparse_surf); + } + //layerm->fill_surfaces.surfaces.erase(it_surf); + } else { + surface.maxNbSolidLayersOnTop = 1; + surf_to_add.clear(); + surf_to_add.push_back(surface); + break; } - sparse_polys = union_ex(sparse_polys); - for (ExPolygon sparse_poly : sparse_polys) { - Surface sparse_surf(surf, sparse_poly); - surf_to_add.push_back(sparse_surf); - } - //layerm->fill_surfaces.surfaces.erase(it_surf); } else { - surf.maxNbSolidLayersOnTop = 1; - surf_to_add.push_back(surf); + surf_to_add.clear(); + surf_to_add.emplace_back(std::move(surface)); + // mitigation: if not possible, don't try the others. + break; } - } else surf_to_add.emplace_back(std::move(surf)); - } else surf_to_add.emplace_back(std::move(surf)); + } + // break go here + surfs_to_add.insert(surfs_to_add.begin(), surf_to_add.begin(), surf_to_add.end()); + } else surfs_to_add.emplace_back(std::move(surface)); } - layerm->fill_surfaces.surfaces = std::move(surf_to_add); + layerm->fill_surfaces.surfaces = std::move(surfs_to_add); previousOne = layerm; } } diff --git a/src/libslic3r/Surface.hpp b/src/libslic3r/Surface.hpp index e7e4871be..09d935f58 100644 --- a/src/libslic3r/Surface.hpp +++ b/src/libslic3r/Surface.hpp @@ -60,42 +60,50 @@ public: unsigned short thickness_layers; // in layers double bridge_angle; // in radians, ccw, 0 = East, only 0+ (negative means undefined) unsigned short extra_perimeters; + //for dense infill uint16_t maxNbSolidLayersOnTop; + uint16_t priority; Surface(const Slic3r::Surface &rhs) : surface_type(rhs.surface_type), expolygon(rhs.expolygon), thickness(rhs.thickness), thickness_layers(rhs.thickness_layers), bridge_angle(rhs.bridge_angle), extra_perimeters(rhs.extra_perimeters), - maxNbSolidLayersOnTop(rhs.maxNbSolidLayersOnTop) + maxNbSolidLayersOnTop(rhs.maxNbSolidLayersOnTop), + priority(rhs.priority) {}; Surface(SurfaceType _surface_type, const ExPolygon &_expolygon) : surface_type(_surface_type), expolygon(_expolygon), thickness(-1), thickness_layers(1), bridge_angle(-1), extra_perimeters(0), - maxNbSolidLayersOnTop(-1) + maxNbSolidLayersOnTop(-1), + priority(0) {}; Surface(const Surface &other, const ExPolygon &_expolygon) : surface_type(other.surface_type), expolygon(_expolygon), thickness(other.thickness), thickness_layers(other.thickness_layers), bridge_angle(other.bridge_angle), extra_perimeters(other.extra_perimeters), - maxNbSolidLayersOnTop(other.maxNbSolidLayersOnTop) + maxNbSolidLayersOnTop(other.maxNbSolidLayersOnTop), + priority(other.priority) {}; Surface(Surface &&rhs) : surface_type(rhs.surface_type), expolygon(std::move(rhs.expolygon)), thickness(rhs.thickness), thickness_layers(rhs.thickness_layers), bridge_angle(rhs.bridge_angle), extra_perimeters(rhs.extra_perimeters), - maxNbSolidLayersOnTop(rhs.maxNbSolidLayersOnTop) + maxNbSolidLayersOnTop(rhs.maxNbSolidLayersOnTop), + priority(rhs.priority) {}; Surface(SurfaceType _surface_type, const ExPolygon &&_expolygon) : surface_type(_surface_type), expolygon(std::move(_expolygon)), - thickness(-1), thickness_layers(1), bridge_angle(-1), extra_perimeters(0), - maxNbSolidLayersOnTop(-1) + thickness(-1), thickness_layers(1), bridge_angle(-1), extra_perimeters(0), + maxNbSolidLayersOnTop(-1), + priority(-1) {}; Surface(const Surface &other, const ExPolygon &&_expolygon) : surface_type(other.surface_type), expolygon(std::move(_expolygon)), thickness(other.thickness), thickness_layers(other.thickness_layers), bridge_angle(other.bridge_angle), extra_perimeters(other.extra_perimeters), - maxNbSolidLayersOnTop(other.maxNbSolidLayersOnTop) + maxNbSolidLayersOnTop(other.maxNbSolidLayersOnTop), + priority(other.priority) {}; Surface& operator=(const Surface &rhs) @@ -107,6 +115,7 @@ public: bridge_angle = rhs.bridge_angle; extra_perimeters = rhs.extra_perimeters; maxNbSolidLayersOnTop = rhs.maxNbSolidLayersOnTop; + priority = rhs.priority; return *this; } @@ -119,6 +128,7 @@ public: bridge_angle = rhs.bridge_angle; extra_perimeters = rhs.extra_perimeters; maxNbSolidLayersOnTop = rhs.maxNbSolidLayersOnTop; + priority = rhs.priority; return *this; }