Name 
Description 

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 be clear about whether their angle is degrees or radians. 

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. 

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 defined by its 4 corner points. 

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 

BSplineSurface3d 
BSplineSurface3d is a parametric surface in xyz space. 

BSplineSurface3dH 
BsplinceCurve in xyzw homogeneous space 

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 
Static class whose various methods are functions for clipping geometry 

ClipVector 
Class holding an array structure of shapes defined by ClipPrimitive 

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

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. 

CoordinateXYZ 
A Coordinate is a persistable Point3d 

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. 

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

CurveLocationDetailArrayPair 
Data bundle for a pair of arrays of CurveLocationDetail structures such as produced by CurveCurve,IntersectXY and 

CurveLocationDetailPair 
A pair of CurveLocationDetail. 

CurvePrimitive 
A curve primitive is bounded 

CylindricalRangeQuery 
Context for computing geometry range around an axis. 

FacetFaceData 
Data for a face in a polyface containing facets. 

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

Geometry 
Class containing static methods for typical numeric operations. 

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

GeometryQuery 
* GeometryQuery is an abstract base class with (abstract) methods for querying curve, solid primitive, mesh, and bspline surfaces 

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 


HalfEdgeMaskValidation 
static methods to inpsect mask consistency properties in HalfEdgeGraph. 

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

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. 

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

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

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

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 segments. 

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

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 carries data used in calculation of moments of inertia. 

NullGeometryHandler 
NullGeometryHandler is a base class for dispatching various geometry types to 

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

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. 

Plane3dByOriginAndUnitNormal 
A plane defined by 

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

PlaneByOriginAndVectors4d 
A Plane4dByOriginAndVectors 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. 

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. 

PointString3d 
A PointString3d is an array of points. 

Polyface 
A Polyface is n 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 . 

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. 

PolygonOps 
Various (static method) computations for arrays of points interpreted as a polygon. 

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. 

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 

RotationalSweep 
A LinearSweep is 

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

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

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. 

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. 

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

Transform 
A transform is an origin and a Matrix3d. 

Triangulator 
(static) mehods for triangulating polygons 

UnionOfConvexClipPlaneSets 
A collection of ConvexClipPlaneSets. 

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

UVSurfaceOps 
UVSurfaceOps is a class containing static methods operating on UVSurface objects. 

Vector2d 
2D vector with x ,y as properties 

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

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

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

XYParitySearchContext 
* XYParitySerachContext 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 point and vector. 

YawPitchRollAngles 
Three angles that determine the orientation of an object in space. 