Sweep

Overview

The sweep operation generates a 3D surface (BREP) by moving a 2D profile shape along a 3D path. It automatically computes rotation-minimizing frames along the path to prevent twisting, making it ideal for creating pipes, tubes, rails, and architectural moldings.

Function Signature

pub fn sweep_profile_along_path(
    path_points: &[Vector3],
    profile_points: &[Vector3],
    options: SweepOptions,
) -> Brep

Sweeps a profile curve along a path curve to create a 3D boundary representation.

path_points

&[Vector3]

required

The 3D path curve to sweep along. Must have at least 2 points. If the first and last points are identical (within epsilon), the path is treated as closed.

profile_points

&[Vector3]

required

The 2D or 3D profile shape to sweep. Must have at least 3 points to form a valid closed profile. The profile is automatically centered and oriented relative to the path.

options

SweepOptions

required

Configuration controlling end cap generation.

Configuration

SweepOptions

pub struct SweepOptions {
    pub cap_start: bool,
    pub cap_end: bool,
}

cap_start

bool

default:"true"

Generate a closed face at the start of the sweep (only for open paths). Set to false to create an open tube.

cap_end

bool

default:"true"

Generate a closed face at the end of the sweep (only for open paths). Set to false to create an open tube.

Default Options

SweepOptions {
    cap_start: true,
    cap_end: true,
}

Return Type

Returns a Brep (Boundary Representation) object containing:

vertices: All 3D vertex positions (profile vertices × path sections)
edges: Connectivity information for the mesh
faces: Quadrilateral side faces and optional triangular/polygonal end caps

How It Works

Path Sanitization: Removes consecutive duplicate points and detects if the path forms a closed loop
Profile Preparation:
- Computes profile centroid
- Calculates profile plane normal
- Converts profile to local coordinates (u, v, w basis)
Frame Calculation:
- Computes tangent vectors along the path
- Builds rotation-minimizing frames using parallel transport
- Ensures smooth frame transitions without twisting
Vertex Placement: Transforms each profile point into world space at each path section
Face Generation:
- Creates quadrilateral side faces connecting successive sections
- Adds end caps for open paths (if enabled)
- Connects vertices to form a watertight mesh

Code Examples

Basic Sweep: Creating a Pipe

use opengeometry::{
    brep::Brep,
    operations::sweep::{sweep_profile_along_path, SweepOptions},
};
use openmaths::Vector3;

// Straight path from origin upward
let path = vec![
    Vector3::new(0.0, 0.0, 0.0),
    Vector3::new(0.0, 2.0, 0.0),
];

// Circular profile (approximated with 8 points)
let radius = 0.5;
let segments = 8;
let mut profile = Vec::new();
for i in 0..segments {
    let angle = (i as f64) * 2.0 * std::f64::consts::PI / (segments as f64);
    profile.push(Vector3::new(
        radius * angle.cos(),
        0.0,
        radius * angle.sin(),
    ));
}

let pipe = sweep_profile_along_path(&path, &profile, SweepOptions::default());

// Result: A capped cylinder
assert_eq!(pipe.vertices.len(), 16); // 8 profile × 2 sections
assert_eq!(pipe.faces.len(), 10); // 8 sides + 2 caps

Curved Path Sweep

use opengeometry::operations::sweep::{sweep_profile_along_path, SweepOptions};
use openmaths::Vector3;

// Curved path (quarter circle arc)
let mut path = Vec::new();
for i in 0..=10 {
    let t = (i as f64) / 10.0;
    let angle = t * std::f64::consts::PI / 2.0;
    path.push(Vector3::new(
        angle.cos(),
        0.0,
        angle.sin(),
    ));
}

// Rectangular profile
let profile = vec![
    Vector3::new(-0.2, 0.0, -0.1),
    Vector3::new(0.2, 0.0, -0.1),
    Vector3::new(0.2, 0.0, 0.1),
    Vector3::new(-0.2, 0.0, 0.1),
];

let curved_beam = sweep_profile_along_path(&path, &profile, SweepOptions::default());

// Result: Curved rectangular beam following the arc

Open Tube Without Caps

use opengeometry::operations::sweep::{sweep_profile_along_path, SweepOptions};
use openmaths::Vector3;

let path = vec![
    Vector3::new(0.0, 0.0, 0.0),
    Vector3::new(0.0, 1.0, 0.0),
    Vector3::new(1.0, 2.0, 0.0),
];

let profile = create_circle_profile(0.4, 12); // 12-sided circle

// Create open tube
let tube = sweep_profile_along_path(
    &path,
    &profile,
    SweepOptions {
        cap_start: false,
        cap_end: false,
    },
);

