Name 
Description 

AkimaCurve3d 
Interpolating curve. 

AkimaCurve3dOptions 
fitPoints and end condition data for AkimaCurve3d 

AlternatingCCTreeBuilder 
Context structure for building an AlternatingConvexClipTreeNode from a polygon. 

AlternatingCCTreeNode 
An AlternatingConvexClipTreeNode is a node in a tree structure in which 

AlternatingCCTreeNodeCurveClipper 


Angle 
An Angle carries the numeric value of an angle, with methods to allow (require!) callers to 

AngleSweep 
An AngleSweep is a pair of angles at start and end of an interval. 

Arc3d 
Circular or elliptic arc. 

AuxChannel 
Represents a single PolyfaceAuxData channel. 

AuxChannelData 
Represents the AuxChannel data at a single input value. 

BagOfCurves 
* A BagOfCurves object is a collection of AnyCurve objects. 

BarycentricTriangle 
3 points defining a triangle to be evaluated with barycentric coordinates. 

BentleyGeometryFlatBuffer 
Top level entries to convert between GeometryQuery types and FlatBuffer Bytes. 

Bezier1dNd 
Shared implementation details for derived bezier curve classes 

BezierCurve3d 
3d Bezier curve class. 

BezierCurve3dH 
3d curve with homogeneous weights. 

BezierCurveBase 
Base class for CurvePrimitive (necessarily 3D) with _polygon. 

BilinearPatch 
A bilinear patch is a surface defined by its 4 corner points. 

BooleanClipFactory 
A BooleanClipFactory is a factory to create objects that implement interior nodes of a tree of boolean clip operations. 

Box 
A boxlike solid defined by 

BSpline1dNd 
Bspline knots and poles for 1dtoNd. 

BSpline2dNd 
Bspline knots and poles for 2dtoNd. 

BSplineCurve3d 
A BSplineCurve3d is a bspline curve whose poles are Point3d. 

BSplineCurve3dBase 
Base class for BSplineCurve3d and BSplineCurve3dH. 

BSplineCurve3dH 
Weighted (Homogeneous) BSplineCurve in 3d 

BSplineCurveOps 
A class with static methods for creating Bspline curves. 

BSplineSurface3d 
BSplineSurface3d is a parametric surface in xyz space. 

BSplineSurface3dH 
BSpline Surface in xyzw homogeneous space 

ClippedPolyfaceBuilders 
A pair of PolyfaceBuilder objects, for use by clippers that emit inside and outside parts. 

ClipPlane 
A ClipPlane is a single plane represented as 

ClipPrimitive 
* ClipPrimitive is a base class for clipping implementations that use 

ClipShape 
A clipping volume defined by a shape (an array of 3d points using only x and y dimensions). 

ClipUtilities 
Class whose various static methods are functions for clipping geometry 

ClipVector 
Class holding an array structure of shapes defined by ClipPrimitive 

CloneCurvesContext 
Algorithmic class for cloning curve collections. 

Cone 
A cone with axis along the z axis of a (possibly skewed) local coordinate system. 

ConsolidateAdjacentCurvePrimitivesOptions 
* Options to control method RegionOps.consolidateAdjacentPrimitives 

ConstructCurveBetweenCurves 
Context for constructing a curve that is interpolated between two other curves. 

ConvexClipPlaneSet 
A ConvexClipPlaneSet is a collection of ClipPlanes, often used for bounding regions of space. 

ConvexFacetLocationDetail 
Implementation of FacetLocationDetail for a convex facet. 

CoordinateXYZ 
A Coordinate is a Point3d with supporting methods from the GeometryQuery abstraction. 

CurveAndSurfaceLocationDetail 
Carrier for both curve and surface data, e.g. 

CurveChain 
Shared base class for use by both open and closed paths. 

CurveChainWithDistanceIndex 
CurveChainWithDistanceIndex is a CurvePrimitive whose fractional parameterization is proportional to true 

CurveCollection 
A CurveCollection is an abstract (noninstantiable) class for various sets of curves with particular structures: 

CurveCurve 
CurveCurve has static method for various computations that work on a pair of curves or curve collections. 

CurveExtendOptions 
Logic for deciding how a curve may be extended for closest point or intersection searches. 

CurveFactory 
The CurveFactory class contains methods for specialized curve constructions. 

