Enum IntersectResult

pub enum IntersectResult<T> {
    Intersect(T),
    Negative,
    Positive,
}

The result of a plane-intersection operation.

This enum represents the outcome when computing the intersection between a geometric shape and a plane. Unlike SplitResult which produces pieces of the original shape, this produces the geometry that lies exactly on the plane (within epsilon tolerance).

Type Parameter

The generic type T represents the result of the intersection. Common types include:

• Polyline - For mesh-plane intersections, representing the cross-section outline

Use Cases

Plane-intersection operations are useful for:

• Cross-sectional analysis: Computing 2D slices of 3D geometry
• Contour generation: Finding outlines at specific heights
• Visualization: Displaying cutting planes through complex geometry
• CAD/CAM: Generating toolpaths or analyzing part geometry

Examples

Computing a Mesh Cross-Section

use parry3d::shape::TriMesh;
use parry3d::math::Point;
use parry3d::query::IntersectResult;

// Create a simple tetrahedron mesh
let vertices = vec![
    Point::new(0.0, 0.0, 0.0),
    Point::new(1.0, 0.0, 0.0),
    Point::new(0.5, 1.0, 0.0),
    Point::new(0.5, 0.5, 1.0),
];
let indices = vec![
    [0u32, 1, 2],  // Bottom face
    [0, 1, 3],     // Front face
    [1, 2, 3],     // Right face
    [2, 0, 3],     // Left face
];
let mesh = TriMesh::new(vertices, indices).unwrap();

// Compute cross-section at z = 0.5
match mesh.canonical_intersection_with_plane(2, 0.5, 1e-6) {
    IntersectResult::Intersect(polyline) => {
        println!("Cross-section computed!");
        println!("Number of vertices: {}", polyline.vertices().len());
        // The polyline represents the outline of the mesh at z = 0.5
        // It may consist of multiple disconnected loops if the mesh
        // has multiple separate pieces at this height
    }
    IntersectResult::Negative => {
        println!("Mesh is entirely below z = 0.5");
    }
    IntersectResult::Positive => {
        println!("Mesh is entirely above z = 0.5");
    }
}

Handling Multiple Connected Components

use parry3d::shape::TriMesh;
use parry3d::query::IntersectResult;

// When intersecting a mesh with holes or multiple separate parts,
// the resulting polyline may have multiple connected components
match mesh.canonical_intersection_with_plane(2, 0.5, 1e-6) {
    IntersectResult::Intersect(polyline) => {
        // The polyline contains all intersection curves
        // You can identify separate components by analyzing connectivity
        // through the polyline's segment indices
        let indices = polyline.indices();
        println!("Number of edges in cross-section: {}", indices.len());
    }
    _ => println!("No intersection"),
}

Variants

Intersect(T)

The intersect operation yielded a result, lying on the plane (within epsilon tolerance).

For triangle meshes, this is typically a Polyline representing the outline where the mesh intersects the plane. The polyline may consist of multiple disconnected loops if the mesh has holes or multiple separate pieces at the intersection height.

The intersection geometry lies on the plane, meaning all points p satisfy n · p ≈ b (within the specified epsilon tolerance).

Negative

The shape being intersected is fully contained in the negative half-space of the plane.

This means all points of the shape satisfy n · p < b (the shape is entirely “behind” or “below” the plane). The plane doesn’t intersect the shape at all.

Positive

The shape being intersected is fully contained in the positive half-space of the plane.

This means all points of the shape satisfy n · p > b (the shape is entirely “in front of” or “above” the plane). The plane doesn’t intersect the shape at all.