diff --git a/src/libslic3r/PrintConfig.cpp b/src/libslic3r/PrintConfig.cpp index d32caf3c0..bab9109b7 100644 --- a/src/libslic3r/PrintConfig.cpp +++ b/src/libslic3r/PrintConfig.cpp @@ -2770,8 +2770,10 @@ void PrintConfigDef::init_fff_params() def->enum_keys_map = &ConfigOptionEnum::get_enum_values(); def->enum_values.push_back("grid"); def->enum_values.push_back("snug"); + def->enum_values.push_back("tree"); def->enum_labels.push_back(L("Grid")); def->enum_labels.push_back(L("Snug")); + def->enum_labels.push_back(L("Tree")); def->mode = comAdvanced; def->set_default_value(new ConfigOptionEnum(smsGrid)); diff --git a/src/libslic3r/PrintConfig.hpp b/src/libslic3r/PrintConfig.hpp index 9e1d7989d..88ebd9470 100644 --- a/src/libslic3r/PrintConfig.hpp +++ b/src/libslic3r/PrintConfig.hpp @@ -60,7 +60,7 @@ enum InfillPattern : int { ipRectilinear, ipMonotonic, ipAlignedRectilinear, ipGrid, ipTriangles, ipStars, ipCubic, ipLine, ipConcentric, ipHoneycomb, ip3DHoneycomb, ipGyroid, ipHilbertCurve, ipArchimedeanChords, ipOctagramSpiral, ipAdaptiveCubic, ipSupportCubic, ipSupportBase, ipLightning, -ipCount, + ipCount, }; enum class IroningType { @@ -85,7 +85,7 @@ enum SupportMaterialPattern { }; enum SupportMaterialStyle { - smsGrid, smsSnug, + smsGrid, smsSnug, smsTree, }; enum SupportMaterialInterfacePattern { diff --git a/src/libslic3r/PrintObject.cpp b/src/libslic3r/PrintObject.cpp index aef501922..29cccd24e 100644 --- a/src/libslic3r/PrintObject.cpp +++ b/src/libslic3r/PrintObject.cpp @@ -8,6 +8,7 @@ #include "Layer.hpp" #include "MutablePolygon.hpp" #include "SupportMaterial.hpp" +#include "TreeSupport.hpp" #include "Surface.hpp" #include "Slicing.hpp" #include "Tesselate.hpp" @@ -2127,8 +2128,13 @@ void PrintObject::combine_infill() void PrintObject::_generate_support_material() { - PrintObjectSupportMaterial support_material(this, m_slicing_params); - support_material.generate(*this); + if (m_config.support_material_style == smsTree) { + TreeSupport tree_support; + tree_support.generateSupportAreas(); + } else { + PrintObjectSupportMaterial support_material(this, m_slicing_params); + support_material.generate(*this); + } } static void project_triangles_to_slabs(ConstLayerPtrsAdaptor layers, const indexed_triangle_set &custom_facets, const Transform3f &tr, bool seam, std::vector &out) diff --git a/src/libslic3r/TreeModelVolumes.cpp b/src/libslic3r/TreeModelVolumes.cpp index 4f445a307..ee208c545 100644 --- a/src/libslic3r/TreeModelVolumes.cpp +++ b/src/libslic3r/TreeModelVolumes.cpp @@ -9,164 +9,217 @@ #include "TreeModelVolumes.hpp" #include "TreeSupport.hpp" +#include "BuildVolume.hpp" +#include "ClipperUtils.hpp" +#include "Flow.hpp" +#include "Layer.hpp" +#include "Point.hpp" +#include "Print.hpp" +#include "PrintConfig.hpp" + +#include + #include #include namespace Slic3r { -TreeModelVolumes::TreeModelVolumes(const SliceDataStorage& storage, const coord_t max_move, const coord_t max_move_slow, size_t current_mesh_idx, double progress_multiplier, double progress_offset, const std::vector& additional_excluded_areas) : max_move_{ std::max(max_move - 2, coord_t(0)) }, max_move_slow_{ std::max(max_move_slow - 2, coord_t(0)) }, progress_multiplier{ progress_multiplier }, progress_offset{ progress_offset }, machine_border_{ calculateMachineBorderCollision(storage.getMachineBorder()) } // -2 to avoid rounding errors +TreeSupportMeshGroupSettings::TreeSupportMeshGroupSettings(const PrintObject &print_object) +{ + const PrintConfig &print_config = print_object.print()->config(); + const PrintObjectConfig &config = print_object.config(); + const SlicingParameters &slicing_params = print_object.slicing_parameters(); +// const std::vector printing_extruders = print_object.object_extruders(); + + // Support must be enabled and set to Tree style. + assert(config.support_material); + assert(config.support_material_style == smsTree); + + coordf_t external_perimeter_width = 0.; + for (size_t region_id = 0; region_id < print_object.num_printing_regions(); ++ region_id) { + const PrintRegion ®ion = print_object.printing_region(region_id); + external_perimeter_width = std::max(external_perimeter_width, coordf_t(region.flow(print_object, frExternalPerimeter, config.layer_height).width())); + } + + this->layer_height = scaled(config.layer_height.value); + this->resolution = scaled(print_config.resolution.value); + this->min_feature_size = scaled(config.min_feature_size.value); + this->support_angle = M_PI / 2. - config.support_angle * M_PI / 180.; + this->support_line_width = support_material_flow(&print_object, config.layer_height).scaled_width(); + this->support_roof_line_width = support_material_interface_flow(&print_object, config.layer_height).scaled_width(); + //FIXME add it to SlicingParameters and reuse in both tree and normal supports? + this->support_bottom_enable = config.support_material_interface_layers.value > 0 && config.support_material_bottom_interface_layers.value != 0; + this->support_bottom_height = this->support_bottom_enable ? + (config.support_material_bottom_interface_layers.value > 0 ? + config.support_material_bottom_interface_layers.value : + config.support_material_interface_layers.value) * this->layer_height : + 0; + this->support_material_buildplate_only = config.support_material_buildplate_only; +// this->support_xy_overrides_z = + this->support_xy_distance = scaled(config.support_material_xy_spacing.get_abs_value(external_perimeter_width)); + this->support_xy_distance_overhang = std::min(this->support_xy_distance, scaled(0.5 * external_perimeter_width)); + this->support_top_distance = scaled(slicing_params.gap_support_object); + this->support_bottom_distance = scaled(slicing_params.gap_object_support); +// this->support_interface_skip_height = +// this->support_infill_angles = + this->support_roof_enable = config.support_material_interface_layers.value > 0; + this->support_roof_height = config.support_material_interface_layers.value * this->layer_height; +// this->minimum_roof_area = +// this->support_roof_angles = + this->support_roof_pattern = config.support_material_interface_pattern; + this->support_pattern = config.support_material_pattern; + this->support_line_spacing = scaled(config.support_material_spacing.value); +// this->support_bottom_offset = + this->support_wall_count = config.support_material_with_sheath ? 1 : 0; + this->support_roof_line_distance = scaled(config.support_material_interface_spacing.value) + this->support_roof_line_width; +// this->minimum_support_area = +// this->minimum_bottom_area = +// this->support_offset = +} + +static Polygons calculateMachineBorderCollision(Polygon machine_border) +{ + Polygons machine_volume_border; + // Put a border of 1m around the print volume so that we don't collide. + append(machine_volume_border, offset(machine_border, scaled(1000.))); + machine_border.reverse(); // Makes the polygon negative so that we subtract the actual volume from the collision area. + machine_volume_border.emplace_back(std::move(machine_border)); + return machine_volume_border; +} + +TreeModelVolumes::TreeModelVolumes( + const PrintObject &print_object, + const BuildVolume &build_volume, + const coord_t max_move, const coord_t max_move_slow, size_t current_mesh_idx, + double progress_multiplier, double progress_offset, const std::vector& additional_excluded_areas) : + m_max_move{ std::max(max_move - 2, coord_t(0)) }, m_max_move_slow{ std::max(max_move_slow - 2, coord_t(0)) }, m_progress_multiplier{ progress_multiplier }, m_progress_offset{ progress_offset }, + // -2 to avoid rounding errors + m_machine_border{ calculateMachineBorderCollision(build_volume.polygon()) } { - anti_overhang_ = std::vector(storage.support.supportLayers.size(), Polygons()); std::unordered_map mesh_to_layeroutline_idx; - min_maximum_deviation_ = std::numeric_limits::max(); - min_maximum_resolution_ = std::numeric_limits::max(); - support_rests_on_model = false; - for (size_t mesh_idx = 0; mesh_idx < storage.meshes.size(); mesh_idx++) - { + +#if 0 + for (size_t mesh_idx = 0; mesh_idx < storage.meshes.size(); ++ mesh_idx) { SliceMeshStorage mesh = storage.meshes[mesh_idx]; bool added = false; - for (size_t idx = 0; idx < layer_outlines_.size(); idx++) - { - if (checkSettingsEquality(layer_outlines_[idx].first, mesh.settings)) - { + for (size_t idx = 0; idx < m_layer_outlines.size(); ++ idx) + if (TreeSupport::TreeSupportSettings(m_layer_outlines[idx].first) == TreeSupport::TreeSupportSettings(mesh.settings)) { added = true; mesh_to_layeroutline_idx[mesh_idx] = idx; } - } - if (!added) - { - mesh_to_layeroutline_idx[mesh_idx] = layer_outlines_.size(); - layer_outlines_.emplace_back(mesh.settings, std::vector(storage.support.supportLayers.size(), Polygons())); + if (! added) { + mesh_to_layeroutline_idx[mesh_idx] = m_layer_outlines.size(); + m_layer_outlines.emplace_back(mesh.settings, std::vector(storage.support.supportLayers.size(), Polygons())); } } - - for (auto data_pair : layer_outlines_) - { - support_rests_on_model |= data_pair.first.get("support_type") == ESupportType::EVERYWHERE; - min_maximum_deviation_ = std::min(min_maximum_deviation_, data_pair.first.get("meshfix_maximum_deviation")); - min_maximum_resolution_ = std::min(min_maximum_resolution_, data_pair.first.get("meshfix_maximum_resolution")); - } - - min_maximum_deviation_ = std::min(coord_t(SUPPORT_TREE_MAX_DEVIATION), min_maximum_deviation_); - current_outline_idx = mesh_to_layeroutline_idx[current_mesh_idx]; - TreeSupport::TreeSupportSettings config(layer_outlines_[current_outline_idx].first); - - if (! config.support_xy_overrides_z) - { - current_min_xy_dist = config.xy_min_distance; - - if (TreeSupport::TreeSupportSettings::has_to_rely_on_min_xy_dist_only) - { - current_min_xy_dist = std::max(current_min_xy_dist, coord_t(100)); - } - - current_min_xy_dist_delta = std::max(config.xy_distance - current_min_xy_dist, coord_t(0)); - } - else - { - current_min_xy_dist = config.xy_distance; - current_min_xy_dist_delta = 0; - } - increase_until_radius = config.increase_radius_until_radius; - - for (size_t mesh_idx = 0; mesh_idx < storage.meshes.size(); mesh_idx++) - { - SliceMeshStorage mesh = storage.meshes[mesh_idx]; - - tbb::parallel_for(tbb::blocked_range(0, layer_outlines_[mesh_to_layeroutline_idx[mesh_idx]].second.size()), - [&](const tbb::blocked_range &range) { - for (size_t layer_idx = range.begin(); layer_idx < range.end(); ++ layer_idx) { - if (mesh.layer_nr_max_filled_layer < layer_idx) - { - return; // cant break as parallel_for wont allow it, this is equivalent to a continue - } - Polygons outline = extractOutlineFromMesh(mesh, layer_idx); - layer_outlines_[mesh_to_layeroutline_idx[mesh_idx]].second[layer_idx].add(outline); - } - }); - } - - tbb::parallel_for(tbb::blocked_range(0, anti_overhang_.size()), - [&](const tbb::blocked_range &range) { - for (size_t layer_idx = range.begin(); layer_idx < range.end(); ++ layer_idx) { - if (layer_idx < coord_t(additional_excluded_areas.size())) - { - anti_overhang_[layer_idx].add(additional_excluded_areas[layer_idx]); - } - - if (SUPPORT_TREE_AVOID_SUPPORT_BLOCKER) - { - anti_overhang_[layer_idx].add(storage.support.supportLayers[layer_idx].anti_overhang); - } - - if (storage.primeTower.enabled) - { - anti_overhang_[layer_idx].add(layer_idx == 0 ? storage.primeTower.outer_poly_first_layer : storage.primeTower.outer_poly); - } - anti_overhang_[layer_idx] = anti_overhang_[layer_idx].unionPolygons(); - } - }); - - for (size_t idx = 0; idx < layer_outlines_.size(); idx++) - { - tbb::parallel_for(tbb::blocked_range(0, anti_overhang_.size()), + for (size_t idx = 0; idx < m_layer_outlines.size(); ++ idx) { + tbb::parallel_for(tbb::blocked_range(0, m_layer_outlines[idx].second.size()), [&](const tbb::blocked_range &range) { for (const size_t layer_idx = range.begin(); layer_idx < range.end(); ++ layer_idx) - layer_outlines_[idx].second[layer_idx] = layer_outlines_[idx].second[layer_idx].unionPolygons(); + m_layer_outlines[idx].second[layer_idx] = union_(m_layer_outlines[idx].second[layer_idx]); }); } - radius_0 = config.getRadius(0); -} + m_current_outline_idx = mesh_to_layeroutline_idx[current_mesh_idx]; + m_support_rests_on_model = false; + m_min_resolution = std::numeric_limits::max(); + for (auto data_pair : m_layer_outlines) { + m_support_rests_on_model |= ! data_pair.first.support_material_buildplate_only; + m_min_resolution = std::min(m_min_resolution, data_pair.first.resolution); + } +#else + { + m_anti_overhang = print_object.slice_support_blockers(); + mesh_to_layeroutline_idx[0] = 0; + TreeSupportMeshGroupSettings mesh_settings(print_object); + m_layer_outlines.emplace_back(mesh_settings, std::vector{}); + m_current_outline_idx = 0; + std::vector &outlines = m_layer_outlines.front().second; + outlines.reserve(print_object.layer_count()); + for (const Layer *layer : print_object.layers()) + outlines.emplace_back(to_polygons(expolygons_simplify(layer->lslices, mesh_settings.resolution))); + } +#endif + + const TreeSupport::TreeSupportSettings &config = m_layer_outlines[m_current_outline_idx].first; + if (! config.support_xy_overrides_z) { + m_current_min_xy_dist = config.xy_min_distance; + if (TreeSupport::TreeSupportSettings::has_to_rely_on_min_xy_dist_only) + m_current_min_xy_dist = std::max(m_current_min_xy_dist, coord_t(100)); + m_current_min_xy_dist_delta = std::max(config.xy_distance - m_current_min_xy_dist, coord_t(0)); + } else { + m_current_min_xy_dist = config.xy_distance; + m_current_min_xy_dist_delta = 0; + } + m_increase_until_radius = config.increase_radius_until_radius; + m_radius_0 = config.getRadius(0); + +#if 0 + for (size_t mesh_idx = 0; mesh_idx < storage.meshes.size(); mesh_idx++) { + SliceMeshStorage mesh = storage.meshes[mesh_idx]; + tbb::parallel_for(tbb::blocked_range(0, m_layer_outlines[mesh_to_layeroutline_idx[mesh_idx]].second.size()), + [&](const tbb::blocked_range &range) { + for (size_t layer_idx = range.begin(); layer_idx < range.end(); ++ layer_idx) + if (layer_idx < mesh.layer_nr_max_filled_layer) { + Polygons outline = extractOutlineFromMesh(mesh, layer_idx); + append(m_layer_outlines[mesh_to_layeroutline_idx[mesh_idx]].second[layer_idx], outline); + } + }); + } + if (! additional_excluded_areas.empty()) { + tbb::parallel_for(tbb::blocked_range(0, m_anti_overhang.size()), + [&](const tbb::blocked_range &range) { + for (size_t layer_idx = range.begin(); layer_idx < range.end(); ++ layer_idx) { + if (layer_idx < coord_t(additional_excluded_areas.size())) + append(m_anti_overhang[layer_idx], additional_excluded_areas[layer_idx]); + // if (SUPPORT_TREE_AVOID_SUPPORT_BLOCKER) + // append(m_anti_overhang[layer_idx], storage.support.supportLayers[layer_idx].anti_overhang); + //FIXME block wipe tower + // if (storage.primeTower.enabled) + // append(m_anti_overhang[layer_idx], layer_idx == 0 ? storage.primeTower.outer_poly_first_layer : storage.primeTower.outer_poly); + m_anti_overhang[layer_idx] = union_(m_anti_overhang[layer_idx]); + } + }); + } +#endif +} void TreeModelVolumes::precalculate(coord_t max_layer) { auto t_start = std::chrono::high_resolution_clock::now(); - precalculated = true; + m_precalculated = true; // Get the config corresponding to one mesh that is in the current group. Which one has to be irrelevant. Not the prettiest way to do this, but it ensures some calculations that may be a bit more complex like inital layer diameter are only done in once. - TreeSupport::TreeSupportSettings config(layer_outlines_[current_outline_idx].first); + TreeSupport::TreeSupportSettings config(m_layer_outlines[m_current_outline_idx].first); // calculate which radius each layer in the tip may have. std::unordered_set possible_tip_radiis; - for (size_t dtt = 0; dtt <= config.tip_layers; dtt++) - { + for (size_t dtt = 0; dtt <= config.tip_layers; dtt++) { possible_tip_radiis.emplace(ceilRadius(config.getRadius(dtt))); - possible_tip_radiis.emplace(ceilRadius(config.getRadius(dtt) + current_min_xy_dist_delta)); + possible_tip_radiis.emplace(ceilRadius(config.getRadius(dtt) + m_current_min_xy_dist_delta)); } // It theoretically may happen in the tip, that the radius can change so much in-between 2 layers, that a ceil step is skipped (as in there is a radius r so that ceilRadius(radius(dtt)) radius_until_layer; // while it is possible to calculate, up to which layer the avoidance should be calculated, this simulation is easier to understand, and does not need to be adjusted if something of the radius calculation is changed. // Overhead with an assumed worst case of 6600 layers was about 2ms - for (LayerIndex simulated_dtt = 0; simulated_dtt <= max_layer; simulated_dtt++) - { + for (LayerIndex simulated_dtt = 0; simulated_dtt <= max_layer; simulated_dtt++) { const LayerIndex current_layer = max_layer - simulated_dtt; - const coord_t max_regular_radius = ceilRadius(config.getRadius(simulated_dtt, 0) + current_min_xy_dist_delta); + const coord_t max_regular_radius = ceilRadius(config.getRadius(simulated_dtt, 0) + m_current_min_xy_dist_delta); const coord_t max_min_radius = ceilRadius(config.getRadius(simulated_dtt, 0)); // the maximal radius that the radius with the min_xy_dist can achieve - const coord_t max_initial_layer_diameter_radius = ceilRadius(config.recommendedMinRadius(current_layer) + current_min_xy_dist_delta); + const coord_t max_initial_layer_diameter_radius = ceilRadius(config.recommendedMinRadius(current_layer) + m_current_min_xy_dist_delta); if (!radius_until_layer.count(max_regular_radius)) - { radius_until_layer[max_regular_radius] = current_layer; - } if (!radius_until_layer.count(max_min_radius)) - { radius_until_layer[max_min_radius] = current_layer; - } if (!radius_until_layer.count(max_initial_layer_diameter_radius)) - { radius_until_layer[max_initial_layer_diameter_radius] = current_layer; - } } // Copy to deque to use in parallel for later. @@ -177,13 +230,11 @@ void TreeModelVolumes::precalculate(coord_t max_layer) // Append additional radiis needed for collision. - radius_until_layer[ceilRadius(increase_until_radius, false)] = max_layer; // To calculate collision holefree for every radius, the collision of radius increase_until_radius will be required. + radius_until_layer[ceilRadius(m_increase_until_radius, false)] = max_layer; // To calculate collision holefree for every radius, the collision of radius m_increase_until_radius will be required. // Collision for radius 0 needs to be calculated everywhere, as it will be used to ensure valid xy_distance in drawAreas. radius_until_layer[0] = max_layer; - if (current_min_xy_dist_delta != 0) - { - radius_until_layer[current_min_xy_dist_delta] = max_layer; - } + if (m_current_min_xy_dist_delta != 0) + radius_until_layer[m_current_min_xy_dist_delta] = max_layer; std::deque relevant_collision_radiis; relevant_collision_radiis.insert(relevant_collision_radiis.end(), radius_until_layer.begin(), radius_until_layer.end()); // Now that required_avoidance_limit contains the maximum of ild and regular required radius just copy. @@ -195,12 +246,8 @@ void TreeModelVolumes::precalculate(coord_t max_layer) // calculate a separate Collisions with all holes removed. These are relevant for some avoidances that try to avoid holes (called safe) std::deque relevant_hole_collision_radiis; for (RadiusLayerPair key : relevant_avoidance_radiis) - { - if (key.first < increase_until_radius + current_min_xy_dist_delta) - { + if (key.first < m_increase_until_radius + m_current_min_xy_dist_delta) relevant_hole_collision_radiis.emplace_back(key); - } - } // ### Calculate collisions without holes, build from regular collision calculateCollisionHolefree(relevant_hole_collision_radiis); @@ -212,7 +259,7 @@ void TreeModelVolumes::precalculate(coord_t max_layer) tbb::task_group task_group; task_group.run([this, relevant_avoidance_radiis]{ calculateAvoidance(relevant_avoidance_radiis); }); task_group.run([this, relevant_avoidance_radiis]{ calculateWallRestrictions(relevant_avoidance_radiis); }); - if (support_rests_on_model) + if (m_support_rests_on_model) task_group.run([this, relevant_avoidance_radiis_to_model]{ calculatePlaceables(relevant_avoidance_radiis_to_model); calculateAvoidanceToModel(relevant_avoidance_radiis_to_model); @@ -223,174 +270,143 @@ void TreeModelVolumes::precalculate(coord_t max_layer) auto dur_col = 0.001 * std::chrono::duration_cast(t_coll - t_start).count(); auto dur_avo = 0.001 * std::chrono::duration_cast(t_end - t_coll).count(); - log("Precalculating collision took %.3lf ms. Precalculating avoidance took %.3lf ms.\n", dur_col, dur_avo); + BOOST_LOG_TRIVIAL(info) << "Precalculating collision took" << dur_col << " ms. Precalculating avoidance took " << dur_avo << " ms."; } -const Polygons& TreeModelVolumes::getCollision(coord_t radius, LayerIndex layer_idx, bool min_xy_dist) +/*! + * \brief Checks a cache for a given RadiusLayerPair and returns it if it is found + * \param key RadiusLayerPair of the requested areas. The radius will be calculated up to the provided layer. + * \return A wrapped optional reference of the requested area (if it was found, an empty optional if nothing was found) + */ +std::optional> getArea(const TreeModelVolumes::RadiusLayerPolygonCache& cache, const TreeModelVolumes::RadiusLayerPair& key) +{ + const auto it = cache.find(key); + return it == cache.end() ? std::optional>{} : std::optional>{ it->second }; +} + +const Polygons& TreeModelVolumes::getCollision(coord_t radius, LayerIndex layer_idx, bool min_xy_dist) const { coord_t orig_radius = radius; std::optional> result; if (!min_xy_dist) - { - radius += current_min_xy_dist_delta; - } + radius += m_current_min_xy_dist_delta; // special case as if a radius 0 is requested it could be to ensure correct xy distance. As such it is beneficial if the collision is as close to the configured values as possible. if (orig_radius != 0) - { radius = ceilRadius(radius); - } RadiusLayerPair key{ radius, layer_idx }; { - std::lock_guard critical_section_support_max_layer_nr(*critical_avoidance_cache_); - result = getArea(collision_cache_, key); + std::lock_guard critical_section_support_max_layer_nr(*m_critical_avoidance_cache); + result = getArea(m_collision_cache, key); } if (result) - { return result.value().get(); - } - if (precalculated) - { - logWarning("Had to calculate collision at radius %lld and layer %lld, but precalculate was called. Performance may suffer!\n", key.first, key.second); + if (m_precalculated) { + BOOST_LOG_TRIVIAL(warning) << "Had to calculate collision at radius " << key.first << " and layer " << key.second << ", but precalculate was called. Performance may suffer!"; TreeSupport::showError("Not precalculated Collision requested.", false); } - calculateCollision(key); + const_cast(this)->calculateCollision(key); return getCollision(orig_radius, layer_idx, min_xy_dist); } -const Polygons& TreeModelVolumes::getCollisionHolefree(coord_t radius, LayerIndex layer_idx, bool min_xy_dist) +const Polygons& TreeModelVolumes::getCollisionHolefree(coord_t radius, LayerIndex layer_idx, bool min_xy_dist) const { coord_t orig_radius = radius; std::optional> result; if (!min_xy_dist) - { - radius += current_min_xy_dist_delta; - } - if (radius >= increase_until_radius + current_min_xy_dist_delta) - { + radius += m_current_min_xy_dist_delta; + if (radius >= m_increase_until_radius + m_current_min_xy_dist_delta) return getCollision(orig_radius, layer_idx, min_xy_dist); - } + RadiusLayerPair key{ radius, layer_idx }; { - std::lock_guard critical_section_support_max_layer_nr(*critical_collision_cache_holefree_); - result = getArea(collision_cache_holefree_, key); + std::lock_guard critical_section_support_max_layer_nr(*m_critical_collision_cache_holefree); + result = getArea(m_collision_cache_holefree, key); } if (result) - { return result.value().get(); - } - if (precalculated) - { - logWarning("Had to calculate collision holefree at radius %lld and layer %lld, but precalculate was called. Performance may suffer!\n", key.first, key.second); + if (m_precalculated) { + BOOST_LOG_TRIVIAL(warning) << "Had to calculate collision holefree at radius " << key.first << " and layer " << key.second << ", but precalculate was called. Performance may suffer!"; TreeSupport::showError("Not precalculated Holefree Collision requested.", false); } - calculateCollisionHolefree(key); + const_cast(this)->calculateCollisionHolefree(key); return getCollisionHolefree(orig_radius, layer_idx, min_xy_dist); } -const Polygons& TreeModelVolumes::getAvoidance(coord_t radius, LayerIndex layer_idx, AvoidanceType type, bool to_model, bool min_xy_dist) +const Polygons& TreeModelVolumes::getAvoidance(coord_t radius, LayerIndex layer_idx, AvoidanceType type, bool to_model, bool min_xy_dist) const { if (layer_idx == 0) // What on the layer directly above buildplate do i have to avoid to reach the buildplate ... - { return getCollision(radius, layer_idx, min_xy_dist); - } coord_t orig_radius = radius; std::optional> result; if (!min_xy_dist) - { - radius += current_min_xy_dist_delta; - } + radius += m_current_min_xy_dist_delta; radius = ceilRadius(radius); - if (radius >= increase_until_radius + current_min_xy_dist_delta && type == AvoidanceType::FAST_SAFE) // no holes anymore by definition at this request - { + if (radius >= m_increase_until_radius + m_current_min_xy_dist_delta && type == AvoidanceType::FAST_SAFE) // no holes anymore by definition at this request type = AvoidanceType::FAST; - } const RadiusLayerPair key{ radius, layer_idx }; - std::unordered_map* cache_ptr = nullptr; + const RadiusLayerPolygonCache* cache_ptr = nullptr; std::mutex* mutex_ptr; - if (!to_model && type == AvoidanceType::FAST) - { - cache_ptr = &avoidance_cache_; - mutex_ptr = critical_avoidance_cache_.get(); - } - else if (!to_model && type == AvoidanceType::SLOW) - { - cache_ptr = &avoidance_cache_slow_; - mutex_ptr = critical_avoidance_cache_slow_.get(); - } - else if (!to_model && type == AvoidanceType::FAST_SAFE) - { - cache_ptr = &avoidance_cache_hole_; - mutex_ptr = critical_avoidance_cache_holefree_.get(); - } - else if (to_model && type == AvoidanceType::FAST) - { - cache_ptr = &avoidance_cache_to_model_; - mutex_ptr = critical_avoidance_cache_to_model_.get(); - } - else if (to_model && type == AvoidanceType::SLOW) - { - cache_ptr = &avoidance_cache_to_model_slow_; - mutex_ptr = critical_avoidance_cache_to_model_slow_.get(); - } - else if (to_model && type == AvoidanceType::FAST_SAFE) - { - cache_ptr = &avoidance_cache_hole_to_model_; - mutex_ptr = critical_avoidance_cache_holefree_to_model_.get(); - } - else - { - logError("Invalid Avoidance Request\n"); + if (!to_model && type == AvoidanceType::FAST) { + cache_ptr = &m_avoidance_cache; + mutex_ptr = m_critical_avoidance_cache.get(); + } else if (!to_model && type == AvoidanceType::SLOW) { + cache_ptr = &m_avoidance_cache_slow; + mutex_ptr = m_critical_avoidance_cache_slow.get(); + } else if (!to_model && type == AvoidanceType::FAST_SAFE) { + cache_ptr = &m_avoidance_cache_hole; + mutex_ptr = m_critical_avoidance_cache_holefree.get(); + } else if (to_model && type == AvoidanceType::FAST) { + cache_ptr = &m_avoidance_cache_to_model; + mutex_ptr = m_critical_avoidance_cache_to_model.get(); + } else if (to_model && type == AvoidanceType::SLOW) { + cache_ptr = &m_avoidance_cache_to_model_slow; + mutex_ptr = m_critical_avoidance_cache_to_model_slow.get(); + } else if (to_model && type == AvoidanceType::FAST_SAFE) { + cache_ptr = &m_avoidance_cache_hole_to_model; + mutex_ptr = m_critical_avoidance_cache_holefree_to_model.get(); + } else { + BOOST_LOG_TRIVIAL(error) << "Invalid Avoidance Request"; TreeSupport::showError("Invalid Avoidance Request.\n", true); } - - if (to_model) - { + if (to_model) { { std::lock_guard critical_section(*mutex_ptr); result = getArea(*cache_ptr, key); } if (result) - { return result.value().get(); - } - if (precalculated) - { - logWarning("Had to calculate Avoidance to model at radius %lld and layer %lld, but precalculate was called. Performance may suffer!\n", key.first, key.second); + if (m_precalculated) { + BOOST_LOG_TRIVIAL(warning) << "Had to calculate Avoidance to model at radius " << key.first << " and layer " << key.second << ", but precalculate was called. Performance may suffer!"; TreeSupport::showError("Not precalculated Avoidance(to model) requested.", false); } - calculateAvoidanceToModel(key); - } - else - { + const_cast(this)->calculateAvoidanceToModel(key); + } else { { std::lock_guard critical_section(*mutex_ptr); result = getArea(*cache_ptr, key); } if (result) - { return result.value().get(); - } - if (precalculated) - { - logWarning("Had to calculate Avoidance at radius %lld and layer %lld, but precalculate was called. Performance may suffer!\n", key.first, key.second); + if (m_precalculated) { + BOOST_LOG_TRIVIAL(warning) << "Had to calculate Avoidance at radius " << key.first << " and layer " << key.second << ", but precalculate was called. Performance may suffer!"; TreeSupport::showError("Not precalculated Avoidance(to buildplate) requested.", false); } - calculateAvoidance(key); + const_cast(this)->calculateAvoidance(key); } return getAvoidance(orig_radius, layer_idx, type, to_model, min_xy_dist); // retrive failed and correct result was calculated. Now it has to be retrived. } -const Polygons& TreeModelVolumes::getPlaceableAreas(coord_t radius, LayerIndex layer_idx) +const Polygons& TreeModelVolumes::getPlaceableAreas(coord_t radius, LayerIndex layer_idx) const { std::optional> result; const coord_t orig_radius = radius; @@ -398,116 +414,87 @@ const Polygons& TreeModelVolumes::getPlaceableAreas(coord_t radius, LayerIndex l RadiusLayerPair key{ radius, layer_idx }; { - std::lock_guard critical_section(*critical_placeable_areas_cache_); - result = getArea(placeable_areas_cache_, key); + std::lock_guard critical_section(*m_critical_placeable_areas_cache); + result = getArea(m_placeable_areas_cache, key); } if (result) - { return result.value().get(); - } - if (precalculated) - { - logWarning("Had to calculate Placeable Areas at radius %lld and layer %lld, but precalculate was called. Performance may suffer!\n", radius, layer_idx); + if (m_precalculated) { + BOOST_LOG_TRIVIAL(warning) << "Had to calculate Placeable Areas at radius " << radius << " and layer " << layer_idx << ", but precalculate was called. Performance may suffer!"; TreeSupport::showError("Not precalculated Placeable areas requested.", false); } if (radius != 0) - { - calculatePlaceables(key); - } + const_cast(this)->calculatePlaceables(key); else - { getCollision(0, layer_idx, true); - } return getPlaceableAreas(orig_radius, layer_idx); } - -const Polygons& TreeModelVolumes::getWallRestriction(coord_t radius, LayerIndex layer_idx, bool min_xy_dist) +const Polygons& TreeModelVolumes::getWallRestriction(coord_t radius, LayerIndex layer_idx, bool min_xy_dist) const { if (layer_idx == 0) // Should never be requested as there will be no going below layer 0 ..., but just to be sure some semi-sane catch. Alternative would be empty Polygon. - { return getCollision(radius, layer_idx, min_xy_dist); - } coord_t orig_radius = radius; - min_xy_dist = min_xy_dist && current_min_xy_dist_delta > 0; + min_xy_dist = min_xy_dist && m_current_min_xy_dist_delta > 0; std::optional> result; radius = ceilRadius(radius); const RadiusLayerPair key{ radius, layer_idx }; - std::unordered_map* cache_ptr; - if (min_xy_dist) - { - cache_ptr = &wall_restrictions_cache_min_; - } - else - { - cache_ptr = &wall_restrictions_cache_; - } + const RadiusLayerPolygonCache* cache_ptr = min_xy_dist ? &m_wall_restrictions_cache_min : &m_wall_restrictions_cache; - - if (min_xy_dist) - { + if (min_xy_dist) { { - std::lock_guard critical_section(*critical_wall_restrictions_cache_min_); + std::lock_guard critical_section(*m_critical_wall_restrictions_cache_min); result = getArea(*cache_ptr, key); } if (result) - { return result.value().get(); - } - if (precalculated) - { - logWarning("Had to calculate Wall restricions at radius %lld and layer %lld, but precalculate was called. Performance may suffer!\n", key.first, key.second); + if (m_precalculated) { + BOOST_LOG_TRIVIAL(warning) << "Had to calculate Wall restricions at radius " << key.first << " and layer " << key.second << ", but precalculate was called. Performance may suffer!"; TreeSupport::showError("Not precalculated Wall restriction of minimum xy distance requested ).", false); } - } - else - { + } else { { - std::lock_guard critical_section(*critical_wall_restrictions_cache_); + std::lock_guard critical_section(*m_critical_wall_restrictions_cache); result = getArea(*cache_ptr, key); } if (result) - { return result.value().get(); - } - if (precalculated) - { - logWarning("Had to calculate Wall restricions at radius %lld and layer %lld, but precalculate was called. Performance may suffer!\n", key.first, key.second); + if (m_precalculated) { + BOOST_LOG_TRIVIAL(warning) << "Had to calculate Wall restricions at radius " << key.first << " and layer " << key.second << ", but precalculate was called. Performance may suffer!"; TreeSupport::showError("Not precalculated Wall restriction requested ).", false); } } - calculateWallRestrictions(key); + const_cast(this)->calculateWallRestrictions(key); return getWallRestriction(orig_radius, layer_idx, min_xy_dist); // Retrieve failed and correct result was calculated. Now it has to be retrieved. } coord_t TreeModelVolumes::ceilRadius(coord_t radius, bool min_xy_dist) const { - if (!min_xy_dist) - { - radius += current_min_xy_dist_delta; - } + if (! min_xy_dist) + radius += m_current_min_xy_dist_delta; return ceilRadius(radius); } + coord_t TreeModelVolumes::getRadiusNextCeil(coord_t radius, bool min_xy_dist) const { coord_t ceiled_radius = ceilRadius(radius, min_xy_dist); - - if (!min_xy_dist) - ceiled_radius -= current_min_xy_dist_delta; + if (! min_xy_dist) + ceiled_radius -= m_current_min_xy_dist_delta; return ceiled_radius; } -bool TreeModelVolumes::checkSettingsEquality(const TreeSupportMeshGroupSettings& me, const TreeSupportMeshGroupSettings& other) const +static inline [[nodiscard]] Polygons simplify(const Polygons &polygons, coord_t resolution) { - return TreeSupport::TreeSupportSettings(me) == TreeSupport::TreeSupportSettings(other); + //FIXME + return polygons; } - -Polygons TreeModelVolumes::extractOutlineFromMesh(const SliceMeshStorage& mesh, LayerIndex layer_idx) const +#if 0 +Polygons TreeModelVolumes::extractOutlineFromMesh(const PrintObject &print_object, LayerIndex layer_idx) const { constexpr bool external_polys_only = false; Polygons total; @@ -515,223 +502,172 @@ Polygons TreeModelVolumes::extractOutlineFromMesh(const SliceMeshStorage& mesh, // similar to SliceDataStorage.getLayerOutlines but only for one mesh instead of for everyone if (mesh.settings.get("infill_mesh") || mesh.settings.get("anti_overhang_mesh")) - { return Polygons(); - } + const SliceLayer& layer = mesh.layers[layer_idx]; layer.getOutlines(total, external_polys_only); if (mesh.settings.get("magic_mesh_surface_mode") != ESurfaceMode::NORMAL) - { - total = total.unionPolygons(layer.openPolyLines.offsetPolyLine(100)); - } - coord_t maximum_resolution = mesh.settings.get("meshfix_maximum_resolution"); - coord_t maximum_deviation = mesh.settings.get("meshfix_maximum_deviation"); - total.simplify(maximum_resolution, maximum_deviation); - return total; + total = union_(total, layer.openPolyLines.offsetPolyLine(100)); + coord_t resolution = mesh.settings.get("resolution"); + return simplify(total, resolution); } +#endif -LayerIndex TreeModelVolumes::getMaxCalculatedLayer(coord_t radius, const std::unordered_map& map) const +LayerIndex TreeModelVolumes::getMaxCalculatedLayer(coord_t radius, const RadiusLayerPolygonCache& map) const { LayerIndex max_layer = -1; - // the placeable on model areas do not exist on layer 0, as there can not be model below it. As such it may be possible that layer 1 is available, but layer 0 does not exist. const RadiusLayerPair key_layer_1(radius, 1); if (getArea(map, key_layer_1)) - { max_layer = 1; - } - while (map.count(RadiusLayerPair(radius, max_layer + 1))) - { max_layer++; - } - return max_layer; } - void TreeModelVolumes::calculateCollision(std::deque keys) { tbb::parallel_for(tbb::blocked_range(0, keys.size()), [&](const tbb::blocked_range &range) { - for (const size_t i = range.begin(); i < range.end(); ++ i) { + for (size_t i = range.begin(); i < range.end(); ++ i) { coord_t radius = keys[i].first; RadiusLayerPair key(radius, 0); - std::unordered_map data_outer; - std::unordered_map data_placeable_outer; - for (size_t outline_idx = 0; outline_idx < layer_outlines_.size(); outline_idx++) + RadiusLayerPolygonCache data_outer; + RadiusLayerPolygonCache data_placeable_outer; + for (size_t outline_idx = 0; outline_idx < m_layer_outlines.size(); outline_idx++) { - std::unordered_map data; - std::unordered_map data_placeable; + RadiusLayerPolygonCache data; + RadiusLayerPolygonCache data_placeable; - const coord_t layer_height = layer_outlines_[outline_idx].first.get("layer_height"); - const bool support_rests_on_this_model = layer_outlines_[outline_idx].first.get("support_type") == ESupportType::EVERYWHERE; - const coord_t z_distance_bottom = layer_outlines_[outline_idx].first.get("support_bottom_distance"); + const coord_t layer_height = m_layer_outlines[outline_idx].first.layer_height; + const bool support_rests_on_this_model = ! m_layer_outlines[outline_idx].first.support_material_buildplate_only; + const coord_t z_distance_bottom = m_layer_outlines[outline_idx].first.support_bottom_distance; const size_t z_distance_bottom_layers = round_up_divide(z_distance_bottom, layer_height); - const coord_t z_distance_top_layers = round_up_divide(layer_outlines_[outline_idx].first.get("support_top_distance"), layer_height); - const LayerIndex max_anti_overhang_layer = anti_overhang_.size() - 1; + const coord_t z_distance_top_layers = round_up_divide(m_layer_outlines[outline_idx].first.support_top_distance, layer_height); + const LayerIndex max_anti_overhang_layer = m_anti_overhang.size() - 1; const LayerIndex max_required_layer = keys[i].second + std::max(coord_t(1), z_distance_top_layers); - const coord_t xy_distance = outline_idx == current_outline_idx ? current_min_xy_dist : layer_outlines_[outline_idx].first.get("support_xy_distance"); - // technically this causes collision for the normal xy_distance to be larger by current_min_xy_dist_delta for all not currently processing meshes as this delta will be added at request time. + const coord_t xy_distance = outline_idx == m_current_outline_idx ? m_current_min_xy_dist : m_layer_outlines[outline_idx].first.support_xy_distance; + // technically this causes collision for the normal xy_distance to be larger by m_current_min_xy_dist_delta for all not currently processing meshes as this delta will be added at request time. // avoiding this would require saving each collision for each outline_idx separately. // and later for each avoidance... But avoidance calculation has to be for the whole scene and can NOT be done for each outline_idx separately and combined later. // so avoiding this inaccuracy seems infeasible as it would require 2x the avoidance calculations => 0.5x the performance. coord_t min_layer_bottom; { - std::lock_guard critical_section(*critical_collision_cache_); - min_layer_bottom = getMaxCalculatedLayer(radius, collision_cache_) - z_distance_bottom_layers; + std::lock_guard critical_section(*m_critical_collision_cache); + min_layer_bottom = getMaxCalculatedLayer(radius, m_collision_cache) - z_distance_bottom_layers; } if (min_layer_bottom < 0) - { min_layer_bottom = 0; - } - for (LayerIndex layer_idx = min_layer_bottom; layer_idx <= max_required_layer; layer_idx++) - { + for (LayerIndex layer_idx = min_layer_bottom; layer_idx <= max_required_layer; layer_idx++) { key.second = layer_idx; - Polygons collision_areas = machine_border_; - if (size_t(layer_idx) < layer_outlines_[outline_idx].second.size()) - { - collision_areas.add(layer_outlines_[outline_idx].second[layer_idx]); - } - collision_areas = collision_areas.offset(radius + xy_distance); // jtRound is not needed here, as the overshoot can not cause errors in the algorithm, because no assumptions are made about the model. - data[key].add(collision_areas); // if a key does not exist when it is accessed it is added! + Polygons collision_areas = m_machine_border; + if (size_t(layer_idx) < m_layer_outlines[outline_idx].second.size()) + append(collision_areas, m_layer_outlines[outline_idx].second[layer_idx]); + // jtRound is not needed here, as the overshoot can not cause errors in the algorithm, because no assumptions are made about the model. + collision_areas = offset(union_ex(collision_areas), radius + xy_distance, ClipperLib::jtMiter, 1.2); + append(data[key], collision_areas); // if a key does not exist when it is accessed it is added! } - // Add layers below, to ensure correct support_bottom_distance. Also save placeable areas of radius 0, if required for this mesh. - for (LayerIndex layer_idx = max_required_layer; layer_idx >= min_layer_bottom; layer_idx--) - { + for (LayerIndex layer_idx = max_required_layer; layer_idx >= min_layer_bottom; -- layer_idx) { key.second = layer_idx; - for (size_t layer_offset = 1; layer_offset <= z_distance_bottom_layers && layer_idx - coord_t(layer_offset) > min_layer_bottom; layer_offset++) - { - data[key].add(data[RadiusLayerPair(radius, layer_idx - layer_offset)]); - } - if (support_rests_on_this_model && radius == 0 && layer_idx < coord_t(1 + keys[i].second)) - { - data[key] = data[key].unionPolygons(); + for (size_t layer_offset = 1; layer_offset <= z_distance_bottom_layers && layer_idx - coord_t(layer_offset) > min_layer_bottom; ++ layer_offset) + append(data[key], data[RadiusLayerPair(radius, layer_idx - layer_offset)]); + if (support_rests_on_this_model && radius == 0 && layer_idx < coord_t(1 + keys[i].second)) { + data[key] = union_(data[key]); Polygons above = data[RadiusLayerPair(radius, layer_idx + 1)]; - if (max_anti_overhang_layer >= layer_idx + 1) - { - above = above.unionPolygons(anti_overhang_[layer_idx]); - } - else - { - above = above.unionPolygons(); // just to be sure the area is correctly unioned as otherwise difference may behave unexpectedly. - } - Polygons placeable = data[key].difference(above); - data_placeable[RadiusLayerPair(radius, layer_idx + 1)] = data_placeable[RadiusLayerPair(radius, layer_idx + 1)].unionPolygons(placeable); + // just to be sure the area is correctly unioned as otherwise difference may behave unexpectedly. + above = max_anti_overhang_layer >= layer_idx + 1 ? union_(above, m_anti_overhang[layer_idx]) : union_(above); + Polygons placeable = diff(data[key], above); + data_placeable[RadiusLayerPair(radius, layer_idx + 1)] = union_(data_placeable[RadiusLayerPair(radius, layer_idx + 1)], placeable); } } // Add collision layers above to ensure correct support_top_distance. - for (LayerIndex layer_idx = min_layer_bottom; layer_idx <= max_required_layer; layer_idx++) - { + for (LayerIndex layer_idx = min_layer_bottom; layer_idx <= max_required_layer; layer_idx++) { key.second = layer_idx; for (coord_t layer_offset = 1; layer_offset <= z_distance_top_layers && layer_offset + layer_idx <= max_required_layer; layer_offset++) - { - data[key].add(data[RadiusLayerPair(radius, layer_idx + layer_offset)]); - } - if (max_anti_overhang_layer >= layer_idx) - { - data[key] = data[key].unionPolygons(anti_overhang_[layer_idx].offset(radius)); - } - else - { - data[key] = data[key].unionPolygons(); - } + append(data[key], data[RadiusLayerPair(radius, layer_idx + layer_offset)]); + data[key] = max_anti_overhang_layer >= layer_idx ? union_(data[key], offset(union_ex(m_anti_overhang[layer_idx]), radius, ClipperLib::jtMiter, 1.2)) : union_(data[key]); } - for (LayerIndex layer_idx = max_required_layer; layer_idx > keys[i].second; layer_idx--) - { - data.erase(RadiusLayerPair(radius, layer_idx)); // all these dont have the correct z_distance_top_layers as they can still have areas above them + for (LayerIndex layer_idx = max_required_layer; layer_idx > keys[i].second; layer_idx--) { + // all these dont have the correct z_distance_top_layers as they can still have areas above them + auto it = data.find(RadiusLayerPair(radius, layer_idx)); + if (it != data.end()) + data.erase(it); } - for (auto pair : data) - { - pair.second.simplify(min_maximum_resolution_, min_maximum_deviation_); - data_outer[pair.first] = data_outer[pair.first].unionPolygons(pair.second); + for (auto pair : data) { + pair.second = simplify(pair.second, m_min_resolution); + data_outer[pair.first] = union_(data_outer[pair.first], pair.second); } if (radius == 0) - { - for (auto pair : data_placeable) - { - pair.second.simplify(min_maximum_resolution_, min_maximum_deviation_); - data_placeable_outer[pair.first] = data_placeable_outer[pair.first].unionPolygons(pair.second); + for (auto pair : data_placeable) { + pair.second = simplify(pair.second, m_min_resolution); + data_placeable_outer[pair.first] = union_(data_placeable_outer[pair.first], pair.second); } - } } +#ifdef SLIC3R_TREESUPPORTS_PROGRESS { - std::lock_guard critical_section(*critical_progress); - - if (precalculated && precalculation_progress < TREE_PROGRESS_PRECALC_COLL) - { - precalculation_progress += TREE_PROGRESS_PRECALC_COLL / keys.size(); - Progress::messageProgress(Progress::Stage::SUPPORT, precalculation_progress * progress_multiplier + progress_offset, TREE_PROGRESS_TOTAL); + std::lock_guard critical_section(*m_critical_progress); + if (m_precalculated && m_precalculation_progress < TREE_PROGRESS_PRECALC_COLL) { + m_precalculation_progress += TREE_PROGRESS_PRECALC_COLL / keys.size(); + Progress::messageProgress(Progress::Stage::SUPPORT, m_precalculation_progress * m_progress_multiplier + m_progress_offset, TREE_PROGRESS_TOTAL); } } +#endif { - std::lock_guard critical_section(*critical_collision_cache_); - collision_cache_.insert(data_outer.begin(), data_outer.end()); + std::lock_guard critical_section(*m_critical_collision_cache); + m_collision_cache.insert(data_outer.begin(), data_outer.end()); } - if (radius == 0) - { - { - std::lock_guard critical_section(*critical_placeable_areas_cache_); - placeable_areas_cache_.insert(data_placeable_outer.begin(), data_placeable_outer.end()); - } + if (radius == 0) { + std::lock_guard critical_section(*m_critical_placeable_areas_cache); + m_placeable_areas_cache.insert(data_placeable_outer.begin(), data_placeable_outer.end()); } } }); } + void TreeModelVolumes::calculateCollisionHolefree(std::deque keys) { LayerIndex max_layer = 0; for (long long unsigned int i = 0; i < keys.size(); i++) - { max_layer = std::max(max_layer, keys[i].second); - } tbb::parallel_for(tbb::blocked_range(0, max_layer + 1), [&](const tbb::blocked_range &range) { - for (const size_t layer_idx = range.begin(); layer_idx < range.end(); ++ layer_idx) { - std::unordered_map data; - for (RadiusLayerPair key : keys) - { - // Logically increase the collision by increase_until_radius + for (size_t layer_idx = range.begin(); layer_idx < range.end(); ++ layer_idx) { + RadiusLayerPolygonCache data; + for (RadiusLayerPair key : keys) { + // Logically increase the collision by m_increase_until_radius coord_t radius = key.first; - coord_t increase_radius_ceil = ceilRadius(increase_until_radius, false) - ceilRadius(radius, true); - Polygons col = getCollision(increase_until_radius, layer_idx, false).offset(5 - increase_radius_ceil, ClipperLib::jtRound).unionPolygons(); // this union is important as otherwise holes(in form of lines that will increase to holes in a later step) can get unioned onto the area. - col.simplify(min_maximum_resolution_, min_maximum_deviation_); + coord_t increase_radius_ceil = ceilRadius(m_increase_until_radius, false) - ceilRadius(radius, true); + // this union is important as otherwise holes(in form of lines that will increase to holes in a later step) can get unioned onto the area. + Polygons col = offset(union_ex(getCollision(m_increase_until_radius, layer_idx, false)), 5 - increase_radius_ceil, ClipperLib::jtRound); + col = simplify(col, m_min_resolution); data[RadiusLayerPair(radius, layer_idx)] = col; } - { - std::lock_guard critical_section(*critical_collision_cache_holefree_); - collision_cache_holefree_.insert(data.begin(), data.end()); - } + std::lock_guard critical_section(*m_critical_collision_cache_holefree); + m_collision_cache_holefree.insert(data.begin(), data.end()); } }); } - // ensures offsets are only done in sizes with a max step size per offset while adding the collision offset after each step, this ensures that areas cannot glitch through walls defined by the collision when offsetting to fast -Polygons TreeModelVolumes::safeOffset(const Polygons& me, coord_t distance, ClipperLib::JoinType jt, coord_t max_safe_step_distance, const Polygons& collision) const +static Polygons safeOffset(const Polygons& me, coord_t distance, ClipperLib::JoinType jt, coord_t max_safe_step_distance, const Polygons& collision) { const size_t steps = std::abs(distance / max_safe_step_distance); assert(distance * max_safe_step_distance >= 0); - Polygons ret = me; - - for (size_t i = 0; i < steps; i++) - { - ret = ret.offset(max_safe_step_distance, jt).unionPolygons(collision); - } - ret = ret.offset(distance % max_safe_step_distance, jt); - - return ret.unionPolygons(collision); + ExPolygons ret = union_ex(me); + for (size_t i = 0; i < steps; ++ i) + ret = union_ex(union_(offset(ret, max_safe_step_distance, jt, 1.2), collision)); + return union_(offset(ret, distance % max_safe_step_distance, jt, 1.2), collision); } void TreeModelVolumes::calculateAvoidance(std::deque keys) @@ -740,7 +676,7 @@ void TreeModelVolumes::calculateAvoidance(std::deque keys) const std::vector all_types = { AvoidanceType::SLOW, AvoidanceType::FAST_SAFE, AvoidanceType::FAST }; tbb::parallel_for(tbb::blocked_range(0, keys.size() * 3), [&, keys, all_types](const tbb::blocked_range &range) { - for (const size_t iter_idx = range.begin(); iter_idx < range.end(); ++ iter_idx) { + for (size_t iter_idx = range.begin(); iter_idx < range.end(); ++ iter_idx) { size_t key_idx = iter_idx / 3; { size_t type_idx = iter_idx % all_types.size(); @@ -752,74 +688,62 @@ void TreeModelVolumes::calculateAvoidance(std::deque keys) LayerIndex max_required_layer = keys[key_idx].second; // do not calculate not needed safe avoidances - if (holefree && radius >= increase_until_radius + current_min_xy_dist_delta) - { - return; - } + if (holefree && radius >= m_increase_until_radius + m_current_min_xy_dist_delta) + continue; - const coord_t offset_speed = slow ? max_move_slow_ : max_move_; - const coord_t max_step_move = std::max(1.9 * radius, current_min_xy_dist * 1.9); + const coord_t offset_speed = slow ? m_max_move_slow : m_max_move; + const coord_t max_step_move = std::max(1.9 * radius, m_current_min_xy_dist * 1.9); RadiusLayerPair key(radius, 0); Polygons latest_avoidance; LayerIndex start_layer; { - std::lock_guard critical_section(*(slow ? critical_avoidance_cache_slow_ : holefree ? critical_avoidance_cache_holefree_ : critical_avoidance_cache_)); - start_layer = 1 + getMaxCalculatedLayer(radius, slow ? avoidance_cache_slow_ : holefree ? avoidance_cache_hole_ : avoidance_cache_); + std::lock_guard critical_section(*(slow ? m_critical_avoidance_cache_slow : holefree ? m_critical_avoidance_cache_holefree : m_critical_avoidance_cache)); + start_layer = 1 + getMaxCalculatedLayer(radius, slow ? m_avoidance_cache_slow : holefree ? m_avoidance_cache_hole : m_avoidance_cache); } - if (start_layer > max_required_layer) - { - logDebug("Requested calculation for value already calculated ?\n"); - return; + if (start_layer > max_required_layer) { + BOOST_LOG_TRIVIAL(debug) << "Requested calculation for value already calculated ?"; + continue; } start_layer = std::max(start_layer, LayerIndex(1)); // Ensure StartLayer is at least 1 as if no avoidance was calculated getMaxCalculatedLayer returns -1 std::vector> data(max_required_layer + 1, std::pair(RadiusLayerPair(radius, -1), Polygons())); - latest_avoidance = getAvoidance(radius, start_layer - 1, type, false, true); // minDist as the delta was already added, also avoidance for layer 0 will return the collision. // ### main loop doing the calculation - for (LayerIndex layer = start_layer; layer <= max_required_layer; layer++) - { + for (LayerIndex layer = start_layer; layer <= max_required_layer; layer++) { key.second = layer; - Polygons col; - if ((slow && radius < increase_until_radius + current_min_xy_dist_delta) || holefree) - { - col = getCollisionHolefree(radius, layer, true); - } - else - { - col = getCollision(radius, layer, true); - } + Polygons col = (slow && radius < m_increase_until_radius + m_current_min_xy_dist_delta) || holefree ? + getCollisionHolefree(radius, layer, true) : + getCollision(radius, layer, true); latest_avoidance = safeOffset(latest_avoidance, -offset_speed, ClipperLib::jtRound, -max_step_move, col); - latest_avoidance.simplify(min_maximum_resolution_, min_maximum_deviation_); + latest_avoidance = simplify(latest_avoidance, m_min_resolution); data[layer] = std::pair(key, latest_avoidance); } +#ifdef SLIC3R_TREESUPPORTS_PROGRESS { - std::lock_guard critical_section(*critical_progress); - - if (precalculated && precalculation_progress < TREE_PROGRESS_PRECALC_COLL + TREE_PROGRESS_PRECALC_AVO) - { - precalculation_progress += support_rests_on_model ? 0.4 : 1 * TREE_PROGRESS_PRECALC_AVO / (keys.size() * 3); - Progress::messageProgress(Progress::Stage::SUPPORT, precalculation_progress * progress_multiplier + progress_offset, TREE_PROGRESS_TOTAL); + std::lock_guard critical_section(*m_critical_progress); + if (m_precalculated && m_precalculation_progress < TREE_PROGRESS_PRECALC_COLL + TREE_PROGRESS_PRECALC_AVO) { + m_precalculation_progress += m_support_rests_on_model ? 0.4 : 1 * TREE_PROGRESS_PRECALC_AVO / (keys.size() * 3); + Progress::messageProgress(Progress::Stage::SUPPORT, m_precalculation_progress * m_progress_multiplier + m_progress_offset, TREE_PROGRESS_TOTAL); } } +#endif { - std::lock_guard critical_section(*(slow ? critical_avoidance_cache_slow_ : holefree ? critical_avoidance_cache_holefree_ : critical_avoidance_cache_)); - (slow ? avoidance_cache_slow_ : holefree ? avoidance_cache_hole_ : avoidance_cache_).insert(data.begin(), data.end()); + std::lock_guard critical_section(*(slow ? m_critical_avoidance_cache_slow : holefree ? m_critical_avoidance_cache_holefree : m_critical_avoidance_cache)); + (slow ? m_avoidance_cache_slow : holefree ? m_avoidance_cache_hole : m_avoidance_cache).insert(data.begin(), data.end()); } } } }); - return ret; } void TreeModelVolumes::calculatePlaceables(std::deque keys) { tbb::parallel_for(tbb::blocked_range(0, keys.size()), [&, keys](const tbb::blocked_range &range) { - for (const size_t key_idx = range.begin(); key_idx < range.end(); ++ key_idx) { + for (size_t key_idx = range.begin(); key_idx < range.end(); ++ key_idx) { const coord_t radius = keys[key_idx].first; const LayerIndex max_required_layer = keys[key_idx].second; std::vector> data(max_required_layer + 1, std::pair(RadiusLayerPair(radius, -1), Polygons())); @@ -827,58 +751,52 @@ void TreeModelVolumes::calculatePlaceables(std::deque keys) LayerIndex start_layer; { - std::lock_guard critical_section(*critical_placeable_areas_cache_); - start_layer = 1 + getMaxCalculatedLayer(radius, placeable_areas_cache_); + std::lock_guard critical_section(*m_critical_placeable_areas_cache); + start_layer = 1 + getMaxCalculatedLayer(radius, m_placeable_areas_cache); } - if (start_layer > max_required_layer) - { - logDebug("Requested calculation for value already calculated ?\n"); - return; + if (start_layer > max_required_layer) { + BOOST_LOG_TRIVIAL(debug) << "Requested calculation for value already calculated ?"; + continue; } - if (start_layer == 0) - { - data[0] = std::pair(key, machine_border_.difference(getCollision(radius, 0, true))); + if (start_layer == 0) { + data[0] = std::pair(key, diff(m_machine_border, getCollision(radius, 0, true))); start_layer = 1; } - for (LayerIndex layer = start_layer; layer <= max_required_layer; layer++) - { + for (LayerIndex layer = start_layer; layer <= max_required_layer; layer++) { key.second = layer; Polygons placeable = getPlaceableAreas(0, layer); - placeable.simplify(min_maximum_resolution_, min_maximum_deviation_); // it is faster to do this here in each thread than once in calculateCollision. - placeable = placeable.offset(-radius); - + placeable = simplify(placeable, m_min_resolution); // it is faster to do this here in each thread than once in calculateCollision. + placeable = offset(union_ex(placeable), - radius); data[layer] = std::pair(key, placeable); } +#ifdef SLIC3R_TREESUPPORTS_PROGRESS { - std::lock_guard critical_section(*critical_progress); - - if (precalculated && precalculation_progress < TREE_PROGRESS_PRECALC_COLL + TREE_PROGRESS_PRECALC_AVO) - { - precalculation_progress += 0.2 * TREE_PROGRESS_PRECALC_AVO / (keys.size()); - Progress::messageProgress(Progress::Stage::SUPPORT, precalculation_progress * progress_multiplier + progress_offset, TREE_PROGRESS_TOTAL); + std::lock_guard critical_section(*m_critical_progress); + if (m_precalculated && m_precalculation_progress < TREE_PROGRESS_PRECALC_COLL + TREE_PROGRESS_PRECALC_AVO) { + m_precalculation_progress += 0.2 * TREE_PROGRESS_PRECALC_AVO / (keys.size()); + Progress::messageProgress(Progress::Stage::SUPPORT, m_precalculation_progress * m_progress_multiplier + m_progress_offset, TREE_PROGRESS_TOTAL); } } +#endif { - std::lock_guard critical_section(*critical_placeable_areas_cache_); - placeable_areas_cache_.insert(data.begin(), data.end()); + std::lock_guard critical_section(*m_critical_placeable_areas_cache); + m_placeable_areas_cache.insert(data.begin(), data.end()); } } }); - return ret; } - void TreeModelVolumes::calculateAvoidanceToModel(std::deque keys) { // For every RadiusLayer pair there are 3 avoidances that have to be calculated, calculated in the same parallel_for loop for better parallelization. const std::vector all_types = { AvoidanceType::SLOW, AvoidanceType::FAST_SAFE, AvoidanceType::FAST }; tbb::parallel_for(tbb::blocked_range(0, keys.size() * 3), [&, keys, all_types](const tbb::blocked_range &range) { - for (const size_t iter_idx = range.begin(); iter_idx < range.end(); ++ iter_idx) { + for (size_t iter_idx = range.begin(); iter_idx < range.end(); ++ iter_idx) { size_t key_idx = iter_idx / 3; size_t type_idx = iter_idx % all_types.size(); AvoidanceType type = all_types[type_idx]; @@ -888,13 +806,12 @@ void TreeModelVolumes::calculateAvoidanceToModel(std::deque key LayerIndex max_required_layer = keys[key_idx].second; // do not calculate not needed safe avoidances - if (holefree && radius >= increase_until_radius + current_min_xy_dist_delta) - { - return; - } + if (holefree && radius >= m_increase_until_radius + m_current_min_xy_dist_delta) + continue; + getPlaceableAreas(radius, max_required_layer); // ensuring Placeableareas are calculated - const coord_t offset_speed = slow ? max_move_slow_ : max_move_; - const coord_t max_step_move = std::max(1.9 * radius, current_min_xy_dist * 1.9); + const coord_t offset_speed = slow ? m_max_move_slow : m_max_move; + const coord_t max_step_move = std::max(1.9 * radius, m_current_min_xy_dist * 1.9); Polygons latest_avoidance; std::vector> data(max_required_layer + 1, std::pair(RadiusLayerPair(radius, -1), Polygons())); RadiusLayerPair key(radius, 0); @@ -902,13 +819,12 @@ void TreeModelVolumes::calculateAvoidanceToModel(std::deque key LayerIndex start_layer; { - std::lock_guard critical_section(*(slow ? critical_avoidance_cache_to_model_slow_ : holefree ? critical_avoidance_cache_holefree_to_model_ : critical_avoidance_cache_to_model_)); - start_layer = 1 + getMaxCalculatedLayer(radius, slow ? avoidance_cache_to_model_slow_ : holefree ? avoidance_cache_hole_to_model_ : avoidance_cache_to_model_); + std::lock_guard critical_section(*(slow ? m_critical_avoidance_cache_to_model_slow : holefree ? m_critical_avoidance_cache_holefree_to_model : m_critical_avoidance_cache_to_model)); + start_layer = 1 + getMaxCalculatedLayer(radius, slow ? m_avoidance_cache_to_model_slow : holefree ? m_avoidance_cache_hole_to_model : m_avoidance_cache_to_model); } - if (start_layer > max_required_layer) - { - logDebug("Requested calculation for value already calculated ?\n"); - return; + if (start_layer > max_required_layer) { + BOOST_LOG_TRIVIAL(debug) << "Requested calculation for value already calculated ?"; + continue; } start_layer = std::max(start_layer, LayerIndex(1)); latest_avoidance = getAvoidance(radius, start_layer - 1, type, true, true); // minDist as the delta was already added, also avoidance for layer 0 will return the collision. @@ -919,7 +835,7 @@ void TreeModelVolumes::calculateAvoidanceToModel(std::deque key key.second = layer; Polygons col = getCollision(radius, layer, true); - if ((slow && radius < increase_until_radius + current_min_xy_dist_delta) || holefree) + if ((slow && radius < m_increase_until_radius + m_current_min_xy_dist_delta) || holefree) { col = getCollisionHolefree(radius, layer, true); } @@ -928,30 +844,28 @@ void TreeModelVolumes::calculateAvoidanceToModel(std::deque key col = getCollision(radius, layer, true); } - latest_avoidance = safeOffset(latest_avoidance, -offset_speed, ClipperLib::jtRound, -max_step_move, col).difference(getPlaceableAreas(radius, layer)); + latest_avoidance = diff(safeOffset(latest_avoidance, -offset_speed, ClipperLib::jtRound, -max_step_move, col), getPlaceableAreas(radius, layer)); - latest_avoidance.simplify(min_maximum_resolution_, min_maximum_deviation_); + latest_avoidance = simplify(latest_avoidance, m_min_resolution); data[layer] = std::pair(key, latest_avoidance); } +#ifdef SLIC3R_TREESUPPORTS_PROGRESS { - std::lock_guard critical_section(*critical_progress); - - if (precalculated && precalculation_progress < TREE_PROGRESS_PRECALC_COLL + TREE_PROGRESS_PRECALC_AVO) - { - precalculation_progress += 0.4 * TREE_PROGRESS_PRECALC_AVO / (keys.size() * 3); - Progress::messageProgress(Progress::Stage::SUPPORT, precalculation_progress * progress_multiplier + progress_offset, TREE_PROGRESS_TOTAL); + std::lock_guard critical_section(*m_critical_progress); + if (m_precalculated && m_precalculation_progress < TREE_PROGRESS_PRECALC_COLL + TREE_PROGRESS_PRECALC_AVO) { + m_precalculation_progress += 0.4 * TREE_PROGRESS_PRECALC_AVO / (keys.size() * 3); + Progress::messageProgress(Progress::Stage::SUPPORT, m_precalculation_progress * m_progress_multiplier + m_progress_offset, TREE_PROGRESS_TOTAL); } } +#endif { - std::lock_guard critical_section(*(slow ? critical_avoidance_cache_to_model_slow_ : holefree ? critical_avoidance_cache_holefree_to_model_ : critical_avoidance_cache_to_model_)); - (slow ? avoidance_cache_to_model_slow_ : holefree ? avoidance_cache_hole_to_model_ : avoidance_cache_to_model_).insert(data.begin(), data.end()); + std::lock_guard critical_section(*(slow ? m_critical_avoidance_cache_to_model_slow : holefree ? m_critical_avoidance_cache_holefree_to_model : m_critical_avoidance_cache_to_model)); + (slow ? m_avoidance_cache_to_model_slow : holefree ? m_avoidance_cache_hole_to_model : m_avoidance_cache_to_model).insert(data.begin(), data.end()); } } }); - - return ret; } @@ -960,7 +874,6 @@ void TreeModelVolumes::calculateWallRestrictions(std::deque key // Wall restrictions are mainly important when they represent actual walls that are printed, and not "just" the configured z_distance, because technically valid placement is no excuse for moving through a wall. // As they exist to prevent accidentially moving though a wall at high speed between layers like thie (x = wall,i = influence area,o= empty space,d = blocked area because of z distance) Assume maximum movement distance is two characters and maximum safe movement distance of one character - /* Potential issue addressed by the wall restrictions: Influence area may lag through a wall * layer z+1:iiiiiiiiiiioooo * layer z+0:xxxxxiiiiiiiooo @@ -994,127 +907,79 @@ void TreeModelVolumes::calculateWallRestrictions(std::deque key tbb::parallel_for(tbb::blocked_range(0, keys.size()), [&, keys](const tbb::blocked_range &range) { - for (const size_t key_idx = range.begin(); key_idx < range.end(); ++ key_idx) { + for (size_t key_idx = range.begin(); key_idx < range.end(); ++ key_idx) { coord_t radius = keys[key_idx].first; RadiusLayerPair key(radius, 0); coord_t min_layer_bottom; - std::unordered_map data; - std::unordered_map data_min; + RadiusLayerPolygonCache data; + RadiusLayerPolygonCache data_min; { - std::lock_guard critical_section(*critical_wall_restrictions_cache_); - min_layer_bottom = getMaxCalculatedLayer(radius, wall_restrictions_cache_); + std::lock_guard critical_section(*m_critical_wall_restrictions_cache); + min_layer_bottom = getMaxCalculatedLayer(radius, m_wall_restrictions_cache); } if (min_layer_bottom < 1) - { min_layer_bottom = 1; - } - for (LayerIndex layer_idx = min_layer_bottom; layer_idx <= keys[key_idx].second; layer_idx++) - { + + for (LayerIndex layer_idx = min_layer_bottom; layer_idx <= keys[key_idx].second; layer_idx++) { key.second = layer_idx; LayerIndex layer_idx_below = layer_idx - 1; - Polygons wall_restriction = getCollision(0, layer_idx, false).intersection(getCollision(radius, layer_idx_below, true)); // radius contains current_min_xy_dist_delta already if required - wall_restriction.simplify(min_maximum_resolution_, min_maximum_deviation_); + Polygons wall_restriction = intersection(getCollision(0, layer_idx, false), getCollision(radius, layer_idx_below, true)); // radius contains m_current_min_xy_dist_delta already if required + wall_restriction = simplify(wall_restriction, m_min_resolution); data.emplace(key, wall_restriction); - if (current_min_xy_dist_delta > 0) + if (m_current_min_xy_dist_delta > 0) { - Polygons wall_restriction_min = getCollision(0, layer_idx, true).intersection(getCollision(radius, layer_idx_below, true)); - wall_restriction_min.simplify(min_maximum_resolution_, min_maximum_deviation_); + Polygons wall_restriction_min = intersection(getCollision(0, layer_idx, true), getCollision(radius, layer_idx_below, true)); + wall_restriction = simplify(wall_restriction_min, m_min_resolution); data_min.emplace(key, wall_restriction_min); } } - { - std::lock_guard critical_section(*critical_wall_restrictions_cache_); - wall_restrictions_cache_.insert(data.begin(), data.end()); + std::lock_guard critical_section(*m_critical_wall_restrictions_cache); + m_wall_restrictions_cache.insert(data.begin(), data.end()); } - { - std::lock_guard critical_section(*critical_wall_restrictions_cache_min_); - wall_restrictions_cache_min_.insert(data_min.begin(), data_min.end()); + std::lock_guard critical_section(*m_critical_wall_restrictions_cache_min); + m_wall_restrictions_cache_min.insert(data_min.begin(), data_min.end()); } } }); - return ret; } coord_t TreeModelVolumes::ceilRadius(coord_t radius) const { if (radius == 0) - { return 0; - } - if (radius <= radius_0) - { - return radius_0; - } + if (radius <= m_radius_0) + return m_radius_0; if (SUPPORT_TREE_USE_EXPONENTIAL_COLLISION_RESOLUTION) { // generate SUPPORT_TREE_PRE_EXPONENTIAL_STEPS of radiis before starting to exponentially increase them. coord_t exponential_result = SUPPORT_TREE_EXPONENTIAL_THRESHOLD * SUPPORT_TREE_EXPONENTIAL_FACTOR; - const coord_t stepsize = (exponential_result - radius_0) / (SUPPORT_TREE_PRE_EXPONENTIAL_STEPS + 1); - coord_t result = radius_0; - for (size_t step = 0; step < SUPPORT_TREE_PRE_EXPONENTIAL_STEPS; step++) - { + const coord_t stepsize = (exponential_result - m_radius_0) / (SUPPORT_TREE_PRE_EXPONENTIAL_STEPS + 1); + coord_t result = m_radius_0; + for (size_t step = 0; step < SUPPORT_TREE_PRE_EXPONENTIAL_STEPS; step++) { result += stepsize; - if (result >= radius && !ignorable_radii_.count(result)) - { + if (result >= radius && !m_ignorable_radii.count(result)) return result; - } } - while (exponential_result < radius || ignorable_radii_.count(exponential_result)) - { + while (exponential_result < radius || m_ignorable_radii.count(exponential_result)) exponential_result = std::max(coord_t(exponential_result * SUPPORT_TREE_EXPONENTIAL_FACTOR), exponential_result + SUPPORT_TREE_COLLISION_RESOLUTION); - } return exponential_result; } else - { // generates equidistant steps of size SUPPORT_TREE_COLLISION_RESOLUTION starting from radius_0. If SUPPORT_TREE_USE_EXPONENTIAL_COLLISION_RESOLUTION then this code is dead, and can safely be removed. - coord_t ceil_step_n = (radius - radius_0) / SUPPORT_TREE_COLLISION_RESOLUTION; - coord_t resulting_ceil = radius_0 + (ceil_step_n + ((radius - radius_0) % SUPPORT_TREE_COLLISION_RESOLUTION != 0)) * SUPPORT_TREE_COLLISION_RESOLUTION; - - if (radius <= radius_0 && radius != 0) - { - return radius_0; - } - else if (ignorable_radii_.count(resulting_ceil)) - { - return ceilRadius(resulting_ceil + 1); - } - else - { - return resulting_ceil; - } + { // generates equidistant steps of size SUPPORT_TREE_COLLISION_RESOLUTION starting from m_radius_0. If SUPPORT_TREE_USE_EXPONENTIAL_COLLISION_RESOLUTION then this code is dead, and can safely be removed. + coord_t ceil_step_n = (radius - m_radius_0) / SUPPORT_TREE_COLLISION_RESOLUTION; + coord_t resulting_ceil = m_radius_0 + (ceil_step_n + ((radius - m_radius_0) % SUPPORT_TREE_COLLISION_RESOLUTION != 0)) * SUPPORT_TREE_COLLISION_RESOLUTION; + return + radius <= m_radius_0 && radius != 0 ? m_radius_0 : + m_ignorable_radii.count(resulting_ceil) ? ceilRadius(resulting_ceil + 1) : resulting_ceil; } } -template -const std::optional> TreeModelVolumes::getArea(const std::unordered_map& cache, const KEY key) const -{ - const auto it = cache.find(key); - if (it != cache.end()) - { - return std::optional>{ it->second }; - } - else - { - return std::optional>(); - } } - - -Polygons TreeModelVolumes::calculateMachineBorderCollision(Polygon machine_border) -{ - Polygons machine_volume_border; - machine_volume_border.add(machine_border.offset(1000000)); // Put a border of 1m around the print volume so that we don't collide. - machine_border.reverse(); // Makes the polygon negative so that we subtract the actual volume from the collision area. - machine_volume_border.add(machine_border); - return machine_volume_border; -} - -} \ No newline at end of file diff --git a/src/libslic3r/TreeModelVolumes.hpp b/src/libslic3r/TreeModelVolumes.hpp index 684dd1fe9..82d1a5d9d 100644 --- a/src/libslic3r/TreeModelVolumes.hpp +++ b/src/libslic3r/TreeModelVolumes.hpp @@ -13,6 +13,9 @@ #include #include +#include + +#include "Point.hpp" #include "Polygon.hpp" #include "PrintConfig.hpp" @@ -22,42 +25,174 @@ namespace Slic3r using LayerIndex = size_t; using AngleRadians = double; -//FIXME -class SliceDataStorage; -class SliceMeshStorage; +class BuildVolume; +class PrintObject; struct TreeSupportMeshGroupSettings { - AngleRadians support_tree_angle; - AngleRadians support_tree_angle_slow; - AngleRadians support_tree_branch_diameter_angle; - coord_t support_tree_bp_diameter; - coord_t support_tree_max_diameter_increase_by_merges_when_support_to_model; - coord_t support_tree_min_height_to_model; - coord_t support_line_width; - coord_t layer_height; - coord_t support_tree_branch_diameter; - coord_t support_tree_tip_diameter; - bool support_bottom_enable; - coord_t support_bottom_height; - bool support_material_buildplate_only; - bool support_xy_overrides_z; - coord_t support_xy_distance; - coord_t support_xy_distance_overhang; - coord_t support_top_distance; - coord_t support_bottom_distance; - coord_t support_interface_skip_height; - std::vector support_infill_angles; - std::vector support_roof_angles; - SupportMaterialInterfacePattern support_roof_pattern; - SupportMaterialPattern support_pattern; - coord_t support_roof_line_width; - coord_t support_line_distance; - coord_t support_bottom_offset; - int support_wall_count; - coord_t meshfix_maximum_deviation; - coord_t meshfix_maximum_resolution; - coord_t support_roof_line_distance; - coord_t min_feature_size; + TreeSupportMeshGroupSettings() = default; + TreeSupportMeshGroupSettings(const PrintObject &print_object); + +/*********************************************************************/ +/* Print parameters, not support specific: */ +/*********************************************************************/ + coord_t layer_height { scaled(0.15) }; + // Maximum Deviation (meshfix_maximum_deviation) + // The maximum deviation allowed when reducing the resolution for the Maximum Resolution setting. If you increase this, + // the print will be less accurate, but the g-code will be smaller. Maximum Deviation is a limit for Maximum Resolution, + // so if the two conflict the Maximum Deviation will always be held true. + coord_t resolution { scaled(0.025) }; + // Minimum Feature Size (aka minimum line width) + // Minimum thickness of thin features. Model features that are thinner than this value will not be printed, while features thicker + // than the Minimum Feature Size will be widened to the Minimum Wall Line Width. + coord_t min_feature_size { scaled(0.1) }; + +/*********************************************************************/ +/* General support parameters: */ +/*********************************************************************/ + + // Support Overhang Angle + // The minimum angle of overhangs for which support is added. At a value of 0° all overhangs are supported, 90° will not provide any support. + AngleRadians support_angle { 50. * M_PI / 180. }; + // Support Line Width + // Width of a single support structure line. + coord_t support_line_width { scaled(0.4) }; + // Support Roof Line Width: Width of a single support roof line. + coord_t support_roof_line_width { scaled(0.4) }; + // Enable Support Floor (aka bottom interfaces) + // Generate a dense slab of material between the bottom of the support and the model. This will create a skin between the model and support. + bool support_bottom_enable { false }; + // Support Floor Thickness + // The thickness of the support floors. This controls the number of dense layers that are printed on top of places of a model on which support rests. + coord_t support_bottom_height { scaled(1.) }; + bool support_material_buildplate_only { false }; + // Support Distance Priority + // Whether the Support X/Y Distance overrides the Support Z Distance or vice versa. When X/Y overrides Z the X/Y distance can push away + // the support from the model, influencing the actual Z distance to the overhang. We can disable this by not applying the X/Y distance around overhangs. + bool support_xy_overrides_z { false }; + // Support X/Y Distance + // Distance of the support structure from the print in the X/Y directions. + // minimum: 0, maximum warning: 1.5 * machine_nozzle_tip_outer_diameter + coord_t support_xy_distance { scaled(0.7) }; + // Minimum Support X/Y Distance + // Distance of the support structure from the overhang in the X/Y directions. + // minimum_value: 0, minimum warning": support_xy_distance - support_line_width * 2, maximum warning: support_xy_distance + // Used if ! support_xy_overrides_z. + coord_t support_xy_distance_overhang { scaled(0.2) }; + // Support Top Distance + // Distance from the top of the support to the print. + coord_t support_top_distance { scaled(0.1) }; + // Support Bottom Distance + // Distance from the print to the bottom of the support. + coord_t support_bottom_distance { scaled(0.1) }; + //FIXME likely not needed, optimization for clipping of interface layers + // When checking where there's model above and below the support, take steps of the given height. Lower values will slice slower, while higher values + // may cause normal support to be printed in some places where there should have been support interface. + coord_t support_interface_skip_height { scaled(0.3) }; + // Support Infill Line Directions + // A list of integer line directions to use. Elements from the list are used sequentially as the layers progress and when the end + // of the list is reached, it starts at the beginning again. The list items are separated by commas and the whole list is contained + // in square brackets. Default is an empty list which means use the default angle 0 degrees. + std::vector support_infill_angles {}; + // Enable Support Roof + // Generate a dense slab of material between the top of support and the model. This will create a skin between the model and support. + bool support_roof_enable { false }; + // Support Roof Thickness + // The thickness of the support roofs. This controls the amount of dense layers at the top of the support on which the model rests. + coord_t support_roof_height { scaled(1.) }; + // Minimum Support Roof Area + // Minimum area size for the roofs of the support. Polygons which have an area smaller than this value will be printed as normal support. + double minimum_roof_area { scaled(scaled(1.)) }; + // A list of integer line directions to use. Elements from the list are used sequentially as the layers progress + // and when the end of the list is reached, it starts at the beginning again. The list items are separated + // by commas and the whole list is contained in square brackets. Default is an empty list which means + // use the default angles (alternates between 45 and 135 degrees if interfaces are quite thick or 90 degrees). + std::vector support_roof_angles {}; + // Support Roof Pattern (aka top interface) + // The pattern with which the roofs of the support are printed. + SupportMaterialInterfacePattern support_roof_pattern { smipAuto }; + // Support Pattern + // The pattern of the support structures of the print. The different options available result in sturdy or easy to remove support. + SupportMaterialPattern support_pattern { smpRectilinear }; + // Support Line Distance + // Distance between the printed support structure lines. This setting is calculated by the support density. + coord_t support_line_spacing { scaled(2.66 - 0.4) }; + // Support Floor Horizontal Expansion + // Amount of offset applied to the floors of the support. + coord_t support_bottom_offset { scaled(0.) }; + // Support Wall Line Count + // The number of walls with which to surround support infill. Adding a wall can make support print more reliably + // and can support overhangs better, but increases print time and material used. + // tree: 1, zig-zag: 0, concentric: 1 + int support_wall_count { 1 }; + // Support Roof Line Distance + // Distance between the printed support roof lines. This setting is calculated by the Support Roof Density, but can be adjusted separately. + coord_t support_roof_line_distance { scaled(0.4) }; + // Minimum Support Area + // Minimum area size for support polygons. Polygons which have an area smaller than this value will not be generated. + coord_t minimum_support_area { scaled(0.) }; + // Minimum Support Floor Area + // Minimum area size for the floors of the support. Polygons which have an area smaller than this value will be printed as normal support. + coord_t minimum_bottom_area { scaled(1.0) }; + // Support Horizontal Expansion + // Amount of offset applied to all support polygons in each layer. Positive values can smooth out the support areas and result in more sturdy support. + coord_t support_offset { scaled(0.) }; + +/*********************************************************************/ +/* Parameters for the Cura tree supports implementation: */ +/*********************************************************************/ + + // Tree Support Maximum Branch Angle + // The maximum angle of the branches, when the branches have to avoid the model. Use a lower angle to make them more vertical and more stable. Use a higher angle to be able to have more reach. + // minimum: 0, minimum warning: 20, maximum: 89, maximum warning": 85 + AngleRadians support_tree_angle { 60. * M_PI / 180. }; + // Tree Support Branch Diameter Angle + // The angle of the branches' diameter as they gradually become thicker towards the bottom. An angle of 0 will cause the branches to have uniform thickness over their length. + // A bit of an angle can increase stability of the tree support. + // minimum: 0, maximum: 89.9999, maximum warning: 15 + AngleRadians support_tree_branch_diameter_angle { 5. * M_PI / 180. }; + // Tree Support Branch Distance + // How far apart the branches need to be when they touch the model. Making this distance small will cause + // the tree support to touch the model at more points, causing better overhang but making support harder to remove. + coord_t support_tree_branch_distance { scaled(50.) }; + // Tree Support Branch Diameter + // The diameter of the thinnest branches of tree support. Thicker branches are more sturdy. Branches towards the base will be thicker than this. + // minimum: 0.001, minimum warning: support_line_width * 2 + coord_t support_tree_branch_diameter { scaled(2.) }; + +/*********************************************************************/ +/* Parameters new to the Thomas Rahm's tree supports implementation: */ +/*********************************************************************/ + + // Tree Support Preferred Branch Angle + // The preferred angle of the branches, when they do not have to avoid the model. Use a lower angle to make them more vertical and more stable. Use a higher angle for branches to merge faster. + // minimum: 0, minimum warning: 10, maximum: support_tree_angle, maximum warning: support_tree_angle-1 + AngleRadians support_tree_angle_slow { 50. * M_PI / 180. }; + // Tree Support Diameter Increase To Model + // The most the diameter of a branch that has to connect to the model may increase by merging with branches that could reach the buildplate. + // Increasing this reduces print time, but increases the area of support that rests on model + // minimum: 0 + coord_t support_tree_max_diameter_increase_by_merges_when_support_to_model { scaled(1.0) }; + // Tree Support Minimum Height To Model + // How tall a branch has to be if it is placed on the model. Prevents small blobs of support. This setting is ignored when a branch is supporting a support roof. + // minimum: 0, maximum warning: 5 + coord_t support_tree_min_height_to_model { scaled(1.0) }; + // Tree Support Inital Layer Diameter + // Diameter every branch tries to achieve when reaching the buildplate. Improves bed adhesion. + // minimum: 0, maximum warning: 20 + coord_t support_tree_bp_diameter { scaled(7.5) }; + // Tree Support Branch Density + // Adjusts the density of the support structure used to generate the tips of the branches. A higher value results in better overhangs, + // but the supports are harder to remove. Use Support Roof for very high values or ensure support density is similarly high at the top. + // 5%-35% + double support_tree_top_rate { 15. }; + // Tree Support Tip Diameter + // The diameter of the top of the tip of the branches of tree support." + // minimum: min_wall_line_width, minimum warning: min_wall_line_width+0.05, maximum_value: support_tree_branch_diameter, value: support_line_width + coord_t support_tree_tip_diameter { scaled(0.4) }; + + // Support Interface Priority + // How support interface and support will interact when they overlap. Currently only implemented for support roof. + //enum support_interface_priority { support_lines_overwrite_interface_area }; }; inline coord_t round_up_divide(const coord_t dividend, const coord_t divisor) //!< Return dividend divided by divisor rounded to the nearest integer @@ -67,9 +202,10 @@ inline coord_t round_up_divide(const coord_t dividend, const coord_t divisor) // class TreeModelVolumes { - public: +public: TreeModelVolumes() = default; - TreeModelVolumes(const SliceDataStorage& storage, coord_t max_move, coord_t max_move_slow, size_t current_mesh_idx, double progress_multiplier, double progress_offset, const std::vector& additional_excluded_areas = std::vector()); + TreeModelVolumes(const PrintObject &print_object, const BuildVolume &build_volume, + coord_t max_move, coord_t max_move_slow, size_t current_mesh_idx, double progress_multiplier, double progress_offset, const std::vector &additional_excluded_areas = {}); TreeModelVolumes(TreeModelVolumes&&) = default; TreeModelVolumes& operator=(TreeModelVolumes&&) = default; @@ -103,22 +239,20 @@ class TreeModelVolumes * \param min_xy_dist Is the minimum xy distance used. * \return Polygons object */ - - const Polygons& getCollision(coord_t radius, LayerIndex layer_idx, bool min_xy_dist = false); + const Polygons& getCollision(coord_t radius, LayerIndex layer_idx, bool min_xy_dist = false) const; /*! * \brief Provides the areas that have to be avoided by the tree's branches to prevent collision with the model on this layer. Holes are removed. * * The result is a 2D area that would cause nodes of given radius to * collide with the model or be inside a hole. - * A Hole is defined as an area, in which a branch with increase_until_radius radius would collide with the wall. + * A Hole is defined as an area, in which a branch with m_increase_until_radius radius would collide with the wall. * \param radius The radius of the node of interest * \param layer_idx The layer of interest * \param min_xy_dist Is the minimum xy distance used. * \return Polygons object */ - const Polygons& getCollisionHolefree(coord_t radius, LayerIndex layer_idx, bool min_xy_dist = false); - + const Polygons& getCollisionHolefree(coord_t radius, LayerIndex layer_idx, bool min_xy_dist = false) const; /*! * \brief Provides the areas that have to be avoided by the tree's branches @@ -137,14 +271,14 @@ class TreeModelVolumes * \param min_xy_dist is the minimum xy distance used. * \return Polygons object */ - const Polygons& getAvoidance(coord_t radius, LayerIndex layer_idx, AvoidanceType type, bool to_model = false, bool min_xy_dist = false); + const Polygons& getAvoidance(coord_t radius, LayerIndex layer_idx, AvoidanceType type, bool to_model = false, bool min_xy_dist = false) const; /*! * \brief Provides the area represents all areas on the model where the branch does completely fit on the given layer. * \param radius The radius of the node of interest * \param layer_idx The layer of interest * \return Polygons object */ - const Polygons& getPlaceableAreas(coord_t radius, LayerIndex layer_idx); + const Polygons& getPlaceableAreas(coord_t radius, LayerIndex layer_idx) const; /*! * \brief Provides the area that represents the walls, as in the printed area, of the model. This is an abstract representation not equal with the outline. See calculateWallRestrictions for better description. * \param radius The radius of the node of interest. @@ -152,9 +286,9 @@ class TreeModelVolumes * \param min_xy_dist is the minimum xy distance used. * \return Polygons object */ - const Polygons& getWallRestriction(coord_t radius, LayerIndex layer_idx, bool min_xy_dist); + const Polygons& getWallRestriction(coord_t radius, LayerIndex layer_idx, bool min_xy_dist) const; /*! - * \brief Round \p radius upwards to either a multiple of radius_sample_resolution_ or a exponentially increasing value + * \brief Round \p radius upwards to either a multiple of m_radius_sample_resolution or a exponentially increasing value * * It also adds the difference between the minimum xy distance and the regular one. * @@ -172,16 +306,17 @@ class TreeModelVolumes */ coord_t getRadiusNextCeil(coord_t radius, bool min_xy_dist) const; - - private: +private: /*! * \brief Convenience typedef for the keys to the caches */ - using RadiusLayerPair = std::pair; + using RadiusLayerPair = std::pair; + using RadiusLayerPolygonCache = std::unordered_map>; + friend std::optional> getArea(const TreeModelVolumes::RadiusLayerPolygonCache &cache, const TreeModelVolumes::RadiusLayerPair &key); /*! - * \brief Round \p radius upwards to either a multiple of radius_sample_resolution_ or a exponentially increasing value + * \brief Round \p radius upwards to either a multiple of m_radius_sample_resolution or a exponentially increasing value * * \param radius The radius of the node of interest */ @@ -193,7 +328,7 @@ class TreeModelVolumes * \param layer_idx The layer which should be extracted from the mesh * \return Polygons object representing the outline */ - Polygons extractOutlineFromMesh(const SliceMeshStorage& mesh, LayerIndex layer_idx) const; +// Polygons extractOutlineFromMesh(const PrintObject &print_object, LayerIndex layer_idx) const; /*! * \brief Creates the areas that have to be avoided by the tree's branches to prevent collision with the model on this layer. @@ -219,7 +354,7 @@ class TreeModelVolumes * * The result is a 2D area that would cause nodes of given radius to * collide with the model or be inside a hole. Result is saved in the cache. - * A Hole is defined as an area, in which a branch with increase_until_radius radius would collide with the wall. + * A Hole is defined as an area, in which a branch with m_increase_until_radius radius would collide with the wall. * \param keys RadiusLayerPairs of all requested areas. Every radius will be calculated up to the provided layer. */ void calculateCollisionHolefree(std::deque keys); @@ -229,7 +364,7 @@ class TreeModelVolumes * * The result is a 2D area that would cause nodes of given radius to * collide with the model or be inside a hole. Result is saved in the cache. - * A Hole is defined as an area, in which a branch with increase_until_radius radius would collide with the wall. + * A Hole is defined as an area, in which a branch with m_increase_until_radius radius would collide with the wall. * \param key RadiusLayerPairs the requested areas. The radius will be calculated up to the provided layer. */ void calculateCollisionHolefree(RadiusLayerPair key) @@ -237,7 +372,7 @@ class TreeModelVolumes calculateCollisionHolefree(std::deque{ RadiusLayerPair(key) }); } - Polygons safeOffset(const Polygons& me, coord_t distance, ClipperLib::JoinType jt, coord_t max_safe_step_distance, const Polygons& collision) const; + static Polygons safeOffset(const Polygons& me, coord_t distance, ClipperLib::JoinType jt, coord_t max_safe_step_distance, const Polygons& collision); /*! * \brief Creates the areas that have to be avoided by the tree's branches to prevent collision with the model. @@ -316,14 +451,6 @@ class TreeModelVolumes calculateWallRestrictions(std::deque{ RadiusLayerPair(key) }); } - /*! - * \brief Checks a cache for a given RadiusLayerPair and returns it if it is found - * \param key RadiusLayerPair of the requested areas. The radius will be calculated up to the provided layer. - * \return A wrapped optional reference of the requested area (if it was found, an empty optional if nothing was found) - */ - template - const std::optional> getArea(const std::unordered_map& cache, const KEY key) const; - bool checkSettingsEquality(const TreeSupportMeshGroupSettings& me, const TreeSupportMeshGroupSettings& other) const; /*! * \brief Get the highest already calculated layer in the cache. * \param radius The radius for which the highest already calculated layer has to be found. @@ -331,141 +458,132 @@ class TreeModelVolumes * * \return A wrapped optional reference of the requested area (if it was found, an empty optional if nothing was found) */ - LayerIndex getMaxCalculatedLayer(coord_t radius, const std::unordered_map& map) const; + LayerIndex getMaxCalculatedLayer(coord_t radius, const RadiusLayerPolygonCache& map) const; - Polygons calculateMachineBorderCollision(Polygon machine_border); /*! * \brief The maximum distance that the center point of a tree branch may move in consecutive layers if it has to avoid the model. */ - coord_t max_move_; + coord_t m_max_move; /*! * \brief The maximum distance that the centre-point of a tree branch may * move in consecutive layers if it does not have to avoid the model */ - coord_t max_move_slow_; + coord_t m_max_move_slow; /*! * \brief The smallest maximum resolution for simplify */ - coord_t min_maximum_resolution_; - /*! - * \brief The smallest maximum deviation for simplify - */ - coord_t min_maximum_deviation_; - /*! - * \brief Whether the precalculate was called, meaning every required value should be cached. - */ - bool precalculated = false; + coord_t m_min_resolution; + + bool m_precalculated = false; /*! * \brief The index to access the outline corresponding with the currently processing mesh */ - size_t current_outline_idx; + size_t m_current_outline_idx; /*! * \brief The minimum required clearance between the model and the tree branches */ - coord_t current_min_xy_dist; + coord_t m_current_min_xy_dist; /*! * \brief The difference between the minimum required clearance between the model and the tree branches and the regular one. */ - coord_t current_min_xy_dist_delta; + coord_t m_current_min_xy_dist_delta; /*! * \brief Does at least one mesh allow support to rest on a model. */ - bool support_rests_on_model; + bool m_support_rests_on_model; /*! * \brief The progress of the precalculate function for communicating it to the progress bar. */ - coord_t precalculation_progress = 0; + coord_t m_precalculation_progress = 0; /*! * \brief The progress multiplier of all values added progress bar. * Required for the progress bar the behave as expected when areas have to be calculated multiple times */ - double progress_multiplier; + double m_progress_multiplier; /*! * \brief The progress offset added to all values communicated to the progress bar. * Required for the progress bar the behave as expected when areas have to be calculated multiple times */ - double progress_offset; + double m_progress_offset; /*! * \brief Increase radius in the resulting drawn branches, even if the avoidance does not allow it. Will be cut later to still fit. */ - coord_t increase_until_radius; + coord_t m_increase_until_radius; /*! * \brief Polygons representing the limits of the printable area of the * machine */ - Polygons machine_border_; + Polygons m_machine_border; /*! * \brief Storage for layer outlines and the corresponding settings of the meshes grouped by meshes with identical setting. */ - std::vector>> layer_outlines_; + std::vector>> m_layer_outlines; /*! * \brief Storage for areas that should be avoided, like support blocker or previous generated trees. */ - std::vector anti_overhang_; + std::vector m_anti_overhang; /*! * \brief Radii that can be ignored by ceilRadius as they will never be requested. */ - std::unordered_set ignorable_radii_; + std::unordered_set m_ignorable_radii; /*! * \brief Smallest radius a branch can have. This is the radius of a SupportElement with DTT=0. */ - coord_t radius_0; + coord_t m_radius_0; /*! * \brief Caches for the collision, avoidance and areas on the model where support can be placed safely * at given radius and layer indices. - * - * These are mutable to allow modification from const function. This is - * generally considered OK as the functions are still logically const - * (ie there is no difference in behaviour for the user between - * calculating the values each time vs caching the results). */ - mutable std::unordered_map collision_cache_; - std::unique_ptr critical_collision_cache_ = std::make_unique(); + RadiusLayerPolygonCache m_collision_cache; + std::unique_ptr m_critical_collision_cache { std::make_unique() }; - mutable std::unordered_map collision_cache_holefree_; - std::unique_ptr critical_collision_cache_holefree_ = std::make_unique(); + RadiusLayerPolygonCache m_collision_cache_holefree; + std::unique_ptr m_critical_collision_cache_holefree { std::make_unique() }; - mutable std::unordered_map avoidance_cache_; - std::unique_ptr critical_avoidance_cache_ = std::make_unique(); + RadiusLayerPolygonCache m_avoidance_cache; + std::unique_ptr m_critical_avoidance_cache { std::make_unique() }; - mutable std::unordered_map avoidance_cache_slow_; - std::unique_ptr critical_avoidance_cache_slow_ = std::make_unique(); + RadiusLayerPolygonCache m_avoidance_cache_slow; + std::unique_ptr m_critical_avoidance_cache_slow { std::make_unique() }; - mutable std::unordered_map avoidance_cache_to_model_; - std::unique_ptr critical_avoidance_cache_to_model_ = std::make_unique(); + RadiusLayerPolygonCache m_avoidance_cache_to_model; + std::unique_ptr m_critical_avoidance_cache_to_model { std::make_unique() }; - mutable std::unordered_map avoidance_cache_to_model_slow_; - std::unique_ptr critical_avoidance_cache_to_model_slow_ = std::make_unique(); - - mutable std::unordered_map placeable_areas_cache_; - std::unique_ptr critical_placeable_areas_cache_ = std::make_unique(); + RadiusLayerPolygonCache m_avoidance_cache_to_model_slow; + std::unique_ptr m_critical_avoidance_cache_to_model_slow { std::make_unique() }; + RadiusLayerPolygonCache m_placeable_areas_cache; + std::unique_ptr m_critical_placeable_areas_cache { std::make_unique() }; /*! - * \brief Caches to avoid holes smaller than the radius until which the radius is always increased, as they are free of holes. Also called safe avoidances, as they are safe regarding not running into holes. + * \brief Caches to avoid holes smaller than the radius until which the radius is always increased, as they are free of holes. + * Also called safe avoidances, as they are safe regarding not running into holes. */ - mutable std::unordered_map avoidance_cache_hole_; - std::unique_ptr critical_avoidance_cache_holefree_ = std::make_unique(); + RadiusLayerPolygonCache m_avoidance_cache_hole; + std::unique_ptr m_critical_avoidance_cache_holefree { std::make_unique() }; - mutable std::unordered_map avoidance_cache_hole_to_model_; - std::unique_ptr critical_avoidance_cache_holefree_to_model_ = std::make_unique(); + RadiusLayerPolygonCache m_avoidance_cache_hole_to_model; + std::unique_ptr m_critical_avoidance_cache_holefree_to_model { std::make_unique() }; /*! * \brief Caches to represent walls not allowed to be passed over. */ - mutable std::unordered_map wall_restrictions_cache_; - std::unique_ptr critical_wall_restrictions_cache_ = std::make_unique(); + RadiusLayerPolygonCache m_wall_restrictions_cache; + std::unique_ptr m_critical_wall_restrictions_cache { std::make_unique() }; - mutable std::unordered_map wall_restrictions_cache_min_; // A different cache for min_xy_dist as the maximal safe distance an influence area can be increased(guaranteed overlap of two walls in consecutive layer) is much smaller when min_xy_dist is used. This causes the area of the wall restriction to be thinner and as such just using the min_xy_dist wall restriction would be slower. - std::unique_ptr critical_wall_restrictions_cache_min_ = std::make_unique(); + // A different cache for min_xy_dist as the maximal safe distance an influence area can be increased(guaranteed overlap of two walls in consecutive layer) + // is much smaller when min_xy_dist is used. This causes the area of the wall restriction to be thinner and as such just using the min_xy_dist wall + // restriction would be slower. + RadiusLayerPolygonCache m_wall_restrictions_cache_min; + std::unique_ptr m_critical_wall_restrictions_cache_min = std::make_unique(); - std::unique_ptr critical_progress = std::make_unique(); + std::unique_ptr m_critical_progress { std::make_unique() }; }; } -#endif //slic3r_TreeModelVolumes_hpp \ No newline at end of file +#endif //slic3r_TreeModelVolumes_hpp diff --git a/src/libslic3r/TreeSupport.cpp b/src/libslic3r/TreeSupport.cpp index 1ed7d2810..fb36fbe14 100644 --- a/src/libslic3r/TreeSupport.cpp +++ b/src/libslic3r/TreeSupport.cpp @@ -7,7 +7,16 @@ // CuraEngine is released under the terms of the AGPLv3 or higher. #include "TreeSupport.hpp" +#include "ClipperUtils.hpp" +#include "Fill/Fill.hpp" +#include "Layer.hpp" +#include "Print.hpp" +#include "MultiPoint.hpp" +#include "Polygon.hpp" +#include "Polyline.hpp" +#include "SupportMaterial.hpp" +#include #include #include #include @@ -15,160 +24,192 @@ #include #include //todo Remove! ONLY FOR PUBLIC BETA!! +#include + #include namespace Slic3r { -TreeSupport::TreeSupport(const SliceDataStorage& storage) -{ - size_t largest_printed_mesh_idx = 0; +static constexpr const auto tiny_area_threshold = sqr(scaled(0.001)); - for (size_t mesh_idx = 0; mesh_idx < storage.meshes.size(); mesh_idx++) - { - SliceMeshStorage mesh = storage.meshes[mesh_idx]; - if (mesh.settings.get("support_roof_height") >= 2 * mesh.settings.get("layer_height")) - { - TreeSupportSettings::some_model_contains_thick_roof = true; - } - if (mesh.settings.get("support_top_distance") == 0 || mesh.settings.get("support_bottom_distance") == 0 || mesh.settings.get("min_feature_size") < 100) - { - TreeSupportSettings::has_to_rely_on_min_xy_dist_only = true; - } +static [[nodiscard]] std::vector>> group_meshes(const Print &print, std::vector &print_object_ids) +{ + std::vector>> grouped_meshes; + + //FIXME this is ugly, it does not belong here. + for (size_t object_id = 0; object_id < print_object_ids.size(); ++ object_id) { + const PrintObject &print_object = *print.get_object(object_id); + const PrintObjectConfig &object_config = print_object.config(); + if (object_config.support_material_interface_layers >= 2) + TreeSupport::TreeSupportSettings::some_model_contains_thick_roof = true; + if (object_config.support_material_contact_distance < EPSILON) + // || min_feature_size < scaled(0.1) that is the minimum line width + TreeSupport::TreeSupportSettings::has_to_rely_on_min_xy_dist_only = true; } - // Group all meshes that can be processed together. NOTE this is different from mesh-groups! Only one setting object is needed per group, as different settings in the same group may only occur in the tip, which uses the original settings objects from the meshes. - for (size_t mesh_idx = 0; mesh_idx < storage.meshes.size(); mesh_idx++) - { - SliceMeshStorage mesh = storage.meshes[mesh_idx]; + size_t largest_printed_mesh_idx = 0; - const bool non_supportable_mesh = mesh.settings.get("infill_mesh") || mesh.settings.get("anti_overhang_mesh") || storage.meshes[mesh_idx].settings.get("support_mesh"); - if (storage.meshes[mesh_idx].settings.get("support_structure") != ESupportStructure::TREE || !storage.meshes[mesh_idx].settings.get("support_enable") || non_supportable_mesh) - { - continue; - } + // Group all meshes that can be processed together. NOTE this is different from mesh-groups! Only one setting object is needed per group, + // as different settings in the same group may only occur in the tip, which uses the original settings objects from the meshes. + for (size_t object_id = 0; object_id < print_object_ids.size(); ++ object_id) { + const PrintObject &print_object = *print.get_object(object_id); + const PrintObjectConfig &object_config = print_object.config(); + // Support must be enabled and set to Tree style. + assert(object_config.support_material); + assert(object_config.support_material_style == smsTree); - bool added = false; - - TreeSupportSettings next_settings(mesh.settings); - - for (size_t idx = 0; idx < grouped_meshes.size(); idx++) - { - if (next_settings == grouped_meshes[idx].first) - { - added = true; - grouped_meshes[idx].second.emplace_back(mesh_idx); + bool found_existing_group = false; + TreeSupport::TreeSupportSettings next_settings(print_object); + //FIXME for now only a single object per group is enabled. +#if 0 + for (size_t idx = 0; idx < grouped_meshes.size(); ++ idx) + if (next_settings == grouped_meshes[idx].first) { + found_existing_group = true; + grouped_meshes[idx].second.emplace_back(object_id); // handle some settings that are only used for performance reasons. This ensures that a horrible set setting intended to improve performance can not reduce it drastically. grouped_meshes[idx].first.performance_interface_skip_layers = std::min(grouped_meshes[idx].first.performance_interface_skip_layers, next_settings.performance_interface_skip_layers); } - } - if (!added) - { - grouped_meshes.emplace_back(next_settings, std::vector{ mesh_idx }); - } +#endif + if (! found_existing_group) + grouped_meshes.emplace_back(next_settings, std::vector{ object_id }); // no need to do this per mesh group as adaptive layers and raft setting are not setable per mesh. - if (storage.meshes[largest_printed_mesh_idx].layers.back().printZ < mesh.layers.back().printZ) - { - largest_printed_mesh_idx = mesh_idx; - } - } - std::vector known_z(storage.meshes[largest_printed_mesh_idx].layers.size()); - - for (size_t z = 0; z < storage.meshes[largest_printed_mesh_idx].layers.size(); z++) - { - known_z[z] = storage.meshes[largest_printed_mesh_idx].layers[z].printZ; + if (print.get_object(largest_printed_mesh_idx)->layers().back()->print_z < print_object.layers().back()->print_z) + largest_printed_mesh_idx = object_id; } - for (size_t idx = 0; idx < grouped_meshes.size(); idx++) +#if 0 { - grouped_meshes[idx].first.setActualZ(known_z); + std::vector known_z(storage.meshes[largest_printed_mesh_idx].layers.size()); + for (size_t z = 0; z < storage.meshes[largest_printed_mesh_idx].layers.size(); z++) + known_z[z] = storage.meshes[largest_printed_mesh_idx].layers[z].printZ; + for (size_t idx = 0; idx < grouped_meshes.size(); ++ idx) + grouped_meshes[idx].first.setActualZ(known_z); } +#endif + + return grouped_meshes; } - // todo remove as only for debugging relevant -std::string getPolygonAsString(const Polygons& poly) +static [[nodiscard]] std::string getPolygonAsString(const Polygons& poly) { - std::string ret = ""; + std::string ret; for (auto path : poly) - { - for (Point p : path) - { + for (Point p : path) { if (ret != "") ret += ","; ret += "(" + std::to_string(p.x()) + "," + std::to_string(p.y()) + ")"; } - } return ret; } - +//todo Remove! Only relevant for public BETA! +static bool inline g_showed_critical_error = false; +static bool inline g_showed_performance_warning = false; void TreeSupport::showError(std::string message, bool critical) { // todo Remove! ONLY FOR PUBLIC BETA!! std::string bugtype = std::string(critical ? " This is a critical bug. It may cause missing or malformed branches.\n" : "This bug should only decrease performance.\n"); - bool show = (critical && !TreeSupport::showed_critical) || (!critical && !TreeSupport::showed_performance); - (critical ? TreeSupport::showed_critical : TreeSupport::showed_performance) = true; + bool show = (critical && !g_showed_critical_error) || (!critical && !g_showed_performance_warning); + (critical ? g_showed_critical_error : g_showed_performance_warning) = true; if (show) - { - MessageBox(nullptr, std::string("TreeSupport_2 MOD detected an error while generating the tree support.\nPlease report this back to me with profile and model.\nRevision 5.0\n" + message + "\n" + bugtype).c_str(), "Bug detected!", MB_OK | MB_SYSTEMMODAL | MB_SETFOREGROUND | MB_ICONWARNING); - } + MessageBoxA(nullptr, std::string("TreeSupport_2 MOD detected an error while generating the tree support.\nPlease report this back to me with profile and model.\nRevision 5.0\n" + message + "\n" + bugtype).c_str(), + "Bug detected!", MB_OK | MB_SYSTEMMODAL | MB_SETFOREGROUND | MB_ICONWARNING); } - - -void TreeSupport::generateSupportAreas(SliceDataStorage& storage) +static bool layer_has_overhangs(const Layer &layer) { - if (grouped_meshes.empty()) - { - return; - } + for (const LayerRegion* layerm : layer.regions()) + if (layerm->slices.has(stBottom) || layerm->slices.has(stBottom)) + return true; + return false; +} - if (storage.support.cross_fill_provider == nullptr) - { - AreaSupport::precomputeCrossInfillTree(storage); +static [[nodiscard]] Polygons layer_overhangs(const Layer &layer) +{ + Polygons out; + for (const LayerRegion* layerm : layer.regions()) + for (const Surface& surface : layerm->slices.surfaces) + if (surface.is_bottom()) + polygons_append(out, surface.expolygon); + return out; +} + +/*! + * \brief Precalculates all avoidances, that could be required. + * + * \param storage[in] Background storage to access meshes. + * \param currently_processing_meshes[in] Indexes of all meshes that are processed in this iteration + */ +LayerIndex precalculate(const Print &print, const TreeSupport::TreeSupportSettings &config, const std::vector &object_ids, TreeModelVolumes &volumes) +{ + // calculate top most layer that is relevant for support + LayerIndex max_layer = 0; + for (size_t object_id : object_ids) { + const PrintObject &print_object = *print.get_object(object_id); + int max_support_layer_id = 0; + for (int layer_id = 1; layer_id < print_object.layer_count(); ++ layer_id) + if (layer_has_overhangs(*print_object.get_layer(layer_id))) + max_support_layer_id = layer_id; + max_layer = std::max(max_support_layer_id - int(config.z_distance_top_layers), 0); } + if (max_layer > 0) + // The actual precalculation happens in TreeModelVolumes. + volumes.precalculate(max_layer); + return max_layer; +} + +void TreeSupport::generateSupportAreas(Print &print, const BuildVolume &build_volume, std::vector &print_object_ids) +{ + std::vector>> grouped_meshes = group_meshes(print, print_object_ids); + if (grouped_meshes.empty()) + return; size_t counter = 0; // Process every mesh group. These groups can not be processed parallel, as the processing in each group is parallelized, and nested parallelization is disables and slow. - for (std::pair> processing : grouped_meshes) + for (std::pair> &processing : grouped_meshes) { // process each combination of meshes - std::vector> move_bounds(storage.support.supportLayers.size()); // value is the area where support may be placed. As this is calculated in CreateLayerPathing it is saved and reused in drawAreas - log("Processing support tree mesh group %lld of %lld containing %lld meshes.\n", counter + 1, grouped_meshes.size(), grouped_meshes[counter].second.size()); - std::vector exclude(storage.support.supportLayers.size()); + // this struct is used to easy retrieve setting. No other function except those in TreeModelVolumes and generateInitialAreas have knowledge of the existence of multiple meshes being processed. + //FIXME this is a copy + m_config = processing.first; + BOOST_LOG_TRIVIAL(info) << "Processing support tree mesh group " << counter + 1 << " of " << grouped_meshes.size() << " containing " << grouped_meshes[counter].second.size() << " meshes."; auto t_start = std::chrono::high_resolution_clock::now(); +#if 0 + std::vector exclude(num_support_layers); // get all already existing support areas and exclude them - tbb::parallel_for(tbb::blocked_range(0, storage.support.supportLayers.size()), + tbb::parallel_for(tbb::blocked_range(0, num_support_layers), [&](const tbb::blocked_range &range) { for (size_t layer_idx = range.begin(); layer_idx < range.end(); ++ layer_idx) { Polygons exlude_at_layer; - exlude_at_layer.add(storage.support.supportLayers[layer_idx].support_bottom); - exlude_at_layer.add(storage.support.supportLayers[layer_idx].support_roof); + append(exlude_at_layer, storage.support.supportLayers[layer_idx].support_bottom); + append(exlude_at_layer, storage.support.supportLayers[layer_idx].support_roof); for (auto part : storage.support.supportLayers[layer_idx].support_infill_parts) - { - exlude_at_layer.add(part.outline); - } - exclude[layer_idx] = exlude_at_layer.unionPolygons(); + append(exlude_at_layer, part.outline); + exclude[layer_idx] = union_(exlude_at_layer); } }); - config = processing.first; // this struct is used to easy retrieve setting. No other function except those in TreeModelVolumes and generateInitialAreas have knowledge of the existence of multiple meshes being processed. - progress_multiplier = 1.0 / double(grouped_meshes.size()); - progress_offset = counter == 0 ? 0 : TREE_PROGRESS_TOTAL * (double(counter) * progress_multiplier); - volumes_ = TreeModelVolumes(storage, config.maximum_move_distance, config.maximum_move_distance_slow, processing.second.front(), progress_multiplier, progress_offset, exclude); +#endif +#ifdef SLIC3R_TREESUPPORTS_PROGRESS + m_progress_multiplier = 1.0 / double(m_grouped_meshes.size()); + m_progress_offset = counter == 0 ? 0 : TREE_PROGRESS_TOTAL * (double(counter) * m_progress_multiplier); +#endif // SLIC3R_TREESUPPORT_PROGRESS + m_volumes = TreeModelVolumes(*print.get_object(processing.second.front()), build_volume, m_config.maximum_move_distance, m_config.maximum_move_distance_slow, processing.second.front(), m_progress_multiplier, m_progress_offset, {} /* exclude */); // ### Precalculate avoidances, collision etc. - precalculate(storage, processing.second); + size_t num_support_layers = precalculate(print, processing.first, processing.second, m_volumes); auto t_precalc = std::chrono::high_resolution_clock::now(); + // value is the area where support may be placed. As this is calculated in CreateLayerPathing it is saved and reused in drawAreas + std::vector> move_bounds(num_support_layers); + // ### Place tips of the support tree for (size_t mesh_idx : processing.second) - { - generateInitialAreas(storage.meshes[mesh_idx], move_bounds, storage); - } + generateInitialAreas(*print.get_object(mesh_idx), move_bounds); auto t_gen = std::chrono::high_resolution_clock::now(); // ### Propagate the influence areas downwards. @@ -180,7 +221,7 @@ void TreeSupport::generateSupportAreas(SliceDataStorage& storage) auto t_place = std::chrono::high_resolution_clock::now(); // ### draw these points as circles - drawAreas(move_bounds, storage); + drawAreas(*print.get_object(processing.second.front()), move_bounds); auto t_draw = std::chrono::high_resolution_clock::now(); auto dur_pre_gen = 0.001 * std::chrono::duration_cast(t_precalc - t_start).count(); @@ -189,105 +230,84 @@ void TreeSupport::generateSupportAreas(SliceDataStorage& storage) auto dur_place = 0.001 * std::chrono::duration_cast(t_place - t_path).count(); auto dur_draw = 0.001 * std::chrono::duration_cast(t_draw - t_place).count(); auto dur_total = 0.001 * std::chrono::duration_cast(t_draw - t_start).count(); - log("Total time used creating Tree support for the currently grouped meshes: %.3lf ms. Different subtasks:\nCalculating Avoidance: %.3lf ms Creating inital influence areas: %.3lf ms Influence area creation: %.3lf ms Placement of Points in InfluenceAreas: %.3lf ms Drawing result as support %.3lf ms\n", dur_total, dur_pre_gen, dur_gen, dur_path, dur_place, dur_draw); - if(config.branch_radius==2121) - { - showError("Why ask questions when you already know the answer twice.\n (This is not a real bug, please dont report it.)",false); - } + BOOST_LOG_TRIVIAL(info) << + "Total time used creating Tree support for the currently grouped meshes: " << dur_total << " ms. " + "Different subtasks:\nCalculating Avoidance: " << dur_pre_gen << " ms " + "Creating inital influence areas: " << dur_gen << " ms " + "Influence area creation: " << dur_path << "ms " + "Placement of Points in InfluenceAreas: " << dur_place << "ms " + "Drawing result as support " << dur_draw << " ms"; +// if (m_config.branch_radius==2121) +// BOOST_LOG_TRIVIAL(error) << "Why ask questions when you already know the answer twice.\n (This is not a real bug, please dont report it.)"; - for (auto& layer : move_bounds) - { - for (auto elem : layer) - { + for (auto &layer : move_bounds) { + for (auto elem : layer) { delete elem->area; delete elem; } } - counter++; + ++ counter; } - storage.support.generated = true; +// storage.support.generated = true; } - -void TreeSupport::precalculate(const SliceDataStorage& storage, std::vector currently_processing_meshes) +static inline [[nodiscard]] bool contains(const Polygons &polygons, const Point &p) { - // calculate top most layer that is relevant for support - LayerIndex max_layer = 0; - for (size_t mesh_idx : currently_processing_meshes) - { - const SliceMeshStorage& mesh = storage.meshes[mesh_idx]; - const coord_t layer_height = mesh.settings.get("layer_height"); - const coord_t z_distance_top = mesh.settings.get("support_top_distance"); - const size_t z_distance_top_layers = round_up_divide(z_distance_top, - layer_height) + 1; // Support must always be 1 layer below overhang. - if (mesh.overhang_areas.size() <= z_distance_top_layers) - { - continue; - } - for (LayerIndex layer_idx = (mesh.overhang_areas.size() - z_distance_top_layers) - 1; layer_idx != 0; layer_idx--) - { - // look for max relevant layer - const Polygons& overhang = mesh.overhang_areas[layer_idx + z_distance_top_layers]; - if (!overhang.empty()) - { - if (layer_idx > max_layer) // iterates over multiple meshes - { - max_layer = 1 + layer_idx; // plus one to avoid problems if something is of by one - } - break; - } - } - } - - // ### The actual precalculation happens in TreeModelVolumes. - volumes_.precalculate(max_layer); + for (const Polygon &polygon : polygons) + if (polygon.contains(p)) + return true; + return false; } - -std::vector TreeSupport::convertLinesToInternal(Polygons polylines, LayerIndex layer_idx) +enum class LineStatus { - const bool xy_overrides = config.support_xy_overrides_z; + INVALID, + TO_MODEL, + TO_MODEL_GRACIOUS, + TO_MODEL_GRACIOUS_SAFE, + TO_BP, + TO_BP_SAFE +}; - std::vector result; +using LineInformation = std::vector>; +using LineInformations = std::vector; + +/*! + * \brief Converts a Polygons object representing a line into the internal format. + * + * \param polylines[in] The Polyline that will be converted. + * \param layer_idx[in] The current layer. + * \return All lines of the \p polylines object, with information for each point regarding in which avoidance it is currently valid in. + */ +static [[nodiscard]] LineInformations convertLinesToInternal( + const TreeModelVolumes &volumes, const TreeSupport::TreeSupportSettings &config, + const Polylines &polylines, LayerIndex layer_idx) +{ + const bool xy_overrides_z = config.support_xy_overrides_z; + + LineInformations result; // Also checks if the position is valid, if it is NOT, it deletes that point - for (auto line : polylines) - { + for (const Polyline &line : polylines) { LineInformation res_line; - for (Point p : line) - { - if (!volumes_.getAvoidance(config.getRadius(0), layer_idx, AvoidanceType::FAST_SAFE, false, !xy_overrides).inside(p, true)) - { + for (Point p : line) { + if (! contains(volumes.getAvoidance(config.getRadius(0), layer_idx, TreeModelVolumes::AvoidanceType::FAST_SAFE, false, !xy_overrides_z), p)) res_line.emplace_back(p, LineStatus::TO_BP_SAFE); - } - else if (!volumes_.getAvoidance(config.getRadius(0), layer_idx, AvoidanceType::FAST, false, !xy_overrides).inside(p, true)) - { + else if (! contains(volumes.getAvoidance(config.getRadius(0), layer_idx, TreeModelVolumes::AvoidanceType::FAST, false, !xy_overrides_z), p)) res_line.emplace_back(p, LineStatus::TO_BP); - } - else if (config.support_rests_on_model && !volumes_.getAvoidance(config.getRadius(0), layer_idx, AvoidanceType::FAST_SAFE, true, !xy_overrides).inside(p, true)) - { + else if (config.support_rests_on_model && ! contains(volumes.getAvoidance(config.getRadius(0), layer_idx, TreeModelVolumes::AvoidanceType::FAST_SAFE, true, !xy_overrides_z), p)) res_line.emplace_back(p, LineStatus::TO_MODEL_GRACIOUS_SAFE); - } - else if (config.support_rests_on_model && !volumes_.getAvoidance(config.getRadius(0), layer_idx, AvoidanceType::FAST, true, !xy_overrides).inside(p, true)) - { + else if (config.support_rests_on_model && ! contains(volumes.getAvoidance(config.getRadius(0), layer_idx, TreeModelVolumes::AvoidanceType::FAST, true, !xy_overrides_z), p)) res_line.emplace_back(p, LineStatus::TO_MODEL_GRACIOUS); - } - else if (config.support_rests_on_model && !volumes_.getCollision(config.getRadius(0), layer_idx, !xy_overrides).inside(p, true)) - { + else if (config.support_rests_on_model && ! contains(volumes.getCollision(config.getRadius(0), layer_idx, !xy_overrides_z), p)) res_line.emplace_back(p, LineStatus::TO_MODEL); - } - else - { - if (!res_line.empty()) - { - result.emplace_back(res_line); - res_line.clear(); - } + else if (!res_line.empty()) { + result.emplace_back(res_line); + res_line.clear(); } } - if (!res_line.empty()) - { + if (!res_line.empty()) { result.emplace_back(res_line); res_line.clear(); } @@ -296,85 +316,81 @@ std::vector TreeSupport::convertLinesToInternal(Po return result; } -Polygons TreeSupport::convertInternalToLines(std::vector lines) +/*! + * \brief Converts lines in internal format into a Polygons object representing these lines. + * + * \param lines[in] The lines that will be converted. + * \return All lines of the \p lines object as a Polygons object. + */ +static [[nodiscard]] Polylines convertInternalToLines(LineInformations lines) { - Polygons result; - - for (LineInformation line : lines) - { - Polygon path; + Polylines result; + for (LineInformation line : lines) { + Polyline path; for (auto point_data : line) - { - path.add(point_data.first); - } - result.add(path); + path.points.emplace_back(point_data.first); + result.emplace_back(std::move(path)); } return result; } - -std::function)> TreeSupport::getEvaluatePointForNextLayerFunction(size_t current_layer) +/*! + * \brief Evaluates if a point has to be added now. Required for a splitLines call in generateInitialAreas. + * + * \param current_layer[in] The layer on which the point lies, point and its status. + * \return whether the point is valid. + */ +static [[nodiscard]] bool evaluatePointForNextLayerFunction( + const TreeModelVolumes &volumes, const TreeSupport::TreeSupportSettings &config, + size_t current_layer, std::pair &p) { - const bool xy_overrides = config.support_xy_overrides_z; - std::function)> evaluatePoint = [=](std::pair p) - { - if (!volumes_.getAvoidance(config.getRadius(0), current_layer - 1, p.second == LineStatus::TO_BP_SAFE ? AvoidanceType::FAST_SAFE : AvoidanceType::FAST, false, !xy_overrides).inside(p.first, true)) - { - return true; - } - if (config.support_rests_on_model && (p.second != LineStatus::TO_BP && p.second != LineStatus::TO_BP_SAFE)) - { - if (p.second == LineStatus::TO_MODEL_GRACIOUS || p.second == LineStatus::TO_MODEL_GRACIOUS_SAFE) - { - return !volumes_.getAvoidance(config.getRadius(0), current_layer - 1, p.second == LineStatus::TO_MODEL_GRACIOUS_SAFE ? AvoidanceType::FAST_SAFE : AvoidanceType::FAST, true, !xy_overrides).inside(p.first, true); - } - else - { - return !volumes_.getCollision(config.getRadius(0), current_layer - 1, !xy_overrides).inside(p.first, true); - } - } - return false; - }; - return evaluatePoint; + using AvoidanceType = TreeSupport::AvoidanceType; + if (! contains(volumes.getAvoidance(config.getRadius(0), current_layer - 1, p.second == LineStatus::TO_BP_SAFE ? AvoidanceType::FAST_SAFE : AvoidanceType::FAST, false, !config.support_xy_overrides_z), p.first)) + return true; + if (config.support_rests_on_model && (p.second != LineStatus::TO_BP && p.second != LineStatus::TO_BP_SAFE)) + return ! contains( + p.second == LineStatus::TO_MODEL_GRACIOUS || p.second == LineStatus::TO_MODEL_GRACIOUS_SAFE ? + volumes.getAvoidance(config.getRadius(0), current_layer - 1, p.second == LineStatus::TO_MODEL_GRACIOUS_SAFE ? AvoidanceType::FAST_SAFE : AvoidanceType::FAST, true, !config.support_xy_overrides_z) : + volumes.getCollision(config.getRadius(0), current_layer - 1, !config.support_xy_overrides_z), + p.first); + return false; } - -std::pair, std::vector> TreeSupport::splitLines(std::vector lines, std::function)> evaluatePoint) +/*! + * \brief Evaluates which points of some lines are not valid one layer below and which are. Assumes all points are valid on the current layer. Validity is evaluated using supplied lambda. + * + * \param lines[in] The lines that have to be evaluated. + * \param evaluatePoint[in] The function used to evaluate the points. + * \return A pair with which points are still valid in the first slot and which are not in the second slot. + */ +template +static [[nodiscard]] std::pair splitLines(LineInformations lines, EvaluatePointFn evaluatePoint) { // assumes all Points on the current line are valid - std::vector keep(1); - std::vector set_free(1); + LineInformations keep(1); + LineInformations set_free(1); enum STATE { keeping, freeing }; - for (std::vector> line : lines) - { + for (std::vector> line : lines) { STATE current = keeping; LineInformation resulting_line; - for (std::pair me : line) - { - if (evaluatePoint(me)) - { - if (keeping != current) - { - if (!resulting_line.empty()) - { + for (std::pair me : line) { + if (evaluatePoint(me)) { + if (keeping != current) { + if (!resulting_line.empty()) { set_free.emplace_back(resulting_line); resulting_line.clear(); } current = keeping; } resulting_line.emplace_back(me); - } - else - { - if (freeing != current) - { - if (!resulting_line.empty()) - { + } else { + if (freeing != current) { + if (!resulting_line.empty()) { keep.emplace_back(resulting_line); resulting_line.clear(); } @@ -383,92 +399,138 @@ std::pair, std::vector>>, std::vector>>>(keep, set_free); +} + +/*! + * A point within a polygon and the index of which segment in the polygon the point lies on. + */ + //from CURA +struct GivenDistPoint +{ + Point location; //!< Result location + int pos; //!< Index to the first point in the polygon of the line segment on which the result was found +}; + +//from CURA +static bool getNextPointWithDistance(Point from, double dist, Points &poly, int start_idx, int poly_start_idx, GivenDistPoint& result) +{ + Point prev_poly_point = poly[(start_idx + poly_start_idx) % poly.size()]; + + for (unsigned int prev_idx = start_idx; prev_idx < poly.size(); ++ prev_idx) + { + // last checked segment is between last point in poly and poly[0]... + int next_idx = (prev_idx + 1 + poly_start_idx) % poly.size(); + const Point &next_poly_point = poly[next_idx]; + if ((next_poly_point - from).cast().norm() >= dist) { + /* + * x r + * p.---------+---+------------.n + * L| / + * | / dist + * |/ + * f. + * + * f=from + * p=prev_poly_point + * n=next_poly_point + * x= f projected on pn + * r=result point at distance [dist] from f + */ + + Point pn = next_poly_point - prev_poly_point; + + static constexpr const double eps = scaled(0.1); + if (pn.cast().squaredNorm() < sqr(eps)) { // when precision is limited + Point middle = (next_poly_point + prev_poly_point) / 2; + double dist_to_middle = (from - middle).cast().norm(); + if (dist_to_middle - dist < eps && dist_to_middle - dist > -eps) { + result.location = middle; + result.pos = prev_idx; + return true; + } else { + prev_poly_point = next_poly_point; + continue; + } } + + Point pf = from - prev_poly_point; + Point px = (pn.cast() * (pf.cast().dot(pn.cast()) / pn.cast().squaredNorm())).cast(); + Point xf = pf - px; + + if (xf.cast().norm() >= dist) { // line lies wholly further than pn + prev_poly_point = next_poly_point; + continue; + } + + double xr_dist = std::sqrt(dist * dist - xf.cast().squaredNorm()); // inverse Pythagoras + + if ((pn - px).cast().norm() - xr_dist < scaled(1.)) { // r lies beyond n + prev_poly_point = next_poly_point; + continue; + } + + Point xr = (pn * (xr_dist / pn.cast().norm())).cast(); + Point pr = px + xr; + + result.location = prev_poly_point + pr; + result.pos = prev_idx; + return true; } + prev_poly_point = next_poly_point; } - return std::pair>>, std::vector>>>(keep, set_free); + return false; } - -void writePolylines(SVG& svg, Polygons polylines, SVG::Color color) // todo remove as only for debugging relevant +/*! + * \brief Eensures that every line segment is about distance in length. The resulting lines may differ from the original but all points are on the original + * + * \param input[in] The lines on which evenly spaced points should be placed. + * \param distance[in] The distance the points should be from each other. + * \param min_points[in] The amount of points that have to be placed. If not enough can be placed the distance will be reduced to place this many points. + * \return A Polygons object containing the evenly spaced points. Does not represent an area, more a collection of points on lines. + */ +static [[nodiscard]] Polylines ensureMaximumDistancePolyline(const Polylines &input, double distance, size_t min_points) { - for (auto path : polylines) - { - if (path.size() == 0) - { + Polylines result; + for (Polyline part : input) { + if (part.empty() == 0) continue; - } - if (path.size() == 1) - { - svg.writePoint(path[0], false, 2, color); - } - Point before = path[0]; - for (size_t i = 1; i < path.size(); i++) - { - svg.writeLine(before, path[i], color, 2); - before = path[i]; - } - } -} -void writePoints(SVG& svg, Polygons polylines, SVG::Color color) // todo remove as only for debugging relevant -{ - for (auto path : polylines) - { - for (Point p : path) + double len = length(part.points); + Polyline line; + double current_distance = std::max(distance, scaled(0.1)); + if (len < 2 * distance && min_points <= 1) { - svg.writePoint(p, false, 2, color); - } - } -} - -Polygons TreeSupport::ensureMaximumDistancePolyline(const Polygons& input, coord_t distance, size_t min_points) const -{ - Polygons result; - for (auto part : input) - { - if (part.size() == 0) - { - continue; - } - coord_t length = Polygon(part).offset(0).polyLineLength(); - Polygon line; - coord_t current_distance = std::max(distance, coord_t(100)); - if (length < 2 * distance && min_points <= 1) - { - ClosestPolygonPoint middle_point(part[0], 0, part); - middle_point = PolygonUtils::walk(middle_point, coord_t(length / 2)); - line.add(middle_point.location); + // Insert the opposite point of the first one. + //FIXME pretty expensive + Polyline pl(line.points); + pl.clip_end(len / 2); + line.points.emplace_back(pl.points.back()); } else { size_t optimal_end_index = part.size() - 1; - if (part.front() == part.back()) - { + if (part.front() == part.back()) { size_t optimal_start_index = 0; // If the polyline was a polygon, there is a high chance it was an overhang. Overhangs that are <60� tend to be very thin areas, so lets get the beginning and end of them and ensure that they are supported. // The first point of the line will always be supported, so rotate the order of points in this polyline that one of the two corresponding points that are furthest from each other is in the beginning. // The other will be manually added (optimal_end_index) coord_t max_dist2_between_vertecies = 0; - for (size_t idx = 0; idx < part.size() - 1; idx++) - { - for (size_t inner_idx = 0; inner_idx < part.size() - 1; inner_idx++) - { - if (vSize2(part[idx] - part[inner_idx]) > max_dist2_between_vertecies) - { + for (size_t idx = 0; idx < part.size() - 1; ++ idx) { + for (size_t inner_idx = 0; inner_idx < part.size() - 1; inner_idx++) { + if ((part[idx] - part[inner_idx]).cast().squaredNorm() > max_dist2_between_vertecies) { optimal_start_index = idx; optimal_end_index = inner_idx; - max_dist2_between_vertecies = vSize2(part[idx] - part[inner_idx]); + max_dist2_between_vertecies = (part[idx] - part[inner_idx]).cast().squaredNorm(); } } } @@ -477,55 +539,46 @@ Polygons TreeSupport::ensureMaximumDistancePolyline(const Polygons& input, coord optimal_end_index = (optimal_end_index - optimal_start_index + part.size() - 1) % (part.size() - 1); } - - while (line.size() < min_points && current_distance >= coord_t(100)) + while (line.size() < min_points && current_distance >= scaled(0.1)) { line.clear(); Point current_point = part[0]; - line.add(part[0]); - if (min_points > 1 || vSize(part[0] - part[optimal_end_index]) > current_distance) - { - line.add(part[optimal_end_index]); - } + line.points.emplace_back(part[0]); + if (min_points > 1 || (part[0] - part[optimal_end_index]).cast().norm() > current_distance) + line.points.emplace_back(part[optimal_end_index]); size_t current_index = 0; GivenDistPoint next_point; coord_t next_distance = current_distance; // Get points so that at least min_points are added and they each are current_distance away from each other. If that is impossible, decrease current_distance a bit. - while (PolygonUtils::getNextPointWithDistance(current_point, next_distance, part, current_index, 0, next_point) && next_point.pos < coord_t(part.size())) // The input are lines, that means that the line from the last to the first vertex does not have to exist, so exclude all points that are on this line! + // The input are lines, that means that the line from the last to the first vertex does not have to exist, so exclude all points that are on this line! + while (getNextPointWithDistance(current_point, next_distance, part.points, current_index, 0, next_point) && next_point.pos < coord_t(part.size())) { // Not every point that is distance away, is valid, as it may be much closer to another point. This is especially the case when the overhang is very thin. // So this ensures that the points are actually a certain distance from each other. // This assurance is only made on a per polygon basis, as different but close polygon may not be able to use support below the other polygon. - coord_t min_distance_to_existing_point = std::numeric_limits::max(); + double min_distance_to_existing_point = std::numeric_limits::max(); for (Point p : line) - { - min_distance_to_existing_point = std::min(min_distance_to_existing_point, vSize(p - next_point.location)); - } - if (min_distance_to_existing_point >= current_distance) - { + min_distance_to_existing_point = std::min(min_distance_to_existing_point, (p - next_point.location).cast().norm()); + if (min_distance_to_existing_point >= current_distance) { // viable point was found. Add to possible result. - line.add(next_point.location); + line.points.emplace_back(next_point.location); current_point = next_point.location; current_index = next_point.pos; next_distance = current_distance; - } - else - { - if (current_point == next_point.location) - { + } else { + if (current_point == next_point.location) { // In case a fixpoint is encountered, better aggressively overcompensate so the code does not become stuck here... - logWarning("Tree Support: Encountered a fixpoint in getNextPointWithDistance. This is expected to happen if the distance (currently %lld) is smaller than 100\n", next_distance); + BOOST_LOG_TRIVIAL(warning) << "Tree Support: Encountered a fixpoint in getNextPointWithDistance. This is expected to happen if the distance (currently " << next_distance << + ") is smaller than 100"; TreeSupport::showError("Encountered issue while placing tips. Some tips may be missing.", true); if (next_distance > 2 * current_distance) - { // This case should never happen, but better safe than sorry. break; - } next_distance += current_distance; continue; } // if the point was too close, the next possible viable point is at least distance-min_distance_to_existing_point away from the one that was just checked. - next_distance = std::max(current_distance - min_distance_to_existing_point, coord_t(100)); + next_distance = std::max(current_distance - min_distance_to_existing_point, scaled(0.1)); current_point = next_point.location; current_index = next_point.pos; } @@ -533,31 +586,26 @@ Polygons TreeSupport::ensureMaximumDistancePolyline(const Polygons& input, coord current_distance *= 0.9; } } - result.add(line); + result.emplace_back(std::move(line)); } return result; } -// adds the implicit line from the last vertex to the first explicitly -Polygons TreeSupport::toPolylines(const Polygons& poly) const -{ - Polygons result; - for (auto path : poly) - { - Polygon part; - for (size_t i = 0; i < path.size(); i++) - { - part.add(path[i]); - } - part.add(path[0]); - result.add(part); - } - return result; -} - - -Polygons TreeSupport::generateSupportInfillLines(const Polygons& area, bool roof, LayerIndex layer_idx, coord_t support_infill_distance, SierpinskiFillProvider* cross_fill_provider, bool include_walls) +/*! + * \brief Returns Polylines representing the (infill) lines that will result in slicing the given area + * + * \param area[in] The area that has to be filled with infill. + * \param roof[in] Whether the roofing or regular support settings should be used. + * \param layer_idx[in] The current layer index. + * \param support_infill_distance[in] The distance that should be between the infill lines. + * + * \return A Polygons object that represents the resulting infill lines. + */ +static [[nodiscard]] Polylines generateSupportInfillLines( + const Polygons &area, const SupportParameters &support_params, + bool roof, LayerIndex layer_idx, coord_t support_infill_distance) { +#if 0 Polygons gaps; // as we effectivly use lines to place our supportPoints we may use the Infill class for it, while not made for it it works perfect @@ -583,15 +631,45 @@ Polygons TreeSupport::generateSupportInfillLines(const Polygons& area, bool roof int divisor = static_cast(angles.size()); int index = ((layer_idx % divisor) + divisor) % divisor; const AngleRadians fill_angle = angles[index]; - Infill roof_computation(pattern, true /* zig_zaggify_infill */, connect_polygons, area, roof ? config.support_roof_line_width : config.support_line_width, support_infill_distance, support_roof_overlap, infill_multiplier, fill_angle, z, support_shift, config.maximum_resolution, config.maximum_deviation, wall_line_count, infill_origin, perimeter_gaps, connected_zigzags, use_endpieces, false /* skip_some_zags */, zag_skip_count, pocket_size); + Infill roof_computation(pattern, true /* zig_zaggify_infill */, connect_polygons, area, + roof ? config.support_roof_line_width : config.support_line_width, support_infill_distance, support_roof_overlap, infill_multiplier, + fill_angle, z, support_shift, config.resolution, wall_line_count, infill_origin, + perimeter_gaps, connected_zigzags, use_endpieces, false /* skip_some_zags */, zag_skip_count, pocket_size); Polygons areas; Polygons lines; - roof_computation.generate(toolpaths, areas, lines, config.settings, cross_fill_provider); - lines.add(toPolylines(areas)); + roof_computation.generate(toolpaths, areas, lines, config.settings); + append(lines, to_polylines(areas)); return lines; +#else + const Flow &flow = roof ? support_params.support_material_interface_flow : support_params.support_material_flow; + std::unique_ptr filler = std::unique_ptr(Fill::new_from_type(roof ? support_params.interface_fill_pattern : support_params.base_fill_pattern)); + FillParams fill_params; + + filler->layer_id = layer_idx; + filler->spacing = flow.spacing(); + fill_params.density = float(roof ? support_params.interface_density : float(filler->spacing) / float(support_infill_distance)); + fill_params.dont_adjust = true; + + Polylines out; + for (ExPolygon &expoly : union_ex(area)) { + // The surface type does not matter. + Surface surface(stInternal, std::move(expoly)); + try { + append(out, filler->fill_surface(&surface, fill_params)); + } catch (InfillFailedException &) { + } + } + return out; +#endif } -Polygons TreeSupport::safeUnion(const Polygons first, const Polygons second) const +/*! + * \brief Unions two Polygons. Ensures that if the input is non empty that the output also will be non empty. + * \param first[in] The first Polygon. + * \param second[in] The second Polygon. + * \return The union of both Polygons + */ +static [[nodiscard]] Polygons safeUnion(const Polygons first, const Polygons second = Polygons()) { // unionPolygons can slowly remove Polygons under certain circumstances, because of rounding issues (Polygons that have a thin area). // This does not cause a problem when actually using it on large areas, but as influence areas (representing centerpoints) can be very thin, this does occur so this ugly workaround is needed @@ -607,151 +685,158 @@ Polygons TreeSupport::safeUnion(const Polygons first, const Polygons second) con exampleInner.add(Point(120419,83580));//F example.add(exampleInner); for(int i=0;i<10;i++){ - log("Iteration %d Example area: %f\n",i,example.area()); + log("Iteration %d Example area: %f\n",i,area(example)); example=example.unionPolygons(); } */ - - bool was_empty = first.empty() && second.empty(); - - Polygons result = first.unionPolygons(second); - - if (result.empty() && !was_empty) // error occurred - { - logDebug("Caught an area destroying union, enlarging areas a bit.\n"); - return toPolylines(first).offsetPolyLine(2).unionPolygons(toPolylines(second).offsetPolyLine(2)); // just take the few lines we have, and offset them a tiny bit. Needs to be offsetPolylines, as offset may aleady have problems with the area. - } - - else - { - return result; + Polygons result; + if (! first.empty() || ! second.empty()) { + result = union_(first, second); + if (result.empty()) { + BOOST_LOG_TRIVIAL(debug) << "Caught an area destroying union, enlarging areas a bit."; + // just take the few lines we have, and offset them a tiny bit. Needs to be offsetPolylines, as offset may aleady have problems with the area. + result = union_(offset(to_polylines(first), scaled(0.002)), offset(to_polylines(second), scaled(0.002))); + } } + + return result; } -SierpinskiFillProvider* TreeSupport::generateCrossFillProvider(const SliceMeshStorage& mesh, coord_t line_distance, coord_t line_width) +/*! + * \brief Offsets (increases the area of) a polygons object in multiple steps to ensure that it does not lag through over a given obstacle. + * \param me[in] Polygons object that has to be offset. + * \param distance[in] The distance by which me should be offset. Expects values >=0. + * \param collision[in] The area representing obstacles. + * \param last_step_offset_without_check[in] The most it is allowed to offset in one step. + * \param min_amount_offset[in] How many steps have to be done at least. As this uses round offset this increases the amount of vertices, which may be required if Polygons get very small. Required as arcTolerance is not exposed in offset, which should result with a similar result. + * \return The resulting Polygons object. + */ +static [[nodiscard]] Polygons safeOffsetInc(const Polygons& me, coord_t distance, const Polygons& collision, coord_t safe_step_size, coord_t last_step_offset_without_check, size_t min_amount_offset) { - const EFillMethod& support_pattern = mesh.settings.get("support_pattern"); - if (support_pattern == EFillMethod::CROSS || support_pattern == EFillMethod::CROSS_3D) - { - AABB3D aabb; - if (mesh.settings.get("infill_mesh") || mesh.settings.get("anti_overhang_mesh")) - { - logWarning("Tree support tried to generate a CrossFillProvider for a non model mesh.\n"); - TreeSupport::showError("Tried to generate a CrossFillProvider for a non model mesh..\n", true); - return nullptr; - } - - const coord_t aabb_expansion = mesh.settings.get("support_offset"); - AABB3D aabb_here(mesh.bounding_box); - aabb_here.include(aabb_here.min - Point3(-aabb_expansion, -aabb_expansion, 0)); - aabb_here.include(aabb_here.max + Point3(-aabb_expansion, -aabb_expansion, 0)); - aabb.include(aabb_here); - - std::string cross_subdisivion_spec_image_file = mesh.settings.get("cross_support_density_image"); - std::ifstream cross_fs(cross_subdisivion_spec_image_file.c_str()); - if (cross_subdisivion_spec_image_file != "" && cross_fs.good()) - { - return new SierpinskiFillProvider(aabb, line_distance, line_width, cross_subdisivion_spec_image_file); - } - else - { - return new SierpinskiFillProvider(aabb, line_distance, line_width); - } + bool do_final_difference = last_step_offset_without_check == 0; + Polygons ret = safeUnion(me); // ensure sane input + if (distance == 0) + return do_final_difference ? diff(ret, collision) : union_(ret); + if (safe_step_size < 0 || last_step_offset_without_check < 0) { + BOOST_LOG_TRIVIAL(error) << "Offset increase got invalid parameter!"; + TreeSupport::showError("Negative offset distance... How did you manage this ?", true); + return do_final_difference ? diff(ret, collision) : union_(ret); } - return nullptr; + + coord_t step_size = safe_step_size; + size_t steps = distance > last_step_offset_without_check ? (distance - last_step_offset_without_check) / step_size : 0; + if (distance - steps * step_size > last_step_offset_without_check) { + if ((steps + 1) * step_size <= distance) + // This will be the case when last_step_offset_without_check >= safe_step_size + ++ steps; + else + do_final_difference = true; + } + if (steps + (distance < last_step_offset_without_check || distance % step_size != 0) < min_amount_offset && min_amount_offset > 1) { + // yes one can add a bool as the standard specifies that a result from compare operators has to be 0 or 1 + // reduce the stepsize to ensure it is offset the required amount of times + step_size = distance / min_amount_offset; + if (step_size >= safe_step_size) { + // effectivly reduce last_step_offset_without_check + step_size = safe_step_size; + steps = min_amount_offset; + } else + steps = distance / step_size; + } + // offset in steps + for (size_t i = 0; i < steps; i++) { + ret = diff(offset(ret, step_size, ClipperLib::jtRound), collision); + // ensure that if many offsets are done the performance does not suffer extremely by the new vertices of jtRound. + if (i % 10 == 7) + ret = polygons_simplify(ret, scaled(0.015)); + } + // offset the remainder + ret = polygons_simplify(offset(ret, distance - steps * step_size, ClipperLib::jtRound), scaled(0.015)); + + if (do_final_difference) + ret = diff(ret, collision); + return union_(ret); } - -void TreeSupport::generateInitialAreas(const SliceMeshStorage& mesh, std::vector>& move_bounds, SliceDataStorage& storage) +void TreeSupport::generateInitialAreas(const PrintObject &print_object, std::vector> &move_bounds) { Polygon base_circle; const int base_radius = 10; - for (unsigned int i = 0; i < SUPPORT_TREE_CIRCLE_RESOLUTION; i++) - { + for (unsigned int i = 0; i < SUPPORT_TREE_CIRCLE_RESOLUTION; ++ i) { const AngleRadians angle = static_cast(i) / SUPPORT_TREE_CIRCLE_RESOLUTION * (2.0 * M_PI); - base_circle.emplace_back(coord_t(cos(angle) * base_radius), coord_t(sin(angle) * base_radius)); + base_circle.points.emplace_back(coord_t(cos(angle) * base_radius), coord_t(sin(angle) * base_radius)); } - TreeSupportSettings mesh_config(mesh.settings); + TreeSupportSettings mesh_config(print_object); + TreeSupportMeshGroupSettings mesh_group_settings(print_object); + SupportParameters support_params(print_object); const size_t z_distance_delta = mesh_config.z_distance_top_layers + 1; // To ensure z_distance_top_layers are left empty between the overhang (zeroth empty layer), the support has to be added z_distance_top_layers+1 layers below - const bool xy_overrides = mesh_config.support_xy_overrides_z; - const coord_t support_roof_line_distance = mesh.settings.get("support_roof_line_distance"); - const double minimum_roof_area = mesh.settings.get("minimum_roof_area"); - const double minimum_support_area = mesh.settings.get("minimum_support_area"); - const size_t support_roof_layers = mesh.settings.get("support_roof_enable") ? (mesh.settings.get("support_roof_height") + mesh_config.layer_height / 2) / mesh_config.layer_height : 0; - const bool roof_enabled = support_roof_layers != 0; - const bool only_gracious = SUPPORT_TREE_ONLY_GRACIOUS_TO_MODEL; - const EFillMethod support_pattern = mesh.settings.get("support_pattern"); - const coord_t connect_length = (mesh_config.support_line_width * 100 / mesh.settings.get("support_tree_top_rate")) + std::max(2 * mesh_config.min_radius - 1.0 * mesh_config.support_line_width, 0.0); - const coord_t support_tree_branch_distance = (support_pattern == EFillMethod::TRIANGLES ? 3 : (support_pattern == EFillMethod::GRID ? 2 : 1)) * connect_length; - const coord_t circle_length_to_half_linewidth_change = mesh_config.min_radius < mesh_config.support_line_width ? mesh_config.min_radius / 2 : sqrt(square(mesh_config.min_radius) - square(mesh_config.min_radius - mesh_config.support_line_width / 2)); // As r*r=x*x+y*y (circle equation): If a circle with center at (0,0) the top most point is at (0,r) as in y=r. This calculates how far one has to move on the x-axis so that y=r-support_line_width/2. In other words how far does one need to move on the x-axis to be support_line_width/2 away from the circle line. As a circle is round this length is identical for every axis as long as the 90� angle between both remains. - const coord_t support_outset = mesh.settings.get("support_offset"); - const coord_t roof_outset = mesh.settings.get("support_roof_offset"); - const coord_t extra_outset = std::max(coord_t(0), mesh_config.min_radius - mesh_config.support_line_width) + (xy_overrides ? 0 : mesh_config.support_line_width / 2); // extra support offset to compensate for larger tip radiis. Also outset a bit more when z overwrites xy, because supporting something with a part of a support line is better than not supporting it at all. - const bool force_tip_to_roof = (mesh_config.min_radius * mesh_config.min_radius * M_PI > minimum_roof_area * (1000 * 1000)) && roof_enabled; - const double support_overhang_angle = mesh.settings.get("support_angle"); - const coord_t max_overhang_speed = (support_overhang_angle < (2.0 * M_PI) / 4) ? (coord_t)(tan(support_overhang_angle) * mesh_config.layer_height) : std::numeric_limits::max(); - const size_t max_overhang_insert_lag = std::max((size_t)round_up_divide(mesh_config.xy_distance, max_overhang_speed / 2), 2 * mesh_config.z_distance_top_layers); // cap for how much layer below the overhang a new support point may be added, as other than with regular support every new inserted point may cause extra material and time cost. Could also be an user setting or differently calculated. Idea is that if an overhang does not turn valid in double the amount of layers a slope of support angle would take to travel xy_distance, nothing reasonable will come from it. The 2*z_distance_delta is only a catch for when the support angle is very high. - SierpinskiFillProvider* cross_fill_provider = generateCrossFillProvider(mesh, support_tree_branch_distance, mesh_config.support_line_width); + const bool xy_overrides_z = mesh_config.support_xy_overrides_z; +#if 0 if (mesh.overhang_areas.size() <= z_distance_delta) - { return; - } - std::vector> already_inserted(mesh.overhang_areas.size() - z_distance_delta); +#endif + const coord_t connect_length = (mesh_config.support_line_width * 100. / mesh_group_settings.support_tree_top_rate) + std::max(2 * mesh_config.min_radius - 1.0 * mesh_config.support_line_width, 0.0); + const coord_t circle_length_to_half_linewidth_change = mesh_config.min_radius < mesh_config.support_line_width ? mesh_config.min_radius / 2 : sqrt(sqr(mesh_config.min_radius) - sqr(mesh_config.min_radius - mesh_config.support_line_width / 2)); // As r*r=x*x+y*y (circle equation): If a circle with center at (0,0) the top most point is at (0,r) as in y=r. This calculates how far one has to move on the x-axis so that y=r-support_line_width/2. In other words how far does one need to move on the x-axis to be support_line_width/2 away from the circle line. As a circle is round this length is identical for every axis as long as the 90� angle between both remains. + const coord_t extra_outset = std::max(coord_t(0), mesh_config.min_radius - mesh_config.support_line_width) + (xy_overrides_z ? 0 : mesh_config.support_line_width / 2); // extra support offset to compensate for larger tip radiis. Also outset a bit more when z overwrites xy, because supporting something with a part of a support line is better than not supporting it at all. + const size_t support_roof_layers = mesh_group_settings.support_roof_enable ? (mesh_group_settings.support_roof_height + mesh_config.layer_height / 2) / mesh_config.layer_height : 0; + const bool roof_enabled = support_roof_layers != 0; + const bool force_tip_to_roof = (mesh_config.min_radius * mesh_config.min_radius * M_PI > mesh_group_settings.minimum_roof_area) && roof_enabled; + const coord_t max_overhang_speed = (mesh_group_settings.support_angle < 0.5 * M_PI) ? (coord_t)(tan(mesh_group_settings.support_angle) * mesh_config.layer_height) : std::numeric_limits::max(); + const size_t max_overhang_insert_lag = std::max((size_t)round_up_divide(mesh_config.xy_distance, max_overhang_speed / 2), 2 * mesh_config.z_distance_top_layers); // cap for how much layer below the overhang a new support point may be added, as other than with regular support every new inserted point may cause extra material and time cost. Could also be an user setting or differently calculated. Idea is that if an overhang does not turn valid in double the amount of layers a slope of support angle would take to travel xy_distance, nothing reasonable will come from it. The 2*z_distance_delta is only a catch for when the support angle is very high. + + //FIXME + size_t num_support_layers = print_object.layer_count(); + std::vector> already_inserted(num_support_layers - z_distance_delta); std::mutex critical_sections; - tbb::parallel_for(tbb::blocked_range(1, mesh.overhang_areas.size() - z_distance_delta), - [&](const tbb::blocked_range &range) { + tbb::parallel_for(tbb::blocked_range(1, num_support_layers - z_distance_delta), + [this, &print_object, &mesh_config, &mesh_group_settings, &support_params, z_distance_delta, xy_overrides_z, force_tip_to_roof, roof_enabled, support_roof_layers, extra_outset, circle_length_to_half_linewidth_change, connect_length, max_overhang_insert_lag, + &base_circle, &critical_sections, &already_inserted, + &move_bounds, &base_radius](const tbb::blocked_range &range) { for (size_t layer_idx = range.begin(); layer_idx < range.end(); ++ layer_idx) { + if (! layer_has_overhangs(*print_object.get_layer(layer_idx + z_distance_delta))) + continue; - if (mesh.overhang_areas[layer_idx + z_distance_delta].empty()) - { - return; // This is a continue if imagined in a loop context - } + Polygons relevant_forbidden = (mesh_config.support_rests_on_model ? (SUPPORT_TREE_ONLY_GRACIOUS_TO_MODEL ? m_volumes.getAvoidance(mesh_config.getRadius(0), layer_idx, AvoidanceType::FAST, true, !xy_overrides_z) : m_volumes.getCollision(mesh_config.getRadius(0), layer_idx, !xy_overrides_z)) : m_volumes.getAvoidance(mesh_config.getRadius(0), layer_idx, AvoidanceType::FAST, false, !xy_overrides_z)); // take the least restrictive avoidance possible + // prevent rounding errors down the line, points placed directly on the line of the forbidden area may not be added otherwise. + relevant_forbidden = offset(union_ex(relevant_forbidden), scaled(0.005)); - Polygons relevant_forbidden = (mesh_config.support_rests_on_model ? (only_gracious ? volumes_.getAvoidance(mesh_config.getRadius(0), layer_idx, AvoidanceType::FAST, true, !xy_overrides) : volumes_.getCollision(mesh_config.getRadius(0), layer_idx, !xy_overrides)) : volumes_.getAvoidance(mesh_config.getRadius(0), layer_idx, AvoidanceType::FAST, false, !xy_overrides)); // take the least restrictive avoidance possible - relevant_forbidden = relevant_forbidden.offset(5); // prevent rounding errors down the line, points placed directly on the line of the forbidden area may not be added otherwise. - std::function generateLines = [&](const Polygons& area, bool roof, LayerIndex layer_idx) - { - const coord_t support_infill_distance = roof ? support_roof_line_distance : support_tree_branch_distance; - return generateSupportInfillLines(area, roof, layer_idx, support_infill_distance, cross_fill_provider); + auto generateLines = [&](const Polygons& area, bool roof, LayerIndex layer_idx) -> Polylines { + const coord_t support_infill_distance = roof ? mesh_group_settings.support_roof_line_distance : mesh_group_settings.support_tree_branch_distance; + return generateSupportInfillLines(area, support_params, roof, layer_idx, support_infill_distance); }; - std::function, size_t, LayerIndex, size_t, bool, bool)> addPointAsInfluenceArea = [&](std::pair p, size_t dtt, LayerIndex insert_layer, size_t dont_move_until, bool roof, bool skip_ovalisation) + auto addPointAsInfluenceArea = [&](std::pair p, size_t dtt, LayerIndex insert_layer, size_t dont_move_until, bool roof, bool skip_ovalisation) { bool to_bp = p.second == LineStatus::TO_BP || p.second == LineStatus::TO_BP_SAFE; bool gracious = to_bp || p.second == LineStatus::TO_MODEL_GRACIOUS || p.second == LineStatus::TO_MODEL_GRACIOUS_SAFE; bool safe_radius = p.second == LineStatus::TO_BP_SAFE || p.second == LineStatus::TO_MODEL_GRACIOUS_SAFE; - if (!mesh_config.support_rests_on_model && !to_bp) - { - logWarning("Tried to add an invalid support point\n"); + if (!mesh_config.support_rests_on_model && !to_bp) { + BOOST_LOG_TRIVIAL(warning) << "Tried to add an invalid support point"; TreeSupport::showError("Unable to add tip. Some overhang may not be supported correctly.", true); return; } Polygon circle; for (Point corner : base_circle) - { - circle.add(p.first + corner); - } - Polygons area = circle.offset(0); + circle.points.emplace_back(p.first + corner); { std::lock_guard critical_section_movebounds(critical_sections); - if (!already_inserted[insert_layer].count(p.first / ((mesh_config.min_radius + 1) / 10))) - { + if (! already_inserted[insert_layer].count(p.first / ((mesh_config.min_radius + 1) / 10))) { // normalize the point a bit to also catch points which are so close that inserting it would achieve nothing already_inserted[insert_layer].emplace(p.first / ((mesh_config.min_radius + 1) / 10)); - SupportElement* elem = new SupportElement(dtt, insert_layer, p.first, to_bp, gracious, !xy_overrides, dont_move_until, roof, safe_radius, force_tip_to_roof, skip_ovalisation); - elem->area = new Polygons(area); + SupportElement* elem = new SupportElement(dtt, insert_layer, p.first, to_bp, gracious, !xy_overrides_z, dont_move_until, roof, safe_radius, force_tip_to_roof, skip_ovalisation); + elem->area = new Polygons(); + elem->area->emplace_back(std::move(circle)); move_bounds[insert_layer].emplace(elem); } } }; - - std::function, size_t, LayerIndex, bool, size_t)> addLinesAsInfluenceAreas = [&](std::vector lines, size_t roof_tip_layers, LayerIndex insert_layer_idx, bool supports_roof, size_t dont_move_until) + auto addLinesAsInfluenceAreas = [&](LineInformations lines, size_t roof_tip_layers, LayerIndex insert_layer_idx, bool supports_roof, size_t dont_move_until) { // Add tip area as roof (happens when minimum roof area > minimum tip area) if possible size_t dtt_roof_tip; @@ -759,146 +844,137 @@ void TreeSupport::generateInitialAreas(const SliceMeshStorage& mesh, std::vector { std::function)> evaluateRoofWillGenerate = [&](std::pair p) { + //FIXME Vojtech: The circle is just shifted, it has a known size, the infill should fit all the time! +#if 0 Polygon roof_circle; for (Point corner : base_circle) - { - roof_circle.add(p.first + corner * mesh_config.min_radius); - } - Polygons area = roof_circle.offset(0); - return !generateLines(area, true, insert_layer_idx - dtt_roof_tip).empty(); + roof_circle.points.emplace_back(p.first + corner * mesh_config.min_radius); + return !generateSupportInfillLines({ roof_circle }, mesh_config, true, insert_layer_idx - dtt_roof_tip, mesh_config.support_roof_line_distance).empty(); +#else + return true; +#endif }; - std::pair, std::vector> split = splitLines(lines, getEvaluatePointForNextLayerFunction(insert_layer_idx - dtt_roof_tip)); // keep all lines that are still valid on the next layer + std::pair split = + // keep all lines that are still valid on the next layer + splitLines(lines, [this, insert_layer_idx, dtt_roof_tip](std::pair &p){ return evaluatePointForNextLayerFunction(m_volumes, m_config, insert_layer_idx - dtt_roof_tip, p); }); for (LineInformation line : split.second) // add all points that would not be valid - { - for (std::pair point_data : line) - { + for (std::pair point_data : line) addPointAsInfluenceArea(point_data, 0, insert_layer_idx - dtt_roof_tip, roof_tip_layers - dtt_roof_tip, dtt_roof_tip != 0, false); - } - } // not all roofs are guaranteed to actually generate lines, so filter these out and add them as points split = splitLines(split.first, evaluateRoofWillGenerate); lines = split.first; for (LineInformation line : split.second) - { - for (std::pair point_data : line) - { + for (std::pair point_data : line) addPointAsInfluenceArea(point_data, 0, insert_layer_idx - dtt_roof_tip, roof_tip_layers - dtt_roof_tip, dtt_roof_tip != 0, false); - } - } // add all tips as roof to the roof storage Polygons added_roofs; for (LineInformation line : lines) - { - for (std::pair p : line) - { + for (std::pair p : line) { Polygon roof_circle; for (Point corner : base_circle) - { - roof_circle.add(p.first + corner * mesh_config.min_radius / base_radius); - } - added_roofs.add(roof_circle); + roof_circle.points.emplace_back(p.first + corner * mesh_config.min_radius / base_radius); + added_roofs.emplace_back(roof_circle); } - } - added_roofs = added_roofs.unionPolygons(); + added_roofs = union_(added_roofs); { std::lock_guard critical_section_storage(critical_sections); - - storage.support.supportLayers[insert_layer_idx - dtt_roof_tip].support_roof.add(added_roofs); +//FIXME store top support interface areas or maybe hatch them? +// append(storage.support.supportLayers[insert_layer_idx - dtt_roof_tip].support_roof, added_roofs); } } - for (LineInformation line : lines) - { + for (LineInformation line : lines) { bool disable_ovalistation = mesh_config.min_radius < 3 * mesh_config.support_line_width && roof_tip_layers == 0 && dtt_roof_tip == 0 && line.size() > 5; // If a line consists of enough tips, the assumption is that it is not a single tip, but part of a simulated support pattern. Ovalisation should be disabled for these to improve the quality of the lines when tip_diameter=line_width for (auto point_data : line) - { addPointAsInfluenceArea(point_data, 0, insert_layer_idx - dtt_roof_tip, dont_move_until > dtt_roof_tip ? dont_move_until - dtt_roof_tip : 0, dtt_roof_tip != 0 || supports_roof, disable_ovalistation); - } } }; - std::vector> overhang_processing; // every overhang has saved if a roof should be generated for it. This can NOT be done in the for loop as an area may NOT have a roof even if it is larger than the minimum_roof_area when it is only larger because of the support horizontal expansion and it would not have a roof if the overhang is offset by support roof horizontal expansion instead. (At least this is the current behavior of the regular support) - Polygons overhang_regular = safeOffsetInc(mesh.overhang_areas[layer_idx + z_distance_delta], support_outset, relevant_forbidden, mesh_config.min_radius * 1.75 + mesh_config.xy_min_distance, 0, 1); - Polygons remaining_overhang = mesh.overhang_areas[layer_idx + z_distance_delta].offset(support_outset).difference(overhang_regular.offset(mesh_config.support_line_width * 0.5)).intersection(relevant_forbidden); // offset ensures that areas that could be supported by a part of a support line, are not considered unsupported overhang + // every overhang has saved if a roof should be generated for it. This can NOT be done in the for loop as an area may NOT have a roof + // even if it is larger than the minimum_roof_area when it is only larger because of the support horizontal expansion and + // it would not have a roof if the overhang is offset by support roof horizontal expansion instead. (At least this is the current behavior of the regular support) + std::vector> overhang_processing; + Polygons overhang_raw = layer_overhangs(*print_object.get_layer(layer_idx + z_distance_delta)); + Polygons overhang_regular = safeOffsetInc(overhang_raw, mesh_group_settings.support_offset, relevant_forbidden, mesh_config.min_radius * 1.75 + mesh_config.xy_min_distance, 0, 1); + // offset ensures that areas that could be supported by a part of a support line, are not considered unsupported overhang + Polygons remaining_overhang = intersection(diff(offset(union_ex(overhang_raw), mesh_group_settings.support_offset), offset(union_ex(overhang_regular), mesh_config.support_line_width * 0.5)), relevant_forbidden); coord_t extra_total_offset_acc = 0; // Offset the area to compensate for large tip radiis. Offset happens in multiple steps to ensure the tip is as close to the original overhang as possible. while (extra_total_offset_acc + mesh_config.support_line_width / 8 < extra_outset) //+mesh_config.support_line_width / 80 to avoid calculating very small (useless) offsets because of rounding errors. { - coord_t offset_current_step = extra_total_offset_acc + 2 * mesh_config.support_line_width > mesh_config.min_radius ? std::min(mesh_config.support_line_width / 8, extra_outset - extra_total_offset_acc) : std::min(circle_length_to_half_linewidth_change, extra_outset - extra_total_offset_acc); + coord_t offset_current_step = extra_total_offset_acc + 2 * mesh_config.support_line_width > mesh_config.min_radius ? + std::min(mesh_config.support_line_width / 8, extra_outset - extra_total_offset_acc) : std::min(circle_length_to_half_linewidth_change, extra_outset - extra_total_offset_acc); extra_total_offset_acc += offset_current_step; - Polygons overhang_offset = safeOffsetInc(overhang_regular, 1.5 * extra_total_offset_acc, volumes_.getCollision(0, layer_idx, true), mesh_config.xy_min_distance + mesh_config.support_line_width, 0, 1); - remaining_overhang = remaining_overhang.difference(overhang_offset).unionPolygons(); - Polygons next_overhang = safeOffsetInc(remaining_overhang, extra_total_offset_acc, volumes_.getCollision(0, layer_idx, true), mesh_config.xy_min_distance + mesh_config.support_line_width, 0, 1); - overhang_regular = overhang_regular.unionPolygons(next_overhang.difference(relevant_forbidden)); + Polygons overhang_offset = safeOffsetInc(overhang_regular, 1.5 * extra_total_offset_acc, m_volumes.getCollision(0, layer_idx, true), mesh_config.xy_min_distance + mesh_config.support_line_width, 0, 1); + remaining_overhang = diff(remaining_overhang, overhang_offset); + Polygons next_overhang = safeOffsetInc(remaining_overhang, extra_total_offset_acc, m_volumes.getCollision(0, layer_idx, true), mesh_config.xy_min_distance + mesh_config.support_line_width, 0, 1); + overhang_regular = union_(overhang_regular, diff(next_overhang, relevant_forbidden)); } // If the xy distance overrides the z distance, some support needs to be inserted further down. //=> Analyze which support points do not fit on this layer and check if they will fit a few layers down (while adding them an infinite amount of layers down would technically be closer the the setting description, it would not produce reasonable results. ) - if (xy_overrides) + if (xy_overrides_z) { - std::vector overhang_lines; - Polygons polylines = ensureMaximumDistancePolyline(generateLines(remaining_overhang, false, layer_idx), mesh_config.min_radius, 1); // support_line_width to form a line here as otherwise most will be unsupported. Technically this violates branch distance, but not only is this the only reasonable choice, but it ensures consistent behavior as some infill patterns generate each line segment as its own polyline part causing a similar line forming behavior. Also it is assumed that the area that is valid a layer below is to small for support roof. - if (polylines.pointCount() <= 3) + LineInformations overhang_lines; { - // add the outer wall to ensure it is correct supported instead - polylines = ensureMaximumDistancePolyline(toPolylines(remaining_overhang), connect_length, 3); - } - - for (auto line : polylines) - { - LineInformation res_line; - for (Point p : line) - { - res_line.emplace_back(p, LineStatus::INVALID); + //Vojtech: Generate support heads at support_tree_branch_distance spacing by producing a zig-zag infill at support_tree_branch_distance spacing, + // which is then resmapled + // support_line_width to form a line here as otherwise most will be unsupported. Technically this violates branch distance, + // mbut not only is this the only reasonable choice, but it ensures consistent behavior as some infill patterns generate + // each line segment as its own polyline part causing a similar line forming behavior. Also it is assumed that + // the area that is valid a layer below is to small for support roof. + Polylines polylines = ensureMaximumDistancePolyline(generateLines(remaining_overhang, false, layer_idx), mesh_config.min_radius, 1); + if (polylines.size() <= 3) + // add the outer wall to ensure it is correct supported instead + polylines = ensureMaximumDistancePolyline(to_polylines(remaining_overhang), connect_length, 3); + for (const auto &line : polylines) { + LineInformation res_line; + for (Point p : line) + res_line.emplace_back(p, LineStatus::INVALID); + overhang_lines.emplace_back(res_line); } - overhang_lines.emplace_back(res_line); } - for (size_t lag_ctr = 1; lag_ctr <= max_overhang_insert_lag && !overhang_lines.empty() && layer_idx - coord_t(lag_ctr) >= 1; lag_ctr++) - { + for (size_t lag_ctr = 1; lag_ctr <= max_overhang_insert_lag && !overhang_lines.empty() && layer_idx - coord_t(lag_ctr) >= 1; lag_ctr++) { // get least restricted avoidance for layer_idx-lag_ctr - Polygons relevant_forbidden_below = (mesh_config.support_rests_on_model ? (only_gracious ? volumes_.getAvoidance(mesh_config.getRadius(0), layer_idx - lag_ctr, AvoidanceType::FAST, true, !xy_overrides) : volumes_.getCollision(mesh_config.getRadius(0), layer_idx - lag_ctr, !xy_overrides)) : volumes_.getAvoidance(mesh_config.getRadius(0), layer_idx - lag_ctr, AvoidanceType::FAST, false, !xy_overrides)); + Polygons relevant_forbidden_below = (mesh_config.support_rests_on_model ? (SUPPORT_TREE_ONLY_GRACIOUS_TO_MODEL ? m_volumes.getAvoidance(mesh_config.getRadius(0), layer_idx - lag_ctr, AvoidanceType::FAST, true, !xy_overrides_z) : m_volumes.getCollision(mesh_config.getRadius(0), layer_idx - lag_ctr, !xy_overrides_z)) : m_volumes.getAvoidance(mesh_config.getRadius(0), layer_idx - lag_ctr, AvoidanceType::FAST, false, !xy_overrides_z)); // it is not required to offset the forbidden area here as the points wont change: If points here are not inside the forbidden area neither will they be later when placing these points, as these are the same points. - std::function)> evaluatePoint = [&](std::pair p) { return relevant_forbidden_below.inside(p.first, true); }; + std::function)> evaluatePoint = [&](std::pair p) { return contains(relevant_forbidden_below, p.first); }; - std::pair, std::vector> split = splitLines(overhang_lines, evaluatePoint); // keep all lines that are invalid + std::pair split = splitLines(overhang_lines, evaluatePoint); // keep all lines that are invalid overhang_lines = split.first; - std::vector fresh_valid_points = convertLinesToInternal(convertInternalToLines(split.second), layer_idx - lag_ctr); // set all now valid lines to their correct LineStatus. Easiest way is to just discard Avoidance information for each point and evaluate them again. + LineInformations fresh_valid_points = convertLinesToInternal(m_volumes, m_config, convertInternalToLines(split.second), layer_idx - lag_ctr); // set all now valid lines to their correct LineStatus. Easiest way is to just discard Avoidance information for each point and evaluate them again. addLinesAsInfluenceAreas(fresh_valid_points, (force_tip_to_roof && lag_ctr <= support_roof_layers) ? support_roof_layers : 0, layer_idx - lag_ctr, false, roof_enabled ? support_roof_layers : 0); } } Polygons overhang_roofs; - if (roof_enabled) - { - overhang_roofs = safeOffsetInc(mesh.overhang_areas[layer_idx + z_distance_delta], roof_outset, relevant_forbidden, mesh_config.min_radius * 2 + mesh_config.xy_min_distance, 0, 1); - overhang_roofs.removeSmallAreas(minimum_roof_area); - overhang_regular = overhang_regular.difference(overhang_roofs); - for (Polygons roof_part : overhang_roofs.splitIntoParts(true)) - { - overhang_processing.emplace_back(roof_part, true); - } + if (roof_enabled) { + static constexpr const coord_t support_roof_offset = 0; + overhang_roofs = safeOffsetInc(layer_overhangs(*print_object.get_layer(layer_idx + z_distance_delta)), support_roof_offset, relevant_forbidden, mesh_config.min_radius * 2 + mesh_config.xy_min_distance, 0, 1); + remove_small(overhang_roofs, mesh_group_settings.minimum_roof_area); + overhang_regular = diff(overhang_regular, overhang_roofs); + for (ExPolygon &roof_part : union_ex(overhang_roofs)) + overhang_processing.emplace_back(std::move(roof_part), true); } - overhang_regular.removeSmallAreas(minimum_support_area); + remove_small(overhang_regular, mesh_group_settings.minimum_support_area); - for (Polygons support_part : overhang_regular.splitIntoParts(true)) - { - overhang_processing.emplace_back(support_part, false); - } + for (ExPolygon &support_part : union_ex(overhang_regular)) + overhang_processing.emplace_back(std::move(support_part), false); - for (std::pair overhang_pair : overhang_processing) + for (const std::pair &overhang_pair : overhang_processing) { const bool roof_allowed_for_this_part = overhang_pair.second; - Polygons overhang_outset = overhang_pair.first; - const size_t min_support_points = std::max(coord_t(1), std::min(coord_t(3), overhang_outset.polygonLength() / connect_length)); - std::vector overhang_lines; + Polygons overhang_outset = to_polygons(overhang_pair.first); + const size_t min_support_points = std::max(coord_t(1), std::min(coord_t(3), coord_t(total_length(overhang_outset) / connect_length))); + LineInformations overhang_lines; Polygons last_overhang = overhang_outset; size_t dtt_roof = 0; std::vector added_roofs(support_roof_layers); // sometimes roofs could be empty as the pattern does not generate lines if the area is narrow enough (i am looking at you, concentric infill). To catch these cases the added roofs are saved to be evaluated later. @@ -908,21 +984,21 @@ void TreeSupport::generateInitialAreas(const SliceMeshStorage& mesh, std::vector // Main problem is that some patterns change each layer, so just calculating points and checking if they are still valid an layer below is not useful, as the pattern may be different one layer below. // Same with calculating which points are now no longer being generated as result from a decreasing roof, as there is no guarantee that a line will be above these points. // Implementing a separate roof support behavior for each pattern harms maintainability as it very well could be >100 LOC - if (roof_allowed_for_this_part) - { - for (dtt_roof = 0; dtt_roof < support_roof_layers && layer_idx - dtt_roof >= 1; dtt_roof++) - { + if (roof_allowed_for_this_part) { + for (dtt_roof = 0; dtt_roof < support_roof_layers && layer_idx - dtt_roof >= 1; dtt_roof++) { // here the roof is handled. If roof can not be added the branches will try to not move instead - Polygons forbidden_next = (mesh_config.support_rests_on_model ? (only_gracious ? volumes_.getAvoidance(mesh_config.getRadius(0), layer_idx - (dtt_roof + 1), AvoidanceType::FAST, true, !xy_overrides) : volumes_.getCollision(mesh_config.getRadius(0), layer_idx - (dtt_roof + 1), !xy_overrides)) : volumes_.getAvoidance(mesh_config.getRadius(0), layer_idx - (dtt_roof + 1), AvoidanceType::FAST, false, !xy_overrides)); - forbidden_next = forbidden_next.offset(5); // prevent rounding errors down the line - Polygons overhang_outset_next = overhang_outset.difference(forbidden_next); - if (overhang_outset_next.area() / (1000 * 1000) < minimum_roof_area) // next layer down the roof area would be to small so we have to insert our roof support here. Also convert squaremicrons to squaremilimeter - { + Polygons forbidden_next = (mesh_config.support_rests_on_model ? (SUPPORT_TREE_ONLY_GRACIOUS_TO_MODEL ? m_volumes.getAvoidance(mesh_config.getRadius(0), layer_idx - (dtt_roof + 1), AvoidanceType::FAST, true, !xy_overrides_z) : m_volumes.getCollision(mesh_config.getRadius(0), layer_idx - (dtt_roof + 1), !xy_overrides_z)) : m_volumes.getAvoidance(mesh_config.getRadius(0), layer_idx - (dtt_roof + 1), AvoidanceType::FAST, false, !xy_overrides_z));\ + // prevent rounding errors down the line + forbidden_next = offset(union_ex(forbidden_next), scaled(0.005)); + Polygons overhang_outset_next = diff(overhang_outset, forbidden_next); + if (area(overhang_outset_next) < mesh_group_settings.minimum_roof_area) { + // next layer down the roof area would be to small so we have to insert our roof support here. Also convert squaremicrons to squaremilimeter size_t dtt_before = dtt_roof > 0 ? dtt_roof - 1 : 0; - if (dtt_roof != 0) - { - overhang_lines = convertLinesToInternal(ensureMaximumDistancePolyline(generateLines(last_overhang, true, layer_idx - dtt_before), connect_length, 1), layer_idx - dtt_before); - overhang_lines = splitLines(overhang_lines, getEvaluatePointForNextLayerFunction(layer_idx - dtt_before)).first; + if (dtt_roof != 0) { + // Produce support head points supporting an interface layer: First produce the interface lines, then sample them. + overhang_lines = convertLinesToInternal(m_volumes, m_config, ensureMaximumDistancePolyline(generateLines(last_overhang, true, layer_idx - dtt_before), connect_length, 1), layer_idx - dtt_before); + overhang_lines = splitLines(overhang_lines, + [this, layer_idx, dtt_before](std::pair &p){ return evaluatePointForNextLayerFunction(m_volumes, m_config, layer_idx - dtt_before, p); }).first; } break; @@ -934,135 +1010,190 @@ void TreeSupport::generateInitialAreas(const SliceMeshStorage& mesh, std::vector } size_t layer_generation_dtt = std::max(dtt_roof, size_t(1)) - 1; // 1 inside max and -1 outside to avoid underflow. layer_generation_dtt=dtt_roof-1 if dtt_roof!=0; - if (overhang_lines.empty() && dtt_roof != 0 && generateLines(overhang_outset, true, layer_idx - layer_generation_dtt).empty()) // if the roof should be valid, check that the area does generate lines. This is NOT guaranteed. - { - for (size_t idx = 0; idx < dtt_roof; idx++) - { + // if the roof should be valid, check that the area does generate lines. This is NOT guaranteed. + if (overhang_lines.empty() && dtt_roof != 0 && generateLines(overhang_outset, true, layer_idx - layer_generation_dtt).empty()) + for (size_t idx = 0; idx < dtt_roof; idx++) { // check for every roof area that it has resulting lines. Remember idx 1 means the 2. layer of roof => higher idx == lower layer - if (generateLines(added_roofs[idx], true, layer_idx - idx).empty()) - { + if (generateLines(added_roofs[idx], true, layer_idx - idx).empty()) { dtt_roof = idx; layer_generation_dtt = std::max(dtt_roof, size_t(1)) - 1; break; } } - } { std::lock_guard critical_section_storage(critical_sections); - for (size_t idx = 0; idx < dtt_roof; idx++) - { - storage.support.supportLayers[layer_idx - idx].support_roof.add(added_roofs[idx]); // will be unioned in finalizeInterfaceAndSupportAreas - } +//FIXME store support areas or hatch the lines? +// for (size_t idx = 0; idx < dtt_roof; idx++) +// append(storage.support.supportLayers[layer_idx - idx].support_roof, added_roofs[idx]); // will be unioned in finalizeInterfaceAndSupportAreas } - if (overhang_lines.empty()) - { - Polygons polylines = ensureMaximumDistancePolyline(generateLines(overhang_outset, dtt_roof != 0, layer_idx - layer_generation_dtt), dtt_roof == 0 ? mesh_config.min_radius / 2 : connect_length, 1); // support_line_width to form a line here as otherwise most will be unsupported. Technically this violates branch distance, but not only is this the only reasonable choice, but it ensures consistant behaviour as some infill patterns generate each line segment as its own polyline part causing a similar line forming behaviour. This is not doen when a roof is above as the roof will support the model and the trees only need to support the roof - - - if (polylines.pointCount() <= min_support_points) - { + if (overhang_lines.empty()) { + // support_line_width to form a line here as otherwise most will be unsupported. Technically this violates branch distance, but not only is this the only reasonable choice, + // but it ensures consistant behaviour as some infill patterns generate each line segment as its own polyline part causing a similar line forming behaviour. + // This is not doen when a roof is above as the roof will support the model and the trees only need to support the roof + Polylines polylines = ensureMaximumDistancePolyline(generateLines(overhang_outset, dtt_roof != 0, layer_idx - layer_generation_dtt), dtt_roof == 0 ? mesh_config.min_radius / 2 : connect_length, 1); + size_t point_count = 0; + for (const Polyline &poly : polylines) + point_count += poly.size(); + if (point_count <= min_support_points) { // add the outer wall (of the overhang) to ensure it is correct supported instead. Try placing the support points in a way that they fully support the outer wall, instead of just the with half of the the support line width. - Polygons reduced_overhang_outset = overhang_outset.offset(-mesh_config.support_line_width / 2.2); // I assume that even small overhangs are over one line width wide, so lets try to place the support points in a way that the full support area generated from them will support the overhang (if this is not done it may only be half). This WILL NOT be the case when supporting an angle of about < 60� so there is a fallback, as some support is better than none. - if (!reduced_overhang_outset.empty() && overhang_outset.difference(reduced_overhang_outset.offset(std::max(mesh_config.support_line_width, connect_length))).area() < 1) - { - polylines = ensureMaximumDistancePolyline(toPolylines(reduced_overhang_outset), connect_length, min_support_points); - } - else - { - polylines = ensureMaximumDistancePolyline(toPolylines(overhang_outset), connect_length, min_support_points); - } + // I assume that even small overhangs are over one line width wide, so lets try to place the support points in a way that the full support area generated from them + // will support the overhang (if this is not done it may only be half). This WILL NOT be the case when supporting an angle of about < 60� so there is a fallback, + // as some support is better than none. + Polygons reduced_overhang_outset = offset(union_ex(overhang_outset), -mesh_config.support_line_width / 2.2); + polylines = ensureMaximumDistancePolyline( + to_polylines(!reduced_overhang_outset.empty() && area(offset(diff_ex(overhang_outset, reduced_overhang_outset), std::max(mesh_config.support_line_width, connect_length))) < 1 ? + reduced_overhang_outset : + overhang_outset), + connect_length, min_support_points); } LayerIndex last_insert_layer = layer_idx - dtt_roof; - overhang_lines = convertLinesToInternal(polylines, last_insert_layer); + overhang_lines = convertLinesToInternal(m_volumes, m_config, polylines, last_insert_layer); } - if (int(dtt_roof) >= layer_idx && roof_allowed_for_this_part) // reached buildplate - { - { - std::lock_guard critical_section_storage(critical_sections); - storage.support.supportLayers[0].support_roof.add(overhang_outset); - } - } - else // normal trees have to be generated - { + if (int(dtt_roof) >= layer_idx && roof_allowed_for_this_part) { // reached buildplate + std::lock_guard critical_section_storage(critical_sections); +//FIXME store support roofs +// append(storage.support.supportLayers[0].support_roof, overhang_outset); + } else // normal trees have to be generated addLinesAsInfluenceAreas(overhang_lines, force_tip_to_roof ? support_roof_layers - dtt_roof : 0, layer_idx - dtt_roof, dtt_roof > 0, roof_enabled ? support_roof_layers - dtt_roof : 0); - } } } }); - - delete cross_fill_provider; } -Polygons TreeSupport::safeOffsetInc(const Polygons& me, coord_t distance, const Polygons& collision, coord_t safe_step_size, coord_t last_step_offset_without_check, size_t min_amount_offset) const +static unsigned int moveInside(const Polygons &polygons, Point &from, int distance = 0, int64_t maxDist2 = std::numeric_limits::max()) { - bool do_final_difference = last_step_offset_without_check == 0; - Polygons ret = safeUnion(me); // ensure sane input - if (distance == 0) - { - return (do_final_difference ? ret.difference(collision) : ret).unionPolygons(); - } - if (safe_step_size < 0 || last_step_offset_without_check < 0) - { - logError("Offset increase got invalid parameter!\n"); - TreeSupport::showError("Negative offset distance... How did you manage this ?", true); - return (do_final_difference ? ret.difference(collision) : ret).unionPolygons(); - } + Point ret = from; + double bestDist2 = std::numeric_limits::max(); + auto bestPoly = static_cast(-1); + bool is_already_on_correct_side_of_boundary = false; // whether [from] is already on the right side of the boundary + for (unsigned int poly_idx = 0; poly_idx < polygons.size(); ++ poly_idx) { + const Polygon &poly = polygons[poly_idx]; + if (poly.size() < 2) + continue; + Point p0 = poly[poly.size() - 2]; + Point p1 = poly.back(); + // because we compare with vSize2 here (no division by zero), we also need to compare by vSize2 inside the loop + // to avoid integer rounding edge cases + bool projected_p_beyond_prev_segment = (p1 - p0).cast().dot((from - p0).cast()) >= (p1 - p0).cast().squaredNorm(); + for (const Point& p2 : poly) { + // X = A + Normal(B-A) * (((B-A) dot (P-A)) / VSize(B-A)); + // = A + (B-A) * ((B-A) dot (P-A)) / VSize2(B-A); + // X = P projected on AB + const Point& a = p1; + const Point& b = p2; + const Point& p = from; + auto ab = (b - a).cast(); + auto ap = (p - a).cast(); + int64_t ab_length2 = ab.squaredNorm(); + if (ab_length2 <= 0) { //A = B, i.e. the input polygon had two adjacent points on top of each other. + p1 = p2; //Skip only one of the points. + continue; + } + int64_t dot_prod = ab.dot(ap); + if (dot_prod <= 0) { // x is projected to before ab + if (projected_p_beyond_prev_segment) { + // case which looks like: > . + projected_p_beyond_prev_segment = false; + Point& x = p1; - coord_t step_size = safe_step_size; - size_t steps = distance > last_step_offset_without_check ? (distance - last_step_offset_without_check) / step_size : 0; - if (distance - steps * step_size > last_step_offset_without_check) - { - if ((steps + 1) * step_size <= distance) - { - steps++; // This will be the case when last_step_offset_without_check >= safe_step_size - } - else - { - do_final_difference = true; + auto dist2 = (x - p).cast().squaredNorm(); + if (dist2 < bestDist2) { + bestDist2 = dist2; + bestPoly = poly_idx; + if (distance == 0) + ret = x; + else { + Vec2d abd = ab.cast(); + Vec2d p1p2 = p1 - p0; + double lab = abd.norm(); + double lp1p2 = p1p2.norm(); + // inward direction irrespective of sign of [distance] + auto inward_dir = perp(abd * (scaled(10.0) / lab) + p1p2 * (scaled(10.0) / lp1p2)); + // MM2INT(10.0) to retain precision for the eventual normalization + ret = x + (inward_dir * (distance / inward_dir.norm())).cast(); + is_already_on_correct_side_of_boundary = inward_dir.dot((p - x).cast()) * distance >= 0; + } + } + } else { + projected_p_beyond_prev_segment = false; + p0 = p1; + p1 = p2; + continue; + } + } else if (dot_prod >= ab_length2) { + // x is projected to beyond ab + projected_p_beyond_prev_segment = true; + p0 = p1; + p1 = p2; + continue; + } else { + // x is projected to a point properly on the line segment (not onto a vertex). The case which looks like | . + projected_p_beyond_prev_segment = false; + Point x = a + (ab.cast() * (double(dot_prod) / double(ab_length2))).cast(); + auto dist2 = (p - x).cast().squaredNorm(); + if (dist2 < bestDist2) { + bestDist2 = dist2; + bestPoly = poly_idx; + if (distance == 0) + ret = x; + else { + Vec2d abd = ab.cast(); + Vec2d inward_dir = perp(abd * (distance / abd.norm())); // inward or outward depending on the sign of [distance] + ret = x + inward_dir.cast(); + is_already_on_correct_side_of_boundary = inward_dir.dot((p - x).cast()) >= 0; + } + } + } + p0 = p1; + p1 = p2; } } - if (steps + (distance < last_step_offset_without_check || distance % step_size != 0) < min_amount_offset && min_amount_offset > 1) // yes one can add a bool as the standard specifies that a result from compare operators has to be 0 or 1 - { - // reduce the stepsize to ensure it is offset the required amount of times - step_size = distance / min_amount_offset; - if (step_size >= safe_step_size) - { - // effectivly reduce last_step_offset_without_check - step_size = safe_step_size; - steps = min_amount_offset; - } - else - { - steps = distance / step_size; + // when the best point is already inside and we're moving inside, or when the best point is already outside and we're moving outside + if (is_already_on_correct_side_of_boundary) { + if (bestDist2 < distance * distance) + from = ret; + else { + // from = from; // original point stays unaltered. It is already inside by enough distance } + return bestPoly; + } else if (bestDist2 < maxDist2) { + from = ret; + return bestPoly; } - // offset in steps - for (size_t i = 0; i < steps; i++) - { - ret = ret.offset(step_size, ClipperLib::jtRound).difference(collision).unionPolygons(); - // ensure that if many offsets are done the performance does not suffer extremely by the new vertices of jtRound. - if (i % 10 == 7) - { - ret.simplify(15); - } - } - ret = ret.offset(distance - steps * step_size, ClipperLib::jtRound); // offset the remainder - - ret.simplify(15); - - if (do_final_difference) - { - ret = ret.difference(collision); - } - return ret.unionPolygons(); + return -1; } - -void TreeSupport::mergeHelper(std::map& reduced_aabb, std::map& input_aabb, const std::unordered_map& to_bp_areas, const std::unordered_map& to_model_areas, const std::map& influence_areas, std::unordered_map& insert_bp_areas, std::unordered_map& insert_model_areas, std::unordered_map& insert_influence, std::vector& erase, const LayerIndex layer_idx) +/*! + * \brief Merges Influence Areas if possible. + * + * Branches which do overlap have to be merged. This helper merges all elements in input with the elements into reduced_new_layer. + * Elements in input_aabb are merged together if possible, while elements reduced_new_layer_aabb are not checked against each other. + * + * \param reduced_aabb[in,out] The already processed elements. + * \param input_aabb[in] Not yet processed elements + * \param to_bp_areas[in] The Elements of the current Layer that will reach the buildplate. Value is the influence area where the center of a circle of support may be placed. + * \param to_model_areas[in] The Elements of the current Layer that do not have to reach the buildplate. Also contains main as every element that can reach the buildplate is not forced to. + * Value is the influence area where the center of a circle of support may be placed. + * \param influence_areas[in] The influence areas without avoidance removed. + * \param insert_bp_areas[out] Elements to be inserted into the main dictionary after the Helper terminates. + * \param insert_model_areas[out] Elements to be inserted into the secondary dictionary after the Helper terminates. + * \param insert_influence[out] Elements to be inserted into the dictionary containing the largest possibly valid influence area (ignoring if the area may not be there because of avoidance) + * \param erase[out] Elements that should be deleted from the above dictionaries. + * \param layer_idx[in] The Index of the current Layer. + */ +static void mergeHelper( + const TreeModelVolumes &volumes, const TreeSupport::TreeSupportSettings &config, + std::map& reduced_aabb, std::map& input_aabb, + const std::unordered_map& to_bp_areas, const std::unordered_map& to_model_areas, + const std::map& influence_areas, + std::unordered_map& insert_bp_areas, std::unordered_map& insert_model_areas, + std::unordered_map& insert_influence, std::vector& erase, const LayerIndex layer_idx) { + using SupportElement = TreeSupport::SupportElement; + const bool first_merge_iteration = reduced_aabb.empty(); // If this is the first iteration, all elements in input have to be merged with each other for (std::map::iterator influence_iter = input_aabb.begin(); influence_iter != input_aabb.end(); influence_iter++) { @@ -1073,12 +1204,9 @@ void TreeSupport::mergeHelper(std::map& reduced_aab // As every area has to be checked for overlaps with other areas, some fast heuristic is needed to abort early if clearly possible // This is so performance critical that using a map lookup instead of the direct access of the cached AABBs can have a surprisingly large performance impact BoundingBox aabb = reduced_check_iter->second; - if (aabb.hit(influence_aabb)) - { + if (aabb.overlap(influence_aabb)) { if (!first_merge_iteration && input_aabb.count(reduced_check_iter->first)) - { break; // Do not try to merge elements that already should have been merged. Done for potential performance improvement. - } bool merging_gracious_and_non_gracious = reduced_check_iter->first.to_model_gracious != influence_iter->first.to_model_gracious; // we do not want to merge a gracious with a non gracious area as bad placement could negatively impact the dependability of the whole subtree bool merging_to_bp = reduced_check_iter->first.to_buildplate && influence_iter->first.to_buildplate; @@ -1086,25 +1214,16 @@ void TreeSupport::mergeHelper(std::map& reduced_aab coord_t increased_to_model_radius = 0; size_t larger_to_model_dtt = 0; - if (!merging_to_bp) - { + if (!merging_to_bp) { coord_t infl_radius = config.getRadius(influence_iter->first); // get the real radius increase as the user does not care for the collision model. coord_t redu_radius = config.getRadius(reduced_check_iter->first); - if (reduced_check_iter->first.to_buildplate != influence_iter->first.to_buildplate) - { - if (reduced_check_iter->first.to_buildplate) - { + if (reduced_check_iter->first.to_buildplate != influence_iter->first.to_buildplate) { + if (reduced_check_iter->first.to_buildplate) { if (infl_radius < redu_radius) - { increased_to_model_radius = influence_iter->first.increased_to_model_radius + redu_radius - infl_radius; - } - } - else - { + } else { if (infl_radius > redu_radius) - { increased_to_model_radius = reduced_check_iter->first.increased_to_model_radius + infl_radius - redu_radius; - } } } larger_to_model_dtt = std::max(influence_iter->first.distance_to_top, reduced_check_iter->first.distance_to_top); @@ -1112,20 +1231,14 @@ void TreeSupport::mergeHelper(std::map& reduced_aab // if a merge could place a stable branch on unstable ground, would be increasing the radius further than allowed to when merging to model and to_bp trees or would merge to model before it is known they will even been drawn the merge is skipped if (merging_min_and_regular_xy || merging_gracious_and_non_gracious || increased_to_model_radius > config.max_to_model_radius_increase || (!merging_to_bp && larger_to_model_dtt < config.min_dtt_to_model && !reduced_check_iter->first.supports_roof && !influence_iter->first.supports_roof)) - { continue; - } Polygons relevant_infl; Polygons relevant_redu; - - if (merging_to_bp) - { + if (merging_to_bp) { relevant_infl = to_bp_areas.count(influence_iter->first) ? to_bp_areas.at(influence_iter->first) : Polygons(); // influence_iter->first is a new element => not required to check if it was changed relevant_redu = insert_bp_areas.count(reduced_check_iter->first) ? insert_bp_areas[reduced_check_iter->first] : (to_bp_areas.count(reduced_check_iter->first) ? to_bp_areas.at(reduced_check_iter->first) : Polygons()); - } - else - { + } else { relevant_infl = to_model_areas.count(influence_iter->first) ? to_model_areas.at(influence_iter->first) : Polygons(); relevant_redu = insert_model_areas.count(reduced_check_iter->first) ? insert_model_areas[reduced_check_iter->first] : (to_model_areas.count(reduced_check_iter->first) ? to_model_areas.at(reduced_check_iter->first) : Polygons()); } @@ -1138,9 +1251,7 @@ void TreeSupport::mergeHelper(std::map& reduced_aab // the area of the bigger radius is used to ensure correct placement regarding the relevant avoidance, so if that would change an invalid area may be created if (!bigger_rad.first.can_use_safe_radius && smaller_rad.first.can_use_safe_radius) - { continue; - } // the bigger radius is used to verify that the area is still valid after the increase with the delta. If there were a point where the big influence area could be valid with can_use_safe_radius the element would already be can_use_safe_radius // the smaller radius, which gets increased by delta may reach into the area where use_min_xy_dist is no longer required. @@ -1150,15 +1261,12 @@ void TreeSupport::mergeHelper(std::map& reduced_aab // If this area has any intersections with the influence area of the larger collision radius, a branch (of the larger collision radius) placed in this intersection, has already engulfed the branch of the smaller collision radius. // Because of this a merge may happen even if the influence areas (that represent possible center points of branches) do not intersect yet. // Remember that collision radius <= real radius as otherwise this assumption would be false. - Polygons small_rad_increased_by_big_minus_small = safeOffsetInc(smaller_rad.second, real_radius_delta, volumes_.getCollision(smaller_collision_radius, layer_idx - 1, use_min_radius), 2 * (config.xy_distance + smaller_collision_radius - 3), 0, 0); // -3 avoids possible rounding errors - Polygons intersect = small_rad_increased_by_big_minus_small.intersection(bigger_rad.second); + Polygons small_rad_increased_by_big_minus_small = safeOffsetInc(smaller_rad.second, real_radius_delta, volumes.getCollision(smaller_collision_radius, layer_idx - 1, use_min_radius), 2 * (config.xy_distance + smaller_collision_radius - 3), 0, 0); // -3 avoids possible rounding errors + Polygons intersect = intersection(small_rad_increased_by_big_minus_small, bigger_rad.second); - if (intersect.area() > 1) // dont use empty as a line is not empty, but for this use-case it very well may be (and would be one layer down as union does not keep lines) - { - if (intersect.offset(-25).area() <= 1) // check if the overlap is large enough (Small ares tend to attract rounding errors in clipper). While 25 was guessed as enough, i did not have reason to change it. - { + if (area(intersect) > tiny_area_threshold) { // dont use empty as a line is not empty, but for this use-case it very well may be (and would be one layer down as union does not keep lines) + if (area(offset(intersect, scaled(-0.025))) <= tiny_area_threshold) // check if the overlap is large enough (Small ares tend to attract rounding errors in clipper). While 25 was guessed as enough, i did not have reason to change it. continue; - } // Do the actual merge now that the branches are confirmed to be able to intersect. @@ -1166,40 +1274,31 @@ void TreeSupport::mergeHelper(std::map& reduced_aab // used at the end to estimate where to best place the branch on the bottom most layer // could be replaced with a random point inside the new area Point new_pos = reduced_check_iter->first.next_position; - if (!intersect.inside(new_pos, true)) - { - PolygonUtils::moveInside(intersect, new_pos); - } + if (! contains(intersect, new_pos)) + moveInside(intersect, new_pos); if (increased_to_model_radius == 0) - { increased_to_model_radius = std::max(reduced_check_iter->first.increased_to_model_radius, influence_iter->first.increased_to_model_radius); - } SupportElement key(reduced_check_iter->first, influence_iter->first, layer_idx - 1, new_pos, increased_to_model_radius, config); Polygons intersect_influence; Polygons infl_small = insert_influence.count(smaller_rad.first) ? insert_influence[smaller_rad.first] : (influence_areas.count(smaller_rad.first) ? influence_areas.at(smaller_rad.first) : Polygons()); Polygons infl_big = insert_influence.count(bigger_rad.first) ? insert_influence[bigger_rad.first] : (influence_areas.count(bigger_rad.first) ? influence_areas.at(bigger_rad.first) : Polygons()); - Polygons small_rad_increased_by_big_minus_small_infl = safeOffsetInc(infl_small, real_radius_delta, volumes_.getCollision(smaller_collision_radius, layer_idx - 1, use_min_radius), 2 * (config.xy_distance + smaller_collision_radius - 3), 0, 0); - intersect_influence = small_rad_increased_by_big_minus_small_infl.intersection(infl_big); // if the one with the bigger radius with the lower radius removed overlaps we can merge + Polygons small_rad_increased_by_big_minus_small_infl = safeOffsetInc(infl_small, real_radius_delta, volumes.getCollision(smaller_collision_radius, layer_idx - 1, use_min_radius), 2 * (config.xy_distance + smaller_collision_radius - 3), 0, 0); + intersect_influence = intersection(small_rad_increased_by_big_minus_small_infl, infl_big); // if the one with the bigger radius with the lower radius removed overlaps we can merge intersect_influence = safeUnion(intersect_influence, intersect); // Rounding errors again. Do not ask me where or why. Polygons intersect_sec; - if (merging_to_bp && config.support_rests_on_model) - { - if (key.to_model_gracious) - { + if (merging_to_bp && config.support_rests_on_model) { + if (key.to_model_gracious) { Polygons sec_small = insert_model_areas.count(smaller_rad.first) ? insert_model_areas[smaller_rad.first] : (to_model_areas.count(smaller_rad.first) ? to_model_areas.at(smaller_rad.first) : Polygons()); Polygons sec_big = insert_model_areas.count(bigger_rad.first) ? insert_model_areas[bigger_rad.first] : (to_model_areas.count(bigger_rad.first) ? to_model_areas.at(bigger_rad.first) : Polygons()); - Polygons small_rad_increased_by_big_minus_small_sec = safeOffsetInc(sec_small, real_radius_delta, volumes_.getCollision(smaller_collision_radius, layer_idx - 1, use_min_radius), 2 * (config.xy_distance + smaller_collision_radius - 3), 0, 0); - intersect_sec = small_rad_increased_by_big_minus_small_sec.intersection(sec_big); // if the one with the bigger radius with the lower radius removed overlaps we can merge + Polygons small_rad_increased_by_big_minus_small_sec = safeOffsetInc(sec_small, real_radius_delta, volumes.getCollision(smaller_collision_radius, layer_idx - 1, use_min_radius), 2 * (config.xy_distance + smaller_collision_radius - 3), 0, 0); + intersect_sec = intersection(small_rad_increased_by_big_minus_small_sec, sec_big); // if the one with the bigger radius with the lower radius removed overlaps we can merge intersect_influence = safeUnion(intersect_influence, intersect_sec); // still rounding errors - } - else - { + } else intersect_sec = intersect_influence; - } } // remove the now merged elements from all buckets, as they do not exist anymore in their old form @@ -1212,17 +1311,15 @@ void TreeSupport::mergeHelper(std::map& reduced_aab (merging_to_bp ? insert_bp_areas : insert_model_areas).emplace(key, intersect); if (merging_to_bp && config.support_rests_on_model) - { insert_model_areas.emplace(key, intersect_sec); - } insert_influence.emplace(key, intersect_influence); erase.emplace_back(reduced_check_iter->first); erase.emplace_back(influence_iter->first); - Polygons merge = intersect.unionPolygons(intersect_sec).offset(config.getRadius(key), ClipperLib::jtRound).difference(volumes_.getCollision(0, layer_idx - 1)); // regular union should be preferable here as Polygons tend to only become smaller through rounding errors (smaller!=has smaller area as holes have a negative area.). And if this area disappears because of rounding errors, the only downside is that it can not merge again on this layer. + Polygons merge = diff(offset(union_(intersect, intersect_sec), config.getRadius(key), ClipperLib::jtRound), volumes.getCollision(0, layer_idx - 1)); // regular union should be preferable here as Polygons tend to only become smaller through rounding errors (smaller!=has smaller area as holes have a negative area.). And if this area disappears because of rounding errors, the only downside is that it can not merge again on this layer. reduced_aabb.erase(reduced_check_iter->first); // this invalidates reduced_check_iter - reduced_aabb.emplace(key, BoundingBox(merge)); + reduced_aabb.emplace(key, get_extents(merge)); merged = true; break; @@ -1231,15 +1328,28 @@ void TreeSupport::mergeHelper(std::map& reduced_aab } if (!merged) - { reduced_aabb[influence_iter->first] = influence_aabb; - } } } - -void TreeSupport::mergeInfluenceAreas(std::unordered_map& to_bp_areas, std::unordered_map& to_model_areas, std::map& influence_areas, LayerIndex layer_idx) +/*! + * \brief Merges Influence Areas if possible. + * + * Branches which do overlap have to be merged. This manages the helper and uses a divide and conquer approach to parallelize this problem. This parallelization can at most accelerate the merging by a factor of 2. + * + * \param to_bp_areas[in] The Elements of the current Layer that will reach the buildplate. + * Value is the influence area where the center of a circle of support may be placed. + * \param to_model_areas[in] The Elements of the current Layer that do not have to reach the buildplate. Also contains main as every element that can reach the buildplate is not forced to. + * Value is the influence area where the center of a circle of support may be placed. + * \param influence_areas[in] The Elements of the current Layer without avoidances removed. This is the largest possible influence area for this layer. + * Value is the influence area where the center of a circle of support may be placed. + * \param layer_idx[in] The current layer. + */ +static void mergeInfluenceAreas( + const TreeModelVolumes &volumes, const TreeSupport::TreeSupportSettings &config, + std::unordered_map& to_bp_areas, std::unordered_map& to_model_areas, std::map& influence_areas, LayerIndex layer_idx) { + using SupportElement = TreeSupport::SupportElement; /* * Idea behind this is that the calculation of merges can be accelerated a bit using divide and conquer: * If two groups of areas are already merged, only all elements in group 2 have to be merged into group one. @@ -1247,14 +1357,11 @@ void TreeSupport::mergeInfluenceAreas(std::unordered_map> buckets_area(2 * bucket_count); std::vector> buckets_aabb(2 * bucket_count); - size_t position = 0, counter = 0; const size_t over_elements = input_size % bucket_count; const size_t elements_per_step = input_size / bucket_count; // split the data in x parts to be able to divide and conquer // the first "over_elements" of buckets gets elements_per_step+1 elements - for (std::map::iterator iter = influence_areas.begin(); iter != influence_areas.end(); iter++) - { + for (std::map::iterator iter = influence_areas.begin(); iter != influence_areas.end(); ++ iter) { buckets_area[position * 2 + 1].emplace(iter->first, iter->second); // only use every second bucket beginning with 1 as this makes the parallel call later easier as we assume everything in a bucket i%2==0 is already processed - counter++; - if ((counter == elements_per_step && position >= over_elements) || counter > elements_per_step) - { + ++ counter; + if ((counter == elements_per_step && position >= over_elements) || counter > elements_per_step) { position++; counter = 0; } } // precalculate the AABBs from the influence areas. - tbb::parallel_for(tbb::blocked_range(0, bucket_count), [&](const tbb::blocked_range &range) { for (size_t idx = range.begin(); idx < range.end(); ++ idx) { - { // +=2 as in the beginning only uneven buckets will be filled size_t bucket_idx = 2 * idx + 1; for (const std::pair& input_pair : buckets_area[bucket_idx]) - { - BoundingBox outer_support_wall_aabb = BoundingBox(input_pair.second); - outer_support_wall_aabb.expand(config.getRadius(input_pair.first)); - buckets_aabb[bucket_idx].emplace(input_pair.first, outer_support_wall_aabb); - } + buckets_aabb[bucket_idx].emplace(input_pair.first, get_extents(input_pair.second).inflated(config.getRadius(input_pair.first))); } }); - while (buckets_area.size() > 1) - { + while (buckets_area.size() > 1) { // Some temporary storage, of elements that have to be inserted or removed from the background storage. Only one per two buckets required std::vector> insert_main(buckets_area.size() / 2); std::vector> insert_secondary(buckets_area.size() / 2); std::vector> insert_influence(buckets_area.size() / 2); std::vector> erase(buckets_area.size() / 2); - tbb::parallel_for(tbb::blocked_range(0, buckets_area.size() / 2), [&](const tbb::blocked_range &range) { for (size_t idx = range.begin(); idx < range.end(); ++ idx) { const size_t bucket_pair_idx = idx * 2; // Merge bucket_count adjacent to each other, merging uneven bucket numbers into even buckets - mergeHelper(buckets_aabb[bucket_pair_idx], buckets_aabb[bucket_pair_idx + 1], to_bp_areas, to_model_areas, influence_areas, insert_main[bucket_pair_idx / 2], insert_secondary[bucket_pair_idx / 2], insert_influence[bucket_pair_idx / 2], erase[bucket_pair_idx / 2], layer_idx); - buckets_area[bucket_pair_idx + 1].clear(); // clear now irrelevant max_bucket_count, and delete them later + mergeHelper(volumes, config, buckets_aabb[bucket_pair_idx], buckets_aabb[bucket_pair_idx + 1], to_bp_areas, to_model_areas, influence_areas, insert_main[bucket_pair_idx / 2], insert_secondary[bucket_pair_idx / 2], insert_influence[bucket_pair_idx / 2], erase[bucket_pair_idx / 2], layer_idx); + // clear now irrelevant max_bucket_count, and delete them later + buckets_area[bucket_pair_idx + 1].clear(); buckets_aabb[bucket_pair_idx + 1].clear(); } }); - for (coord_t i = 0; i < (coord_t)buckets_area.size() - 1; i = i + 2) - { - for (SupportElement& del : erase[i / 2]) - { + for (size_t i = 0; i + 1 < buckets_area.size(); i += 2) { + for (SupportElement &del : erase[i / 2]) { to_bp_areas.erase(del); to_model_areas.erase(del); influence_areas.erase(del); } - - for (const std::pair& tup : insert_main[i / 2]) - { - to_bp_areas.emplace(tup); - } - - for (const std::pair& tup : insert_secondary[i / 2]) - { - to_model_areas.emplace(tup); - } - for (const std::pair& tup : insert_influence[i / 2]) - { - influence_areas.emplace(tup); - } + for (const std::pair &tup : insert_main[i / 2]) + to_bp_areas.emplace(std::move(tup)); + for (const std::pair &tup : insert_secondary[i / 2]) + to_model_areas.emplace(std::move(tup)); + for (const std::pair &tup : insert_influence[i / 2]) + influence_areas.emplace(std::move(tup)); } - auto position_rem = std::remove_if(buckets_area.begin(), buckets_area.end(), [&](const std::map x) mutable { return x.empty(); }); - buckets_area.erase(position_rem, buckets_area.end()); - - auto position_aabb = std::remove_if(buckets_aabb.begin(), buckets_aabb.end(), [&](const std::map x) mutable { return x.empty(); }); - buckets_aabb.erase(position_aabb, buckets_aabb.end()); + buckets_area.erase(std::remove_if(buckets_area.begin(), buckets_area.end(), [&](const std::map &x) { return x.empty(); }), buckets_area.end()); + buckets_aabb.erase(std::remove_if(buckets_aabb.begin(), buckets_aabb.end(), [&](const std::map &x) { return x.empty(); }), buckets_aabb.end()); } } @@ -1362,170 +1446,123 @@ std::optional TreeSupport::increaseSingleArea(AreaI SupportElement current_elem(parent); // also increases DTT by one Polygons check_layer_data; if (settings.increase_radius) - { current_elem.effective_radius_height += 1; - } - coord_t radius = config.getCollisionRadius(current_elem); + coord_t radius = m_config.getCollisionRadius(current_elem); - if (settings.move) - { + if (settings.move) { increased = relevant_offset; - if (overspeed > 0) - { - const coord_t safe_movement_distance = (current_elem.use_min_xy_dist ? config.xy_min_distance : config.xy_distance) + (std::min(config.z_distance_top_layers, config.z_distance_bottom_layers) > 0 ? config.min_feature_size : 0); + if (overspeed > 0) { + const coord_t safe_movement_distance = (current_elem.use_min_xy_dist ? m_config.xy_min_distance : m_config.xy_distance) + (std::min(m_config.z_distance_top_layers, m_config.z_distance_bottom_layers) > 0 ? m_config.min_feature_size : 0); // The difference to ensure that the result not only conforms to wall_restriction, but collision/avoidance is done later. The higher last_safe_step_movement_distance comes exactly from the fact that the collision will be subtracted later. - increased = safeOffsetInc(increased, overspeed, volumes_.getWallRestriction(config.getCollisionRadius(*parent), layer_idx, parent->use_min_xy_dist), safe_movement_distance, safe_movement_distance + radius, 1); + increased = safeOffsetInc(increased, overspeed, m_volumes.getWallRestriction(m_config.getCollisionRadius(*parent), layer_idx, parent->use_min_xy_dist), safe_movement_distance, safe_movement_distance + radius, 1); } if (settings.no_error && settings.move) - { - increased.simplify(25); // as ClipperLib::jtRound has to be used for offsets this simplify is VERY important for performance. - } - } - else // if no movement is done the areas keep parent area as no move == offset(0) - { + // as ClipperLib::jtRound has to be used for offsets this simplify is VERY important for performance. + polygons_simplify(increased, scaled(0.025)); + } else + // if no movement is done the areas keep parent area as no move == offset(0) increased = *parent->area; - } - if (mergelayer || current_elem.to_buildplate) - { - to_bp_data = safeUnion(increased.difference(volumes_.getAvoidance(radius, layer_idx - 1, settings.type, false, settings.use_min_distance))); - if (!current_elem.to_buildplate && to_bp_data.area() > 1) // mostly happening in the tip, but with merges one should check every time, just to be sure. - { + if (mergelayer || current_elem.to_buildplate) { + to_bp_data = safeUnion(diff(increased, m_volumes.getAvoidance(radius, layer_idx - 1, settings.type, false, settings.use_min_distance))); + if (! current_elem.to_buildplate && area(to_bp_data) > tiny_area_threshold) { + // mostly happening in the tip, but with merges one should check every time, just to be sure. current_elem.to_buildplate = true; // sometimes nodes that can reach the buildplate are marked as cant reach, tainting subtrees. This corrects it. - logDebug("Corrected taint leading to a wrong to model value on layer %lld targeting %lld with radius %lld\n", layer_idx - 1, current_elem.target_height, radius); + BOOST_LOG_TRIVIAL(debug) << "Corrected taint leading to a wrong to model value on layer " << layer_idx - 1 << " targeting " << current_elem.target_height << " with radius " << radius; } } - if (config.support_rests_on_model) - { + if (m_config.support_rests_on_model) { if (mergelayer || current_elem.to_model_gracious) - { - to_model_data = safeUnion(increased.difference(volumes_.getAvoidance(radius, layer_idx - 1, settings.type, true, settings.use_min_distance))); - } + to_model_data = safeUnion(diff(increased, m_volumes.getAvoidance(radius, layer_idx - 1, settings.type, true, settings.use_min_distance))); - if (!current_elem.to_model_gracious) - { - if (mergelayer && to_model_data.area() >= 1) - { + if (!current_elem.to_model_gracious) { + if (mergelayer && area(to_model_data) >= tiny_area_threshold) { current_elem.to_model_gracious = true; - logDebug("Corrected taint leading to a wrong non gracious value on layer %lld targeting %lld with radius %lld\n", layer_idx - 1, current_elem.target_height, radius); - } - else - { - to_model_data = safeUnion(increased.difference(volumes_.getCollision(radius, layer_idx - 1, settings.use_min_distance))); - } + BOOST_LOG_TRIVIAL(debug) << "Corrected taint leading to a wrong non gracious value on layer " << layer_idx - 1 << " targeting " << current_elem.target_height << " with radius " << radius; + } else + to_model_data = safeUnion(diff(increased, m_volumes.getCollision(radius, layer_idx - 1, settings.use_min_distance))); } } check_layer_data = current_elem.to_buildplate ? to_bp_data : to_model_data; - if (settings.increase_radius && check_layer_data.area() > 1) - { + if (settings.increase_radius && area(check_layer_data) > tiny_area_threshold) { std::function validWithRadius = [&](coord_t next_radius) { - if (volumes_.ceilRadius(next_radius, settings.use_min_distance) <= volumes_.ceilRadius(radius, settings.use_min_distance)) - { + if (m_volumes.ceilRadius(next_radius, settings.use_min_distance) <= m_volumes.ceilRadius(radius, settings.use_min_distance)) return true; - } Polygons to_bp_data_2; if (current_elem.to_buildplate) - { - to_bp_data_2 = increased.difference(volumes_.getAvoidance(next_radius, layer_idx - 1, settings.type, false, settings.use_min_distance)).unionPolygons(); // regular union as output will not be used later => this area should always be a subset of the safeUnion one (i think) - } + to_bp_data_2 = diff(increased, m_volumes.getAvoidance(next_radius, layer_idx - 1, settings.type, false, settings.use_min_distance)); // regular union as output will not be used later => this area should always be a subset of the safeUnion one (i think) Polygons to_model_data_2; - if (config.support_rests_on_model && !current_elem.to_buildplate) - { - if (!current_elem.to_model_gracious) - { - to_model_data_2 = increased.difference(volumes_.getCollision(next_radius, layer_idx - 1, settings.use_min_distance)).unionPolygons(); - } - else - { - to_model_data_2 = increased.difference(volumes_.getAvoidance(next_radius, layer_idx - 1, settings.type, true, settings.use_min_distance)).unionPolygons(); - } - } + if (m_config.support_rests_on_model && !current_elem.to_buildplate) + to_model_data_2 = diff(increased, + current_elem.to_model_gracious ? + m_volumes.getAvoidance(next_radius, layer_idx - 1, settings.type, true, settings.use_min_distance) : + m_volumes.getCollision(next_radius, layer_idx - 1, settings.use_min_distance)); Polygons check_layer_data_2 = current_elem.to_buildplate ? to_bp_data_2 : to_model_data_2; - - return check_layer_data_2.area() > 1; + return area(check_layer_data_2) > tiny_area_threshold; }; - coord_t ceil_radius_before = volumes_.ceilRadius(radius, settings.use_min_distance); + coord_t ceil_radius_before = m_volumes.ceilRadius(radius, settings.use_min_distance); + if (m_config.getCollisionRadius(current_elem) < m_config.increase_radius_until_radius && m_config.getCollisionRadius(current_elem) < m_config.getRadius(current_elem)) { + coord_t target_radius = std::min(m_config.getRadius(current_elem), m_config.increase_radius_until_radius); + coord_t current_ceil_radius = m_volumes.getRadiusNextCeil(radius, settings.use_min_distance); - if (config.getCollisionRadius(current_elem) < config.increase_radius_until_radius && config.getCollisionRadius(current_elem) < config.getRadius(current_elem)) - { - coord_t target_radius = std::min(config.getRadius(current_elem), config.increase_radius_until_radius); - coord_t current_ceil_radius = volumes_.getRadiusNextCeil(radius, settings.use_min_distance); - - while (current_ceil_radius < target_radius && validWithRadius(volumes_.getRadiusNextCeil(current_ceil_radius + 1, settings.use_min_distance))) - { - current_ceil_radius = volumes_.getRadiusNextCeil(current_ceil_radius + 1, settings.use_min_distance); - } + while (current_ceil_radius < target_radius && validWithRadius(m_volumes.getRadiusNextCeil(current_ceil_radius + 1, settings.use_min_distance))) + current_ceil_radius = m_volumes.getRadiusNextCeil(current_ceil_radius + 1, settings.use_min_distance); size_t resulting_eff_dtt = current_elem.effective_radius_height; - while (resulting_eff_dtt + 1 < current_elem.distance_to_top && config.getRadius(resulting_eff_dtt + 1, current_elem.elephant_foot_increases) <= current_ceil_radius && config.getRadius(resulting_eff_dtt + 1, current_elem.elephant_foot_increases) <= config.getRadius(current_elem)) - { + while (resulting_eff_dtt + 1 < current_elem.distance_to_top && m_config.getRadius(resulting_eff_dtt + 1, current_elem.elephant_foot_increases) <= current_ceil_radius && m_config.getRadius(resulting_eff_dtt + 1, current_elem.elephant_foot_increases) <= m_config.getRadius(current_elem)) resulting_eff_dtt++; - } current_elem.effective_radius_height = resulting_eff_dtt; } - radius = config.getCollisionRadius(current_elem); + radius = m_config.getCollisionRadius(current_elem); - const coord_t foot_radius_increase = config.branch_radius * (std::max(config.diameter_scale_bp_radius - config.diameter_angle_scale_factor, 0.0)); - double planned_foot_increase = std::min(1.0, double(config.recommendedMinRadius(layer_idx - 1) - config.getRadius(current_elem)) / foot_radius_increase); // Is nearly all of the time 1, but sometimes an increase of 1 could cause the radius to become bigger than recommendedMinRadius, which could cause the radius to become bigger than precalculated. + const coord_t foot_radius_increase = m_config.branch_radius * (std::max(m_config.diameter_scale_bp_radius - m_config.diameter_angle_scale_factor, 0.0)); + double planned_foot_increase = std::min(1.0, double(m_config.recommendedMinRadius(layer_idx - 1) - m_config.getRadius(current_elem)) / foot_radius_increase); // Is nearly all of the time 1, but sometimes an increase of 1 could cause the radius to become bigger than recommendedMinRadius, which could cause the radius to become bigger than precalculated. bool increase_bp_foot = planned_foot_increase > 0 && current_elem.to_buildplate; - if (increase_bp_foot && config.getRadius(current_elem) >= config.branch_radius && config.getRadius(current_elem) >= config.increase_radius_until_radius) - { - if (validWithRadius(config.getRadius(current_elem.effective_radius_height, current_elem.elephant_foot_increases + planned_foot_increase))) - { + if (increase_bp_foot && m_config.getRadius(current_elem) >= m_config.branch_radius && m_config.getRadius(current_elem) >= m_config.increase_radius_until_radius) + if (validWithRadius(m_config.getRadius(current_elem.effective_radius_height, current_elem.elephant_foot_increases + planned_foot_increase))) { current_elem.elephant_foot_increases += planned_foot_increase; - radius = config.getCollisionRadius(current_elem); + radius = m_config.getCollisionRadius(current_elem); } - } - if (ceil_radius_before != volumes_.ceilRadius(radius, settings.use_min_distance)) - { + if (ceil_radius_before != m_volumes.ceilRadius(radius, settings.use_min_distance)) { if (current_elem.to_buildplate) - { - to_bp_data = safeUnion(increased.difference(volumes_.getAvoidance(radius, layer_idx - 1, settings.type, false, settings.use_min_distance))); - } - if (config.support_rests_on_model && (!current_elem.to_buildplate || mergelayer)) - { - if (!current_elem.to_model_gracious) - { - to_model_data = safeUnion(increased.difference(volumes_.getCollision(radius, layer_idx - 1, settings.use_min_distance))); - } - else - { - to_model_data = safeUnion(increased.difference(volumes_.getAvoidance(radius, layer_idx - 1, settings.type, true, settings.use_min_distance))); - } - } + to_bp_data = safeUnion(diff(increased, m_volumes.getAvoidance(radius, layer_idx - 1, settings.type, false, settings.use_min_distance))); + if (m_config.support_rests_on_model && (!current_elem.to_buildplate || mergelayer)) + to_model_data = safeUnion(diff(increased, + current_elem.to_model_gracious ? + m_volumes.getAvoidance(radius, layer_idx - 1, settings.type, true, settings.use_min_distance) : + m_volumes.getCollision(radius, layer_idx - 1, settings.use_min_distance) + )); check_layer_data = current_elem.to_buildplate ? to_bp_data : to_model_data; - if (check_layer_data.area() < 1) - { - logError("Lost area by doing catch up from %lld to radius %lld\n", ceil_radius_before, volumes_.ceilRadius(config.getCollisionRadius(current_elem), settings.use_min_distance)); + if (area(check_layer_data) < tiny_area_threshold) { + BOOST_LOG_TRIVIAL(error) << "Lost area by doing catch up from " << ceil_radius_before << " to radius " << m_volumes.ceilRadius(m_config.getCollisionRadius(current_elem), settings.use_min_distance); TreeSupport::showError("Area lost catching up radius. May not cause visible malformation.", true); } } } - return check_layer_data.area() > 1 ? std::optional(current_elem) : std::optional(); + return area(check_layer_data) > tiny_area_threshold ? std::optional(current_elem) : std::optional(); } - void TreeSupport::increaseAreas(std::unordered_map& to_bp_areas, std::unordered_map& to_model_areas, std::map& influence_areas, std::vector& bypass_merge_areas, const std::vector& last_layer, const LayerIndex layer_idx, const bool mergelayer) { std::mutex critical_sections; tbb::parallel_for(tbb::blocked_range(0, last_layer.size()), [&](const tbb::blocked_range &range) { - for (const size_t idx = range.begin(); idx < range.end(); ++ idx) { + for (size_t idx = range.begin(); idx < range.end(); ++ idx) { SupportElement* parent = last_layer[idx]; SupportElement elem(parent); // also increases dtt - Polygons wall_restriction = volumes_.getWallRestriction(config.getCollisionRadius(*parent), layer_idx, parent->use_min_xy_dist); // Abstract representation of the model outline. If an influence area would move through it, it could teleport through a wall. + Polygons wall_restriction = m_volumes.getWallRestriction(m_config.getCollisionRadius(*parent), layer_idx, parent->use_min_xy_dist); // Abstract representation of the model outline. If an influence area would move through it, it could teleport through a wall. Polygons to_bp_data, to_model_data; - coord_t radius = config.getCollisionRadius(elem); + coord_t radius = m_config.getCollisionRadius(elem); // When the radius increases, the outer "support wall" of the branch will have been moved farther away from the center (as this is the definition of radius). // As it is not specified that the support_tree_angle has to be one of the center of the branch, it is here seen as the smaller angle of the outer wall of the branch, to the outer wall of the same branch one layer above. @@ -1534,9 +1571,9 @@ void TreeSupport::increaseAreas(std::unordered_map& to coord_t extra_speed = 5; // The extra speed is added to both movement distances. Also move 5 microns faster than allowed to avoid rounding errors, this may cause issues at VERY VERY small layer heights. coord_t extra_slow_speed = 0; // Only added to the slow movement distance. - const coord_t ceiled_parent_radius = volumes_.ceilRadius(config.getCollisionRadius(*parent), parent->use_min_xy_dist); - coord_t projected_radius_increased = config.getRadius(parent->effective_radius_height + 1, parent->elephant_foot_increases); - coord_t projected_radius_delta = projected_radius_increased - config.getCollisionRadius(*parent); + const coord_t ceiled_parent_radius = m_volumes.ceilRadius(m_config.getCollisionRadius(*parent), parent->use_min_xy_dist); + coord_t projected_radius_increased = m_config.getRadius(parent->effective_radius_height + 1, parent->elephant_foot_increases); + coord_t projected_radius_delta = projected_radius_increased - m_config.getCollisionRadius(*parent); // When z distance is more than one layer up and down the Collision used to calculate the wall restriction will always include the wall (and not just the xy_min_distance) of the layer above and below like this (d = blocked area because of z distance): /* @@ -1545,33 +1582,24 @@ void TreeSupport::increaseAreas(std::unordered_map& to * layer z-1:dddddxxxxxxxxxx * For more detailed visualisation see calculateWallRestrictions */ - const coord_t safe_movement_distance = (elem.use_min_xy_dist ? config.xy_min_distance : config.xy_distance) + (std::min(config.z_distance_top_layers, config.z_distance_bottom_layers) > 0 ? config.min_feature_size : 0); - if (ceiled_parent_radius == volumes_.ceilRadius(projected_radius_increased, parent->use_min_xy_dist) || projected_radius_increased < config.increase_radius_until_radius) - { + const coord_t safe_movement_distance = (elem.use_min_xy_dist ? m_config.xy_min_distance : m_config.xy_distance) + (std::min(m_config.z_distance_top_layers, m_config.z_distance_bottom_layers) > 0 ? m_config.min_feature_size : 0); + if (ceiled_parent_radius == m_volumes.ceilRadius(projected_radius_increased, parent->use_min_xy_dist) || projected_radius_increased < m_config.increase_radius_until_radius) // If it is guaranteed possible to increase the radius, the maximum movement speed can be increased, as it is assumed that the maximum movement speed is the one of the slower moving wall extra_speed += projected_radius_delta; - } else - { // if a guaranteed radius increase is not possible, only increase the slow speed - extra_slow_speed += std::min(projected_radius_delta, (config.maximum_move_distance + extra_speed) - (config.maximum_move_distance_slow + extra_slow_speed)); // Ensure that the slow movement distance can not become larger than the fast one. - } + extra_slow_speed += std::min(projected_radius_delta, (m_config.maximum_move_distance + extra_speed) - (m_config.maximum_move_distance_slow + extra_slow_speed)); // Ensure that the slow movement distance can not become larger than the fast one. - if (config.layer_start_bp_radius > layer_idx && config.recommendedMinRadius(layer_idx - 1) < config.getRadius(elem.effective_radius_height + 1, elem.elephant_foot_increases)) - { + if (m_config.layer_start_bp_radius > layer_idx && m_config.recommendedMinRadius(layer_idx - 1) < m_config.getRadius(elem.effective_radius_height + 1, elem.elephant_foot_increases)) { // can guarantee elephant foot radius increase - if (ceiled_parent_radius == volumes_.ceilRadius(config.getRadius(parent->effective_radius_height + 1, parent->elephant_foot_increases + 1), parent->use_min_xy_dist)) - { - extra_speed += config.branch_radius * config.diameter_scale_bp_radius; - } + if (ceiled_parent_radius == m_volumes.ceilRadius(m_config.getRadius(parent->effective_radius_height + 1, parent->elephant_foot_increases + 1), parent->use_min_xy_dist)) + extra_speed += m_config.branch_radius * m_config.diameter_scale_bp_radius; else - { - extra_slow_speed += std::min(coord_t(config.branch_radius * config.diameter_scale_bp_radius), config.maximum_move_distance - (config.maximum_move_distance_slow + extra_slow_speed)); - } + extra_slow_speed += std::min(coord_t(m_config.branch_radius * m_config.diameter_scale_bp_radius), m_config.maximum_move_distance - (m_config.maximum_move_distance_slow + extra_slow_speed)); } - const coord_t fast_speed = config.maximum_move_distance + extra_speed; - const coord_t slow_speed = config.maximum_move_distance_slow + extra_speed + extra_slow_speed; + const coord_t fast_speed = m_config.maximum_move_distance + extra_speed; + const coord_t slow_speed = m_config.maximum_move_distance_slow + extra_speed + extra_slow_speed; Polygons offset_slow, offset_fast; @@ -1583,54 +1611,47 @@ void TreeSupport::increaseAreas(std::unordered_map& to std::deque order; std::function insertSetting = [&](AreaIncreaseSettings settings, bool back) { - if (std::find(order.begin(), order.end(), settings) == order.end()) - { + if (std::find(order.begin(), order.end(), settings) == order.end()) { if (back) - { order.emplace_back(settings); - } else - { order.emplace_front(settings); - } } }; - const bool parent_moved_slow = elem.last_area_increase.increase_speed < config.maximum_move_distance; + const bool parent_moved_slow = elem.last_area_increase.increase_speed < m_config.maximum_move_distance; const bool avoidance_speed_mismatch = parent_moved_slow && elem.last_area_increase.type != AvoidanceType::SLOW; - if (elem.last_area_increase.move && elem.last_area_increase.no_error && elem.can_use_safe_radius && !mergelayer && !avoidance_speed_mismatch && (elem.distance_to_top >= config.tip_layers || parent_moved_slow)) + if (elem.last_area_increase.move && elem.last_area_increase.no_error && elem.can_use_safe_radius && !mergelayer && !avoidance_speed_mismatch && (elem.distance_to_top >= m_config.tip_layers || parent_moved_slow)) { // assume that the avoidance type that was best for the parent is best for me. Makes this function about 7% faster. - insertSetting(AreaIncreaseSettings(elem.last_area_increase.type, elem.last_area_increase.increase_speed < config.maximum_move_distance ? slow_speed : fast_speed, increase_radius, elem.last_area_increase.no_error, !use_min_radius, elem.last_area_increase.move), true); - insertSetting(AreaIncreaseSettings(elem.last_area_increase.type, elem.last_area_increase.increase_speed < config.maximum_move_distance ? slow_speed : fast_speed, !increase_radius, elem.last_area_increase.no_error, !use_min_radius, elem.last_area_increase.move), true); + insertSetting({ elem.last_area_increase.type, elem.last_area_increase.increase_speed < m_config.maximum_move_distance ? slow_speed : fast_speed, increase_radius, elem.last_area_increase.no_error, !use_min_radius, elem.last_area_increase.move }, true); + insertSetting({ elem.last_area_increase.type, elem.last_area_increase.increase_speed < m_config.maximum_move_distance ? slow_speed : fast_speed, !increase_radius, elem.last_area_increase.no_error, !use_min_radius, elem.last_area_increase.move }, true); } // branch may still go though a hole, so a check has to be done whether the hole was already passed, and the regular avoidance can be used. if (!elem.can_use_safe_radius) { // if the radius until which it is always increased can not be guaranteed, move fast. This is to avoid holes smaller than the real branch radius. This does not guarantee the avoidance of such holes, but ensures they are avoided if possible. // order.emplace_back(AvoidanceType::SLOW,!increase_radius,no_error,!use_min_radius,move); - insertSetting(AreaIncreaseSettings(AvoidanceType::SLOW, slow_speed, increase_radius, no_error, !use_min_radius, !move), true); // did we go through the hole + insertSetting({ AvoidanceType::SLOW, slow_speed, increase_radius, no_error, !use_min_radius, !move }, true); // did we go through the hole // in many cases the definition of hole is overly restrictive, so to avoid unnecessary fast movement in the tip, it is ignored there for a bit. This CAN cause a branch to go though a hole it otherwise may have avoided. - if (elem.distance_to_top < round_up_divide(config.tip_layers, 2)) - { - insertSetting(AreaIncreaseSettings(AvoidanceType::FAST, slow_speed, increase_radius, no_error, !use_min_radius, !move), true); - } - insertSetting(AreaIncreaseSettings(AvoidanceType::FAST_SAFE, fast_speed, increase_radius, no_error, !use_min_radius, !move), true); // did we manage to avoid the hole - insertSetting(AreaIncreaseSettings(AvoidanceType::FAST_SAFE, fast_speed, !increase_radius, no_error, !use_min_radius, move), true); - insertSetting(AreaIncreaseSettings(AvoidanceType::FAST, fast_speed, !increase_radius, no_error, !use_min_radius, move), true); + if (elem.distance_to_top < round_up_divide(m_config.tip_layers, 2)) + insertSetting({ AvoidanceType::FAST, slow_speed, increase_radius, no_error, !use_min_radius, !move }, true); + insertSetting({ AvoidanceType::FAST_SAFE, fast_speed, increase_radius, no_error, !use_min_radius, !move }, true); // did we manage to avoid the hole + insertSetting({ AvoidanceType::FAST_SAFE, fast_speed, !increase_radius, no_error, !use_min_radius, move }, true); + insertSetting({ AvoidanceType::FAST, fast_speed, !increase_radius, no_error, !use_min_radius, move }, true); } else { - insertSetting(AreaIncreaseSettings(AvoidanceType::SLOW, slow_speed, increase_radius, no_error, !use_min_radius, move), true); + insertSetting({ AvoidanceType::SLOW, slow_speed, increase_radius, no_error, !use_min_radius, move }, true); // while moving fast to be able to increase the radius (b) may seems preferable (over a) this can cause the a sudden skip in movement, which looks similar to a layer shift and can reduce stability. // as such idx have chosen to only use the user setting for radius increases as a friendly recommendation. - insertSetting(AreaIncreaseSettings(AvoidanceType::SLOW, slow_speed, !increase_radius, no_error, !use_min_radius, move), true); // a - if (elem.distance_to_top < config.tip_layers) + insertSetting({ AvoidanceType::SLOW, slow_speed, !increase_radius, no_error, !use_min_radius, move }, true); // a + if (elem.distance_to_top < m_config.tip_layers) { - insertSetting(AreaIncreaseSettings(AvoidanceType::FAST_SAFE, slow_speed, increase_radius, no_error, !use_min_radius, move), true); + insertSetting({ AvoidanceType::FAST_SAFE, slow_speed, increase_radius, no_error, !use_min_radius, move }, true); } - insertSetting(AreaIncreaseSettings(AvoidanceType::FAST_SAFE, fast_speed, increase_radius, no_error, !use_min_radius, move), true); // b - insertSetting(AreaIncreaseSettings(AvoidanceType::FAST_SAFE, fast_speed, !increase_radius, no_error, !use_min_radius, move), true); + insertSetting({ AvoidanceType::FAST_SAFE, fast_speed, increase_radius, no_error, !use_min_radius, move }, true); // b + insertSetting({ AvoidanceType::FAST_SAFE, fast_speed, !increase_radius, no_error, !use_min_radius, move }, true); } if (elem.use_min_xy_dist) @@ -1644,124 +1665,99 @@ void TreeSupport::increaseAreas(std::unordered_map& to } order = new_order; } - if (elem.to_buildplate || (elem.to_model_gracious && (parent->area->intersection(volumes_.getPlaceableAreas(radius, layer_idx)).empty()))) // error case + if (elem.to_buildplate || (elem.to_model_gracious && intersection(*parent->area, m_volumes.getPlaceableAreas(radius, layer_idx)).empty())) // error case { // it is normal that we wont be able to find a new area at some point in time if we wont be able to reach layer 0 aka have to connect with the model - insertSetting(AreaIncreaseSettings(AvoidanceType::FAST, fast_speed, !increase_radius, !no_error, elem.use_min_xy_dist, move), true); + insertSetting({ AvoidanceType::FAST, fast_speed, !increase_radius, !no_error, elem.use_min_xy_dist, move }, true); } if (elem.distance_to_top < elem.dont_move_until && elem.can_use_safe_radius) // only do not move when holes would be avoided in every case. - { - insertSetting(AreaIncreaseSettings(AvoidanceType::SLOW, 0, increase_radius, no_error, !use_min_radius, !move), false); // Only do not move when already in a no hole avoidance with the regular xy distance. - } + // Only do not move when already in a no hole avoidance with the regular xy distance. + insertSetting({ AvoidanceType::SLOW, 0, increase_radius, no_error, !use_min_radius, !move }, false); Polygons inc_wo_collision; // Check whether it is faster to calculate the area increased with the fast speed independently from the slow area, or time could be saved by reusing the slow area to calculate the fast one. // Calculated by comparing the steps saved when calcualting idependently with the saved steps when not. - bool offset_independant_faster = (radius / safe_movement_distance - (((config.maximum_move_distance + extra_speed) < (radius + safe_movement_distance)) ? 1 : 0)) > (round_up_divide((extra_speed + extra_slow_speed + config.maximum_move_distance_slow), safe_movement_distance)); + bool offset_independant_faster = (radius / safe_movement_distance - (((m_config.maximum_move_distance + extra_speed) < (radius + safe_movement_distance)) ? 1 : 0)) > (round_up_divide((extra_speed + extra_slow_speed + m_config.maximum_move_distance_slow), safe_movement_distance)); for (AreaIncreaseSettings settings : order) { - if (settings.move) - { - if (offset_slow.empty() && (settings.increase_speed == slow_speed || !offset_independant_faster)) - { - offset_slow = safeOffsetInc(*parent->area, extra_speed + extra_slow_speed + config.maximum_move_distance_slow, wall_restriction, safe_movement_distance, offset_independant_faster ? safe_movement_distance + radius : 0, 2).unionPolygons(); // offsetting in 2 steps makes our offsetted area rounder preventing (rounding) errors created by to pointy areas. At this point one can see that the Polygons class was never made for precision in the single digit micron range. + if (settings.move) { + if (offset_slow.empty() && (settings.increase_speed == slow_speed || !offset_independant_faster)) { + // offsetting in 2 steps makes our offsetted area rounder preventing (rounding) errors created by to pointy areas. At this point one can see that the Polygons class + // was never made for precision in the single digit micron range. + offset_slow = safeOffsetInc(*parent->area, extra_speed + extra_slow_speed + m_config.maximum_move_distance_slow, wall_restriction, safe_movement_distance, offset_independant_faster ? safe_movement_distance + radius : 0, 2); } - if ((settings.increase_speed != slow_speed) && offset_fast.empty()) - { + if ((settings.increase_speed != slow_speed) && offset_fast.empty()) { if (offset_independant_faster) - { - offset_fast = safeOffsetInc(*parent->area, extra_speed + config.maximum_move_distance, wall_restriction, safe_movement_distance, offset_independant_faster ? safe_movement_distance + radius : 0, 1).unionPolygons(); - } - else - { - const coord_t delta_slow_fast = config.maximum_move_distance - (config.maximum_move_distance_slow + extra_slow_speed); - offset_fast = safeOffsetInc(offset_slow, delta_slow_fast, wall_restriction, safe_movement_distance, safe_movement_distance + radius, offset_independant_faster ? 2 : 1).unionPolygons(); + offset_fast = safeOffsetInc(*parent->area, extra_speed + m_config.maximum_move_distance, wall_restriction, safe_movement_distance, offset_independant_faster ? safe_movement_distance + radius : 0, 1); + else { + const coord_t delta_slow_fast = m_config.maximum_move_distance - (m_config.maximum_move_distance_slow + extra_slow_speed); + offset_fast = safeOffsetInc(offset_slow, delta_slow_fast, wall_restriction, safe_movement_distance, safe_movement_distance + radius, offset_independant_faster ? 2 : 1); } } } std::optional result; - if (!settings.no_error) // ERROR CASE - { + if (!settings.no_error) { + // ERROR CASE // if the area becomes for whatever reason something that clipper sees as a line, offset would stop working, so ensure that even if if wrongly would be a line, it still actually has an area that can be increased - Polygons lines_offset = toPolylines(*parent->area).offsetPolyLine(5); - Polygons base_error_area = parent->area->unionPolygons(lines_offset); - result = increaseSingleArea(settings, layer_idx, parent, base_error_area, to_bp_data, to_model_data, inc_wo_collision, (config.maximum_move_distance + extra_speed) * 1.5, mergelayer); - logError("Influence area could not be increased! Data about the Influence area: " - "Radius: %lld at layer: %d NextTarget: %lld Distance to top: %lld Elephant foot increases %llf use_min_xy_dist %d to buildplate %d gracious %d safe %d until move %d \n " - "Parent %lld: Radius: %lld at layer: %d NextTarget: %lld Distance to top: %lld Elephant foot increases %llf use_min_xy_dist %d to buildplate %d gracious %d safe %d until move %d\n", - radius, layer_idx - 1, elem.next_height, elem.distance_to_top, elem.elephant_foot_increases, elem.use_min_xy_dist, elem.to_buildplate, elem.to_model_gracious, elem.can_use_safe_radius, elem.dont_move_until, parent, config.getCollisionRadius(*parent), layer_idx, parent->next_height, parent->distance_to_top, parent->elephant_foot_increases, parent->use_min_xy_dist, parent->to_buildplate, parent->to_model_gracious, parent->can_use_safe_radius, parent->dont_move_until); + Polygons lines_offset = offset(to_polylines(*parent->area), scaled(0.005)); + Polygons base_error_area = union_(*parent->area, lines_offset); + result = increaseSingleArea(settings, layer_idx, parent, base_error_area, to_bp_data, to_model_data, inc_wo_collision, (m_config.maximum_move_distance + extra_speed) * 1.5, mergelayer); + BOOST_LOG_TRIVIAL(error) << + "Influence area could not be increased! Data about the Influence area: " + "Radius: " << radius << " at layer: " << layer_idx - 1 << " NextTarget: " << elem.next_height << " Distance to top: " << elem.distance_to_top << + " Elephant foot increases " << elem.elephant_foot_increases << " use_min_xy_dist " << elem.use_min_xy_dist << " to buildplate " << elem.to_buildplate << + " gracious " << elem.to_model_gracious << " safe " << elem.can_use_safe_radius << " until move " << elem.dont_move_until << " \n " + "Parent " << parent << ": Radius: " << m_config.getCollisionRadius(*parent) << " at layer: " << layer_idx << " NextTarget: " << parent->next_height << + " Distance to top: " << parent->distance_to_top << " Elephant foot increases " << parent->elephant_foot_increases << " use_min_xy_dist " << parent->use_min_xy_dist << + " to buildplate " << parent->to_buildplate << " gracious " << parent->to_model_gracious << " safe " << parent->can_use_safe_radius << " until move " << parent->dont_move_until; showError("Potentially lost branch!", true); - } - else - { + } else result = increaseSingleArea(settings, layer_idx, parent, settings.increase_speed == slow_speed ? offset_slow : offset_fast, to_bp_data, to_model_data, inc_wo_collision, 0, mergelayer); - } if (result) { elem = result.value(); - radius = config.getCollisionRadius(elem); + radius = m_config.getCollisionRadius(elem); elem.last_area_increase = settings; add = true; - bypass_merge = !settings.move || (settings.use_min_distance && elem.distance_to_top < config.tip_layers); // do not merge if the branch should not move or the priority has to be to get farther away from the model. + bypass_merge = !settings.move || (settings.use_min_distance && elem.distance_to_top < m_config.tip_layers); // do not merge if the branch should not move or the priority has to be to get farther away from the model. if (settings.move) - { elem.dont_move_until = 0; - } else - { elem.result_on_layer = parent->result_on_layer; - } elem.can_use_safe_radius = settings.type != AvoidanceType::FAST; if (!settings.use_min_distance) - { elem.use_min_xy_dist = false; - } if (!settings.no_error) - { - logError("Trying to keep area by moving faster than intended: Success \n"); - } + BOOST_LOG_TRIVIAL(error) << "Trying to keep area by moving faster than intended: Success"; break; } else if (!settings.no_error) - { - logError("Trying to keep area by moving faster than intended: FAILURE! WRONG BRANCHES LIKLY! \n"); - } + BOOST_LOG_TRIVIAL(error) << "Trying to keep area by moving faster than intended: FAILURE! WRONG BRANCHES LIKLY!"; } - if (add) - { - Polygons max_influence_area = safeUnion(inc_wo_collision.difference(volumes_.getCollision(radius, layer_idx - 1, elem.use_min_xy_dist)), safeUnion(to_bp_data, to_model_data)); // union seems useless, but some rounding errors somewhere can cause to_bp_data to be slightly bigger than it should be - + if (add) { + Polygons max_influence_area = safeUnion(diff(inc_wo_collision, m_volumes.getCollision(radius, layer_idx - 1, elem.use_min_xy_dist)), safeUnion(to_bp_data, to_model_data)); // union seems useless, but some rounding errors somewhere can cause to_bp_data to be slightly bigger than it should be { std::lock_guard critical_section_newLayer(critical_sections); - if (bypass_merge) - { + if (bypass_merge) { Polygons* new_area = new Polygons(max_influence_area); SupportElement* next = new SupportElement(elem, new_area); bypass_merge_areas.emplace_back(next); - } - else - { + } else { influence_areas.emplace(elem, max_influence_area); if (elem.to_buildplate) - { to_bp_areas.emplace(elem, to_bp_data); - } - if (config.support_rests_on_model) - { + if (m_config.support_rests_on_model) to_model_areas.emplace(elem, to_model_data); - } } } } else - { parent->result_on_layer = Point(-1, -1); // If the bottom most point of a branch is set, later functions will assume that the position is valid, and ignore it. But as branches connecting with the model that are to small have to be culled, the bottom most point has to be not set. A point can be set on the top most tip layer (maybe more if it should not move for a few layers). - } } }); } @@ -1770,7 +1766,9 @@ void TreeSupport::increaseAreas(std::unordered_map& to void TreeSupport::createLayerPathing(std::vector>& move_bounds) { const double data_size_inverse = 1 / double(move_bounds.size()); +#ifdef SLIC3R_TREESUPPORTS_PROGRESS double progress_total = TREE_PROGRESS_PRECALC_AVO + TREE_PROGRESS_PRECALC_COLL + TREE_PROGRESS_GENERATE_NODES; +#endif // SLIC3R_TREESUPPORTS_PROGRESS auto dur_inc = std::chrono::duration_values::zero(); auto dur_merge = std::chrono::duration_values::zero(); @@ -1781,7 +1779,7 @@ void TreeSupport::createLayerPathing(std::vector>& mov LayerIndex last_merge = move_bounds.size(); bool new_element = false; - size_t max_merge_every_x_layers = std::min(std::min(5000 / (std::max(config.maximum_move_distance, coord_t(100))), 1000 / std::max(config.maximum_move_distance_slow, coord_t(20))), 3000 / config.layer_height); // Ensures at least one merge operation per 3mm height, 50 layers, 1 mm movement of slow speed or 5mm movement of fast speed (whatever is lowest). Values were guessed. + size_t max_merge_every_x_layers = std::min(std::min(5000 / (std::max(m_config.maximum_move_distance, coord_t(100))), 1000 / std::max(m_config.maximum_move_distance_slow, coord_t(20))), 3000 / m_config.layer_height); // Ensures at least one merge operation per 3mm height, 50 layers, 1 mm movement of slow speed or 5mm movement of fast speed (whatever is lowest). Values were guessed. size_t merge_every_x_layers = 1; // Calculate the influence areas for each layer below (Top down) // This is done by first increasing the influence area by the allowed movement distance, and merging them with other influence areas if possible @@ -1814,7 +1812,7 @@ void TreeSupport::createLayerPathing(std::vector>& mov bool reduced_by_merging = false; size_t count_before_merge = influence_areas.size(); // ### Calculate which influence areas overlap, and merge them into a new influence area (simplified: an intersection of influence areas that have such an intersection) - mergeInfluenceAreas(to_bp_areas, to_model_areas, influence_areas, layer_idx); + mergeInfluenceAreas(m_volumes, m_config, to_bp_areas, to_model_areas, influence_areas, layer_idx); last_merge = layer_idx; reduced_by_merging = count_before_merge > influence_areas.size(); @@ -1831,37 +1829,34 @@ void TreeSupport::createLayerPathing(std::vector>& mov new_element = !move_bounds[layer_idx - 1].empty(); // Save calculated elements to output, and allocate Polygons on heap, as they will not be changed again. - for (std::pair tup : influence_areas) - { + for (std::pair tup : influence_areas) { const SupportElement elem = tup.first; Polygons* new_area = new Polygons(safeUnion(tup.second)); SupportElement* next = new SupportElement(elem, new_area); move_bounds[layer_idx - 1].emplace(next); - if (new_area->area() < 1) - { - logError("Insert Error of Influence area on layer %lld. Origin of %lld areas. Was to bp %d\n", layer_idx - 1, elem.parents.size(), elem.to_buildplate); + if (area(*new_area) < tiny_area_threshold) { + BOOST_LOG_TRIVIAL(error) << "Insert Error of Influence area on layer " << layer_idx - 1 << ". Origin of " << elem.parents.size() << " areas. Was to bp " << elem.to_buildplate; TreeSupport::showError("Insert error of area after merge.\n", true); } } // Place already fully constructed elements in the output. - for (SupportElement* elem : bypass_merge_areas) - { - if (elem->area->area() < 1) - { - logError("Insert Error of Influence area bypass on layer %lld.\n", layer_idx - 1); + for (SupportElement* elem : bypass_merge_areas) { + if (area(*elem->area) < tiny_area_threshold) { + BOOST_LOG_TRIVIAL(error) << "Insert Error of Influence area bypass on layer " << layer_idx - 1; TreeSupport::showError("Insert error of area after bypassing merge.\n", true); - } move_bounds[layer_idx - 1].emplace(elem); } +#ifdef SLIC3R_TREESUPPORTS_PROGRESS progress_total += data_size_inverse * TREE_PROGRESS_AREA_CALC; - Progress::messageProgress(Progress::Stage::SUPPORT, progress_total * progress_multiplier + progress_offset, TREE_PROGRESS_TOTAL); + Progress::messageProgress(Progress::Stage::SUPPORT, progress_total * m_progress_multiplier + m_progress_offset, TREE_PROGRESS_TOTAL); +#endif } - log("Time spent with creating influence areas' subtasks: Increasing areas %lld ms merging areas: %lld ms\n", dur_inc.count() / 1000000, dur_merge.count() / 1000000); + BOOST_LOG_TRIVIAL(info) << "Time spent with creating influence areas' subtasks: Increasing areas " << dur_inc.count() / 1000000 << " ms merging areas: " << dur_merge.count() / 1000000 << " ms"; } @@ -1871,7 +1866,7 @@ void TreeSupport::setPointsOnAreas(const SupportElement* elem) if (elem->result_on_layer == Point(-1, -1)) { - logError("Uninitialized support element\n"); + BOOST_LOG_TRIVIAL(error) << "Uninitialized support element"; TreeSupport::showError("Uninitialized support element. A branch may be missing.\n", true); return; } @@ -1879,14 +1874,11 @@ void TreeSupport::setPointsOnAreas(const SupportElement* elem) for (SupportElement* next_elem : elem->parents) { if (next_elem->result_on_layer != Point(-1, -1)) // if the value was set somewhere else it it kept. This happens when a branch tries not to move after being unable to create a roof. - { continue; - } Point from = elem->result_on_layer; - if (!(next_elem->area->inside(from, true))) - { - PolygonUtils::moveInside(*next_elem->area, from, 0); // Move inside has edgecases (see tests) so DONT use Polygons.inside to confirm correct move, Error with distance 0 is <= 1 + if (! contains(*next_elem->area, from)) { + moveInside(*next_elem->area, from, 0); // Move inside has edgecases (see tests) so DONT use Polygons.inside to confirm correct move, Error with distance 0 is <= 1 // it is not required to check if how far this move moved a point as is can be larger than maximum_movement_distance. While this seems like a problem it may for example occur after merges. } next_elem->result_on_layer = from; @@ -1908,8 +1900,7 @@ bool TreeSupport::setToModelContact(std::vector>& move for (LayerIndex layer_check = layer_idx; check->next_height >= layer_check; layer_check++) { - if (!check->area->intersection(volumes_.getPlaceableAreas(config.getCollisionRadius(*check), layer_check)).empty()) - { + if (! intersection(*check->area, m_volumes.getPlaceableAreas(m_config.getCollisionRadius(*check), layer_check)).empty()) { set = true; last_successfull_layer = layer_check; } @@ -1929,7 +1920,7 @@ bool TreeSupport::setToModelContact(std::vector>& move { if (SUPPORT_TREE_ONLY_GRACIOUS_TO_MODEL) { - logWarning("No valid placement found for to model gracious element on layer %lld: REMOVING BRANCH\n", layer_idx); + BOOST_LOG_TRIVIAL(warning) << "No valid placement found for to model gracious element on layer " << layer_idx << ": REMOVING BRANCH"; TreeSupport::showError("Could not fine valid placement on model! Removing this branch...", true); for (LayerIndex layer = layer_idx; layer <= first_elem->next_height; layer++) { @@ -1940,7 +1931,7 @@ bool TreeSupport::setToModelContact(std::vector>& move } else { - logWarning("No valid placement found for to model gracious element on layer %lld\n", layer_idx); + BOOST_LOG_TRIVIAL(warning) << "No valid placement found for to model gracious element on layer " << layer_idx; TreeSupport::showError("Could not fine valid placement on model! Just placing it down anyway. Could cause floating branches.", true); first_elem->to_model_gracious = false; return setToModelContact(move_bounds, first_elem, layer_idx); @@ -1956,26 +1947,22 @@ bool TreeSupport::setToModelContact(std::vector>& move // Guess a point inside the influence area, in which the branch will be placed in. Point best = checked[last_successfull_layer - layer_idx]->next_position; - if (!checked[last_successfull_layer - layer_idx]->area->inside(best, true)) - { - PolygonUtils::moveInside(*checked[last_successfull_layer - layer_idx]->area, best); - } + if (! contains(*checked[last_successfull_layer - layer_idx]->area, best)) + moveInside(*checked[last_successfull_layer - layer_idx]->area, best); checked[last_successfull_layer - layer_idx]->result_on_layer = best; - logDebug("Added gracious Support On Model Point (%lld,%lld). The current layer is %lld\n", best.x(), best.y(), last_successfull_layer); + BOOST_LOG_TRIVIAL(debug) << "Added gracious Support On Model Point (" << best.x() << "," << best.y() << "). The current layer is ", last_successfull_layer; return last_successfull_layer != layer_idx; } else // can not add graceful => just place it here and hope for the best { Point best = first_elem->next_position; - if (!first_elem->area->inside(best, true)) - { - PolygonUtils::moveInside(*first_elem->area, best); - } + if (! contains(*first_elem->area, best)) + moveInside(*first_elem->area, best); first_elem->result_on_layer = best; first_elem->to_model_gracious = false; - logDebug("Added NON gracious Support On Model Point (%lld,%lld). The current layer is %lld\n", best.x(), best.y(), layer_idx); + BOOST_LOG_TRIVIAL(debug) << "Added NON gracious Support On Model Point (" << best.x() << "," << best.y() << "). The current layer is ", layer_idx; return false; } } @@ -1984,62 +1971,45 @@ bool TreeSupport::setToModelContact(std::vector>& move void TreeSupport::createNodesFromArea(std::vector>& move_bounds) { // Initialize points on layer 0, with a "random" point in the influence area. Point is chosen based on an inaccurate estimate where the branches will split into two, but every point inside the influence area would produce a valid result. - for (SupportElement* init : move_bounds[0]) - { + for (SupportElement* init : move_bounds[0]) { Point p = init->next_position; - if (!(init->area->inside(p, true))) - { - PolygonUtils::moveInside(*init->area, p, 0); - } + if (! contains(*init->area, p)) + moveInside(*init->area, p, 0); init->result_on_layer = p; - setPointsOnAreas(init); // also set the parent nodes, as these will be required for the first iteration of the loop below } - - for (LayerIndex layer_idx = 1; layer_idx < LayerIndex(move_bounds.size()); layer_idx++) - { + for (LayerIndex layer_idx = 1; layer_idx < LayerIndex(move_bounds.size()); ++ layer_idx) { std::unordered_set remove; - for (SupportElement* elem : move_bounds[layer_idx]) - { + for (SupportElement* elem : move_bounds[layer_idx]) { bool removed = false; - if (elem->result_on_layer == Point(-1, -1)) // check if the resulting center point is not yet set - { - if (elem->to_buildplate || (!elem->to_buildplate && elem->distance_to_top < config.min_dtt_to_model && !elem->supports_roof)) - { - if (elem->to_buildplate) - { - logError("Uninitialized Influence area targeting (%lld,%lld) at target_height: %lld layer: %lld\n", elem->target_position.x(), elem->target_position.y(), elem->target_height, layer_idx); + // check if the resulting center point is not yet set + if (elem->result_on_layer == Point(-1, -1)) { + if (elem->to_buildplate || (!elem->to_buildplate && elem->distance_to_top < m_config.min_dtt_to_model && !elem->supports_roof)) { + if (elem->to_buildplate) { + BOOST_LOG_TRIVIAL(error) << "Uninitialized Influence area targeting " << elem->target_position.x() << "," << elem->target_position.y() << ") " + "at target_height: " << elem->target_height << " layer: " << layer_idx; TreeSupport::showError("Uninitialized support element! A branch could be missing or exist partially.", true); } remove.emplace(elem); // we dont need to remove yet the parents as they will have a lower dtt and also no result_on_layer set removed = true; for (SupportElement* parent : elem->parents) - { parent->result_on_layer = Point(-1, -1); // When the roof was not able to generate downwards enough, the top elements may have not moved, and have result_on_layer already set. As this branch needs to be removed => all parents result_on_layer have to be invalidated. - } continue; - } - else - { + } else { // set the point where the branch will be placed on the model removed = setToModelContact(move_bounds, elem, layer_idx); if (removed) - { remove.emplace(elem); - } } } if (!removed) - { setPointsOnAreas(elem); // element is valid now setting points in the layer above - } } // delete all not needed support elements - for (SupportElement* del : remove) - { + for (SupportElement* del : remove) { move_bounds[layer_idx].erase(del); delete del->area; delete del; @@ -2050,60 +2020,61 @@ void TreeSupport::createNodesFromArea(std::vector>& mo void TreeSupport::generateBranchAreas(std::vector>& linear_data, std::vector>& layer_tree_polygons, const std::map& inverse_tree_order) { +#ifdef SLIC3R_TREESUPPORTS_PROGRESS double progress_total = TREE_PROGRESS_PRECALC_AVO + TREE_PROGRESS_PRECALC_COLL + TREE_PROGRESS_GENERATE_NODES + TREE_PROGRESS_AREA_CALC; constexpr int progress_report_steps = 10; +#endif // SLIC3R_TREESUPPORTS_PROGRESS + Polygon branch_circle; // Pre-generate a circle with correct diameter so that we don't have to recompute those (co)sines every time. - for (unsigned int i = 0; i < SUPPORT_TREE_CIRCLE_RESOLUTION; i++) - { + for (unsigned int i = 0; i < SUPPORT_TREE_CIRCLE_RESOLUTION; ++ i) { const AngleRadians angle = static_cast(i) / SUPPORT_TREE_CIRCLE_RESOLUTION * (2.0 * M_PI); - branch_circle.emplace_back(coord_t(cos(angle) * config.branch_radius), coord_t(sin(angle) * config.branch_radius)); + branch_circle.points.emplace_back(coord_t(cos(angle) * m_config.branch_radius), coord_t(sin(angle) * m_config.branch_radius)); } std::vector linear_inserts(linear_data.size()); + +#ifdef SLIC3R_TREESUPPORTS_PROGRESS const size_t progress_inserts_check_interval = linear_data.size() / progress_report_steps; +#endif // SLIC3R_TREESUPPORTS_PROGRESS std::mutex critical_sections; tbb::parallel_for(tbb::blocked_range(0, linear_data.size()), [&](const tbb::blocked_range &range) { - for (const size_t idx = range.begin(); idx < range.end(); ++ idx) { + for (size_t idx = range.begin(); idx < range.end(); ++ idx) { SupportElement* elem = linear_data[idx].second; - coord_t radius = config.getRadius(*elem); + coord_t radius = m_config.getRadius(*elem); bool parent_uses_min = false; SupportElement* child_elem = inverse_tree_order.count(elem) ? inverse_tree_order.at(elem) : nullptr; // Calculate multiple ovalized circles, to connect with every parent and child. Also generate regular circle for the current layer. Merge all these into one area. std::vector> movement_directions{ std::pair(Point(0, 0), radius) }; - if (!elem->skip_ovalisation) - { - if (child_elem != nullptr) - { + if (!elem->skip_ovalisation) { + if (child_elem != nullptr) { Point movement = (child_elem->result_on_layer - elem->result_on_layer); movement_directions.emplace_back(movement, radius); } - for (SupportElement* parent : elem->parents) - { + for (SupportElement* parent : elem->parents) { Point movement = (parent->result_on_layer - elem->result_on_layer); - movement_directions.emplace_back(movement, std::max(config.getRadius(parent), config.support_line_width)); + movement_directions.emplace_back(movement, std::max(m_config.getRadius(parent), m_config.support_line_width)); parent_uses_min |= parent->use_min_xy_dist; } } - coord_t max_speed = 0; - std::function generateArea = [&](coord_t offset) + double max_speed = 0; + std::function generateArea = [&](coord_t aoffset) { Polygons poly; - for (std::pair movement : movement_directions) - { - max_speed = std::max(max_speed, vSize(movement.first)); + for (std::pair movement : movement_directions) { + max_speed = std::max(max_speed, movement.first.cast().norm()); // Visualization: https://jsfiddle.net/0zvcq39L/2/ // Ovalizes the circle to an ellipse, that contains both old center and new target position. - double used_scale = (movement.second + offset) / (1.0 * config.branch_radius); + double used_scale = (movement.second + aoffset) / (1.0 * m_config.branch_radius); Point center_position = elem->result_on_layer + movement.first / 2; - const double moveX = movement.first.x() / (used_scale * config.branch_radius); - const double moveY = movement.first.y() / (used_scale * config.branch_radius); + const double moveX = movement.first.x() / (used_scale * m_config.branch_radius); + const double moveY = movement.first.y() / (used_scale * m_config.branch_radius); const double vsize_inv = 0.5 / (0.01 + std::sqrt(moveX * moveX + moveY * moveY)); double matrix[] = { @@ -2114,207 +2085,173 @@ void TreeSupport::generateBranchAreas(std::vectoruse_min_xy_dist)); // There seem to be some rounding errors, causing a branch to be a tiny bit further away from the model that it has to be. This can cause the tip to be slightly further away front the overhang (x/y wise) than optimal. This fixes it, and for every other part, 0.05mm will not be noticed. + poly = diff(offset(union_(poly), std::min(coord_t(50), m_config.support_line_width / 4)), m_volumes.getCollision(0, linear_data[idx].first, parent_uses_min || elem->use_min_xy_dist)); // There seem to be some rounding errors, causing a branch to be a tiny bit further away from the model that it has to be. This can cause the tip to be slightly further away front the overhang (x/y wise) than optimal. This fixes it, and for every other part, 0.05mm will not be noticed. return poly; }; - bool fast_relative_movement = max_speed > radius * 0.75; // ensure branch area will not overlap with model/collision. This can happen because of e.g. ovalization or increase_until_radius. linear_inserts[idx] = generateArea(0); - if (fast_relative_movement || config.getRadius(*elem) - config.getCollisionRadius(*elem) > config.support_line_width) - { + if (fast_relative_movement || m_config.getRadius(*elem) - m_config.getCollisionRadius(*elem) > m_config.support_line_width) { // simulate the path the nozzle will take on the outermost wall // if multiple parts exist, the outer line will not go all around the support part potentially causing support material to be printed mid air - Polygons nozzle_path = linear_inserts[idx].offset(-config.support_line_width / 2); - if (nozzle_path.splitIntoParts(false).size() > 1) - { + ExPolygons nozzle_path = offset_ex(linear_inserts[idx], -m_config.support_line_width / 2); + if (nozzle_path.size() > 1) { // Just try to make the area a tiny bit larger. - linear_inserts[idx] = generateArea(config.support_line_width / 2); - nozzle_path = linear_inserts[idx].offset(-config.support_line_width / 2); + linear_inserts[idx] = generateArea(m_config.support_line_width / 2); + nozzle_path = offset_ex(linear_inserts[idx], -m_config.support_line_width / 2); // if larger area did not fix the problem, all parts off the nozzle path that do not contain the center point are removed, hoping for the best - if (nozzle_path.splitIntoParts(false).size() > 1) - { + if (nozzle_path.size() > 1) { Polygons polygons_with_correct_center; - for (PolygonsPart part : nozzle_path.splitIntoParts(false)) - { - if (part.inside(elem->result_on_layer, true)) - { - polygons_with_correct_center = polygons_with_correct_center.unionPolygons(part); - } - else - { + for (const ExPolygon &part : nozzle_path) { + if (part.contains(elem->result_on_layer)) + polygons_with_correct_center = union_(polygons_with_correct_center, part); + else { // try a fuzzy inside as sometimes the point should be on the border, but is not because of rounding errors... Point from = elem->result_on_layer; - PolygonUtils::moveInside(part, from, 0); - if (vSize(elem->result_on_layer - from) < 25) - { - polygons_with_correct_center = polygons_with_correct_center.unionPolygons(part); - } + moveInside(part, from, 0); + if ((elem->result_on_layer - from).cast().norm() < scaled(0.025)) + polygons_with_correct_center = union_(polygons_with_correct_center, part); } } - linear_inserts[idx] = polygons_with_correct_center.offset(config.support_line_width / 2).unionPolygons(); // Increase the area again, to ensure the nozzle path when calculated later is very similar to the one assumed above. - linear_inserts[idx] = linear_inserts[idx].difference(volumes_.getCollision(0, linear_data[idx].first, parent_uses_min || elem->use_min_xy_dist)).unionPolygons(); + // Increase the area again, to ensure the nozzle path when calculated later is very similar to the one assumed above. + linear_inserts[idx] = offset(polygons_with_correct_center, m_config.support_line_width / 2); + linear_inserts[idx] = diff(linear_inserts[idx], m_volumes.getCollision(0, linear_data[idx].first, parent_uses_min || elem->use_min_xy_dist)); } } } - if (idx % progress_inserts_check_interval == 0) - { - { - std::lock_guard critical_section_progress(critical_sections); - progress_total += TREE_PROGRESS_GENERATE_BRANCH_AREAS / progress_report_steps; - Progress::messageProgress(Progress::Stage::SUPPORT, progress_total * progress_multiplier + progress_offset, TREE_PROGRESS_TOTAL); - } +#ifdef SLIC3R_TREESUPPORTS_PROGRESS + if (idx % progress_inserts_check_interval == 0) { + std::lock_guard critical_section_progress(critical_sections); + progress_total += TREE_PROGRESS_GENERATE_BRANCH_AREAS / progress_report_steps; + Progress::messageProgress(Progress::Stage::SUPPORT, progress_total * m_progress_multiplier + m_progress_offset, TREE_PROGRESS_TOTAL); } +#endif } }); // single threaded combining all elements to the right layers. ONLY COPYS DATA! for (coord_t i = 0; i < static_cast(linear_data.size()); i++) - { layer_tree_polygons[linear_data[i].first].emplace(linear_data[i].second, linear_inserts[i]); - } } void TreeSupport::smoothBranchAreas(std::vector>& layer_tree_polygons) { +#ifdef SLIC3R_TREESUPPORTS_PROGRESS double progress_total = TREE_PROGRESS_PRECALC_AVO + TREE_PROGRESS_PRECALC_COLL + TREE_PROGRESS_GENERATE_NODES + TREE_PROGRESS_AREA_CALC + TREE_PROGRESS_GENERATE_BRANCH_AREAS; - const coord_t max_radius_change_per_layer = 1 + config.support_line_width / 2; // this is the upper limit a radius may change per layer. +1 to avoid rounding errors +#endif // SLIC3R_TREESUPPORTS_PROGRESS + + const coord_t max_radius_change_per_layer = 1 + m_config.support_line_width / 2; // this is the upper limit a radius may change per layer. +1 to avoid rounding errors // smooth upwards - for (LayerIndex layer_idx = 0; layer_idx < LayerIndex(layer_tree_polygons.size()) - 1; layer_idx++) - { + for (LayerIndex layer_idx = 0; layer_idx < LayerIndex(layer_tree_polygons.size()) - 1; layer_idx++) { std::vector> processing; processing.insert(processing.end(), layer_tree_polygons[layer_idx].begin(), layer_tree_polygons[layer_idx].end()); std::vector>> update_next(processing.size()); // with this a lock can be avoided tbb::parallel_for(tbb::blocked_range(0, processing.size()), [&](const tbb::blocked_range &range) { - for (const size_t processing_idx = range.begin(); processing_idx < range.end(); ++ processing_idx) { + for (size_t processing_idx = range.begin(); processing_idx < range.end(); ++ processing_idx) { std::pair data_pair = processing[processing_idx]; - - coord_t max_outer_wall_distance = 0; + double max_outer_wall_distance = 0; bool do_something = false; for (SupportElement* parent : data_pair.first->parents) - { - if (config.getRadius(*parent) != config.getCollisionRadius(*parent)) - { + if (m_config.getRadius(*parent) != m_config.getCollisionRadius(*parent)) { do_something = true; - max_outer_wall_distance = std::max(max_outer_wall_distance, vSize(data_pair.first->result_on_layer - parent->result_on_layer) - (config.getRadius(*data_pair.first) - config.getRadius(*parent))); + max_outer_wall_distance = std::max(max_outer_wall_distance, (data_pair.first->result_on_layer - parent->result_on_layer).cast().norm() - (m_config.getRadius(*data_pair.first) - m_config.getRadius(*parent))); } - } max_outer_wall_distance += max_radius_change_per_layer; // As this change is a bit larger than what usually appears, lost radius can be slowly reclaimed over the layers. - if (do_something) - { - Polygons max_allowed_area = data_pair.second.offset(max_outer_wall_distance); + if (do_something) { + Polygons max_allowed_area = offset(data_pair.second, float(max_outer_wall_distance)); for (SupportElement* parent : data_pair.first->parents) - { - if (config.getRadius(*parent) != config.getCollisionRadius(*parent)) - { - update_next[processing_idx].emplace_back(std::pair(parent, layer_tree_polygons[layer_idx + 1][parent].intersection(max_allowed_area))); - } - } + if (m_config.getRadius(*parent) != m_config.getCollisionRadius(*parent)) + update_next[processing_idx].emplace_back(std::pair(parent, intersection(layer_tree_polygons[layer_idx + 1][parent], max_allowed_area))); } } }); for (std::vector> data_vector : update_next) - { for (std::pair data_pair : data_vector) - { layer_tree_polygons[layer_idx + 1][data_pair.first] = data_pair.second; - } - } } +#ifdef SLIC3R_TREESUPPORTS_PROGRESS progress_total += TREE_PROGRESS_SMOOTH_BRANCH_AREAS / 2; - Progress::messageProgress(Progress::Stage::SUPPORT, progress_total * progress_multiplier + progress_offset, TREE_PROGRESS_TOTAL); // It is just assumed that both smoothing loops together are one third of the time spent in this function. This was guessed. As the whole function is only 10%, and the smoothing is hard to predict a progress report in the loop may be not useful. + Progress::messageProgress(Progress::Stage::SUPPORT, progress_total * m_progress_multiplier + m_progress_offset, TREE_PROGRESS_TOTAL); // It is just assumed that both smoothing loops together are one third of the time spent in this function. This was guessed. As the whole function is only 10%, and the smoothing is hard to predict a progress report in the loop may be not useful. +#endif // smooth downwards std::unordered_set updated_last_iteration; - for (LayerIndex layer_idx = layer_tree_polygons.size() - 2; layer_idx >= 0; layer_idx--) - { + for (LayerIndex layer_idx = layer_tree_polygons.size() - 2; layer_idx >= 0; layer_idx--) { std::vector> processing; processing.insert(processing.end(), layer_tree_polygons[layer_idx].begin(), layer_tree_polygons[layer_idx].end()); std::vector> update_next(processing.size(), std::pair(nullptr, Polygons())); // with this a lock can be avoided tbb::parallel_for(tbb::blocked_range(0, processing.size()), [&](const tbb::blocked_range &range) { - for (const size_t processing_idx = range.begin(); processing_idx < range.end(); ++ processing_idx) { + for (size_t processing_idx = range.begin(); processing_idx < range.end(); ++ processing_idx) { std::pair data_pair = processing[processing_idx]; bool do_something = false; Polygons max_allowed_area; - for (size_t idx = 0; idx < data_pair.first->parents.size(); idx++) - { + for (size_t idx = 0; idx < data_pair.first->parents.size(); ++ idx) { SupportElement* parent = data_pair.first->parents[idx]; coord_t max_outer_line_increase = max_radius_change_per_layer; - Polygons result = layer_tree_polygons[layer_idx + 1][parent].offset(max_outer_line_increase); + Polygons result = offset(layer_tree_polygons[layer_idx + 1][parent], max_outer_line_increase); Point direction = data_pair.first->result_on_layer - parent->result_on_layer; // move the polygons object for (auto& outer : result) - { for (Point& p : outer) - { p += direction; - } - } - max_allowed_area.add(result); - do_something = do_something || updated_last_iteration.count(parent) || config.getCollisionRadius(*parent) != config.getRadius(*parent); + append(max_allowed_area, std::move(result)); + do_something = do_something || updated_last_iteration.count(parent) || m_config.getCollisionRadius(*parent) != m_config.getRadius(*parent); } - if (do_something) - { - Polygons result = max_allowed_area.unionPolygons().intersection(data_pair.second); - if (result.area() < data_pair.second.area()) - { + if (do_something) { + Polygons result = intersection(max_allowed_area, data_pair.second); + if (area(result) < area(data_pair.second)) update_next[processing_idx] = std::pair(data_pair.first, result); - } } } }); updated_last_iteration.clear(); for (std::pair data_pair : update_next) - { - if (data_pair.first != nullptr) - { + if (data_pair.first != nullptr) { updated_last_iteration.emplace(data_pair.first); layer_tree_polygons[layer_idx][data_pair.first] = data_pair.second; } - } } +#ifdef SLIC3R_TREESUPPORTS_PROGRESS progress_total += TREE_PROGRESS_SMOOTH_BRANCH_AREAS / 2; - Progress::messageProgress(Progress::Stage::SUPPORT, progress_total * progress_multiplier + progress_offset, TREE_PROGRESS_TOTAL); + Progress::messageProgress(Progress::Stage::SUPPORT, progress_total * m_progress_multiplier + m_progress_offset, TREE_PROGRESS_TOTAL); +#endif } - -void TreeSupport::dropNonGraciousAreas(std::vector>& layer_tree_polygons, const std::vector>& linear_data, std::vector>>& dropped_down_areas, const std::map& inverse_tree_order) +void TreeSupport::dropNonGraciousAreas( + std::vector> &layer_tree_polygons, + const std::vector> &linear_data, + std::vector>> &dropped_down_areas, + const std::map &inverse_tree_order) { tbb::parallel_for(tbb::blocked_range(0, linear_data.size()), [&](const tbb::blocked_range &range) { - for (const size_t idx = range.begin(); idx < range.end(); ++ idx) { + for (size_t idx = range.begin(); idx < range.end(); ++ idx) { SupportElement* elem = linear_data[idx].second; bool non_gracious_model_contact = !elem->to_model_gracious && !inverse_tree_order.count(elem); // if a element has no child, it connects to whatever is below as no support further down for it will exist. - - if (non_gracious_model_contact) - { + if (non_gracious_model_contact) { Polygons rest_support = layer_tree_polygons[linear_data[idx].first][elem]; LayerIndex counter = 1; - while (rest_support.area() > 1 && counter < linear_data[idx].first) - { - rest_support = rest_support.difference(volumes_.getCollision(0, linear_data[idx].first - counter)); + while (area(rest_support) > tiny_area_threshold && counter < linear_data[idx].first) { + rest_support = diff(rest_support, m_volumes.getCollision(0, linear_data[idx].first - counter)); dropped_down_areas[idx].emplace_back(linear_data[idx].first - counter, rest_support); counter++; } @@ -2323,123 +2260,116 @@ void TreeSupport::dropNonGraciousAreas(std::vector& support_layer_storage, std::vector& support_roof_storage, SliceDataStorage& storage) +void TreeSupport::finalizeInterfaceAndSupportAreas(const PrintObject &print_object, std::vector& support_layer_storage, std::vector& support_roof_storage) { - InterfacePreference interface_pref = config.interface_preference; // InterfacePreference::SUPPORT_LINES_OVERWRITE_INTERFACE; + InterfacePreference interface_pref = m_config.interface_preference; // InterfacePreference::SUPPORT_LINES_OVERWRITE_INTERFACE; + +#ifdef SLIC3R_TREESUPPORTS_PROGRESS double progress_total = TREE_PROGRESS_PRECALC_AVO + TREE_PROGRESS_PRECALC_COLL + TREE_PROGRESS_GENERATE_NODES + TREE_PROGRESS_AREA_CALC + TREE_PROGRESS_GENERATE_BRANCH_AREAS + TREE_PROGRESS_SMOOTH_BRANCH_AREAS; +#endif // SLIC3R_TREESUPPORTS_PROGRESS // Iterate over the generated circles in parallel and clean them up. Also add support floor. std::mutex critical_sections; tbb::parallel_for(tbb::blocked_range(0, support_layer_storage.size()), [&](const tbb::blocked_range &range) { - for (const size_t layer_idx = range.begin(); layer_idx < range.end(); ++ layer_idx) { - support_layer_storage[layer_idx] = support_layer_storage[layer_idx].unionPolygons().smooth(50); // Most of the time in this function is this union call. Can take 300+ ms when a lot of areas are to be unioned. - support_layer_storage[layer_idx].simplify(std::min(coord_t(30), config.maximum_resolution), std::min(coord_t(10), config.maximum_deviation)); // simplify a bit, to ensure the output does not contain outrageous amounts of vertices. Should not be necessary, just a precaution. + for (size_t layer_idx = range.begin(); layer_idx < range.end(); ++ layer_idx) { + // Most of the time in this function is this union call. Can take 300+ ms when a lot of areas are to be unioned. + support_layer_storage[layer_idx] = union_(support_layer_storage[layer_idx]); //FIXME .smooth(50); + // simplify a bit, to ensure the output does not contain outrageous amounts of vertices. Should not be necessary, just a precaution. + support_layer_storage[layer_idx] = polygons_simplify(support_layer_storage[layer_idx], std::min(scaled(0.03), double(m_config.resolution))); // Subtract support lines of the branches from the roof - storage.support.supportLayers[layer_idx].support_roof = storage.support.supportLayers[layer_idx].support_roof.unionPolygons(support_roof_storage[layer_idx]); - if (!storage.support.supportLayers[layer_idx].support_roof.empty() && support_layer_storage[layer_idx].intersection(storage.support.supportLayers[layer_idx].support_roof).area() > 1) - { - switch (interface_pref) - { + storage.support.supportLayers[layer_idx].support_roof = union_(storage.support.supportLayers[layer_idx].support_roof, support_roof_storage[layer_idx]); + if (!storage.support.supportLayers[layer_idx].support_roof.empty() && + area(intersection(support_layer_storage[layer_idx], storage.support.supportLayers[layer_idx].support_roof)) > tiny_area_threshold) { + switch (interface_pref) { case InterfacePreference::INTERFACE_AREA_OVERWRITES_SUPPORT: - support_layer_storage[layer_idx] = support_layer_storage[layer_idx].difference(storage.support.supportLayers[layer_idx].support_roof); + support_layer_storage[layer_idx] = diff(support_layer_storage[layer_idx], storage.support.supportLayers[layer_idx].support_roof); break; case InterfacePreference::SUPPORT_AREA_OVERWRITES_INTERFACE: - storage.support.supportLayers[layer_idx].support_roof = storage.support.supportLayers[layer_idx].support_roof.difference(support_layer_storage[layer_idx]); + storage.support.supportLayers[layer_idx].support_roof = diff(storage.support.supportLayers[layer_idx].support_roof, support_layer_storage[layer_idx]); break; +//FIXME +#if 0 case InterfacePreference::INTERFACE_LINES_OVERWRITE_SUPPORT: { - Polygons interface_lines = toPolylines(generateSupportInfillLines(storage.support.supportLayers[layer_idx].support_roof, true, layer_idx, config.support_roof_line_distance, storage.support.cross_fill_provider)).offsetPolyLine(config.support_roof_line_width / 2); - support_layer_storage[layer_idx] = support_layer_storage[layer_idx].difference(interface_lines); + // Hatch the support roof interfaces, offset them by their line width and subtract them from support base. + Polygons interface_lines = offset(to_polylines( + generateSupportInfillLines(storage.support.supportLayers[layer_idx].support_roof, true, layer_idx, m_config.support_roof_line_distance)), + m_config.support_roof_line_width / 2); + support_layer_storage[layer_idx] = diff(support_layer_storage[layer_idx], interface_lines); + break; } - break; case InterfacePreference::SUPPORT_LINES_OVERWRITE_INTERFACE: { - Polygons tree_lines; - tree_lines = tree_lines.unionPolygons(toPolylines(generateSupportInfillLines(support_layer_storage[layer_idx], false, layer_idx, config.support_line_distance, storage.support.cross_fill_provider, true)).offsetPolyLine(config.support_line_width / 2)); - storage.support.supportLayers[layer_idx].support_roof = storage.support.supportLayers[layer_idx].support_roof.difference(tree_lines); // do not draw roof where the tree is. I prefer it this way as otherwise the roof may cut of a branch from its support below. + // Hatch the support roof interfaces, offset them by their line width and subtract them from support base. + Polygons tree_lines = union_(offset(to_polylines( + generateSupportInfillLines(support_layer_storage[layer_idx], false, layer_idx, m_config.support_line_distance, true)), + m_config.support_line_width / 2)); + // do not draw roof where the tree is. I prefer it this way as otherwise the roof may cut of a branch from its support below. + storage.support.supportLayers[layer_idx].support_roof = diff(storage.support.supportLayers[layer_idx].support_roof, tree_lines); + break; } - - break; +#endif case InterfacePreference::NOTHING: break; } } // Subtract support floors from the support area and add them to the support floor instead. - if (config.support_bottom_layers > 0 && !support_layer_storage[layer_idx].empty()) - { + if (m_config.support_bottom_layers > 0 && !support_layer_storage[layer_idx].empty()) { Polygons floor_layer = storage.support.supportLayers[layer_idx].support_bottom; - Polygons layer_outset = support_layer_storage[layer_idx].offset(config.support_bottom_offset).difference(volumes_.getCollision(0, layer_idx, false)); + Polygons layer_outset = diff(offset(support_layer_storage[layer_idx], m_config.support_bottom_offset), m_volumes.getCollision(0, layer_idx, false)); size_t layers_below = 0; - while (layers_below <= config.support_bottom_layers) - { - // one sample at 0 layers below, another at config.support_bottom_layers. In-between samples at config.performance_interface_skip_layers distance from each other. - const size_t sample_layer = static_cast(std::max(0, (static_cast(layer_idx) - static_cast(layers_below)) - static_cast(config.z_distance_bottom_layers))); - constexpr bool no_support = false; - constexpr bool no_prime_tower = false; - floor_layer.add(layer_outset.intersection(storage.getLayerOutlines(sample_layer, no_support, no_prime_tower))); - if (layers_below < config.support_bottom_layers) - { - layers_below = std::min(layers_below + config.performance_interface_skip_layers, config.support_bottom_layers); - } + while (layers_below <= m_config.support_bottom_layers) { + // one sample at 0 layers below, another at m_config.support_bottom_layers. In-between samples at m_config.performance_interface_skip_layers distance from each other. + const size_t sample_layer = static_cast(std::max(0, (static_cast(layer_idx) - static_cast(layers_below)) - static_cast(m_config.z_distance_bottom_layers))); + //FIXME subtract the wipe tower + append(floor_layer, intersection(layer_outset, layer_overhangs(*print_object.get_layer(sample_layer)))); + if (layers_below < m_config.support_bottom_layers) + layers_below = std::min(layers_below + m_config.performance_interface_skip_layers, m_config.support_bottom_layers); else - { break; - } } - floor_layer = floor_layer.unionPolygons(); - storage.support.supportLayers[layer_idx].support_bottom = storage.support.supportLayers[layer_idx].support_bottom.unionPolygons(floor_layer); - support_layer_storage[layer_idx] = support_layer_storage[layer_idx].difference(floor_layer.offset(10)); // Subtract the support floor from the normal support. + floor_layer = union_(floor_layer); + storage.support.supportLayers[layer_idx].support_bottom = union_(storage.support.supportLayers[layer_idx].support_bottom, floor_layer); + support_layer_storage[layer_idx] = diff(support_layer_storage[layer_idx], offset(floor_layer, scaled(0.01))); // Subtract the support floor from the normal support. } - for (PolygonsPart part : support_layer_storage[layer_idx].splitIntoParts(true)) // Convert every part into a PolygonsPart for the support. - { - storage.support.supportLayers[layer_idx].support_infill_parts.emplace_back(part, config.support_line_width, config.support_wall_count); - } + for (const ExPolygon &part : union_ex(support_layer_storage[layer_idx])) // Convert every part into a PolygonsPart for the support. + storage.support.supportLayers[layer_idx].support_infill_parts.emplace_back(part, m_config.support_line_width, m_config.support_wall_count); +#ifdef SLIC3R_TREESUPPORTS_PROGRESS { std::lock_guard critical_section_progress(critical_sections); progress_total += TREE_PROGRESS_FINALIZE_BRANCH_AREAS / support_layer_storage.size(); - Progress::messageProgress(Progress::Stage::SUPPORT, progress_total * progress_multiplier + progress_offset, TREE_PROGRESS_TOTAL); + Progress::messageProgress(Progress::Stage::SUPPORT, progress_total * m_progress_multiplier + m_progress_offset, TREE_PROGRESS_TOTAL); } - +#endif +#if 0 { std::lock_guard critical_section_storage(critical_sections); if (!storage.support.supportLayers[layer_idx].support_infill_parts.empty() || !storage.support.supportLayers[layer_idx].support_roof.empty()) - { storage.support.layer_nr_max_filled_layer = std::max(storage.support.layer_nr_max_filled_layer, static_cast(layer_idx)); - } } +#endif } }); } -void TreeSupport::drawAreas(std::vector>& move_bounds, SliceDataStorage& storage) +void TreeSupport::drawAreas(PrintObject &print_object, std::vector> &move_bounds) { std::vector support_layer_storage(move_bounds.size()); std::vector support_roof_storage(move_bounds.size()); std::map inverese_tree_order; // in the tree structure only the parents can be accessed. Inverse this to be able to access the children. std::vector> linear_data; // All SupportElements are put into a layer independent storage to improve parallelization. Was added at a point in time where this function had performance issues. // These were fixed by creating less initial points, but i do not see a good reason to remove a working performance optimization. - for (LayerIndex layer_idx = 0; layer_idx < LayerIndex(move_bounds.size()); layer_idx++) - { - for (SupportElement* elem : move_bounds[layer_idx]) - { + for (LayerIndex layer_idx = 0; layer_idx < LayerIndex(move_bounds.size()); ++ layer_idx) { + for (SupportElement* elem : move_bounds[layer_idx]) { if ((layer_idx > 0 && ((!inverese_tree_order.count(elem) && elem->target_height == layer_idx) || (inverese_tree_order.count(elem) && inverese_tree_order[elem]->result_on_layer == Point(-1, -1))))) // we either come from nowhere at the final layer or we had invalid parents 2. should never happen but just to be sure - { continue; - } - for (SupportElement* par : elem->parents) - { - if (par->result_on_layer == Point(-1, -1)) - { - continue; - } - inverese_tree_order.emplace(par, elem); - } + if (par->result_on_layer != Point(-1, -1)) + inverese_tree_order.emplace(par, elem); linear_data.emplace_back(layer_idx, elem); } } @@ -2458,30 +2388,15 @@ void TreeSupport::drawAreas(std::vector>& move_bounds, auto t_drop = std::chrono::high_resolution_clock::now(); // single threaded combining all dropped down support areas to the right layers. ONLY COPYS DATA! for (coord_t i = 0; i < static_cast(dropped_down_areas.size()); i++) - { for (std::pair pair : dropped_down_areas[i]) - { - support_layer_storage[pair.first].add(pair.second); - } - } + append(support_layer_storage[pair.first], std::move(pair.second)); // single threaded combining all support areas to the right layers. ONLY COPYS DATA! - for (LayerIndex layer_idx = 0; layer_idx < LayerIndex(layer_tree_polygons.size()); layer_idx++) - { + for (LayerIndex layer_idx = 0; layer_idx < LayerIndex(layer_tree_polygons.size()); ++ layer_idx) for (std::pair data_pair : layer_tree_polygons[layer_idx]) - { - if (data_pair.first->missing_roof_layers > data_pair.first->distance_to_top) - { - support_roof_storage[layer_idx].add(data_pair.second); - } - else - { - support_layer_storage[layer_idx].add(data_pair.second); - } - } - } + append(data_pair.first->missing_roof_layers > data_pair.first->distance_to_top ? support_roof_storage[layer_idx] : support_layer_storage[layer_idx], std::move(data_pair.second)); - finalizeInterfaceAndSupportAreas(support_layer_storage, support_roof_storage, storage); + finalizeInterfaceAndSupportAreas(print_object, support_layer_storage, support_roof_storage); auto t_end = std::chrono::high_resolution_clock::now(); auto dur_gen_tips = 0.001 * std::chrono::duration_cast(t_generate - t_start).count(); @@ -2489,9 +2404,11 @@ void TreeSupport::drawAreas(std::vector>& move_bounds, auto dur_drop = 0.001 * std::chrono::duration_cast(t_drop - t_smooth).count(); auto dur_finalize = 0.001 * std::chrono::duration_cast(t_end - t_drop).count(); - log("Time used for drawing subfuctions: generateBranchAreas: %.3lf ms smoothBranchAreas: %.3lf ms dropNonGraciousAreas: %.3lf ms finalizeInterfaceAndSupportAreas %.3lf ms\n", dur_gen_tips, dur_smooth, dur_drop, dur_finalize); + BOOST_LOG_TRIVIAL(info) << + "Time used for drawing subfuctions: generateBranchAreas: " << dur_gen_tips << " ms " + "smoothBranchAreas: " << dur_smooth << " ms " + "dropNonGraciousAreas: " << dur_drop << " ms " + "finalizeInterfaceAndSupportAreas " << dur_finalize << " ms"; } - - } // namespace Slic3r diff --git a/src/libslic3r/TreeSupport.hpp b/src/libslic3r/TreeSupport.hpp index 04f0eb5b1..cf976b76a 100644 --- a/src/libslic3r/TreeSupport.hpp +++ b/src/libslic3r/TreeSupport.hpp @@ -10,6 +10,7 @@ #define slic3r_TreeSupport_hpp #include "TreeModelVolumes.hpp" +#include "Point.hpp" #include // For combining hashes @@ -17,18 +18,19 @@ #define SUPPORT_TREE_CIRCLE_RESOLUTION 25 // The number of vertices in each circle. -// The various stages of the process can be weighted differently in the progress bar. -// These weights are obtained experimentally using a small sample size. Sensible weights can differ drastically based on the assumed default settings and model. -#define TREE_PROGRESS_TOTAL 10000 -#define TREE_PROGRESS_PRECALC_COLL TREE_PROGRESS_TOTAL * 0.1 -#define TREE_PROGRESS_PRECALC_AVO TREE_PROGRESS_TOTAL * 0.4 -#define TREE_PROGRESS_GENERATE_NODES TREE_PROGRESS_TOTAL * 0.1 -#define TREE_PROGRESS_AREA_CALC TREE_PROGRESS_TOTAL * 0.3 -#define TREE_PROGRESS_DRAW_AREAS TREE_PROGRESS_TOTAL * 0.1 - -#define TREE_PROGRESS_GENERATE_BRANCH_AREAS TREE_PROGRESS_DRAW_AREAS / 3 -#define TREE_PROGRESS_SMOOTH_BRANCH_AREAS TREE_PROGRESS_DRAW_AREAS / 3 -#define TREE_PROGRESS_FINALIZE_BRANCH_AREAS TREE_PROGRESS_DRAW_AREAS / 3 +#ifdef SLIC3R_TREESUPPORTS_PROGRESS + // The various stages of the process can be weighted differently in the progress bar. + // These weights are obtained experimentally using a small sample size. Sensible weights can differ drastically based on the assumed default settings and model. + #define TREE_PROGRESS_TOTAL 10000 + #define TREE_PROGRESS_PRECALC_COLL TREE_PROGRESS_TOTAL * 0.1 + #define TREE_PROGRESS_PRECALC_AVO TREE_PROGRESS_TOTAL * 0.4 + #define TREE_PROGRESS_GENERATE_NODES TREE_PROGRESS_TOTAL * 0.1 + #define TREE_PROGRESS_AREA_CALC TREE_PROGRESS_TOTAL * 0.3 + #define TREE_PROGRESS_DRAW_AREAS TREE_PROGRESS_TOTAL * 0.1 + #define TREE_PROGRESS_GENERATE_BRANCH_AREAS TREE_PROGRESS_DRAW_AREAS / 3 + #define TREE_PROGRESS_SMOOTH_BRANCH_AREAS TREE_PROGRESS_DRAW_AREAS / 3 + #define TREE_PROGRESS_FINALIZE_BRANCH_AREAS TREE_PROGRESS_DRAW_AREAS / 3 +#endif // SLIC3R_TREESUPPORTS_PROGRESS #define SUPPORT_TREE_ONLY_GRACIOUS_TO_MODEL false #define SUPPORT_TREE_AVOID_SUPPORT_BLOCKER true @@ -38,16 +40,15 @@ #define SUPPORT_TREE_PRE_EXPONENTIAL_STEPS 1 #define SUPPORT_TREE_COLLISION_RESOLUTION 500 // Only has an effect if SUPPORT_TREE_USE_EXPONENTIAL_COLLISION_RESOLUTION is false -#define SUPPORT_TREE_MAX_DEVIATION 0 - namespace Slic3r { using LayerIndex = size_t; //FIXME -class SierpinskiFillProvider; - +class Print; +class PrintObject; +class SliceDataStorage; /*! * \brief Generates a tree structure to support your models. @@ -55,7 +56,7 @@ class SierpinskiFillProvider; class TreeSupport { - public: +public: using AvoidanceType = TreeModelVolumes::AvoidanceType; enum class InterfacePreference { @@ -68,10 +69,8 @@ class TreeSupport /*! * \brief Creates an instance of the tree support generator. - * - * \param storage The data storage to get global settings from. */ - TreeSupport(const SliceDataStorage& storage); + TreeSupport(); /*! * \brief Create the areas that need support. @@ -80,7 +79,7 @@ class TreeSupport * \param storage The data storage where the mesh data is gotten from and * where the resulting support areas are stored. */ - void generateSupportAreas(SliceDataStorage& storage); + void generateSupportAreas(Print &print, const BuildVolume &build_volume, std::vector& print_object_ids); //todo Remove! Only relevant for public BETA! @@ -92,29 +91,28 @@ class TreeSupport struct AreaIncreaseSettings { - AreaIncreaseSettings() : type(AvoidanceType::FAST), increase_speed(0), increase_radius(false), no_error(false), use_min_distance(false), move(false) - { - } - - AreaIncreaseSettings(AvoidanceType type, coord_t increase_speed, bool increase_radius, bool simplify, bool use_min_distance, bool move) : type(type), increase_speed(increase_speed), increase_radius(increase_radius), no_error(simplify), use_min_distance(use_min_distance), move(move) - { - } - - AvoidanceType type; - coord_t increase_speed; - bool increase_radius; - bool no_error; - bool use_min_distance; - bool move; + AvoidanceType type { AvoidanceType::FAST }; + coord_t increase_speed { 0 }; + bool increase_radius { false }; + bool no_error { false }; + bool use_min_distance { false }; + bool move { false }; bool operator==(const AreaIncreaseSettings& other) const { - return increase_radius == other.increase_radius && increase_speed == other.increase_speed && type == other.type && no_error == other.no_error && use_min_distance == other.use_min_distance && move == other.move; + return increase_radius == other.increase_radius && increase_speed == other.increase_speed && type == other.type && + no_error == other.no_error && use_min_distance == other.use_min_distance && move == other.move; } }; struct SupportElement { - SupportElement(coord_t distance_to_top, size_t target_height, Point target_position, bool to_buildplate, bool to_model_gracious, bool use_min_xy_dist, size_t dont_move_until, bool supports_roof, bool can_use_safe_radius, bool force_tips_to_roof, bool skip_ovalisation) : target_height(target_height), target_position(target_position), next_position(target_position), next_height(target_height), effective_radius_height(distance_to_top), to_buildplate(to_buildplate), distance_to_top(distance_to_top), area(nullptr), result_on_layer(target_position), increased_to_model_radius(0), to_model_gracious(to_model_gracious), elephant_foot_increases(0), use_min_xy_dist(use_min_xy_dist), supports_roof(supports_roof), dont_move_until(dont_move_until), can_use_safe_radius(can_use_safe_radius), last_area_increase(AreaIncreaseSettings(AvoidanceType::FAST, 0, false, false, false, false)), missing_roof_layers(force_tips_to_roof ? dont_move_until : 0), skip_ovalisation(skip_ovalisation) + SupportElement( + coord_t distance_to_top, size_t target_height, Point target_position, bool to_buildplate, bool to_model_gracious, bool use_min_xy_dist, size_t dont_move_until, + bool supports_roof, bool can_use_safe_radius, bool force_tips_to_roof, bool skip_ovalisation) : + target_height(target_height), target_position(target_position), next_position(target_position), next_height(target_height), effective_radius_height(distance_to_top), + to_buildplate(to_buildplate), distance_to_top(distance_to_top), area(nullptr), result_on_layer(target_position), increased_to_model_radius(0), to_model_gracious(to_model_gracious), + elephant_foot_increases(0), use_min_xy_dist(use_min_xy_dist), supports_roof(supports_roof), dont_move_until(dont_move_until), can_use_safe_radius(can_use_safe_radius), + last_area_increase(AreaIncreaseSettings{ AvoidanceType::FAST, 0, false, false, false, false }), missing_roof_layers(force_tips_to_roof ? dont_move_until : 0), skip_ovalisation(skip_ovalisation) { } @@ -205,7 +203,13 @@ class TreeSupport // set last settings to the best out of both parents. If this is wrong, it will only cause a small performance penalty instead of weird behavior. - last_area_increase = AreaIncreaseSettings(std::min(first.last_area_increase.type, second.last_area_increase.type), std::min(first.last_area_increase.increase_speed, second.last_area_increase.increase_speed), first.last_area_increase.increase_radius || second.last_area_increase.increase_radius, first.last_area_increase.no_error || second.last_area_increase.no_error, first.last_area_increase.use_min_distance && second.last_area_increase.use_min_distance, first.last_area_increase.move || second.last_area_increase.move); + last_area_increase = { + std::min(first.last_area_increase.type, second.last_area_increase.type), + std::min(first.last_area_increase.increase_speed, second.last_area_increase.increase_speed), + first.last_area_increase.increase_radius || second.last_area_increase.increase_radius, + first.last_area_increase.no_error || second.last_area_increase.no_error, + first.last_area_increase.use_min_distance && second.last_area_increase.use_min_distance, + first.last_area_increase.move || second.last_area_increase.move }; } /*! @@ -326,10 +330,7 @@ class TreeSupport if (*this == other) return false; if (other.target_height != target_height) - { return other.target_height < target_height; - } - return other.target_position.x() == target_position.x() ? other.target_position.y() < target_position.y() : other.target_position.x() < target_position.x(); } @@ -379,11 +380,10 @@ class TreeSupport roof_pattern(mesh_group_settings.support_roof_pattern), support_pattern(mesh_group_settings.support_pattern), support_roof_line_width(mesh_group_settings.support_roof_line_width), - support_line_distance(mesh_group_settings.support_line_distance), + support_line_spacing(mesh_group_settings.support_line_spacing), support_bottom_offset(mesh_group_settings.support_bottom_offset), support_wall_count(mesh_group_settings.support_wall_count), - maximum_deviation(mesh_group_settings.meshfix_maximum_deviation), - maximum_resolution(mesh_group_settings.meshfix_maximum_resolution), + resolution(mesh_group_settings.resolution), support_roof_line_distance(mesh_group_settings.support_roof_line_distance), // in the end the actual infill has to be calculated to subtract interface from support areas according to interface_preference. settings(mesh_group_settings), min_feature_size(mesh_group_settings.min_feature_size) @@ -406,28 +406,20 @@ class TreeSupport if (angles.empty()) { if (pattern == SupportMaterialInterfacePattern::smipConcentric) - { angles.push_back(0); // Concentric has no rotation. - } /* else if (pattern == SupportMaterialInterfacePattern::TRIANGLES) - { angles.push_back(90); // Triangular support interface shouldn't alternate every layer. - } */ - else - { - if (TreeSupportSettings::some_model_contains_thick_roof) - { + else { + if (TreeSupportSettings::some_model_contains_thick_roof) { // Some roofs are quite thick. // Alternate between the two kinds of diagonal: / and \ . angles.push_back(M_PI / 4.); angles.push_back(3. * M_PI / 4.); } if (angles.empty()) - { angles.push_back(M_PI / 2.); // Perpendicular to support lines. - } } } }; @@ -437,15 +429,17 @@ class TreeSupport getInterfaceAngles(support_roof_angles, roof_pattern); // const std::unordered_map interface_map = { { "support_area_overwrite_interface_area", InterfacePreference::SUPPORT_AREA_OVERWRITES_INTERFACE }, { "interface_area_overwrite_support_area", InterfacePreference::INTERFACE_AREA_OVERWRITES_SUPPORT }, { "support_lines_overwrite_interface_area", InterfacePreference::SUPPORT_LINES_OVERWRITE_INTERFACE }, { "interface_lines_overwrite_support_area", InterfacePreference::INTERFACE_LINES_OVERWRITE_SUPPORT }, { "nothing", InterfacePreference::NOTHING } }; // interface_preference = interface_map.at(mesh_group_settings.get("support_interface_priority")); - interface_preference = InterfacePreference::SUPPORT_LINES_OVERWRITE_INTERFACE; +//FIXME this was the default +// interface_preference = InterfacePreference::SUPPORT_LINES_OVERWRITE_INTERFACE; + interface_preference = InterfacePreference::SUPPORT_AREA_OVERWRITES_INTERFACE; } - private: + private: double angle; double angle_slow; std::vector known_z; - public: + public: // some static variables dependent on other meshes that are not currently processed. // Has to be static because TreeSupportConfig will be used in TreeModelVolumes as this reduces redundancy. inline static bool some_model_contains_thick_roof = false; @@ -565,7 +559,7 @@ class TreeSupport /*! * \brief Distance between support infill lines. */ - coord_t support_line_distance; + coord_t support_line_spacing; /*! * \brief Offset applied to the support floor area. */ @@ -577,11 +571,7 @@ class TreeSupport /* * \brief Maximum allowed deviation when simplifying. */ - coord_t maximum_deviation; - /* - * \brief Maximum allowed resolution (length of a line segment) when simplifying. The resolution is higher when this variable is smaller => Minimum size a line segment may have. - */ - coord_t maximum_resolution; + coord_t resolution; /* * \brief Distance between the lines of the roof. */ @@ -607,10 +597,10 @@ class TreeSupport return branch_radius == other.branch_radius && tip_layers == other.tip_layers && diameter_angle_scale_factor == other.diameter_angle_scale_factor && layer_start_bp_radius == other.layer_start_bp_radius && bp_radius == other.bp_radius && diameter_scale_bp_radius == other.diameter_scale_bp_radius && min_radius == other.min_radius && xy_min_distance == other.xy_min_distance && // as a recalculation of the collision areas is required to set a new min_radius. xy_distance - xy_min_distance == other.xy_distance - other.xy_min_distance && // if the delta of xy_min_distance and xy_distance is different the collision areas have to be recalculated. support_rests_on_model == other.support_rests_on_model && increase_radius_until_layer == other.increase_radius_until_layer && min_dtt_to_model == other.min_dtt_to_model && max_to_model_radius_increase == other.max_to_model_radius_increase && maximum_move_distance == other.maximum_move_distance && maximum_move_distance_slow == other.maximum_move_distance_slow && z_distance_bottom_layers == other.z_distance_bottom_layers && support_line_width == other.support_line_width && - support_xy_overrides_z == other.support_xy_overrides_z && support_line_distance == other.support_line_distance && support_roof_line_width == other.support_roof_line_width && // can not be set on a per-mesh basis currently, so code to enable processing different roof line width in the same iteration seems useless. + support_xy_overrides_z == other.support_xy_overrides_z && support_line_spacing == other.support_line_spacing && support_roof_line_width == other.support_roof_line_width && // can not be set on a per-mesh basis currently, so code to enable processing different roof line width in the same iteration seems useless. support_bottom_offset == other.support_bottom_offset && support_wall_count == other.support_wall_count && support_pattern == other.support_pattern && roof_pattern == other.roof_pattern && // can not be set on a per-mesh basis currently, so code to enable processing different roof patterns in the same iteration seems useless. - support_roof_angles == other.support_roof_angles && support_infill_angles == other.support_infill_angles && increase_radius_until_radius == other.increase_radius_until_radius && support_bottom_layers == other.support_bottom_layers && layer_height == other.layer_height && z_distance_top_layers == other.z_distance_top_layers && maximum_deviation == other.maximum_deviation && // Infill generation depends on deviation and resolution. - maximum_resolution == other.maximum_resolution && support_roof_line_distance == other.support_roof_line_distance && interface_preference == other.interface_preference + support_roof_angles == other.support_roof_angles && support_infill_angles == other.support_infill_angles && increase_radius_until_radius == other.increase_radius_until_radius && support_bottom_layers == other.support_bottom_layers && layer_height == other.layer_height && z_distance_top_layers == other.z_distance_top_layers && resolution == other.resolution && // Infill generation depends on deviation and resolution. + support_roof_line_distance == other.support_roof_line_distance && interface_preference == other.interface_preference && min_feature_size == other.min_feature_size // interface_preference should be identical to ensure the tree will correctly interact with the roof. // The infill class now wants the settings object and reads a lot of settings, and as the infill class is used to calculate support roof lines for interface-preference. Not all of these may be required to be identical, but as I am not sure, better safe than sorry #if 0 @@ -711,109 +701,7 @@ class TreeSupport } }; - private: - enum class LineStatus - { - INVALID, - TO_MODEL, - TO_MODEL_GRACIOUS, - TO_MODEL_GRACIOUS_SAFE, - TO_BP, - TO_BP_SAFE - }; - - using LineInformation = std::vector>; - - - /*! - * \brief Precalculates all avoidances, that could be required. - * - * \param storage[in] Background storage to access meshes. - * \param currently_processing_meshes[in] Indexes of all meshes that are processed in this iteration - */ - void precalculate(const SliceDataStorage& storage, std::vector currently_processing_meshes); - /*! - * \brief Converts a Polygons object representing a line into the internal format. - * - * \param polylines[in] The Polyline that will be converted. - * \param layer_idx[in] The current layer. - * \return All lines of the \p polylines object, with information for each point regarding in which avoidance it is currently valid in. - */ - std::vector convertLinesToInternal(Polygons polylines, LayerIndex layer_idx); - /*! - * \brief Converts lines in internal format into a Polygons object representing these lines. - * - * \param lines[in] The lines that will be converted. - * \return All lines of the \p lines object as a Polygons object. - */ - Polygons convertInternalToLines(std::vector lines); - /*! - * \brief Returns a function, evaluating if a point has to be added now. Required for a splitLines call in generateInitialAreas. - * - * \param current_layer[in] The layer on which the point lies - * \return A function that can be called to evaluate a point. - */ - std::function)> getEvaluatePointForNextLayerFunction(size_t current_layer); - /*! - * \brief Evaluates which points of some lines are not valid one layer below and which are. Assumes all points are valid on the current layer. Validity is evaluated using supplied lambda. - * - * \param lines[in] The lines that have to be evaluated. - * \param evaluatePoint[in] The function used to evaluate the points. - * \return A pair with which points are still valid in the first slot and which are not in the second slot. - */ - std::pair, std::vector> splitLines(std::vector lines, std::function)> evaluatePoint); // assumes all Points on the current line are valid - - /*! - * \brief Eensures that every line segment is about distance in length. The resulting lines may differ from the original but all points are on the original - * - * \param input[in] The lines on which evenly spaced points should be placed. - * \param distance[in] The distance the points should be from each other. - * \param min_points[in] The amount of points that have to be placed. If not enough can be placed the distance will be reduced to place this many points. - * \return A Polygons object containing the evenly spaced points. Does not represent an area, more a collection of points on lines. - */ - Polygons ensureMaximumDistancePolyline(const Polygons& input, coord_t distance, size_t min_points) const; - - /*! - * \brief Adds the implicit line from the last vertex of a Polygon to the first one. - * - * \param poly[in] The Polygons object, of which its lines should be extended. - * \return A Polygons object with implicit line from the last vertex of a Polygon to the first one added. - */ - Polygons toPolylines(const Polygons& poly) const; - - - /*! - * \brief Returns Polylines representing the (infill) lines that will result in slicing the given area - * - * \param area[in] The area that has to be filled with infill. - * \param roof[in] Whether the roofing or regular support settings should be used. - * \param layer_idx[in] The current layer index. - * \param support_infill_distance[in] The distance that should be between the infill lines. - * \param cross_fill_provider[in] A SierpinskiFillProvider required for cross infill. - * - * \return A Polygons object that represents the resulting infill lines. - */ - Polygons generateSupportInfillLines(const Polygons& area, bool roof, LayerIndex layer_idx, coord_t support_infill_distance, SierpinskiFillProvider* cross_fill_provider = nullptr, bool include_walls = false); - - /*! - * \brief Unions two Polygons. Ensures that if the input is non empty that the output also will be non empty. - * \param first[in] The first Polygon. - * \param second[in] The second Polygon. - * \return The union of both Polygons - */ - [[nodiscard]] Polygons safeUnion(const Polygons first, const Polygons second = Polygons()) const; - - /*! - * \brief Creates a valid CrossInfillProvider - * Based on AreaSupport::precomputeCrossInfillTree, but calculates for each mesh separately - * \param mesh[in] The mesh that is currently processed. - * \param line_distance[in] The distance between the infill lines of the resulting infill - * \param line_width[in] What is the width of a line used in the infill. - * \return A valid CrossInfillProvider. Has to be freed manually to avoid a memory leak. - */ - SierpinskiFillProvider* generateCrossFillProvider(const SliceMeshStorage& mesh, coord_t line_distance, coord_t line_width); - - +private: /*! * \brief Creates the initial influence areas (that can later be propagated down) by placing them below the overhang. * @@ -823,53 +711,7 @@ class TreeSupport * \param move_bounds[out] Storage for the influence areas. * \param storage[in] Background storage, required for adding roofs. */ - void generateInitialAreas(const SliceMeshStorage& mesh, std::vector>& move_bounds, SliceDataStorage& storage); - - /*! - * \brief Offsets (increases the area of) a polygons object in multiple steps to ensure that it does not lag through over a given obstacle. - * \param me[in] Polygons object that has to be offset. - * \param distance[in] The distance by which me should be offset. Expects values >=0. - * \param collision[in] The area representing obstacles. - * \param last_step_offset_without_check[in] The most it is allowed to offset in one step. - * \param min_amount_offset[in] How many steps have to be done at least. As this uses round offset this increases the amount of vertices, which may be required if Polygons get very small. Required as arcTolerance is not exposed in offset, which should result with a similar result. - * \return The resulting Polygons object. - */ - [[nodiscard]] Polygons safeOffsetInc(const Polygons& me, coord_t distance, const Polygons& collision, coord_t safe_step_size, coord_t last_step_offset_without_check, size_t min_amount_offset) const; - - - /*! - * \brief Merges Influence Areas if possible. - * - * Branches which do overlap have to be merged. This helper merges all elements in input with the elements into reduced_new_layer. - * Elements in input_aabb are merged together if possible, while elements reduced_new_layer_aabb are not checked against each other. - * - * \param reduced_aabb[in,out] The already processed elements. - * \param input_aabb[in] Not yet processed elements - * \param to_bp_areas[in] The Elements of the current Layer that will reach the buildplate. Value is the influence area where the center of a circle of support may be placed. - * \param to_model_areas[in] The Elements of the current Layer that do not have to reach the buildplate. Also contains main as every element that can reach the buildplate is not forced to. - * Value is the influence area where the center of a circle of support may be placed. - * \param influence_areas[in] The influence areas without avoidance removed. - * \param insert_bp_areas[out] Elements to be inserted into the main dictionary after the Helper terminates. - * \param insert_model_areas[out] Elements to be inserted into the secondary dictionary after the Helper terminates. - * \param insert_influence[out] Elements to be inserted into the dictionary containing the largest possibly valid influence area (ignoring if the area may not be there because of avoidance) - * \param erase[out] Elements that should be deleted from the above dictionaries. - * \param layer_idx[in] The Index of the current Layer. - */ - void mergeHelper(std::map& reduced_aabb, std::map& input_aabb, const std::unordered_map& to_bp_areas, const std::unordered_map& to_model_areas, const std::map& influence_areas, std::unordered_map& insert_bp_areas, std::unordered_map& insert_model_areas, std::unordered_map& insert_influence, std::vector& erase, const LayerIndex layer_idx); - /*! - * \brief Merges Influence Areas if possible. - * - * Branches which do overlap have to be merged. This manages the helper and uses a divide and conquer approach to parallelize this problem. This parallelization can at most accelerate the merging by a factor of 2. - * - * \param to_bp_areas[in] The Elements of the current Layer that will reach the buildplate. - * Value is the influence area where the center of a circle of support may be placed. - * \param to_model_areas[in] The Elements of the current Layer that do not have to reach the buildplate. Also contains main as every element that can reach the buildplate is not forced to. - * Value is the influence area where the center of a circle of support may be placed. - * \param influence_areas[in] The Elements of the current Layer without avoidances removed. This is the largest possible influence area for this layer. - * Value is the influence area where the center of a circle of support may be placed. - * \param layer_idx[in] The current layer. - */ - void mergeInfluenceAreas(std::unordered_map& to_bp_areas, std::unordered_map& to_model_areas, std::map& influence_areas, LayerIndex layer_idx); + void generateInitialAreas(const PrintObject &print_object, std::vector> &move_bounds); /*! * \brief Checks if an influence area contains a valid subsection and returns the corresponding metadata and the new Influence area. @@ -969,7 +811,6 @@ class TreeSupport */ void dropNonGraciousAreas(std::vector>& layer_tree_polygons, const std::vector>& linear_data, std::vector>>& dropped_down_areas, const std::map& inverse_tree_order); - /*! * \brief Generates Support Floor, ensures Support Roof can not cut of branches, and saves the branches as support to storage * @@ -977,7 +818,7 @@ class TreeSupport * \param support_roof_storage[in] Areas where support was replaced with roof. * \param storage[in,out] The storage where the support should be stored. */ - void finalizeInterfaceAndSupportAreas(std::vector& support_layer_storage, std::vector& support_roof_storage, SliceDataStorage& storage); + void finalizeInterfaceAndSupportAreas(const PrintObject &print_object, std::vector& support_layer_storage, std::vector& support_roof_storage); /*! * \brief Draws circles around result_on_layer points of the influence areas and applies some post processing. @@ -985,36 +826,36 @@ class TreeSupport * \param move_bounds[in] All currently existing influence areas * \param storage[in,out] The storage where the support should be stored. */ - void drawAreas(std::vector>& move_bounds, SliceDataStorage& storage); + void drawAreas(PrintObject &print_object, std::vector>& move_bounds); /*! * \brief Settings with the indexes of meshes that use these settings. * */ - std::vector>> grouped_meshes; + std::vector>> m_grouped_meshes; /*! * \brief Generator for model collision, avoidance and internal guide volumes. * */ - TreeModelVolumes volumes_; + TreeModelVolumes m_volumes; /*! * \brief Contains config settings to avoid loading them in every function. This was done to improve readability of the code. */ - TreeSupportSettings config; + TreeSupportSettings m_config; /*! * \brief The progress multiplier of all values added progress bar. * Required for the progress bar the behave as expected when areas have to be calculated multiple times */ - double progress_multiplier = 1; + double m_progress_multiplier = 1; /*! * \brief The progress offset added to all values communicated to the progress bar. * Required for the progress bar the behave as expected when areas have to be calculated multiple times */ - double progress_offset = 0; + double m_progress_offset = 0; }; @@ -1027,7 +868,7 @@ struct hash { size_t operator()(const Slic3r::TreeSupport::SupportElement& node) const { - size_t hash_node = hash()(node.target_position); + size_t hash_node = Slic3r::PointHash{}(node.target_position); boost::hash_combine(hash_node, size_t(node.target_height)); return hash_node; }