Collaboration diagram for Slic3r::SeamPlacerImpl::GlobalModelInfo:

Public Member Functions
bool	is_enforced (const Vec3f &position, float radius) const
bool	is_blocked (const Vec3f &position, float radius) const
float	calculate_point_visibility (const Vec3f &position) const

Public Attributes
TriangleSetSamples	mesh_samples
std::vector< float >	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
indexed_triangle_set	non_enforcers
AABBTreeIndirect::Tree< 3, float >	enforcers_tree
AABBTreeIndirect::Tree< 3, float >	blockers_tree
AABBTreeIndirect::Tree< 3, float >	non_enforcers_tree
PaintedContour	enforcer_contour
PaintedContour	blocker_contour
std::vector< const ModelVolume * >	precise_seam_strong_volumes
std::vector< const ModelVolume * >	precise_seam_weak_volumes
PreciseSeam::ModifierRegionsCache	precise_seam_slices

Detailed Description

Member Function Documentation

◆ calculate_point_visibility()

float Slic3r::SeamPlacerImpl::GlobalModelInfo::calculate_point_visibility ( const Vec3f & position ) const

inline

                                                                {
    std::vector<size_t> 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;
 
  }

References Slic3r::find_nearby_points(), mesh_samples_radius, mesh_samples_tree, mesh_samples_visibility, Slic3r::TriangleSetSamples::normals, and Slic3r::TriangleSetSamples::positions.

Here is the call graph for this function:

◆ is_blocked()

bool Slic3r::SeamPlacerImpl::GlobalModelInfo::is_blocked	(	const Vec3f &	position,
		float	radius ) const

inline

                                                             {
    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);
  }

References blockers, blockers_tree, and Slic3r::AABBTreeIndirect::is_any_triangle_in_radius().

Referenced by Slic3r::SeamPlacerImpl::process_perimeter_polygon().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_enforced()

bool Slic3r::SeamPlacerImpl::GlobalModelInfo::is_enforced	(	const Vec3f &	position,
		float	radius ) const

inline

                                                              {
    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);
  }