When Euclid is opened this module will be auto-opened. It only contains extension members for type Line2D.

When Euclid is opened this module will be auto-opened. It only contains extension members for type Line3D.

When Euclid is opened this module will be auto-opened. It only contains extension members for type Matrix.

When Euclid is opened this module will be auto-opened. It only contains extension members for type Pnt.

When Euclid is opened this module will be auto-opened. It only contains extension members for type PPlane.

When Euclid is opened this module will be auto-opened. It only contains extension members for type Pt.

When Euclid is opened, this module will be auto-opened. It only contains extension members for the type Quaternion.

When Euclid is opened this module will be auto-opened. It only contains extension members for type UnitVc.

When Euclid is opened this module will be auto-opened. It only contains extension members for type UnitVec.

When Euclid is opened this module will be auto-opened. It only contains extension members for type Vc.

When Euclid is opened this module will be auto-opened. It only contains extension members for type Vec.

A struct of 6 floats representing an immutable 3D bounding box. This implementation guarantees the box to always be valid. That means the Min X, Y, and Z values are always smaller or equal to the respective Max values. The X, Y, and Z axes are also called Width, Depth, and Height3D.

   Z-Axis       Y-Axis
   ^           /
   |   7      /        6 MaxPt
   |   +---------------+
   |  /|    /         /|
   | / |   /         / |
 4 |/  |  /       5 /  |
   +---------------+   |
   |   |/          |   |
   |   +-----------|---+
   |  / 3          |  / 2
   | /             | /
   |/              |/
   +---------------+----> X-Axis
   0 MinPt         1

A struct of one Pnt and three Vec, representing an immutable 3D Box with any rotation in 3D space. Described by an Origin and three Edge vectors. Similar to PPlane, however the three vectors are not unitized. This implementation guarantees the box to be always valid. That means the Min X, Y and Z axes cannot be flipped individually. However the length of one of these axes might still be zero.

   local        local
   Z-Axis       Y-Axis
   ^           /
   |   7      /        6
   |   +---------------+
   |  /|    /         /|
   | / |   /         / |
 4 |/  |  /       5 /  |
   +---------------+   |
   |   |/          |   |
   |   +-----------|---+
   |  / 3          |  / 2
   | /             | /
   |/              |/     local
   +---------------+----> X-Axis
   0               1

A struct of 4 floats representing an immutable 2D bounding rectangle. Sometimes also called 2D a bounding box. This implementation guarantees the rectangle to be always valid. That means the Min X and Y values are always smaller or equal than the respective Max values.

   Y-Axis
   ^
   |
   |             2 max X,Y
 3 +------------+
   |            |
   |            |
   |            |
   |            |
   |            |       local
   +------------+-----> X-Axis
  0-min X,Y      1

A module of precalculated cosine values for faster checking the angles of dot products of unit-vectors.

An internal module for Euclid specific exceptions and failure functions.

A module with functions for formatting floats with adaptive precision.

A class containing an array of 8 points representing an arbitrary 3D Box. The points can be in arbitrary position in space.

       7               6
       +---------------+
      /|              /|
     / |             / |
 4  /  |          5 /  |
   +---------------+   |
   |   |           |   |
   |   +-----------|---+
   |  / 3          |  / 2
   | /             | /
   |/              |/
   +---------------+
   0               1

A struct containing 4 floats, representing an immutable finite line in 2D.

A struct containing 6 floats, representing an immutable finite line in 3D.

A struct containing 16 floats, representing an immutable 4x4 transformation matrix. The matrix is represented in the following column-vector syntax form:

 M11 M21 M31 X41
 M12 M22 M32 Y42
 M13 M23 M33 Z43
 M14 M24 M34 M44

Where X41, Y42 and Z43 refer to the translation part of the matrix. Note: Never use the struct default constructor Matrix() as it will create an invalid zero Matrix. Use Matrix.create or Matrix.createUnchecked instead.

A struct containing a Pnt and a UnitVec, representing an unparametrized plane defined by a point and a normal vector. As opposed to the PPlane, this plane is not parametrized in X, Y, and Z directions. Note: Never use the struct default constructor NPlane() as it will create an invalid zero plane. Use NPlane.create or NPlane.createUnchecked instead.

A module containing the core algorithms for offsetting 2D polylines. Normally you would not use this directly; prefer the Polyline2D or Points2D module.

A module containing the core algorithms for offsetting 2D polylines. Normally you would not use this directly; prefer the Polyline2D or Points2D module. Each vertex has its own normal defined by the cross product of the incoming and outgoing segment tangents. These vertex normals define a local plane for each joint; within that plane we build per-segment offset directions.

A struct containing 3 floats, representing an immutable 3D point. X, Y, and Z. A 3D point represents a location in space, but not direction. (use Vec for that.) (2D Points are called 'Pt' )

A type containing only static member functions for operating on multiple 2D points or set of 2D points. Aka point-clouds

A type containing only static member functions for operating on multiple 3D points or set of 3D points. Aka point-clouds

A class holding a list of 2D points representing a mutable 2D Polyline. If the last point is the same as the first point, the Polyline2D is considered closed. The Default constructor uses the provided ResizeArray of points directly, so changes to the list will be reflected in the Polyline2D.

A class holding a list of 3D points representing a mutable 3D Polyline. If the last point is the same as the first point, the Polyline3D is closed. The Default constructor uses the provided ResizeArray of points directly, so changes to the list will be reflected in the Polyline3D.