assert_eq!(tube.vertices.len(), 36); // 12 profile × 3 sections
assert_eq!(tube.faces.len(), 24); // Only side faces, no caps

Closed Loop Sweep

use opengeometry::operations::sweep::{sweep_profile_along_path, SweepOptions};
use openmaths::Vector3;

// Circular closed path
let mut path = Vec::new();
for i in 0..16 {
    let angle = (i as f64) * 2.0 * std::f64::consts::PI / 16.0;
    path.push(Vector3::new(
        2.0 * angle.cos(),
        0.0,
        2.0 * angle.sin(),
    ));
}
path.push(path[0]); // Close the loop

// Small circular profile
let profile = create_circle_profile(0.2, 8);

// Sweep to create a torus-like shape
let torus = sweep_profile_along_path(&path, &profile, SweepOptions::default());

// Note: End caps are NOT generated for closed paths
assert_eq!(torus.vertices.len(), 128); // 8 profile × 16 sections
assert_eq!(torus.faces.len(), 128); // Only side faces

Visual Examples

Sweep Process:

   Path              Profile           Result
   
     ●                 ○               ╭─○─╮
     │                                  │   │
     ●                         →       ●───●
     │                                  │   │
     ●                                  ╰─○─╯


Closed Path Sweep (Torus):

   Path (circle)     Profile (circle)    Result
   
     ╭───╮              ●              ╭─────╮
     │   │                             ╱ ╭───╮ ╲
     ╰───╯              ●      →      │  │   │  │
                                       ╲ ╰───╯ ╱
                                        ╰─────╯

Frame Calculation Details

Rotation-Minimizing Frames

The sweep operation uses a parallel transport method to compute frames that:

Follow the path tangent direction
Minimize rotation (twist) along the path
Handle sudden direction changes smoothly
Work correctly for both open and closed paths

Frame Components

Tangent: Direction along the path
Normal: First perpendicular direction (maps to profile U axis)
Binormal: Second perpendicular direction (maps to profile V axis)

Implementation Details

Source Location

~/workspace/source/main/opengeometry/src/operations/sweep.rs:98

Precision

Uses EPSILON = 1.0e-9 for geometric comparisons
Robust handling of near-zero vectors
Graceful fallback for degenerate cases

Profile Orientation

Profile is automatically centered at its centroid
Profile normal is computed using Newell’s method
Profile is decomposed into local orthonormal basis (u, v, w)
No manual profile alignment required

Edge Cases

Insufficient Points:
- Path < 2 points: Returns empty BREP
- Profile < 3 points: Returns empty BREP
Closed Paths: Automatically detected and handled (no end caps generated)
Degenerate Frames: Fallback to default orthogonal vectors
Collinear Path Segments: Frames smoothly interpolated

Performance Considerations

Vertex count: profile_points × path_sections
Face count (open): profile_points × (path_sections - 1) + 2 caps
Face count (closed): profile_points × path_sections
Memory: O(vertices + faces)

Live Demo

Sweep Demo

Try the Sweep operation in the browser

Extrude

Special case of sweep along a straight vertical path

Offset

Create parallel offset curves in 2D

2D Primitives

3D Shapes

Operations

Export (Experimental)

Overview

Function Signature

Configuration

SweepOptions

Default Options

Return Type

How It Works

Code Examples

Basic Sweep: Creating a Pipe

Curved Path Sweep

Open Tube Without Caps

Closed Loop Sweep

Visual Examples

Frame Calculation Details

Rotation-Minimizing Frames

Frame Components

Implementation Details

Source Location

Precision

Profile Orientation

Edge Cases

Performance Considerations

Live Demo

Sweep Demo

See Also

Extrude

Offset

​Overview

​Function Signature

​Configuration

​SweepOptions

​Default Options

​Return Type

​How It Works

​Code Examples

​Basic Sweep: Creating a Pipe

​Curved Path Sweep

​Open Tube Without Caps

​Closed Loop Sweep

​Visual Examples

​Frame Calculation Details

​Rotation-Minimizing Frames

​Frame Components

​Implementation Details

​Source Location

​Precision

​Profile Orientation

​Edge Cases

​Performance Considerations

​Live Demo

Sweep Demo

​See Also

Extrude

Offset

Overview

Function Signature

Configuration

SweepOptions

Default Options

Return Type

How It Works

Code Examples

Basic Sweep: Creating a Pipe

Curved Path Sweep

Open Tube Without Caps

Closed Loop Sweep

Visual Examples

Frame Calculation Details

Rotation-Minimizing Frames

Frame Components

Implementation Details

Source Location

Precision

Profile Orientation

Edge Cases

Performance Considerations

Live Demo

See Also