CurveLocationDetail 
CurveLocationDetail carries point and parameter data about a point evaluated on a curve. 

CurveLocationDetailArrayPair 
Data bundle for a pair of arrays of CurveLocationDetail structures such as produced by CurveCurve.intersectionXYZ. 

CurveLocationDetailPair 
A pair of CurveLocationDetail. 

CurveOps 
Static methods for miscellaneous curve operations. 

CurvePrimitive 
A curve primitive is bounded. 

CylindricalRangeQuery 
Context for computing geometry range around an axis. 

DeepCompare 
Utilities to compare json objects by searching through their properties. 

DirectSpiral3d 
DirectSpiral3d acts like a TransitionSpiral3d for serialization purposes, but implements spiral types that have "direct" xy calculations without the integrations required 

Ellipsoid 
* An Ellipsoid is a (complete) unit sphere with an arbitrary (possibly skewed) Transform to 3d. 

EllipsoidPatch 
* An EllipsoidPatch is 

FacetFaceData 
Data for a face in a polyface containing facets. 

FacetIntersectOptions 
Options for computing and processing facet intersection methods. 

FacetOffsetProperties 


FacetOrientationFixup 


FrameBuilder 
Helper class to accumulate points and vectors until there is enough data to define a coordinate system. 

GeodesicPathPoint 
Detailed data for a point on a 2angle parameter space. 

GeodesicPathSolver 
Algorithm implementation class for computing approximate optimal (shortest) path points. 

Geometry 
Class containing static methods for typical numeric operations. 

GeometryHandler 
GeometryHandler defines the base abstract methods for doubledispatch geometry computation. 

GeometryQuery 
Queries to be supported by Curve, Surface, and Solid objects 

GraphSplitData 


GriddedRaggedRange2dSet 
A GriddedRaggedRange2dSet is: 

GriddedRaggedRange2dSetWithOverflow 
Use GriddedRaggedRange2dSetWithOverflow for searching among many ranges for which: 

GrowableBlockedArray 
Array of contiguous doubles, indexed by block number and index within block. 

GrowableFloat64Array 
A GrowableFloat64Array is Float64Array accompanied by a count of how many of the array's entries are considered in use. 

GrowableXYArray 
GrowableXYArray manages a (possibly growing) Float64Array to pack xy coordinates. 

GrowableXYZArray 
GrowableXYArray manages a (possibly growing) Float64Array to pack xy coordinates. 

HalfEdgeGraphSearch 


HalfEdgeMaskTester 


HalfEdgeMaskValidation 
static methods to inspect mask consistency properties in HalfEdgeGraph. 

HalfEdgePointerInspector 
HalfEdgePointerInspector has methods to check HalfEdge objects for pointer errors. 

HalfEdgePositionDetail 
Description of a generalized position within a graph, categorized as: 

IndexedCollectionInterval 
Object describing a (contiguous) subset of indices to an IndexedXYZCollection 

IndexedEdgeMatcher 
An IndexedEdgeMatcher carries an array (edges ) of edges start & end indices for sorting and subsequent analyses (such as testing for closed mesh) 

IndexedPolyface 
An IndexedPolyface is a set of facets which can have normal, param, and color arrays with independent point, normal, param, and color indices. 

IndexedPolyfaceSubsetVisitor 
An IndexedPolyfaceSubsetVisitor is an IndexedPolyfaceVisitor which only visits a subset of facets in the polyface. 

IndexedPolyfaceVisitor 
An IndexedPolyfaceVisitor is an iteratorlike object that "visits" facets of a mesh. 

IndexedReadWriteXYZCollection 
abstract base class extends IndexedXYZCollection, adding methods to push, peek, and pop, and rewrite. 

IndexedXYCollection 
abstract base class for access to XY data with indexed reference. 

IndexedXYZCollection 
abstract base class for readonly access to XYZ data with indexed reference. 

IndexedXYZCollectionInterval 
Reference to an interval of the indices of an IndexedXYZCollection. 

IndexedXYZCollectionPolygonOps 
IndexedXYZCollectionPolygonOps class contains static methods for typical operations on polygons carried as IndexedXyZCollection 

InsertAndRetriangulateContext 
Context for repeated insertion of new points in a graph. 

IntegratedSpiral3d 
An IntegratedSpiral3d is a curve defined by integrating its curvature. 

InterpolationCurve3d 
Interpolating curve. 

