Line

A simple line primitive defined by two points

Overview

The Line primitive represents a straight line segment in 3D space, defined by a start point and an end point. It is the simplest 2D primitive in OpenGeometry and is suitable for creating linear segments, edges, and simple geometric constructions.

Use Cases:

• Drawing straight line segments
• Creating basic geometric shapes
• Defining edges in technical drawings
• Path offset operations for parallel lines

Constructor

Rust

let line = OGLine::new(id: String);

TypeScript

const line = new Line(options?: ILineOptions);

Rust Constructor Parameters

id · String · required

Unique identifier for the line instance

TypeScript Constructor Parameters

options · ILineOptions

Configuration options for the line

options.ogid · string

Optional unique identifier (auto-generated if not provided)

options.start · Vector3 · required

Starting point of the line

options.end · Vector3 · required

Ending point of the line

options.color · number · required

Line color as a hexadecimal number (e.g., 0x000000 for black)

options.fatLines · boolean · default: "false"

Enable thick line rendering using Line2

options.width · number · default: "20"

Line width when fatLines is enabled

Methods

set_config

Rust

line.set_config(start: Vector3, end: Vector3);

Updates the line’s start and end points.

TypeScript

line.setConfig(options: ILineOptions);

Updates the line configuration and regenerates geometry.

generate_geometry

Rust

line.generate_geometry();

TypeScript

// Called automatically by setConfig

Generates the BREP (Boundary Representation) geometry for the line, creating vertices and edges.

get_geometry_serialized

Rust

let geometry: String = line.get_geometry_serialized();

TypeScript

// Used internally for rendering

Returns serialized vertex buffer data as a JSON string.

get_offset_serialized

Rust

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

TypeScript

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

Generates an offset path parallel to the line at the specified distance.

distance · number · required

Distance to offset the line (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 = line.get_brep_serialized();

TypeScript

// Available through internal API

Returns the complete BREP representation as JSON.

Properties

id · String

Unique identifier for the line instance

start · Vector3

Starting point of the line (Rust only)

end · Vector3

Ending point of the line (Rust only)

brep · Brep

Internal BREP representation containing vertices and edges

color · number

Line color (TypeScript only, settable)

Code Examples

Creating a Basic Line

Rust

use opengeometry::primitives::OGLine;
use openmaths::Vector3;

let mut line = OGLine::new("line-1".to_string());
line.set_config(
    Vector3::new(0.0, 0.0, 0.0),
    Vector3::new(10.0, 0.0, 0.0)
);
line.generate_geometry();

TypeScript

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

const line = new Line({
  start: new Vector3(0, 0, 0),
  end: new Vector3(10, 0, 0),
  color: 0x000000
});

Generating Offset Lines

Rust

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

TypeScript

const offsetResult = line.getOffset(
  2.0,  // distance
  35.0, // acute threshold
  true  // bevel
);

console.log(offsetResult.points);              // Vector3[]
console.log(offsetResult.beveledVertexIndices); // number[]
console.log(offsetResult.isClosed);            // false for lines

Using Fat Lines

TypeScript

const thickLine = new Line({
  start: new Vector3(0, 0, 0),
  end: new Vector3(10, 5, 0),
  color: 0xff0000,
  fatLines: true,
  width: 50
});

Updating Line Configuration

TypeScript

line.setConfig({
  start: new Vector3(0, 0, 0),
  end: new Vector3(15, 10, 0),
  color: 0x00ff00
});

// Change color dynamically
line.color = 0x0000ff;