From 2808e41238dded9c09841a252db3b56df0fd558d Mon Sep 17 00:00:00 2001 From: PavelMikus Date: Mon, 25 Jul 2022 17:48:42 +0200 Subject: [PATCH] reworked bed adhesion model to use elastic section modulus fixed units updated bed adhesion value --- src/libslic3r/SupportSpotsGenerator.cpp | 317 ++++++++++-------------- src/libslic3r/SupportSpotsGenerator.hpp | 23 +- 2 files changed, 144 insertions(+), 196 deletions(-) diff --git a/src/libslic3r/SupportSpotsGenerator.cpp b/src/libslic3r/SupportSpotsGenerator.cpp index 28ea8d17c..b313030ac 100644 --- a/src/libslic3r/SupportSpotsGenerator.cpp +++ b/src/libslic3r/SupportSpotsGenerator.cpp @@ -272,11 +272,11 @@ struct IslandConnection { struct Island { std::unordered_map connected_islands { }; - std::vector pivot_points { }; // for support points present on this layer (or bed extrusions) float volume { }; Vec3f volume_centroid_accumulator = Vec3f::Zero(); - float sticking_force { }; // for support points present on this layer (or bed extrusions) + float sticking_area { }; // for support points present on this layer (or bed extrusions) Vec3f sticking_centroid_accumulator = Vec3f::Zero(); + Vec2f sticking_second_moment_of_area_accumulator = Vec2f::Zero(); std::vector external_lines; }; @@ -473,8 +473,8 @@ std::tuple reckon_islands( if (!layer_lines[extrusions[e].first].is_external_perimeter()) { bool island_assigned = false; for (size_t i = 0; i < islands.size(); ++i) { - size_t _idx; - Vec2f _pt; + size_t _idx = 0; + Vec2f _pt = Vec2f::Zero(); if (islands[i].signed_distance_from_lines(layer_lines[extrusions[e].first].a, _idx, _pt) < 0) { island_extrusions[i].push_back(e); island_assigned = true; @@ -530,22 +530,16 @@ std::tuple reckon_islands( * volume; if (first_layer) { - float sticking_force = line.len * flow_width * params.base_adhesion; - island.sticking_force += sticking_force; - island.sticking_centroid_accumulator += sticking_force - * to_3d(Vec2f((line.a + line.b) / 2.0f), float(layer->slice_z)); - if (line.is_external_perimeter()) { - island.pivot_points.push_back(to_3d(Vec2f(line.b), float(layer->slice_z))); - } + float sticking_area = line.len * flow_width; + island.sticking_area += sticking_area; + Vec2f middle = Vec2f((line.a + line.b) / 2.0f); + island.sticking_centroid_accumulator += sticking_area * to_3d(middle, float(layer->slice_z)); + island.sticking_second_moment_of_area_accumulator += sticking_area * middle.cwiseProduct(middle); } else if (layer_lines[lidx].support_point_generated) { - float support_interface_area = params.support_points_interface_radius - * params.support_points_interface_radius - * float(PI); - float sticking_force = support_interface_area * params.support_adhesion; - island.sticking_force += sticking_force; - island.sticking_centroid_accumulator += sticking_force - * to_3d(Vec2f(line.b), float(layer->slice_z)); - island.pivot_points.push_back(to_3d(Vec2f(line.b), float(layer->slice_z))); + float sticking_area = line.len * flow_width; + island.sticking_area += sticking_area; + island.sticking_centroid_accumulator += sticking_area * to_3d(line.b, float(layer->slice_z)); + island.sticking_second_moment_of_area_accumulator += sticking_area * line.b.cwiseProduct(line.b); } } } @@ -604,194 +598,157 @@ struct CoordinateFunctor { class ObjectPart { float volume { }; Vec3f volume_centroid_accumulator = Vec3f::Zero(); - float sticking_force { }; + float sticking_area { }; Vec3f sticking_centroid_accumulator = Vec3f::Zero(); - std::vector pivot_points { }; - - CoordinateFunctor pivots_coordinate_functor; - bool is_pivot_tree_valid = false; - KDTreeIndirect<3, float, CoordinateFunctor> pivot_tree { CoordinateFunctor { } }; - - void check_pivot_tree() { - if (!is_pivot_tree_valid) { - this->pivots_coordinate_functor = CoordinateFunctor(&this->pivot_points); - this->pivot_tree = { this->pivots_coordinate_functor }; - pivot_tree.build(pivot_points.size()); - is_pivot_tree_valid = true; - } - } + Vec2f sticking_second_moment_of_area_accumulator = Vec2f::Zero(); public: - void add(const ObjectPart &other) { - this->volume_centroid_accumulator += other.volume_centroid_accumulator; - this->volume += other.volume; - this->sticking_force += other.sticking_force; - this->sticking_centroid_accumulator += other.sticking_centroid_accumulator; - this->pivot_points.insert(this->pivot_points.end(), other.pivot_points.begin(), other.pivot_points.end()); - this->is_pivot_tree_valid = this->is_pivot_tree_valid && other.pivot_points.empty(); - } + ObjectPart() = default; ObjectPart(const Island &island) { this->volume = island.volume; this->volume_centroid_accumulator = island.volume_centroid_accumulator; - this->sticking_force = island.sticking_force; + this->sticking_area = island.sticking_area; this->sticking_centroid_accumulator = island.sticking_centroid_accumulator; - this->pivot_points = island.pivot_points; + this->sticking_second_moment_of_area_accumulator = island.sticking_second_moment_of_area_accumulator; } - ObjectPart() = default; - - std::tuple is_stable_while_extruding(const ExtrusionLine &extruded_line, float layer_z, - const Params ¶ms) { - if (pivot_points.empty()) { - return {this->volume * params.filament_density*params.gravity_constant,Vec3f {0.0f,0.0f,-1.0f}}; - } - - check_pivot_tree(); - - Vec2f line_dir = (extruded_line.b - extruded_line.a).normalized(); - Vec3f pivot_site_search_point = to_3d(Vec2f(extruded_line.b + line_dir * 300.0f), layer_z); - size_t pivot_idx = find_closest_point(this->pivot_tree, pivot_site_search_point); - const Vec3f &pivot = pivot_points[pivot_idx]; - - const Vec3f &sticking_centroid = this->sticking_centroid_accumulator / this->sticking_force; - float sticking_arm = (pivot - sticking_centroid).norm(); - float sticking_torque = sticking_arm * this->sticking_force; - - float mass = this->volume * params.filament_density; - const Vec3f &mass_centroid = this->volume_centroid_accumulator / this->volume; - float weight = mass * params.gravity_constant; - float weight_arm = (pivot.head<2>() - mass_centroid.head<2>()).norm(); - float weight_torque = weight_arm * weight; - - float bed_movement_arm = mass_centroid.z(); - float bed_movement_force = params.max_acceleration * mass; - float bed_movement_torque = bed_movement_force * bed_movement_arm; - - Vec3f extruder_pressure_direction = to_3d(line_dir, 0.0f); - extruder_pressure_direction.z() = -0.1f - extruded_line.malformation * 0.5f; - extruder_pressure_direction.normalize(); - Vec3d endpoint = (to_3d(extruded_line.b, layer_z)).cast(); - float conflict_torque_arm = line_alg::distance_to( - Linef3(endpoint, endpoint + extruder_pressure_direction.cast()), pivot.cast()); - float extruder_conflict_force = params.standard_extruder_conflict_force + - std::min(extruded_line.malformation, 1.0f) * params.malformations_additive_conflict_extruder_force; - float extruder_conflict_torque = extruder_conflict_force * conflict_torque_arm; - - float total_torque = bed_movement_torque + extruder_conflict_torque - weight_torque - sticking_torque; - -#if 1 - BOOST_LOG_TRIVIAL(debug) - << "pivot: " << pivot.x() << " " << pivot.y() << " " << pivot.z(); - BOOST_LOG_TRIVIAL(debug) - << "sticking_centroid: " << sticking_centroid.x() << " " << sticking_centroid.y() << " " - << sticking_centroid.z(); - BOOST_LOG_TRIVIAL(debug) - << "SSG: sticking_force: " << sticking_force; - BOOST_LOG_TRIVIAL(debug) - << "SSG: sticking_arm: " << sticking_arm; - BOOST_LOG_TRIVIAL(debug) - << "SSG: sticking_torque: " << sticking_torque; - BOOST_LOG_TRIVIAL(debug) - << "SSG: weight_arm: " << weight_arm; - BOOST_LOG_TRIVIAL(debug) - << "SSG: weight_torque: " << weight_torque; - BOOST_LOG_TRIVIAL(debug) - << "SSG: bed_movement_arm: " << bed_movement_arm; - BOOST_LOG_TRIVIAL(debug) - << "SSG: bed_movement_torque: " << bed_movement_torque; - BOOST_LOG_TRIVIAL(debug) - << "SSG: conflict_torque_arm: " << conflict_torque_arm; - BOOST_LOG_TRIVIAL(debug) - << "SSG: extruder_conflict_torque: " << extruder_conflict_torque; - BOOST_LOG_TRIVIAL(debug) - << "SSG: total_torque: " << total_torque << " layer_z: " << layer_z; -#endif - - return {total_torque / conflict_torque_arm, pivot_site_search_point}; + void add(const ObjectPart &other) { + this->volume_centroid_accumulator += other.volume_centroid_accumulator; + this->volume += other.volume; + this->sticking_area += other.sticking_area; + this->sticking_centroid_accumulator += other.sticking_centroid_accumulator; + this->sticking_second_moment_of_area_accumulator += other.sticking_second_moment_of_area_accumulator; } - float is_strong_enough_while_extruding( + void add_support_point(const Vec3f &position, float sticking_area) { + this->sticking_area += sticking_area; + this->sticking_centroid_accumulator += sticking_area * position; + this->sticking_second_moment_of_area_accumulator += sticking_area + * position.head<2>().cwiseProduct(position.head<2>()); + } + + float is_stable_while_extruding( const IslandConnection &connection, const ExtrusionLine &extruded_line, float layer_z, const Params ¶ms) const { Vec2f line_dir = (extruded_line.b - extruded_line.a).normalized(); - Vec3f centroid = connection.centroid_accumulator / connection.area; - Vec2f variance = (connection.second_moment_of_area_accumulator / connection.area - - centroid.head<2>().cwiseProduct(centroid.head<2>())); - variance = variance.cwiseProduct(line_dir.cwiseAbs()); - float extreme_fiber_dist = variance.cwiseSqrt().norm(); - float elastic_section_modulus = connection.area * (variance.x() + variance.y()) / extreme_fiber_dist; - float yield_torque = elastic_section_modulus * params.yield_strength; + + auto compute_elastic_section_modulus = [&line_dir]( + const Vec3f ¢roid_accumulator, const Vec2f &second_moment_of_area_accumulator, const float &area) { + Vec3f centroid = centroid_accumulator / area; + Vec2f variance = (second_moment_of_area_accumulator / area + - centroid.head<2>().cwiseProduct(centroid.head<2>())); + variance = variance.cwiseProduct(line_dir.cwiseAbs()); + float extreme_fiber_dist = variance.cwiseSqrt().norm(); + float elastic_section_modulus = area * (variance.x() + variance.y()) / extreme_fiber_dist; + return elastic_section_modulus; + }; const Vec3f &mass_centroid = this->volume_centroid_accumulator / this->volume; - float mass = this->volume * params.filament_density - * ((2.0f * layer_z - centroid.z() - mass_centroid.z()) / (2.0f * layer_z)); - + float mass = this->volume * params.filament_density; float weight = mass * params.gravity_constant; - float weight_arm = (centroid.head<2>() - mass_centroid.head<2>()).norm(); - float weight_torque = weight_arm * weight; - float bed_movement_arm = std::max(0.0f, mass_centroid.z() - centroid.z()); - float bed_movement_force = params.max_acceleration * mass; - float bed_movement_torque = bed_movement_force * bed_movement_arm; + float movement_force = params.max_acceleration * mass; Vec3f extruder_pressure_direction = to_3d(line_dir, 0.0f); extruder_pressure_direction.z() = -extruded_line.malformation * 0.5f; extruder_pressure_direction.normalize(); Vec3d endpoint = (to_3d(extruded_line.b, layer_z)).cast(); - float conflict_torque_arm = line_alg::distance_to( - Linef3(endpoint, endpoint + extruder_pressure_direction.cast()), centroid.cast()); float extruder_conflict_force = params.standard_extruder_conflict_force + std::min(extruded_line.malformation, 1.0f) * params.malformations_additive_conflict_extruder_force; - float extruder_conflict_torque = extruder_conflict_force * conflict_torque_arm; - float total_torque = bed_movement_torque + extruder_conflict_torque + weight_torque - yield_torque; + // section for bed calculations + { + Vec3f bed_centroid = this->sticking_centroid_accumulator / this->sticking_area; + float bed_yield_torque = compute_elastic_section_modulus(this->sticking_centroid_accumulator, + this->sticking_second_moment_of_area_accumulator, this->sticking_area) + * params.bed_adhesion_yield_strength; + + float bed_weight_arm = (bed_centroid.head<2>() - mass_centroid.head<2>()).norm(); + float bed_weight_torque = bed_weight_arm * weight; + + float bed_movement_arm = std::max(0.0f, mass_centroid.z() - bed_centroid.z()); + float bed_movement_torque = movement_force * bed_movement_arm; + + float bed_conflict_torque_arm = line_alg::distance_to( + Linef3(endpoint, endpoint + extruder_pressure_direction.cast()), + bed_centroid.cast()); + float bed_extruder_conflict_torque = extruder_conflict_force * bed_conflict_torque_arm; + + float bed_total_torque = bed_movement_torque + bed_extruder_conflict_torque + bed_weight_torque + - bed_yield_torque; #if 1 - BOOST_LOG_TRIVIAL(debug) - << "centroid: " << centroid.x() << " " << centroid.y() << " " << centroid.z(); - BOOST_LOG_TRIVIAL(debug) - << "mass_centroid: " << mass_centroid.x() << " " << mass_centroid.y() << " " - << mass_centroid.z(); - BOOST_LOG_TRIVIAL(debug) - << "variance: " << variance.x() << " " << variance.y(); - BOOST_LOG_TRIVIAL(debug) - << "SSG: elastic_section_modulus: " << elastic_section_modulus; - BOOST_LOG_TRIVIAL(debug) - << "SSG: yield_torque: " << yield_torque; - BOOST_LOG_TRIVIAL(debug) - << "SSG: weight_arm: " << weight_arm; - BOOST_LOG_TRIVIAL(debug) - << "SSG: weight_torque: " << weight_torque; - BOOST_LOG_TRIVIAL(debug) - << "SSG: bed_movement_arm: " << bed_movement_arm; - BOOST_LOG_TRIVIAL(debug) - << "SSG: bed_movement_torque: " << bed_movement_torque; - BOOST_LOG_TRIVIAL(debug) - << "SSG: conflict_torque_arm: " << conflict_torque_arm; - BOOST_LOG_TRIVIAL(debug) - << "SSG: extruder_conflict_torque: " << extruder_conflict_torque; - BOOST_LOG_TRIVIAL(debug) - << "SSG: total_torque: " << total_torque << " layer_z: " << layer_z; + BOOST_LOG_TRIVIAL(debug) + << "bed_centroid: " << bed_centroid.x() << " " << bed_centroid.y() << " " << bed_centroid.z(); + BOOST_LOG_TRIVIAL(debug) + << "SSG: bed_yield_torque: " << bed_yield_torque; + BOOST_LOG_TRIVIAL(debug) + << "SSG: bed_weight_arm: " << bed_weight_arm; + BOOST_LOG_TRIVIAL(debug) + << "SSG: bed_weight_torque: " << bed_weight_torque; + BOOST_LOG_TRIVIAL(debug) + << "SSG: bed_movement_arm: " << bed_movement_arm; + BOOST_LOG_TRIVIAL(debug) + << "SSG: bed_movement_torque: " << bed_movement_torque; + BOOST_LOG_TRIVIAL(debug) + << "SSG: bed_conflict_torque_arm: " << bed_conflict_torque_arm; + BOOST_LOG_TRIVIAL(debug) + << "SSG: bed_extruder_conflict_torque: " << bed_extruder_conflict_torque; + BOOST_LOG_TRIVIAL(debug) + << "SSG: total_torque: " << bed_total_torque << " layer_z: " << layer_z; #endif - return total_torque / conflict_torque_arm; - } + if (bed_total_torque > 0) + return bed_total_torque / bed_conflict_torque_arm; + } - void add_pivot_point(const Vec3f pivot_point, float sticking_force) { - this->pivot_points.push_back(pivot_point); - this->sticking_force += sticking_force; - this->sticking_centroid_accumulator += sticking_force * pivot_point; - this->is_pivot_tree_valid = false; - } + //section for weak connection calculations + { + Vec3f conn_centroid = connection.centroid_accumulator / connection.area; + float conn_yield_torque = compute_elastic_section_modulus(connection.centroid_accumulator, + connection.second_moment_of_area_accumulator, connection.area) * params.material_yield_strength; - void print() const { - std::cout << "sticking_force: " << sticking_force << std::endl; - std::cout << "volume: " << volume << std::endl; - } + float conn_weight_arm = (conn_centroid.head<2>() - mass_centroid.head<2>()).norm(); + float conn_weight_torque = conn_weight_arm * weight * (conn_centroid.z() / layer_z); + float conn_movement_arm = std::max(0.0f, mass_centroid.z() - conn_centroid.z()); + float conn_movement_torque = movement_force * conn_movement_arm; + + float conn_conflict_torque_arm = line_alg::distance_to( + Linef3(endpoint, endpoint + extruder_pressure_direction.cast()), + conn_centroid.cast()); + float conn_extruder_conflict_torque = extruder_conflict_force * conn_conflict_torque_arm; + + float conn_total_torque = conn_movement_torque + conn_extruder_conflict_torque + conn_weight_torque + - conn_yield_torque; + +#if 1 + BOOST_LOG_TRIVIAL(debug) + << "bed_centroid: " << conn_centroid.x() << " " << conn_centroid.y() << " " << conn_centroid.z(); + BOOST_LOG_TRIVIAL(debug) + << "SSG: conn_yield_torque: " << conn_yield_torque; + BOOST_LOG_TRIVIAL(debug) + << "SSG: conn_weight_arm: " << conn_weight_arm; + BOOST_LOG_TRIVIAL(debug) + << "SSG: conn_weight_torque: " << conn_weight_torque; + BOOST_LOG_TRIVIAL(debug) + << "SSG: conn_movement_arm: " << conn_movement_arm; + BOOST_LOG_TRIVIAL(debug) + << "SSG: conn_movement_torque: " << conn_movement_torque; + BOOST_LOG_TRIVIAL(debug) + << "SSG: conn_conflict_torque_arm: " << conn_conflict_torque_arm; + BOOST_LOG_TRIVIAL(debug) + << "SSG: conn_extruder_conflict_torque: " << conn_extruder_conflict_torque; + BOOST_LOG_TRIVIAL(debug) + << "SSG: total_torque: " << conn_total_torque << " layer_z: " << layer_z; +#endif + + return conn_total_torque / conn_conflict_torque_arm; + } + } }; void debug_print_graph(const std::vector &islands_graph) { @@ -803,8 +760,7 @@ void debug_print_graph(const std::vector &islands_graph) { const Island &island = islands_graph[layer_idx].islands[island_idx]; std::cout << " ISLAND " << island_idx << std::endl; std::cout << " volume: " << island.volume << std::endl; - std::cout << " sticking_force: " << island.sticking_force << std::endl; - std::cout << " pivot_points count: " << island.pivot_points.size() << std::endl; + std::cout << " sticking_area: " << island.sticking_area << std::endl; std::cout << " connected_islands count: " << island.connected_islands.size() << std::endl; } } @@ -885,7 +841,8 @@ Issues check_global_stability(SupportGridFilter supports_presence_grid, { std::unordered_set parts_ids; for (const auto &connection : island.connected_islands) { - size_t part_id = active_object_parts.get_flat_id(prev_island_to_object_part_mapping.at(connection.first)); + size_t part_id = active_object_parts.get_flat_id( + prev_island_to_object_part_mapping.at(connection.first)); parts_ids.insert(part_id); transfered_weakest_connection.add(prev_island_weakest_connection.at(connection.first)); new_weakest_connection.add(connection.second); @@ -932,7 +889,6 @@ Issues check_global_stability(SupportGridFilter supports_presence_grid, for (size_t island_idx = 0; island_idx < islands_graph[layer_idx].islands.size(); ++island_idx) { const Island &island = islands_graph[layer_idx].islands[island_idx]; ObjectPart &part = active_object_parts.access(prev_island_to_object_part_mapping[island_idx]); - part.print(); IslandConnection &weakest_conn = prev_island_weakest_connection[island_idx]; weakest_conn.print_info("weakest connection info: "); @@ -946,25 +902,22 @@ Issues check_global_stability(SupportGridFilter supports_presence_grid, unchecked_dist += line.len; } else { unchecked_dist = line.len; - auto [force, pivot_site_search_point] = part.is_stable_while_extruding(line, layer_z, params); - if (force <= 0) { - force = part.is_strong_enough_while_extruding(weakest_conn, line, layer_z, params); - } - + auto force = part.is_stable_while_extruding(weakest_conn, line, layer_z, params); if (force > 0) { if (island_lines_dist.get_lines().empty()) { island_lines_dist = LinesDistancer(island.external_lines); } Vec2f target_point; size_t _idx; + Vec3f pivot_site_search_point = to_3d(Vec2f(line.b + (line.b - line.a).normalized() * 300.0f), + layer_z); island_lines_dist.signed_distance_from_lines(pivot_site_search_point.head<2>(), _idx, target_point); Vec3f support_point = to_3d(target_point, layer_z); if (!supports_presence_grid.position_taken(support_point)) { float area = params.support_points_interface_radius * params.support_points_interface_radius * float(PI); - float sticking_force = area * params.support_adhesion; - part.add_pivot_point(support_point, sticking_force); + part.add_support_point(support_point, area); issues.support_points.emplace_back(support_point, force, to_3d(Vec2f(line.b - line.a).normalized(), 0.0f)); supports_presence_grid.take_position(support_point); diff --git a/src/libslic3r/SupportSpotsGenerator.hpp b/src/libslic3r/SupportSpotsGenerator.hpp index 081366369..531f2768b 100644 --- a/src/libslic3r/SupportSpotsGenerator.hpp +++ b/src/libslic3r/SupportSpotsGenerator.hpp @@ -8,29 +8,24 @@ namespace Slic3r { namespace SupportSpotsGenerator { struct Params { - const float gravity_constant = 9806.65f; // mm/s^2; gravity acceleration on Earth's surface, algorithm assumes that printer is in upwards position. - + // the algorithm should use the following units for all computations: distance [mm], mass [g], time [s], force [N] const float bridge_distance = 12.0f; //mm const float bridge_distance_decrease_by_curvature_factor = 5.0f; // allowed bridge distance = bridge_distance / (this factor * (curvature / PI) ) - const float min_distance_between_support_points = 3.0f; - - // Adhesion computation : from experiment, PLA holds about 3g per mm^2 of base area (with reserve); So it can withstand about 3*gravity_constant force per mm^2 - const float base_adhesion = 3.0f * gravity_constant; // adhesion per mm^2 of first layer - const float support_adhesion = 1.0f * gravity_constant; // adhesion per mm^2 of support interface layer - + const float min_distance_between_support_points = 3.0f; //mm const float support_points_interface_radius = 0.6f; // mm + const float gravity_constant = 9806.65f; // mm/s^2; gravity acceleration on Earth's surface, algorithm assumes that printer is in upwards position. const float max_acceleration = 9*1000.0f; // mm/s^2 ; max acceleration of object (bed) in XY (NOTE: The max hit is received by the object in the jerk phase, so the usual machine limits are too low) - const float filament_density = 1.25f * 0.001f; // g/mm^3 ; Common filaments are very lightweight, so precise number is not that important - const float yield_strength = 33000.0f; // mN/mm^2; 33 MPa is yield strength of ABS, which has the lowest yield strength from common materials. - const float standard_extruder_conflict_force = 1.0f * gravity_constant; // force that can occasionally push the model due to various factors (filament leaks, small curling, ... ); current value corresponds to weight of X grams - const float malformations_additive_conflict_extruder_force = 100.0f * gravity_constant; // for areas with possible high layered curled filaments - + const float filament_density = 1.25e-3f ; // g/mm^3 ; Common filaments are very lightweight, so precise number is not that important + const float bed_adhesion_yield_strength = 0.128f * 1e6f; //MPa * 1e^6 = (g*mm/s^2)/mm^2 = g/(mm*s^2); yield strength of the bed surface + const float material_yield_strength = 33.0f * 1e6f; // (g*mm/s^2)/mm^2; 33 MPa is yield strength of ABS, which has the lowest yield strength from common materials. + const float standard_extruder_conflict_force = 20.0f * gravity_constant; // force that can occasionally push the model due to various factors (filament leaks, small curling, ... ); + const float malformations_additive_conflict_extruder_force = 300.0f * gravity_constant; // for areas with possible high layered curled filaments }; struct SupportPoint { - SupportPoint(const Vec3f &position, float force,const Vec3f& direction); + SupportPoint(const Vec3f &position, float force, const Vec3f& direction); Vec3f position; float force; Vec3f direction;