Curve

A curve primitive represented through control points

Overview

The Curve primitive represents a curve in 3D space defined by a series of control points. Currently, the curve is represented as a polyline through these control points. It is an open path (non-closed) and is useful for creating smooth or complex curved paths.

Use Cases:

• Creating curved paths and contours
• Spline-like representations
• Profile curves for sweep operations
• Offset operations for parallel curves
• Complex path definitions

Constructor

Rust

let curve = OGCurve::new(id: String);

TypeScript

const curve = new Curve(options?: ICurveOptions);

Rust Constructor Parameters

id · String · required

Unique identifier for the curve instance

TypeScript Constructor Parameters

options · ICurveOptions

Configuration options for the curve

options.ogid · string

Optional unique identifier (auto-generated if not provided)

options.controlPoints · Vector3[] · required

Array of control points defining the curve path

options.color · number · required

Curve color as a hexadecimal number (e.g., 0x00aa55)

Methods

set_config

Rust

curve.set_config(control_points: Vec<Vector3>);

Updates the curve’s control points and regenerates geometry.

TypeScript

curve.setConfig(options: ICurveOptions);

Updates the curve configuration and regenerates geometry.

generate_geometry

Rust

curve.generate_geometry();

TypeScript

// Called automatically by setConfig

Generates vertices and edges connecting the control points sequentially.

get_geometry_serialized

Rust

let geometry: String = curve.get_geometry_serialized();

TypeScript

// Used internally for rendering

Returns serialized vertex buffer data as a JSON string.

get_offset_serialized

Rust

let offset_data = curve.get_offset_serialized(
    distance: f64,
    acute_threshold_degrees: f64,
    bevel: bool
);

TypeScript

const result = curve.getOffset(
    distance: number,
    acuteThresholdDegrees: number = 35.0,
    bevel: boolean = true
): ICurveOffsetResult;

Generates an offset curve parallel to the original at the specified distance. The curve is treated as an open path.

distance · number · required

Distance to offset the curve (positive or negative)

acuteThresholdDegrees · number · default: "35.0"

Angle threshold for beveling acute corners

bevel · boolean · default: "true"

Enable beveling at acute angles

get_brep_serialized

Rust

let brep: String = curve.get_brep_serialized();

TypeScript

// Available through internal API

Returns the complete BREP representation including vertices and edges.

dispose

Rust

curve.dispose();

Clears the BREP and control points to free memory.

Properties

id · String

Unique identifier for the curve instance

control_points · Vec<Vector3>

Array of control points defining the curve

brep · Brep

Internal BREP representation containing vertices and edges

color · number

Curve color (TypeScript only, settable)

Code Examples

Creating a Simple Curve

Rust

use opengeometry::primitives::OGCurve;
use openmaths::Vector3;

let mut curve = OGCurve::new("curve-1".to_string());
let control_points = vec![
    Vector3::new(0.0, 0.0, 0.0),
    Vector3::new(5.0, 0.0, 3.0),
    Vector3::new(10.0, 0.0, 2.0),
    Vector3::new(15.0, 0.0, 5.0),
];
curve.set_config(control_points);

TypeScript

import { Curve, Vector3 } from 'opengeometry-three';

const curve = new Curve({
  controlPoints: [
    new Vector3(0, 0, 0),
    new Vector3(5, 0, 3),
    new Vector3(10, 0, 2),
    new Vector3(15, 0, 5)
  ],
  color: 0x00aa55
});

Creating a Wave Pattern

TypeScript

// Generate a sine wave using control points
const controlPoints = [];
for (let i = 0; i <= 20; i++) {
  const x = i * 2;
  const z = Math.sin(i * 0.5) * 5;
  controlPoints.push(new Vector3(x, 0, z));
}

const wave = new Curve({
  controlPoints,
  color: 0x0088ff
});

Generating Offset Curves

Rust

let offset_data = curve.get_offset_serialized(2.0, 35.0, true);
let result: OffsetResult = serde_json::from_str(&offset_data).unwrap();

println!("Offset points: {}", result.points.len());
println!("Is closed: {}", result.is_closed);  // false for curves

TypeScript

const offsetResult = curve.getOffset(2.0, 35.0, true);

console.log(offsetResult.points);              // Vector3[]
console.log(offsetResult.beveledVertexIndices); // number[]
console.log(offsetResult.isClosed);            // false (curves are open)

// Create a parallel curve
const parallelCurve = new Curve({
  controlPoints: offsetResult.points,
  color: 0xff0088
});

Creating Multiple Parallel Curves

TypeScript

const baseCurve = new Curve({
  controlPoints: [
    new Vector3(0, 0, 0),
    new Vector3(10, 0, 5),
    new Vector3(20, 0, 3),
    new Vector3(30, 0, 8)
  ],
  color: 0xff0000
});

// Create offset curves on both sides
const distances = [2, 4, 6];
const upperCurves = distances.map(d => {
  const offset = baseCurve.getOffset(d);
  return new Curve({
    controlPoints: offset.points,
    color: 0x0000ff
  });
});

const lowerCurves = distances.map(d => {
  const offset = baseCurve.getOffset(-d);
  return new Curve({
    controlPoints: offset.points,
    color: 0x00ff00
  });
});

Updating Curve Control Points

TypeScript

curve.setConfig({
  controlPoints: [
    new Vector3(0, 0, 0),
    new Vector3(8, 0, 4),
    new Vector3(16, 0, 1),
    new Vector3(24, 0, 6)
  ],
  color: 0xffff00
});

// Change color
curve.color = 0xff00ff;

Bezier-like Curve Approximation

TypeScript

// Approximate a quadratic bezier with control points
function quadraticBezier(
  p0: Vector3, 
  p1: Vector3, 
  p2: Vector3, 
  segments: number
): Vector3[] {
  const points = [];
  for (let i = 0; i <= segments; i++) {
    const t = i / segments;
    const x = (1-t)*(1-t)*p0.x + 2*(1-t)*t*p1.x + t*t*p2.x;
    const y = (1-t)*(1-t)*p0.y + 2*(1-t)*t*p1.y + t*t*p2.y;
    const z = (1-t)*(1-t)*p0.z + 2*(1-t)*t*p1.z + t*t*p2.z;
    points.push(new Vector3(x, y, z));
  }
  return points;
}

const bezierPoints = quadraticBezier(
  new Vector3(0, 0, 0),
  new Vector3(10, 0, 10),
  new Vector3(20, 0, 0),
  20
);

const bezierCurve = new Curve({
  controlPoints: bezierPoints,
  color: 0xff00ff
});