InterpolationCurve3dOptions 
fitPoints and end condition data for InterpolationCurve3d 

JointOptions 
Control parameters for joint construction, used in offset construction methods such as RegionOps.constructPolygonWireXYOffset and Region.Ops.constructCurveXYOffset. 

KnotVector 
Array of nondecreasing numbers acting as a knot array for bsplines. 

LinearSweep 
A LinearSweep is a SolidPrimitive defined by 

LineSegment3d 
A LineSegment3d is: 

LineString3d 
* A LineString3d (sometimes called a PolyLine) is a sequence of xyz coordinates that are to be joined by line 

LongitudeLatitudeNumber 
An AngleAngleNumber is a pair of angles (named longitude and latitude ) and an additional number. 

Loop 
A Loop is a curve chain that is the boundary of a closed (planar) loop. 

LoopCurveLoopCurve 
Structure carrying a pair of loops with curve geometry. 

Map4d 
Map4 carries two Matrix4d which are inverses of each other. 

Matrix3d 
A Matrix3d is a 3x3 matrix. 

Matrix4d 
* A Matrix4d is a matrix with 4 rows and 4 columns. 

MomentData 
A MomentData structure exists in several levels: 

NonConvexFacetLocationDetail 
Implementation of FacetLocationDetail for a nonconvex facet. 

NullGeometryHandler 
NullGeometryHandler is a base class for dispatching various geometry types to application specific implementation 

NumberArray 
The NumberArray class contains static methods that act on arrays of numbers. 

OffsetMeshContext 


OffsetMeshOptions 
Options carrier for PolyfaceQuery.cloneOffset. 

OffsetOptions 
Options for offsetting a curve, used in offset construction methods such as CurvePrimitive.constructOffsetXY, RegionOps.constructPolygonWireXYOffset and Region.Ops.constructCurveXYOffset. 

ParityRegion 
* A ParityRegion is a collection of Loop objects. 

Path 
* A Path object is a collection of curves that join headtotail to form a path. 

PathFragment 
Annotation of an interval of a curve. 

Plane3d 
Plane3d is the abstract base class for multiple 3d plane representations: 

Plane3dByOriginAndUnitNormal 
A plane defined by 

Plane3dByOriginAndVectors 
A Plane3dByOriginAndVectors is an origin and a pair of vectors. 

PlaneByOriginAndVectors4d 
A PlaneByOriginAndVectors4d is a 4d origin and pair of 4d "vectors" defining a 4d plane. 

Point2d 
2D point with x ,y as properties 

Point2dArray 
The Point2dArray class contains static methods that act on arrays of 2d points. 

Point2dArrayCarrier 
Helper object to access members of a Point2d[] in geometric calculations. 

Point3d 
3D point with x ,y ,z as properties 

Point3dArray 
The Point3dArray class contains static methods that act on arrays of 3d points. 

Point3dArrayCarrier 
Helper object to access members of a Point3d[] in geometric calculations. 

Point3dArrayPolygonOps 
Point3dArrayPolygonOps class contains static methods for typical operations on polygons carried as Point3d[] 

Point4d 
4 Dimensional point (x,y,z,w) used in perspective calculations. 

Point4dArray 
The Point4dArray class contains static methods that act on arrays of 4d points. 

PointSearchContext 


