Offset

Overview

The offset operation creates a new path parallel to the input path at a specified distance. It intelligently handles corners with mitering or beveling, supports both open and closed paths, and maintains geometric correctness for complex shapes.

Function Signature

pub fn offset_path(
    points: &[Vector3],
    distance: f64,
    force_closed: Option<bool>,
    options: OffsetOptions,
) -> OffsetResult

Generates an offset path from a sequence of points.

points

&[Vector3]

required

Array of 3D points defining the path to offset. For 2D paths, use the XZ plane (Y=0 or constant).

distance

f64

required

Offset distance. Positive values offset to the left (counter-clockwise side), negative values offset to the right. The distance is measured perpendicular to the path direction.

force_closed

Option<bool>

Explicitly specify whether the path should be treated as closed:

Some(true): Force closed path
Some(false): Force open path
None: Auto-detect (closed if first and last points are nearly identical)

options

OffsetOptions

required

Configuration options controlling corner handling behavior.

Configuration

OffsetOptions

pub struct OffsetOptions {
    pub bevel: bool,
    pub acute_threshold_degrees: f64,
}

bevel

bool

default:"true"

Enable beveling for outer corners when the interior angle is below the threshold. When true, sharp corners are cut off creating two vertices; when false, attempts to miter all corners.

acute_threshold_degrees

f64

default:"35.0"

The interior angle threshold (in degrees) below which outer corners will be beveled. Valid range: 1.0 to 179.0 degrees. Lower values bevel more aggressively.

Default Options

OffsetOptions {
    bevel: true,
    acute_threshold_degrees: 35.0,
}

Return Type

OffsetResult

pub struct OffsetResult {
    pub points: Vec<Vector3>,
    pub beveled_vertex_indices: Vec<u32>,
    pub is_closed: bool,
}

points

Vec<Vector3>

The offset path vertices. For closed paths, the last point duplicates the first.

beveled_vertex_indices

Vec<u32>

Indices of vertices in the original path where beveling was applied. Useful for post-processing or visualization.

is_closed

bool

Whether the result is a closed loop.

How It Works

Path Sanitization: Removes consecutive duplicate points and detects if the path is closed
Segment Analysis: Calculates unit direction vectors and left-normal vectors for each segment
Corner Processing:
- Straight segments: Simple perpendicular offset
- Outer corners: Mitered intersection or beveled based on angle threshold
- Inner corners (open paths): Clipped to prevent spikes
- Collinear segments: Merged smoothly
Path Closing: For closed paths, ensures first and last points match exactly

Code Examples

Basic Line Offset

use opengeometry::operations::offset::{offset_path, OffsetOptions};
use openmaths::Vector3;

// Straight line from origin to (5, 0, 0)
let line = vec![
    Vector3::new(0.0, 0.0, 0.0),
    Vector3::new(5.0, 0.0, 0.0),
];

// Offset 1 unit to the left (positive Z direction)
let result = offset_path(&line, 1.0, Some(false), OffsetOptions::default());

// Result points at Z=1.0:
// Vector3::new(0.0, 0.0, 1.0)
// Vector3::new(5.0, 0.0, 1.0)
assert_eq!(result.points.len(), 2);
assert!((result.points[0].z - 1.0).abs() < 1e-6);

Closed Rectangle Offset

use opengeometry::operations::offset::{offset_path, OffsetOptions};
use openmaths::Vector3;

// Rectangle
let rectangle = vec![
    Vector3::new(0.0, 0.0, 0.0),
    Vector3::new(2.0, 0.0, 0.0),
    Vector3::new(2.0, 0.0, 2.0),
    Vector3::new(0.0, 0.0, 2.0),
    Vector3::new(0.0, 0.0, 0.0), // Close the loop
];

// Inset by 0.2 units (negative offset)
let result = offset_path(&rectangle, -0.2, None, OffsetOptions::default());

assert!(result.is_closed);
assert!(result.points.len() >= 5);

Beveling Acute Corners

use opengeometry::operations::offset::{offset_path, OffsetOptions};
use openmaths::Vector3;

