A line formed by start vector of start and a direction vector. Direction vector is not necessarily normalized, but its length does not affect line properties

Line2D

typealias Line2D = Line<DoubleVector2D>

Line3D

typealias Line3D = Line<DoubleVector3D>

LineSegment

interface LineSegment<out V : Vector>

A directed line segment between begin and end

LineSegment2D

typealias LineSegment2D = LineSegment<DoubleVector2D>

LineSegment3D

typealias LineSegment3D = LineSegment<DoubleVector3D>

Polygon

interface Polygon<T>

A closed polygon in 2D space

Radians

@Serializable

@JvmInline

value class Radians(val value: Double) : Angle

Type safe radians

ReferenceFrame

interface ReferenceFrame

RotationOrder

enum RotationOrder : Enum<RotationOrder>

Vector

interface Vector

Vector2D

interface Vector2D<T> : Buffer<T> , Vector

Vector3D

interface Vector3D<T> : Buffer<T> , Vector

Functions

abs

fun abs(angle: Angle): Angle

asVector3D

fun <T> Buffer<T>.asVector3D(): Vector3D<T>

component1

operator fun <T> Vector2D<T>.component1(): T

operator fun <T> Vector3D<T>.component1(): T

component2

operator fun <T> Vector2D<T>.component2(): T

operator fun <T> Vector3D<T>.component2(): T

component3

operator fun <T> Vector3D<T>.component3(): T

cos

fun cos(angle: Angle): Double

equalsFloat

fun Double.equalsFloat(other: Double, precision: Double = DEFAULT_PRECISION): Boolean

fun Double.equalsFloat(other: Float, precision: Double = DEFAULT_PRECISION): Boolean

Float equality within given precision

equalsLine

fun <V : Vector> LineSegment<V>.equalsLine(space: GeometrySpace<V>, other: LineSegment<V>, precision: Double = DEFAULT_PRECISION): Boolean

Line equality using GeometrySpace.norm provided by the space and given precision

equalsVector

fun Float64Vector2D.equalsVector(other: Float64Vector2D, precision: Double = DEFAULT_PRECISION): Boolean

fun Float64Vector3D.equalsVector(other: Float64Vector3D, precision: Double = DEFAULT_PRECISION): Boolean

Vector equality using Euclidian L2 norm and given precision

fun <V : Vector> V.equalsVector(space: GeometrySpace<V>, other: V, precision: Double = DEFAULT_PRECISION): Boolean

Vector equality within given precision (using GeometrySpace.norm provided by the space

fromEuler

fun Quaternion.Companion.fromEuler(a: Angle, b: Angle, c: Angle, rotationOrder: RotationOrder): Quaternion

Based on https://github.com/mrdoob/three.js/blob/master/src/math/Quaternion.js

fromRotation

fun Quaternion.Companion.fromRotation(theta: Angle, vector: DoubleVector3D): Quaternion

Create a normalized Quaternion from rotation angle and rotation vector

fromRotationMatrix

fun Quaternion.Companion.fromRotationMatrix(matrix: Matrix<Double>): Quaternion

taken from https://www.euclideanspace.com/maths/geometry/rotations/conversions/matrixToQuaternion/

Line

fun <V : Vector> Line(base: V, direction: V): Line<V>

line

fun <V : Vector> LineSegment<V>.line(algebra: GeometrySpace<V>): Line<V>

LineSegment

fun <V : Vector> LineSegment(begin: V, end: V): LineSegment<V>

normalized

fun Angle.normalized(center: Angle = Angle.pi): Angle

Normalized angle 2 PI range symmetric around center. By default, uses (0, 2PI) range.

projectAlong

fun <V : Vector> GeometrySpace<V>.projectAlong(vector: V, normal: V, base: V): V

Project vector onto a hyperplane, which is defined by a normal and base. In 2D case it is the projection to a line, in 3d case it is the one to a plane.

projectToLine