PointStreamGrowableXYZArrayCollector 
Concrete class to handle startChain, handleXYZ and endChain calls and return a (onelevel deep array of 

PointStreamRangeCollector 
PointStream handler to collect the range of points. 

PointStreamXYZXYZHandlerBase 
Base class for handling points in pairs. 

PointString3d 
A PointString3d is an array of points. 

PointStringDeepXYZArrayCollector 


Polyface 
A Polyface is an abstract mesh structure (of unspecified implementation) that provides a PolyfaceVisitor 

PolyfaceAuxData 
The PolyfaceAuxData structure contains one or more analytical data channels for each vertex of a Polyface, allowing the polyface to be styled 

PolyfaceBuilder 
* Simple construction for strongly typed GeometryQuery objects: 

PolyfaceClip 
PolyfaceClip is a static class gathering operations using Polyfaces and clippers. 

PolyfaceData 
PolyfaceData carries data arrays for point, normal, param, color and their indices. 

PolyfaceQuery 
PolyfaceQuery is a static class whose methods implement queries on a polyface or polyface visitor provided as a parameter to each method. 

PolygonLocationDetail 
Carries data about a point in the plane of a polygon. 

PolygonOps 
Various static methods to perform computations on an array of points interpreted as a polygon. 

PolylineOps 
PolylineOps is a collection of static methods operating on polylines. 

ProxyCurve 
A ProxyCurve is expected to be used as a base class for curve types that use some existing curve (the proxy) 

Range1d 
Range on a 1d axis 

Range2d 
Range box in xy plane 

Range3d 
Axis aligned range in 3D. 

RangeBase 
Base class for Range1d, Range2d, Range3d. 

RangeLengthData 
Accumulated data for x,y,z length statistics in ranges. 

RangeSearch 
Class with static members to work with various range searchers. 

Ray2d 
Ray with xy origin and direction 

Ray3d 
A Ray3d contains 

RecurseToCurvesGeometryHandler 
Implement GeometryHandler methods, with all curve collection methods recursing to children. 

RecursiveCurveProcessor 
base class for detailed traversal of curve artifacts. 

RecursiveCurveProcessorWithStack 
base class for detailed traversal of curve artifacts 

RegionOps 
Class RegionOps has static members for calculations on regions (areas). 

RotationalSweep 
A LinearSweep is 

RuledSweep 
A ruled sweep (surface) is a collection of 2 or more contours. 

SectorOffsetProperties 
Sector properties during offset. 

Segment1d 
* A Segment1d is an interval of an axis named x. 

SignedDataSummary 
Class to accumulate statistics about a stream of signed numbers with tag items. 

SmallSystem 
static methods for commonly appearing sets of equations in 2 or 3 variables 

SmoothTransformBetweenFrusta 
context for constructing smooth motion a startFrustum and endFrustum. 

SolidPrimitive 
Base class for SolidPrimitive variants. 

SortableEdge 
* For boundary sorting, an edge is a (packed!) Float64Array. 

SpacePolygonTriangulation 
Class with static methods to triangulate various forms of possibly nonplanar polygons. 

Sphere 
A Sphere is 

StrokeCountChain 
class StrokeCountChain contains: 

StrokeCountMap 
Data carrier interface for perprimitive stroke counts and distances used by PolyfaceBuilder. 

StrokeOptions 
Tolerance blob for various stroking methods. 

SweepContour 
Sweepable contour with Transform for local to world interaction. 

SweepLineStringToFacetContext 


SweepLineStringToFacetsOptions 
Options carrier for sweeping linework onto meshes. 

TaggedNumericData 
Structure with 2 integer tags and optional arrays of integers, doubles, points, vectors, and geometry. 

TorusPipe 
A torus pipe is a partial torus (donut). 

Transform 
A Transform consists of an origin and a Matrix3d. 

TransitionConditionalProperties 
A true transition spiral is a curve defined by its curvature, with the curvature function symmetric about midpoint. 

TransitionSpiral3d 
TransitionSpiral3d is a base class for multiple variants of spirals. 

TriangleLocationDetail 
Carries data about a location in the plane of a triangle. 

TriangularFacetLocationDetail 
Implementation of FacetLocationDetail for a triangular facet. 

UnionOfConvexClipPlaneSets 
A collection of ConvexClipPlaneSets. 

UnionRegion 
* A UnionRegion is a collection of other planar region types  Loop and ParityRegion . 

UVSurfaceLocationDetail 
CurveLocationDetail carries point and paramter data about a point evaluated on a curve. 

UVSurfaceOps 
Support methods to act on surfaces with 0..1 uv fractional parameterization 

Vector2d 
2D vector with x ,y as properties 

Vector3d 
3D vector with x ,y ,z as properties 

Vector3dArray 
The Vector3dArray class contains static methods that act on arrays of 3d vectors. 

VertexNeighborhoodSortData 
Structure for data used when sorting outbound edges "around a node" 

XY 
Minimal object containing x,y and operations that are meaningful without change in both point and vector. 

XYParitySearchContext 
* XYParitySearchContext is an internal class for callers that can feed points (without extracting to array structures) 

XYZ 
* XYZ is a minimal object containing x,y,z and operations that are meaningful without change in both 

YawPitchRollAngles 
Three angles that determine the orientation of an object in space, sometimes referred to as [Taitâ€“Bryan angles] 