// Path with a sharp corner
let sharp_path = vec![
    Vector3::new(0.0, 0.0, 0.0),
    Vector3::new(2.0, 0.0, 0.0),
    Vector3::new(1.0, 0.0, 0.3), // Creates acute angle
];

let result = offset_path(
    &sharp_path,
    0.3,
    Some(false),
    OffsetOptions {
        bevel: true,
        acute_threshold_degrees: 45.0,
    },
);

// Check that beveling occurred
assert!(!result.beveled_vertex_indices.is_empty());
assert!(result.points.len() >= 4); // Extra vertex from bevel

Custom Corner Handling

use opengeometry::operations::offset::{offset_path, OffsetOptions};
use openmaths::Vector3;

let path = create_complex_path(); // Your path creation logic

// Aggressive beveling for smoother offsets
let smooth_options = OffsetOptions {
    bevel: true,
    acute_threshold_degrees: 60.0,
};

// Sharp corners with minimal beveling
let sharp_options = OffsetOptions {
    bevel: true,
    acute_threshold_degrees: 20.0,
};

let smooth_result = offset_path(&path, 0.5, None, smooth_options);
let sharp_result = offset_path(&path, 0.5, None, sharp_options);

Visual Examples

Open Path Offset:

Original:          Offset (distance=0.5):
    
  p1────p2           p1'──p2'
                      │    │
  p0────p1    →      p0'──p1'


Closed Path with Beveled Corner:

                    Offset with beveling:
    p2
    ╱│               ┌─────┐
   ╱ │      →        │  ╱b2│  (corner beveled)
  p0─p1              b1───┘

Corner Behavior

Outer Corners

Angle > threshold: Mitered (intersection point calculated)
Angle ≤ threshold: Beveled (two vertices inserted)
Parallel segments: Smooth continuation

Inner Corners

Closed paths: Mitered to intersection point
Open paths: Clipped with two vertices to prevent long spikes

Implementation Details

Source Location

~/workspace/source/main/opengeometry/src/operations/offset.rs:87

Precision

Uses EPSILON = 1.0e-9 for geometric comparisons
Works in 2D projection (XZ plane, Y preserved)
Robust handling of degenerate cases (zero-length segments, duplicate points)

Performance Considerations

Linear time complexity: O(n) where n is the number of input points
Minimal memory allocation beyond output storage
Removes duplicate points during sanitization

Edge Cases

Zero distance: Returns a copy of the input path
Insufficient points: Returns empty result
Collinear points: Handled gracefully with tangent smoothing
Self-intersecting paths: Not automatically resolved; may produce overlapping geometry

2D Primitives

3D Shapes

Operations

Scene & Export

Overview

Function Signature

Configuration

OffsetOptions

Default Options

Return Type

OffsetResult

How It Works

Code Examples

Basic Line Offset

Closed Rectangle Offset

Beveling Acute Corners

Custom Corner Handling

Visual Examples

Corner Behavior

Outer Corners

Inner Corners

Implementation Details

Source Location

Precision

Performance Considerations

Edge Cases

See Also

2D Primitives

3D Shapes

Operations

Scene & Export

​Overview

​Function Signature

​Configuration

​OffsetOptions

​Default Options

​Return Type

​OffsetResult

​How It Works

​Code Examples

​Basic Line Offset

​Closed Rectangle Offset

​Beveling Acute Corners

​Custom Corner Handling

​Visual Examples

​Corner Behavior

​Outer Corners

​Inner Corners

​Implementation Details

​Source Location

​Precision

​Performance Considerations

​Edge Cases

​See Also

Overview

Function Signature

Configuration

OffsetOptions

Default Options

Return Type

OffsetResult

How It Works

Code Examples

Basic Line Offset

Closed Rectangle Offset

Beveling Acute Corners

Custom Corner Handling

Visual Examples

Corner Behavior

Outer Corners

Inner Corners

Implementation Details

Source Location

Precision

Performance Considerations

Edge Cases

See Also