A struct containing one 3D point and three 3D unit vectors, representing an immutable parametrized plane or frame with unitized X, Y and Z Direction. This struct is called 'PPlane'; the other plane 'NPlane' refers to an un-oriented plane consisting only of an origin and a normal. Note: Never use the struct default constructor PPlane() as it will create an invalid zero length PPlane. Use PPlane.create or PPlane.createUnchecked instead.

Pt is an immutable 2D point. Made up from 2 floats: X and Y.

A struct containing 4 floats, representing an immutable unitized Quaternion, for arbitrary 3D rotations. This implementation guarantees the Quaternion to be always unitized. Note: Never use the struct default constructor Quaternion() as it will create an invalid zero length Quaternion. Use Quaternion.create or Quaternion.createUnchecked instead.

A struct containing a 2D Origin point and two 2D Edge vectors, representing an immutable 2D Rectangle with any rotation in 2D space. This implementation guarantees the 2D Rectangle to be always valid. That means the X and Y axes are always perpendicular to each other. However the length of one of these axes might still be zero.

   local
   Y-Axis
   ^
   |
   |             2
 3 +------------+
   |            |
   |            |
   |            |
   |            |
   |            |       local
   +------------+-----> X-Axis
  0-Origin       1

A struct containing a 3D Origin point and two 3D Edge vectors, representing an immutable planar 3D-rectangle with any rotation in 3D space. Similar to PPlane, however the two vectors are not unitized. This implementation guarantees the 3D-rectangle to be always valid. That means the X and Y axes are always perpendicular to each other. However the length of one of these axes might still be zero.

   local
   Y-Axis
   ^
   |
   |             2
 3 +------------+
   |            |
   |            |
   |            |
   |            |
   |            |       local
   +------------+-----> X-Axis
  0-Origin       1

A struct containing 12 floats, representing an immutable 4x3 rigid matrix. For only rotation and translation in 3D space. This matrix guarantees to NOT scale, shear, flip, mirror, reflect or project. Angles are preserved. Lengths are preserved. Area is preserved. Volume is preserved. A rigid matrix is a matrix whose 3x3 columns and rows are orthogonal unit-vectors. The matrix is represented in the following column-vector syntax form:

 M11 M21 M31 X41
 M12 M22 M32 Y42
 M13 M23 M33 Z43

Where X41, Y42 and Z43 refer to the translation part of the RigidMatrix. The Determinant of this matrix is always 1.0. Note: Never use the struct default constructor RigidMatrix() as it will create an invalid zero RigidMatrix. Use RigidMatrix.create instead.

A struct containing 2 floats, representing a 2D Counter Clockwise rotation. It can be applied in World X, Y or Z plane. Internally stored just as a Sine and Cosine value. For arbitrary rotations use Quaternions or 4x4 Matrix. However this module has much better performance than the more general Matrix4x4 or a Quaternion. Note: Never use the struct default constructor Rotation2D() as it will create an invalid zero Rotation2D. Use Rotation2D.createFromRadians, Rotation2D.createFromDegrees, or Rotation2D.createUnchecked instead.

A module for finding 2D object that are similar but not exactly the same. Based on their 2D point clouds. Within one list of points the order does not matter, but each location must exist only once in order to be consider similar within the tolerance. (This module could be extended to work in 3d too)

A module of precalculated tangent values for faster checking the angles between two vectors. The Cross Product length (=determinant) divided by the Dot Product value gives the tangent of the angle between two vectors. If one of vectors has a zero length, the tangent is NaN

A type containing only static member functions for 2D topological operations.

A type containing only static member functions for 3D topological operations.

A type containing only static member functions for operations on 2D Triangles.

A type containing only static member functions for operations on 2D Triangles.

A struct containing 2 floats, representing an 2D unitized vector. All instances of this type are guaranteed to be always unitized. Never use the struct default constructor UnitVc()! It will create an invalid zero length vector. Use UnitVc.create or UnitVc.createUnchecked instead.

A struct containing 3 floats, representing an 3D unitized vector. All instances of this type are guaranteed to be always unitized. A 3D vector represents a direction or translation in space, but not a location. A 4x4 transformation matrix applied to a vector will only rotate and scale the vector but not translate it. (2D unit-vectors are called 'UnitVc' ) Use UnitVec.create or UnitVec.createUnchecked to create instances. Note: Never use the struct default constructor UnitVec() as it will create an invalid zero length vector. Use UnitVec.create or UnitVec.createUnchecked instead.

A module for math , logic utility functions and default tolerance values for use within Euclid.

Vc is an immutable 2D vector with any length. Made up from 2 floats: X and Y.

An immutable 3D vector of any length. Made up from 3 floats: X, Y, and Z. A 3D vector represents a direction or translation in space, but not a location. A 4x4 transformation matrix applied to a vector will only rotate and scale the vector but not translate it. (3D unit-vectors of length 1.0 are called 'UnitVec' ) (2D vectors are called 'Vc' )

A module containing the result types for 2D Line-Line-Intersections and 2D Line-Line relationship queries.

A type containing only static member functions for computing 2D line intersections. Some functions return Discriminated Unions from the XLine2D module.

A module containing the result types for 3D Line-Line-Intersections, 3D Line-Line relationship queries, and Line-Cone intersections.

A type containing only static member functions for computing 3D line intersections and closest approaches. Some functions return Discriminated Unions from the XLine3D module.