From e60b8b119373cd1c0a97bb1c3812dbd0401b00e2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Martin=20=C5=A0ach?= Date: Fri, 26 Apr 2024 12:16:04 +0200 Subject: [PATCH] Seam placement improvements. Previously there was an algirithm that was fitting a curve through the resulting seam points. This worked for smooth models, but was failing for some very basic cases (such as a cylinder). The new algorithm builds on the previously implemented visibility algirithm but does not do the curve fitting anymore. Now the code is more separated for the four seam placement options (rear, random, aligned, nearest). Nearest and random are handled as one would expect. Aligned is handled in a more "brute force" manner (trying multiple seams and picking the best one) and rear smartly switches between two modes (center straight line projection and max y). --- src/libslic3r/CMakeLists.txt | 18 + src/libslic3r/GCode.cpp | 6 +- src/libslic3r/GCode.hpp | 3 +- src/libslic3r/GCode/ModelVisibility.cpp | 301 ++++ src/libslic3r/GCode/ModelVisibility.hpp | 51 + src/libslic3r/GCode/SeamAligned.cpp | 491 ++++++ src/libslic3r/GCode/SeamAligned.hpp | 96 ++ src/libslic3r/GCode/SeamChoice.cpp | 108 ++ src/libslic3r/GCode/SeamChoice.hpp | 72 + src/libslic3r/GCode/SeamGeometry.cpp | 357 +++++ src/libslic3r/GCode/SeamGeometry.hpp | 162 ++ src/libslic3r/GCode/SeamPainting.cpp | 48 + src/libslic3r/GCode/SeamPainting.hpp | 24 + src/libslic3r/GCode/SeamPerimeters.cpp | 403 +++++ src/libslic3r/GCode/SeamPerimeters.hpp | 188 +++ src/libslic3r/GCode/SeamPlacer.cpp | 1813 ++++------------------ src/libslic3r/GCode/SeamPlacer.hpp | 182 +-- src/libslic3r/GCode/SeamRandom.cpp | 136 ++ src/libslic3r/GCode/SeamRandom.hpp | 29 + src/libslic3r/GCode/SeamRear.cpp | 125 ++ src/libslic3r/GCode/SeamRear.hpp | 40 + src/libslic3r/GCode/SeamShells.cpp | 99 ++ src/libslic3r/GCode/SeamShells.hpp | 60 + src/libslic3r/Layer.cpp | 5 +- src/libslic3r/Layer.hpp | 2 + src/libslic3r/ShortEdgeCollapse.cpp | 22 +- src/libslic3r/TriangleSetSampling.cpp | 4 +- tests/data/seam_test_object.3mf | Bin 0 -> 2514963 bytes tests/fff_print/CMakeLists.txt | 8 + tests/fff_print/benchmark_seams.cpp | 124 ++ tests/fff_print/test_data.hpp | 194 ++- tests/fff_print/test_seam_aligned.cpp | 159 ++ tests/fff_print/test_seam_geometry.cpp | 145 ++ tests/fff_print/test_seam_perimeters.cpp | 180 +++ tests/fff_print/test_seam_random.cpp | 98 ++ tests/fff_print/test_seam_rear.cpp | 59 + tests/fff_print/test_seam_shells.cpp | 73 + 37 files changed, 4160 insertions(+), 1725 deletions(-) create mode 100644 src/libslic3r/GCode/ModelVisibility.cpp create mode 100644 src/libslic3r/GCode/ModelVisibility.hpp create mode 100644 src/libslic3r/GCode/SeamAligned.cpp create mode 100644 src/libslic3r/GCode/SeamAligned.hpp create mode 100644 src/libslic3r/GCode/SeamChoice.cpp create mode 100644 src/libslic3r/GCode/SeamChoice.hpp create mode 100644 src/libslic3r/GCode/SeamGeometry.cpp create mode 100644 src/libslic3r/GCode/SeamGeometry.hpp create mode 100644 src/libslic3r/GCode/SeamPainting.cpp create mode 100644 src/libslic3r/GCode/SeamPainting.hpp create mode 100644 src/libslic3r/GCode/SeamPerimeters.cpp create mode 100644 src/libslic3r/GCode/SeamPerimeters.hpp create mode 100644 src/libslic3r/GCode/SeamRandom.cpp create mode 100644 src/libslic3r/GCode/SeamRandom.hpp create mode 100644 src/libslic3r/GCode/SeamRear.cpp create mode 100644 src/libslic3r/GCode/SeamRear.hpp create mode 100644 src/libslic3r/GCode/SeamShells.cpp create mode 100644 src/libslic3r/GCode/SeamShells.hpp create mode 100644 tests/data/seam_test_object.3mf create mode 100644 tests/fff_print/benchmark_seams.cpp create mode 100644 tests/fff_print/test_seam_aligned.cpp create mode 100644 tests/fff_print/test_seam_geometry.cpp create mode 100644 tests/fff_print/test_seam_perimeters.cpp create mode 100644 tests/fff_print/test_seam_random.cpp create mode 100644 tests/fff_print/test_seam_rear.cpp create mode 100644 tests/fff_print/test_seam_shells.cpp diff --git a/src/libslic3r/CMakeLists.txt b/src/libslic3r/CMakeLists.txt index 5919143126..1ec0e1c8a0 100644 --- a/src/libslic3r/CMakeLists.txt +++ b/src/libslic3r/CMakeLists.txt @@ -177,6 +177,24 @@ set(SLIC3R_SOURCES GCode/SpiralVase.hpp GCode/SeamPlacer.cpp GCode/SeamPlacer.hpp + GCode/SeamChoice.cpp + GCode/SeamChoice.hpp + GCode/SeamPerimeters.cpp + GCode/SeamPerimeters.hpp + GCode/SeamShells.cpp + GCode/SeamShells.hpp + GCode/SeamGeometry.cpp + GCode/SeamGeometry.hpp + GCode/SeamAligned.cpp + GCode/SeamAligned.hpp + GCode/SeamRear.cpp + GCode/SeamRear.hpp + GCode/SeamRandom.cpp + GCode/SeamRandom.hpp + GCode/SeamPainting.cpp + GCode/SeamPainting.hpp + GCode/ModelVisibility.cpp + GCode/ModelVisibility.hpp GCode/SmoothPath.cpp GCode/SmoothPath.hpp GCode/ToolOrdering.cpp diff --git a/src/libslic3r/GCode.cpp b/src/libslic3r/GCode.cpp index 6a7f825815..954f96fc3e 100644 --- a/src/libslic3r/GCode.cpp +++ b/src/libslic3r/GCode.cpp @@ -1232,7 +1232,9 @@ void GCodeGenerator::_do_export(Print& print, GCodeOutputStream &file, Thumbnail // Collect custom seam data from all objects. std::function throw_if_canceled_func = [&print]() { print.throw_if_canceled();}; - m_seam_placer.init(print, throw_if_canceled_func); + + const Seams::Params params{Seams::Placer::get_params(print.full_print_config())}; + m_seam_placer.init(print.objects(), params, throw_if_canceled_func); if (! (has_wipe_tower && print.config().single_extruder_multi_material_priming)) { // Set initial extruder only after custom start G-code. @@ -2953,7 +2955,7 @@ std::string GCodeGenerator::extrude_loop(const ExtrusionLoop &loop_src, const GC Point seam_point = this->last_position.has_value() ? *this->last_position : Point::Zero(); if (!m_config.spiral_vase && comment_is_perimeter(description)) { assert(m_layer != nullptr); - seam_point = m_seam_placer.place_seam(m_layer, loop_src, m_config.external_perimeters_first, seam_point); + seam_point = m_seam_placer.place_seam(m_layer, loop_src, seam_point); } // Because the G-code export has 1um resolution, don't generate segments shorter than 1.5 microns, // thus empty path segments will not be produced by G-code export. diff --git a/src/libslic3r/GCode.hpp b/src/libslic3r/GCode.hpp index 3aa59fb286..e8342d2547 100644 --- a/src/libslic3r/GCode.hpp +++ b/src/libslic3r/GCode.hpp @@ -353,8 +353,7 @@ private: std::string set_extruder(unsigned int extruder_id, double print_z); bool line_distancer_is_required(const std::vector& extruder_ids); - // Cache for custom seam enforcers/blockers for each layer. - SeamPlacer m_seam_placer; + Seams::Placer m_seam_placer; /* Origin of print coordinates expressed in unscaled G-code coordinates. This affects the input arguments supplied to the extrude*() and travel_to() diff --git a/src/libslic3r/GCode/ModelVisibility.cpp b/src/libslic3r/GCode/ModelVisibility.cpp new file mode 100644 index 0000000000..63f3beffc3 --- /dev/null +++ b/src/libslic3r/GCode/ModelVisibility.cpp @@ -0,0 +1,301 @@ +#include + +#include "libslic3r/ShortEdgeCollapse.hpp" +#include "libslic3r/GCode/ModelVisibility.hpp" +#include "libslic3r/AABBTreeIndirect.hpp" + +namespace Slic3r::ModelInfo { +namespace Impl { + +CoordinateFunctor::CoordinateFunctor(const std::vector *coords) : coordinates(coords) {} +CoordinateFunctor::CoordinateFunctor() : coordinates(nullptr) {} + +const float &CoordinateFunctor::operator()(size_t idx, size_t dim) const { + return coordinates->operator[](idx)[dim]; +} + + +template int sgn(T val) { + return int(T(0) < val) - int(val < T(0)); +} + +/// Coordinate frame +class Frame { +public: + Frame() { + mX = Vec3f(1, 0, 0); + mY = Vec3f(0, 1, 0); + mZ = Vec3f(0, 0, 1); + } + + Frame(const Vec3f &x, const Vec3f &y, const Vec3f &z) : + mX(x), mY(y), mZ(z) { + } + + void set_from_z(const Vec3f &z) { + mZ = z.normalized(); + Vec3f tmpZ = mZ; + Vec3f tmpX = (std::abs(tmpZ.x()) > 0.99f) ? Vec3f(0, 1, 0) : Vec3f(1, 0, 0); + mY = (tmpZ.cross(tmpX)).normalized(); + mX = mY.cross(tmpZ); + } + + Vec3f to_world(const Vec3f &a) const { + return a.x() * mX + a.y() * mY + a.z() * mZ; + } + + Vec3f to_local(const Vec3f &a) const { + return Vec3f(mX.dot(a), mY.dot(a), mZ.dot(a)); + } + + const Vec3f& binormal() const { + return mX; + } + + const Vec3f& tangent() const { + return mY; + } + + const Vec3f& normal() const { + return mZ; + } + +private: + Vec3f mX, mY, mZ; +}; + +Vec3f sample_sphere_uniform(const Vec2f &samples) { + float term1 = 2.0f * float(PI) * samples.x(); + float term2 = 2.0f * sqrt(samples.y() - samples.y() * samples.y()); + return {cos(term1) * term2, sin(term1) * term2, + 1.0f - 2.0f * samples.y()}; +} + +Vec3f sample_hemisphere_uniform(const Vec2f &samples) { + float term1 = 2.0f * float(PI) * samples.x(); + float term2 = 2.0f * sqrt(samples.y() - samples.y() * samples.y()); + return {cos(term1) * term2, sin(term1) * term2, + abs(1.0f - 2.0f * samples.y())}; +} + +Vec3f sample_power_cosine_hemisphere(const Vec2f &samples, float power) { + float term1 = 2.f * float(PI) * samples.x(); + float term2 = pow(samples.y(), 1.f / (power + 1.f)); + float term3 = sqrt(1.f - term2 * term2); + + return Vec3f(cos(term1) * term3, sin(term1) * term3, term2); +} + +std::vector raycast_visibility( + const AABBTreeIndirect::Tree<3, float> &raycasting_tree, + const indexed_triangle_set &triangles, + const TriangleSetSamples &samples, + size_t negative_volumes_start_index, + const Visibility::Params ¶ms +) { + BOOST_LOG_TRIVIAL(debug) + << "SeamPlacer: raycast visibility of " << samples.positions.size() << " samples over " << triangles.indices.size() + << " triangles: end"; + + //prepare uniform samples of a hemisphere + float step_size = 1.0f / params.sqr_rays_per_sample_point; + std::vector precomputed_sample_directions( + params.sqr_rays_per_sample_point * params.sqr_rays_per_sample_point); + for (size_t x_idx = 0; x_idx < params.sqr_rays_per_sample_point; ++x_idx) { + float sample_x = x_idx * step_size + step_size / 2.0; + for (size_t y_idx = 0; y_idx < params.sqr_rays_per_sample_point; ++y_idx) { + size_t dir_index = x_idx * params.sqr_rays_per_sample_point + y_idx; + float sample_y = y_idx * step_size + step_size / 2.0; + precomputed_sample_directions[dir_index] = sample_hemisphere_uniform( { sample_x, sample_y }); + } + } + + bool model_contains_negative_parts = negative_volumes_start_index < triangles.indices.size(); + + std::vector result(samples.positions.size()); + tbb::parallel_for(tbb::blocked_range(0, result.size()), + [&triangles, &precomputed_sample_directions, model_contains_negative_parts, negative_volumes_start_index, + &raycasting_tree, &result, &samples, ¶ms](tbb::blocked_range r) { + // Maintaining hits memory outside of the loop, so it does not have to be reallocated for each query. + std::vector hits; + for (size_t s_idx = r.begin(); s_idx < r.end(); ++s_idx) { + result[s_idx] = 1.0f; + const float decrease_step = 1.0f + / (params.sqr_rays_per_sample_point * params.sqr_rays_per_sample_point); + + const Vec3f ¢er = samples.positions[s_idx]; + const Vec3f &normal = samples.normals[s_idx]; + // apply the local direction via Frame struct - the local_dir is with respect to +Z being forward + Frame f; + f.set_from_z(normal); + + for (const auto &dir : precomputed_sample_directions) { + Vec3f final_ray_dir = (f.to_world(dir)); + if (!model_contains_negative_parts) { + igl::Hit hitpoint; + // FIXME: This AABBTTreeIndirect query will not compile for float ray origin and + // direction. + Vec3d final_ray_dir_d = final_ray_dir.cast(); + Vec3d ray_origin_d = (center + normal * 0.01f).cast(); // start above surface. + bool hit = AABBTreeIndirect::intersect_ray_first_hit(triangles.vertices, + triangles.indices, raycasting_tree, ray_origin_d, final_ray_dir_d, hitpoint); + if (hit && its_face_normal(triangles, hitpoint.id).dot(final_ray_dir) <= 0) { + result[s_idx] -= decrease_step; + } + } else { //TODO improve logic for order based boolean operations - consider order of volumes + bool casting_from_negative_volume = samples.triangle_indices[s_idx] + >= negative_volumes_start_index; + + Vec3d ray_origin_d = (center + normal * 0.01f).cast(); // start above surface. + if (casting_from_negative_volume) { // if casting from negative volume face, invert direction, change start pos + final_ray_dir = -1.0 * final_ray_dir; + ray_origin_d = (center - normal * 0.01f).cast(); + } + Vec3d final_ray_dir_d = final_ray_dir.cast(); + bool some_hit = AABBTreeIndirect::intersect_ray_all_hits(triangles.vertices, + triangles.indices, raycasting_tree, + ray_origin_d, final_ray_dir_d, hits); + if (some_hit) { + int counter = 0; + // NOTE: iterating in reverse, from the last hit for one simple reason: We know the state of the ray at that point; + // It cannot be inside model, and it cannot be inside negative volume + for (int hit_index = int(hits.size()) - 1; hit_index >= 0; --hit_index) { + Vec3f face_normal = its_face_normal(triangles, hits[hit_index].id); + if (hits[hit_index].id >= int(negative_volumes_start_index)) { //negative volume hit + counter -= sgn(face_normal.dot(final_ray_dir)); // if volume face aligns with ray dir, we are leaving negative space + // which in reverse hit analysis means, that we are entering negative space :) and vice versa + } else { + counter += sgn(face_normal.dot(final_ray_dir)); + } + } + if (counter == 0) { + result[s_idx] -= decrease_step; + } + } + } + } + } + }); + + BOOST_LOG_TRIVIAL(debug) + << "SeamPlacer: raycast visibility of " << samples.positions.size() << " samples over " << triangles.indices.size() + << " triangles: end"; + + return result; +} +} + +Visibility::Visibility( + const Transform3d &obj_transform, + const ModelVolumePtrs &volumes, + const Params ¶ms, + const std::function &throw_if_canceled +) { + BOOST_LOG_TRIVIAL(debug) + << "SeamPlacer: gather occlusion meshes: start"; + indexed_triangle_set triangle_set; + indexed_triangle_set negative_volumes_set; + //add all parts + for (const ModelVolume *model_volume : volumes) { + if (model_volume->type() == ModelVolumeType::MODEL_PART + || model_volume->type() == ModelVolumeType::NEGATIVE_VOLUME) { + auto model_transformation = model_volume->get_matrix(); + indexed_triangle_set model_its = model_volume->mesh().its; + its_transform(model_its, model_transformation); + if (model_volume->type() == ModelVolumeType::MODEL_PART) { + its_merge(triangle_set, model_its); + } else { + its_merge(negative_volumes_set, model_its); + } + } + } + throw_if_canceled(); + + BOOST_LOG_TRIVIAL(debug) + << "SeamPlacer: gather occlusion meshes: end"; + + BOOST_LOG_TRIVIAL(debug) + << "SeamPlacer: decimate: start"; + its_short_edge_collpase(triangle_set, params.fast_decimation_triangle_count_target); + its_short_edge_collpase(negative_volumes_set, params.fast_decimation_triangle_count_target); + + size_t negative_volumes_start_index = triangle_set.indices.size(); + its_merge(triangle_set, negative_volumes_set); + its_transform(triangle_set, obj_transform); + BOOST_LOG_TRIVIAL(debug) + << "SeamPlacer: decimate: end"; + + BOOST_LOG_TRIVIAL(debug) + << "SeamPlacer: Compute visibility sample points: start"; + + this->mesh_samples = sample_its_uniform_parallel(params.raycasting_visibility_samples_count, + triangle_set); + this->mesh_samples_coordinate_functor = Impl::CoordinateFunctor(&this->mesh_samples.positions); + this->mesh_samples_tree = KDTreeIndirect<3, float, Impl::CoordinateFunctor>(this->mesh_samples_coordinate_functor, + this->mesh_samples.positions.size()); + + // The following code determines search area for random visibility samples on the mesh when calculating visibility of each perimeter point + // number of random samples in the given radius (area) is approximately poisson distribution + // to compute ideal search radius (area), we use exponential distribution (complementary distr to poisson) + // parameters of exponential distribution to compute area that will have with probability="probability" more than given number of samples="samples" + float probability = 0.9f; + float samples = 4; + float density = params.raycasting_visibility_samples_count / this->mesh_samples.total_area; + // exponential probability distrubtion function is : f(x) = P(X > x) = e^(l*x) where l is the rate parameter (computed as 1/u where u is mean value) + // probability that sampled area A with S samples contains more than samples count: + // P(S > samples in A) = e^-(samples/(density*A)); express A: + float search_area = samples / (-logf(probability) * density); + float search_radius = sqrt(search_area / PI); + this->mesh_samples_radius = search_radius; + + BOOST_LOG_TRIVIAL(debug) + << "SeamPlacer: Compute visiblity sample points: end"; + throw_if_canceled(); + + BOOST_LOG_TRIVIAL(debug) + << "SeamPlacer: Mesh sample raidus: " << this->mesh_samples_radius; + + BOOST_LOG_TRIVIAL(debug) + << "SeamPlacer: build AABB tree: start"; + auto raycasting_tree = AABBTreeIndirect::build_aabb_tree_over_indexed_triangle_set(triangle_set.vertices, + triangle_set.indices); + + throw_if_canceled(); + BOOST_LOG_TRIVIAL(debug) + << "SeamPlacer: build AABB tree: end"; + this->mesh_samples_visibility = Impl::raycast_visibility(raycasting_tree, triangle_set, this->mesh_samples, + negative_volumes_start_index, params); + throw_if_canceled(); +} + +float Visibility::calculate_point_visibility(const Vec3f &position) const { + std::vector points = find_nearby_points(mesh_samples_tree, position, mesh_samples_radius); + if (points.empty()) { + return 1.0f; + } + + auto compute_dist_to_plane = [](const Vec3f &position, const Vec3f &plane_origin, + const Vec3f &plane_normal) { + Vec3f orig_to_point = position - plane_origin; + return std::abs(orig_to_point.dot(plane_normal)); + }; + + float total_weight = 0; + float total_visibility = 0; + for (size_t i = 0; i < points.size(); ++i) { + size_t sample_idx = points[i]; + + Vec3f sample_point = this->mesh_samples.positions[sample_idx]; + Vec3f sample_normal = this->mesh_samples.normals[sample_idx]; + + float weight = mesh_samples_radius - + compute_dist_to_plane(position, sample_point, sample_normal); + weight += (mesh_samples_radius - (position - sample_point).norm()); + total_visibility += weight * mesh_samples_visibility[sample_idx]; + total_weight += weight; + } + + return total_visibility / total_weight; +} + +} diff --git a/src/libslic3r/GCode/ModelVisibility.hpp b/src/libslic3r/GCode/ModelVisibility.hpp new file mode 100644 index 0000000000..a6ce29fba2 --- /dev/null +++ b/src/libslic3r/GCode/ModelVisibility.hpp @@ -0,0 +1,51 @@ +#ifndef libslic3r_ModelVisibility_hpp_ +#define libslic3r_ModelVisibility_hpp_ + +#include "libslic3r/KDTreeIndirect.hpp" +#include "libslic3r/Point.hpp" +#include "libslic3r/Model.hpp" +#include "libslic3r/TriangleSetSampling.hpp" + +namespace Slic3r::ModelInfo { +namespace Impl { + +struct CoordinateFunctor +{ + const std::vector *coordinates; + CoordinateFunctor(const std::vector *coords); + CoordinateFunctor(); + + const float &operator()(size_t idx, size_t dim) const; +}; +} // namespace Impl + +struct Visibility +{ + struct Params + { + // Number of samples generated on the mesh. There are + // sqr_rays_per_sample_point*sqr_rays_per_sample_point rays casted from each samples + size_t raycasting_visibility_samples_count{}; + size_t fast_decimation_triangle_count_target{}; + // square of number of rays per sample point + size_t sqr_rays_per_sample_point{}; + }; + + Visibility( + const Transform3d &obj_transform, + const ModelVolumePtrs &volumes, + const Params ¶ms, + const std::function &throw_if_canceled + ); + + TriangleSetSamples mesh_samples; + std::vector mesh_samples_visibility; + Impl::CoordinateFunctor mesh_samples_coordinate_functor; + KDTreeIndirect<3, float, Impl::CoordinateFunctor> mesh_samples_tree{Impl::CoordinateFunctor{}}; + float mesh_samples_radius; + + float calculate_point_visibility(const Vec3f &position) const; +}; + +} // namespace Slic3r::ModelInfo +#endif // libslic3r_ModelVisibility_hpp_ diff --git a/src/libslic3r/GCode/SeamAligned.cpp b/src/libslic3r/GCode/SeamAligned.cpp new file mode 100644 index 0000000000..a2e22c6b33 --- /dev/null +++ b/src/libslic3r/GCode/SeamAligned.cpp @@ -0,0 +1,491 @@ +#include "libslic3r/GCode/SeamAligned.hpp" +#include "libslic3r/GCode/SeamGeometry.hpp" +#include "libslic3r/GCode/ModelVisibility.hpp" +#include + +namespace Slic3r::Seams::Aligned { +using Perimeters::PointType; +using Perimeters::PointClassification; + +namespace Impl { +const Perimeters::Perimeter::PointTrees &pick_trees( + const Perimeters::Perimeter &perimeter, const PointType point_type +) { + switch (point_type) { + case PointType::enforcer: return perimeter.enforced_points; + case PointType::blocker: return perimeter.blocked_points; + case PointType::common: return perimeter.common_points; + } + throw std::runtime_error("Point trees for point type do not exist."); +} + +const Perimeters::Perimeter::OptionalPointTree &pick_tree( + const Perimeters::Perimeter::PointTrees &point_trees, + const PointClassification &point_classification +) { + switch (point_classification) { + case PointClassification::overhang: return point_trees.overhanging_points; + case PointClassification::embedded: return point_trees.embedded_points; + case PointClassification::common: return point_trees.common_points; + } + throw std::runtime_error("Point tree for classification does not exist."); +} + +unsigned point_value(PointType point_type, PointClassification point_classification) { + // Better be explicit than smart. + switch (point_type) { + case PointType::enforcer: + switch (point_classification) { + case PointClassification::embedded: return 9; + case PointClassification::common: return 8; + case PointClassification::overhang: return 7; + } + case PointType::common: + switch (point_classification) { + case PointClassification::embedded: return 6; + case PointClassification::common: return 5; + case PointClassification::overhang: return 4; + } + case PointType::blocker: + switch (point_classification) { + case PointClassification::embedded: return 3; + case PointClassification::common: return 2; + case PointClassification::overhang: return 1; + } + } + return 0; +} + +SeamChoice pick_seam_option(const Perimeters::Perimeter &perimeter, const SeamOptions &options) { + const std::vector &types{perimeter.point_types}; + const std::vector &classifications{perimeter.point_classifications}; + const std::vector &positions{perimeter.positions}; + + unsigned closeset_point_value = + point_value(types.at(options.closest), classifications[options.closest]); + + if (options.snapped) { + unsigned snapped_point_value = + point_value(types.at(*options.snapped), classifications[*options.snapped]); + if (snapped_point_value >= closeset_point_value) { + const Vec2d position{positions.at(*options.snapped)}; + return {*options.snapped, *options.snapped, position}; + } + } + + unsigned adjacent_point_value = + point_value(types.at(options.adjacent), classifications[options.adjacent]); + if (adjacent_point_value < closeset_point_value) { + const Vec2d position = positions[options.closest]; + return {options.closest, options.closest, position}; + } + + const std::size_t next_index{options.adjacent_forward ? options.adjacent : options.closest}; + const std::size_t previous_index{options.adjacent_forward ? options.closest : options.adjacent}; + return {previous_index, next_index, options.on_edge}; +} + +std::optional snap_to_angle( + const Vec2d &point, + const std::size_t search_start, + const Perimeters::Perimeter &perimeter, + const double max_detour +) { + using Perimeters::AngleType; + const std::vector &positions{perimeter.positions}; + const std::vector &angle_types{perimeter.angle_types}; + + std::optional match; + double min_distance{std::numeric_limits::infinity()}; + AngleType angle_type{AngleType::convex}; + + const auto visitor{[&](const std::size_t index) { + const double distance = (positions[index] - point).norm(); + if (distance > max_detour) { + return true; + } + if (angle_types[index] == angle_type && + distance < min_distance) { + match = index; + min_distance = distance; + return true; + } + return false; + }}; + Geometry::visit_backward(search_start, positions.size(), visitor); + Geometry::visit_forward(search_start, positions.size(), visitor); + if (match) { + return match; + } + + min_distance = std::numeric_limits::infinity(); + angle_type = AngleType::concave; + + Geometry::visit_backward(search_start, positions.size(), visitor); + Geometry::visit_forward(search_start, positions.size(), visitor); + + return match; +} + +SeamOptions get_seam_options( + const Perimeters::Perimeter &perimeter, + const Vec2d &prefered_position, + const Perimeters::Perimeter::PointTree &points_tree, + const double max_detour +) { + const std::vector &positions{perimeter.positions}; + + const std::size_t closest{find_closest_point(points_tree, prefered_position.head<2>())}; + std::size_t previous{closest == 0 ? positions.size() - 1 : closest - 1}; + std::size_t next{closest == positions.size() - 1 ? 0 : closest + 1}; + + const Vec2d previous_adjacent_point{positions[previous]}; + const Vec2d closest_point{positions[closest]}; + const Vec2d next_adjacent_point{positions[next]}; + + const Linef previous_segment{previous_adjacent_point, closest_point}; + const auto [previous_point, previous_distance] = + Geometry::distance_to_segment_squared(previous_segment, prefered_position); + const Linef next_segment{closest_point, next_adjacent_point}; + const auto [next_point, next_distance] = + Geometry::distance_to_segment_squared(next_segment, prefered_position); + + const bool adjacent_forward{next_distance < previous_distance}; + const Vec2d nearest_point{adjacent_forward ? next_point : previous_point}; + const std::size_t adjacent{adjacent_forward ? next : previous}; + + std::optional snapped{ + snap_to_angle(nearest_point.head<2>(), closest, perimeter, max_detour)}; + + return { + closest, adjacent, adjacent_forward, snapped, nearest_point, + }; +} + +std::optional LeastVisible::operator()( + const Perimeters::Perimeter &perimeter, + const PointType point_type, + const PointClassification point_classification +) const { + std::optional chosen_index; + double visibility{std::numeric_limits::infinity()}; + + for (std::size_t i{0}; i < perimeter.positions.size(); ++i) { + if (perimeter.point_types[i] != point_type || + perimeter.point_classifications[i] != point_classification) { + continue; + } + const Vec2d point{perimeter.positions[i]}; + const double point_visibility{precalculated_visibility[i]}; + + if (point_visibility < visibility) { + visibility = point_visibility; + chosen_index = i; + } + } + + if (chosen_index) { + return {{*chosen_index, *chosen_index, perimeter.positions[*chosen_index]}}; + } + return std::nullopt; +} + +std::optional Nearest::operator()( + const Perimeters::Perimeter &perimeter, + const PointType point_type, + const PointClassification point_classification +) const { + const Perimeters::Perimeter::PointTrees &trees{pick_trees(perimeter, point_type)}; + const Perimeters::Perimeter::OptionalPointTree &tree = pick_tree(trees, point_classification); + if (tree) { + const SeamOptions options{get_seam_options(perimeter, prefered_position, *tree, max_detour)}; + return pick_seam_option(perimeter, options); + } + return std::nullopt; +} +} // namespace Impl + +double VisibilityCalculator::operator()( + const SeamChoice &choice, const Perimeters::Perimeter &perimeter +) const { + double visibility = points_visibility.calculate_point_visibility( + to_3d(choice.position, perimeter.slice_z).cast() + ); + + const double angle{ + choice.previous_index == choice.next_index ? perimeter.angles[choice.previous_index] : 0.0}; + visibility += + get_angle_visibility_modifier(angle, convex_visibility_modifier, concave_visibility_modifier); + return visibility; +} + +double VisibilityCalculator::get_angle_visibility_modifier( + double angle, + const double convex_visibility_modifier, + const double concave_visibility_modifier +) { + const double weight_max{angle > 0 ? convex_visibility_modifier : concave_visibility_modifier}; + angle = std::abs(angle); + const double right_angle{M_PI / 2.0}; + if (angle > right_angle) { + return -weight_max; + } + const double angle_linear_weight{angle / right_angle}; + // It is smooth and at angle 0 slope is equal to `angle linear weight`, at right angle the slope is 0 and value is equal to weight max. + const double angle_smooth_weight{angle / right_angle * weight_max + (right_angle - angle) / right_angle * angle_linear_weight}; + return -angle_smooth_weight; +} + +std::vector extract_points( + const Perimeters::Perimeter &perimeter, const Perimeters::PointType point_type +) { + std::vector result; + for (std::size_t i{0}; i < perimeter.positions.size(); ++i) { + if (perimeter.point_types[i] == point_type) { + result.push_back(perimeter.positions[i]); + } + } + return result; +} + +std::vector get_starting_positions(const Shells::Shell<> &shell) { + const Perimeters::Perimeter &perimeter{shell.front().boundary}; + + std::vector enforcers{extract_points(perimeter, Perimeters::PointType::enforcer)}; + if (!enforcers.empty()) { + return enforcers; + } + std::vector common{extract_points(perimeter, Perimeters::PointType::common)}; + if (!common.empty()) { + return common; + } + return perimeter.positions; +} + +struct LeastVisiblePoint +{ + SeamChoice choice; + double visibility; +}; + +struct SeamCandidate { + std::vector choices; + std::vector visibilities; +}; + +SeamCandidate get_seam_candidate( + const Shells::Shell<> &shell, + const Vec2d &starting_position, + const SeamChoiceVisibility &visibility_calculator, + const Params ¶ms, + const std::vector> &precalculated_visibility, + const std::vector &least_visible_points +) { + using Perimeters::Perimeter, Perimeters::AngleType; + + std::vector choice_visibilities(shell.size(), 1.0); + std::vector choices{ + Seams::get_shell_seam(shell, [&, previous_position{starting_position}](const Perimeter &perimeter, std::size_t slice_index) mutable { + SeamChoice candidate{Seams::choose_seam_point( + perimeter, Impl::Nearest{previous_position, params.max_detour} + )}; + const bool is_too_far{ + (candidate.position - previous_position).norm() > params.max_detour}; + const LeastVisiblePoint &least_visible{least_visible_points[slice_index]}; + + const bool is_on_edge{ + candidate.previous_index == candidate.next_index && + perimeter.angle_types[candidate.next_index] != AngleType::smooth}; + + if (is_on_edge) { + choice_visibilities[slice_index] = precalculated_visibility[slice_index][candidate.previous_index]; + } else { + choice_visibilities[slice_index] = + visibility_calculator(candidate, perimeter); + } + const bool is_too_visible{ + choice_visibilities[slice_index] > + least_visible.visibility + params.jump_visibility_threshold}; + const bool can_be_on_edge{ + !is_on_edge && + perimeter.angle_types[least_visible.choice.next_index] != AngleType::smooth}; + if (is_too_far || (can_be_on_edge && is_too_visible)) { + candidate = least_visible.choice; + } + previous_position = candidate.position; + return candidate; + })}; + return {std::move(choices), std::move(choice_visibilities)}; +} + +using ShellVertexVisibility = std::vector>; + +std::vector get_shells_vertex_visibility( + const Shells::Shells<> &shells, const SeamChoiceVisibility &visibility_calculator +) { + std::vector result; + + result.reserve(shells.size()); + std::transform( + shells.begin(), shells.end(), std::back_inserter(result), + [](const Shells::Shell<> &shell) { return ShellVertexVisibility(shell.size()); } + ); + + Geometry::iterate_nested(shells, [&](const std::size_t shell_index, const std::size_t slice_index) { + const Shells::Shell<> &shell{shells[shell_index]}; + const Shells::Slice<> &slice{shell[slice_index]}; + const std::vector &positions{slice.boundary.positions}; + + for (std::size_t point_index{0}; point_index < positions.size(); ++point_index) { + result[shell_index][slice_index].emplace_back(visibility_calculator( + SeamChoice{point_index, point_index, positions[point_index]}, slice.boundary + )); + } + }); + return result; +} + +using ShellLeastVisiblePoints = std::vector; + +std::vector get_shells_least_visible_points( + const Shells::Shells<> &shells, + const std::vector &precalculated_visibility +) { + std::vector result; + + result.reserve(shells.size()); + std::transform( + shells.begin(), shells.end(), std::back_inserter(result), + [](const Shells::Shell<> &shell) { return ShellLeastVisiblePoints(shell.size()); } + ); + + Geometry::iterate_nested(shells, [&](const std::size_t shell_index, const std::size_t slice_index) { + const Shells::Shell<> &shell{shells[shell_index]}; + const Shells::Slice<> &slice{shell[slice_index]}; + const SeamChoice least_visibile{ + Seams::choose_seam_point(slice.boundary, Impl::LeastVisible{precalculated_visibility[shell_index][slice_index]})}; + + const double visibility{precalculated_visibility[shell_index][slice_index][least_visibile.previous_index]}; + result[shell_index][slice_index] = LeastVisiblePoint{least_visibile, visibility}; + }); + return result; +} + +using ShellStartingPositions = std::vector; + +std::vector get_shells_starting_positions( + const Shells::Shells<> &shells +) { + std::vector result; + for (const Shells::Shell<> &shell : shells) { + std::vector starting_positions{get_starting_positions(shell)}; + result.push_back(std::move(starting_positions)); + } + return result; +} + +using ShellSeamCandidates = std::vector; + +std::vector get_shells_seam_candidates( + const Shells::Shells<> &shells, + const std::vector &starting_positions, + const SeamChoiceVisibility &visibility_calculator, + const std::vector &precalculated_visibility, + const std::vector &least_visible_points, + const Params ¶ms +) { + std::vector result; + + result.reserve(starting_positions.size()); + std::transform( + starting_positions.begin(), starting_positions.end(), std::back_inserter(result), + [](const ShellStartingPositions &positions) { return ShellSeamCandidates(positions.size()); } + ); + + Geometry::iterate_nested(starting_positions, [&](const std::size_t shell_index, const std::size_t starting_position_index){ + const Shells::Shell<> &shell{shells[shell_index]}; + using Perimeters::Perimeter, Perimeters::AngleType; + + result[shell_index][starting_position_index] = get_seam_candidate( + shell, + starting_positions[shell_index][starting_position_index], + visibility_calculator, + params, + precalculated_visibility[shell_index], + least_visible_points[shell_index] + ); + }); + return result; +} + +std::vector get_shell_seam( + const Shells::Shell<> &shell, + std::vector seam_candidates +) { + std::vector seam; + double visibility{std::numeric_limits::infinity()}; + + for (std::size_t i{0}; i < seam_candidates.size(); ++i) { + using Perimeters::Perimeter, Perimeters::AngleType; + + SeamCandidate seam_candidate{seam_candidates[i]}; + + double seam_candidate_visibility{0.0}; + for (std::size_t slice_index{}; slice_index < shell.size(); ++slice_index) { + seam_candidate_visibility += seam_candidate.visibilities[slice_index]; + } + + if (seam_candidate_visibility < visibility) { + seam = std::move(seam_candidate.choices); + visibility = seam_candidate_visibility; + } + } + + return seam; +} + +std::vector> get_object_seams( + Shells::Shells<> &&shells, + const SeamChoiceVisibility &visibility_calculator, + const Params ¶ms +) { + const std::vector precalculated_visibility{ + get_shells_vertex_visibility(shells, visibility_calculator)}; + + const std::vector least_visible_points{ + get_shells_least_visible_points(shells, precalculated_visibility) + }; + + const std::vector starting_positions{ + get_shells_starting_positions(shells) + }; + + const std::vector seam_candidates{ + get_shells_seam_candidates( + shells, + starting_positions, + visibility_calculator, + precalculated_visibility, + least_visible_points, + params + ) + }; + + std::vector> layer_seams(get_layer_count(shells)); + + for (std::size_t shell_index{0}; shell_index < shells.size(); ++shell_index) { + Shells::Shell<> &shell{shells[shell_index]}; + + std::vector seam{ + Aligned::get_shell_seam(shell, seam_candidates[shell_index])}; + + for (std::size_t perimeter_id{}; perimeter_id < shell.size(); ++perimeter_id) { + const SeamChoice &choice{seam[perimeter_id]}; + Perimeters::Perimeter &perimeter{shell[perimeter_id].boundary}; + layer_seams[shell[perimeter_id].layer_index].emplace_back(choice, std::move(perimeter)); + } + } + return layer_seams; +} + +} // namespace Slic3r::Seams::Aligned diff --git a/src/libslic3r/GCode/SeamAligned.hpp b/src/libslic3r/GCode/SeamAligned.hpp new file mode 100644 index 0000000000..d3fbebab6c --- /dev/null +++ b/src/libslic3r/GCode/SeamAligned.hpp @@ -0,0 +1,96 @@ +#ifndef libslic3r_SeamAligned_hpp_ +#define libslic3r_SeamAligned_hpp_ + +#include "libslic3r/GCode/SeamPerimeters.hpp" +#include "libslic3r/GCode/SeamChoice.hpp" +#include "libslic3r/Point.hpp" + +namespace Slic3r::ModelInfo { + struct Visibility; +} + +namespace Slic3r::Seams::Aligned { + +using SeamChoiceVisibility = std::function; + +namespace Impl { +struct SeamOptions +{ + std::size_t closest; + std::size_t adjacent; + bool adjacent_forward; + std::optional snapped; + Vec2d on_edge; +}; + +SeamChoice pick_seam_option(const Perimeters::Perimeter &perimeter, const SeamOptions &options); + +std::optional snap_to_angle( + const Vec2d &point, + const std::size_t search_start, + const Perimeters::Perimeter &perimeter, + const double max_detour +); + +SeamOptions get_seam_options( + const Perimeters::Perimeter &perimeter, + const Vec2d &prefered_position, + const Perimeters::Perimeter::PointTree &points_tree, + const double max_detour +); + +struct Nearest +{ + Vec2d prefered_position; + double max_detour; + + std::optional operator()( + const Perimeters::Perimeter &perimeter, + const Perimeters::PointType point_type, + const Perimeters::PointClassification point_classification + ) const; +}; + +struct LeastVisible +{ + std::optional operator()( + const Perimeters::Perimeter &perimeter, + const Perimeters::PointType point_type, + const Perimeters::PointClassification point_classification + ) const; + + const std::vector &precalculated_visibility; +}; +} + + +struct VisibilityCalculator +{ + const Slic3r::ModelInfo::Visibility &points_visibility; + double convex_visibility_modifier; + double concave_visibility_modifier; + + double operator()(const SeamChoice &choice, const Perimeters::Perimeter &perimeter) const; + +private: + static double get_angle_visibility_modifier( + const double angle, + const double convex_visibility_modifier, + const double concave_visibility_modifier + ); +}; + +struct Params { + double max_detour{}; + double jump_visibility_threshold{}; +}; + +std::vector> get_object_seams( + Shells::Shells<> &&shells, + const SeamChoiceVisibility& visibility_calculator, + const Params& params +); + +} // namespace Slic3r::Seams::Aligned + +#endif // libslic3r_SeamAligned_hpp_ diff --git a/src/libslic3r/GCode/SeamChoice.cpp b/src/libslic3r/GCode/SeamChoice.cpp new file mode 100644 index 0000000000..6db562e2a1 --- /dev/null +++ b/src/libslic3r/GCode/SeamChoice.cpp @@ -0,0 +1,108 @@ +#include "libslic3r/GCode/SeamChoice.hpp" + +namespace Slic3r::Seams { +std::optional maybe_choose_seam_point( + const Perimeters::Perimeter &perimeter, const SeamPicker &seam_picker +) { + using Perimeters::PointType; + using Perimeters::PointClassification; + + std::vector + type_search_order{PointType::enforcer, PointType::common, PointType::blocker}; + std::vector classification_search_order{ + PointClassification::embedded, PointClassification::common, PointClassification::overhang}; + for (const PointType point_type : type_search_order) { + for (const PointClassification point_classification : classification_search_order) { + if (std::optional seam_choice{ + seam_picker(perimeter, point_type, point_classification)}) { + return seam_choice; + } + } + } + + return std::nullopt; +} + +SeamChoice choose_seam_point(const Perimeters::Perimeter &perimeter, const SeamPicker &seam_picker) { + using Perimeters::PointType; + using Perimeters::PointClassification; + + std::optional seam_choice{maybe_choose_seam_point(perimeter, seam_picker)}; + + if (seam_choice) { + return *seam_choice; + } + + // Failed to choose any reasonable point! + return SeamChoice{0, 0, perimeter.positions.front()}; +} + +std::optional choose_degenerate_seam_point(const Perimeters::Perimeter &perimeter) { + if (!perimeter.positions.empty()) { + return SeamChoice{0, 0, perimeter.positions.front()}; + } + return std::nullopt; +} + +std::optional> maybe_get_shell_seam( + const Shells::Shell<> &shell, + const std::function(const Perimeters::Perimeter &, std::size_t)> &chooser +) { + std::vector result; + result.reserve(shell.size()); + for (std::size_t i{0}; i < shell.size(); ++i) { + const Shells::Slice<> &slice{shell[i]}; + if (slice.boundary.is_degenerate) { + if (std::optional seam_choice{ + choose_degenerate_seam_point(slice.boundary)}) { + result.push_back(*seam_choice); + } else { + result.emplace_back(); + } + } else { + const std::optional choice{chooser(slice.boundary, i)}; + if (!choice) { + return std::nullopt; + } + result.push_back(*choice); + } + } + return result; +} + +std::vector get_shell_seam( + const Shells::Shell<> &shell, + const std::function &chooser +) { + std::optional> seam{maybe_get_shell_seam( + shell, + [&](const Perimeters::Perimeter &perimeter, std::size_t slice_index) { + return chooser(perimeter, slice_index); + } + )}; + if (!seam) { + // Should be unreachable as chooser always returns a SeamChoice! + return std::vector(shell.size()); + } + return *seam; +} + +std::vector> get_object_seams( + Shells::Shells<> &&shells, + const std::function(const Shells::Shell<>&)> &get_shell_seam +) { + std::vector> layer_seams(get_layer_count(shells)); + + for (Shells::Shell<> &shell : shells) { + std::vector seam{get_shell_seam(shell)}; + + for (std::size_t perimeter_id{}; perimeter_id < shell.size(); ++perimeter_id) { + const SeamChoice &choice{seam[perimeter_id]}; + Perimeters::Perimeter &perimeter{shell[perimeter_id].boundary}; + layer_seams[shell[perimeter_id].layer_index].emplace_back(choice, std::move(perimeter)); + } + } + + return layer_seams; +} +} // namespace Slic3r::Seams diff --git a/src/libslic3r/GCode/SeamChoice.hpp b/src/libslic3r/GCode/SeamChoice.hpp new file mode 100644 index 0000000000..d33933b71f --- /dev/null +++ b/src/libslic3r/GCode/SeamChoice.hpp @@ -0,0 +1,72 @@ +#ifndef libslic3r_SeamChoice_hpp_ +#define libslic3r_SeamChoice_hpp_ + +#include "libslic3r/Polygon.hpp" +#include "libslic3r/GCode/SeamPerimeters.hpp" + +namespace Slic3r::Seams { + +/** + * When previous_index == next_index, the point is at the point. + * Otherwise the point is at the edge. + */ +struct SeamChoice +{ + std::size_t previous_index{}; + std::size_t next_index{}; + Vec2d position{Vec2d::Zero()}; +}; + +struct SeamPerimeterChoice +{ + SeamPerimeterChoice(const SeamChoice &choice, Perimeters::Perimeter &&perimeter) + : choice(choice) + , perimeter(std::move(perimeter)) + , bounding_box(Polygon{Geometry::scaled(this->perimeter.positions)}.bounding_box()) {} + + SeamChoice choice; + Perimeters::Perimeter perimeter; + BoundingBox bounding_box; +}; + +using SeamPicker = std::function(const Perimeters::Perimeter &, const Perimeters::PointType, const Perimeters::PointClassification)>; + +std::optional maybe_choose_seam_point( + const Perimeters::Perimeter &perimeter, const SeamPicker &seam_picker +); + +/** + * Go throught points on perimeter and choose the best seam point closest to + * the prefered position. + * + * Points in the perimeter can be diveded into 3x3=9 categories. An example category is + * enforced overhanging point. These categories are searched in particualr order. + * For example enforced overhang will be always choosen over common embedded point, etc. + * + * A closest point is choosen from the first non-empty category. + */ +SeamChoice choose_seam_point( + const Perimeters::Perimeter &perimeter, const SeamPicker& seam_picker +); + +std::optional choose_degenerate_seam_point(const Perimeters::Perimeter &perimeter); + +std::optional> maybe_get_shell_seam( + const Shells::Shell<> &shell, + const std::function(const Perimeters::Perimeter &, std::size_t)> &chooser +); + +std::vector get_shell_seam( + const Shells::Shell<> &shell, + const std::function &chooser +); + +std::vector> get_object_seams( + Shells::Shells<> &&shells, + const std::function(const Shells::Shell<> &)> &get_shell_seam +); + +} // namespace Slic3r::Seams + +#endif // libslic3r_SeamChoice_hpp_ diff --git a/src/libslic3r/GCode/SeamGeometry.cpp b/src/libslic3r/GCode/SeamGeometry.cpp new file mode 100644 index 0000000000..2a90668215 --- /dev/null +++ b/src/libslic3r/GCode/SeamGeometry.cpp @@ -0,0 +1,357 @@ +#include "libslic3r/GCode/SeamGeometry.hpp" +#include "KDTreeIndirect.hpp" +#include "Layer.hpp" +#include +#include +#include +#include + +namespace Slic3r::Seams::Geometry { + +namespace MappingImpl { + +/** + * @brief Return 0, 1, ..., size - 1. + */ +std::vector range(std::size_t size) { + std::vector result(size); + std::iota(result.begin(), result.end(), 0); + return result; +} + +/** + * @brief A link between lists. + */ +struct Link +{ + std::size_t bucket_id; + double weight; +}; + +/** + * @brief Get optional values. Replace any nullopt Links with new_bucket_id and increment new_bucket_id. + * + * @param links A list of optional links. + * @param new_bucket_id In-out parameter incremented on each nullopt replacement. + */ +std::vector assign_buckets( + const std::vector> &links, std::size_t &new_bucket_id +) { + std::vector result; + std::transform( + links.begin(), links.end(), std::back_inserter(result), + [&](const std::optional &link) { + if (link) { + return link->bucket_id; + } + return new_bucket_id++; + } + ); + return result; +} +} // namespace MappingImpl + +Vec2d get_normal(const Vec2d &vector) { return Vec2d{vector.y(), -vector.x()}.normalized(); } + +Vec2d get_polygon_normal( + const std::vector &points, const std::size_t index, const double min_arm_length +) { + std::optional previous_index; + std::optional next_index; + + visit_forward(index, points.size(), [&](const std::size_t index_candidate) { + if (index == index_candidate) { + return false; + } + const double distance{(points[index_candidate] - points[index]).norm()}; + if (distance > min_arm_length) { + next_index = index_candidate; + return true; + } + return false; + }); + visit_backward(index, points.size(), [&](const std::size_t index_candidate) { + const double distance{(points[index_candidate] - points[index]).norm()}; + if (distance > min_arm_length) { + previous_index = index_candidate; + return true; + } + return false; + }); + + if (previous_index && next_index) { + const Vec2d previous_normal{ + Geometry::get_normal(points.at(index) - points.at(*previous_index))}; + const Vec2d next_normal{Geometry::get_normal(points.at(*next_index) - points.at(index))}; + return (previous_normal + next_normal).normalized(); + } + return Vec2d::Zero(); +} + +std::pair distance_to_segment_squared(const Linef &segment, const Vec2d &point) { + Vec2d segment_point; + const double distance{line_alg::distance_to_squared(segment, point, &segment_point)}; + return {segment_point, distance}; +} + +std::pair get_mapping( + const std::vector &list_sizes, const MappingOperator &mapping_operator +) { + using namespace MappingImpl; + + std::vector> result; + result.reserve(list_sizes.size()); + result.push_back(range(list_sizes.front())); + + std::size_t new_bucket_id{result.back().size()}; + + for (std::size_t layer_index{0}; layer_index < list_sizes.size() - 1; ++layer_index) { + // Current layer is already assigned mapping. + + // Links on the next layer to the current layer. + std::vector> links(list_sizes[layer_index + 1]); + + for (std::size_t item_index{0}; item_index < list_sizes[layer_index]; ++item_index) { + const MappingOperatorResult next_item{ + mapping_operator(layer_index, item_index)}; + if (next_item) { + const auto [index, weight] = *next_item; + const Link link{result.back()[item_index], weight}; + if (!links[index] || links[index]->weight < link.weight) { + links[index] = link; + } + } + } + result.push_back(assign_buckets(links, new_bucket_id)); + } + return {result, new_bucket_id}; +} + +Extrusion::Extrusion(BoundingBox bounding_box, const double width, const ExPolygon &island_boundary) + : bounding_box(std::move(bounding_box)), width(width), island_boundary(island_boundary) { + + this->island_boundary_bounding_boxes.push_back(island_boundary.contour.bounding_box()); + + std::transform( + this->island_boundary.holes.begin(), this->island_boundary.holes.end(), + std::back_inserter(this->island_boundary_bounding_boxes), + [](const Polygon &polygon) { return polygon.bounding_box(); } + ); +} + +Geometry::Extrusions get_external_perimeters(const Slic3r::Layer &layer, const LayerSlice &slice) { + std::vector result; + for (const LayerIsland &island : slice.islands) { + const LayerRegion &layer_region = *layer.get_region(island.perimeters.region()); + for (const uint32_t perimeter_id : island.perimeters) { + const auto collection{static_cast( + layer_region.perimeters().entities[perimeter_id] + )}; + for (const ExtrusionEntity *entity : *collection) { + if (entity->role().is_external_perimeter()) { + const BoundingBox bounding_box{entity->as_polyline().points}; + const double width{layer_region.flow(FlowRole::frExternalPerimeter).width()}; + result.emplace_back(bounding_box, width, island.boundary); + } + } + } + } + return result; +} + +std::vector get_extrusions(tcb::span object_layers) { + std::vector result; + result.reserve(object_layers.size()); + + for (const Slic3r::Layer *object_layer : object_layers) { + Extrusions extrusions; + + for (const LayerSlice &slice : object_layer->lslices_ex) { + std::vector external_perimeters{ + get_external_perimeters(*object_layer, slice)}; + for (Geometry::Extrusion &extrusion : external_perimeters) { + extrusions.push_back(std::move(extrusion)); + } + } + + result.push_back(std::move(extrusions)); + } + + return result; +} + +std::vector oversample_edge(const Vec2d &from, const Vec2d &to, const double max_distance) { + const double total_distance{(from - to).norm()}; + const auto points_count{static_cast(std::ceil(total_distance / max_distance)) + 1}; + if (points_count < 3) { + return {}; + } + const double step_size{total_distance / (points_count - 1)}; + const Vec2d step_vector{step_size * (to - from).normalized()}; + std::vector result; + result.reserve(points_count - 2); + for (std::size_t i{1}; i < points_count - 1; ++i) { + result.push_back(from + i * step_vector); + } + return result; +} + +void visit_forward( + const std::size_t start_index, + const std::size_t loop_size, + const std::function &visitor +) { + std::size_t last_index{loop_size - 1}; + std::size_t index{start_index}; + for (unsigned _{0}; _ < 30; ++_) { // Infinite loop prevention + if (visitor(index)) { + return; + } + index = index == last_index ? 0 : index + 1; + } + assert(false); +} + +void visit_backward( + const std::size_t start_index, + const std::size_t loop_size, + const std::function &visitor +) { + std::size_t last_index{loop_size - 1}; + std::size_t index{start_index == 0 ? loop_size - 1 : start_index - 1}; + for (unsigned _{0}; _ < 30; ++_) { // Infinite loop prevention + if (visitor(index)) { + return; + } + index = index == 0 ? last_index : index - 1; + } + assert(false); +} + +std::vector unscaled(const Points &points) { + std::vector result; + result.reserve(points.size()); + using std::transform, std::begin, std::end, std::back_inserter; + transform(begin(points), end(points), back_inserter(result), [](const Point &point) { + return unscaled(point); + }); + return result; +} + +std::vector unscaled(const Lines &lines) { + std::vector result; + result.reserve(lines.size()); + std::transform(lines.begin(), lines.end(), std::back_inserter(result), [](const Line &line) { + return Linef{unscaled(line.a), unscaled(line.b)}; + }); + return result; +} + +Points scaled(const std::vector &points) { + Points result; + for (const Vec2d &point : points) { + result.push_back(Slic3r::scaled(point)); + } + return result; +} + +std::vector get_embedding_distances( + const std::vector &points, const AABBTreeLines::LinesDistancer &perimeter_distancer +) { + std::vector result; + result.reserve(points.size()); + using std::transform, std::back_inserter; + transform(points.begin(), points.end(), back_inserter(result), [&](const Vec2d &point) { + const double distance{perimeter_distancer.distance_from_lines(point)}; + return distance < 0 ? -distance : 0.0; + }); + return result; +} + +std::vector get_overhangs( + const std::vector &points, + const AABBTreeLines::LinesDistancer &previous_layer_perimeter_distancer, + const double layer_height +) { + std::vector result; + result.reserve(points.size()); + using std::transform, std::back_inserter; + transform(points.begin(), points.end(), back_inserter(result), [&](const Vec2d &point) { + const double distance{previous_layer_perimeter_distancer.distance_from_lines(point)}; + return distance > 0 ? M_PI / 2 - std::atan(layer_height / distance) : 0.0; + }); + return result; +} + +// Measured from outside, convex is positive +std::vector get_vertex_angles(const std::vector &points, const double min_arm_length) { + std::vector result; + result.reserve(points.size()); + + for (std::size_t index{0}; index < points.size(); ++index) { + std::optional previous_index; + std::optional next_index; + + visit_forward(index, points.size(), [&](const std::size_t index_candidate) { + if (index == index_candidate) { + return false; + } + const double distance{(points[index_candidate] - points[index]).norm()}; + if (distance > min_arm_length) { + next_index = index_candidate; + return true; + } + return false; + }); + visit_backward(index, points.size(), [&](const std::size_t index_candidate) { + const double distance{(points[index_candidate] - points[index]).norm()}; + if (distance > min_arm_length) { + previous_index = index_candidate; + return true; + } + return false; + }); + + if (previous_index && next_index) { + const Vec2d &previous_point = points[*previous_index]; + const Vec2d &point = points[index]; + const Vec2d &next_point = points[*next_index]; + result.push_back(-angle((point - previous_point), (next_point - point))); + } else { + result.push_back(0.0); + } + } + + return result; +} + +std::pair pick_closest_bounding_box( + const BoundingBox &to, const BoundingBoxes &choose_from +) { + double min_distance{std::numeric_limits::infinity()}; + std::size_t choosen_index{0}; + + for (std::size_t i{0}; i < choose_from.size(); ++i) { + const BoundingBox &candidate{choose_from[i]}; + const double bb_max_distance{unscaled(Point{candidate.max - to.max}).norm()}; + const double bb_min_distance{unscaled(Point{candidate.min - to.min}).norm()}; + const double distance{std::max(bb_max_distance, bb_min_distance)}; + + if (distance < min_distance) { + choosen_index = i; + min_distance = distance; + } + } + return {choosen_index, min_distance}; +} + +Polygon to_polygon(const ExtrusionLoop &loop) { + Points loop_points{}; + for (const ExtrusionPath &path : loop.paths) { + for (const Point &point : path.polyline.points) { + loop_points.push_back(point); + } + } + return Polygon{loop_points}; +} +} // namespace Slic3r::Seams::Geometry diff --git a/src/libslic3r/GCode/SeamGeometry.hpp b/src/libslic3r/GCode/SeamGeometry.hpp new file mode 100644 index 0000000000..219fd1a4fe --- /dev/null +++ b/src/libslic3r/GCode/SeamGeometry.hpp @@ -0,0 +1,162 @@ +#ifndef libslic3r_SeamGeometry_hpp_ +#define libslic3r_SeamGeometry_hpp_ + +#include "libslic3r/ExtrusionEntity.hpp" +#include "libslic3r/ExPolygon.hpp" +#include "libslic3r/AABBTreeLines.hpp" +#include "libslic3r/Point.hpp" +#include +#include +#include +#include "tcbspan/span.hpp" + +namespace Slic3r { +class Layer; +} + +namespace Slic3r::Seams::Geometry { + +struct Extrusion +{ + Extrusion(BoundingBox bounding_box, const double width, const ExPolygon &island_boundary); + + Extrusion(const Extrusion &) = delete; + Extrusion(Extrusion &&) = default; + Extrusion &operator=(const Extrusion &) = delete; + Extrusion &operator=(Extrusion &&) = delete; + + BoundingBox bounding_box; + double width; + const ExPolygon &island_boundary; + + // At index 0 there is the bounding box of contour. Rest are the bounding boxes of holes in order. + BoundingBoxes island_boundary_bounding_boxes; +}; + +using Extrusions = std::vector; + +std::vector get_extrusions(tcb::span object_layers); + +Vec2d get_polygon_normal( + const std::vector &points, const std::size_t index, const double min_arm_length +); + +Vec2d get_normal(const Vec2d &vector); + +std::pair distance_to_segment_squared(const Linef &segment, const Vec2d &point); + +using Mapping = std::vector>; +using MappingOperatorResult = std::optional>; +using MappingOperator = std::function; + +/** + * @brief Indirectly map list of lists into buckets. + * + * Look for chains of items accross the lists. + * It may do this mapping: [[1, 2], [3, 4, 5], [6]] -> [[1, 4, 6], [2, 3], [5]]. + * It depends on the weights provided by the mapping operator. + * + * Same bucket cannot be choosen for multiple items in any of the inner lists. + * Bucket is choosen **based on the weight** provided by the mapping operator. Multiple items from + * the same list may want to claim the same bucket. In that case, the item with the biggest weight + * wins the bucket. For example: [[1, 2], [3]] -> [[1, 3], [2]] + * + * @param list_sizes Vector of sizes of the original lists in a list. + * @param mapping_operator Operator that takes layer index and item index on that layer as input + * and returns the best fitting item index from the next layer, along with weight, representing how + * good the fit is. It may return nullopt if there is no good fit. + * + * @return Mapping [outter_list_index][inner_list_index] -> bucket id and the number of buckets. + */ +std::pair get_mapping( + const std::vector &list_sizes, const MappingOperator &mapping_operator +); + +std::vector oversample_edge(const Vec2d &from, const Vec2d &to, const double max_distance); + +template +std::size_t get_flat_size(const NestedVector &nested_vector) { + return std::accumulate( + nested_vector.begin(), nested_vector.end(), std::size_t{0}, + [](const std::size_t sum, const auto &vector) { return sum + vector.size(); } + ); +} + +template +std::vector> get_flat_index2indices_table( + const NestedVector &nested_vector +) { + std::vector> result; + for (std::size_t parent_index{0}; parent_index < nested_vector.size(); ++parent_index) { + const auto &vector{nested_vector[parent_index]}; + for (std::size_t nested_index{0}; nested_index < vector.size(); ++nested_index) { + result.push_back({parent_index, nested_index}); + } + } + return result; +} + +template +void iterate_nested(const NestedVector &nested_vector, const std::function &function) { + std::size_t flat_size{Geometry::get_flat_size(nested_vector)}; + using Range = tbb::blocked_range; + const Range range{0, flat_size}; + + std::vector> index_table{ + get_flat_index2indices_table(nested_vector)}; + + // Iterate the shells as if it was flat. + tbb::parallel_for(range, [&](Range range) { + for (std::size_t index{range.begin()}; index < range.end(); ++index) { + const auto[parent_index, nested_index]{index_table[index]}; + function(parent_index, nested_index); + } + }); +} + +void visit_forward( + const std::size_t start_index, + const std::size_t loop_size, + const std::function &visitor +); +void visit_backward( + const std::size_t start_index, + const std::size_t loop_size, + const std::function &visitor +); + +std::vector unscaled(const Points &points); + +std::vector unscaled(const Lines &lines); + +Points scaled(const std::vector &points); + +std::vector get_embedding_distances( + const std::vector &points, const AABBTreeLines::LinesDistancer &perimeter_distancer +); + +/** + * @brief Calculate overhang angle for each of the points over the previous layer perimeters. + * + * Larger angle <=> larger overhang. E.g. floating box has overhang = PI / 2. + * + * @returns Angles in radians <0, PI / 2>. + */ +std::vector get_overhangs( + const std::vector &points, + const AABBTreeLines::LinesDistancer &previous_layer_perimeter_distancer, + const double layer_height +); + +// Measured from outside, convex is positive +std::vector get_vertex_angles(const std::vector &points, const double min_arm_length); + +std::pair pick_closest_bounding_box( + const BoundingBox &to, const BoundingBoxes &choose_from +); + +Polygon to_polygon(const ExtrusionLoop &loop); + +} // namespace Slic3r::Seams::Geometry + +#endif // libslic3r_SeamGeometry_hpp_ diff --git a/src/libslic3r/GCode/SeamPainting.cpp b/src/libslic3r/GCode/SeamPainting.cpp new file mode 100644 index 0000000000..1f78eb5098 --- /dev/null +++ b/src/libslic3r/GCode/SeamPainting.cpp @@ -0,0 +1,48 @@ +#include "libslic3r/GCode/SeamPainting.hpp" + +namespace Slic3r::Seams::ModelInfo { +Painting::Painting(const Transform3d &obj_transform, const ModelVolumePtrs &volumes) { + for (const ModelVolume *mv : volumes) { + if (mv->is_seam_painted()) { + auto model_transformation = obj_transform * mv->get_matrix(); + + indexed_triangle_set enforcers = mv->seam_facets + .get_facets(*mv, EnforcerBlockerType::ENFORCER); + its_transform(enforcers, model_transformation); + its_merge(this->enforcers, enforcers); + + indexed_triangle_set blockers = mv->seam_facets + .get_facets(*mv, EnforcerBlockerType::BLOCKER); + its_transform(blockers, model_transformation); + its_merge(this->blockers, blockers); + } + } + + this->enforcers_tree = AABBTreeIndirect::build_aabb_tree_over_indexed_triangle_set( + this->enforcers.vertices, this->enforcers.indices + ); + this->blockers_tree = AABBTreeIndirect::build_aabb_tree_over_indexed_triangle_set( + this->blockers.vertices, this->blockers.indices + ); +} + +bool Painting::is_enforced(const Vec3f &position, float radius) const { + if (enforcers.empty()) { + return false; + } + float radius_sqr = radius * radius; + return AABBTreeIndirect::is_any_triangle_in_radius( + enforcers.vertices, enforcers.indices, enforcers_tree, position, radius_sqr + ); +} + +bool Painting::is_blocked(const Vec3f &position, float radius) const { + if (blockers.empty()) { + return false; + } + float radius_sqr = radius * radius; + return AABBTreeIndirect::is_any_triangle_in_radius( + blockers.vertices, blockers.indices, blockers_tree, position, radius_sqr + ); +} +} // namespace Slic3r::Seams::ModelInfo diff --git a/src/libslic3r/GCode/SeamPainting.hpp b/src/libslic3r/GCode/SeamPainting.hpp new file mode 100644 index 0000000000..a6fa6ff8d0 --- /dev/null +++ b/src/libslic3r/GCode/SeamPainting.hpp @@ -0,0 +1,24 @@ +#ifndef libslic3r_GlobalModelInfo_hpp_ +#define libslic3r_GlobalModelInfo_hpp_ + +#include "libslic3r/AABBTreeIndirect.hpp" +#include "libslic3r/Point.hpp" +#include "libslic3r/Model.hpp" + +namespace Slic3r::Seams::ModelInfo { +class Painting +{ +public: + Painting(const Transform3d &obj_transform, const ModelVolumePtrs &volumes); + + bool is_enforced(const Vec3f &position, float radius) const; + bool is_blocked(const Vec3f &position, float radius) const; + +private: + indexed_triangle_set enforcers; + indexed_triangle_set blockers; + AABBTreeIndirect::Tree<3, float> enforcers_tree; + AABBTreeIndirect::Tree<3, float> blockers_tree; +}; +} // namespace Slic3r::Seams::ModelInfo +#endif // libslic3r_GlobalModelInfo_hpp_ diff --git a/src/libslic3r/GCode/SeamPerimeters.cpp b/src/libslic3r/GCode/SeamPerimeters.cpp new file mode 100644 index 0000000000..e83b694afd --- /dev/null +++ b/src/libslic3r/GCode/SeamPerimeters.cpp @@ -0,0 +1,403 @@ +#include + +#include "ClipperUtils.hpp" + +#include "libslic3r/Layer.hpp" + +#include "libslic3r/GCode/SeamGeometry.hpp" +#include "libslic3r/GCode/SeamPerimeters.hpp" + +namespace Slic3r::Seams::Perimeters::Impl { + +std::vector oversample_painted( + const std::vector &points, + const std::function &is_painted, + const double slice_z, + const double max_distance +) { + std::vector result; + + for (std::size_t index{0}; index < points.size(); ++index) { + const Vec2d &point{points[index]}; + + result.push_back(point); + + const std::size_t next_index{index == points.size() - 1 ? 0 : index + 1}; + const Vec2d &next_point{points[next_index]}; + const float next_point_distance{static_cast((point - next_point).norm())}; + const Vec2d middle_point{(point + next_point) / 2.0}; + Vec3f point3d{to_3d(middle_point, slice_z).cast()}; + if (is_painted(point3d, next_point_distance / 2.0)) { + for (const Vec2d &edge_point : + Geometry::oversample_edge(point, next_point, max_distance)) { + result.push_back(edge_point); + } + } + } + return result; +} + +std::pair, std::vector> remove_redundant_points( + const std::vector &points, + const std::vector &point_types, + const double tolerance +) { + std::vector points_result; + std::vector point_types_result; + + auto range_start{points.begin()}; + + for (auto iterator{points.begin()}; iterator != points.end(); ++iterator) { + const std::int64_t index{std::distance(points.begin(), iterator)}; + if (next(iterator) == points.end() || point_types[index] != point_types[index + 1]) { + std::vector simplification_result; + douglas_peucker( + range_start, next(iterator), std::back_inserter(simplification_result), tolerance, + [](const Vec2d &point) { return point; } + ); + + points_result.insert( + points_result.end(), simplification_result.begin(), simplification_result.end() + ); + const std::vector + point_types_to_add(simplification_result.size(), point_types[index]); + point_types_result.insert( + point_types_result.end(), point_types_to_add.begin(), point_types_to_add.end() + ); + + range_start = next(iterator); + } + } + + return {points_result, point_types_result}; +} + +std::vector get_point_types( + const std::vector &positions, + const ModelInfo::Painting &painting, + const double slice_z, + const double painting_radius +) { + std::vector result; + result.reserve(positions.size()); + using std::transform, std::back_inserter; + transform( + positions.begin(), positions.end(), back_inserter(result), + [&](const Vec2d &point) { + const Vec3f point3d{to_3d(point.cast(), static_cast(slice_z))}; + if (painting.is_blocked(point3d, painting_radius)) { + return PointType::blocker; + } + if (painting.is_enforced(point3d, painting_radius)) { + return PointType::enforcer; + } + return PointType::common; + } + ); + return result; +} + +std::vector classify_points( + const std::vector &embeddings, + const std::optional> &overhangs, + const double overhang_threshold, + const double embedding_threshold +) { + std::vector result; + result.reserve(embeddings.size()); + using std::transform, std::back_inserter; + transform( + embeddings.begin(), embeddings.end(), back_inserter(result), + [&, i = 0](const double embedding) mutable { + const unsigned index = i++; + if (overhangs && overhangs->operator[](index) > overhang_threshold) { + return PointClassification::overhang; + } + if (embedding > embedding_threshold) { + return PointClassification::embedded; + } + return PointClassification::common; + } + ); + return result; +} + +std::vector get_angle_types( + const std::vector &angles, const double convex_threshold, const double concave_threshold +) { + std::vector result; + using std::transform, std::back_inserter; + transform(angles.begin(), angles.end(), back_inserter(result), [&](const double angle) { + if (angle > convex_threshold) { + return AngleType::convex; + } + if (angle < -concave_threshold) { + return AngleType::concave; + } + return AngleType::smooth; + }); + return result; +} + +std::vector merge_angle_types( + const std::vector &angle_types, + const std::vector &smooth_angle_types, + const std::vector &points, + const double min_arm_length +) { + std::vector result; + result.reserve(angle_types.size()); + for (std::size_t index{0}; index < angle_types.size(); ++index) { + const AngleType &angle_type{angle_types[index]}; + const AngleType &smooth_angle_type{smooth_angle_types[index]}; + + AngleType resulting_type{angle_type}; + + if (smooth_angle_type != angle_type && smooth_angle_type != AngleType::smooth) { + resulting_type = smooth_angle_type; + + // Check if there is a sharp angle in the vicinity. If so, do not use the smooth angle. + Geometry::visit_forward(index, angle_types.size(), [&](const std::size_t forward_index) { + const double distance{(points[forward_index] - points[index]).norm()}; + if (distance > min_arm_length) { + return true; + } + if (angle_types[forward_index] == smooth_angle_type) { + resulting_type = angle_type; + } + return false; + }); + Geometry::visit_backward(index, angle_types.size(), [&](const std::size_t backward_index) { + const double distance{(points[backward_index] - points[index]).norm()}; + if (distance > min_arm_length) { + return true; + } + if (angle_types[backward_index] == smooth_angle_type) { + resulting_type = angle_type; + } + return false; + }); + } + result.push_back(resulting_type); + } + return result; +} + +} // namespace Slic3r::Seams::Perimeters::Impl + +namespace Slic3r::Seams::Perimeters { + +LayerInfos get_layer_infos( + tcb::span object_layers, const double elephant_foot_compensation +) { + LayerInfos result(object_layers.size()); + + using Range = tbb::blocked_range; + const Range range{0, object_layers.size()}; + tbb::parallel_for(range, [&](Range range) { + for (std::size_t layer_index{range.begin()}; layer_index < range.end(); ++layer_index) { + result[layer_index] = LayerInfo::create( + *object_layers[layer_index], layer_index, elephant_foot_compensation + ); + } + }); + return result; +} + +LayerInfo LayerInfo::create( + const Slic3r::Layer &object_layer, + const std::size_t index, + const double elephant_foot_compensation +) { + AABBTreeLines::LinesDistancer perimeter_distancer{ + to_unscaled_linesf({object_layer.lslices})}; + + using PreviousLayerDistancer = std::optional>; + PreviousLayerDistancer previous_layer_perimeter_distancer; + if (object_layer.lower_layer != nullptr) { + previous_layer_perimeter_distancer = PreviousLayerDistancer{ + to_unscaled_linesf(object_layer.lower_layer->lslices)}; + } + + return { + std::move(perimeter_distancer), + std::move(previous_layer_perimeter_distancer), + index, + object_layer.height, + object_layer.slice_z, + index == 0 ? elephant_foot_compensation : 0.0}; +} + +double Perimeter::IndexToCoord::operator()(const size_t index, size_t dim) const { + return positions[index][dim]; +} + +Perimeter::PointTrees get_kd_trees( + const PointType point_type, + const std::vector &all_point_types, + const std::vector &point_classifications, + const Perimeter::IndexToCoord &index_to_coord +) { + std::vector overhang_indexes; + std::vector embedded_indexes; + std::vector common_indexes; + for (std::size_t i{0}; i < all_point_types.size(); ++i) { + if (all_point_types[i] == point_type) { + switch (point_classifications[i]) { + case PointClassification::overhang: overhang_indexes.push_back(i); break; + case PointClassification::embedded: embedded_indexes.push_back(i); break; + case PointClassification::common: common_indexes.push_back(i); break; + } + } + } + Perimeter::PointTrees trees; + if (!overhang_indexes.empty()) { + trees.overhanging_points = Perimeter::PointTree{index_to_coord}; + trees.overhanging_points->build(overhang_indexes); + } + if (!embedded_indexes.empty()) { + trees.embedded_points = Perimeter::PointTree{index_to_coord}; + trees.embedded_points->build(embedded_indexes); + } + if (!common_indexes.empty()) { + trees.common_points = Perimeter::PointTree{index_to_coord}; + trees.common_points->build(common_indexes); + } + return trees; +} + +Perimeter::Perimeter( + const double slice_z, + const std::size_t layer_index, + std::vector &&positions, + std::vector &&angles, + std::vector &&point_types, + std::vector &&point_classifications, + std::vector &&angle_types +) + : slice_z(slice_z) + , layer_index(layer_index) + , positions(std::move(positions)) + , angles(std::move(angles)) + , index_to_coord(IndexToCoord{tcb::span{this->positions}}) + , point_types(std::move(point_types)) + , point_classifications(std::move(point_classifications)) + , angle_types(std::move(angle_types)) + , enforced_points(get_kd_trees( + PointType::enforcer, this->point_types, this->point_classifications, this->index_to_coord + )) + , common_points(get_kd_trees( + PointType::common, this->point_types, this->point_classifications, this->index_to_coord + )) + , blocked_points(get_kd_trees( + PointType::blocker, this->point_types, this->point_classifications, this->index_to_coord + )) {} + +Perimeter Perimeter::create_degenerate( + std::vector &&points, const double slice_z, const std::size_t layer_index +) { + std::vector point_types(points.size(), PointType::common); + std::vector + point_classifications(points.size(), PointClassification::common); + std::vector angles(points.size()); + std::vector angle_types(points.size(), AngleType::smooth); + Perimeter perimeter{ + slice_z, + layer_index, + std::move(points), + std::move(angles), + std::move(point_types), + std::move(point_classifications), + std::move(angle_types)}; + perimeter.is_degenerate = true; + return perimeter; +} + +Perimeter Perimeter::create( + const Polygon &polygon, + const ModelInfo::Painting &painting, + const LayerInfo &layer_info, + const PerimeterParams ¶ms +) { + if (polygon.size() < 3) { + return Perimeter::create_degenerate( + Geometry::unscaled(polygon.points), layer_info.slice_z, layer_info.index + ); + } + std::vector points; + if (layer_info.elephant_foot_compensation > 0) { + const Polygons expanded{expand(polygon, scaled(layer_info.elephant_foot_compensation))}; + if (expanded.empty()) { + points = Geometry::unscaled(polygon.points); + } else { + points = Geometry::unscaled(expanded.front().points); + } + } else { + points = Geometry::unscaled(polygon.points); + } + + auto is_painted{[&](const Vec3f &point, const double radius) { + return painting.is_enforced(point, radius) || painting.is_blocked(point, radius); + }}; + + std::vector perimeter_points{ + Impl::oversample_painted(points, is_painted, layer_info.slice_z, params.oversampling_max_distance)}; + + std::vector point_types{ + Impl::get_point_types(perimeter_points, painting, layer_info.slice_z, params.painting_radius)}; + + std::tie(perimeter_points, point_types) = + Impl::remove_redundant_points(perimeter_points, point_types, params.simplification_epsilon); + + const std::vector embeddings{ + Geometry::get_embedding_distances(perimeter_points, layer_info.distancer)}; + std::optional> overhangs; + if (layer_info.previous_distancer) { + overhangs = Geometry::get_overhangs( + perimeter_points, *layer_info.previous_distancer, layer_info.height + ); + } + std::vector point_classifications{ + Impl::classify_points(embeddings, overhangs, params.overhang_threshold, params.embedding_threshold)}; + + std::vector smooth_angles{Geometry::get_vertex_angles(perimeter_points, params.smooth_angle_arm_length)}; + std::vector angles{Geometry::get_vertex_angles(perimeter_points, params.sharp_angle_arm_length)}; + std::vector angle_types{ + Impl::get_angle_types(angles, params.convex_threshold, params.concave_threshold)}; + std::vector smooth_angle_types{ + Impl::get_angle_types(smooth_angles, params.convex_threshold, params.concave_threshold)}; + angle_types = Impl::merge_angle_types(angle_types, smooth_angle_types, perimeter_points, params.smooth_angle_arm_length); + + return Perimeter{ + layer_info.slice_z, + layer_info.index, + std::move(perimeter_points), + std::move(angles), + std::move(point_types), + std::move(point_classifications), + std::move(angle_types)}; +} + +Shells::Shells<> create_perimeters( + const std::vector> &shells, + const std::vector &layer_infos, + const ModelInfo::Painting &painting, + const PerimeterParams ¶ms +) { + std::vector> result; + result.reserve(shells.size()); + std::transform( + shells.begin(), shells.end(), std::back_inserter(result), + [](const Shells::Shell &shell) { return Shells::Shell<>(shell.size()); } + ); + + Geometry::iterate_nested(shells, [&](const std::size_t shell_index, const std::size_t polygon_index){ + const Shells::Shell &shell{shells[shell_index]}; + const Shells::Slice& slice{shell[polygon_index]}; + const Polygon &polygon{slice.boundary}; + const LayerInfo &layer_info{layer_infos[slice.layer_index]}; + result[shell_index][polygon_index] = {Perimeter::create(polygon, painting, layer_info, params), slice.layer_index}; + }); + return result; +} +} // namespace Slic3r::Seams::Perimeter diff --git a/src/libslic3r/GCode/SeamPerimeters.hpp b/src/libslic3r/GCode/SeamPerimeters.hpp new file mode 100644 index 0000000000..20705754fd --- /dev/null +++ b/src/libslic3r/GCode/SeamPerimeters.hpp @@ -0,0 +1,188 @@ +#ifndef libslic3r_SeamPerimeters_hpp_ +#define libslic3r_SeamPerimeters_hpp_ + +#include + +#include "libslic3r/GCode/SeamPainting.hpp" +#include "libslic3r/KDTreeIndirect.hpp" + +#include "libslic3r/GCode/SeamShells.hpp" + +namespace Slic3r { + class Layer; +} + +namespace Slic3r::Seams::ModelInfo { +class Painting; +} + +namespace Slic3r::Seams::Perimeters { +enum class AngleType; +enum class PointType; +enum class PointClassification; +struct Perimeter; +struct PerimeterParams; + +struct LayerInfo +{ + static LayerInfo create( + const Slic3r::Layer &object_layer, std::size_t index, const double elephant_foot_compensation + ); + + AABBTreeLines::LinesDistancer distancer; + std::optional> previous_distancer; + std::size_t index; + double height{}; + double slice_z{}; + double elephant_foot_compensation; +}; + +using LayerInfos = std::vector; + +/** + * @brief Construct LayerInfo for each of the provided layers. + */ +LayerInfos get_layer_infos( + tcb::span object_layers, const double elephant_foot_compensation +); +} // namespace Slic3r::Seams::Perimeters + +namespace Slic3r::Seams::Perimeters::Impl { + + +/** + * @brief Split edges between points into multiple points if there is a painted point anywhere on + * the edge. + * + * The edge will be split by points no more than max_distance apart. + * Smaller max_distance -> more points. + * + * @return All the points (original and added) in order along the edges. + */ +std::vector oversample_painted( + const std::vector &points, + const std::function &is_painted, + const double slice_z, + const double max_distance +); + +/** + * @brief Call Duglas-Peucker for consecutive points of the same type. + * + * It never removes the first point and last point. + * + * @param tolerance Douglas-Peucker epsilon. + */ +std::pair, std::vector> remove_redundant_points( + const std::vector &points, + const std::vector &point_types, + const double tolerance +); + +} // namespace Slic3r::Seams::Perimeters::Impl + +namespace Slic3r::Seams::Perimeters { + +enum class AngleType { convex, concave, smooth }; + +enum class PointType { enforcer, blocker, common }; + +enum class PointClassification { overhang, embedded, common }; + +struct PerimeterParams +{ + double elephant_foot_compensation{}; + double oversampling_max_distance{}; + double embedding_threshold{}; + double overhang_threshold{}; + double convex_threshold{}; + double concave_threshold{}; + double painting_radius{}; + double simplification_epsilon{}; + double smooth_angle_arm_length{}; + double sharp_angle_arm_length{}; +}; + +struct Perimeter +{ + struct IndexToCoord + { + double operator()(const size_t index, size_t dim) const; + + tcb::span positions; + }; + + using PointTree = KDTreeIndirect<2, double, IndexToCoord>; + using OptionalPointTree = std::optional; + + struct PointTrees + { + OptionalPointTree embedded_points; + OptionalPointTree common_points; + OptionalPointTree overhanging_points; + }; + + Perimeter() = default; + + Perimeter( + const double slice_z, + const std::size_t layer_index, + std::vector &&positions, + std::vector &&angles, + std::vector &&point_types, + std::vector &&point_classifications, + std::vector &&angle_types + ); + + static Perimeter create( + const Polygon &polygon, + const ModelInfo::Painting &painting, + const LayerInfo &layer_info, + const PerimeterParams ¶ms + ); + + static Perimeter create_degenerate( + std::vector &&points, const double slice_z, const std::size_t layer_index + ); + + bool is_degenerate{false}; + double slice_z{}; + std::size_t layer_index{}; + std::vector positions{}; + std::vector angles{}; + IndexToCoord index_to_coord{}; + std::vector point_types{}; + std::vector point_classifications{}; + std::vector angle_types{}; + + PointTrees enforced_points{}; + PointTrees common_points{}; + PointTrees blocked_points{}; +}; + +/** + * @brief Create a Perimeter for each polygon in each of the shells. + */ +Shells::Shells create_perimeters( + const std::vector> &shells, + const std::vector &layer_infos, + const ModelInfo::Painting &painting, + const PerimeterParams ¶ms +); + +inline std::size_t get_layer_count( + const Shells::Shells<> &shells +) { + std::size_t layer_count{0}; + for (const Shells::Shell<> &shell : shells) { + for (const Shells::Slice<>& slice : shell) { + if (slice.layer_index >= layer_count) { + layer_count = slice.layer_index + 1; + } + } + } + return layer_count; +} +} // namespace Slic3r::Seams::Perimeters + +#endif // libslic3r_SeamPerimeters_hpp_ diff --git a/src/libslic3r/GCode/SeamPlacer.cpp b/src/libslic3r/GCode/SeamPlacer.cpp index ed0d480027..21b42584e0 100644 --- a/src/libslic3r/GCode/SeamPlacer.cpp +++ b/src/libslic3r/GCode/SeamPlacer.cpp @@ -1,1616 +1,323 @@ -///|/ Copyright (c) Prusa Research 2020 - 2023 VojtÄ›ch Bubník @bubnikv, Lukáš MatÄ›na @lukasmatena, Pavel MikuÅ¡ @Godrak +///|/ Copyright (c) Prusa Research 2020 - 2023 VojtÄ›ch Bubník @bubnikv, Lukáš MatÄ›na @lukasmatena, +/// Pavel MikuÅ¡ @Godrak ///|/ Copyright (c) SuperSlicer 2023 Remi Durand @supermerill ///|/ ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher ///|/ + +#include +#include #include "SeamPlacer.hpp" -#include "Color.hpp" -#include "Polygon.hpp" -#include "PrintConfig.hpp" -#include "tbb/parallel_for.h" -#include "tbb/blocked_range.h" -#include "tbb/parallel_reduce.h" -#include -#include -#include -#include +#include "libslic3r/GCode/SeamAligned.hpp" +#include "libslic3r/GCode/SeamRear.hpp" +#include "libslic3r/GCode/SeamRandom.hpp" +#include "libslic3r/GCode/ModelVisibility.hpp" +#include "libslic3r/GCode/SeamGeometry.hpp" -#include "libslic3r/AABBTreeLines.hpp" -#include "libslic3r/KDTreeIndirect.hpp" -#include "libslic3r/ExtrusionEntity.hpp" -#include "libslic3r/Print.hpp" -#include "libslic3r/BoundingBox.hpp" -#include "libslic3r/ClipperUtils.hpp" -#include "libslic3r/Layer.hpp" +namespace Slic3r::Seams { -#include "libslic3r/Geometry/Curves.hpp" -#include "libslic3r/ShortEdgeCollapse.hpp" -#include "libslic3r/TriangleSetSampling.hpp" +using ObjectShells = std::vector>>; +using ObjectPainting = std::map; -#include "libslic3r/Utils.hpp" +ObjectShells partition_to_shells( + SpanOfConstPtrs objects, + const Params ¶ms, + const ObjectPainting& object_painting, + const std::function &throw_if_canceled +) { + ObjectShells result; -//#define DEBUG_FILES + for (const PrintObject *print_object : objects) { + const ModelInfo::Painting &painting{object_painting.at(print_object)}; + throw_if_canceled(); -#ifdef DEBUG_FILES -#include -#include -#endif + const std::vector extrusions{ + Geometry::get_extrusions(print_object->layers())}; + const Perimeters::LayerInfos layer_infos{Perimeters::get_layer_infos( + print_object->layers(), params.perimeter.elephant_foot_compensation + )}; + Shells::Shells shell_polygons{ + Shells::create_shells(extrusions, params.max_distance)}; -namespace Slic3r { - -namespace SeamPlacerImpl { - -template int sgn(T val) { - return int(T(0) < val) - int(val < T(0)); -} - -// base function: ((e^(((1)/(x^(2)+1)))-1)/(e-1)) -// checkout e.g. here: https://www.geogebra.org/calculator -float gauss(float value, float mean_x_coord, float mean_value, float falloff_speed) { - float shifted = value - mean_x_coord; - float denominator = falloff_speed * shifted * shifted + 1.0f; - float exponent = 1.0f / denominator; - return mean_value * (std::exp(exponent) - 1.0f) / (std::exp(1.0f) - 1.0f); -} - -float compute_angle_penalty(float ccw_angle) { - // This function is used: - // ((ℯ^(((1)/(x^(2)*3+1)))-1)/(ℯ-1))*1+((1)/(2+ℯ^(-x))) - // looks scary, but it is gaussian combined with sigmoid, - // so that concave points have much smaller penalty over convex ones - // https://github.com/prusa3d/PrusaSlicer/tree/master/doc/seam_placement/corner_penalty_function.png - return gauss(ccw_angle, 0.0f, 1.0f, 3.0f) + - 1.0f / (2 + std::exp(-ccw_angle)); -} - -/// Coordinate frame -class Frame { -public: - Frame() { - mX = Vec3f(1, 0, 0); - mY = Vec3f(0, 1, 0); - mZ = Vec3f(0, 0, 1); + Shells::Shells<> perimeters{ + Perimeters::create_perimeters(shell_polygons, layer_infos, painting, params.perimeter)}; + throw_if_canceled(); + result.emplace_back(print_object, std::move(perimeters)); } - - Frame(const Vec3f &x, const Vec3f &y, const Vec3f &z) : - mX(x), mY(y), mZ(z) { - } - - void set_from_z(const Vec3f &z) { - mZ = z.normalized(); - Vec3f tmpZ = mZ; - Vec3f tmpX = (std::abs(tmpZ.x()) > 0.99f) ? Vec3f(0, 1, 0) : Vec3f(1, 0, 0); - mY = (tmpZ.cross(tmpX)).normalized(); - mX = mY.cross(tmpZ); - } - - Vec3f to_world(const Vec3f &a) const { - return a.x() * mX + a.y() * mY + a.z() * mZ; - } - - Vec3f to_local(const Vec3f &a) const { - return Vec3f(mX.dot(a), mY.dot(a), mZ.dot(a)); - } - - const Vec3f& binormal() const { - return mX; - } - - const Vec3f& tangent() const { - return mY; - } - - const Vec3f& normal() const { - return mZ; - } - -private: - Vec3f mX, mY, mZ; -}; - -Vec3f sample_sphere_uniform(const Vec2f &samples) { - float term1 = 2.0f * float(PI) * samples.x(); - float term2 = 2.0f * sqrt(samples.y() - samples.y() * samples.y()); - return {cos(term1) * term2, sin(term1) * term2, - 1.0f - 2.0f * samples.y()}; -} - -Vec3f sample_hemisphere_uniform(const Vec2f &samples) { - float term1 = 2.0f * float(PI) * samples.x(); - float term2 = 2.0f * sqrt(samples.y() - samples.y() * samples.y()); - return {cos(term1) * term2, sin(term1) * term2, - abs(1.0f - 2.0f * samples.y())}; -} - -Vec3f sample_power_cosine_hemisphere(const Vec2f &samples, float power) { - float term1 = 2.f * float(PI) * samples.x(); - float term2 = pow(samples.y(), 1.f / (power + 1.f)); - float term3 = sqrt(1.f - term2 * term2); - - return Vec3f(cos(term1) * term3, sin(term1) * term3, term2); -} - -std::vector raycast_visibility(const AABBTreeIndirect::Tree<3, float> &raycasting_tree, - const indexed_triangle_set &triangles, - const TriangleSetSamples &samples, - size_t negative_volumes_start_index) { - BOOST_LOG_TRIVIAL(debug) - << "SeamPlacer: raycast visibility of " << samples.positions.size() << " samples over " << triangles.indices.size() - << " triangles: end"; - - //prepare uniform samples of a hemisphere - float step_size = 1.0f / SeamPlacer::sqr_rays_per_sample_point; - std::vector precomputed_sample_directions( - SeamPlacer::sqr_rays_per_sample_point * SeamPlacer::sqr_rays_per_sample_point); - for (size_t x_idx = 0; x_idx < SeamPlacer::sqr_rays_per_sample_point; ++x_idx) { - float sample_x = x_idx * step_size + step_size / 2.0; - for (size_t y_idx = 0; y_idx < SeamPlacer::sqr_rays_per_sample_point; ++y_idx) { - size_t dir_index = x_idx * SeamPlacer::sqr_rays_per_sample_point + y_idx; - float sample_y = y_idx * step_size + step_size / 2.0; - precomputed_sample_directions[dir_index] = sample_hemisphere_uniform( { sample_x, sample_y }); - } - } - - bool model_contains_negative_parts = negative_volumes_start_index < triangles.indices.size(); - - std::vector result(samples.positions.size()); - tbb::parallel_for(tbb::blocked_range(0, result.size()), - [&triangles, &precomputed_sample_directions, model_contains_negative_parts, negative_volumes_start_index, - &raycasting_tree, &result, &samples](tbb::blocked_range r) { - // Maintaining hits memory outside of the loop, so it does not have to be reallocated for each query. - std::vector hits; - for (size_t s_idx = r.begin(); s_idx < r.end(); ++s_idx) { - result[s_idx] = 1.0f; - constexpr float decrease_step = 1.0f - / (SeamPlacer::sqr_rays_per_sample_point * SeamPlacer::sqr_rays_per_sample_point); - - const Vec3f ¢er = samples.positions[s_idx]; - const Vec3f &normal = samples.normals[s_idx]; - // apply the local direction via Frame struct - the local_dir is with respect to +Z being forward - Frame f; - f.set_from_z(normal); - - for (const auto &dir : precomputed_sample_directions) { - Vec3f final_ray_dir = (f.to_world(dir)); - if (!model_contains_negative_parts) { - igl::Hit hitpoint; - // FIXME: This AABBTTreeIndirect query will not compile for float ray origin and - // direction. - Vec3d final_ray_dir_d = final_ray_dir.cast(); - Vec3d ray_origin_d = (center + normal * 0.01f).cast(); // start above surface. - bool hit = AABBTreeIndirect::intersect_ray_first_hit(triangles.vertices, - triangles.indices, raycasting_tree, ray_origin_d, final_ray_dir_d, hitpoint); - if (hit && its_face_normal(triangles, hitpoint.id).dot(final_ray_dir) <= 0) { - result[s_idx] -= decrease_step; - } - } else { //TODO improve logic for order based boolean operations - consider order of volumes - bool casting_from_negative_volume = samples.triangle_indices[s_idx] - >= negative_volumes_start_index; - - Vec3d ray_origin_d = (center + normal * 0.01f).cast(); // start above surface. - if (casting_from_negative_volume) { // if casting from negative volume face, invert direction, change start pos - final_ray_dir = -1.0 * final_ray_dir; - ray_origin_d = (center - normal * 0.01f).cast(); - } - Vec3d final_ray_dir_d = final_ray_dir.cast(); - bool some_hit = AABBTreeIndirect::intersect_ray_all_hits(triangles.vertices, - triangles.indices, raycasting_tree, - ray_origin_d, final_ray_dir_d, hits); - if (some_hit) { - int counter = 0; - // NOTE: iterating in reverse, from the last hit for one simple reason: We know the state of the ray at that point; - // It cannot be inside model, and it cannot be inside negative volume - for (int hit_index = int(hits.size()) - 1; hit_index >= 0; --hit_index) { - Vec3f face_normal = its_face_normal(triangles, hits[hit_index].id); - if (hits[hit_index].id >= int(negative_volumes_start_index)) { //negative volume hit - counter -= sgn(face_normal.dot(final_ray_dir)); // if volume face aligns with ray dir, we are leaving negative space - // which in reverse hit analysis means, that we are entering negative space :) and vice versa - } else { - counter += sgn(face_normal.dot(final_ray_dir)); - } - } - if (counter == 0) { - result[s_idx] -= decrease_step; - } - } - } - } - } - }); - - BOOST_LOG_TRIVIAL(debug) - << "SeamPlacer: raycast visibility of " << samples.positions.size() << " samples over " << triangles.indices.size() - << " triangles: end"; - return result; } -std::vector calculate_polygon_angles_at_vertices(const Polygon &polygon, const std::vector &lengths, - float min_arm_length) { - std::vector result(polygon.size()); - - if (polygon.size() == 1) { - result[0] = 0.0f; - } - - size_t idx_prev = 0; - size_t idx_curr = 0; - size_t idx_next = 0; - - float distance_to_prev = 0; - float distance_to_next = 0; - - //push idx_prev far enough back as initialization - while (distance_to_prev < min_arm_length) { - idx_prev = Slic3r::prev_idx_modulo(idx_prev, polygon.size()); - distance_to_prev += lengths[idx_prev]; - } - - for (size_t _i = 0; _i < polygon.size(); ++_i) { - // pull idx_prev to current as much as possible, while respecting the min_arm_length - while (distance_to_prev - lengths[idx_prev] > min_arm_length) { - distance_to_prev -= lengths[idx_prev]; - idx_prev = Slic3r::next_idx_modulo(idx_prev, polygon.size()); - } - - //push idx_next forward as far as needed - while (distance_to_next < min_arm_length) { - distance_to_next += lengths[idx_next]; - idx_next = Slic3r::next_idx_modulo(idx_next, polygon.size()); - } - - // Calculate angle between idx_prev, idx_curr, idx_next. - const Point &p0 = polygon.points[idx_prev]; - const Point &p1 = polygon.points[idx_curr]; - const Point &p2 = polygon.points[idx_next]; - result[idx_curr] = float(angle(p1 - p0, p2 - p1)); - - // increase idx_curr by one - float curr_distance = lengths[idx_curr]; - idx_curr++; - distance_to_prev += curr_distance; - distance_to_next -= curr_distance; - } - - return result; -} - -struct CoordinateFunctor { - const std::vector *coordinates; - CoordinateFunctor(const std::vector *coords) : - coordinates(coords) { - } - CoordinateFunctor() : - coordinates(nullptr) { - } - - const float& operator()(size_t idx, size_t dim) const { - return coordinates->operator [](idx)[dim]; - } -}; - -// structure to store global information about the model - occlusion hits, enforcers, blockers -struct GlobalModelInfo { - TriangleSetSamples mesh_samples; - std::vector mesh_samples_visibility; - CoordinateFunctor mesh_samples_coordinate_functor; - KDTreeIndirect<3, float, CoordinateFunctor> mesh_samples_tree { CoordinateFunctor { } }; - float mesh_samples_radius; - - indexed_triangle_set enforcers; - indexed_triangle_set blockers; - AABBTreeIndirect::Tree<3, float> enforcers_tree; - AABBTreeIndirect::Tree<3, float> blockers_tree; - - bool is_enforced(const Vec3f &position, float radius) const { - if (enforcers.empty()) { - return false; - } - float radius_sqr = radius * radius; - return AABBTreeIndirect::is_any_triangle_in_radius(enforcers.vertices, enforcers.indices, - enforcers_tree, position, radius_sqr); - } - - bool is_blocked(const Vec3f &position, float radius) const { - if (blockers.empty()) { - return false; - } - float radius_sqr = radius * radius; - return AABBTreeIndirect::is_any_triangle_in_radius(blockers.vertices, blockers.indices, - blockers_tree, position, radius_sqr); - } - - float calculate_point_visibility(const Vec3f &position) const { - std::vector points = find_nearby_points(mesh_samples_tree, position, mesh_samples_radius); - if (points.empty()) { - return 1.0f; - } - - auto compute_dist_to_plane = [](const Vec3f &position, const Vec3f &plane_origin, const Vec3f &plane_normal) { - Vec3f orig_to_point = position - plane_origin; - return std::abs(orig_to_point.dot(plane_normal)); - }; - - float total_weight = 0; - float total_visibility = 0; - for (size_t i = 0; i < points.size(); ++i) { - size_t sample_idx = points[i]; - - Vec3f sample_point = this->mesh_samples.positions[sample_idx]; - Vec3f sample_normal = this->mesh_samples.normals[sample_idx]; - - float weight = mesh_samples_radius - compute_dist_to_plane(position, sample_point, sample_normal); - weight += (mesh_samples_radius - (position - sample_point).norm()); - total_visibility += weight * mesh_samples_visibility[sample_idx]; - total_weight += weight; - } - - return total_visibility / total_weight; - - } - -#ifdef DEBUG_FILES - void debug_export(const indexed_triangle_set &obj_mesh) const { - - indexed_triangle_set divided_mesh = obj_mesh; - Slic3r::CNumericLocalesSetter locales_setter; - - { - auto filename = debug_out_path("visiblity.obj"); - FILE *fp = boost::nowide::fopen(filename.c_str(), "w"); - if (fp == nullptr) { - BOOST_LOG_TRIVIAL(error) - << "stl_write_obj: Couldn't open " << filename << " for writing"; - return; - } - - for (size_t i = 0; i < divided_mesh.vertices.size(); ++i) { - float visibility = calculate_point_visibility(divided_mesh.vertices[i]); - Vec3f color = value_to_rgbf(0.0f, 1.0f, visibility); - fprintf(fp, "v %f %f %f %f %f %f\n", - divided_mesh.vertices[i](0), divided_mesh.vertices[i](1), divided_mesh.vertices[i](2), - color(0), color(1), color(2)); - } - for (size_t i = 0; i < divided_mesh.indices.size(); ++i) - fprintf(fp, "f %d %d %d\n", divided_mesh.indices[i][0] + 1, divided_mesh.indices[i][1] + 1, - divided_mesh.indices[i][2] + 1); - fclose(fp); - } - - { - auto filename = debug_out_path("visiblity_samples.obj"); - FILE *fp = boost::nowide::fopen(filename.c_str(), "w"); - if (fp == nullptr) { - BOOST_LOG_TRIVIAL(error) - << "stl_write_obj: Couldn't open " << filename << " for writing"; - return; - } - - for (size_t i = 0; i < mesh_samples.positions.size(); ++i) { - float visibility = mesh_samples_visibility[i]; - Vec3f color = value_to_rgbf(0.0f, 1.0f, visibility); - fprintf(fp, "v %f %f %f %f %f %f\n", - mesh_samples.positions[i](0), mesh_samples.positions[i](1), mesh_samples.positions[i](2), - color(0), color(1), color(2)); - } - fclose(fp); - } - - } -#endif -} -; - -//Extract perimeter polygons of the given layer -Polygons extract_perimeter_polygons(const Layer *layer, std::vector &corresponding_regions_out) { - Polygons polygons; - for (const LayerRegion *layer_region : layer->regions()) { - for (const ExtrusionEntity *ex_entity : layer_region->perimeters()) { - if (ex_entity->is_collection()) { //collection of inner, outer, and overhang perimeters - for (const ExtrusionEntity *perimeter : static_cast(ex_entity)->entities) { - ExtrusionRole role = perimeter->role(); - if (perimeter->is_loop()) { - for (const ExtrusionPath &path : static_cast(perimeter)->paths) { - if (path.role() == ExtrusionRole::ExternalPerimeter) { - role = ExtrusionRole::ExternalPerimeter; - } - } - } - - if (role == ExtrusionRole::ExternalPerimeter) { - Points p; - perimeter->collect_points(p); - polygons.emplace_back(std::move(p)); - corresponding_regions_out.push_back(layer_region); - } - } - if (polygons.empty()) { - Points p; - ex_entity->collect_points(p); - polygons.emplace_back(std::move(p)); - corresponding_regions_out.push_back(layer_region); - } - } else { - Points p; - ex_entity->collect_points(p); - polygons.emplace_back(std::move(p)); - corresponding_regions_out.push_back(layer_region); - } - } - } - - if (polygons.empty()) { // If there are no perimeter polygons for whatever reason (disabled perimeters .. ) insert dummy point - // it is easier than checking everywhere if the layer is not emtpy, no seam will be placed to this layer anyway - polygons.emplace_back(Points{ { 0, 0 } }); - corresponding_regions_out.push_back(nullptr); - } - - return polygons; -} - -// Insert SeamCandidates created from perimeter polygons in to the result vector. -// Compute its type (Enfrocer,Blocker), angle, and position -//each SeamCandidate also contains pointer to shared Perimeter structure representing the polygon -// if Custom Seam modifiers are present, oversamples the polygon if necessary to better fit user intentions -void process_perimeter_polygon(const Polygon &orig_polygon, float z_coord, const LayerRegion *region, - const GlobalModelInfo &global_model_info, PrintObjectSeamData::LayerSeams &result) { - if (orig_polygon.size() == 0) { - return; - } - Polygon polygon = orig_polygon; - bool was_clockwise = polygon.make_counter_clockwise(); - float angle_arm_len = region != nullptr ? region->flow(FlowRole::frExternalPerimeter).nozzle_diameter() : 0.5f; - - std::vector lengths { }; - for (size_t point_idx = 0; point_idx < polygon.size() - 1; ++point_idx) { - lengths.push_back((unscale(polygon[point_idx]) - unscale(polygon[point_idx + 1])).norm()); - } - lengths.push_back(std::max((unscale(polygon[0]) - unscale(polygon[polygon.size() - 1])).norm(), 0.1)); - std::vector polygon_angles = calculate_polygon_angles_at_vertices(polygon, lengths, - angle_arm_len); - - result.perimeters.push_back( { }); - Perimeter &perimeter = result.perimeters.back(); - - std::queue orig_polygon_points { }; - for (size_t index = 0; index < polygon.size(); ++index) { - Vec2f unscaled_p = unscale(polygon[index]).cast(); - orig_polygon_points.emplace(unscaled_p.x(), unscaled_p.y(), z_coord); - } - Vec3f first = orig_polygon_points.front(); - std::queue oversampled_points { }; - size_t orig_angle_index = 0; - perimeter.start_index = result.points.size(); - perimeter.flow_width = region != nullptr ? region->flow(FlowRole::frExternalPerimeter).width() : 0.0f; - bool some_point_enforced = false; - while (!orig_polygon_points.empty() || !oversampled_points.empty()) { - EnforcedBlockedSeamPoint type = EnforcedBlockedSeamPoint::Neutral; - Vec3f position; - float local_ccw_angle = 0; - bool orig_point = false; - if (!oversampled_points.empty()) { - position = oversampled_points.front(); - oversampled_points.pop(); - } else { - position = orig_polygon_points.front(); - orig_polygon_points.pop(); - local_ccw_angle = was_clockwise ? -polygon_angles[orig_angle_index] : polygon_angles[orig_angle_index]; - orig_angle_index++; - orig_point = true; - } - - if (global_model_info.is_enforced(position, perimeter.flow_width)) { - type = EnforcedBlockedSeamPoint::Enforced; - } - - if (global_model_info.is_blocked(position, perimeter.flow_width)) { - type = EnforcedBlockedSeamPoint::Blocked; - } - some_point_enforced = some_point_enforced || type == EnforcedBlockedSeamPoint::Enforced; - - if (orig_point) { - Vec3f pos_of_next = orig_polygon_points.empty() ? first : orig_polygon_points.front(); - float distance_to_next = (position - pos_of_next).norm(); - if (global_model_info.is_enforced(position, distance_to_next)) { - Vec3f vec_to_next = (pos_of_next - position).normalized(); - float step_size = SeamPlacer::enforcer_oversampling_distance; - float step = step_size; - while (step < distance_to_next) { - oversampled_points.push(position + vec_to_next * step); - step += step_size; - } - } - } - - result.points.emplace_back(position, perimeter, local_ccw_angle, type); - } - - perimeter.end_index = result.points.size(); - - if (some_point_enforced) { - // We will patches of enforced points (patch: continuous section of enforced points), choose - // the longest patch, and select the middle point or sharp point (depending on the angle) - // this point will have high priority on this perimeter - size_t perimeter_size = perimeter.end_index - perimeter.start_index; - const auto next_index = [&](size_t idx) { - return perimeter.start_index + Slic3r::next_idx_modulo(idx - perimeter.start_index, perimeter_size); - }; - - std::vector patches_starts_ends; - for (size_t i = perimeter.start_index; i < perimeter.end_index; ++i) { - if (result.points[i].type != EnforcedBlockedSeamPoint::Enforced && - result.points[next_index(i)].type == EnforcedBlockedSeamPoint::Enforced) { - patches_starts_ends.push_back(next_index(i)); - } - if (result.points[i].type == EnforcedBlockedSeamPoint::Enforced && - result.points[next_index(i)].type != EnforcedBlockedSeamPoint::Enforced) { - patches_starts_ends.push_back(next_index(i)); - } - } - //if patches_starts_ends are empty, it means that the whole perimeter is enforced.. don't do anything in that case - if (!patches_starts_ends.empty()) { - //if the first point in the patches is not enforced, it marks a patch end. in that case, put it to the end and start on next - // to simplify the processing - assert(patches_starts_ends.size() % 2 == 0); - bool start_on_second = false; - if (result.points[patches_starts_ends[0]].type != EnforcedBlockedSeamPoint::Enforced) { - start_on_second = true; - patches_starts_ends.push_back(patches_starts_ends[0]); - } - //now pick the longest patch - std::pair longest_patch { 0, 0 }; - auto patch_len = [perimeter_size](const std::pair &start_end) { - if (start_end.second < start_end.first) { - return start_end.first + (perimeter_size - start_end.second); - } else { - return start_end.second - start_end.first; - } - }; - for (size_t patch_idx = start_on_second ? 1 : 0; patch_idx < patches_starts_ends.size(); patch_idx += 2) { - std::pair current_patch { patches_starts_ends[patch_idx], patches_starts_ends[patch_idx - + 1] }; - if (patch_len(longest_patch) < patch_len(current_patch)) { - longest_patch = current_patch; - } - } - std::vector viable_points_indices; - std::vector large_angle_points_indices; - for (size_t point_idx = longest_patch.first; point_idx != longest_patch.second; - point_idx = next_index(point_idx)) { - viable_points_indices.push_back(point_idx); - if (std::abs(result.points[point_idx].local_ccw_angle) - > SeamPlacer::sharp_angle_snapping_threshold) { - large_angle_points_indices.push_back(point_idx); - } - } - assert(viable_points_indices.size() > 0); - if (large_angle_points_indices.empty()) { - size_t central_idx = viable_points_indices[viable_points_indices.size() / 2]; - result.points[central_idx].central_enforcer = true; - } else { - size_t central_idx = large_angle_points_indices.size() / 2; - result.points[large_angle_points_indices[central_idx]].central_enforcer = true; - } - } - } - -} - -// Get index of previous and next perimeter point of the layer. Because SeamCandidates of all polygons of the given layer -// are sequentially stored in the vector, each perimeter contains info about start and end index. These vales are used to -// deduce index of previous and next neigbour in the corresponding perimeter. -std::pair find_previous_and_next_perimeter_point(const std::vector &perimeter_points, - size_t point_index) { - const SeamCandidate ¤t = perimeter_points[point_index]; - int prev = point_index - 1; //for majority of points, it is true that neighbours lie behind and in front of them in the vector - int next = point_index + 1; - - if (point_index == current.perimeter.start_index) { - // if point_index is equal to start, it means that the previous neighbour is at the end - prev = current.perimeter.end_index; - } - - if (point_index == current.perimeter.end_index - 1) { - // if point_index is equal to end, than next neighbour is at the start - next = current.perimeter.start_index; - } - - assert(prev >= 0); - assert(next >= 0); - return {size_t(prev),size_t(next)}; -} - -// Computes all global model info - transforms object, performs raycasting -void compute_global_occlusion(GlobalModelInfo &result, const PrintObject *po, - std::function throw_if_canceled) { - BOOST_LOG_TRIVIAL(debug) - << "SeamPlacer: gather occlusion meshes: start"; - auto obj_transform = po->trafo_centered(); - indexed_triangle_set triangle_set; - indexed_triangle_set negative_volumes_set; - //add all parts - for (const ModelVolume *model_volume : po->model_object()->volumes) { - if (model_volume->type() == ModelVolumeType::MODEL_PART - || model_volume->type() == ModelVolumeType::NEGATIVE_VOLUME) { - auto model_transformation = model_volume->get_matrix(); - indexed_triangle_set model_its = model_volume->mesh().its; - its_transform(model_its, model_transformation); - if (model_volume->type() == ModelVolumeType::MODEL_PART) { - its_merge(triangle_set, model_its); - } else { - its_merge(negative_volumes_set, model_its); - } - } - } - throw_if_canceled(); - - BOOST_LOG_TRIVIAL(debug) - << "SeamPlacer: gather occlusion meshes: end"; - - BOOST_LOG_TRIVIAL(debug) - << "SeamPlacer: decimate: start"; - its_short_edge_collpase(triangle_set, SeamPlacer::fast_decimation_triangle_count_target); - its_short_edge_collpase(negative_volumes_set, SeamPlacer::fast_decimation_triangle_count_target); - - size_t negative_volumes_start_index = triangle_set.indices.size(); - its_merge(triangle_set, negative_volumes_set); - its_transform(triangle_set, obj_transform); - BOOST_LOG_TRIVIAL(debug) - << "SeamPlacer: decimate: end"; - - BOOST_LOG_TRIVIAL(debug) - << "SeamPlacer: Compute visibility sample points: start"; - - result.mesh_samples = sample_its_uniform_parallel(SeamPlacer::raycasting_visibility_samples_count, - triangle_set); - result.mesh_samples_coordinate_functor = CoordinateFunctor(&result.mesh_samples.positions); - result.mesh_samples_tree = KDTreeIndirect<3, float, CoordinateFunctor>(result.mesh_samples_coordinate_functor, - result.mesh_samples.positions.size()); - - // The following code determines search area for random visibility samples on the mesh when calculating visibility of each perimeter point - // number of random samples in the given radius (area) is approximately poisson distribution - // to compute ideal search radius (area), we use exponential distribution (complementary distr to poisson) - // parameters of exponential distribution to compute area that will have with probability="probability" more than given number of samples="samples" - float probability = 0.9f; - float samples = 4; - float density = SeamPlacer::raycasting_visibility_samples_count / result.mesh_samples.total_area; - // exponential probability distrubtion function is : f(x) = P(X > x) = e^(l*x) where l is the rate parameter (computed as 1/u where u is mean value) - // probability that sampled area A with S samples contains more than samples count: - // P(S > samples in A) = e^-(samples/(density*A)); express A: - float search_area = samples / (-logf(probability) * density); - float search_radius = sqrt(search_area / PI); - result.mesh_samples_radius = search_radius; - - BOOST_LOG_TRIVIAL(debug) - << "SeamPlacer: Compute visiblity sample points: end"; - throw_if_canceled(); - - BOOST_LOG_TRIVIAL(debug) - << "SeamPlacer: Mesh sample raidus: " << result.mesh_samples_radius; - - BOOST_LOG_TRIVIAL(debug) - << "SeamPlacer: build AABB tree: start"; - auto raycasting_tree = AABBTreeIndirect::build_aabb_tree_over_indexed_triangle_set(triangle_set.vertices, - triangle_set.indices); - - throw_if_canceled(); - BOOST_LOG_TRIVIAL(debug) - << "SeamPlacer: build AABB tree: end"; - result.mesh_samples_visibility = raycast_visibility(raycasting_tree, triangle_set, result.mesh_samples, - negative_volumes_start_index); - throw_if_canceled(); -#ifdef DEBUG_FILES - result.debug_export(triangle_set); -#endif -} - -void gather_enforcers_blockers(GlobalModelInfo &result, const PrintObject *po) { - BOOST_LOG_TRIVIAL(debug) - << "SeamPlacer: build AABB trees for raycasting enforcers/blockers: start"; - - auto obj_transform = po->trafo_centered(); - - for (const ModelVolume *mv : po->model_object()->volumes) { - if (mv->is_seam_painted()) { - auto model_transformation = obj_transform * mv->get_matrix(); - - indexed_triangle_set enforcers = mv->seam_facets.get_facets(*mv, EnforcerBlockerType::ENFORCER); - its_transform(enforcers, model_transformation); - its_merge(result.enforcers, enforcers); - - indexed_triangle_set blockers = mv->seam_facets.get_facets(*mv, EnforcerBlockerType::BLOCKER); - its_transform(blockers, model_transformation); - its_merge(result.blockers, blockers); - } - } - - result.enforcers_tree = AABBTreeIndirect::build_aabb_tree_over_indexed_triangle_set(result.enforcers.vertices, - result.enforcers.indices); - result.blockers_tree = AABBTreeIndirect::build_aabb_tree_over_indexed_triangle_set(result.blockers.vertices, - result.blockers.indices); - - BOOST_LOG_TRIVIAL(debug) - << "SeamPlacer: build AABB trees for raycasting enforcers/blockers: end"; -} - -struct SeamComparator { - SeamPosition setup; - float angle_importance; - explicit SeamComparator(SeamPosition setup) : - setup(setup) { - angle_importance = - setup == spNearest ? SeamPlacer::angle_importance_nearest : SeamPlacer::angle_importance_aligned; - } - - // Standard comparator, must respect the requirements of comparators (e.g. give same result on same inputs) for sorting usage - // should return if a is better seamCandidate than b - bool is_first_better(const SeamCandidate &a, const SeamCandidate &b, const Vec2f &preffered_location = Vec2f { 0.0f, - 0.0f }) const { - if (setup == SeamPosition::spAligned && a.central_enforcer != b.central_enforcer) { - return a.central_enforcer; - } - - // Blockers/Enforcers discrimination, top priority - if (a.type != b.type) { - return a.type > b.type; - } - - //avoid overhangs - if (a.overhang > 0.0f || b.overhang > 0.0f) { - return a.overhang < b.overhang; - } - - // prefer hidden points (more than 0.5 mm inside) - if (a.embedded_distance < -0.5f && b.embedded_distance > -0.5f) { - return true; - } - if (b.embedded_distance < -0.5f && a.embedded_distance > -0.5f) { - return false; - } - - if (setup == SeamPosition::spRear && a.position.y() != b.position.y()) { - return a.position.y() > b.position.y(); - } - - float distance_penalty_a = 0.0f; - float distance_penalty_b = 0.0f; - if (setup == spNearest) { - distance_penalty_a = 1.0f - gauss((a.position.head<2>() - preffered_location).norm(), 0.0f, 1.0f, 0.005f); - distance_penalty_b = 1.0f - gauss((b.position.head<2>() - preffered_location).norm(), 0.0f, 1.0f, 0.005f); - } - - // the penalites are kept close to range [0-1.x] however, it should not be relied upon - float penalty_a = a.overhang + a.visibility + - angle_importance * compute_angle_penalty(a.local_ccw_angle) - + distance_penalty_a; - float penalty_b = b.overhang + b.visibility + - angle_importance * compute_angle_penalty(b.local_ccw_angle) - + distance_penalty_b; - - return penalty_a < penalty_b; - } - - // Comparator used during alignment. If there is close potential aligned point, it is compared to the current - // seam point of the perimeter, to find out if the aligned point is not much worse than the current seam - // Also used by the random seam generator. - bool is_first_not_much_worse(const SeamCandidate &a, const SeamCandidate &b) const { - // Blockers/Enforcers discrimination, top priority - if (setup == SeamPosition::spAligned && a.central_enforcer != b.central_enforcer) { - // Prefer centers of enforcers. - return a.central_enforcer; - } - - if (a.type == EnforcedBlockedSeamPoint::Enforced) { - return true; - } - - if (a.type == EnforcedBlockedSeamPoint::Blocked) { - return false; - } - - if (a.type != b.type) { - return a.type > b.type; - } - - //avoid overhangs - if ((a.overhang > 0.0f || b.overhang > 0.0f) - && abs(a.overhang - b.overhang) > (0.1f * a.perimeter.flow_width)) { - return a.overhang < b.overhang; - } - - // prefer hidden points (more than 0.5 mm inside) - if (a.embedded_distance < -0.5f && b.embedded_distance > -0.5f) { - return true; - } - if (b.embedded_distance < -0.5f && a.embedded_distance > -0.5f) { - return false; - } - - if (setup == SeamPosition::spRandom) { - return true; - } - - if (setup == SeamPosition::spRear) { - return a.position.y() + SeamPlacer::seam_align_score_tolerance * 5.0f > b.position.y(); - } - - float penalty_a = a.overhang + a.visibility - + angle_importance * compute_angle_penalty(a.local_ccw_angle); - float penalty_b = b.overhang + b.visibility + - angle_importance * compute_angle_penalty(b.local_ccw_angle); - - return penalty_a <= penalty_b || penalty_a - penalty_b < SeamPlacer::seam_align_score_tolerance; - } - - bool are_similar(const SeamCandidate &a, const SeamCandidate &b) const { - return is_first_not_much_worse(a, b) && is_first_not_much_worse(b, a); - } -}; - -#ifdef DEBUG_FILES -void debug_export_points(const std::vector &layers, - const BoundingBox &bounding_box, const SeamComparator &comparator) { - for (size_t layer_idx = 0; layer_idx < layers.size(); ++layer_idx) { - std::string angles_file_name = debug_out_path( - ("angles_" + std::to_string(layer_idx) + ".svg").c_str()); - SVG angles_svg { angles_file_name, bounding_box }; - float min_vis = 0; - float max_vis = min_vis; - - float min_weight = std::numeric_limits::min(); - float max_weight = min_weight; - - for (const SeamCandidate &point : layers[layer_idx].points) { - Vec3i color = value_to_rgbi(-PI, PI, point.local_ccw_angle); - std::string fill = "rgb(" + std::to_string(color.x()) + "," + std::to_string(color.y()) + "," - + std::to_string(color.z()) + ")"; - angles_svg.draw(scaled(Vec2f(point.position.head<2>())), fill); - min_vis = std::min(min_vis, point.visibility); - max_vis = std::max(max_vis, point.visibility); - - min_weight = std::min(min_weight, -compute_angle_penalty(point.local_ccw_angle)); - max_weight = std::max(max_weight, -compute_angle_penalty(point.local_ccw_angle)); - - } - - std::string visiblity_file_name = debug_out_path( - ("visibility_" + std::to_string(layer_idx) + ".svg").c_str()); - SVG visibility_svg { visiblity_file_name, bounding_box }; - std::string weights_file_name = debug_out_path( - ("weight_" + std::to_string(layer_idx) + ".svg").c_str()); - SVG weight_svg { weights_file_name, bounding_box }; - std::string overhangs_file_name = debug_out_path( - ("overhang_" + std::to_string(layer_idx) + ".svg").c_str()); - SVG overhangs_svg { overhangs_file_name, bounding_box }; - - for (const SeamCandidate &point : layers[layer_idx].points) { - Vec3i color = value_to_rgbi(min_vis, max_vis, point.visibility); - std::string visibility_fill = "rgb(" + std::to_string(color.x()) + "," + std::to_string(color.y()) + "," - + std::to_string(color.z()) + ")"; - visibility_svg.draw(scaled(Vec2f(point.position.head<2>())), visibility_fill); - - Vec3i weight_color = value_to_rgbi(min_weight, max_weight, - -compute_angle_penalty(point.local_ccw_angle)); - std::string weight_fill = "rgb(" + std::to_string(weight_color.x()) + "," + std::to_string(weight_color.y()) - + "," - + std::to_string(weight_color.z()) + ")"; - weight_svg.draw(scaled(Vec2f(point.position.head<2>())), weight_fill); - - Vec3i overhang_color = value_to_rgbi(-0.5, 0.5, std::clamp(point.overhang, -0.5f, 0.5f)); - std::string overhang_fill = "rgb(" + std::to_string(overhang_color.x()) + "," - + std::to_string(overhang_color.y()) - + "," - + std::to_string(overhang_color.z()) + ")"; - overhangs_svg.draw(scaled(Vec2f(point.position.head<2>())), overhang_fill); - } - } -} -#endif - -// Pick best seam point based on the given comparator -void pick_seam_point(std::vector &perimeter_points, size_t start_index, - const SeamComparator &comparator) { - size_t end_index = perimeter_points[start_index].perimeter.end_index; - - size_t seam_index = start_index; - for (size_t index = start_index; index < end_index; ++index) { - if (comparator.is_first_better(perimeter_points[index], perimeter_points[seam_index])) { - seam_index = index; - } - } - perimeter_points[start_index].perimeter.seam_index = seam_index; -} - -size_t pick_nearest_seam_point_index(const std::vector &perimeter_points, size_t start_index, - const Vec2f &preffered_location) { - size_t end_index = perimeter_points[start_index].perimeter.end_index; - SeamComparator comparator { spNearest }; - - size_t seam_index = start_index; - for (size_t index = start_index; index < end_index; ++index) { - if (comparator.is_first_better(perimeter_points[index], perimeter_points[seam_index], preffered_location)) { - seam_index = index; - } - } - return seam_index; -} - -// picks random seam point uniformly, respecting enforcers blockers and overhang avoidance. -void pick_random_seam_point(const std::vector &perimeter_points, size_t start_index) { - SeamComparator comparator { spRandom }; - - // algorithm keeps a list of viable points and their lengths. If it finds a point - // that is much better than the viable_example_index (e.g. better type, no overhang; see is_first_not_much_worse) - // then it throws away stored lists and starts from start - // in the end, the list should contain points with same type (Enforced > Neutral > Blocked) and also only those which are not - // big overhang. - size_t viable_example_index = start_index; - size_t end_index = perimeter_points[start_index].perimeter.end_index; - struct Viable { - // Candidate seam point index. - size_t index; - float edge_length; - Vec3f edge; - }; - std::vector viables; - - const Vec3f pseudornd_seed = perimeter_points[viable_example_index].position; - float rand = std::abs(sin(pseudornd_seed.dot(Vec3f(12.9898f,78.233f, 133.3333f))) * 43758.5453f); - rand = rand - (int) rand; - - for (size_t index = start_index; index < end_index; ++index) { - if (comparator.are_similar(perimeter_points[index], perimeter_points[viable_example_index])) { - // index ok, push info into viables - Vec3f edge_to_next { perimeter_points[index == end_index - 1 ? start_index : index + 1].position - - perimeter_points[index].position }; - float dist_to_next = edge_to_next.norm(); - viables.push_back( { index, dist_to_next, edge_to_next }); - } else if (comparator.is_first_not_much_worse(perimeter_points[viable_example_index], - perimeter_points[index])) { - // index is worse then viable_example_index, skip this point - } else { - // index is better than viable example index, update example, clear gathered info, start again - // clear up all gathered info, start from scratch, update example index - viable_example_index = index; - viables.clear(); - - Vec3f edge_to_next = (perimeter_points[index == end_index - 1 ? start_index : index + 1].position - - perimeter_points[index].position); - float dist_to_next = edge_to_next.norm(); - viables.push_back( { index, dist_to_next, edge_to_next }); - } - } - - // now pick random point from the stored options - float len_sum = std::accumulate(viables.begin(), viables.end(), 0.0f, [](const float acc, const Viable &v) { - return acc + v.edge_length; - }); - float picked_len = len_sum * rand; - - size_t point_idx = 0; - while (picked_len - viables[point_idx].edge_length > 0) { - picked_len = picked_len - viables[point_idx].edge_length; - point_idx++; - } - - Perimeter &perimeter = perimeter_points[start_index].perimeter; - perimeter.seam_index = viables[point_idx].index; - perimeter.final_seam_position = perimeter_points[perimeter.seam_index].position - + viables[point_idx].edge.normalized() * picked_len; - perimeter.finalized = true; -} - -} // namespace SeamPlacerImpl - -// Parallel process and extract each perimeter polygon of the given print object. -// Gather SeamCandidates of each layer into vector and build KDtree over them -// Store results in the SeamPlacer variables m_seam_per_object -void SeamPlacer::gather_seam_candidates(const PrintObject *po, const SeamPlacerImpl::GlobalModelInfo &global_model_info) { - using namespace SeamPlacerImpl; - PrintObjectSeamData &seam_data = m_seam_per_object.emplace(po, PrintObjectSeamData { }).first->second; - seam_data.layers.resize(po->layer_count()); - - tbb::parallel_for(tbb::blocked_range(0, po->layers().size()), - [po, &global_model_info, &seam_data] - (tbb::blocked_range r) { - for (size_t layer_idx = r.begin(); layer_idx < r.end(); ++layer_idx) { - PrintObjectSeamData::LayerSeams &layer_seams = seam_data.layers[layer_idx]; - const Layer *layer = po->get_layer(layer_idx); - auto unscaled_z = layer->slice_z; - std::vector regions; - //NOTE corresponding region ptr may be null, if the layer has zero perimeters - Polygons polygons = extract_perimeter_polygons(layer, regions); - for (size_t poly_index = 0; poly_index < polygons.size(); ++poly_index) { - process_perimeter_polygon(polygons[poly_index], unscaled_z, - regions[poly_index], global_model_info, layer_seams); - } - auto functor = SeamCandidateCoordinateFunctor { layer_seams.points }; - seam_data.layers[layer_idx].points_tree = - std::make_unique(functor, - layer_seams.points.size()); - } - } - ); -} - -void SeamPlacer::calculate_candidates_visibility(const PrintObject *po, - const SeamPlacerImpl::GlobalModelInfo &global_model_info) { - using namespace SeamPlacerImpl; - - std::vector &layers = m_seam_per_object[po].layers; - tbb::parallel_for(tbb::blocked_range(0, layers.size()), - [&layers, &global_model_info](tbb::blocked_range r) { - for (size_t layer_idx = r.begin(); layer_idx < r.end(); ++layer_idx) { - for (auto &perimeter_point : layers[layer_idx].points) { - perimeter_point.visibility = global_model_info.calculate_point_visibility( - perimeter_point.position); - } - } - }); -} - -void SeamPlacer::calculate_overhangs_and_layer_embedding(const PrintObject *po) { - using namespace SeamPlacerImpl; - using PerimeterDistancer = AABBTreeLines::LinesDistancer; - - std::vector &layers = m_seam_per_object[po].layers; - tbb::parallel_for(tbb::blocked_range(0, layers.size()), - [po, &layers](tbb::blocked_range r) { - std::unique_ptr prev_layer_distancer; - if (r.begin() > 0) { // previous layer exists - prev_layer_distancer = std::make_unique(to_unscaled_linesf(po->layers()[r.begin() - 1]->lslices)); - } - - for (size_t layer_idx = r.begin(); layer_idx < r.end(); ++layer_idx) { - size_t regions_with_perimeter = 0; - for (const LayerRegion *region : po->layers()[layer_idx]->regions()) { - if (region->perimeters().size() > 0) { - regions_with_perimeter++; - } - }; - bool should_compute_layer_embedding = regions_with_perimeter > 1; - std::unique_ptr current_layer_distancer = std::make_unique( - to_unscaled_linesf(po->layers()[layer_idx]->lslices)); - - for (SeamCandidate &perimeter_point : layers[layer_idx].points) { - Vec2f point = Vec2f { perimeter_point.position.head<2>() }; - if (prev_layer_distancer.get() != nullptr) { - perimeter_point.overhang = prev_layer_distancer->distance_from_lines(point.cast()) - + 0.6f * perimeter_point.perimeter.flow_width - - tan(SeamPlacer::overhang_angle_threshold) - * po->layers()[layer_idx]->height; - perimeter_point.overhang = - perimeter_point.overhang < 0.0f ? 0.0f : perimeter_point.overhang; - } - - if (should_compute_layer_embedding) { // search for embedded perimeter points (points hidden inside the print ,e.g. multimaterial join, best position for seam) - perimeter_point.embedded_distance = current_layer_distancer->distance_from_lines(point.cast()) - + 0.6f * perimeter_point.perimeter.flow_width; - } - } - - prev_layer_distancer.swap(current_layer_distancer); - } - } +ObjectSeams precalculate_seams( + const Params ¶ms, + ObjectShells &&seam_data, + const std::function &throw_if_canceled +) { + ObjectSeams result; + + for (auto &[print_object, shells] : seam_data) { + switch (params.seam_preference) { + case spAligned: { + const Transform3d transformation{print_object->trafo_centered()}; + const ModelVolumePtrs &volumes{print_object->model_object()->volumes}; + + Slic3r::ModelInfo::Visibility + points_visibility{transformation, volumes, params.visibility, throw_if_canceled}; + throw_if_canceled(); + const Aligned::VisibilityCalculator visibility_calculator{ + points_visibility, params.convex_visibility_modifier, + params.concave_visibility_modifier}; + + result[print_object] = Aligned::get_object_seams( + std::move(shells), visibility_calculator, params.aligned ); + break; } - -// Estimates, if there is good seam point in the layer_idx which is close to last_point_pos -// uses comparator.is_first_not_much_worse method to compare current seam with the closest point -// (if current seam is too far away ) -// If the current chosen stream is close enough, it is stored in seam_string. returns true and updates last_point_pos -// If the closest point is good enough to replace current chosen seam, it is stored in potential_string_seams, returns true and updates last_point_pos -// Otherwise does nothing, returns false -// Used by align_seam_points(). -std::optional> SeamPlacer::find_next_seam_in_layer( - const std::vector &layers, - const Vec3f &projected_position, - const size_t layer_idx, const float max_distance, - const SeamPlacerImpl::SeamComparator &comparator) const { - using namespace SeamPlacerImpl; - std::vector nearby_points_indices = find_nearby_points(*layers[layer_idx].points_tree, projected_position, - max_distance); - - if (nearby_points_indices.empty()) { - return {}; - } - - size_t best_nearby_point_index = nearby_points_indices[0]; - size_t nearest_point_index = nearby_points_indices[0]; - - // Now find best nearby point, nearest point, and corresponding indices - for (const size_t &nearby_point_index : nearby_points_indices) { - const SeamCandidate &point = layers[layer_idx].points[nearby_point_index]; - if (point.perimeter.finalized) { - continue; // skip over finalized perimeters, try to find some that is not finalized + case spRear: { + result[print_object] = Rear::get_object_seams(std::move(shells), params.rear_project_threshold); + break; } - if (comparator.is_first_better(point, layers[layer_idx].points[best_nearby_point_index], - projected_position.head<2>()) - || layers[layer_idx].points[best_nearby_point_index].perimeter.finalized) { - best_nearby_point_index = nearby_point_index; + case spRandom: { + result[print_object] = Random::get_object_seams(std::move(shells), params.random_seed); + break; } - if ((point.position - projected_position).squaredNorm() - < (layers[layer_idx].points[nearest_point_index].position - projected_position).squaredNorm() - || layers[layer_idx].points[nearest_point_index].perimeter.finalized) { - nearest_point_index = nearby_point_index; + case spNearest: { + throw std::runtime_error("Cannot precalculate seams for nearest position!"); } + } + throw_if_canceled(); } - - const SeamCandidate &best_nearby_point = layers[layer_idx].points[best_nearby_point_index]; - const SeamCandidate &nearest_point = layers[layer_idx].points[nearest_point_index]; - - if (nearest_point.perimeter.finalized) { - //all points are from already finalized perimeter, skip - return {}; - } - - //from the nearest_point, deduce index of seam in the next layer - const SeamCandidate &next_layer_seam = layers[layer_idx].points[nearest_point.perimeter.seam_index]; - - // First try to pick central enforcer if any present - if (next_layer_seam.central_enforcer - && (next_layer_seam.position - projected_position).squaredNorm() - < sqr(3 * max_distance)) { - return {std::pair {layer_idx, nearest_point.perimeter.seam_index}}; - } - - // First try to align the nearest, then try the best nearby - if (comparator.is_first_not_much_worse(nearest_point, next_layer_seam)) { - return {std::pair {layer_idx, nearest_point_index}}; - } - // If nearest point is not good enough, try it with the best nearby point. - if (comparator.is_first_not_much_worse(best_nearby_point, next_layer_seam)) { - return {std::pair {layer_idx, best_nearby_point_index}}; - } - - return {}; + return result; } -std::vector> SeamPlacer::find_seam_string(const PrintObject *po, - std::pair start_seam, const SeamPlacerImpl::SeamComparator &comparator) const { - const std::vector &layers = m_seam_per_object.find(po)->second.layers; - int layer_idx = start_seam.first; +Params Placer::get_params(const DynamicPrintConfig &config) { + Params params{}; - //initialize searching for seam string - cluster of nearby seams on previous and next layers - int next_layer = layer_idx + 1; - int step = 1; - std::pair prev_point_index = start_seam; - std::vector> seam_string { start_seam }; - - auto reverse_lookup_direction = [&]() { - step = -1; - prev_point_index = start_seam; - next_layer = layer_idx - 1; - }; - - while (next_layer >= 0) { - if (next_layer >= int(layers.size())) { - reverse_lookup_direction(); - if (next_layer < 0) { - break; - } - } - float max_distance = SeamPlacer::seam_align_tolerable_dist_factor * - layers[start_seam.first].points[start_seam.second].perimeter.flow_width; - Vec3f prev_position = layers[prev_point_index.first].points[prev_point_index.second].position; - Vec3f projected_position = prev_position; - projected_position.z() = float(po->get_layer(next_layer)->slice_z); - - std::optional> maybe_next_seam = find_next_seam_in_layer(layers, projected_position, - next_layer, - max_distance, comparator); - - if (maybe_next_seam.has_value()) { - // For old macOS (pre 10.14), std::optional does not have .value() method, so the code is using operator*() instead. - seam_string.push_back(maybe_next_seam.operator*()); - prev_point_index = seam_string.back(); - //String added, prev_point_index updated - } else { - if (step == 1) { - reverse_lookup_direction(); - if (next_layer < 0) { - break; - } - } else { - break; - } - } - next_layer += step; + params.perimeter.elephant_foot_compensation = config.opt_float("elefant_foot_compensation"); + if (config.opt_int("raft_layers") > 0) { + params.perimeter.elephant_foot_compensation = 0.0; } - return seam_string; + params.random_seed = 1653710332u; + + params.aligned.max_detour = 1.0; + params.convex_visibility_modifier = 1.1; + params.concave_visibility_modifier = 0.9; + params.perimeter.overhang_threshold = Slic3r::Geometry::deg2rad(55.0); + params.perimeter.convex_threshold = Slic3r::Geometry::deg2rad(10.0); + params.perimeter.concave_threshold = Slic3r::Geometry::deg2rad(15.0); + + params.seam_preference = config.opt_enum("seam_position"); + params.staggered_inner_seams = config.opt_bool("staggered_inner_seams"); + + params.max_nearest_detour = 1.0; + params.rear_project_threshold = 0.05; // % + params.aligned.jump_visibility_threshold = 0.6; + params.max_distance = 5.0; + params.perimeter.oversampling_max_distance = 0.2; + params.perimeter.embedding_threshold = 0.5; + params.perimeter.painting_radius = 0.1; + params.perimeter.simplification_epsilon = 0.001; + params.perimeter.smooth_angle_arm_length = 0.5; + params.perimeter.sharp_angle_arm_length = 0.05; + + params.visibility.raycasting_visibility_samples_count = 30000; + params.visibility.fast_decimation_triangle_count_target = 16000; + params.visibility.sqr_rays_per_sample_point = 5; + + return params; } -// clusters already chosen seam points into strings across multiple layers, and then -// aligns the strings via polynomial fit -// Does not change the positions of the SeamCandidates themselves, instead stores -// the new aligned position into the shared Perimeter structure of each perimeter -// Note that this position does not necesarilly lay on the perimeter. -void SeamPlacer::align_seam_points(const PrintObject *po, const SeamPlacerImpl::SeamComparator &comparator) { - using namespace SeamPlacerImpl; +ObjectLayerPerimeters sort_to_layers(ObjectShells &&object_shells) { + ObjectLayerPerimeters result; + for (auto &[print_object, shells] : object_shells) { + const std::size_t layer_count{print_object->layer_count()}; + result[print_object] = LayerPerimeters(layer_count); - // Prepares Debug files for writing. -#ifdef DEBUG_FILES - Slic3r::CNumericLocalesSetter locales_setter; - auto clusters_f = debug_out_path("seam_clusters.obj"); - FILE *clusters = boost::nowide::fopen(clusters_f.c_str(), "w"); - if (clusters == nullptr) { - BOOST_LOG_TRIVIAL(error) - << "stl_write_obj: Couldn't open " << clusters_f << " for writing"; - return; - } - auto aligned_f = debug_out_path("aligned_clusters.obj"); - FILE *aligns = boost::nowide::fopen(aligned_f.c_str(), "w"); - if (aligns == nullptr) { - BOOST_LOG_TRIVIAL(error) - << "stl_write_obj: Couldn't open " << clusters_f << " for writing"; - return; - } -#endif - - //gather vector of all seams on the print_object - pair of layer_index and seam__index within that layer - const std::vector &layers = m_seam_per_object[po].layers; - std::vector> seams; - for (size_t layer_idx = 0; layer_idx < layers.size(); ++layer_idx) { - const std::vector &layer_perimeter_points = layers[layer_idx].points; - size_t current_point_index = 0; - while (current_point_index < layer_perimeter_points.size()) { - seams.emplace_back(layer_idx, layer_perimeter_points[current_point_index].perimeter.seam_index); - current_point_index = layer_perimeter_points[current_point_index].perimeter.end_index; + for (Shells::Shell<> &shell : shells) { + for (Shells::Slice<> &slice : shell) { + const BoundingBox bounding_box{Geometry::scaled(slice.boundary.positions)}; + result[print_object][slice.layer_index].push_back( + BoundedPerimeter{std::move(slice.boundary), bounding_box} + ); + } } } + return result; +} - //sort them before alignment. Alignment is sensitive to initializaion, this gives it better chance to choose something nice - std::stable_sort(seams.begin(), seams.end(), - [&comparator, &layers](const std::pair &left, - const std::pair &right) { - return comparator.is_first_better(layers[left.first].points[left.second], - layers[right.first].points[right.second]); - } +void Placer::init( + SpanOfConstPtrs objects, + const Params ¶ms, + const std::function &throw_if_canceled +) { + BOOST_LOG_TRIVIAL(debug) << "SeamPlacer: init: start"; + + ObjectPainting object_painting; + for (const PrintObject *print_object : objects) { + const Transform3d transformation{print_object->trafo_centered()}; + const ModelVolumePtrs &volumes{print_object->model_object()->volumes}; + object_painting.emplace(print_object, ModelInfo::Painting{transformation, volumes}); + } + + ObjectShells seam_data{partition_to_shells(objects, params, object_painting, throw_if_canceled)}; + this->params = params; + + if (this->params.seam_preference != spNearest) { + this->seams_per_object = + precalculate_seams(params, std::move(seam_data), throw_if_canceled); + } else { + this->perimeters_per_layer = sort_to_layers(std::move(seam_data)); + } + + BOOST_LOG_TRIVIAL(debug) << "SeamPlacer: init: end"; +} + +const SeamPerimeterChoice &choose_closest_seam( + const std::vector &seams, const Polygon &loop_polygon +) { + BoundingBoxes choose_from; + choose_from.reserve(seams.size()); + for (const SeamPerimeterChoice &choice : seams) { + choose_from.push_back(choice.bounding_box); + } + + const std::size_t choice_index{ + Geometry::pick_closest_bounding_box(loop_polygon.bounding_box(), choose_from).first}; + + return seams[choice_index]; +} + +std::pair project_to_extrusion_loop( + const SeamChoice &seam_choice, const Perimeters::Perimeter &perimeter, const Linesf &loop_lines +) { + const AABBTreeLines::LinesDistancer distancer{loop_lines}; + + const bool is_at_vertex{seam_choice.previous_index == seam_choice.next_index}; + const Vec2d edge{ + perimeter.positions[seam_choice.next_index] - + perimeter.positions[seam_choice.previous_index]}; + const Vec2d normal{ + is_at_vertex ? + Geometry::get_polygon_normal(perimeter.positions, seam_choice.previous_index, 0.1) : + Geometry::get_normal(edge)}; + + double depth{distancer.distance_from_lines(seam_choice.position)}; + const Vec2d final_position{seam_choice.position - normal * depth}; + + auto [_, loop_line_index, loop_point] = distancer.distance_from_lines_extra(final_position ); + return {loop_line_index, loop_point}; +} - //align the seam points - start with the best, and check if they are aligned, if yes, skip, else start alignment - // Keeping the vectors outside, so with a bit of luck they will not get reallocated after couple of for loop iterations. - std::vector> seam_string; - std::vector> alternative_seam_string; - std::vector observations; - std::vector observation_points; - std::vector weights; +std::optional offset_along_loop_lines( + const Vec2d &point, + const std::size_t loop_line_index, + const Linesf &loop_lines, + const double offset +) { + double distance{0}; + Vec2d previous_point{point}; + std::optional offset_point; + Geometry::visit_forward(loop_line_index, loop_lines.size(), [&](std::size_t index) { + const Vec2d next_point{loop_lines[index].b}; + const Vec2d edge{next_point - previous_point}; - int global_index = 0; - while (global_index < int(seams.size())) { - size_t layer_idx = seams[global_index].first; - size_t seam_index = seams[global_index].second; - global_index++; - const std::vector &layer_perimeter_points = layers[layer_idx].points; - if (layer_perimeter_points[seam_index].perimeter.finalized) { - // This perimeter is already aligned, skip seam - continue; - } else { - seam_string = this->find_seam_string(po, { layer_idx, seam_index }, comparator); - size_t step_size = 1 + seam_string.size() / 20; - for (size_t alternative_start = 0; alternative_start < seam_string.size(); alternative_start += step_size) { - size_t start_layer_idx = seam_string[alternative_start].first; - size_t seam_idx = - layers[start_layer_idx].points[seam_string[alternative_start].second].perimeter.seam_index; - alternative_seam_string = this->find_seam_string(po, - std::pair(start_layer_idx, seam_idx), comparator); - if (alternative_seam_string.size() > seam_string.size()) { - seam_string = std::move(alternative_seam_string); - } - } - if (seam_string.size() < seam_align_minimum_string_seams) { - //string NOT long enough to be worth aligning, skip - continue; - } + if (distance + edge.norm() > offset) { + const double remaining_distance{offset - distance}; + offset_point = previous_point + remaining_distance * edge.normalized(); + return true; + } - // String is long enough, all string seams and potential string seams gathered, now do the alignment - //sort by layer index - std::sort(seam_string.begin(), seam_string.end(), - [](const std::pair &left, const std::pair &right) { - return left.first < right.first; - }); + distance += edge.norm(); + previous_point = next_point; - //repeat the alignment for the current seam, since it could be skipped due to alternative path being aligned. - global_index--; + return false; + }); - // gather all positions of seams and their weights - observations.resize(seam_string.size()); - observation_points.resize(seam_string.size()); - weights.resize(seam_string.size()); + return offset_point; +} - auto angle_3d = [](const Vec3f& a, const Vec3f& b){ - return std::abs(acosf(a.normalized().dot(b.normalized()))); - }; +double get_angle(const SeamChoice &seam_choice, const Perimeters::Perimeter &perimeter) { + const bool is_at_vertex{seam_choice.previous_index == seam_choice.next_index}; + return is_at_vertex ? perimeter.angles[seam_choice.previous_index] : 0.0; +} - auto angle_weight = [](float angle){ - return 1.0f / (0.1f + compute_angle_penalty(angle)); - }; +Point finalize_seam_position( + const Polygon &loop_polygon, + const SeamChoice &seam_choice, + const Perimeters::Perimeter &perimeter, + const double loop_width, + const bool do_staggering +) { + const Linesf loop_lines{to_unscaled_linesf({ExPolygon{loop_polygon}})}; + const auto [loop_line_index, loop_point]{ + project_to_extrusion_loop(seam_choice, perimeter, loop_lines)}; - //gather points positions and weights - float total_length = 0.0f; - Vec3f last_point_pos = layers[seam_string[0].first].points[seam_string[0].second].position; - for (size_t index = 0; index < seam_string.size(); ++index) { - const SeamCandidate ¤t = layers[seam_string[index].first].points[seam_string[index].second]; - float layer_angle = 0.0f; - if (index > 0 && index < seam_string.size() - 1) { - layer_angle = angle_3d( - current.position - - layers[seam_string[index - 1].first].points[seam_string[index - 1].second].position, - layers[seam_string[index + 1].first].points[seam_string[index + 1].second].position - - current.position - ); - } - observations[index] = current.position.head<2>(); - observation_points[index] = current.position.z(); - weights[index] = angle_weight(current.local_ccw_angle); - float curling_influence = layer_angle > 2.0 * std::abs(current.local_ccw_angle) ? -0.8f : 1.0f; - if (current.type == EnforcedBlockedSeamPoint::Enforced) { - curling_influence = 1.0f; - weights[index] += 3.0f; - } - total_length += curling_influence * (last_point_pos - current.position).norm(); - last_point_pos = current.position; - } + // ExtrusionRole::Perimeter is inner perimeter. + if (do_staggering) { + const double depth = (loop_point - seam_choice.position).norm() - + loop_width / 2.0; + const double angle{get_angle(seam_choice, perimeter)}; + const double initial_offset{angle > 0 ? angle / 2.0 * depth : 0.0}; + const double additional_offset{angle < 0 ? std::cos(angle / 2.0) * depth : depth}; - if (comparator.setup == spRear) { - total_length *= 0.3f; - } + const double staggering_offset{initial_offset + additional_offset}; - // Curve Fitting - size_t number_of_segments = std::max(size_t(1), - size_t(std::max(0.0f,total_length) / SeamPlacer::seam_align_mm_per_segment)); - auto curve = Geometry::fit_cubic_bspline(observations, observation_points, weights, number_of_segments); + std::optional staggered_point{ + offset_along_loop_lines(loop_point, loop_line_index, loop_lines, staggering_offset)}; - // Do alignment - compute fitted point for each point in the string from its Z coord, and store the position into - // Perimeter structure of the point; also set flag aligned to true - for (size_t index = 0; index < seam_string.size(); ++index) { - const auto &pair = seam_string[index]; - float t = std::min(1.0f, std::pow(std::abs(layers[pair.first].points[pair.second].local_ccw_angle) - / SeamPlacer::sharp_angle_snapping_threshold, 3.0f)); - if (layers[pair.first].points[pair.second].type == EnforcedBlockedSeamPoint::Enforced){ - t = std::max(0.4f, t); - } - - Vec3f current_pos = layers[pair.first].points[pair.second].position; - Vec2f fitted_pos = curve.get_fitted_value(current_pos.z()); - - //interpolate between current and fitted position, prefer current pos for large weights. - Vec3f final_position = t * current_pos + (1.0f - t) * to_3d(fitted_pos, current_pos.z()); - - Perimeter &perimeter = layers[pair.first].points[pair.second].perimeter; - perimeter.seam_index = pair.second; - perimeter.final_seam_position = final_position; - perimeter.finalized = true; - } - -#ifdef DEBUG_FILES - auto randf = []() { - return float(rand()) / float(RAND_MAX); - }; - Vec3f color { randf(), randf(), randf() }; - for (size_t i = 0; i < seam_string.size(); ++i) { - auto orig_seam = layers[seam_string[i].first].points[seam_string[i].second]; - fprintf(clusters, "v %f %f %f %f %f %f \n", orig_seam.position[0], - orig_seam.position[1], - orig_seam.position[2], color[0], color[1], - color[2]); - } - - color = Vec3f { randf(), randf(), randf() }; - for (size_t i = 0; i < seam_string.size(); ++i) { - const Perimeter &perimeter = layers[seam_string[i].first].points[seam_string[i].second].perimeter; - fprintf(aligns, "v %f %f %f %f %f %f \n", perimeter.final_seam_position[0], - perimeter.final_seam_position[1], - perimeter.final_seam_position[2], color[0], color[1], - color[2]); - } -#endif + if (staggered_point) { + return scaled(*staggered_point); } } -#ifdef DEBUG_FILES - fclose(clusters); - fclose(aligns); -#endif - + return scaled(loop_point); } -void SeamPlacer::init(const Print &print, std::function throw_if_canceled_func) { - using namespace SeamPlacerImpl; - m_seam_per_object.clear(); - - for (const PrintObject *po : print.objects()) { - throw_if_canceled_func(); - SeamPosition configured_seam_preference = po->config().seam_position.value; - SeamComparator comparator { configured_seam_preference }; - - { - GlobalModelInfo global_model_info { }; - gather_enforcers_blockers(global_model_info, po); - throw_if_canceled_func(); - if (configured_seam_preference == spAligned || configured_seam_preference == spNearest) { - compute_global_occlusion(global_model_info, po, throw_if_canceled_func); - } - throw_if_canceled_func(); - BOOST_LOG_TRIVIAL(debug) - << "SeamPlacer: gather_seam_candidates: start"; - gather_seam_candidates(po, global_model_info); - BOOST_LOG_TRIVIAL(debug) - << "SeamPlacer: gather_seam_candidates: end"; - throw_if_canceled_func(); - if (configured_seam_preference == spAligned || configured_seam_preference == spNearest) { - BOOST_LOG_TRIVIAL(debug) - << "SeamPlacer: calculate_candidates_visibility : start"; - calculate_candidates_visibility(po, global_model_info); - BOOST_LOG_TRIVIAL(debug) - << "SeamPlacer: calculate_candidates_visibility : end"; - } - } // destruction of global_model_info (large structure, no longer needed) - throw_if_canceled_func(); - BOOST_LOG_TRIVIAL(debug) - << "SeamPlacer: calculate_overhangs and layer embdedding : start"; - calculate_overhangs_and_layer_embedding(po); - BOOST_LOG_TRIVIAL(debug) - << "SeamPlacer: calculate_overhangs and layer embdedding: end"; - throw_if_canceled_func(); - if (configured_seam_preference != spNearest) { // For spNearest, the seam is picked in the place_seam method with actual nozzle position information - BOOST_LOG_TRIVIAL(debug) - << "SeamPlacer: pick_seam_point : start"; - //pick seam point - std::vector &layers = m_seam_per_object[po].layers; - tbb::parallel_for(tbb::blocked_range(0, layers.size()), - [&layers, configured_seam_preference, comparator](tbb::blocked_range r) { - for (size_t layer_idx = r.begin(); layer_idx < r.end(); ++layer_idx) { - std::vector &layer_perimeter_points = layers[layer_idx].points; - for (size_t current = 0; current < layer_perimeter_points.size(); - current = layer_perimeter_points[current].perimeter.end_index) - if (configured_seam_preference == spRandom) - pick_random_seam_point(layer_perimeter_points, current); - else - pick_seam_point(layer_perimeter_points, current, comparator); - } - }); - BOOST_LOG_TRIVIAL(debug) - << "SeamPlacer: pick_seam_point : end"; - } - throw_if_canceled_func(); - if (configured_seam_preference == spAligned || configured_seam_preference == spRear) { - BOOST_LOG_TRIVIAL(debug) - << "SeamPlacer: align_seam_points : start"; - align_seam_points(po, comparator); - BOOST_LOG_TRIVIAL(debug) - << "SeamPlacer: align_seam_points : end"; - } - -#ifdef DEBUG_FILES - debug_export_points(m_seam_per_object[po].layers, po->bounding_box(), comparator); -#endif +std::pair place_seam_near( + const std::vector &layer_perimeters, + const ExtrusionLoop &loop, + const Point &position, + const double max_detour +) { + BoundingBoxes choose_from; + choose_from.reserve(layer_perimeters.size()); + for (const BoundedPerimeter &perimeter : layer_perimeters) { + choose_from.push_back(perimeter.bounding_box); } + + const Polygon loop_polygon{Geometry::to_polygon(loop)}; + + const std::size_t choice_index{ + Geometry::pick_closest_bounding_box(loop_polygon.bounding_box(), choose_from).first}; + + Seams::Aligned::Impl::Nearest nearest{unscaled(position), max_detour}; + + const SeamChoice choice{Seams::choose_seam_point(layer_perimeters[choice_index].perimeter, nearest)}; + + return {choice, choice_index}; } -Point SeamPlacer::place_seam(const Layer *layer, const ExtrusionLoop &loop, bool external_first, - const Point &last_pos) const { - using namespace SeamPlacerImpl; +Point Placer::place_seam(const Layer *layer, const ExtrusionLoop &loop, const Point &last_pos) const { const PrintObject *po = layer->object(); // Must not be called with supprot layer. - assert(dynamic_cast(layer) == nullptr); + assert(dynamic_cast(layer) == nullptr); // Object layer IDs are incremented by the number of raft layers. assert(layer->id() >= po->slicing_parameters().raft_layers()); const size_t layer_index = layer->id() - po->slicing_parameters().raft_layers(); - const double unscaled_z = layer->slice_z; - auto get_next_loop_point = [loop](ExtrusionLoop::ClosestPathPoint current) { - current.segment_idx += 1; - if (current.segment_idx >= loop.paths[current.path_idx].polyline.points.size()) { - current.path_idx = next_idx_modulo(current.path_idx, loop.paths.size()); - current.segment_idx = 0; - } - current.foot_pt = loop.paths[current.path_idx].polyline.points[current.segment_idx]; - return current; - }; + const Polygon loop_polygon{Geometry::to_polygon(loop)}; - const PrintObjectSeamData::LayerSeams &layer_perimeters = - m_seam_per_object.find(layer->object())->second.layers[layer_index]; + const bool do_staggering{this->params.staggered_inner_seams && loop.role() == ExtrusionRole::Perimeter}; + const double loop_width{loop.paths.empty() ? 0.0 : loop.paths.front().width()}; - // Find the closest perimeter in the SeamPlacer to this loop. - // Repeat search until two consecutive points of the loop are found, that result in the same closest_perimeter - // This is beacuse with arachne, T-Junctions may exist and sometimes the wrong perimeter was chosen - size_t closest_perimeter_point_index = 0; - { // local space for the closest_perimeter_point_index - Perimeter *closest_perimeter = nullptr; - ExtrusionLoop::ClosestPathPoint closest_point{0,0,loop.paths[0].polyline.points[0]}; - size_t points_count = std::accumulate(loop.paths.begin(), loop.paths.end(), 0, [](size_t acc,const ExtrusionPath& p) { - return acc + p.polyline.points.size(); - }); - for (size_t i = 0; i < points_count; ++i) { - Vec2f unscaled_p = unscaled(closest_point.foot_pt); - closest_perimeter_point_index = find_closest_point(*layer_perimeters.points_tree.get(), - to_3d(unscaled_p, float(unscaled_z))); - if (closest_perimeter != &layer_perimeters.points[closest_perimeter_point_index].perimeter) { - closest_perimeter = &layer_perimeters.points[closest_perimeter_point_index].perimeter; - closest_point = get_next_loop_point(closest_point); - } else { - break; - } - } - } - - Vec3f seam_position; - size_t seam_index; - if (const Perimeter &perimeter = layer_perimeters.points[closest_perimeter_point_index].perimeter; - perimeter.finalized) { - seam_position = perimeter.final_seam_position; - seam_index = perimeter.seam_index; + if (this->params.seam_preference == spNearest) { + const std::vector &perimeters{this->perimeters_per_layer.at(po)[layer_index]}; + const auto [seam_choice, perimeter_index] = place_seam_near(perimeters, loop, last_pos, this->params.max_nearest_detour); + return finalize_seam_position(loop_polygon, seam_choice, perimeters[perimeter_index].perimeter, loop_width, do_staggering); } else { - seam_index = - po->config().seam_position == spNearest ? - pick_nearest_seam_point_index(layer_perimeters.points, perimeter.start_index, - unscaled(last_pos)) : - perimeter.seam_index; - seam_position = layer_perimeters.points[seam_index].position; + const SeamPerimeterChoice &seam_perimeter_choice{choose_closest_seam(this->seams_per_object.at(po)[layer_index], loop_polygon)}; + return finalize_seam_position(loop_polygon, seam_perimeter_choice.choice, seam_perimeter_choice.perimeter, loop_width, do_staggering); } - - Point seam_point = Point::new_scale(seam_position.x(), seam_position.y()); - - if (loop.role() == ExtrusionRole::Perimeter) { //Hopefully inner perimeter - const SeamCandidate &perimeter_point = layer_perimeters.points[seam_index]; - ExtrusionLoop::ClosestPathPoint projected_point = loop.get_closest_path_and_point(seam_point, false); - // determine depth of the seam point. - float depth = (float) unscale(Point(seam_point - projected_point.foot_pt)).norm(); - float beta_angle = cos(perimeter_point.local_ccw_angle / 2.0f); - size_t index_of_prev = - seam_index == perimeter_point.perimeter.start_index ? - perimeter_point.perimeter.end_index - 1 : - seam_index - 1; - size_t index_of_next = - seam_index == perimeter_point.perimeter.end_index - 1 ? - perimeter_point.perimeter.start_index : - seam_index + 1; - - if ((seam_position - perimeter_point.position).squaredNorm() < depth && // seam is on perimeter point - perimeter_point.local_ccw_angle < -EPSILON // In concave angles - ) { // In this case, we are at internal perimeter, where the external perimeter has seam in concave angle. We want to align - // the internal seam into the concave corner, and not on the perpendicular projection on the closest edge (which is what the split_at function does) - Vec2f dir_to_middle = - ((perimeter_point.position - layer_perimeters.points[index_of_prev].position).head<2>().normalized() - + (perimeter_point.position - layer_perimeters.points[index_of_next].position).head<2>().normalized()) - * 0.5; - depth = 1.4142 * depth / beta_angle; - // There are some nice geometric identities in determination of the correct depth of new seam point. - //overshoot the target depth, in concave angles it will correctly snap to the corner; TODO: find out why such big overshoot is needed. - Vec2f final_pos = perimeter_point.position.head<2>() + depth * dir_to_middle; - projected_point = loop.get_closest_path_and_point(Point::new_scale(final_pos.x(), final_pos.y()), false); - } else { // not concave angle, in that case the nearest point is the good candidate - // but for staggering, we also need to recompute depth of the inner perimter, because in convex corners, the distance is larger than layer width - // we want the perpendicular depth, not distance to nearest point - depth = depth * beta_angle / 1.4142; - } - - seam_point = projected_point.foot_pt; - - //lastly, for internal perimeters, do the staggering if requested - if (po->config().staggered_inner_seams && loop.length() > 0.0) { - //fix depth, it is sometimes strongly underestimated - depth = std::max(loop.paths[projected_point.path_idx].width(), depth); - - while (depth > 0.0f) { - auto next_point = get_next_loop_point(projected_point); - Vec2f a = unscale(projected_point.foot_pt).cast(); - Vec2f b = unscale(next_point.foot_pt).cast(); - float dist = (a - b).norm(); - if (dist > depth) { - Vec2f final_pos = a + (b - a) * depth / dist; - next_point.foot_pt = Point::new_scale(final_pos.x(), final_pos.y()); - } - depth -= dist; - projected_point = next_point; - } - seam_point = projected_point.foot_pt; - } - } - - return seam_point; } - -} // namespace Slic3r +} // namespace Slic3r::Seams diff --git a/src/libslic3r/GCode/SeamPlacer.hpp b/src/libslic3r/GCode/SeamPlacer.hpp index c4b1edc00b..625170944a 100644 --- a/src/libslic3r/GCode/SeamPlacer.hpp +++ b/src/libslic3r/GCode/SeamPlacer.hpp @@ -1,4 +1,5 @@ -///|/ Copyright (c) Prusa Research 2020 - 2022 Pavel MikuÅ¡ @Godrak, Lukáš MatÄ›na @lukasmatena, VojtÄ›ch Bubník @bubnikv +///|/ Copyright (c) Prusa Research 2020 - 2022 Pavel MikuÅ¡ @Godrak, Lukáš MatÄ›na @lukasmatena, +/// VojtÄ›ch Bubník @bubnikv ///|/ ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher ///|/ @@ -10,159 +11,62 @@ #include #include -#include "libslic3r/libslic3r.h" -#include "libslic3r/ExtrusionEntity.hpp" +#include "libslic3r/GCode/SeamAligned.hpp" #include "libslic3r/Polygon.hpp" -#include "libslic3r/PrintConfig.hpp" -#include "libslic3r/BoundingBox.hpp" -#include "libslic3r/AABBTreeIndirect.hpp" -#include "libslic3r/KDTreeIndirect.hpp" +#include "libslic3r/Print.hpp" +#include "libslic3r/Point.hpp" +#include "libslic3r/GCode/SeamPerimeters.hpp" +#include "libslic3r/GCode/SeamChoice.hpp" +#include "libslic3r/GCode/ModelVisibility.hpp" -namespace Slic3r { +namespace Slic3r::Seams { -class PrintObject; -class ExtrusionLoop; -class Print; -class Layer; - -namespace EdgeGrid { -class Grid; -} - -namespace SeamPlacerImpl { - - -struct GlobalModelInfo; -struct SeamComparator; - -enum class EnforcedBlockedSeamPoint { - Blocked = 0, - Neutral = 1, - Enforced = 2, +struct BoundedPerimeter { + Perimeters::Perimeter perimeter; + BoundingBox bounding_box; }; -// struct representing single perimeter loop -struct Perimeter { - size_t start_index{}; - size_t end_index{}; //inclusive! - size_t seam_index{}; - float flow_width{}; +using ObjectSeams = + std::unordered_map>>; +using LayerPerimeters = std::vector>; +using ObjectLayerPerimeters = std::unordered_map; - // During alignment, a final position may be stored here. In that case, finalized is set to true. - // Note that final seam position is not limited to points of the perimeter loop. In theory it can be any position - // Random position also uses this flexibility to set final seam point position - bool finalized = false; - Vec3f final_seam_position = Vec3f::Zero(); -}; - -//Struct over which all processing of perimeters is done. For each perimeter point, its respective candidate is created, -// then all the needed attributes are computed and finally, for each perimeter one point is chosen as seam. -// This seam position can be then further aligned -struct SeamCandidate { - SeamCandidate(const Vec3f &pos, Perimeter &perimeter, - float local_ccw_angle, - EnforcedBlockedSeamPoint type) : - position(pos), perimeter(perimeter), visibility(0.0f), overhang(0.0f), embedded_distance(0.0f), local_ccw_angle( - local_ccw_angle), type(type), central_enforcer(false) { - } - const Vec3f position; - // pointer to Perimeter loop of this point. It is shared across all points of the loop - Perimeter &perimeter; - float visibility; - float overhang; - // distance inside the merged layer regions, for detecting perimeter points which are hidden indside the print (e.g. multimaterial join) - // Negative sign means inside the print, comes from EdgeGrid structure - float embedded_distance; - float local_ccw_angle; - EnforcedBlockedSeamPoint type; - bool central_enforcer; //marks this candidate as central point of enforced segment on the perimeter - important for alignment -}; - -struct SeamCandidateCoordinateFunctor { - SeamCandidateCoordinateFunctor(const std::vector &seam_candidates) : - seam_candidates(seam_candidates) { - } - const std::vector &seam_candidates; - float operator()(size_t index, size_t dim) const { - return seam_candidates[index].position[dim]; - } -}; -} // namespace SeamPlacerImpl - -struct PrintObjectSeamData +struct Params { - using SeamCandidatesTree = KDTreeIndirect<3, float, SeamPlacerImpl::SeamCandidateCoordinateFunctor>; - - struct LayerSeams - { - Slic3r::deque perimeters; - std::vector points; - std::unique_ptr points_tree; - }; - // Map of PrintObjects (PO) -> vector of layers of PO -> vector of perimeter - std::vector layers; - // Map of PrintObjects (PO) -> vector of layers of PO -> unique_ptr to KD - // tree of all points of the given layer - - void clear() - { - layers.clear(); - } + double max_nearest_detour; + double rear_project_threshold; + Aligned::Params aligned; + double max_distance{}; + unsigned random_seed{}; + double convex_visibility_modifier{}; + double concave_visibility_modifier{}; + Perimeters::PerimeterParams perimeter; + Slic3r::ModelInfo::Visibility::Params visibility; + SeamPosition seam_preference; + bool staggered_inner_seams; }; -class SeamPlacer { +std::ostream& operator<<(std::ostream& os, const Params& params); + +class Placer +{ public: - // Number of samples generated on the mesh. There are sqr_rays_per_sample_point*sqr_rays_per_sample_point rays casted from each samples - static constexpr size_t raycasting_visibility_samples_count = 30000; - static constexpr size_t fast_decimation_triangle_count_target = 16000; - //square of number of rays per sample point - static constexpr size_t sqr_rays_per_sample_point = 5; + static Params get_params(const DynamicPrintConfig &config); - // snapping angle - angles larger than this value will be snapped to during seam painting - static constexpr float sharp_angle_snapping_threshold = 55.0f * float(PI) / 180.0f; - // overhang angle for seam placement that still yields good results, in degrees, measured from vertical direction - static constexpr float overhang_angle_threshold = 50.0f * float(PI) / 180.0f; + void init( + SpanOfConstPtrs objects, + const Params ¶ms, + const std::function &throw_if_canceled + ); - // determines angle importance compared to visibility ( neutral value is 1.0f. ) - static constexpr float angle_importance_aligned = 0.6f; - static constexpr float angle_importance_nearest = 1.0f; // use much higher angle importance for nearest mode, to combat the visibility info noise - - // For long polygon sides, if they are close to the custom seam drawings, they are oversampled with this step size - static constexpr float enforcer_oversampling_distance = 0.2f; - - // When searching for seam clusters for alignment: - // following value describes, how much worse score can point have and still be picked into seam cluster instead of original seam point on the same layer - static constexpr float seam_align_score_tolerance = 0.3f; - // seam_align_tolerable_dist_factor - how far to search for seam from current position, final dist is seam_align_tolerable_dist_factor * flow_width - static constexpr float seam_align_tolerable_dist_factor = 4.0f; - // minimum number of seams needed in cluster to make alignment happen - static constexpr size_t seam_align_minimum_string_seams = 6; - // millimeters covered by spline; determines number of splines for the given string - static constexpr size_t seam_align_mm_per_segment = 4.0f; - - //The following data structures hold all perimeter points for all PrintObject. - std::unordered_map m_seam_per_object; - - void init(const Print &print, std::function throw_if_canceled_func); - - Point place_seam(const Layer *layer, const ExtrusionLoop &loop, bool external_first, const Point &last_pos) const; + Point place_seam(const Layer *layer, const ExtrusionLoop &loop, const Point &last_pos) const; private: - void gather_seam_candidates(const PrintObject *po, const SeamPlacerImpl::GlobalModelInfo &global_model_info); - void calculate_candidates_visibility(const PrintObject *po, - const SeamPlacerImpl::GlobalModelInfo &global_model_info); - void calculate_overhangs_and_layer_embedding(const PrintObject *po); - void align_seam_points(const PrintObject *po, const SeamPlacerImpl::SeamComparator &comparator); - std::vector> find_seam_string(const PrintObject *po, - std::pair start_seam, - const SeamPlacerImpl::SeamComparator &comparator) const; - std::optional> find_next_seam_in_layer( - const std::vector &layers, - const Vec3f& projected_position, - const size_t layer_idx, const float max_distance, - const SeamPlacerImpl::SeamComparator &comparator) const; + Params params; + ObjectSeams seams_per_object; + ObjectLayerPerimeters perimeters_per_layer; }; -} // namespace Slic3r +} // namespace Slic3r::Seams #endif // libslic3r_SeamPlacer_hpp_ diff --git a/src/libslic3r/GCode/SeamRandom.cpp b/src/libslic3r/GCode/SeamRandom.cpp new file mode 100644 index 0000000000..27f01ca6be --- /dev/null +++ b/src/libslic3r/GCode/SeamRandom.cpp @@ -0,0 +1,136 @@ +#include + +#include "libslic3r/GCode/SeamRandom.hpp" +#include "libslic3r/GCode/SeamGeometry.hpp" + +namespace Slic3r::Seams::Random { +using Perimeters::PointType; +using Perimeters::PointClassification; + +namespace Impl { +std::vector get_segments( + const Perimeters::Perimeter &perimeter, + const PointType point_type, + const PointClassification point_classification +) { + const std::vector &positions{perimeter.positions}; + const std::vector &point_types{perimeter.point_types}; + const std::vector &point_classifications{perimeter.point_classifications}; + + std::optional current_begin; + std::optional current_begin_index; + Vec2d previous_position{positions.front()}; + double distance{0.0}; + std::vector result; + for (std::size_t index{0}; index < positions.size(); ++index) { + distance += (positions[index] - previous_position).norm(); + previous_position = positions[index]; + + if (point_types[index] == point_type && + point_classifications[index] == point_classification) { + if (!current_begin) { + current_begin = distance; + current_begin_index = index; + } + } else { + if (current_begin) { + result.push_back(PerimeterSegment{*current_begin, distance, *current_begin_index}); + } + current_begin = std::nullopt; + current_begin_index = std::nullopt; + } + } + + if (current_begin) { + result.push_back(PerimeterSegment{*current_begin, distance, *current_begin_index}); + } + return result; +} + +PerimeterSegment pick_random_segment( + const std::vector &segments, std::mt19937 &random_engine +) { + double length{0.0}; + for (const PerimeterSegment &segment : segments) { + length += segment.length(); + } + + std::uniform_real_distribution distribution{0.0, length}; + double random_distance{distribution(random_engine)}; + + double distance{0.0}; + return *std::find_if(segments.begin(), segments.end(), [&](const PerimeterSegment &segment) { + if (random_distance >= distance && random_distance <= distance + segment.length()) { + return true; + } + distance += segment.length(); + return false; + }); +} + +SeamChoice pick_random_point( + const PerimeterSegment &segment, const Perimeters::Perimeter &perimeter, std::mt19937 &random_engine +) { + const std::vector &positions{perimeter.positions}; + + if (segment.length() < std::numeric_limits::epsilon()) { + return {segment.begin_index, segment.begin_index, positions[segment.begin_index]}; + } + + std::uniform_real_distribution distribution{0.0, segment.length()}; + const double random_distance{distribution(random_engine)}; + + double distance{0.0}; + std::size_t previous_index{segment.begin_index}; + for (std::size_t index{segment.begin_index + 1}; index < perimeter.positions.size(); ++index) { + const Vec2d edge{positions[index] - positions[previous_index]}; + + if (distance + edge.norm() >= random_distance) { + if (random_distance - distance < std::numeric_limits::epsilon()) { + index = previous_index; + } else if (distance + edge.norm() - random_distance < std::numeric_limits::epsilon()) { + previous_index = index; + } + + const double remaining_distance{random_distance - distance}; + const Vec2d position{positions[previous_index] + remaining_distance * edge.normalized()}; + return {previous_index, index, position}; + } + + distance += edge.norm(); + previous_index = index; + } + + // Should be unreachable. + return {segment.begin_index, segment.begin_index, positions[segment.begin_index]}; +} + +std::optional Random::operator()( + const Perimeters::Perimeter &perimeter, + const PointType point_type, + const PointClassification point_classification +) const { + std::vector segments{ + get_segments(perimeter, point_type, point_classification)}; + + if (!segments.empty()) { + const PerimeterSegment segment{pick_random_segment(segments, random_engine)}; + return pick_random_point(segment, perimeter, random_engine); + } + return std::nullopt; +} +} // namespace Impl + +std::vector> get_object_seams( + Shells::Shells<> &&shells, const unsigned fixed_seed +) { + std::mt19937 random_engine{fixed_seed}; + const Impl::Random random{random_engine}; + + return Seams::get_object_seams(std::move(shells), [&](const Shells::Shell<> &shell) { + return Seams::get_shell_seam(shell, [&](const Perimeters::Perimeter &perimeter, std::size_t) { + return Seams::choose_seam_point(perimeter, random); + }); + }); +} +} // namespace Slic3r::Seams::Random diff --git a/src/libslic3r/GCode/SeamRandom.hpp b/src/libslic3r/GCode/SeamRandom.hpp new file mode 100644 index 0000000000..81c8dc4342 --- /dev/null +++ b/src/libslic3r/GCode/SeamRandom.hpp @@ -0,0 +1,29 @@ +#include "libslic3r/GCode/SeamChoice.hpp" +#include + +namespace Slic3r::Seams::Random { +namespace Impl { +struct PerimeterSegment +{ + double begin{}; + double end{}; + std::size_t begin_index{}; + + double length() const { return end - begin; } +}; + +struct Random +{ + std::mt19937 &random_engine; + + std::optional operator()( + const Perimeters::Perimeter &perimeter, + const Perimeters::PointType point_type, + const Perimeters::PointClassification point_classification + ) const; +}; +} +std::vector> get_object_seams( + Shells::Shells<> &&shells, const unsigned fixed_seed +); +} diff --git a/src/libslic3r/GCode/SeamRear.cpp b/src/libslic3r/GCode/SeamRear.cpp new file mode 100644 index 0000000000..d189b5ad08 --- /dev/null +++ b/src/libslic3r/GCode/SeamRear.cpp @@ -0,0 +1,125 @@ +#include "libslic3r/GCode/SeamRear.hpp" +#include "libslic3r/GCode/SeamGeometry.hpp" + +namespace Slic3r::Seams::Rear { +using Perimeters::PointType; +using Perimeters::PointClassification; + +namespace Impl { + +BoundingBoxf get_bounding_box(const Shells::Shell<> &shell) { + BoundingBoxf result; + for (const Shells::Slice<> &slice : shell) { + result.merge(BoundingBoxf{slice.boundary.positions}); + } + return result; +} + +std::optional get_rearest_point( + const Perimeters::Perimeter &perimeter, + const PointType point_type, + const PointClassification point_classification +) { + double max_y{-std::numeric_limits::infinity()}; + std::optional choosen_index; + for (std::size_t i{0}; i < perimeter.positions.size(); ++i) { + const Perimeters::PointType _point_type{perimeter.point_types[i]}; + const Perimeters::PointClassification _point_classification{perimeter.point_classifications[i]}; + + if (point_type == _point_type && point_classification == _point_classification) { + const Vec2d &position{perimeter.positions[i]}; + if (position.y() > max_y) { + max_y = position.y(); + choosen_index = i; + } + } + } + if (choosen_index) { + return SeamChoice{*choosen_index, *choosen_index, perimeter.positions[*choosen_index]}; + } + return std::nullopt; +} + +std::optional StraightLine::operator()( + const Perimeters::Perimeter &perimeter, + const PointType point_type, + const PointClassification point_classification +) const { + std::vector possible_lines; + for (std::size_t i{0}; i < perimeter.positions.size() - 1; ++i) { + if (perimeter.point_types[i] != point_type) { + continue; + } + if (perimeter.point_classifications[i] != point_classification) { + continue; + } + if (perimeter.point_types[i + 1] != point_type) { + continue; + } + if (perimeter.point_classifications[i + 1] != point_classification) { + continue; + } + possible_lines.push_back(PerimeterLine{perimeter.positions[i], perimeter.positions[i+1], i, i + 1}); + } + if (possible_lines.empty()) { + return std::nullopt; + } + + const AABBTreeLines::LinesDistancer possible_distancer{possible_lines}; + const BoundingBoxf bounding_box{perimeter.positions}; + + const std::vector> intersections{ + possible_distancer.intersections_with_line(PerimeterLine{ + this->prefered_position, Vec2d{this->prefered_position.x(), bounding_box.min.y()}, + 0, 0})}; + if (!intersections.empty()) { + const auto[position, line_index]{intersections.front()}; + if (position.y() < bounding_box.max.y() - + this->rear_project_threshold * (bounding_box.max.y() - bounding_box.min.y())) { + return std::nullopt; + } + const PerimeterLine &intersected_line{possible_lines[line_index]}; + const SeamChoice intersected_choice{intersected_line.previous_index, intersected_line.next_index, position}; + return intersected_choice; + } + return std::nullopt; +} +} // namespace Impl + +std::vector> get_object_seams( + Shells::Shells<> &&shells, + const double rear_project_threshold +) { + double average_x_center{0.0}; + std::size_t count{0}; + for (const Shells::Shell<> &shell : shells) { + for (const Shells::Slice<> &slice : shell) { + if (slice.boundary.positions.empty()) { + continue; + } + const BoundingBoxf slice_bounding_box{slice.boundary.positions}; + average_x_center += (slice_bounding_box.min.x() + slice_bounding_box.max.x()) / 2.0; + count++; + } + } + average_x_center /= count; + return Seams::get_object_seams(std::move(shells), [&](const Shells::Shell<> &shell) { + BoundingBoxf bounding_box{Impl::get_bounding_box(shell)}; + const Vec2d back_center{average_x_center, bounding_box.max.y()}; + std::optional> straight_seam { + Seams::maybe_get_shell_seam(shell, [&](const Perimeters::Perimeter &perimeter, std::size_t) { + return Seams::maybe_choose_seam_point( + perimeter, + Impl::StraightLine{back_center, rear_project_threshold} + ); + }) + }; + if (!straight_seam) { + return Seams::get_shell_seam(shell, [&](const Perimeters::Perimeter &perimeter, std::size_t) { + return Seams::choose_seam_point(perimeter, Impl::get_rearest_point); + }); + } + return *straight_seam; + }); +} +} // namespace Slic3r::Seams::Rear diff --git a/src/libslic3r/GCode/SeamRear.hpp b/src/libslic3r/GCode/SeamRear.hpp new file mode 100644 index 0000000000..a313432780 --- /dev/null +++ b/src/libslic3r/GCode/SeamRear.hpp @@ -0,0 +1,40 @@ +#ifndef libslic3r_SeamRear_hpp_ +#define libslic3r_SeamRear_hpp_ + +#include "libslic3r/GCode/SeamPerimeters.hpp" +#include "libslic3r/GCode/SeamChoice.hpp" + +namespace Slic3r::Seams::Rear { +namespace Impl { +struct PerimeterLine +{ + Vec2d a; + Vec2d b; + std::size_t previous_index; + std::size_t next_index; + + using Scalar = Vec2d::Scalar; + static const constexpr int Dim = 2; +}; + +struct StraightLine +{ + Vec2d prefered_position; + double rear_project_threshold; + + std::optional operator()( + const Perimeters::Perimeter &perimeter, + const Perimeters::PointType point_type, + const Perimeters::PointClassification point_classification + ) const; +}; + +} // namespace Impl + +std::vector> get_object_seams( + Shells::Shells<> &&shells, + const double rear_project_threshold +); +} // namespace Slic3r::Seams::Rear + +#endif // libslic3r_SeamRear_hpp_ diff --git a/src/libslic3r/GCode/SeamShells.cpp b/src/libslic3r/GCode/SeamShells.cpp new file mode 100644 index 0000000000..f90ce0881c --- /dev/null +++ b/src/libslic3r/GCode/SeamShells.cpp @@ -0,0 +1,99 @@ +#include "libslic3r/GCode/SeamShells.hpp" +#include "libslic3r/ClipperUtils.hpp" +#include +#include + +namespace Slic3r::Seams::Shells::Impl { + +BoundedPolygons project_to_geometry(const Geometry::Extrusions &external_perimeters) { + BoundedPolygons result; + result.reserve(external_perimeters.size()); + + using std::transform, std::back_inserter; + + transform( + external_perimeters.begin(), external_perimeters.end(), back_inserter(result), + [](const Geometry::Extrusion &external_perimeter) { + const auto [choosen_index, _]{Geometry::pick_closest_bounding_box( + external_perimeter.bounding_box, + external_perimeter.island_boundary_bounding_boxes + )}; + + const Polygon &adjacent_boundary{ + choosen_index == 0 ? external_perimeter.island_boundary.contour : + external_perimeter.island_boundary.holes[choosen_index - 1]}; + return BoundedPolygon{adjacent_boundary, external_perimeter.island_boundary_bounding_boxes[choosen_index]}; + } + ); + return result; +} + +std::vector project_to_geometry(const std::vector &extrusions) { + std::vector result(extrusions.size()); + + for (std::size_t layer_index{0}; layer_index < extrusions.size(); ++layer_index) { + result[layer_index] = project_to_geometry(extrusions[layer_index]); + } + + return result; +} + +Shells map_to_shells( + std::vector &&layers, const Geometry::Mapping &mapping, const std::size_t shell_count +) { + Shells result(shell_count); + for (std::size_t layer_index{0}; layer_index < layers.size(); ++layer_index) { + BoundedPolygons &perimeters{layers[layer_index]}; + for (std::size_t perimeter_index{0}; perimeter_index < perimeters.size(); + perimeter_index++) { + Polygon &perimeter{perimeters[perimeter_index].polygon}; + result[mapping[layer_index][perimeter_index]].push_back( + Slice{std::move(perimeter), layer_index} + ); + } + } + return result; +} +} // namespace Slic3r::Seams::Shells::Impl + +namespace Slic3r::Seams::Shells { +Shells create_shells( + const std::vector &extrusions, const double max_distance +) { + std::vector projected{Impl::project_to_geometry(extrusions)}; + + std::vector layer_sizes; + layer_sizes.reserve(projected.size()); + for (const Impl::BoundedPolygons &perimeters : projected) { + layer_sizes.push_back(perimeters.size()); + } + + const auto &[shell_mapping, shell_count]{Geometry::get_mapping( + layer_sizes, + [&](const std::size_t layer_index, + const std::size_t item_index) -> Geometry::MappingOperatorResult { + const Impl::BoundedPolygons &layer{projected[layer_index]}; + const Impl::BoundedPolygons &next_layer{projected[layer_index + 1]}; + if (next_layer.empty()) { + return std::nullopt; + } + + BoundingBoxes next_layer_bounding_boxes; + for (const Impl::BoundedPolygon &bounded_polygon : next_layer) { + next_layer_bounding_boxes.emplace_back(bounded_polygon.bounding_box); + } + + const auto [perimeter_index, distance] = Geometry::pick_closest_bounding_box( + layer[item_index].bounding_box, next_layer_bounding_boxes + ); + + if (distance > max_distance) { + return std::nullopt; + } + return std::pair{perimeter_index, 1.0 / distance}; + } + )}; + + return Impl::map_to_shells(std::move(projected), shell_mapping, shell_count); +} +} // namespace Slic3r::Seams::Shells diff --git a/src/libslic3r/GCode/SeamShells.hpp b/src/libslic3r/GCode/SeamShells.hpp new file mode 100644 index 0000000000..555332708e --- /dev/null +++ b/src/libslic3r/GCode/SeamShells.hpp @@ -0,0 +1,60 @@ +#ifndef libslic3r_SeamShells_hpp_ +#define libslic3r_SeamShells_hpp_ + +#include +#include + +#include "libslic3r/Polygon.hpp" +#include "libslic3r/GCode/SeamGeometry.hpp" + +namespace Slic3r { +class Layer; +} + +namespace Slic3r::Seams::Perimeters { +struct Perimeter; +} + +namespace Slic3r::Seams::Shells::Impl { + +struct BoundedPolygon { + Polygon polygon; + BoundingBox bounding_box; +}; + +using BoundedPolygons = std::vector; + +/** + * Project extrusion path to the original mesh. + * + * Takes the extrusion path and finds the closest polygon to it in + * the extruison island boundary. + * + * Then it expands the extrusion path so it roughly tracks the island boundary + * and check that all points in expanded extrusion path are within a reasonable + * distance (extrusion width) from the closes polygon. + * + * If the expanded extrusion path matches the boundary it returns the + * closeset polygon from the island boundary. Otherwise it returns + * the expanded extrusion. + */ +BoundedPolygons project_to_geometry(const Geometry::Extrusions &extrusions); +} + +namespace Slic3r::Seams::Shells { +template struct Slice +{ + T boundary; + std::size_t layer_index; +}; + +template using Shell = std::vector>; + +template using Shells = std::vector>; + +Shells create_shells( + const std::vector &extrusions, const double max_distance +); +} // namespace Slic3r::Seams::Shells + +#endif // libslic3r_SeamShells_hpp_ diff --git a/src/libslic3r/Layer.cpp b/src/libslic3r/Layer.cpp index e4b4d6539a..804999c796 100644 --- a/src/libslic3r/Layer.cpp +++ b/src/libslic3r/Layer.cpp @@ -944,9 +944,11 @@ void Layer::sort_perimeters_into_islands( auto insert_into_island = [ // Region where the perimeters, gap fills and fill expolygons are stored. - region_id, + region_id, // Whether there are infills with different regions generated for this LayerSlice. has_multiple_regions, + // Layer split into surfaces + &slices, // Perimeters and gap fills to be sorted into islands. &perimeter_and_gapfill_ranges, // Infill regions to be sorted into islands. @@ -959,6 +961,7 @@ void Layer::sort_perimeters_into_islands( lslices_ex[lslice_idx].islands.push_back({}); LayerIsland &island = lslices_ex[lslice_idx].islands.back(); island.perimeters = LayerExtrusionRange(region_id, perimeter_and_gapfill_ranges[source_slice_idx].first); + island.boundary = slices.surfaces[source_slice_idx].expolygon; island.thin_fills = perimeter_and_gapfill_ranges[source_slice_idx].second; if (ExPolygonRange fill_range = fill_expolygons_ranges[source_slice_idx]; ! fill_range.empty()) { if (has_multiple_regions) { diff --git a/src/libslic3r/Layer.hpp b/src/libslic3r/Layer.hpp index 6b45c38925..0a2e457df9 100644 --- a/src/libslic3r/Layer.hpp +++ b/src/libslic3r/Layer.hpp @@ -77,6 +77,8 @@ private: static constexpr const uint32_t fill_region_composite_id = std::numeric_limits::max(); public: + // Boundary of the LayerIsland before perimeter generation. + ExPolygon boundary; // Perimeter extrusions in LayerRegion belonging to this island. LayerExtrusionRange perimeters; // Thin fills of the same region as perimeters. Generated by classic perimeter generator, while Arachne puts them into perimeters. diff --git a/src/libslic3r/ShortEdgeCollapse.cpp b/src/libslic3r/ShortEdgeCollapse.cpp index 6917b24c7c..9089bae6a7 100644 --- a/src/libslic3r/ShortEdgeCollapse.cpp +++ b/src/libslic3r/ShortEdgeCollapse.cpp @@ -9,11 +9,29 @@ #include #include #include +#include #include namespace Slic3r { +/** + * Simple implementation of Fisher-Yates algorithm using uniform int + * distribution from boost, ensurinng the result is the same + * accross platforms. + * + * DO NOT EXPECT IT TO BE PERFORMANT! Use it only when std::shuffle is + * not applicable. + */ +template +void stable_shuffle(Range &range, UniformRandomNumberGenerator &generator) { + const int n{static_cast(range.size())}; + for (int i{0}; i < n - 2; ++i) { + int j{boost::random::uniform_int_distribution{i, n-1}(generator)}; + std::swap(range[i], range[j]); + } +} + void its_short_edge_collpase(indexed_triangle_set &mesh, size_t target_triangle_count) { // whenever vertex is removed, its mapping is update to the index of vertex with wich it merged std::vector vertices_index_mapping(mesh.vertices.size()); @@ -102,8 +120,8 @@ void its_short_edge_collpase(indexed_triangle_set &mesh, size_t target_triangle_ float max_edge_len_squared = edge_len * edge_len; //shuffle the faces and traverse in random order, this MASSIVELY improves the quality of the result - std::shuffle(face_indices.begin(), face_indices.end(), generator); - + stable_shuffle(face_indices, generator); + int allowed_face_removals = int(face_indices.size()) - int(target_triangle_count); for (const size_t &face_idx : face_indices) { if (face_removal_flags[face_idx]) { diff --git a/src/libslic3r/TriangleSetSampling.cpp b/src/libslic3r/TriangleSetSampling.cpp index 363df8659c..dd968fce77 100644 --- a/src/libslic3r/TriangleSetSampling.cpp +++ b/src/libslic3r/TriangleSetSampling.cpp @@ -7,6 +7,7 @@ #include #include #include +#include namespace Slic3r { @@ -33,8 +34,9 @@ TriangleSetSamples sample_its_uniform_parallel(size_t samples_count, const index } std::mt19937_64 mersenne_engine { 27644437 }; + // Use boost instead of std to ensure stability accross platforms! // random numbers on interval [0, 1) - std::uniform_real_distribution fdistribution; + boost::random::uniform_real_distribution fdistribution; auto get_random = [&fdistribution, &mersenne_engine]() { return Vec3d { fdistribution(mersenne_engine), fdistribution(mersenne_engine), fdistribution(mersenne_engine) }; diff --git a/tests/data/seam_test_object.3mf b/tests/data/seam_test_object.3mf new file mode 100644 index 0000000000000000000000000000000000000000..c216b30725783f4e82e02bb3254efea7e7cd0b67 GIT binary patch literal 2514963 zcmV)AK*YaLO9KQH00;;O0I`CRSO5S30000000000022TJ09!+EZggdCbYE0?aAk8{ zE_iKhg^=4y#4r$s@AoM}Zlz6C5RtZf;o%9^2N=?68%!o4nJ(+wJJ}V41@&^~KYZ}_ z`&01hh`G2(gT8G$t&nV-94&)>KfE=MdOz;^!)L;x#7kw+D|31>rq~q&lr|Qhf-`KM)$2)w3pt}NT0LK^l{RQd$vX=yx;fHx z#c947tt8K$vbt1m#GuVDj1VXE|3Jb|@%|Zut_6Q05-nE%7wQo8FPYw) zhaA5EP)i30%Gy9B&;S4ccL4wZP)h>@6aWYa2mrBykyro#0000000000000&M002#8 zbYWy+bYU-aXmxF3ZeeL`E^uyV9Gz!S6JHm`Hz7c1(u;~Tk>0xqBnSu!2#WOH1f)xE zAs|wv2})CfsGtJUi`0Ph-lUfZNH3uW2;|NG{lGAj$;{r|z2}_g`JKCWC>e-}5+?Pk|lP zed?;4v@u6E(2zj{5{f?@K6$J;nktbg@Cpt|l_rad0&C?((J|cTO7|Izu(?UCTz~oL zLi}4pc+uv()2^SSFH5-7~~|c}VQO|FmO<;k4hRWg$67Am*rPFKq9KgcFB8`rtE| z#SyYyJ~r<^>ppOC9=pf(^v!??VR!G!Blw_)UoTm4^V>$w!cl?M$6_t0_*e9jDo_C{$?ix-&>D6AqXKpER{8`?TC}G&soU-(RbAM zbUwh^IB)2c5AkPZ<@!ySP6yJ1?sw}gRG_U+%4qLxm${`P&ibr#cN_MauXn#E#VSsR z6D|u;xOV;m!htwJDr~#Ft6(iRWcO&m6LC1&WvB_B_`OrRsB$^KhmgM<3}{X(N#jFV zvVim(tuJOK3s407n)Dr(Qa>JKO&+ZT=gV&H>o{d!H0*fXpfE??bC7RnD*+tFSOy;W z8^fs*cG|G0tbEunEuHAQlB)T5@%U$equHOWEfDs5S%H%CQUKL)6Z4A(foe){R2c z!q$v^F~!iO8t3`&QP^IH^~o)-fL_5u9oRu?vO`PP1)n_#h2w#@?IKg(wtb4>$o@sr z#qOhXG9#tRd2mwO5*EA^$NzYdaCKTbfw`n0K0oPR-^oCGr zG^nurW}$!mN^AP0@oe&R*0beJW1V<4WSAL;tUX-_DV2Jj6_@-~ zXQ@Cpr=rJ_Y&|Zr(@{aeyCxD!mscP&%;jb5Q1wx`gyebq*W_Uu#0Io_`N^4V`K+qo~7vM z&k6XX%?Hx1XRG&a3#VB)jUJZLzvf~|3vnxBjhM+-2Xu9wQ~e>4@9MlqR%TJD70StY zHloS-QRQ^bXDk_U^m+P2Mia`UQIp+Uz2JL_`Ja%O_jRm8a(04#hstE0VK9|x057Q^>mOiedk#0)5>NFEzppY zsYDe#?cpByM5(*|HWKw~&OghB4^{Y`LyYepJV~f%A<&jGvVuw;s^NYC@eO{O>#6ITG(sxgCPOTv0=T|h*$ zN`$igm)EJWTW>%-i?$zNgtMW-mh(TQ1=fV~N#kWYOTeWVes>~JO-b7<{kfakv+w%6 ztEb-!b9+U=@9lC$q8WU8n_LfWeWpi}^E!7%aqwiW-H?gNS@LWs=Z14;&y#?I?F%R_ zGB>$7qUw-&=3ic)gH`^tN8aspi>NWxF{FAoVe=!KcF0SBuKb5OinNo1xLn;HN7prP zAYZ_B0^>)`y29@4g*;(MYunnD;X+P}`)7DBRm<;Ol?IW^OF}Ssnxk0~Bvf z^1>oetgEcX_k*>L>cnv*T9LfynL@1sEfF3ge+`+j36A>qH%9$UJN*l-b=$UqIZdsv#DfaO*REULKaoAAc@ zEjxudBXx!G&|RzhX0`MF=Bq4Fx0k6i7Pl=K!D*2#VG%8lh$T%xw_1hqVbmg+lM(mb z#KzW+#D{U19NxiTLJtn>RFT0Xw38&+@f&I0EFkmGBfrvmCwjlm5*+oiTetP5O*)yu z_0vk!rN~9YHMCl+ANDV8xI)fy4a#vxK=X9EZZgpQ%`ZPo@7JE;7qeN~UVjXYOX_`e z+k@?BZWn#3R7m4Tg-Y2Aq&+1K1#FhG6|(KzhFLXsvf5;HnH094rv8w2LAG1uUp7F_ z&vo38kC4NsF>#hh&2-t_$`42v*%HbhrO*Eb=4#mXVJ9+e))vBAtY2GQCWm(p^ z>V=88U)$R+8uXT^ycL(E9scyAD)~{=9j5wqM1q&c=BE)UyB#>*xxyK5swN?~Mfytm zZ!d=e&EMRV*-S3aiaPox#jxEsPN?vCX}WuKe_M!&P?`rT5=|Cpu;2LgW~wT)smbpr z*YBQW{;2w8f@F)!|3)R=D3P<4zqWEWR?oK_a+47$uWgQ<-|m%Cu;xH^q=T<>oJ&QZ zUYtwBnUL`D)3kfL&_zw=K+dDdLR0-|D>)(#7N2qs+c|J&o`!x2)FH0Wa^ROnY&(9a z?ozZ~bTVw?YsPbxTs|w3!>PBkb={Vq2&Psk!gw(-M zgHMgFjdx&Kcmlo2p`_a`s~-yz=pzeDRTtw7Yzt*U#+w~zylUR%9)7l(?za@+v)$Uo z_t_C>dW6&{GsdP5_2vhkZxmMApe}%V$H?!_jdNmXsoJXoUI_Ih)swFbU+$>ELAM1d z-%OnPKrxf_ZM>-9i;3E1*~=Zz@Ei@1h@PAb5Wax#9-rgP^kILvsPKR#8KzGMp66tD z2r@O&MYj}d+yLn|EL?4cUzU#Lc+?A$nBLUgY)W8QbfPJH5srPu>F^#CeESD}&Wlh7 z4#)lGEU}T+Fx;GILBh#l>0-6 zR6AX$&P?qPjr?M|*@(%5+rSe`v!1r9Vdc;bN{w5g%6v8p%qC>(BvTwhTo3m&I5On^ zIb9I+FEBCL&a}yW`S(R+1auvnADWjaR=q;_G%?9`q#$&x-+on*9h|BQPU+FLOVo@jr$H-titrbypwY;C zE=D2t*>4}af+YZYO{9qQjthwf$0$oIkKCpR<y9`Pb&~LK6Tct5M^XN>#HB zQ~px+Gi3!M>e2fZQa3HDbQU$XLP|(eU7kDpstbj*Od+3(cUm1cOOj5N*xK|m8eWA> zl=yyfDt}WRjYBvX8p=4T2udlF*{K_YGdhee}$hWWlI8ziefX`qz-7By#$?EdSEv$u$Htk2OL~paCXbhV2=u*UzqKU%b;Cmfr$a0 zlgA+;Mavw{mh!EkLz!${ZA{m^ zTHP-dMuS50Y-{ZI#H{TrXvUj5E4-(U?I;Nuc=I60%;e2)3vn>MS+mF2P4P#XuWlg6 z>Iu;c^gk_w2E_J1;0DQztY%sjz$Ihj3t}5-i2}pxNmsILpZ{;!a)Gd;Py z##in8N!I8jxA}1Uu9*)wEUbIZM2XY=59V>aPiz=#+E4m0WS-$a(Q<~d&~F2BF1Nzd zv;09}Ru(afFXnXR?PWe{(PjvmF|8Mogxt~^PqM+T8la> z*JJ9RL*;*)3{cQ0j0cuTcHFn@G?yJJwl{ikl*PU@ZR)fnCL$;JJDY68#+^5+v=(YSoO z8|y!7k8IW&yIG06=_UJ7Vej{L6~D3LI=T7RkpUN`dm}$}BLogg8qGz+nR?$)@Fl?1 z*?(6$&V#(q&EDZYkb2;CVPlio`$4Yy^(kMcRx3wta?6FvzEj!a(b{@%?$NVJ)^FSl zFM4rH?;H#hCu`?TZAkwubG^A3+JD7)iTiBZm5CP5fl~GJKDa0s!fM|1#w737+eb7# zGT;V0RI3h!%=@isThx9hp{|Y!r+M5--pZki7=CgKr@o897AtgDtXY?kPu@!7 zOv594Nu``K0jYW7c4`Rb9ZH#?)g$>tDx5cDk_T-?s&k`v?nZ#hWv4Mq>{w=6oYv=m zmunh;F!RudAZn2(O6jZx&DpqhohqF;vuhEJQUN{Lbbo6XX6d%rqL85`X1Txai$RQz zrWGX84?a>;;2X1sRt%oCt)(}kuOwYq3J30uP}^S56K6?uvIWNFWQ% zQirJ+rI(vlAs*annJd?5bd&hX!$N;SasT)2XQWarWg%vI%heACoFIv>*xM29{E)UT zFv9#kl!1Afp3C>K>bN5A!&DT{H4xZo zHyq4CON=8~0neaKTWa5-57uG&WA!5VXmL{66X8#fp1_ZbIFYEcST>{rpvhV<1VKeU^-Kdq}- z&7fA*u`l6VUfJ?-A%*^ZJdjj9p9N%tQSHBuWxjQ=0S+|ZSoP)6%CRJD85HL!RY|Z> zK|aRo-Otp+2vX==R$8_xNqnVn0mmV%>Kj)!sjx?DOo`bydlE5mxcD%uGHKflK)}JZ z@yhC`E?%o`uhXS*LZgwTJ%O$cqL#X?{{>zB_U#*7l%FkPulZuPpE;x8R5?u&N$b^| z`D;Zx;hGit2+SO6SlFXJV`qw%zm9iC(nEE0zh^$90_D_~Hs@HKi_yK0lS!h~(cogS z=UCxTWK22c0UF%&DU?7u?44#u9IZypu8bKr^vlde@dl9z&^AT7#wxyp!xrlM5@etW zt)jKb53+-1Z|ur?QqcU(yqh@5=kMb7s;fr6ynbOztijwef!8@{Ky77P%`aU600Y!+KdEmJAS|Yvco|_li6fWJpTf+^ke=0&`?6@O`(bQ`5Vf zNrY$JtY)xSlMlvF5{wFA6lW05CfZtLk|Kg$lLc-NZuJIEexpN3r$nsb!%U)Q0YaZ?HG<=0jj5Rq~tW6jnC=5Xjw>qID5Odz7`%m@>yk} zk7XTxo^V5)^RC>j>a*gt&kW*oT`A=h5oq?x=I@R#EG)_&T4VO!7cCpF*uvdOg83F! zOy}@SDgj5IIT?<)M+y>F_skeMLpDBNPO;I-S*8ceP#&F8FuAkJ(`6aA-;o>p(=M0G z*Y*y~`#xsRjf(FDTEB%GV{dn#E6wGo*{abWCmttt_2~k$!W&OSG#xKcfEhoWF6J(zKvu*%o`V zRIIpBVO5v^@*-VzWGfMxM}@sT?8L1RvQ z9$xFnBPIPR0-^ZqRwufymY>A=TYkQ5MB^2e1qD0E@JhADR6&HPWOBvBWpwJ{B-x6e z-9C`E=Ip_9IboQ&Q6-R<^y#a8f3N8)=ZjF<(f1F_2kWgq?*>K9-nmE};`QZ*JPBACSOVI#1#Kl`r7l8P@6fKFsI zywm~F1j3(3ey(sHK@U+$ReV={kG8$j8V}kg>PLKN<0sX{j?e_awu)1mQ{rg@ZYiO1 zun~6Fqi1w)Gl}9rQL>A^4`7)vI40<^b!ne6-=n0Ip|R6BtFRUeP`gy|JR(N&Re2 z?9f$3P}XcQ`1)o@G_SoY_X%S=p@YIMDWTg|ODb~(BB*TO@Z;$^9iipA_7 zfbGMbIC&(xz%5$6dOjb7UVWOdqrYCv4G?VZk9<4X9y1ZdO;TYETHlU3j5@|Uij03t zw0>V8o~AIXe+xGHcHY_Sj{FJuC&T-^S2lHVEP^}P=Q9ZF_e_Zy)oq?~&nKwb%zTj* zqJmtaIZJh~{5lNO7+QIeG&247%sB0X4aV(4mV-%}B}Yzl5MuFw9=lC1%>4z$8=7-E zpC1BIzr@qH)wqJ)o0sVlkAV}Vymy_^aY6zDVswSfqKr64hMC1+Z0#@RWAY!4UBbPw zA9FfLWgbxKx`Q?594wD58yIaE-mP48wdQ>9OlC9$y_n9UjZ;KKY1|~uRJNG_QY1@U zX7jIAB>x13FGQGo@Y^Ni7lR*54n;sdWj3N3HgksEI7z@ z1aSr`>oBr>3`#(|N4!vAxS(juH)UEs#H?mRjXIyqXqa)BYFumHyT47vrxMQ8lin0V zYSU-|j;evCWKfVkH?LZ=I^p;NJQMj@Mm7`LHH)i!<+gq@gVcW~ z@y#f|DE|!hN=4JcC~!GdZ=PSbK%D(E9YCsVK!1NpqB#!?gc|ZrvN+M)%k=e2;Hk$+ zl#7mPAeBosO!d2SwWn4tJ2x+PJx3;xlII8qX481ZeT#M}rfS(=U7sGdvOm;(`Sr)s zx8?8qCGW5}dDd7aBw8TlKq{}w_;0-u1>-=^_hZ-lXU9wBjgX@_Bv(VddzGasCxbHm zZvEEJesHU%@1@I_#RwiXDHd_4s8!Hm48Av?&r?J0MEd1q;$mnAd_do5{ZE3pJy3196rYd zIUc>E9u+swe#(TYa+<-Oh9XNzqzJzf3ZS|j78+!J2v<%JnX1$m4x4qb&JDKd_&eoH zmI2h@Sc6Rau_rf2yBS&a%gIcv>`le@m41b<-mQ@iNabo;eue;vNr>5|ppc z0T}Ii;BdKii6_(Iv636;K7V1E&5xRJIZ)`2>W-&wmPuBwU?q3Jns=2o4@f}W8_%b< z0qD3iiprWXZzf*E_Q@*OaLVrCA>B?_G*E=hgroX@4=>+=JJN*YN-i{GG#BiIewsRR z`_i*`Z}YD++=OQNk|L~T?dv59>%ohOfoQb#xLpw~F&7-wu*|;flZ~CaZ!kiAa+n9{U@;fbR{P2;hxeRBR z(Xpl9r1#=TRxNG!R+NSVO~_Bj3GFnej;E;$YJfX9(fuL1I@M@xYyx)+{Jw5=Q7_I?e6L5gGJjn-(wx2bTu11#waP3fJM?fO`gsz(68h`b0sjx9Gb~%i zgkHl3>aROn?K}-v=UbILABla;km;!+4nWkl;ul>oYcR$h+4Q2-)WRY%)^1W%KRXhY zu<~Pp@awmAJsIx1QuBRER*sXUPT+Azz{|V&mzn#|nijVv)O=%i4?c#)0j=?#rfIr% z*S#mW57-pn4@W`!%lA7!)%dAn2ww6VcDwSa3Qw5fz34sV$lD`j_9E`qYh#+cbCNS= zDdjc?A#TLP+mRrxEm~` z?AS6{OZH_=+u-{|8lP;7#@^?SXNTNHiuvoebypRxO%-c<_CCw9KQ;E<(MXNhd)n^U z@8~VCwQ!+C?&>5ZgFWoHr{j1*fzN#rmd(`H6(`pRAgr7TvmOni+N=k6l}*wHAECD` zUUzYXxK;oC#{;r1@B{AYY>y9}WD{=N<_VFgoVAV&pg9k^d(uQyhDifgN81uk>_IPK z9h8|vkuCP17EwtYr?&Pyz$yvr+P%}iS1{!6CS@c0khRU|N)}|+s^)sn2h>Ttu99yW z6XMBCnf(*A=cd6(G0P{5t6KqcsaZ4rF5IL$^*Wdez?!f8VN90$Pa^Qk@_5IhY>S%I z+f(o#rNndVeNfD@D!BCetQ#iC;Getj-x+3W-n=aQnYn-ZahL}GeXiwYq7QAT%fGtbs4Y8P3u4>G)Zbn? z5+)9J6ty7I&S`eqv(Om6R{{O+L>=j>p=Z@9*KgwfQc7&qkyJ4h=;=jUildVsR!Qix zVG<6Aeb$zt6UM0I(nP(&nZf?)oxwwJyz)%pu}Q=}egpY|RoB_vi?5&1gM02z9a z@=j(EiP8I4W6w8ca9YX_;%njIecn>eVDI#^!j8_Em4Pjd_YLj3ebVRKl9k!QIpKtg z9yFWaD`$x<#Z@^}MeZ9?1lMz(v!}2_;PjtWT0PWmoroZ3RHBmkO(<}WUXO)g5%JdT zpn`swV7ennrCn{pA<8;q^2CZt-}H;A`bAlWWAgU#~>0pDt}XkN0?qUFM}coCs3bvNL<;V+2S?fOY(A8zrWDxK@WPH( zE+{DC49;3RS@rZ5JQHLAB^d^;kzB){5g~Sd+*F4RPzC`WQb4L}#He`N6fpeKm{1%+ z3_w?(ul+vLAv|zrU44!;?g-lPCtZ3MzzassMH`yN9$OkU5DFkq%XQhq=+2C;Jj*)e zyPLH0lor#PVK_lUfqQm)BxN+6#VV}>e|FodMgmiKF#J$>qfO1~y-P^R+%oTK{eCcQ zq#BqAJDyCyW7#Mdr-PG%N<+jZyq={`G=&RD#rpLIFBx@!M0M4v?WG{tLqEK(B9;j> zi^K_V1X^Q^=j$l!+ob<3V+MZMW%KN(d|dd=-M2 zoFk%Za!cO*>To0OVy|&?Po8;(38a2eUbhw)MvdvRqOkc{sS=-?<=0+P-P{}hF`AbI zWiKhYHEYCWR1dgUA;$N+3bIw6gfaF-#ii-RKvX0j>YS2u1lk;927X>(ULAj2{T+$E z`Xm_*gbMw=rzz;p_-ixsUnJ~ZLvoG|tZcE*EDiX}Q8B0_-}`lAZ6*>$;hD7Tm0H6v zG!kI`yMmp5nCOkOi(8=TJUxo1c{+SyRVr}lJ?BflE_T^>TGmx}{eScfbb5#v++)lY zT#N}a2>-yGXA)}&HMK`@FGA#;QX~;oCAQ^J3f~-{JlOCr-7AG&CvNoo0(X!#=;T-rnQb;OE=WIwO(!QG z99@u?jEQvxT-Y0@3w$f%^f>*NZzQ!NBJ;aLZ^kKOM=U-k33R)VH*yOPntBqW%}GD_ zo_fNvzD0t6HpeURaO78(96Gs*eC$Kq;IriD3?lB-`t0+ninq2w-}dp7`l7fASnIsS2P-nq8wAYk|G2-O$Jh$hHbzy*B2_PB_>wPDV^0 z)h}BqUG7te=Pm>iZQHYzw8FuaEZww?%ADsggZ&xz975?vz{2swAEpI55A`gQ-y(0k zZ0qTOId9YD#?G3jT7Z=^C1UTLR6_JEdoZkY;};u1f75rf-Q*qn*oimx`54E`Fq7=e zn@!}h?B0|qXD_k`E7-o~y1{$Mn|`P#q2j{!_R}^l`LDcFkig$lqsVmr-HXm`E48_y z)mIA=mrJSQIf%1w8M@(tbJXL=3;f2de{bHl3}wEPM$HWKY^Z@JP{1d@X;p=45h#|LMNgF%8q2v= zh&Xg^RKm4zZ+y^}dJlZwIL&IKsZZ42%Kq|;?k{JJJ+`l1rNrpvc2G_TQ+PRQ zrFISiO+m98hfdAT=i>$L#>IIwVgFc`*B2v@w2RXs>y9_*fgf@;B}IbYz3xlz;GHr+c9>d)2^E zjxg8NXm429%jBM;SHh>bt6ThIwA%_7$}1m!;eQXNZNxB~Va3umH2psg{P7|61`bjK z8UuADUOsUEu-8(UNgff=9JMYajcKlbR3VTt1t;)itR)wzr}LEkqND0PpTl$Mk1Xy> zlMyP+e{2`eCu%DqSsJeSaXejTY*@TM`b}Zl7kyK@#02u(Mq#+_kx=hna^1_+S-gm54qDz`Sdb^bBxk@D=81zuf_G}>Y-CAI@#)FZy<3z>+`t_d4xEM;Tn6OW#`pufy54z z*9vQL`OIDURt34MFP@76Ih%nY6qLd(cb0otR#dv_4~^tmq88g z^t%k;yp38)NUll_YXrImG8|29@?GcZM{u% zBfx0-`x?0?*kBA}g){DKf)2+BfQS>cl_T~+;nGmk@Hra;O~bd@L% zK-E+%hH1DMijTU=gmSGE3NK$B<-~(fN<9WPIa1e#fV>Q5_t$JnZu^g-0^#z6@AvqJD0 z8hP0D2v~`DN8M_?Xm#zJ38xc2L#Xu3qDLDqK1rcaus>_9H0=bm!k-;7`2#DoYV;nS@>xhD8WSVA{M{tw;}OrGw!&F^g2W5fVw#T2&5 zvvM&BY*U3YSlTchwYTQDD;ACGJ~%3%a?KZCS8M0}a@wypOZxVaDI+b!21IqP?0XRX zuA|`-BW{Nl&g;~&8%_hR`x~3pNx)hBUIXbl`+|?GL$`GB9}U@AAYgHmEY$CX{m%Og z&T3>9hErv^IdxF?s3pfg6JM#ev}~l*&1k(MglcB|NyB}m|83n1OxuG&))T6f!-Z}L z`I3eKY!7?p5B@eFb3arNZb~z@xP2lAnN0Egg)P<%98F7G%Y>~Sxx0!+cIkaIy#_{r zZE~#dkq|iVfuK-uQJ^Nr_I1o!9--f2?!tIM+Ce zZ=V2%|2v~^=J1?rq4w^Kv_V)dpg;_jaW~}mlW?gp%oq0pJ=8vbmLYaLUi|~tBZMK| z6c3JaYCa)Onm(8B8OR)*ixLCyPHGEM4Fv2ZJ#z9Zyp{(!=H%0KhMaVmsTQPYKcuBH z_?=Yap~lL94J+p_cvvrS2ZTcTl7?qR2aK6Kq#Vo`kFa)+*i`-#dTn6^CQo5=1VRXP zZr!_G`Gou&kV)K=c8q8ywyzpr5qM_n&1*3UP>kB4Qr+UEb=)@WC+@^LylXpPk340} zxPm0-%K!ZxEeiBjIJJ$Q#%q0))!ddGr8*X3NTUEU_rj=3rU(1 ztaSe6JE4*0B-qJ2%(_PI|4vLDJwUfoFiupoK)zGQm(mGw>BF7Z#`5|T@{3$1)ZW_un1I71#0LJx{tcSUH?=86%W;oas{4sRu z^j-}@nlJyivAu%Ji;>lqUY*PD@c~ga8Hcfj37a;jaSNaI$}~|t+kL^1{`=9phkO5R zxzFNk(!sFm212~@O-bx*W`4y$kNijxt30>%S+fLZNue)KpIU`c0GTYHxxx?x$HRpR z@8=bsh#fO*R}&NmQlLTg8n3l&^UIynm6o%N>oS=Ff*`tb;Ko8T8%zE%-JPQe3I^vx zJgX`sUCfw0;yUc>S5b~RA~#z!FVW0w46`Y*=7WE|Js5U6pFw(_Ibvw}Gy{ZxrgOum zcfxr?nYNjBJx=4W<8%EhRH&QPdL$HRrU898*t||5@)kIc6=(uhWBjLY;J9@{TjBRO znlkX%VbK=rfGGUH~s((&jlbok1uDhZH<(ztryHBF=J)DK_Oy(`XMcj~=X) z8xT{>(h=JlAZfrn2* zFOM9ynAFlFs}T_PpAEb9BDLZF-WflC)s{ChR!W8If~XMN9kjD*PAVOU$eKJ_qQ%Xi z1}7b^8hUbOH2~Mw7Zna)xdi8tCylN0!Ain6i)!nDt&f0%x`&b-%bEa5^Tn^_c7pr) z(B9eUSa{G-c;?k^6T$Ypbno(17-sD7FPxBl*<_Rp+tRB?_aSfAr-z6T8*}t@ zZ_<#Czv^m6xbH30a>Swui3!#2MR$u^Kly%|$(DgDT-V+rkw^8&8Lw)7Amy|veDV)N zNvfy-uKI;sjj0p!uIUUqKMR+&dUggI6X$VPDO^!q&m9=-gxlJzgg+W6Xe9r;tpoKVook?BpD^2pMmgb0tj^?}+F#(&2@ zTE7LwRNvs2WL36~zXsC3mTn4xW~f5E0{TR29qJm^^An5=W`f+%_P!U{)Gh}%tL6k( zxJO}^%1EJsq0&izU zyln4}51!m|Vo@EraG+mk86xCl;Xqfvc=#6c}q*CT(Dc(o5T zecF_*)|zA!&9ePBVwd~-CLVJ#U~8AY#Bd@Mw%*=R$Xbk>NdU4T=MuR$!*+kI8PP82 zkc3%&zTneErnp%7-?ogFkT4B|Bt%#GBooVyC3&HO4h>wGB-DbtjvLbG|mo=aU0Hdl&{6kP%@d77ru ziBc7=Kdh*I%1EsNw$K+Vsyep}n1AQ~Ji&^@5Y*NQ8E#);wTWe4PLy9TnR#7HgFS4! zg<<*fq+bQ?Bt~&$JNN@`&FZaeMCuBEXIQVWP~D|%WNvb(eEgLdV(vy3k?z6t=$L?9 z(DztCt`LH)HD^TUx9VNIs1w8)F|WJwD02951IUb}F+Li4SV-{xgk5lZx|)%veI48HAm606)wS%h988>1zwm%-w*nYD8AMX}DjG?+>IN z#3|plOCK$61{CxBc@-&TOY`BprllX5eNs{Dsw=oTCM>3!1K7HP1OH4w%GSdGa2R0h zcyQDDNtve>xcg~D*HGuv8b{^B1mt>Nj2i@4i0liqU28_9{E=Gj|-ACpWdbuv0z%iNs0R&#p(Q$C*>$& z&X#56c0)g<0mog(jyuluTyNL_*Zc(1vTv5ibB1r@V^zQF&YdrxdCX5O5R#we>1t3W z_DTU-ZH*j+_bo!cYxNAE%8xmji+aORkYa8lxstsjt`4P*i}Mt86k(Wm*hzJ^@ivBt z`&pSL_G!N!_l1V7(&~5ceH6kl&hn6+x>m*z#_hIH?wH=Yo4MmZ#<{i)Ux3T77hIOng?s%eoY`{ zlGXdoD|yyW#|iDP0HM|NI3aKgp^{Dg!J#bP{*{XO6M@J&$Su8~S!?FE@LAx~T#z}~ zgb8=+u75{FCD%WFGuS)ps%n5iRYwc6|Mqk1wrUw6FBXXA0q;vqhdRfGQ@05_Ym|Kf18phN(4Cv>>C`1$ zQ*#HucGt3bn|+2)`^L!PQ1(hIeuxlibnqHeH4q8@$G{hX|f zW-%q{U*+WF0JR0XVpugjH)3zseUs0f0uOI_R6X%}S>j9IKTsE0yMMsDXLKWJ5Y;1bg_?@GpUN9P4va<{w+ zp*1Ol9`6!AB%tou`@csr+03rZyo0vQ6|xbNS}t|Ke@`YDzcaH$mWfm7j4C1!(LSec z^EB|poxM{K?8!@!rWnQcv2QAG-gIm;>(2fe7gbt z`px@Wv>Lz?V=adP{swDw$izFKo(}XHaC(6wJx5x9POZ3vxX0zugCxHGX)h9~h%q6} zr7iMfy%{^Yz^!}LjFzW3$gc`-2kCsf(1$-W^ev~xgbag!N(rp()Vv4o4^F#0%@$*N z7V_mcBJzpD>sSs8&}g;neDH&E;AH(8!W6h_IfV3rk$W??HT2zwn}>}#bRc6xGrhdM z|F&*n$rAioCU*GQ;vsya49#;~VlDWCl5Ag_{DK%)u}51}-yZH!yl2v-&ZEd>avwF7 z!Nz%W@kPBZ9-OVt1o9he-$30y{My0=)q6d}Ob+VEex#8Nul?=t3BzxhfQ$s{g!Mic z;p>xr?{0i+3h41l=}qCq5Gq_~m9X&lMj5Xw3rM!D3Zs6JYS|Kb&sT^Im2DLjc#tQ2 z@uth4AHQW|k`6Ll!nR{m@@+Mz+kua#-mZ3btfY9~zuzo}!*7{(5LC=m0YQ4ERHTrK z^6ojY&u@R=`q`1%5l|L&QBjOe&)UBOFW3c6ja`Nu1HgOrS0KYu|>JeS5*`o8CU;EPb%Q)4?}OxHayLCaf>Sb9^m z6qYufiq5_R!<3h@VM1D&{1MF;6!o!`iXPqMif&6Fkz0Xo=)b>Jd35BZZh3~<9ADWPH~jBYa$W=M&d zm*Ia)1{#i|)>})((B2kmra;TODlqgxg(P^yHJ1CBkfSvwd;d)Teq^ZG3P{?zB~B{d z&yB{1!i1XG-L6kTf1$w{Byz^M%55l(GUGhvYApSrPr4Ra@Pc*9Q3?{a)R=~!GCztT z6+-3;h7h_KlNV-LS1kgDY@quWlf_EF1*gBTCr2Y1zm(6cA1l)Fbn&fndG@A?LPm+RdLhDfui?>vFc95LlhGV1acnvn;ll& zoDXeg;H*!W5ND)?YvhtkGhvr8q*2|9QsRz~RCh{2ZlIvzJ_n}O-AFtHen6-PY`6IX z{gJ>YT_tds&WYT7@X9bV$9HSC8#pyOc-G0<4K6E){>ke5UXtjG=KLGB9mN;H9 zo{8PFsHDVa%3oVxSKG?aRjSlM4nqni;PbC0;xx8=RI~W{Z+-u$h$5s}2++Hbua!QI2jfvvD?83G3|HX{U%(ok)y`r9pC$hs%y zaJ3m}UL99h{Nc2MM6MVa{(AyrUH%k-I4a(EdIUfuHG(TeK}VwCA5w$?zwVVyzoyGgToQI&hgg}9!r5O-g~T~8$Yzr%0YV$&e)ht2~B!II{|yH zpaF$IpKiFd0cK6Zi}ZR>o(ApAm!OY5%vAX_*exjLQkYBSs-?ew**U${lMhJak4%ST zZ}a2+O%puM+g4c}Bko5uH>}MEFI;r8z&|8!HITbi^4y%j;Q$Wwq+i#BnKBfNFSj4@ z(6GO{c)x=d-_Zi}+=aqLe-OS94u;~SV$*z0VuKj+sEbLzHz};DJYFuLq)XBOUloKV z$`@xSQQ$1OKD05ae>eh#e=ObW!ySgM_%1dRiiF;PKRP=9S9t^9OunLRS(y6F0x~7S zlv^NR(xr!@nP_U9&qFPc<2(G=>~B{znr_`JmtQXoIXjG6sP8HllH$#61Keje`m9gTPj@T zZcND0FeIshH3Ij89I@pnAnv-nJa;ve&;AvxomVKlaibu|=-%N^V{A-x248w-Yi1al z6J5%K^jW=A<3x(HZuvSwTxu4etMje^>x-bX0D63=2=^Uizz_wOvV570s4+Ht=D_J@ z?RN<5>_kNxLj{gkP2mAM=eVzrQWh5<(%P1&H~x#g0p=QYm+N;K{Ql&c1Vz0pDIxzM znvj~tcekwTXs8RqmjJYAlqOj_q!YWB0s|Es5qda8XhZiSo5y0>nci?yilLF_nqj&4E??3VJ?57Hj;H53ny&PTiH3l_6q3K|Nfh4w&HpwL zE_BuW%UF^EP$Iw3QFS3m}lu*Z;LbN^! z!RvGwY}~2r%o@6dl+nJzU^XgzKW%em>z4^+7~YU5OQ`T10<5H_U#Z|;ueEK!4anvs z09?Em_WKPrlC%2{rVs+(dK9D4Q`Xyx!)GkYQN1{G)5;b)I{bLgO|aVqd`{QeMwLbh zvuD~D2gCNWhkzFQkpm3B`zxd+G*5>~C(Cn{&~wkdcJ=JbkaYGE<-zn_Vf6FFKon5x z%RNw^tA)PkD1LL#ulkTY^CttE4RiYX$C-{k1ULl5?^*abW95U`Y!7Y=PdvO{=O|}F z9^{%wfmQQR`d-JB*`p^sibd+Wf*E{ZcOn27UC(^DVmZXwvI$7|Nf^8v@d5wCRC2H& zI>y`UF77C3Y*E2fz>pWiF{f<}UN0b zVR$I(O2`A?jfn@54fzPR&VHfT=-X+M=wz1za?kfJ!LOLOm^3WkPdKd>LEr4&_p>X; z|KN(3!?c{#?Nog5HKjrGuVD%YWaokBXM5>@N)B@IV!K9L6tpT2YuvuK&|=?!vHqY& z7k>N8P?KX{&4LsdH>Wg1>qfFBwXK<&PM!LvN z;nNui-g>4kj12M8iYSS;q){aJd_0;7k`lQX($c)vKmPb3CY~gQ8}Mj9rOjp{yD}j& z#1N|X`)5(i^zfU9EqcObjVA#m3d(|>S0O(a&jtf36cHuAKG*;3$;MDZfUT#ImJjow zjKxoOp``EqS$;5{%5IQcJ=x+BsikZ6- z_;|DgPtcFnwSll7fWfbzpO?3B0ZU2dP^32HkpgrQ{POG8ruYNmufG12|mQ%=6A49{4v%Rrd{r z!(q$H;0rzo8VoHNI$8~}4#ySmlcR4VWig9BHG5b2XB>F#6H9a6XAc0~h%QRO(JS2! zCps+-JZh@x7U*aLQuX6fZ!!OJ2r>_7#P* z>Q_RG?Va^P`i@EpP`b;S#Nr_)Ag@rVt}_q+A}7N6%5$Ka;CL}mv%e5DH&YDU-*^P9 zZ7ZeW8iY2j`S9Dc;weC`LUq8p3d_3wA#UT0s zbvo~YpS&2^Ep1tz9cxx`S6x6Cy{ATI)27o-tY@Bz$`+NPI9&y!jD-Z~4jWoewz)VG z_$8bNt=@i?=(=5edIRbEKSRY-gUZpZu9^;biU-*1A-xSk$b z-$IKXend3aQh?OwZ0I%M*;(mLEFo8F7t(~i#{KvWam0Q?zlB~&johd&(Lryekj{Mh ztA+SzZUFuV4s&t(#Aot@7qFg42bM6p$at={OpM;0Ym;v}$%*6r^dpkti|b)oJs9>b zfb*9**%1%eW+^;y?FAS!Mnc%>>VGj2VeMo^Za&;TSWE7!dfyQ(Lr5!h&%9clCtMtT zN|P_P(qtkqHq`P1e_m~{{2eD`*s1FeimwznWW|C{0qoA*6fyP&==$_n(LDGtg+=va zc)x4q@s~2;TvOvw&-$MxpL7DUDk^Rj1~FizlbAAI^rxvYDjBAt+npLCHYVZy- zU*cFPuISPRqR2PvdzQ1IM;dg`-AYistH1qoWb;J0kSKOZVchrI02uRqVsdQ3FYZP_ z6q3Dh*E8y{Pr5ei>g8cVfiY*rz^0!{vv~+uUpCW&aWLSNyO<6=Sy`raaXUrJJjs$o zUju-$;)Whq5w3fl!=zuo5BIlcfX6B_AdOOu|1q%9Ze>&_e#>?sHDd&j+U9I23IAF> zxkAlWHM1AYWpD;1*43ViUu+-kQ#>EzsYZ0u@O#LUgbNi8>G;Aca0J`JU~soZ#O?Uj zy_9R&14CVFO98UG^>Y>>-7LazrYp63wYQNz{#I0@Jm7DPi%*P5BzQsTXP51b-;LfZ z_a?>}z8r6Ec&E~$kpd*Vm$Ikl%Ev3#)R~^~>bhC( zj4fPks+f~VhRDoT?z2B^ZbNXyJ#xAYumJ624(%@*zxV(XE z?aHTc4$G*v`!@g1r)8vva{wMR`LinJ7SpmJVB#ij4B(WeeCYiIa<2X|09kKBu^$~l5ZBGiVS7oK_gv|Gg6jB|I?=T0`}v+Dz! zxAJEotwP480qT5eye`y62V1zId<>Rz*Gd#o+e#a{RUKB~eSmSwJ$Pq;MO7Y7=qhK& z=Gml9g!}H^fYSAXV{d+=(1I1QqKVYIMiBkO$maB8neBPI%j{$8DLlV0Z`plFPVGQ( zL?}kQs%1b=x3xupxSY-U825_`zPC0Tp?PVJ_BEHPIQeQ8mmv$sP(*8=LZEbLIE&7_ z8ru!LX*;2+q&1oD*)l0E>o0Pg7ckKTC-a-3P<-a~ceM@|;E~e6_|jUZyJCztm?Zye(-q@iE}81q_b=k~jld=c2T^WV6gD z>`g(}LG7(M%`&tn&H^?PTcr3-VI&WoNtJTti^Z#93~V`Nz9QF0W5(J*C-vxb4P9!! z7u4X#AHm74KtlNKgI$y#BAcuCe$SAetu0TMdiwJ=Yo079-4}d6@C9$I%(|NJE;=oz z#`574k2L0s4^6+{%dLI798yF~EVwG0fF^$U>0Hx&L1MBn2crB{B0M}nnW>eg;o{cZ z2~(%j=e`zgCWlLWJ<*kISlnCqH0+(q8}10sgXMRz1Zf|4PB303ZT;c~c27!LJHaft z`dw*L7}-fkGK!g^oLXjiJZ7)RbMgEVD5nMs91v!iK<~~77M$%~TaxBln8Bc?sIvhm z7pP@{oKtzp(6k9AEGZKtB*T^7^>D?)($w+x{2xfeca=6v1s<4}=U$V*AWAAz5~iu4eP)`&p$6xayXQ~im6 zF)uqbY1L9wT$SEx2;;`N@V%BaEfc4`ns>rvOehj`f78Q1hT3#hhl}R`+2a7$u+!O5 zj`g$5CHqSzdZe4S?^CNkSK;?&Pl{p(%trs3UJ|5-l+v;mnc7WwQ-pY#s~!dQ6;BFf zOd`PciHH0#6<|J%*^n)sD~|^Qa5pWsv7<=`?r`jL18iZQTtsZ%kJW|^Fm6+_1H+o0 z|N8feIE27a$zrv(Cz+K*ife2P?<%4ABntAKrkslbekuj7E-00|%x+7hS$izJT?$#M z5=H7gM0W~GW{e-v?v!H5K~W~g0SiHEN2e`>%cJ}Rv0iY`6)c(=PGK58H~M4nKKY+# zwNIPVZHN=~2ADy@n9XD#@0Z+;sKJ~{tf)Ei%()q33mHV;DsPLS`A5U_SdrHCLu6S@ z_|(n5SBw5ux574&vv&-q#(7MJAed(3%X54F>4oSl*)sPB02uLof)*@6n2r!C6`i>H z9{3(9n0u77h<_eTxIA^r&N5ZurD*5lQf>NC2WJFBT}`|sZX_M~k?>iza<*|6n$EB5 zW0GIVGoP(21OI&l#)QW?RndSSo`Qlo@K9A+ylgfMMBw+qtnp}#Q5gNxJ26eyF4F-! z=U;mEWu2V%mw@gPc*d;%GGFud0U*_$Fk#l;K=PgB=?tbIqe79#`K z6004_l7)tts)2BxJgB{+jQy~EAb_-GNa|gFQaG_5+(1#V@e^c%ruLLVYl}C3b{|bv zY<+mEMc`jk2}dpt-W^bJuIYMvU`bWyk$@#|Lb?8238LfrUH|cn->w2EBEp+KuPDH6F(vw06rMHE0dwu&(GtrcWc{ zN32e^tHFZrUNGUmi?rQXzYlcl6xeRxKn`C85fFxBo)+4`^o87Dti4bE-U;T|V>(hORUW|QJDn4M$LdPBn0mBxCB2^WNu{FFB*D3MbWM5jcXF^-# zxseKim2SyLDKoIWLrqP?6@x0}^zP$A4DF{>U{ft_l`v&-cz6brC5Lf+(`oQ-t}La- zf0r%epg>QV+_R@gmUIMp6`EP4>`g>Yrf#l+$6De}#CgEX1vg$p=@dz|IGRP^Y_38x zzTTpJid2cJ0QVdVOIfG7`;6E4 z2@)2Da_JBZ%$x~446!wPgQS7m4MN*URQ3Bo{DODJ`kO~@voaSn!Q@chTo&9 z9XZrASL1uhiHZlPjl9dG@+EXzMUDj%PA!Gm;L-En4pw0n*YG}{Iz+Ld+2WyBdIMpI zyDt34b2AKh`vyoD1=p9s8_ouhX9bssyeZ@@FJ1TJ1kQVO!Zl#`u1xu{h1m;x@Ry5W zr$omTO3uBN^Hn?IpLwi!0z_+@Kb9*PGrG5{iIo_Hejtt`AB|#ywg~V|E{=L5teJ2* zbZ{l#C$l;7gdlF*PUGjSEWGQFi?<~AVA8M&ZRuo1r0b>Q(7EVMRwo*24ZxO$Iu-0j zdDWQN@a#hR@>W=9J#W}UWVi2sXHpJSKt|LgULMG}K+Y$qKy(w7+DJn?e5Z5c5-CDF z5k&p<@-UKHycxH&;h16hK1~pG4-B*5gTT;VU->+SyY8?h00*EpK3TwJrj!QfLO5;lPB?-2d7N`r@9mn?!>xtU zd){+$i7)2k8K?EIM`L-v$~Kzi?F7nTVd|rltLeGZF&a^m3aYFosHf-}~=r-y3CvC8vD5=u8jfmNqHn zbJmaLE^i`{UTcR$(BjDeVNW-#PgTMhNdB6V88oui!_@xjio2J(+UJTeBV;F;wNQYf zv?Y9zSQ45fvMp@@Zk7Qq9=m#SoWYM2xS-jg#cLFVTZ8G=6MTgFet=15-S{d{nB0)v z9=XkNQqnFSz@bA!6)5+sgO*w?M^n*Vd;H&yW`9bf2w2oFh8ToMHqiXCzfZe$Z#WTp zQX;r>iw^HcoE_ORC|IBZIDqIIAAN2m?@2?ZrP%F0E|R=#phF&U(Cz0e7o!zZuZ6Cp zYD)274x}nC-og#QSSv9~Ygj#%{CBby4xMOliz-w~{Z_aN)P!H9G+yYMk_8lJ9D2pS zW;4WyB>hluHd=pGM9V>jbBE@+Aj{(ZyQ~+%63Vsm*P!O3ivOnE7`fg|ilGG=1zxG} zG9uhQabqzWvQ+1OrIKjIL@mOw^;i}|8;<+E@!zq98_D7LWojEou~vOa;FO6xr9d-U zmK!NTCZWE-i7~vSh+Y|ZTY#Z$wds9%cu^2TMyS;b84$u9@_Oxjx{KYb(Kw`~xsroO zJVSb!vcSzC&sGRA(c!oinlbB-m;9!M*2-7-TbG3927=j6IQ}M~SQ1wRMY|RoHLL7c zzoYra1DaIj7=jT(YYLI~g*UZiAs~U(Psg{1jhSM$GyvVI7I>_jrA}@IlZ^op?)yfy z6-$+?F(6&7j~A2+^nR+JNcW^7qqB=Ha6Zq&E$^1Xt#4ui?jZTZR1NFB=pp**U_p?D zpI7-tY42!mxaNnAV?tl$74H@)c0FF!YmegQgxmRD7mW+fY4lO)ZIFjBiVat?T<>dh zi-Im<@4x3yXZ5@`zGis*d6iEK!f{MP>BCsG4drZPz!FfthRZ=m!MK_kn79R{I@j=M z6l9YlDJEoD^JD>h#ZH0u`gt~_jSjzJ$L9~Ky|`?K4D-Y51i)M_5)v-}v3oW-Iz@$7 zO(;cnr=6CyeCA9QLW@;786xPUB?qyGcAs!2$Q6XsgK!_gpUX{49a-+Pg1JQONfk~Q z*X8L91H+)`2e-|v%gP@nqX!}S$K3F@C;DC1$Nz}Ho1qX)_40@tpbr22E5x1V>esLl zr|2-=G>I@!ndUWl6XZ)nC-xSIg!I#b>Chpz2&CZQ)$T7B0)`TYx)&x2>K_D8rBstN ztVOvO?#*z2KMy$!@2$`T{=5bRm=onl&+~7YSSrKK!LhP}|4z^(v^s<{6ydIc^Qe!m z7FS37X+u(RlueN7jWSsfHUK{w1yDcQMAQHED5k{`dqg^4j-oFij)Lzi$a(VnG=42v z-g6>V*1*tKT7Mxlvg7{YM6GrTCeo<>n=)r`ci%QJmgOJ5+t2Fg#14cD4e`V1qne{7 zt@(d`!55Rv%wBu^Yex=(R;tZ)eyTpqD?R)UxDR0>s?j|sUhE-?5b8JS!U!&lPLz*N z=^aIWB(~p{?k%1@mdg~v-i+$$%=WWZOg|aQx#VC^dxZT=fg{yiaTZtjXJ~$_AnV1I z%%2Ro1Dl#n8K2+um3CYmuv(d^X=5X7r3e+5NV>u;=V=H$H#5N4Zgs5{^%m)iA!oq4 z9(a!w8;&WauRw= z(4220U_UPWXP?e%%Iq+CPqeF%ql9U*n-<8t61b3Z_NICex~F7_{J|y5L&=p^ROI|# zs9kSFvIXQy!Q-CdVT~x|jYyzvd+k19+X>b;$Zx~!_4QCJVy~)`{(*u>9^twZj9B8~uv+xt%X~9Sh zI(P~aRR!C+xto$v2MJ#c%&~Ey14HTQTGRhKjZ-SFE%*2l@aarVanw-enrIN3~m=}eztiS_>sA@WW^9vf|NW$*9n&qqN4R5FcgG7g|7juQ_0 z$mW7|Byq0*6$RMt*5_L#5j*{za!oenVu-8%TZ< zYD;KO?3%i2u`w9iz$71loGvBgk?5F;ie$c~L&{5?eLV$l=ckdqhJ46wOE%M+f&Cy= zwy;;ZD4UlG4`aqtP+*hCpJkX={zZ%Mo8MU6VOQ-DQKT|O)VLt&yqZ|Osa5$LG5jK#8VvA{J;`OJ z)-Ilr2Ifc@l*<4(RJ>BqkQZONFJ<*|V=Dr{;bMF1EMb;}>1?YYUF0yRpsYvPlj`aL zgw7A|=;=kD>Q@ck%=T)kg}1*gK2he%&Pil_TmpQ^8TmDF)bU%etQa-u+DN9>_-1Cwg^N3v=uskD|(W<9Ny(K4KD+f;}NLi^1eH+ z(1VvR;@_&vR|)LwsS3kZx4P8MMmu-3S-BIh{?vMI%oCYl@^xI+!I_M8+G|lpuff3% z2)302)b^~g)-|}C5}&{Wpq&n4AnVHkUqpIah$tr4<#PF|j~cJJ+n{+H9IJ?U9-i~o zM!j`D5rH6n`+4(zysmn0sSa4W)3sQ{>tDOb0hI3AeZbxS>g;LS)o0F2fvq&L-uQ=I ze83wDy!TRk+|_~PKTNID2hSEVyw5->`^0;zujQwAT$&4>J_m(*Apu)P!Lf6v#)2Do zVzCUENTf;y2M~=0^e8SMov4n~Dp9EZan|)pjvO%Tm;g#)u)jP0i|CHfvMWasE#KA) z;{mX|$`CVaTH4Z^S1^`G05@19Ki%XZE7OxnN%UT;z)36i$+0F9HO=`}O#NL*|7E_e z^5T@Mk>z`hb3GB-lVfgVGpJ1r1G|(R;GL(g`V|c{<7%=J#!a?7g~(Oxa4#Njk>irB zL09FXXih&oy1mr%zy1zFlM5VG94Uzpr(_rrxF4CrhY_bb=PnU0ZIqhTY7^_1W5*7Lfqk z#0h?o;|sT>Owmv+`f>YuJb*8$vU+66(&l#{h^~RaLsk4bQf*ECQr$sHT>M5oZTDLH z81VCick2k$P5v()QWz2JVic*lCmVO9D(u%_~JXiMPf+B`$zn)zy(mRyBgDfyY z(}CKW&01(cRUpET3GugMPDAZ3-9aVckMfU`&$fDwzR5S`v*07gS(*e|q^9fd=hZ;y zCXl$N&)%L$5)yT9wMceNEau-pib3d_Tke(@>1)~*vOGz5vB;yqg)qWnZ$4jAknKQ# zLyC2^%)wYMS*FC2x01Hj3c>GJLuAAY`}?)S)@#9p-AVTwl1KsGo)!tgMETi(nWjPEj6O?AS#|qVl`&~ z60eSxCnt`{>%N>dhoF@PCV55|(;+HT5s-LrRHulL*l#Z3Pc|EEplSpX*7@_U)+4|j zO;~aHgBCwLCPo@VN%&DbyD166RkJrq>dEO7LqLWXL^oO3#M~y!9T98nt($MFX$TtD zhtN%>4Gh1vu(2vpt6D3%4V;=1n{4qkqY;v*{MZN$wA8oyednpawuK0Wpi}yWpCBUR z1U|>|mh4iY2ni3f_ZA{rIhQV4a5Wz4DP|=9J;ybkKcMK;;z2gUjozElaAL~N;B#V) zcJBTZmVv*NzJnonM@$S|+rn*$qKB$fz=3_%#*rwVCx5Tg+=~W>8-Ss zhn+&^hU0**GgzQ4FJvr4|2@3qT3=6fuUDc>yE0!`b@&s?;Y6wB9U-Rjsy@2m!wDo; zKAf}iy8xBffcGpj0}^h9t1Qoe0UiBKKQyyFM<(F6Kp*zAugqGKhtEOyMxgmt+T-;B z*UL0(W%8@Jxx(Y*;C~LmOMgR3S22fZGXJ|T%}^9p59ktraA(Apks0rBdD^MxDR4)*P2{Aa{Rnu$C% zBHV%lcQ=jmn=|L?OLog!{~b-M`R;X@78sgmU{nnH`H=3_3zeU)^W0nsJj4(j*r1W0 zOWEPCBerg(GTL2NO?K3eG`j5oVz=y>)PAC`26J)VzWA?|w}1Fh8iHs#%Rmn0Uzrfd zkjRl9@7=4dYdP|nO5T#_A#K(S49UHLY)7Gld3^o!1GWmQY885ev))d0Z73)Zp-(R z*<6^Z|5zGJ{c_U10>W}QK3T-_Ti!C}741)6K&2Uu(m3;?pr7h+`b!XacqmGO=XSRQ zL$Cq&+(0Q>zhcj%(1i8S+&(0y)1Bsv<2$QY)}ABh*RjHAy=VU5Gy`7~5{;`XsZfFx zSc2?^wc!u9Kl!c1fCM*K2#K|}T+X&QUIf`K4&A3fKI9p88jGeB<1e6Vj*Sz&4SS7N|7UGCx|}Fx~s5WG4f(VS6UDpessF{XshLgE3D-j zPW@pqIxEcwu+HAowmyIQ+^$q}hw~Embp|iiGIXb#6IZUYgJM7~nhN-z^MInhzBK;J zu{C@AfFF?Wz@Ppbxg2+3Lnq2FWPTO>`D-=%4OhGtrnsqgNDG-9{=H({K%R*KE<{un zGbSWqP#b7TslliL1?~`n7Q!l*FXlmUH`maG$F$)c@z0RNoc(pG_|=iDs-Rc|^dxxX zN@a+UJlMD&%!KD6eN+DAzVc`b?2t!o_zt z<-tk|BIFd*u6z5|7pC!xP*mEiXwZBk`OSR*A7-{_^TT6?r0tOuBo^uU?mgk{^68@A z`Bkk)Z9(8_ObmC#OIOTQ5Tt>EPQ-sN{JB-b)jIxAjZyVF(KH0CLNV#a$)(4}5#civ zyx8HM%Bxu2fy>`ktt;VZ!$^}$}!e7YQyU%nE=8PlQ!)CFZ#=mbO#iUz0rL@B1`d`|ao zR*+h#w&fLHq~ z?+O>;`=}BeCBU)Kw^Fx;7}Y*X)JkNgzvhXaD*X5u>+Lz`q5B7AM#xE;k)Wb`p8|h! zU4n+qrp0-2I=`T29H%XQ9xhYCK6}UcKA?7fuJ;Z}7_`@Z8WQ)b<;Hw?ht3wK)#u|g zoKDctpG9{x=kpen9huH{g&HgxfW;{yRHflBNUol}F+fVxY$Z`#IU{?Y?k`BOXM6-H zLO~KC5YPDY_r&sUqhGLCJ!zG*!%rvhhL3A{D`Yntq%Iorf(A;b;(HKXVh7Ry-A7-; z7IEgyul!Ui`aYO2$;_On3jQvuuL*>;5^#8E6%d{aR6VZT3oja9D5_aGn$5gW_v*l|HZvSX433gr~g)N`f!ST}h%G!E@P>5bR@o zj%ce0Kn?zOk3JCUiZ1vn1zt~EFkswA$GJwdL__2TRxt*iLX+o$SX%2p=YKYo_c;?7 zGV^;&#c^tlt1}Z1AkYg2q|KLdGy8O1YiuDehF?DNnBm{98q#|BNu#P#N9Lx45+#T& z3XZy2)DTA$S4!+bI=b}kUUmPy{NQE;aZUM-xjt7uf67z0nL<-UDypH5sRnTO0;XQB zT1+JDzN=*UW5q~)be;*Jv+K$az4~=nVPn7U)5QN+lw9SBpkQ~vb73C>bM=*?XfG=> zb_s_F!_M+Cv7>ckRu(aE4kvJ#0Mqr%~+VJ1apGD<`wST>kYX;wlIR&(qsCK zrBV&Qqg5bu4AehXUgVgi#DL{dB z;IOK2>aw0hA^@{%!=+z)vcmF>t&e3u_<6$n35VW-3FLXi7A?w&;&FDd5j_ti3_SXc zATIawGDq(X8y#}1H~?KVnpXep$Atq0?ia*5P}?s>e2Gi9y7{$M2v~)&UOTUp3TF^U z;+~z0)BZG^SIoR@2_b&aPqtM<0aAaHII6)VD0xImKwRv|f5d(dRb{`ld;m;IA&rg6 zhhGDmT3nQ3?1lw2Z%aD6ZdEwdm{2g}O&@^ntIB}x!{e;LHKkVdi_{{Z;I;8ZME`p^ zBc~?+2SCD0lKObAg|tJs_5T^f?%6EqyHNgj0BQnunfI}9t!b~ncLu-S{JCJ{$%D$>=xwzMpy53Sl+^IK>?gJ z82cdAFd~JgrLDaqwa+8($2A)ru$F;H=Q;jx$Vu?`812Gc^G25a3;(&4V=_7u?T7IC zVML?=$J+z2$Mcr;+WA1DIS?!RC_No3=a&m zE+!(^l6()5%z~%X*>0HYj5xum%f}BXl0c6s5fh*c*&F^u8}MJJ@3ivUuUZX$P-QWl z`m^p;Z~3Sb>pOtmsM7el`s$ zJcMj*ENY?ybD3!7*wQLx`-{W_GbwN--h`1rRPg5a4f&ya(&ocD7W=?0fBd*;_nr$9 z8xte=c3R&|hDp=Jo8-!N?Vs%R?_i<NqevKna@!(wzhjIF zb~d=dJv;RBLZ`)J5#oORB7ChiB!LZV za9+iqSzU&04lOR<)4u0Tk~xu@D7iNGN`s{38os+X*s+yTr<0&Qzx)j2h-`@m@{>40 z?eBx4`YL4KbCZOBCE8`XM+nPv4McK5jQ8WSU@oLU<(otD`y!8W6c)m;i_dvevT92+ zvzmTv@mQMFpfI1bm~)@CplrC!2;*5yAZvE6nV7YK%lr?BnvsWX3Q zT%2Tp@Ks6HeikZFEeGJJ@MtC&1k)9-6`y$DWyJ2p5pgD275)H-ROBd#vGBJorJ&1h zudt70(Eyt~WoEMz3Py6&ybe0g6-RM2-Ur8`+X$FJX^Ap22<0KD%~|2V83Yok|EtCB z$pJ}ui=32QPT$e*33#sNLx_z=*J7Rfh@JB7Fl76Ehg(Em!gtk-mc`!mJU2tQmpMbA zeG`NEXwQBNrp%?>FTXBB|8Z)pEo?&bsE7%`M(R5JPlr8x>RnC>EZUhKf&tk+qLtXW zuHU&L)3)D0fQ`MndQtI$X6h{C&t=QY=W?v1(5(~3H-Ef%vr#IDM~@l6!-kFoWPy)03wDz8&wF zgeD}&qAl4z0NFU^4I3Sq41jIyCR-YyBye{mwDPqOm`f#KJc*$B09*_TnFOiTW7mU7 z|DJ^~?eTwmq0n}pEgrJ{_)TYF^2eue;PBL;`eMTrQJUpPtFrGIUwuU{icHpbc`~Ck ziq`G80jPsSW?l$T<^4?JOey|7b!!TO|1MF|A%%3M$DEp$$2m{Y6G}#P2^!fA-QMG_vImy2?DNa0Uzva$zxsY6ELWkg_B34CDX}Zbpg1E!yEiJ!l?XGvuvf@8daH+3+oPeTUXo0<6 zjlh2HwvH>Wzgpv^Q}^ngy8(x24&033ia4YKN0p=UL@Wj1xOKtbX~e`V|C zrW$au+pzZr$WDPzb1BzN>A8brxIi-tB;OSs%7rP|>+S>O?yvxg)d}?4LWM0U?q)@H zMDat-9zrs*FT^| z*>)7;E&ICW<4np5#mO99fQ?u zB*eus_PNmUCZ;R<)Id?$eM(XWM}kH0um;)&Rg)5IAaqNh*KsT{5ps7xjAEnLbCP<& zkwp9U4(dOT2)0>b_)-qSfa_>?o;IT}Ba|6%r2Zc+UBsz(<^9|vtwSXWDBnzp@xL`= zm&*bh9omIAidT}Yoc9?=pK2A-V4J!WT%P=VG~yIZ79KnPp^kCu+jmkM-J6Ve*l6w@ zxFWQ$g-aLoiU%)95R=(oSU0taDEk`+oiy9E5BtV0`j8CFYXcRHX%kokWJ;=?>U!(Cf3~)vXE)#y-#K z%vO8E{&U)4u{opy!PBh-!RAE5m{;rV9o?Q};g1OTP$QbdAXBpz=bf*+ zF6SIR)Hq_u_0RmLBgYmm=miqmtJSt{`aI+EV1}?KK%jCJbmiY)M@W8sFhgeA$qN!| z1(hy{ZAl7T)^0NN-;wdz7Snl%857%7eQD~ zQ_$73{_m91RH@pp1G7pKCeHm`or7P`oeT%fvYQ5!SNFkeuOK??1nBbN zX;zT82PT*|!k%{8C-|(OW$;D>d!{z)IciX~aEO-ai7Fe!=JUwiL&eC`M%%tmDF5}3 zsQ@9fWzgl)cvT1SE>yHNdHS=or>{GQ^uQ!3_WSVT@>zZVNYs3_cUPtvjJa9*PG_}U zxk;ZXy9+O>MI2`u4xPY1IAo71lK^w^bw|p$xVZ3UaGiIRvNDvFDUUnl20cG-qY~E{ zQt&+$G3=&(b#l@+;*T&?0^s=ArUgknb-Ub<@K_ z@pUzT;>q=Z@%`ITRU!e(E@6AsVvuTk^H4~=ecE6!xMk7=iS|U0Yl%zcZvqeHe zua~qx6QWEBbQX!wI(~DD_S9A^ zx;1M=E;hy+mp_Xavb3b~j-$neJ;8|I2JB<^3+@u=2+JPVEBBM{1AJm9lE!CR>U7Y` z&IryvE>OgW|K5k=Dk0>|aIgJoj}Y{8x`H>wHPk7$I(0~suT)qUO0OW~Cw}f!e3j*Q zpA&M(^->Bu`4AXylvD%#xYlnc24{ZfYaiLDlbNS`ZGl(nL2-r&V;_KkT)HjUe#g1} zQ9R*rB_9!^!cUaI7x#s~ydy_gDTOb8d=~bQmBFUh)XjxIO_3q*y2v$;`&Ak@av=Dl zCcbU?mNVT4z?0TMXAPvp{4=HrfG6bvuRkQrMU z7AA+KI5f!gh@!T-~=K63k44P@r^{0PLau92L6yq-4`|)xEtkD zRCP0LLINZjj)XQIngoEr!x7|r_St7M=InATV2498O|DDK{O$N zw&3>}Yr=Ch_9oyToB-UI#pFiIdIfeN0S`_LA@&mtMFKR^_19lN{oU_=m;K~pHZ@7B ztbzUhVy*V)0_-z)0iwjX3-Ad-jCe}XZn!=mWim#w&=A)&CtVNTtRjGL+mH$OvTEOc z7p-rNDew_bX>xF9(@4MfawP;|ea}$fH`h{nEUWwmpElrcL;z(Z;D+q*qCuNZNK*m` zp`rMI;kR}r0gH!8_t;~PO@ICCUuRKL41Gw00AUl^|JB>AA%J%zF@VEg(H;D>XdG!Z z6!7yRc-7``%_7hfzsJFwQODmG^hE;vNPxT97x>;E=NlrIzFNP`-7S-|-F4S$r<$ro z)@9Ki^p4%8`|ten=>f0(kJIDd{Fl>je*Em|`S04eRYsu+sG?y9?Lmu<1^)E=fC_Ny z0)$2P?inGesN)|4_^B8N?Z@r(dl&G>v1i7d-={Jp_(MW#N9+A2z)!(%%y7U(N&nvm z{22k{8wpg2flDdTpk+5Y1_`)%z@=TVX_JTTJ>Glw-FIiF31dwfs*V5Hbs?t*m?|pb z%9Q!Rd4NU34wluTQ*}s|DI96KGQg(-JW|#_<2e9?Y9AcoOC44l#%y9z;EK~ zn08A=)=SHgrV=?gc`OS4VIR*)kXgCs^M#>&A;8@7N z`qi(pBg2?^7IoK!)@4x}1J}g?rizQMzWVA)fJ9SGi$g?rk-$%Z4pgGLl4G>74)>?eFX-j|A|~{AWs0h|A9E^H%8Q5Wfcw^W2)RkLnTP!eUR} zHCqmui(GV%+Q<|zL8o6g>sS8Zw6gkhtun-$03NApZT+AAGkOfbzkxbyr_2Vv3`F%Cu#bMd&a%jyp z4~Q)~rYo?L^(|%IhYu;hQr%QDYliD zXy6V*2w1q%M>QbGLFEahvO#&H>tTg?XN3NYwwXg{n!gi(4`n^Bi6Fv zZDT1n|4in}1QpU$`U+<^(vzB&Kk;|w5$1;sYQz^cF(WW7I%diH5JJ_h(GSqAHVIVwvl#UI#xE`Qg>`*m@fS1!2kR7_(2>Z)eYJOhGk z6kTpab++PAcCxwQNKCkYF4_*W$4?#=RlFDVTHyonKC!Qy(trMi1hvvJD4JY$aO-1k zG5}|eVyh6DxSuadzWF5|eM^dCTTSv=h5!6b6O<&M&-@TWP^@WVaG7Shdz!bN~$GmzkXU7c@uB;Kb5Ub zo0`rOWC~>%`;|{ROZXLtg80bafKM`k0T-PQmZ+0(oS$$*2mE2u%TEKt@ULm~|G15yC4RssF?ORt*{@uja!&`V&Zs=&<OpG)wi%*wrW@0M}-|?_6*`5YP za?#sQQtOHrq0WX{xPrug6bm9nsTu^Y&MwffB=F*@Z^8^JPF#0^CQw^KlCX>Z`BmfH z%pN*U@^8HulXU264sQ>aA5R-exBwM7741*9 zC44of$Wjs<6V+*TI_t^fA4pTR1e8uAM^5Ay-jGljg`f^zh&e-Gdo}ztippMLfWL8W zXcFZRrW?di&0F&ZTEUR}SR?I9_10pddX?a@Y{)}69CLJ07h18Y3k+4>8UucS4v0%` zakmiE5mD^@Sep6-eMjx`0wrV5Vh0CR7QqD!d zw$)2awVrU~ajQ5|E^ySC;Pi$c6#RA9XC?T*j%kBZMQB7SBm!%ZF98y4zv;6*O`Bqj zMaqu*Pvzk7@m=t8)454x2|Qg7CUXe2AKI#WEbdW4%ZV{vZHOyfx*Lyvj^98B8qqsl zy9nLSg_b@|F(pF|+o8IZ`l-LBCrN@9*XZj4g4v1t_8h33j>4=~5FkVBqXE|B*xyV7 z|2zruCg@7TAXKGFqZ>FWXV$Ll_kP4uW(pYJ?CMLcy+hy?6ouzQb;>1jm8t@%7;ZE{ zyFFa%1y^$rJH5(JwAoJHt(FOg*oY4J|E_@0kPfczmEk>)89!cYJsCpSn*7tc9oE$9 zFL#ODwt$xT3HkqFZOV>DgKv-~-(wnkqeb8lgfvo!Q4aoPFAqcJOj3}wNPx?1`DSJN zn^fG48w+E4jWKl2HH1(H*NaCeouIeLuAV=!&_#hw;%CE&mm~fD{roSUztz9Fd!{p9 z64TtQKWSqHrb@$=6BONzEBGyv{u%Ydh2Hc?)pnv?ZjxOVd5#Z+PW}8Q>n|L%S(k+L zPyiH4XI9cHXA$A$#)86spuWf1WB!eF>xOLqi5Y8TehoK>FMgIH%nr)9 zX!&VaGRp%?oWyvt(h&c{YalqG(PVTDuRIV*QrK_3B!7Ctw85M0GyVxLv5n93()Dsa z?#NR{q+*Osp?X4e-1lRNa>irXBE^EvHX*EufvT1PD^T*Y4;qsmi&*15V*`3J<$*d| zRBPa4;A!Ypz1o`e>MyNO1m9&6SPdPPHv&WlDbn|RkCH`{KPfv_Fb_ zH+9K~ZL0C#PeuP~T6ZFCV;S>b2W3n*V*D+kZF;js=I_tfy1<-=n>gGvB1DI3>B|zD z?=e|kW$hYz>w5PA|3$*$v4QaA^@^n3oXN80rXF5D{A6>#5F*{m3LO8TSOV>Zms-RJ z4~{%EG<_Zi2a;Ice-OOUF^SFE_#x=%Ks9d!<{;ead|hOb7qQJ{=oaR@d%Tk~ifxGr(6icEJV z2P2LRoh$SH?e&Hz=P&l*8XhT5rwsBX6*ZQjIbM+LJ5SDpbuoF$7QOJ3Y(cV)S+LN6 zpmW9J`=ZDjSFTv=)3h7BANiJaF7WRMti?8KP0*9x)?!d*Hh#e(y7Z1=P?#0(h+C5d zK3MZ3C_!`O`FY_`p7wvwnwhk#k`lx1(`+cXDMWs-4fN|FU`bdRCCjFMxC25_iT*eX zYt=qUXez?w`rXR>=yuybR254dT=z?3m6g0H+4s^$7SmJ#tq1IZ%9wuMmzHsD7gp#DqoX&qO|F@uioESS>*t)Q?{8uN%PRk8^!yLMJ!8JKw zwQixHQhcBaMr2hZ|E@5{xdfq1i|p#u6?N6U-?I3g`qZ__!$BepVcbw;VL?DPoDcpc zDtQ*1bjc1lb=c-T54CE*1|`+EYDoMGp)xU1@(7n?9#Xe9WzSPONCi0AH4I9eL|68T zuWo#Q14HjBWwu2|)N?UGzxbRs0aq#~J>aiOX*KS;VA=fWTtx4c_H}k9q9fmEifbne zJ;(2&P%gY}|B|csfRE_=3nP%dmLWD2E!!#f|e z;ig{JOdjMZIf&H=ZfT%{+x2S17_K!eICtX1!)-P0KrIR9mP01Mz=HojttYgLC{JTF3*Q`!C*~Q@UUGyWd`iKl&`$913`yzj%X? zzu$RuzrO@P?mi#3bia=q2fW%j3cWA>2D3s+x?is_x`6?&55}8s3r`rrZ`Yvr`_;#i zcR9-)UJ+p%Zy<}3K(?d|U-u5Vy+|M#`a_xp?Yx8d>glz^vz_dDUY`@ipZk58cPu0G&> zf2aS$aKL-ZrX&P4;PuWS;0f6M_6F)E6^0z-yj{P)e*piw8E_L807$-K?S6WB&u!`- zPhK2y_|eh*O8gG`07K^k{eBA`|F^sD_k-^D8`dZ3GcJL{-H+zv?~w8FcciD3O-Rmg zKoR+@&!GWoH{^b*x-HeaW}c~OH^q=-h%$M@=l)^nTj`5^&&mzk_rG3KI_M3FxD7J`p>D{x1+0;7F2|6wasD~|xn@9>OX2%$gQel9_oQlJ-Pkv!xOaEWD2`8t zhha{gac;zm>$5&d)w=UD7BOcy!foV>lZQ7o>-s4Q0lxl*#sVGgpCXI|7#C;fL6ap- zFSFv?b=3sZ!~HYw;VYTa-nS~4R1yX^kt&D)Bl0)6aFfWC}is|WOQh<`3u^?pEN;o^Qa@AroU@R-+f_=JC z)8?rUa<@i?KdD?v$mSx<=CsoQc>n2KBeYp=+9qUNWm+P*$#CuI>(4*NvGasQiBWoZ zn9vbVwkdP{-QSmGTwwbuiNY{&m@KdZg?uyQ8sFa+88z%MsGHh1W|$@H);*hFV3H?w z-^D^P>{2KG*6d$YXXZX;2CwKm#Ji7bLi?KI~2kZ}j z3u~q%b{OFvVi|0>@;!?^)(qz6uF2yUMBSXO=)|xA9SKzE*CTpqhGcujRXzwkv~b%T zTBwAX&2$Q)qk~mOZD!qR$^E{yS(v{b&oh{oSe0z1*5Sdq5wG%L;jp;6caa z6U?^1Dl?w$ZZfc{IYd=txdtg$I@k3ZO}C^jt=Al`>Sr_697_KYTr`@V=JHDK$|fnf zMhXA``uESSy#4(~GQf9_C-Er<;H#=H7hupXs(w3R&9Hyyt)tPjL8h1he-`ocr=D_M zjxSKq$O)A>2>UuNMz)8o-JS%~T?mEzd5r;~F# z1(ZL`q=h6h+8ZAgs>``@+H?)|4u8=P^5Z!L_A3dADe|ju_D^6KHfGuWrZ-=&?~3N= ztg+PfEN}3)CyIMFF?#9(pR}csbcb>;b1`#1oGql)dcG&iF|- zXy|rG>9w)8k_WeO#J=5jVT|^KLmiCx^5{k{apRi3PvHL+w152^@edEa^3K&_-0sd- zJA(NYM?jB+ep(sFD;Xd>c5PsS0aWpF6&7mS|9!RB6$@I})tB3d1+vO`@d?X;!-!t_;3x9Z%!*29t2w_=EFl z713Rnt?TUb;M=%|3>WtdTviU91+7HK)h&#x@+fC-vy0i;UH5s9D8wJKi|gHsF6@c` z=kdR)h{9ei{Swx8$0?p!Cyd`)Uw2D}*Y+CHQ1#UwwzYr3-*|VK4w(7@jH{eWIy!tvuDpGv!sn0gAfEB`yWpo;2IYOwu9>b8Qq3?=aBHLy@Pf(G|kR6`A@cIY^K(H%IU84+Efi|>m^;Hdwvo; z?5G!Ug`#uvB^&bn{qxVfPf*$K-QEPGIS9~nTX5OqD(>FvUYMPje!t$8u=je0%C{)- zI3Xopw?$HnztV=xU3#PR#(ZN{QjpiF`2^V4rT8zK&kMTC8^tNio`?#;4LjGI5lhS`X{WZ#pZY{%##bo3GaaB46<$eQvb&x>(cK3bwLu$pl z9WQ2}Yb1$`Ff&;q3fG^cc_=M2)m4CHy|ua5!Z7VBmJ=!h5Op;aXR6cIn)$KT+d6+P zJtZx(8U?Q56SZ5$IPi{ANU^?7cf;vO_mjtKANeaaUf2@fk?JRqLTx%Slo;f5J0K7V zwJv-+T3B+urWz-3Wt~asH*;aA!h4&Y?d7;31h7}%%_uS$@-%uj)0{J-=lYut&n*R4 z;SS@(A?!^itf$oyp~GqP;%|Xs*bFI1O^5Od*VFnf;AIYZ1X|eH<{GLh&HquSnH%*a zE0hc6tX9D7^sxWt&UDM9TX&z=V<|M934JnaS}Ot|M-8!xZpb%VSw8NHMUO(DNQtpL(EDpd_Ewp+KY&6A!mX;!cio$}Ec=Ddo77>C$U zJKnwtL4&+X8*OJbU~pg&i>x-&pHKw+<|!O>S=z`^5%&y7_1uIqj7dUxKr{hcup|{K zwv(^C6T|KEHgOEHYCX(-1&=b$mqwaEnqzL^yYyaB&lB<Gi`Iif02Qma9$vx&Y#<-{=Tl`HoI3IC?Gqb0M2u6x~AF&^&JD zD+t$uhmC?d^mB}=won0XzxV21ZWn$Rynz$Qs#Atr{&Xy78`)yU17b$ZIUjjHCz2hi zhv85qBs~l1k}CDPFz%j;%A&`=dI^`_$5sVQ?+hiN78a|qp+aIbEz`S8L!I^UKQt?~ zLq0by?|ijL66mB(rUyv<`uct6tTBcGC*1?oMXpa=6X4VoNB1ADQdV}} zu$LhoXn>W=(g~X``dYQTIIg|-)Lb_}hZWe_I`o%!$I%#Tmw1f(=teD7Ed73w5WPH0~CkH66abuauT%uc7F#_!?Yc8=yL; zT|(kvgd|FB!sQDr>ITUy_3`k8OSVlIse9^<`vuy{!Kd?(LaBgC>%n;iJq^Fu)2OCp z-o3AeH=-T7tmIU1%3B_TX7fi79mXQJIWB(}_O=-s>v$$LfD(UNvp)$z*-I{38e`U# z=)7s!&Paz7ds@1I#&RaNO})LChLM%74=53|UmvjPI>DYoUsld%vX0F&i|P`q=~Ucf zFRz`SGBeuxqmL(E$PcIUvjld0#Q90HuIemg^u={6% z@S}&;mBmZBoh5Hzg=R6 zeUJ<9@vi+{6dsl8s2$p0(W#L7^($L-i-FpldZPw-Yu^HrEYJR(pxiZ_-S|0Kek>U_ zUU%D6%e|8}3}={pOck|IX#}145jIU$wTOoWFx_hCP$0=`Ikh zmq*TgpF`cpr0dp-^I0mQGHZ%&(qg1%$bkExC5gJr-&BTXQrK@DEp~LbELo$3-dLx) z0(A467IX`K%E$kEeCH}K$_(+Y55qaZ3<&sPj!EV3sb;aj|McvdNPi8!ieqB^1=?K| z*$}T8CWz~RF$P|Uc)ffC4c#|$0f5fCUXUliox3pO#{2Y81_OMzG#KBt4lZ-ij`et) zsHnt0yDSi1jfKCSNy2A=fb%dg>iWUfmry3-V5c=I>SEAttSo{}&G2kG5{@x&SAsCN zi%hzdo!cLP9wRFD_VM}eTOdds6KX3AWCjtXBCi>q3F|R10*Vqu+;@=m1Jrnq*=A_4 zszGMq^1(JWB}YVC-ZdpXWFnC@!>Rdj9LCDC3djXrWV@xl>Irs#l!O#mPRwpg@Ma|FVV+%bd%`m+X)=oOg~a$` zP+MsgA*Hhw6VKl-?Vs4>elB6z_`WL(Dw}#mbd9P~jQM?t}!5SatxLay> zLAiFy2C)=eYEm~HL?dOt4csPA@Z+!ayMAK;!Gj%_OiS-eO6)@C)o^;GTIlThr3HZ z3`it0xM6@q>;7uEHN3#uRdqUN2pEFFWb1KiFSOejzX3~|bVprVy`Go}A``�!LZ+ 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Ɖc5+yQ> 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

@Y$^1=uJ3y3#ot_5K?1PyUe?>wI&; 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

7s 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≺o>~&hb<7_|@talds`fl;e}U&CO}F%=?@FXf$iBQ|SF~<9g?LJ}!hzrk)Yi z`K{p|-~Pf;zR5=40!G)v=l!ipDu2{`fB)zUcaxY>%zrm~{bFU-2^I7O>qhmVv(l?) zDeo66B_N%@IBCplwD>1fyiv3NX>?-H6Eyw-By&;jb&%d2maxL-D=xPCGHieNWdhUs z^a$e-RwCxxFUv|@y`Jdn4>i07XQs zFKst3v8Qzc1Z8X(HuX#MLVXw}M^wLm-@5~A{}44?UpiFj>OHEe2GCRSfv0*a<|`iCZT4+`&yLaY*HXeGV^E2-p)v`zwl&=;O>^;en zDf8rbS|{1oxaWq7w~unRbQjaUySylcd$@jEy6)(JOLE+eKeO?fDo{V3NiW(@%Xg>5 z&tW^?1%1_i2G{jb_%BvcOt1 zpPk@anEe@-af@j8^Vc>_E{*3}$a?J+=iJx3@$;w{Vk9=KUq&8<2u-iP)3 z8>I^?i-bL+_{oqN1JdKmzv~(a@5Zp-T}ob$ilYkFC(c(9_O@7Thbld_`R`}8V4g*i z)GT-bUGE!wjvqgB1NToAS)7K&w6Y5QQ#^J)*rf_Ltn+JZNiypzicC?8{WltT@o+xo5eiIHND#}h3T`H zHKEy`Q;ZW{UoC1q)2uJ3n(x@WpDRpWG1rS0w!Spv>Ie-;&%(MQc9P6g7y2BB5SL>t zRJ`8b8C2X-5X}Vr@88kw&NY+=O;uAD`V)Nrg03n`_?dsPts(F1v|Uu1CA{cf@SP!1 zt6Q}2%a`B9vFSzU@CS5%#hP#QKrbdv5t-4+|MI(Q0(9iQ92fd2dHsUE<>UH;rVa`h zx`;My{5EPCmzLO$Afaj6&bN48er+RR)3hD${)6?koj?fJw0(t-_;=UlwjJa}sYh^m zjZ;S;%XrYn6X6}U*gz-BG=9r~g|=oKmE;ZMLD*FK%javIv@tB}?H;(gtUu}krsbw7 z)G*fX#|~F|Mm`g(nejOw`F}gEvI^0UIUKh@22ITa*shZ z0zRhi0E*LmxO*Z#6fLzsy?Z>!rqo!<_~Q@1katt^iFUnvOfpRgqIYT+C2I`ZIqJi; zW*Boi6_2*-{pB5OL%pJ9yN3IB$7Q?t>~<~bn01|LWq8l>AoMql*TBXe^wme(gTnJ_ z+h=y%fsL^?R>x*xN3-z}7G0|g3tG>nB|&`u;&qNj@5a*9^m6_5{s`VVj{NG?>mzv& zlgrm=Va+h9!WdRd4RqC0`yR`xGH>4B8>F1iZ@FpOZLIB-n*aBXSJhk62Hks6#=B^6 z!T}PdcYc%PdfxYkN(x2q&rP3*^;ok+idTl=yD)3KZtN_{Z}~21h10edzvX;)l3!Dt zcqbk$Gx+D3ceGqbg3s2|#CtaVy}eg=f*BkSz!B1yq&e+23&~@eiNb zR0^*{7$0Ba1{h2GrA9ZKAyZKd-Xgjaqn?JrnQ#`zA7Yu(Ej{3bB&7a*{o1DIz#C6V zBROWVDOKy;5J_*fSdCe{xfu^AQ-|Ykpn^FgVV2tgCXor#&HjS0$lxnRD2Q*cv^bJI zB1Avd_UWS9JiQ4mX*{I^|IF6Sq&p9M{ShoxS&LDe7CAo=XLqcRkF4FhK5oi$KY!-^ zj#zO>4HEbUre2;}pNr{q2T^>u*}B9 z=_&MP$D=mO9fqZ<-od+}E0b!Ck=XLO73)S!@Ta}YJqIe=G3R3BegREQ%Dyqr!kJ|2 zbM^7q=Evf#E**_^HtL&%;Y-;t)@~9`etw>AzG&?Bssz$cD5SY~CaUpL!=o$JUChJ_ z6a&VA@3Y8Smic}GKN~f)XkpsrJ`t}W-_hFX8^pVzd4Ffjkp~t{vqT`0pZoTiK|k}e z58CB@4%4?0P{1YJyUksz($H_Esjtr?sf2Hq+AU0#-@T0jK<81ED)flCp_`WM#1gy@Uk^XAZKWAMS7e;9m!2p#xA8~Np;&7}+9+G(2Rc^7`Z8(~>Pa)&{mpBAG{?T~RC%i(Q%_01R1?Prx| zrh`g`4FmMikbc%wbYxPy#6)X&DmR+Ax{m46GUM5v(c=`qu|8s@V?3$IUN;Qh`mwJE zl3KT34V`nu*A~<3%$Fm+p4*z=rkwS5gDXo_r7s3^ASblVfljDo zRAtlV-@!>!8hQB&s3vxO?UNAu6@2qN+k9gMM4&Xl;Y0R&?pKnTO2WHpdSw4TLv^X0 zh*B14H=m(HCU5OuSs#>+H^A{xw-V;S!1XSH?DX}=(%bb%O~Dy^tHZyeyuA*O^D7So zt%Q3$)w>9}_*Ub%$#(B6u@b}FnxeO<=_gc{+46C56lL|)mzt|NfmmGQb$2R!Uvf>~ z@9zW~`=Nx@ui)Aa`g(s|XXB$Y63CkL%EtGxwJhI;LAL|JPs!s%$vJzyR+H|xxkyflbCyS|G4PC1L$#At3f76$I=wk5mHJ%wfLN`= z^IJutDNrVi)b}l`ecP#1eUfHdZL{LJ(i5`|jz(+lnA4#)%<<5bHi9lbZ0-;Q5^zM4r~$4jJKtZ+>2Yi=V5d2{fYpba>T)e^Wr|2BID)Tj zhpEh)9tm640OvfIQ;PlQEb#r{0wPs_rnVNi-$a{reYN0S8fEh>;#2qR0as>H=%G=3 zKrCWaH>&$^MO$3;b$j*U9j9vx-A3PWDzg!|YsEtTePP|QZR-kZBvU0tq<4tu_x-2T zfwc{Y8gE%nSTS;eudF70_R(_IE(+@wDkb`?mXP6~i_rPcut)`ZVi5y;meregJ~`iF;6BR_sr$7|EPliCEtlE*w*&TQdESa8?~zs7An?I*`QcUN(CO4U zSiZnB(P-aU+T^pmmmb{mztLwoV>nzsdlv6*67mRyF2!>CgXKCZop-tZ!7?T2eh|qG z%l+o*F3T}__p!8FulO#C)YQ^2JW)~Mmzg>ku0nBzBVKN%;9c7F({Figs+5Y)>PO}X zUS!$(dn;!^ln>o~R_pC{uh(a&-i0NUfXr`{G`t6hFdiC()TXXV=kM*hAKLnC>{w%2 zo&mCnVmT!L{Lae!?<+#>vD$9E$n{_t#dS(+jtMSOaX6Cqr%H#cEeJTXclWlD5>)wP)^yXcc114zd6xp8>dfNS#t@i$Ks95 z2t5o#Sm9soh2GL%!|FW%Z{z~LK|haGV(^I7R6K!6X)2g#epAeTtDml*@0z|v@VjNT zePsW_`&)@od$uaHi%1cN5}Rj)+pC!NT76!&9;;UniDCx1MNbOhI&$KmAjcmnnVPIq z`M>XBmjefqzFH-g;`}#BPTaD(m*FNX0X|u!DuVfM-dyMCv$`)uEEfA}abh9Ryv{n5 zFgaTkIv#oo;YU<4e>+}c0=m|e^v;~Gn3`oZ-4b>0+4L!Uu&rhlP|MGpc2)h2!)LYJ ztx=wV`s5I@ZMA5y>?0gEHl3 ztTrB~tu@)fYSUL{d48)p9508_vO2T|sLsdg9lCMM>(I;b-K{~ZEPN@cDV*kVQ?fqO zGhM%Re)`qL2Nx$a?=o7o|8suFse1>QTvAbsMgd1FzqyMn^upoRrwmqj8~$B=k-^&D;YZ5_>qo`%mZLdZE~W4^72XU-%S;SXaaQjhmde1g&ULZ8g$|FFN91r? z$<@2Mie!V!iU7z|b?@rBQp=I01*l~3Y*~nAkl2b3f6-?+-733~rtK6ZIvP&poJBZV zE=nMV&@^Sl4a@riD^&DuSZ+k9l00vu&pujix~bMVkbCqVoLB5(PFf>WSY=rrN(@(mQ^q;r#v{}6SMaqX+QFitk+~%F4|~*rYYp%U0{vXYBgf)USQG$di(6&y?3Pa z!DFW4OHcM#PQ+u75PSCi<||53I}>xTqTI6lX@k0$ImJECBF(2|FmKqZwd}o}RVA_B zp^49DkLdr+y+8}9@b4{m_81;|UM0}#JXjuF zlBRs@>|J1@XQ}l8FZd(A>9fq_x+^9+g5NTUPReJK_K#t?hD;|IM`I1kRXdI4vclHG zyPc(D7fU*()V+RzycVHINIts+@20w5)w-DTvP^v5BY4VtZ=HYgyhVYRGfQZ4xx0p_ zWTu)A%+LE<@iI&w_N@|%rugrw=;XQ=wE=`eiYR{9DL zNIW|I!E(`Jh4cg^-u7B9a2inbIX~(0(tY3D%ueA1_J=y)6rEwh; zBkS2S=bXt09-3}nl#1XdI1ZsupuZQlb$P^={1k&dX-+o@Oqv^}?KaMS%R$AB;0Vdh z3zl{U^pi^%K3r4I+ZyLRaCHP<*%orjYpLF`n%w(F2ihHPn?G1aVRr9xV1Bw>te4xJ z4{?HfESL|RTL0RL4?F{KBd-0FhxaGTXKHAmz3Jt_d+`{94yviS1dXS*0e|-5)Apu) ziS*yX-EY)uHVkMO;8Gh!Mpw;?0i;%p0t~o|4e;1Vx11I^f~5wr6Ww>@>I0@8C~U+$ zFaumRZgj^Yb_?84SMWzB#{ds(Z1W@Legs$P6-xn_mb3RaOFwz!MTyA!@P2lEJMF#T z;=?uV7_gE##lIJXkku&Yt)dL?b$SGg#z>=>WFA^E}eGb!SJ>JwFygl4Sz!8KEqw#;`N=WgfeWF<(BaJPfrgUX6Tq@>wOexL6(8XR%=9LO-{FOKVsq70Cj-iQo_;Zl)WnYW0(VVLiT%QD4G49nPfR}51m&@dd^q%BcH_4=5F-NY;G zoCY1Y2gA}GV*T1r=TVq#j+Vs{jZ{yp7cu-5qV(xKNkn z;r4x^NR>ktB7fS$_@ap$mojgnriSH$4d-M_xZPXHOr=70hu`kyg!7Jw{`i{IJgtu| zo2HFnnEIyZR*YU>AV?XTF0Z&u5AVtjuUgVtBgyUjghzzzxuK+FEO;FeWsB+Z?929` z`|W5u*L!id|H*bvw?6AS4^sEp{oEDL!>??uO%1zY-a^*}&RzE#>OWDn&_Bo7&R&O8 z;OTCXyv|;#BC@P!?y0T&%e&0~(<#%BUkg2YE!Ud|vV2Dp_%|)rTcf+Rb*Q*KKxsuj z?oo#`e0oDr|EWMYxvpcnW6A$T;vI|W=3Z_B&PapFn|`-tI%VX+*Mox6LTYXK#D&b4|^)c+)r6bZd=l5h{$--B%Jr~8Y0{W6=P|;qK=lw$0135CE^M>1xL$G>3j7Z z?OR%9_$+@oCTV?k_s;VW{n@gl3PkNWd$+Sz!9hqoJ^Eul%TYULLW-z6t$t|Jj|=3n zCS;~gfzDXmBP`vkL4!s#_Xj!FdAg@qS{o(`!ROd~R(r+v5m%0+ zI4w4)ZDzJWEjNPA(9=^f-GDW@F?YvqxW4Zoq|5Hkz%#EeVs&E|G81Lj~4q~h1XxJBYHiq}dKBm9hyT8J6#(eZB)7 z=|yQ+4%FdG=mYMze}tpG{N>RQg_N)YL$V-~JJfNV>=Uw^V%Q(C{BVZnT2~t6^~JNU zlO1%d<&UfL=VsM#gDgm&?ue2sB>Ln?NOAFu(4+jmcvH`duA~0ex6C>kVor^ zJ9;NsI$>_Rskztm6FGdZU^xNYi#oiDooL$|-U+X!Px+s0-zu^*4H$8+cNw17AsqA@ zuk2v^KM{k!DNAu}troqbF8I5z%PX)^w&sDSPRbonD|eW zMCSeV>s)a=eUh@%Tw_e@x@&H?Pf~X2ZZx$fKKDQT_I~FZ8(#6=eg2;`mZ_L;lq;k< zEzfZ`^I3bX_}85DN=lHjlUp;of3}okO?Z2jt-{Z;UBV>Wfm*0pwo3+8ma=uovrM;K z`NL_cTBcjwK0L%f{OmiD3m1O(UMB(`M7N#8?IHaqnWwT%mpfG;xq(3WAf9Uph2Nj@ zJ2=Nc*|UK~N<#j>g~Wab$6hECMOwL*!x@U44EoHEUPVc1Se{IY*{W?<(Nc37H(b3G9`7>7T&Zhe}rsSE-1QJR(v|Zyq~R% zx9YTf_m6zREm!w%7A4G%zq!);>TFrWpdyZTCk;Q#avQ)NyFR<;KUl6RrT$tTvC~wY zEtf)Np&#ver{y#U?xy*4;Bi?_8s~&WQlLe0wj3IbHkU{pEl=sW48bUQkXNtec}40} z#tRZj?o;#1&SucG5-{CyhGlN4C}ltH(Z0YTQaF1(;SH;%NEG z(yIScR_=g$Ivg!`R`k^TP@+Y0wA{2c)mXWMlxV7smMdqZuYauitd^8$fiP*nu$l{( z!u8}nG`kd5Lhw<_1+w2Vw+hTqbbPdWWmz-lJek3MwAy|Y;Eg=IE9=U({wOxcbO;kg?dQ})UX`On%+5!cVS77LQL^W!X|jP zu=HdNFiY~#j(*EM^(|;xy}!3!C(Yn#q9CGSnT5;BCNXJPF8ZJd2}0XmPg9y-BsjLp z))CsU97)w`4+0)7OO@rs@OEl$=US>Pbx*uOFxE>l40EMr5mjIEV2+mC>sfv*m+0Nf zSH3lJM1%D_4aC$gFgFC7(0J+8G`~=SsT|?pJjH}q%1diw{eyRZj^-l zG_Uhn4!6wg8&oYb`>cjL-?IiQyTcLJ%Q7LYMRr!0&WDpch>`oG)8t)U5<#dh@baj= z`!{`p-|Lf0tKQwDAtuVY))KudD}B0muiJ(7a16`wPUXMnboDy{BJHGyKv|0;dVh0d z0b{N2@Gfaiy4K+K0pjPmw)TIe+^1o+Y7BIM<>6h@5}g}7(7kz=w1~BJ+DtW8ceLq> zI&dCw50V`%$J^uT%d$KEp?zxf@L2nJWbauWMA8>nX0jcFHxwb=$?tlh48PjDrNU>K z%>2LEE_Z@Gz$%;GO%+7{OTDfFL+;&GA}v|S$*sNlNBmY^nPF|p=#DK)^7B)X z==i8lz27@J-LxmO!axZ4V~0M~eJeUVwMp-1_xT6QJtj)cB>yfBA9=EOm|1w=vRsre zvvM3%m~UCmudkj&W7xfyq)QO6BPF%M?$p_AEQ<{q3TG(}W<{SA%ic7%LPK>hE1e`T z0F{4)fsU5D)^+Fi2XoUf!!mVT*8-(M2j0>0%|nG02g%MDmP?wHXh>st&*}Mzi>dvz^EOXJJe0K8sw@vt#1xsOABGs_WU8l>Y?0U2;lA)cmGtGTD zN}F!1W|JgI@&4wzY0Cagk{m7HDo}mpNSgN`snce1MITF7=aAmV{ zrAT%j&Vjx|;C+2^YTgZ1t`lc1=@N(c04W=5Ni!AR=`GxUR4i}V?4#vM4W1;mQ@tL& zBo{KcFJs>P4y6R+mzbpwas@eWjlUN>lK0dS8LGG~knCO4q8`RokE}grSZ*WI zx?Wu&468-sR4XOara#Ihkw?nQwA{V#L{XUIv@i=67?#sk5!;G;b%jUNbveeZB=0uqaLjoF>+cw7?a) z_0j~SyBCN^gvJ8w#kei(GdPTh#ZW1A?=(rzC6*CU#d63zZucCOuf3{)X^(R*{}As)duSz?8a zN_Ow5az*qelb^c#+$<9HWo}F8KH#p;QSA$3H7!em%`aRi3DU)%cR;aZZyKP2gu-NQX%>wOo$d!a}7aVZL~ zOhMcW8qcm?A97N^RE`v%sf};{gWrL73$n#6AYm*EoMT5%t&l>b1t#Z1WLJGaDGe^@ zTyhgY3*0muzl1z<`U5!MFtKecaBLm3R;*%t1W)NuT$l2xw5q}L-2gW&^G_>(Od?kXxD@W^#e_`*95r9I z3RdqH$gbZ!BtKTs$86a<*jEOaDgxxxMlP5E-jlf8`p5t$Ep!9vHe!(+!Cl%GLKsBk z$chhmZC%Q>&)K}QB+V1`IYMItFj4uAF)lok_&>UEXM%%?K)&1(E!&?D2oMS z4e%BDLFY8b>Hq4WMB?R~vZ(kGd?m{C1X*QFB@7?1Y9?^GOI%1`fRkp-7t@>>p$0f? z#RS(4>m95jMWUPusnZ9nT73z@d6I21z-eXpXJJd~pv8 zHPxFcs5%i5m!qObe)|or$*fb+IB>rEpKu;l_V!D z%OO$Rl-~en%h$rmBq7r}gHM*@!ykLS(^$xPI9tBkk1fA=^VH6kt2&sA&Pg?DmgSF- z`TNCVa^L5(!l60e8AqVEV362tK(pG{%A9Yh(B>_Lf zaBj4u8*!@*yNP;p?BrF$a7-N4?=^cjlTd|KxMnG-6Sw+kS@H?3qC(I}e9Igx59v0= zDS@UQJ}!=)ITyj#s<3eW#c) zXKoD3O;_h4zwX}o(ee+b;P$3JTHX_MC1(F`{?vA@0c*|wn`5KKucZ#}Zf??Ch$xEN zM<47~>77YjVQ$KDG+ei2`A$(ZEVsrQGPSs!+$#*SlOyNw|K^gQSW*kXy<=TB0jsh} zg&Bt9t;F2E#UqZEV~87V&;5QY5_P7;U?U0Vqvdj4hK0gLEx4Uc34Kuhw~g*Szr@fQ zXl5rFMhkV$`xyl}TFtr@AumYjZo_hnjT3FIFU}heL-J(4mw6MaTZN`~Ie~hF5S(u$~FlXkbqcD2`=0LSq3Fto?e%SeAjXFP_9lY5$AmTX^=hjP>0nI7?H2xHbi!WndFFqMe@D9k7X3X*(P}8gkA>u3sM{^LzeRwaMi1K zshgmBnhEYIP_hg|B3?WKS)22lU45swFLuw^rn0_Ye(!vg4t~cLJuuprkv70rE(+5$ zS8)3Vb}4e48in{Bm^*28(4sQI6{Kru_ehbpZ1}GmAWf3^r`=*@NED=C=;9}eRfXy0nWP}#J7P8ZL^xt zssT=srs!>NJD&W`@5gG9(kUFMg39~`SZZ>)Wd-^cL*D;W)ee5QybB^FAb1<#Dm~tC zC!`5dt!U1!Ku3_^v~OdK?J2U19mE1qJO3xF>E9f?0SIJa|o~o)CO1 zUWad^-FQt?cM%iZCtVGxLWp4gds~(L4z4xRY1d(@OmGkMq$54w`JtNU`UPBgswit{ zf-lb(UfdObaJ~BtecMv`&g=Yog`41-3N0^`PL|xB-Yefm>vDnN;3;UowhZObwd9>d$e?Tcj&t0YQ-S>Rh(_Z{k(G36LulG^WJ zO6_X6U@c4&e0RB9-I$1*5?|I<~20dJ>q<(#JWTqX++Ke>X zXYf>h={wI{<0j>u{R?pOq$73eIRPb3_?k;AXnkr`Dam8ffQwr!^$hMExaCor$W}uDBokT5g9pH?{O?B=Zi4_J1T}OJ#J2@G` zXn@a_hHh@2qc)}iHc0#nXILB4jCGeu9YP4+3Jqx=1g*v54<)2C_*RL2S5}{_O@FGp z&g@#ojh$tIBUUd^_H~4?Nzqb=));vQhTadc+mkBc6^HxX+2hR0}RDQTv#Op{hOOifqtH z_zdhJpw%*PH41HL9!82 z$z_347&u_uaJd{kBe@7@Rj&RWXP|g*0XII=K(80fC!O=V)iE=ISp@71PV9qTmJ@Ol z<)s=AmOBP@;?{B90?!ClNeI)>XN0ylJ2anL{2cN<8 z1eI3glPo{2wSEUvL8$1iBpR(VxFmQZ1Skk?LhkyGOImhY-Y=#eqy{#piA$M#wn`>z zeBTB!HT4L2RuJz#j)AI>Gqa^Kr8mxPRgl zzk^FlFknO1MjT#n#ot_Sv5)8IxPsV{-iu$g#MO;`z#p<#@q*jh5E4<;x8r!hPwS80 z!2xP1q~w@hWhS_<9MY7Y2J;pc{(zq+-Y?*5cqcRfou3-gLV3vx zJhRiW$}^&`uie?E*O}a+PuvvRa$ze-(fusD9t&``t9u#fjdOlYhDu?TI;!&le9g-WsZjNU^&aB82^2@Cd!>4=q z3IlZt=A0uVrDPnbf&5f6m{U={?gDpL-zSNRq%r{WU+2%g9{Ts2^ckp6>)`DBt@CyQ;xjeGJF$LiZ6LLCJ+K)34TSyJ#vn=Piil`N+=;>DeJui6+7M3tNT$Zcp$(Hv)13&lSkv-&(bMc zDKLz^T<)Arc|b&#`hMbQ7qHx=P1oS@i0T2ve72Y(NbA*4kz{aQ6kYwR^6Y}UEdwmj8O}q0v`Bkoz?RqBl(%SI zJlN`4?YR3TDmABdZcB$t==4?}Wy0wD%v;^`b>6Z@nBF2;1N>p$y~m;kqQmrov2}Bi zE7El04uKUIt4&RNDABU3M<3IP_HdMpEvdMhH(&+^kA2& zIGlkiI8(mHafh@)D)Z?*sWKku92nrzK@(e)IP@4;=Rnciz?YZ8ctt<|@74g(FlO{w z?%LgSJU9L)R2@B*=k8b!s_C>WPbCI@PIsx|&3Hf?mT%Rv`hchR=g!<8KX+;y#z*q} z43zW|jT2QlS|5wac_~V#_l{w=Xi3axW6R{~IrMB9A*|*3rJ8hpxL4y{lXsfD`@m7N zzaIrI5sL*5goO|!A{V>4D<r;9d73?o_Ev8`D{i1n$}GBdew_&QN?4{`0A<%yA{^uCPG&;(Bg4P9g9X{JyNT75fU}Uc;mg zxcirWqA+H=^fSgoE)S-)#aA)AC#CAxo#vqo}C9}!^W#3(MAypG}*1v}mVe|@r`&bLods`f`N zqkMW&Sr6~Y4{s$fyB~%0YM1tbuAs|=CRAnL=idhAW!)>e!Tm;;Y#FrgmWoWhpr>Ij zLG_lru^{JQ8jKI;RI$bJ)KWFwC2%d`Y7N79hDGXYDtd(|z4g^%fsBsGbv1lO8Wx8Z z^5)m#-KwdbCw}PZ(VySA?c;9``X1mbi_&qT@vNrS=h8oT20NTyCj~gF22##(Y0X^^ z499R%`J3Aa&)M@)Omqd5WO?-W_9&sd4-pyXv`Q+a zBS|usu-+aGL6iLBuOOvVJe%cncp1BL0t-`gU8@=Q)LM%IXR6W@ox>r#ya>lYq&%)Q zlzA*tQUf?nZRPm|_-VH?w$Dw_(vJZauYbx60}F$xuJVySqXJC!#xOjrIh&O-Y58Nf|if zv!OkU@E970D-O>)p>JcTBgRgls3SCGT-f7|y1U|M%3NOW19?^wgT^ono|`^}7EQze zmXRT`x@|@4i@SD4cs$h+q1&-#cY?5Jm8uV1(FPV}j>J>-J@`ciq5^JnQja!8I3}P? zcG;}o+R!=PQtZ|kzcM45%fr+4yzdi99Eieo=Xb>U(CDCJAyP*LJveLky$zj|_>V6# z3t3A5f9}(s(0f*)%24^4&N+b-IcK8Wu8-y99O?=^nZ$QZ{tHd1t1=^2wsC6CMRwYo469f@+$<*1x5~x^o*|FCI8?(m>%o3!6X~ zqCTCRyk|#EFEVNiIqw&@ioD3+P9Z5rJHaUTySRHgKe%hu?@i9vC-U{QEwJ@ljDJ`cW7Ox1b77nj%6;DO!hTbU+lR?7 z{GoCPw1l|alku;H2(cCuoZ@1IjHiurdBNW+BuA=XHRvXFfAWAAFObn~tJqv?e1wzR zbXu*D&k!ES1lQ(ZHPW+LTDhX5Z&>A9NGR~wq2asHL{+nWi{Y(MsnwTdaD&02aExQB`)jaw9;I|do$dsQl$ zf#-1=P?IeADlDow-U1_HGvr z=2A-V`)24abMW-eA7v-^h+-Hy$wHl0MUjS&8?5I*&i~hWsIkDr*E?k99hfWE_5Ma} zCSYeX(#n5GC-dmfwul1TglR8IUI^JRccoSzbNyD-98PmpFYw3Q718kgx>P63+_+n; zcdx~?Tm~s<4xVW*3D-(%j@2ncfw{yj0cl0xW*M;1IxlTA_6LtXNz&=fP@S=`(lcx- zenHtG%Z^9!xF2uD2~It|qeZTqffS+PjCoMrVdv2jW#$6MF#>{eD=M|gV!>O=;rNlZjN>;5rTk)Yk-WXSgy!8+h}T5L@gjT{v|PV z4Nwm&vP@xk!z!wNm%aYc`nB+)k`8gnA1=+GdcP;%aciCS<}-{96tCSBsKChj!TG(! z8_5uuUpynah7q8v@57t*hvDNFqjF*Xbc=H`!Nm=ZaNg0=$UHiFDR7yLyd8JO zxsxlpbQy_4_7=>5W#XoNSfWQUZw)Ok7&R_rwAvrA6Ov(RFGD_$mh?^?@Qbs$8Dlty zx;+KV(rmJ!OJjX=gEL2(O&0%cDCg=DFA}|%xv`=Lgg#H~olk(%PAsG(mj9GV6Ur=pbkyb~PUyBDJ^@1KH`n^Ur^8(~?i}Th ze8T(S!M$KWv35mT>Hg`1J2}r=t+HVlYa2vGZQyZdU@?J_b}a@gb2!Qpxe)C#-y1JI ztoUc^-)xZS1iyUPr?;k)BqvAPfN|P>s|Ah`B=PntfUi&e2)af8G*@cJg07+Xh!sh# ztNrp4r96BGh14*B^bIti-%ZM4CDrFctp(556(oWdz2r8_c!15+2i-~!gLoa{^l8qf3(x$dkM8yzd3bd zc0*gPUie5`V9ez-Lzx>yh!4e%;(2;&!lfT_^alb8@e0zO2e8~~>MnB~)s?->GnfSK zWu^FE62kwP_!=O|q@yn(v|aS8b9X-R-nXC80{0HWd}I71DxERn@=*br&rhDgZ&@aJ^@6@u zW%j${(zslH@^fgE`zCWPt`VSf$)|s%FGf^_1PFHHT}R@yJ5@^jy%TN`isao9kj5;M z#+-|{Y$T(F5;}qQ$mCKJ-0JF%Uig$eB(g=6Jwfo0ohj339&)a~tYwlJI9la|T>A@E zK&mY3J42W2plbZlM^b3gA)!7RBNAyUa6%tGxk<%!dFrNx?nAwQEUQUJ`H8`&iVM;N zH_bb|T!WkBlO3NN3+Bh~mdc?xtp*J%Jp)w>_I9$cMI{TL*}eCDb1aLdlA~|MSugG( zt{eS6s8JZk+F62h^I0>-o&-IS+kYbtf#InPO z{%C%3m*f830eh^&u-b)XT$En(iCAEj{LyMr$

5tGDO+CWAx>=Z+Bn{$o|@=2MIw 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