void combineInfillLayers(SliceMeshStorage& storage,unsigned int amount) { if(amount <= 1) //If we must combine 1 layer, nothing needs to be combined. Combining 0 layers is invalid. { return; } if(storage.layers.empty() || storage.layers.size() - 1 < static_cast<size_t>(storage.getSettingAsCount("top_layers")) || storage.getSettingAsCount("infill_line_distance") <= 0) //No infill is even generated. { return; } /* We need to round down the layer index we start at to the nearest divisible index. Otherwise we get some parts that have infill at divisible layers and some at non-divisible layers. Those layers would then miss each other. */ size_t min_layer = storage.getSettingAsCount("bottom_layers") + amount - 1; min_layer -= min_layer % amount; //Round upwards to the nearest layer divisible by infill_sparse_combine. size_t max_layer = storage.layers.size() - 1 - storage.getSettingAsCount("top_layers"); max_layer -= max_layer % amount; //Round downwards to the nearest layer divisible by infill_sparse_combine. for(size_t layer_idx = min_layer;layer_idx <= max_layer;layer_idx += amount) //Skip every few layers, but extrude more. { SliceLayer* layer = &storage.layers[layer_idx]; for(unsigned int n = 1;n < amount;n++) { if(layer_idx < n) { break; } SliceLayer* layer2 = &storage.layers[layer_idx - n]; for(SliceLayerPart& part : layer->parts) { Polygons result; for(SliceLayerPart& part2 : layer2->parts) { if(part.boundaryBox.hit(part2.boundaryBox)) { Polygons intersection = part.infill_area[n - 1].intersection(part2.infill_area[0]).offset(-200).offset(200); result.add(intersection); part.infill_area[n - 1] = part.infill_area[n - 1].difference(intersection); part2.infill_area[0] = part2.infill_area[0].difference(intersection); } } part.infill_area.push_back(result); } } } }
void FffPolygonGenerator::processFuzzyWalls(SliceMeshStorage& mesh) { if (mesh.getSettingAsCount("wall_line_count") == 0) { return; } int64_t fuzziness = mesh.getSettingInMicrons("magic_fuzzy_skin_thickness"); int64_t avg_dist_between_points = mesh.getSettingInMicrons("magic_fuzzy_skin_point_dist"); int64_t min_dist_between_points = avg_dist_between_points * 3 / 4; // hardcoded: the point distance may vary between 3/4 and 5/4 the supplied value int64_t range_random_point_dist = avg_dist_between_points / 2; for (unsigned int layer_nr = 0; layer_nr < mesh.layers.size(); layer_nr++) { SliceLayer& layer = mesh.layers[layer_nr]; for (SliceLayerPart& part : layer.parts) { Polygons results; Polygons& skin = (mesh.getSettingAsSurfaceMode("magic_mesh_surface_mode") == ESurfaceMode::SURFACE)? part.outline : part.insets[0]; for (PolygonRef poly : skin) { // generate points in between p0 and p1 PolygonRef result = results.newPoly(); int64_t dist_left_over = rand() % (min_dist_between_points / 2); // the distance to be traversed on the line before making the first new point Point* p0 = &poly.back(); for (Point& p1 : poly) { // 'a' is the (next) new point between p0 and p1 Point p0p1 = p1 - *p0; int64_t p0p1_size = vSize(p0p1); int64_t dist_last_point = dist_left_over + p0p1_size * 2; // so that p0p1_size - dist_last_point evaulates to dist_left_over - p0p1_size for (int64_t p0pa_dist = dist_left_over; p0pa_dist < p0p1_size; p0pa_dist += min_dist_between_points + rand() % range_random_point_dist) { int r = rand() % (fuzziness * 2) - fuzziness; Point perp_to_p0p1 = turn90CCW(p0p1); Point fuzz = normal(perp_to_p0p1, r); Point pa = *p0 + normal(p0p1, p0pa_dist) + fuzz; result.add(pa); dist_last_point = p0pa_dist; } dist_left_over = p0p1_size - dist_last_point; p0 = &p1; } while (result.size() < 3 ) { unsigned int point_idx = poly.size() - 2; result.add(poly[point_idx]); if (point_idx == 0) { break; } point_idx--; } if (result.size() < 3) { result.clear(); for (Point& p : poly) result.add(p); } } skin = results; } } }
void FffPolygonGenerator::processInsets(SliceMeshStorage& mesh, unsigned int layer_nr) { SliceLayer* layer = &mesh.layers[layer_nr]; if (mesh.getSettingAsSurfaceMode("magic_mesh_surface_mode") != ESurfaceMode::SURFACE) { int inset_count = mesh.getSettingAsCount("wall_line_count"); if (mesh.getSettingBoolean("magic_spiralize") && static_cast<int>(layer_nr) < mesh.getSettingAsCount("bottom_layers") && layer_nr % 2 == 1)//Add extra insets every 2 layers when spiralizing, this makes bottoms of cups watertight. inset_count += 5; int line_width_x = mesh.getSettingInMicrons("wall_line_width_x"); int line_width_0 = mesh.getSettingInMicrons("wall_line_width_0"); if (mesh.getSettingBoolean("alternate_extra_perimeter")) inset_count += layer_nr % 2; bool recompute_outline_based_on_outer_wall = mesh.getSettingBoolean("support_enable"); WallsComputation walls_computation(mesh.getSettingInMicrons("wall_0_inset"), line_width_0, line_width_x, inset_count, recompute_outline_based_on_outer_wall); walls_computation.generateInsets(layer); } if (mesh.getSettingAsSurfaceMode("magic_mesh_surface_mode") != ESurfaceMode::NORMAL) { for (PolygonRef polyline : layer->openPolyLines) { Polygons segments; for (unsigned int point_idx = 1; point_idx < polyline.size(); point_idx++) { PolygonRef segment = segments.newPoly(); segment.add(polyline[point_idx-1]); segment.add(polyline[point_idx]); } } } }
void FffPolygonGenerator::processSkinsAndInfill(SliceMeshStorage& mesh, unsigned int layer_nr) { if (mesh.getSettingAsSurfaceMode("magic_mesh_surface_mode") == ESurfaceMode::SURFACE) { return; } int wall_line_count = mesh.getSettingAsCount("wall_line_count"); int skin_extrusion_width = mesh.getSettingInMicrons("skin_line_width"); int innermost_wall_extrusion_width = (wall_line_count == 1)? mesh.getSettingInMicrons("wall_line_width_0") : mesh.getSettingInMicrons("wall_line_width_x"); generateSkins(layer_nr, mesh, skin_extrusion_width, mesh.getSettingAsCount("bottom_layers"), mesh.getSettingAsCount("top_layers"), wall_line_count, innermost_wall_extrusion_width, mesh.getSettingAsCount("skin_outline_count"), mesh.getSettingBoolean("skin_no_small_gaps_heuristic")); if (mesh.getSettingInMicrons("infill_line_distance") > 0) { int infill_skin_overlap = 0; bool infill_is_dense = mesh.getSettingInMicrons("infill_line_distance") < mesh.getSettingInMicrons("infill_line_width") + 10; if (!infill_is_dense && mesh.getSettingAsFillMethod("infill_pattern") != EFillMethod::CONCENTRIC) { infill_skin_overlap = skin_extrusion_width / 2; } generateInfill(layer_nr, mesh, innermost_wall_extrusion_width, infill_skin_overlap, wall_line_count); } }
SkinInfillAreaComputation::SkinInfillAreaComputation(int layer_nr, const SliceDataStorage& storage, SliceMeshStorage& mesh, bool process_infill) : layer_nr(layer_nr) , mesh(mesh) , bottom_layer_count(mesh.getSettingAsCount("bottom_layers")) , top_layer_count(mesh.getSettingAsCount("top_layers")) , wall_line_count(mesh.getSettingAsCount("wall_line_count")) , skin_line_width(getSkinLineWidth(storage, mesh, layer_nr)) , wall_line_width_0(getWallLineWidth0(storage, mesh, layer_nr)) , wall_line_width_x(getWallLineWidthX(storage, mesh, layer_nr)) , innermost_wall_line_width((wall_line_count == 1) ? wall_line_width_0 : wall_line_width_x) , infill_skin_overlap(getInfillSkinOverlap(storage, mesh, layer_nr, innermost_wall_line_width)) , skin_inset_count(mesh.getSettingAsCount("skin_outline_count")) , no_small_gaps_heuristic(mesh.getSettingBoolean("skin_no_small_gaps_heuristic")) , process_infill(process_infill) , top_reference_wall_expansion(mesh.getSettingInMicrons("top_skin_preshrink")) , bottom_reference_wall_expansion(mesh.getSettingInMicrons("bottom_skin_preshrink")) , top_skin_expand_distance(mesh.getSettingInMicrons("top_skin_expand_distance")) , bottom_skin_expand_distance(mesh.getSettingInMicrons("bottom_skin_expand_distance")) , top_reference_wall_idx(getReferenceWallIdx(top_reference_wall_expansion)) , bottom_reference_wall_idx(getReferenceWallIdx(bottom_reference_wall_expansion)) { }
void combineInfillLayers(SliceMeshStorage& mesh, unsigned int amount) { if (mesh.layers.empty() || mesh.layers.size() - 1 < static_cast<size_t>(mesh.getSettingAsCount("top_layers")) || mesh.getSettingAsCount("infill_line_distance") <= 0) //No infill is even generated. { return; } if(amount <= 1) //If we must combine 1 layer, nothing needs to be combined. Combining 0 layers is invalid. { return; } /* We need to round down the layer index we start at to the nearest divisible index. Otherwise we get some parts that have infill at divisible layers and some at non-divisible layers. Those layers would then miss each other. */ size_t min_layer = mesh.getSettingAsCount("bottom_layers") + amount - 1; min_layer -= min_layer % amount; //Round upwards to the nearest layer divisible by infill_sparse_combine. size_t max_layer = mesh.layers.size() - 1 - mesh.getSettingAsCount("top_layers"); max_layer -= max_layer % amount; //Round downwards to the nearest layer divisible by infill_sparse_combine. for(size_t layer_idx = min_layer;layer_idx <= max_layer;layer_idx += amount) //Skip every few layers, but extrude more. { SliceLayer* layer = &mesh.layers[layer_idx]; for(unsigned int combine_count_here = 1; combine_count_here < amount; combine_count_here++) { if(layer_idx < combine_count_here) { break; } size_t lower_layer_idx = layer_idx - combine_count_here; if (lower_layer_idx < min_layer) { break; } SliceLayer* lower_layer = &mesh.layers[lower_layer_idx]; for (SliceLayerPart& part : layer->parts) { for (unsigned int density_idx = 0; density_idx < part.infill_area_per_combine_per_density.size(); density_idx++) { // go over each density of gradual infill (these density areas overlap!) std::vector<Polygons>& infill_area_per_combine = part.infill_area_per_combine_per_density[density_idx]; Polygons result; for (SliceLayerPart& lower_layer_part : lower_layer->parts) { if (part.boundaryBox.hit(lower_layer_part.boundaryBox)) { Polygons intersection = infill_area_per_combine[combine_count_here - 1].intersection(lower_layer_part.infill_area).offset(-200).offset(200); result.add(intersection); // add area to be thickened infill_area_per_combine[combine_count_here - 1] = infill_area_per_combine[combine_count_here - 1].difference(intersection); // remove thickened area from less thick layer here if (density_idx < lower_layer_part.infill_area_per_combine_per_density.size()) { // only remove from *same density* areas on layer below // If there are no same density areas, then it's ok to print them anyway // Don't remove other density areas unsigned int lower_density_idx = density_idx; std::vector<Polygons>& lower_infill_area_per_combine = lower_layer_part.infill_area_per_combine_per_density[lower_density_idx]; lower_infill_area_per_combine[0] = lower_infill_area_per_combine[0].difference(intersection); // remove thickened area from lower (thickened) layer } } } infill_area_per_combine.push_back(result); } } } } }
void SkinInfillAreaComputation::generateGradualInfill(SliceMeshStorage& mesh, unsigned int gradual_infill_step_height, unsigned int max_infill_steps) { // no early-out for this function; it needs to initialize the [infill_area_per_combine_per_density] float layer_skip_count = 8; // skip every so many layers as to ignore small gaps in the model making computation more easy if (!mesh.getSettingBoolean("skin_no_small_gaps_heuristic")) { layer_skip_count = 1; } unsigned int gradual_infill_step_layer_count = gradual_infill_step_height / mesh.getSettingInMicrons("layer_height"); // The difference in layer count between consecutive density infill areas // make gradual_infill_step_height divisable by layer_skip_count float n_skip_steps_per_gradual_step = std::max(1.0f, std::ceil(gradual_infill_step_layer_count / layer_skip_count)); // only decrease layer_skip_count to make it a divisor of gradual_infill_step_layer_count layer_skip_count = gradual_infill_step_layer_count / n_skip_steps_per_gradual_step; size_t min_layer = mesh.getSettingAsCount("bottom_layers"); size_t max_layer = mesh.layers.size() - 1 - mesh.getSettingAsCount("top_layers"); for (size_t layer_idx = 0; layer_idx < mesh.layers.size(); layer_idx++) { // loop also over layers which don't contain infill cause of bottom_ and top_layer to initialize their infill_area_per_combine_per_density SliceLayer& layer = mesh.layers[layer_idx]; for (SliceLayerPart& part : layer.parts) { assert(part.infill_area_per_combine_per_density.size() == 0 && "infill_area_per_combine_per_density is supposed to be uninitialized"); const Polygons& infill_area = part.getOwnInfillArea(); if (infill_area.size() == 0 || layer_idx < min_layer || layer_idx > max_layer) { // initialize infill_area_per_combine_per_density empty part.infill_area_per_combine_per_density.emplace_back(); // create a new infill_area_per_combine part.infill_area_per_combine_per_density.back().emplace_back(); // put empty infill area in the newly constructed infill_area_per_combine // note: no need to copy part.infill_area, cause it's the empty vector anyway continue; } Polygons less_dense_infill = infill_area; // one step less dense with each infill_step for (unsigned int infill_step = 0; infill_step < max_infill_steps; infill_step++) { size_t min_layer = layer_idx + infill_step * gradual_infill_step_layer_count + layer_skip_count; size_t max_layer = layer_idx + (infill_step + 1) * gradual_infill_step_layer_count; for (float upper_layer_idx = min_layer; static_cast<unsigned int>(upper_layer_idx) <= max_layer; upper_layer_idx += layer_skip_count) { if (static_cast<unsigned int>(upper_layer_idx) >= mesh.layers.size()) { less_dense_infill.clear(); break; } SliceLayer& upper_layer = mesh.layers[static_cast<unsigned int>(upper_layer_idx)]; Polygons relevent_upper_polygons; for (SliceLayerPart& upper_layer_part : upper_layer.parts) { if (!upper_layer_part.boundaryBox.hit(part.boundaryBox)) { continue; } relevent_upper_polygons.add(upper_layer_part.getOwnInfillArea()); } less_dense_infill = less_dense_infill.intersection(relevent_upper_polygons); } if (less_dense_infill.size() == 0) { break; } // add new infill_area_per_combine for the current density part.infill_area_per_combine_per_density.emplace_back(); std::vector<Polygons>& infill_area_per_combine_current_density = part.infill_area_per_combine_per_density.back(); const Polygons more_dense_infill = infill_area.difference(less_dense_infill); infill_area_per_combine_current_density.push_back(more_dense_infill); if (less_dense_infill.size() == 0) { break; } } part.infill_area_per_combine_per_density.emplace_back(); std::vector<Polygons>& infill_area_per_combine_current_density = part.infill_area_per_combine_per_density.back(); infill_area_per_combine_current_density.push_back(infill_area); part.infill_area_own = nullptr; // clear infill_area_own, it's not needed any more. assert(part.infill_area_per_combine_per_density.size() != 0 && "infill_area_per_combine_per_density is now initialized"); } } }