priv::Visitor Struct Reference

Track source of intersection Help for anotate inner and outer faces. More...

Inheritance diagram for priv::Visitor:

Collaboration diagram for priv::Visitor:

Public Member Functions
	Visitor (const CutMesh &object, const CutMesh &shape, EdgeShapeMap edge_shape_map, FaceShapeMap face_shape_map, VertexShapeMap vert_shape_map, bool *is_valid)
void	intersection_point_detected (std::size_t i_id, int sdim, HI h_f, HI h_e, const CutMesh &tm_f, const CutMesh &tm_e, bool is_target_coplanar, bool is_source_coplanar)
	Called when a new intersection point is detected. The intersection is detected using a face of tm_f and an edge of tm_e. Intersecting an edge hh_edge from tm_f with a face h_e of tm_e. https://doc.cgal.org/latest/Polygon_mesh_processing/classPMPCorefinementVisitor.html#a00ee0ca85db535a48726a92414acda7f.
void	new_vertex_added (std::size_t i_id, VI v, const CutMesh &tm)
	Called when a new vertex is added in tm (either an edge split or a vertex inserted in the interior of a face). Fill vertex_shape_map by intersections.

Public Attributes
const CutMesh &	object
const CutMesh &	shape
EdgeShapeMap	edge_shape_map
FaceShapeMap	face_shape_map
VertexShapeMap	vert_shape_map
bool *	is_valid
std::vector< const IntersectingElement * >	intersections

Detailed Description

Track source of intersection Help for anotate inner and outer faces.

Constructor & Destructor Documentation

Visitor()

priv::Visitor::Visitor ( const CutMesh &  object, const CutMesh &  shape, EdgeShapeMap  edge_shape_map, FaceShapeMap  face_shape_map, VertexShapeMap  vert_shape_map, bool *  is_valid  )

inline

                                                                                        :
        object(object), shape(shape), edge_shape_map(edge_shape_map), face_shape_map(face_shape_map),
        vert_shape_map(vert_shape_map), is_valid(is_valid)
    {}

Member Function Documentation

intersection_point_detected()

void priv::Visitor::intersection_point_detected	(	std::size_t	i_id,
		int	sdim,
		HI	h_f,
		HI	h_e,
		const CutMesh &	tm_f,
		const CutMesh &	tm_e,
		bool	is_target_coplanar,
		bool	is_source_coplanar
	)

Called when a new intersection point is detected. The intersection is detected using a face of tm_f and an edge of tm_e. Intersecting an edge hh_edge from tm_f with a face h_e of tm_e. https://doc.cgal.org/latest/Polygon_mesh_processing/classPMPCorefinementVisitor.html#a00ee0ca85db535a48726a92414acda7f.

Parameters

i_id	The id of the intersection point, starting at 0. Ids are consecutive.
sdim	Dimension of a simplex part of face(h_e) that is intersected by edge(h_f): 0 for vertex: target(h_e) 1 for edge: h_e 2 for the interior of face: face(h_e)
h_f	A halfedge from tm_f indicating the simplex intersected: if sdim==0 the target of h_f is the intersection point, if sdim==1 the edge of h_f contains the intersection point in its interior, if sdim==2 the face of h_f contains the intersection point in its interior. @Vojta: Edge of tm_f, see is_target_coplanar & is_source_coplanar whether any vertex of h_f is coplanar with face(h_e).
h_e	A halfedge from tm_e @Vojta: Vertex, halfedge or face of tm_e intersected by h_f, see comment at sdim.
tm_f	Mesh containing h_f
tm_e	Mesh containing h_e
is_target_coplanar	True if the target of h_e is the intersection point @Vojta: source(h_f) is coplanar with face(made by h_e).
is_source_coplanar	True if the source of h_e is the intersection point @Vojta: target(h_f) is coplanar with face(h_e).

{
    if (i_id >= intersections.size()) {
        size_t capacity = Slic3r::next_highest_power_of_2(i_id + 1);
        intersections.reserve(capacity);
        intersections.resize(capacity);
    }
 
    const IntersectingElement *intersection_ptr = nullptr;
    if (&tm_e == &shape) {
        assert(&tm_f == &object);
        switch (sdim) {
        case 1:
            // edge x edge intersection
            intersection_ptr = &edge_shape_map[shape.edge(h_e)];
            break;
        case 2:
            // edge x face intersection
            intersection_ptr = &face_shape_map[shape.face(h_e)];
            break;
        default: assert(false);
        }
        if (is_target_coplanar)
            vert_shape_map[object.source(h_f)] = intersection_ptr;
        if (is_source_coplanar)
            vert_shape_map[object.target(h_f)] = intersection_ptr;
    } else {
        assert(&tm_f == &shape && &tm_e == &object);
        assert(!is_target_coplanar);
        assert(!is_source_coplanar);
        if (is_target_coplanar || is_source_coplanar) 
            *is_valid = false;
        intersection_ptr = &edge_shape_map[shape.edge(h_f)];
        if (sdim == 0) vert_shape_map[object.target(h_e)] = intersection_ptr;
    }
 
    if (intersection_ptr->shape_point_index == std::numeric_limits<uint32_t>::max()) {
        // there is unexpected intersection
        // Top (or Bottom) shape contour edge (or vertex) intersection
        // Suggest to change projection min/max limits
        *is_valid = false;
    }
    intersections[i_id] = intersection_ptr;
}

References priv::is_valid(), Slic3r::next_highest_power_of_2(), and priv::IntersectingElement::shape_point_index.

Here is the call graph for this function:

new_vertex_added()

void priv::Visitor::new_vertex_added	(	std::size_t	i_id,
		VI	v,
		const CutMesh &	tm
	)

Called when a new vertex is added in tm (either an edge split or a vertex inserted in the interior of a face). Fill vertex_shape_map by intersections.

Parameters

i_id	Order number of intersection point
v	New added vertex
tm	Affected mesh

{
    assert(&tm == &object);
    assert(i_id < intersections.size());
    const IntersectingElement *intersection_ptr = intersections[i_id];
    assert(intersection_ptr != nullptr);
    // intersection was not filled in function intersection_point_detected
    //assert(intersection_ptr->point_index != std::numeric_limits<uint32_t>::max());
    vert_shape_map[v] = intersection_ptr;
}

Member Data Documentation

edge_shape_map

EdgeShapeMap priv::Visitor::edge_shape_map

face_shape_map

FaceShapeMap priv::Visitor::face_shape_map

intersections

std::vector<const IntersectingElement*> priv::Visitor::intersections

is_valid

bool* priv::Visitor::is_valid

object

const CutMesh& priv::Visitor::object

shape

const CutMesh& priv::Visitor::shape

vert_shape_map

VertexShapeMap priv::Visitor::vert_shape_map

---

The documentation for this struct was generated from the following file:

• src/libslic3r/CutSurface.cpp