Class List

Here are the classes, structs, unions and interfaces with brief descriptions:

[detail level 1234567]

▼NConsoleTestRunner
CArguments	Arguments class
CConsoleTest	Summary description for ConsoleTest.
CTestInfo	Summary description for TestInfo.
CTestInfoCollection	Summary description for TestInfoCollection.
CTestOptionsParser	Summary description for TestOptionsParser.
CTestRunner	Summary description for TestRunner.
▼NDotSpatial
▼NGeoAPI
►NGeometries
►NTest
CConvertAndBackTest
CNetTopologySuiteBootstrapper	A utility class to register NTS as GeoAPI implementation to use
▼NGisSharpBlog
►NNetTopologySuite
►NSamples
►NTests
►NVarious
CGraphBuilder
CGraphBuilderTest
►NWindows
►NForms
CShapeCollectionPathIterator
▼NMiscUtil
►NConversion
CDoubleConverter	A class to allow the conversion of doubles to string representations of their exact decimal values. The implementation aims for readability over efficiency.
▼NNetTopologySuite
►NAlgorithm
►NDistance
►CDiscreteHausdorffDistance	An algorithm for computing a distance metric which is an approximation to the Hausdorff Distance based on a discretization of the input IGeometry.
CMaxDensifiedByFractionDistanceFilter
CMaxPointDistanceFilter
CPointPairDistance	Contains a pair of points and the distance between them.
►NLocate
CIndexedPointInAreaLocator	Determines the location of Coordinates relative to a IPolygonal geometry, using indexing for efficiency. This algorithm is suitable for use in cases where many points will be tested against a given area. Thread-safe and immutable. /summary> <author>Martin Davis</author>
CIPointOnGeometryLocator	An interface for classes which determine the Location of points in areal geometries.
CSimplePointInAreaLocator	Computes the location of points relative to an areal IGeometry, using a simple O(n) algorithm. This algorithm is suitable for use in cases where only one or a few points will be tested against a given area. /summary>
►NMatch
CAreaSimilarityMeasure	Measures the degree of similarity between two IGeometrys using the area of intersection between the geometries. The measure is normalized to lie in the range [0, 1]. Higher measures indicate a great degree of similarity.
CHausdorffSimilarityMeasure	Measures the degree of similarity between two IGeometrys using the Hausdorff distance metric.
CISimilarityMeasure	An interface for classes which measures the degree of similarity between two Geometrys.
CCentralEndpointIntersector	Computes an approximate intersection of two line segments by taking the most central of the endpoints of the segments. This is effective in cases where the segments are nearly parallel and should intersect at an endpoint. It is also a reasonable strategy for cases where the endpoint of one segment lies on or almost on the interior of another one. Taking the most central endpoint ensures that the computed intersection point lies in the envelope of the segments. Also, by always returning one of the input points, this should result in reducing segment fragmentation. Intended to be used as a last resort for computing ill-conditioned intersection situations which cause other methods to fail.
CCentroid	Computes the centroid of a IGeometry of any dimension. If the geometry is nominally of higher dimension, but has lower effective dimension (i.e. contains only components having zero length or area), the centroid will be computed as for the equivalent lower-dimension geometry. If the input geometry is empty, a null Coordinate is returned
CCentroidArea	Computes the centroid of an area point.
CCentroidLine	Computes the centroid of a linear point. Algorithm: Compute the average of the midpoints of all line segments weighted by the segment length.
CCentroidPoint	Computes the centroid of a point point. Algorithm: Compute the average of all points.
CCGAlgorithms3D
CConvexHull	Computes the convex hull of a Geometry. The convex hull is the smallest convex Geometry that contains all the points in the input Geometry. Uses the Graham Scan algorithm.
CHCoordinate	Represents a homogeneous coordinate in a 2-D coordinate space. In NTS HCoordinates are used as a clean way of computing intersections between line segments.
CIBoundaryNodeRule	An interface for rules which determine whether node points which are in boundaries of ILineal geometry components are in the boundary of the parent geometry collection. The SFS specifies a single kind of boundary node rule, the BoundaryNodeRules.Mod2BoundaryNodeRule rule. However, other kinds of Boundary Node Rules are appropriate in specific situations (for instance, linear network topology usually follows the BoundaryNodeRules.EndPointBoundaryNodeRule.) Some JTS operations (such as RelateOp, BoundaryOp and IsSimpleOp) allow the BoundaryNodeRule to be specified, and respect the supplied rule when computing the results of the operation. An example use case for a non-SFS-standard Boundary Node Rule is that of checking that a set of ILineStrings have valid linear network topology, when turn-arounds are represented as closed rings. In this situation, the entry road to the turn-around is only valid when it touches the turn-around ring at the single (common) endpoint. This is equivalent to requiring the set of LineStrings to be simple under the BoundaryNodeRules.EndPointBoundaryNodeRule. The SFS-standard BoundaryNodeRules.Mod2BoundaryNodeRule is not sufficient to perform this test, since it states that closed rings have no boundary points. This interface and its subclasses follow the Strategy design pattern. /summary> <author>Martin Davis</author> See also RelateOp, BoundaryOp, IsSimpleOp, PointLocator
CIndexedPointInAreaLocator	Determines the Location of ICoordinates relative to a IPolygonal geometry, using indexing for efficiency. /summary>
CInteriorPointArea	Computes a point in the interior of an areal geometry.
CInteriorPointLine	Computes a point in the interior of an linear point. Algorithm: Find an interior vertex which is closest to the centroid of the linestring. If there is no interior vertex, find the endpoint which is closest to the centroid.
CInteriorPointPoint	Computes a point in the interior of an point point. Algorithm: Find a point which is closest to the centroid of the point.
CIPointInAreaLocator	An interface for classes which determine the Location of points in a IGeometry /summary> author>Martin Davis</author>
CIPointInRing	An interface for classes which test whether a Coordinate lies inside a ring.
CLineIntersector	A LineIntersector is an algorithm that can both test whether two line segments intersect and compute the intersection point(s) if they do
CMCPointInRing	Implements IPointInRing using a MonotoneChains and a BinTree index to increase performance.
CMinimumBoundingCircle	Computes the Minimum Bounding Circle (MBC) for the points in a IGeometry. The MBC is the smallest circle which covers all the input points (this is also sometimes known as the Smallest Enclosing Circle). This is equivalent to computing the Maximum Diameter of the input point set.
CMinimumDiameter	Computes the minimum diameter of a IGeometry.
CNonRobustLineIntersector	A non-robust version of LineIntersector.
CNotRepresentableException
CPointLocator	Computes the topological relationship (Location) of a single point to a Geometry.
CRayCrossingCounter	Counts the number of segments crossed by a horizontal ray extending to the right from a given point, in an incremental fashion
CRectangleLineIntersector	Computes whether a rectangle intersects line segments.
CRobustDeterminant	Implements an algorithm to compute the sign of a 2x2 determinant for double precision values robustly. It is a direct translation of code developed by Olivier Devillers
CRobustLineIntersector	A robust version of LineIntersector.
CSimplePointInAreaLocator	Computes the location of points relative to a IPolygonal IGeometry, using a simple O(n) algorithm. This algorithm is suitable for use in cases where only one or a few points will be tested against a given area.
CSimplePointInRing	Tests whether a Coordinate lies inside a ring, using a linear-time algorithm.
CSIRtreePointInRing	Implements PointInRing using a SIRtree index to increase performance.
►NCoordinateSystems
►NTransformation
►NDotSpatial
►NProjections
CDotSpatialMathTransform
►NTransformations
CGeometryTransform	Helper class for transforming Geometry objects.
CCRSBase	Base class for all ICRSObject implementing types
CICRSObject	Base Interface for CRSBase Object types.
CLinkedCRS	Defines the Linked CRS type.
CNamedCRS	Defines the Named CRS type.
►NDensify
CDensifier	Densifies a geometry by inserting extra vertices along the line segments contained in the geometry. All segments in the created densified geometry will be no longer than than the given distance tolerance.
►NDissolve
CDissolveEdgeGraph	A graph containing DissolveHalfEdges.
CDissolveHalfEdge	A HalfEdge which carries information required to support LineDissolver.
CLineDissolver	Dissolves the linear components from a collection of IGeometrys. into a set of maximal-length ILineStrings in which every unique segment appears once only. The output linestrings run between node vertices of the input, which are vertices which have either degree 1, or degree 3 or greater.
►NEdgeGraph
CEdgeGraph	A graph comprised of HalfEdges. It supports tracking the vertices in the graph via edges incident on them, to allow efficient lookup of edges and vertices.
CEdgeGraphBuilder	Builds an edge graph from geometries containing edges.
CHalfEdge	Represents a directed component of an edge in an EdgeGraph. HalfEdges link vertices whose locations are defined by Coordinates. HalfEdges start at an origin vertex, and terminate at a destination vertex. HalfEdges always occur in symmetric pairs, with the Sym method giving access to the oppositely-oriented component. HalfEdges and the methods on them form an edge algebra, which can be used to traverse and query the topology of the graph formed by the edges.
CMarkHalfEdge	A HalfEdge which supports marking edges with a boolean flag. Useful for algorithms which perform graph traversals.
►NFeatures
CAttributesTable	Stores all attributes associated with a single Geometry feature.
CFeature	Feature class /summary>
CFeatureCollection	Represents a feature collection. /summary>
CIAttributesTable
CIFeature
►NGeometries
►NImplementation
CCoordinateArraySequence	A ICoordinateSequence backed by an array of Coordinates. This is the implementation that IGeometrys use by default. Coordinates returned by ToCoordinateArray, GetCoordinate(int) and GetCoordinate(int, Coordinate) are live – modifications to them are actually changing the CoordinateSequence's underlying data. A dimension may be specified for the coordinates in the sequence, which may be 2 or 3. The actual coordinates will always have 3 ordinates, but the dimension is useful as metadata in some situations.
CCoordinateArraySequenceFactory	Creates CoordinateSequences represented as an array of Coordinates.
CDotSpatialAffineCoordinateSequence	A coordinate sequence that follows the dotspatial shape range
CDotSpatialAffineCoordinateSequenceFactory	A coordinate sequence factory class that creates DotSpatial's Shape/ShapeRange like coordinate sequences.
CPackedCoordinateSequence	A CoordinateSequence implementation based on a packed arrays. A CoordinateSequence implementation based on a packed arrays.
CPackedCoordinateSequenceFactory	Builds packed array coordinate sequences. The array data type can be either double or float, and defaults to double.
CPackedDoubleCoordinateSequence	Packed coordinate sequence implementation based on doubles.
CPackedFloatCoordinateSequence	Packed coordinate sequence implementation based on floats.
►NPrepared
CBasicPreparedGeometry	A base class for IPreparedGeometry subclasses. /summary>
CLineIntersectionAdder	Computes the intersections between two line segments in ISegmentStrings and adds them to each string.
CLineNode
CLineTopology
CPreparedGeometryFactory	A factory for creating IPreparedGeometrys. It chooses an appropriate implementation of PreparedGeometry based on the geoemtric type of the input geometry. /summary>
CPreparedLineString	A prepared version for ILineal geometries
CPreparedPoint	A prepared version for IPuntal geometries
CPreparedPolygon	A prepared version for IPolygonal geometries. This class supports both IPolygons and IMultiPolygons
CPreparedPolygonLineIntersection	Computes the SpatialFunction.Intersection spatial overlay function for a target PreparedLineString relative to other IGeometry classes. /summary>
►NUtilities
CAffineTransformation	Represents an affine transformation on the 2D Cartesian plane.
CAffineTransformationBuilder	Builds an AffineTransformation defined by a set of control vectors. /summary>
CComponentCoordinateExtracter	Extracts a single representative Coordinate from each connected component of a IGeometry. /summary> <version>1.9</version>
CGeometryCollectionMapper	Maps the members of a IGeometryCollection into another GeometryCollection via a defined mapping function.
CGeometryCombiner	Combines IGeometrys to produce a IGeometryCollection of the most appropriate type. /summary>
►CGeometryEditor	A class which supports creating new IGeometrys which are modifications of existing ones, maintaining the same type structure.
CCoordinateOperation	A GeometryEditorOperation which edits the coordinate list of a Geometry. Operates on Geometry subclasses which contains a single coordinate list.
CCoordinateSequenceOperation	A IGeometryEditorOperation which edits the ICoordinateSequence of a IGeometry. Operates on Geometry subclasses which contains a single coordinate list.
CIGeometryEditorOperation	A interface which specifies an edit operation for Geometries.
CNoOpGeometryOperation	A GeometryEditorOperation which does not modify the input geometry. This can be used for simple changes of IGeometryFactory (including PrecisionModel and SRID).
CGeometryExtracter< T >	Extracts the components of type T from a IGeometry. /summary>
►CGeometryMapper	Methods to map various collections of IGeometrys via defined mapping functions.
CIMapOp	An interface for geometry functions used for mapping.
CGeometryTransformer	A framework for processes which transform an input Geometry into an output IGeometry, possibly changing its structure and type(s).
CLinearComponentExtracter	Extracts all the 1-dimensional (ILineString) components from a IGeometry. For polygonal geometries, this will extract all the component ILinearRings. If desired, ILinearRings can be forced to be returned as ILineStrings.
CLineStringExtracter	Extracts all the ILineString elements from a IGeometry.
CMatrix	Implements some 2D matrix operations (in particular, solving systems of linear equations).
CNoninvertibleTransformationException	Indicates that an AffineTransformation is non-invertible. /summary> author>Martin Davis</author>
CPointExtracter	Extracts all the 0-dimensional (Point) components from a Geometry.
CPolygonExtracter	Extracts all the IPolygon elements from a IGeometry.
CShortCircuitedGeometryVisitor	A visitor to IGeometry elements which componets, which allows short-circuiting when a defined condition holds.
CSineStarFactory	Creates geometries which are shaped like multi-armed stars with each arm shaped like a sine wave. These kinds of geometries are useful as a more complex geometry for testing algorithms. /summary> <author> Martin Davis </author>
CCoordinateList	A list of Coordinates, which may be set to prevent repeated coordinates from occuring in the list.
CCoordinateSequenceComparator	Compares two ICoordinateSequences.
CDefaultCoordinateSequence	The CoordinateSequence implementation that Geometries use by default. In this implementation, Coordinates returned by ToArray and GetCoordinates are live – parties that change them are actually changing the DefaultCoordinateSequence's underlying data.
CDefaultCoordinateSequenceFactory	Creates CoordinateSequences internally represented as an array of x's and an array of y's.
CGeometry	A representation of a planar, linear vector geometry.
CGeometryCollection	Basic implementation of GeometryCollection.
CGeometryCollectionEnumerator	Iterates over all Geometry's in a GeometryCollection. Implements a pre-order depth-first traversal of the GeometryCollection (which may be nested). The original GeometryCollection is returned as well (as the first object), as are all sub-collections. It is simple to ignore the GeometryCollection objects if they are not needed.
CGeometryComponentFilter	An IGeometryComponentFilter implementation that applies filtering with the provided FilterMethod
CGeometryFactory	Supplies a set of utility methods for building Geometry objects from lists of Coordinates.
CLinearRing	Models an OGC SFS LinearRing.
CLineSegment	Represents a line segment defined by two Coordinates. Provides methods to compute various geometric properties and relationships of line segments. This class is designed to be easily mutable (to the extent of having its contained points public). This supports a common pattern of reusing a single LineSegment object as a way of computing segment properties on the segments defined by arrays or lists of Coordinates.
CLineString	Models an OGC-style
CMultiLineString	Basic implementation of MultiLineString.
CMultiPoint	Models a collection of Points.
CMultiPolygon	Basic implementation of MultiPolygon.
COctagonalEnvelope	A Bounding Container which is in the shape of an octagon.
COgcCompliantGeometryFactory	OGC compliant geometry factory
CPoint	Represents a single point. A Point is topologically valid if and only if: The coordinate which defines it if any) is a valid coordinate (i.e. does not have an NaN X- or Y-ordinate
CPolygon	Represents a polygon with linear edges, which may include holes. The outer boundary (shell) and inner boundaries (holes) of the polygon are represented by LinearRings. The boundary rings of the polygon may have any orientation. Polygons are closed, simple geometries by definition. The polygon model conforms to the assertions specified in the OpenGIS Simple Features Specification for SQL. A Polygon is topologically valid if and only if: the coordinates which define it are valid coordinates the linear rings for the shell and holes are valid (i.e. are closed and do not self-intersect) holes touch the shell or another hole at at most one point (which implies that the rings of the shell and holes must not cross) the interior of the polygon is connected, or equivalently no sequence of touching holes makes the interior of the polygon disconnected (i.e. effectively split the polygon into two pieces).
CPrecisionModel	Specifies the precision model of the Coordinates in a Geometry. In other words, specifies the grid of allowable points for all Geometrys.
CTopologyException	Indicates an invalid or inconsistent topological situation encountered during processing
CTriangle	Represents a planar triangle, and provides methods for calculating various properties of triangles.
►NGeometriesGraph
►NIndex
CEdgeSetIntersector	An EdgeSetIntersector computes all the intersections between the edges in the set. It adds the computed intersections to each edge they are found on. It may be used in two scenarios: determining the internal intersections between a single set of edges determining the mutual intersections between two different sets of edges It uses a SegmentIntersector to compute the intersections between segments and to record statistics about what kinds of intersections were found.
CMonotoneChain
CMonotoneChainEdge	MonotoneChains are a way of partitioning the segments of an edge to allow for fast searching of intersections. They have the following properties: the segments within a monotone chain will never intersect each other, and the envelope of any contiguous subset of the segments in a monotone chain is simply the envelope of the endpoints of the subset. Property 1 means that there is no need to test pairs of segments from within the same monotone chain for intersection. Property 2 allows binary search to be used to find the intersection points of two monotone chains. For many types of real-world data, these properties eliminate a large number of segment comparisons, producing substantial speed gains.
CMonotoneChainIndexer	MonotoneChains are a way of partitioning the segments of an edge to allow for fast searching of intersections
CSegmentIntersector	Computes the intersection of line segments, and adds the intersection to the edges containing the segments.
CSimpleEdgeSetIntersector	Finds all intersections in one or two sets of edges, using the straightforward method of comparing all segments. This algorithm is too slow for production use, but is useful for testing purposes.
CSimpleMCSweepLineIntersector	Finds all intersections in one or two sets of edges, using an x-axis sweepline algorithm in conjunction with Monotone Chains. While still O(n^2) in the worst case, this algorithm drastically improves the average-case time. The use of MonotoneChains as the items in the index seems to offer an improvement in performance over a sweep-line alone.
CSimpleSweepLineIntersector	Finds all intersections in one or two sets of edges, using a simple x-axis sweepline algorithm. While still O(n^2) in the worst case, this algorithm drastically improves the average-case time.
CSweepLineEvent
CSweepLineSegment
CDepth	A Depth object records the topological depth of the sides of an Edge for up to two Geometries.
CDirectedEdge
CDirectedEdgeStar	A DirectedEdgeStar is an ordered list of outgoing DirectedEdges around a node. It supports labelling the edges as well as linking the edges to form both MaximalEdgeRings and MinimalEdgeRings.
CEdge
CEdgeEnd	Models the end of an edge incident on a node.
CEdgeEndStar	A EdgeEndStar is an ordered list of EdgeEnds around a node. They are maintained in CCW order (starting with the positive x-axis) around the node for efficient lookup and topology building.
CEdgeIntersection	An EdgeIntersection represents a point on an edge which intersects with another edge. The intersection may either be a single point, or a line segment (in which case this point is the start of the line segment) The label attached to this intersection point applies to the edge from this point forwards, until the next intersection or the end of the edge. The intersection point must be precise.
CEdgeIntersectionList	A list of edge intersections along an Edge.
CEdgeList	A EdgeList is a list of Edges. It supports locating edges that are pointwise equals to a target edge.
CEdgeNodingValidator	Validates that a collection of Edge is correctly noded. Throws an appropriate exception if an noding error is found.
CEdgeRing
CGeometryGraph	A GeometryGraph is a graph that models a given Geometry.
CGraphComponent	A GraphComponent is the parent class for the objects' that form a graph. Each GraphComponent can carry a Label.
CLabel	A Label indicates the topological relationship of a component of a topology graph to a given Geometry. This class supports labels for relationships to two Geometrys, which is sufficient for algorithms for binary operations. Topology graphs support the concept of labeling nodes and edges in the graph. The label of a node or edge specifies its topological relationship to one or more geometries. (In fact, since NTS operations have only two arguments labels are required for only two geometries). A label for a node or edge has one or two elements, depending on whether the node or edge occurs in one or both of the input Geometrys. Elements contain attributes which categorize the topological location of the node or edge relative to the parent Geometry; that is, whether the node or edge is in the interior, boundary or exterior of the Geometry. Attributes have a value from the set {Interior, Boundary, Exterior}. In a node each element has a single attribute On. For an edge each element has a triplet of attributes Left, On, Right. It is up to the client code to associate the 0 and 1 TopologyLocations with specific geometries.
CNode
CNodeFactory
CNodeMap	A map of nodes, indexed by the coordinate of the node.
CPlanarGraph	The computation of the IntersectionMatrix relies on the use of a structure called a "topology graph". The topology graph contains nodes and edges corresponding to the nodes and line segments of a Geometry. Each node and edge in the graph is labeled with its topological location relative to the source point. Note that there is no requirement that points of self-intersection be a vertex. Thus to obtain a correct topology graph, Geometrys must be self-noded before constructing their graphs. Two fundamental operations are supported by topology graphs: Computing the intersections between all the edges and nodes of a single graph Computing the intersections between the edges and nodes of two different graphs
CPosition	A Position indicates the position of a Location relative to a graph component (Node, Edge, or Area).
CQuadrantOp	Utility functions for working with quadrants, which are numbered as follows:
CTopologyLocation	A TopologyLocation is the labelling of a GraphComponent's topological relationship to a single Geometry.
►NIndex
►NBintree
CBinTree
CBintree< T >	An BinTree (or "Binary Interval Tree") is a 1-dimensional version of a quadtree. It indexes 1-dimensional intervals (which may be the projection of 2-D objects on an axis). It supports range searching (where the range may be a single point).
CInterval	Represents an (1-dimensional) closed interval on the Real number line.
CKey	A Key is a unique identifier for a node in a tree. It contains a lower-left point and a level number. The level number is the power of two for the size of the node envelope.
CNode< T >	A node of a Bintree.
CNodeBase< T >	The base class for nodes in a Bintree.
CRoot< T >	The root node of a single Bintree. It is centred at the origin, and does not have a defined extent.
►NChain
CMonotoneChain	MonotoneChains are a way of partitioning the segments of a linestring to allow for fast searching of intersections.
CMonotoneChainBuilder	Constructs MonotoneChains for sequences of Coordinates.
CMonotoneChainOverlapAction	The action for the internal iterator for performing overlap queries on a MonotoneChain.
CMonotoneChainSelectAction	The action for the internal iterator for performing envelope select queries on a MonotoneChain.
►NIntervalRTree
CIntervalRTreeBranchNode< T >
CIntervalRTreeLeafNode< T >
►CIntervalRTreeNode< T >
CNodeComparator
CSortedPackedIntervalRTree< T >	A static index on a set of 1-dimensional intervals, using an R-Tree packed based on the order of the interval midpoints.
►NKdTree
CKdNode< T >	A node of a NetTopologySuite.Index.KdTree.KdTree{T}, which represents one or more points in the same location.
CKdTree< T >	An implementation of a 2-D KD-Tree. KD-trees provide fast range searching on point data.
►NQuadtree
CDoubleBits	DoubleBits manipulates Double numbers by using bit manipulation and bit-field extraction. For some operations (such as determining the exponent) this is more accurate than using mathematical operations (which suffer from round-off error). The algorithms and constants in this class apply only to IEEE-754 double-precision floating point format.
CIntervalSize	Provides a test for whether an interval is so small it should be considered as zero for the purposes of inserting it into a binary tree. The reason this check is necessary is that round-off error can cause the algorithm used to subdivide an interval to fail, by computing a midpoint value which does not lie strictly between the endpoints.
CKey	A Key is a unique identifier for a node in a quadtree. It contains a lower-left point and a level number. The level number is the power of two for the size of the node envelope.
CNode< T >	Represents a node of a Quadtree. Nodes contain items which have a spatial extent corresponding to the node's position in the quadtree.
CNodeBase< T >	The base class for nodes in a Quadtree.
CQuadtree< T >	A Quadtree is a spatial index structure for efficient range querying of items bounded by 2D rectangles. IGeometrys can be indexed by using their Envelopes. Any type of object can also be indexed, as long as it has an extent that can be represented by an Envelope. This Quadtree index provides a primary filter for range rectangle queries. The various query methods return a list of all items which may intersect the query rectangle. Note that it may thus return items which do not in fact intersect the query rectangle. A secondary filter is required to test for actual intersection between the query rectangle and the envelope of each candidate item. The secondary filter may be performed explicitly, or it may be provided implicitly by subsequent operations executed on the items (for instance, if the index query is followed by computing a spatial predicate between the query geometry and tree items, the envelope intersection check is performed automatically. This implementation does not require specifying the extent of the inserted items beforehand. It will automatically expand to accomodate any extent of dataset. This data structure is also known as an MX-CIF quadtree following the terminology usage of Samet and others.
CRoot< T >	QuadRoot is the root of a single Quadtree. It is centred at the origin, and does not have a defined extent.
►NStrtree
CAbstractNode< T, TItem >	A node of an AbstractSTRtree{T, TItem}. A node is one of: empty an interior node containing child AbstractNode{T, TItem}s a leaf node containing data items (ItemBoundable{T, TItem}s). A node stores the bounds of its children, and its level within the index tree.
►CAbstractSTRtree< T, TItem >	Base class for STRtree and SIRtree. STR-packed R-trees are described in: P. Rigaux, Michel Scholl and Agnes Voisard. Spatial Databases With Application To GIS. Morgan Kaufmann, San Francisco, 2002
CIIntersectsOp
CGeometryItemDistance	An IItemDistance{Envelope, IGeometry} function for items which are IGeometry using the IGeometry.Distance(IGeometry) method.
CIBoundable	A spatial object in an AbstractSTRtree.
CIItemDistance< T, TItem >	A function method which computes the distance between two IBoundable{T, TItem}s in an STRtree{TItem}. Used for Nearest Neighbour searches.
CInterval	A contiguous portion of 1D-space. Used internally by SIRtree.
CItemBoundable< T, TItem >	Boundable wrapper for a non-Boundable spatial object. Used internally by AbstractSTRtree.
CSIRtree< TItem >	One-dimensional version of an STR-packed R-tree. SIR stands for "Sort-Interval-Recursive". STR-packed R-trees are described in: P. Rigaux, Michel Scholl and Agnes Voisard. Spatial Databases With Application To GIS. Morgan Kaufmann, San Francisco, 2002.
CSTRtree< TItem >	A query-only R-tree created using the Sort-Tile-Recursive (STR) algorithm. For two-dimensional spatial data. The STR packed R-tree is simple to implement and maximizes space utilization; that is, as many leaves as possible are filled to capacity. Overlap between nodes is far less than in a basic R-tree. However, once the tree has been built (explicitly or on the first call to #query), items may not be added or removed. Described in: P. Rigaux, Michel Scholl and Agnes Voisard. Spatial Databases With Application To GIS. Morgan Kaufmann, San Francisco, 2002.
►NSweepline
CISweepLineOverlapAction
CSweepLineEvent
CSweepLineIndex	A sweepline implements a sorted index on a set of intervals. It is used to compute all overlaps between the interval in the index.
CSweepLineInterval
CArrayListVisitor
CArrayListVisitor< T >
CIIndexVisitor	A visitor for nodes and items in an index.
CIItemVisitor< T >	A visitor for items in an index.
CISpatialIndex	The basic insertion and query operations supported by classes implementing spatial index algorithms. A spatial index typically provides a primary filter for range rectangle queries. A secondary filter is required to test for exact intersection. Of course, this secondary filter may consist of other tests besides intersection, such as testing other kinds of spatial relationships.
CISpatialIndex< T >
►NIO
►NConverters
CArcsConverter
CAttributesTableConverter	Converts IAttributesTable object to its JSON representation.
CCoordinateConverter
CDataConverter
CEnvelopeConverter
CFeatureCollectionConverter	Converts FeatureCollection object to its JSON representation.
CFeatureConverter	Converts Feature object to its JSON representation.
CGeometryArrayConverter
CGeometryConverter
CICRSObjectConverter	Converts ICRSObject object to its JSON representation.
CObjectsConverter
CTopoFeatureConverter
CTopoObjectConverter
CTransformConverter
►NGeometries
CTopoObject
►NGeoTools
CStringToGeometryConverter
►NGML2
CGMLReader	Reads a GML document and creates a representation of the features based on NetTopologySuite model. Uses GML 2.1.1 Geometry.xsd schema for base for features.
CGMLWriter	Writes the GML representation of the features of NetTopologySuite model. Uses GML 2.1.1 Geometry.xsd schema for base for features
►NHandlers
CMBRInfo
CMultiLineHandler	Converts a Shapefile multi-line to a OGIS LineString/MultiLineString.
CMultiPointHandler	Converts a Shapefile point to a OGIS Polygon.
CNullShapeHandler
CPointHandler	Converts a Shapefile point to a OGIS Point.
CPolygonHandler	Converts a Shapefile point to a OGIS Polygon.
CShapeHandler	Abstract class that defines the interfaces that other 'Shape' handlers must implement.
CShapeLocationInFileInfo
►NHelpers
CITransform
CITransformer
CTransform
CTransformer
►NKML
CKMLWriter	Writes a formatted string containing the KML representation of a JTS IGeometry. The output is KML fragments which can be substituted wherever the KML IGeometry abstract element can be used.
►NSdo
►CSdoGeometry
CElemArrayFactory
COrdinatesArrayFactory
CSdoPoint
►NShapeFile
►NExtended
►NEntities
CIShapefileFeature
CDbaseReader
CShapeDataReader
CShapeReader
►NTests
►NGeoJSON
CAttributesTableConverterTest	This is a test class for AttributesTableConverterTest and is intended to contain all AttributesTableConverterTest Unit Tests /summary>
CFeatureCollectionTest	This is a test class for FeatureCollectionTest and is intended to contain all FeatureCollectionTest Unit Tests /summary>
CFeatureConverterTest	This is a test class for FeatureConverterTest and is intended to contain all FeatureConverterTest Unit Tests /summary>
CGeoJsonFixture
CGeoJsonReaderTest	This is a test class for GeoJsonReaderTest and is intended to contain all GeoJsonReaderTest Unit Tests /summary>
CGeoJsonSerializerTest	This is a test class for GeoJsonSerializerTest and is intended to contain all GeoJsonSerializerTest Unit Tests /summary>
CGeoJsonWriterTest	This is a test class for GeoJsonWriterTest and is intended to contain all GeoJsonWriterTest Unit Tests /summary>
CIssue148
CIssue16Fixture	see: https://github.com/NetTopologySuite/NetTopologySuite/issues/16
CLinkedCRSTest	This is a test class for LinkedCRSTest and is intended to contain all LinkedCRSTest Unit Tests /summary>
CNamedCRSTest	This is a test class for NamedCRSTest and is intended to contain all NamedCRSTest Unit Tests /summary>
CTest
►NShapeFile
►NExtended
CDbaseReaderTests	Summary description for DbfFileReaderTests
CShapeDataReaderTests
CShapeReaderTests
CTempFileWriter
CAbstractIOFixture
CIssues
CPostgisFixture
CRandomGeometryHelper
CSpatiaLiteFixture
CSpatiaLiteFixture3D
CSpatiaLiteFixture3DCompressed
CSpatiaLiteFixtureCompressed
CSqlGeographyFixture
CSqlGeometryFixture
CSqlServer2008Fixture
►NTopoJSON
►NFixtures
CTopoJsonReaderFixture
CTopoJsonWriterFixture
►NUdtBase
COracleArrayTypeFactoryBase< T >
COracleCustomTypeBase< T >
CBEBinaryReader	Extends the BinaryReader class to allow reading values in the BigEndian format.
CBEBinaryWriter	Extends the BinaryWriter class to allow writing values in the BigEndian format.
CBigEndianBinaryReader	Extends the System.IO.BinaryReader class to allow reading of integers and doubles in the Big Endian format.
CBigEndianBinaryWriter	Extends the BinaryWriter class to allow the writing of integers and double values in the Big Endian format.
CDbaseFieldDescriptor	Class for holding the information assicated with a dbase field.
CDbaseFileHeader	Class for holding the information assicated with a dbase header.
CDbaseFileReader	Class that allows records in a dbase file to be enumerated.
CDbaseFileWriter	This class aids in the writing of Dbase IV files.
CGaiaGeoReader
CGaiaGeoWriter
CGDBReader	Read features stored as ESRI GeoDatabase binary format in a SqlServer database, and converts these features to IGeometry format.
CGDBWriter	Writes features as ESRI GeoDatabase binary format in a SqlServer database, and converts this features to <coordinate>Geometry</coordinate> format.
CGeoJsonReader	Represents a GeoJSON Reader allowing for deserialization of various GeoJSON elements or any object containing GeoJSON elements.
CGeoJsonSerializer	Json Serializer with support for GeoJson object structure.
CGeoJsonWriter	Represents a GeoJSON Writer allowing for serialization of various GeoJSON elements or any object containing GeoJSON elements.
CMsSql2008GeographyReader
CMsSql2008GeographyWriter
CMsSql2008GeometryReader
CMsSql2008GeometryWriter
CMsSqlSpatialReader
CMsSqlSpatialWriter
COracleGeometryReader
COracleGeometryWriter
CParseException	Thrown by a WKTReader when a parsing problem occurs.
CPostGis2GeometryHeader
CPostGis2Reader
CPostGis2Writer
CPostGisReader	Converts a PostGIS binary data to a Geometry.
CPostGisWriter	Writes a PostGIS binary representation of a Geometry.
CShapefile	This class is used to read and write ESRI Shapefiles.
CShapefileDataReader	Creates a IDataReader that can be used to enumerate through an ESRI shape file.
CShapefileDataWriter	A simple test class for write a complete (shp, shx and dbf) shapefile structure.
CShapefileException	The exception that is thrown when a non-fatal application error occurs related to Topology functionality.
CShapefileHeader	Class that represents a shape file header record.
CShapefileReader	This class represnts an ESRI Shapefile.
CShapefileWriter	This class writes ESRI Shapefiles.
CShapeReader	Contains methods for reading a single Geometry in binary ESRI shapefile format.
CShapeWriter	Contains methods for writing a single Geometry in binary ESRI shapefile format.
CTopoJsonReader	Represents a TopoJSON Reader, used to deserialize TopoJSON elements
CTopoJsonSerializer	Json Serializer with support for TopoJSON object structure. For more information about TopoJSON format, see: https://github.com/mbostock/topojson/wiki/Introduction
CTopoJsonWriter	Represents a TopoJSON Writer, uesd to serialize TopoJSON elements.
CWKBHexFileReader	Reads a sequence of Geometrys in WKBHex format from a text file. Each WKBHex geometry must be on a single line The geometries in the file may be separated by any amount of whitespace and newlines.
CWKBReader	Converts a Well-Known Binary byte data to a Geometry.
CWKBWriter	Writes a Well-Known Binary byte data representation of a Geometry.
CWKTFileReader	Reads a sequence of IGeometrys in WKT format from a text file. /summary>
CWKTReader	Converts a Well-Known Text string to a Geometry
CWktStreamTokenizer	Reads a stream of Well Known Text (wkt) string and returns a stream of tokens.
CWKTWriter	Outputs the textual representation of a Geometry. The WKTWriter outputs coordinates rounded to the precision model. No more than the maximum number of necessary decimal places will be output. The Well-known Text format is defined in the OpenGIS Simple Features Specification for SQL. A non-standard "LINEARRING" tag is used for LinearRings. The WKT spec does not define a special tag for LinearRings. The standard tag to use is "LINESTRING".
►NLinearReferencing
CExtractLineByLocation	Extracts the subline of a linear Geometry between two LinearLocations on the line.
CLengthIndexedLine	Supports linear referencing along a linear Geometry using the length along the line as the index. Negative length values are taken as measured in the reverse direction from the end of the geometry. Out-of-range index values are handled by clamping them to the valid range of values. Non-simple lines (i.e. which loop back to cross or touch themselves) are supported.
CLengthIndexOfPoint
CLengthLocationMap	Computes the LinearLocation for a given length along a linear Geometry Negative lengths are measured in reverse from end of the linear geometry. Out-of-range values are clamped.
CLinearGeometryBuilder	Builds a linear geometry (LineString or MultiLineString) incrementally (point-by-point).
CLinearIterator	An iterator over the components and coordinates of a linear geometry (LineStrings and MultiLineStrings.
CLinearLocation	Represents a location along a ILineString or IMultiLineString. The referenced geometry is not maintained within this location, but must be provided for operations which require it. Various methods are provided to manipulate the location value and query the geometry it references.
CLocationIndexedLine	Supports linear referencing along a linear IGeometry using LinearLocations as the index.
CLocationIndexOfLine	Determines the location of a subline along a linear Geometry. The location is reported as a pair of LinearLocations. NOTE: Currently this algorithm is not guaranteed to return the correct substring in some situations where an endpoint of the test line occurs more than once in the input line. (However, the common case of a ring is always handled correctly).
CLocationIndexOfPoint	Computes the LinearLocation of the point on a linear Geometrynearest a given Coordinate. The nearest point is not necessarily unique; this class always computes the nearest point closest to the start of the geometry.
►NMathematics
CDD	Implements extended-precision floating-point numbers which maintain 106 bits (approximately 30 decimal digits) of precision. A DoubleDouble uses a representation containing two double-precision values. A number x is represented as a pair of doubles, x.hi and x.lo, such that the number represented by x is x.hi + x.lo, where
CMathUtil	Various utility functions for mathematical and numerical operations.
CMatrix	Implements some 2D matrix operations (in particular, solving systems of linear equations).
CPlane3D	Models a plane in 3-dimensional Cartesian space.
CVector2D	A 2-dimensional mathematical vector represented by double-precision X and Y components.
CVector3D	Represents a vector in 3-dimensional Cartesian space.
►NNoding
►NSnapround
CGeometryNoder	Nodes the linework in a list of IGeometrys using Snap-Rounding to a given IPrecisionModel
CHotPixel	Implements a "hot pixel" as used in the Snap Rounding algorithm. A hot pixel contains the interior of the tolerance square and the boundary minus the top and right segments. The hot pixel operations are all computed in the integer domain to avoid rounding problems.
►CMCIndexPointSnapper	"Snaps" all ISegmentStrings in a ISpatialIndex containing MonotoneChains to a given HotPixel.
CHotPixelSnapAction
CMCIndexSnapRounder	Uses Snap Rounding to compute a rounded, fully noded arrangement from a set of ISegmentStrings. Implements the Snap Rounding technique described in papers by Hobby, Guibas and Marimont, and Goodrich et al. Snap Rounding assumes that all vertices lie on a uniform grid; hence the precision model of the input must be fixed precision, and all the input vertices must be rounded to that precision
CSimpleSnapRounder	Uses Snap Rounding to compute a rounded, fully noded arrangement from a set of ISegmentStrings. Implements the Snap Rounding technique described in the papers by Hobby, Guibas & Marimont, and Goodrich et al. Snap Rounding assumes that all vertices lie on a uniform grid; hence the precision model of the input must be fixed precision, and all the input vertices must be rounded to that precision
CBasicSegmentString	Represents a list of contiguous line segments, and supports noding the segments. The line segments are represented by an array of Coordinates. Intended to optimize the noding of contiguous segments by reducing the number of allocated objects. SegmentStrings can carry a context object, which is useful for preserving topological or parentage information. All noded substrings are initialized with the same context object. /summary>
CFastNodingValidator	Validates that a collection of ISegmentStrings is correctly noded. Indexing is used to improve performance. /summary>
CFastSegmentSetIntersectionFinder	Finds if two sets of ISegmentStrings intersect.
CINodableSegmentString	An interface for classes which support adding nodes to a segment string. /summary>
CINoder	Computes all intersections between segments in a set of ISegmentStrings. Intersections found are represented as SegmentNodes and added to the ISegmentStrings in which they occur. As a final step in the noding a new set of segment strings split at the nodes may be returned.
CInteriorIntersectionFinder	/summary>
CInteriorIntersectionFinderAdder	Finds interior intersections between line segments in NodedSegmentStrings, and adds them as nodes using NodedSegmentString.AddIntersection(NetTopologySuite.Algorithm.LineIntersector,int,int,int). This class is used primarily for Snap-Rounding. For general-purpose noding, use IntersectionAdder.
CIntersectionAdder	Computes the possible intersections between two line segments in ISegmentStrings and adds them to each string using NodedSegmentString.AddIntersection(NetTopologySuite.Algorithm.LineIntersector,int,int,int).
CIntersectionFinderAdder	Finds interior intersections between line segments in NodedSegmentStrings, and adds them as nodes using NodedSegmentString.AddIntersection(NetTopologySuite.Algorithm.LineIntersector,int,int,int). This class is used primarily for Snap-Rounding. For general-purpose noding, use IntersectionAdder.
CISegmentIntersector	Processes possible intersections detected by a INoder.
CISegmentSetMutualIntersector	An intersector for the red-blue intersection problem. In this class of line arrangement problem, two disjoint sets of linestrings are intersected. Implementing classes must provide a way of supplying the base set of segment strings to test against (e.g. in the constructor, for straightforward thread-safety). In order to allow optimizing processing, the following condition is assumed to hold for each set: the only intersection between any two linestrings occurs at their endpoints. Implementations can take advantage of this fact to optimize processing (i.e by avoiding testing for intersections between linestrings belonging to the same set). /summary>
CISegmentString	An interface for classes which represent a sequence of contiguous line segments. SegmentStrings can carry a context object, which is useful for preserving topological or parentage information. /summary>
CIteratedNoder	Nodes a set of ISegmentStrings completely. The set of ISegmentStrings is fully noded; i.e. noding is repeated until no further intersections are detected
►CMCIndexNoder	Nodes a set of ISegmentStrings using a index based on MonotoneChains and a ISpatialIndex. The ISpatialIndex used should be something that supports envelope (range) queries efficiently (such as a Quadtree" or <see cref="STRtree{MonotoneChain}" />.
CSegmentOverlapAction
►CMCIndexSegmentSetMutualIntersector	Intersects two sets of ISegmentStrings using a index based on MonotoneChains and a ISpatialIndex. Thread-safe and immutable. /summary>
CSegmentOverlapAction	Segment overlap action class
CNodedSegmentString	Represents a list of contiguous line segments, and supports noding the segments. The line segments are represented by an array of Coordinates. Intended to optimize the noding of contiguous segments by reducing the number of allocated objects. NodedSegmentStrings can carry a context object, which is useful for preserving topological or parentage information. All noded substrings are initialized with the same context object.
CNodeVertexIterator
CNodingValidator	Validates that a collection of ISegmentStrings is correctly noded. Throws an appropriate exception if an noding error is found.
COrientedCoordinateArray	Allows comparing Coordinate arrays in an orientation-independent way.
CScaledNoder	Wraps a INoder and transforms its input into the integer domain. This is intended for use with Snap-Rounding noders, which typically are only intended to work in the integer domain. Offsets can be provided to increase the number of digits of available precision
CSegmentIntersectionDetector	Detects and records an intersection between two ISegmentStrings, if one exists. Only a single intersection is recorded. /summary>
CSegmentNode	Represents an intersection point between two ISegmentStrings.
CSegmentNodeList	A list of the SegmentNodes present along a noded ISegmentString.
CSegmentPointComparator	Implements a robust method of comparing the relative position of two points along the same segment. The coordinates are assumed to lie "near" the segment. This means that this algorithm will only return correct results if the input coordinates have the same precision and correspond to rounded values of exact coordinates lying on the segment.
►CSegmentStringDissolver	Dissolves a noded collection of ISegmentStrings to produce a set of merged linework with unique segments.
CISegmentStringMerger	A merging strategy which can be used to update the context data of ISegmentStrings which are merged during the dissolve process.
CSegmentStringUtil	Utility methods for processing ISegmentStrings /summary> <author>Martin Davis</author>
CSimpleNoder	Nodes a set of ISegmentStrings by performing a brute-force comparison of every segment to every other one. This has n^2 performance, so is too slow for use on large numbers of segments.
CSimpleSegmentSetMutualIntersector	Intersects two sets of ISegmentStrings using brute-force comparison.
CSinglePassNoder	Base class for INoders which make a single pass to find intersections. This allows using a custom ISegmentIntersector (which for instance may simply identify intersections, rather than insert them).
►NOperation
►NBuffer
►NValidate
►CBufferCurveMaximumDistanceFinder	Finds the approximate maximum distance from a buffer curve to the originating geometry. /summary>
CMaxMidpointDistanceFilter
CMaxPointDistanceFilter
CBufferDistanceValidator	Validates that a given buffer curve lies an appropriate distance from the input generating it.
CBufferResultValidator	Validates that the result of a buffer operation is geometrically correct, within a computed tolerance.
CPointPairDistance	Contains a pair of points and the distance between them. Provides methods to update with a new point pair with either maximum or minimum distance.
CBufferInputLineSimplifier	Simplifies a buffer input line to remove concavities with shallow depth. /summary>
CBufferOp	Computes the buffer of a geometry, for both positive and negative buffer distances.
CBufferParameters	A value class containing the parameters which specify how a buffer should be constructed. The parameters allow control over: Quadrant segments (accuracy of approximation for circular arcs) End Cap style Join style Mitre limit whether the buffer is single-sided
COffsetCurveBuilder	Computes the raw offset curve for a single IGeometry component (ring, line or point). A raw offset curve line is not noded - it may contain self-intersections (and usually will). The final buffer polygon is computed by forming a topological graph of all the noded raw curves and tracing outside contours. The points in the raw curve are rounded to a given IPrecisionModel.
COffsetCurveSetBuilder	Creates all the raw offset curves for a buffer of a Geometry. Raw curves need to be noded together and polygonized to form the final buffer area.
COffsetCurveVertexList	A list of the vertices in a constructed offset curve. /summary>
COldOffsetCurveBuilder	Computes the raw offset curve for a single IGeometry component (ring, line or point). /summary>
►NDistance
CConnectedElementLocationFilter	A ConnectedElementPointFilter extracts a single point from each connected element in a Geometry (e.g. a polygon, linestring or point) and returns them in a list. The elements of the list are com.vividsolutions.jts.operation.distance.GeometryLocations.
CConnectedElementPointFilter	Extracts a single point from each connected element in a Geometry (e.g. a polygon, linestring or point) and returns them in a list
CDistanceOp	Computes the distance and closest points between two Geometrys. The distance computation finds a pair of points in the input geometries which have minimum distance between them. These points may not be vertices of the geometries, but may lie in the interior of a line segment. In this case the coordinate computed is a close approximation to the exact point. The algorithms used are straightforward O(n^2) comparisons. This worst-case performance could be improved on by using Voronoi techniques.
CFacetSequence	Represents a sequence of facets (points or line segments) of a IGeometry specified by a subsequence of a ICoordinateSequence.
CGeometryLocation	Represents the location of a point on a Geometry. Maintains both the actual point location (which may not be exact, if the point is not a vertex) as well as information about the component and segment index where the point occurs. Locations inside area Geometrys will not have an associated segment index, so in this case the segment index will have the sentinel value of InsideArea.
CIndexedFacetDistance	Computes the distance between the facets (segments and vertices) of two IGeometrys using a Branch-and-Bound algorithm. The Branch-and-Bound algorithm operates over a traversal of R-trees built on the target and possibly also the query geometries
►NDistance3D
CAxisPlaneCoordinateSequence	A ICoordinateSequence wrapper which projects 3D coordinates into one of the three Cartesian axis planes, using the standard orthonormal projection (i.e. simply selecting the appropriate ordinates into the XY ordinates). The projected data is represented as 2D coordinates.
CDistance3DOp	Find two points on two IGeometrys which lie within a given distance, or else are the nearest points on the geometries (in which case this also provides the distance between the geometries). The distance computation also finds a pair of points in the input geometries which have the minimum distance between them. If a point lies in the interior of a line segment, the coordinate computed is a close approximation to the exact point. The algorithms used are straightforward O(n^2) comparisons. This worst-case performance could be improved on by using Voronoi techniques or spatial indexes.
CPlanarPolygon3D	Models a polygon lying in a plane in 3-dimensional Cartesian space. The polygon representation is supplied by a IPolygon, containing coordinates with XYZ ordinates. 3D polygons are assumed to lie in a single plane. The plane best fitting the polygon coordinates is computed and is represented by a Plane3D.
►NLinemerge
CEdgeString	A sequence of LineMergeDirectedEdges forming one of the lines that will be output by the line-merging process.
CLineMergeDirectedEdge	A com.vividsolutions.jts.planargraph.DirectedEdge of a LineMergeGraph.
CLineMergeEdge	An edge of a LineMergeGraph. The marked field indicates whether this Edge has been logically deleted from the graph.
CLineMergeGraph	A planar graph of edges that is analyzed to sew the edges together. The marked flag on com.vividsolutions.planargraph.Edges and com.vividsolutions.planargraph.Nodes indicates whether they have been logically deleted from the graph.
CLineMerger	Sews together a set of fully noded LineStrings.
CLineSequencer
►NOverlay
►NSnap
CGeometrySnapper	Snaps the vertices and segments of a IGeometry to another Geometry's vertices. A snap distance tolerance is used to control where snapping is performed. Snapping one geometry to another can improve robustness for overlay operations by eliminating nearly-coincident edges (which cause problems during noding and intersection calculation). It can also be used to eliminate artifacts such as narrow slivers, spikes and gores. Too much snapping can result in invalid topology beging created, so the number and location of snapped vertices is decided using heuristics to determine when it is safe to snap. This can result in some potential snaps being omitted, however.
CLineStringSnapper	Snaps the vertices and segments of a ILineString to a set of target snap vertices. A snap distance tolerance is used to control where snapping is performed. The implementation handles empty geometry and empty snap vertex sets.
CSnapIfNeededOverlayOp	Performs an overlay operation using snapping and enhanced precision to improve the robustness of the result. This class only uses snapping if an error is detected when running the standard JTS overlay code. Errors detected include thrown exceptions (in particular, TopologyException) and invalid overlay computations.
CSnapOverlayOp	Performs an overlay operation using snapping and enhanced precision to improve the robustness of the result. This class always uses snapping. This is less performant than the standard JTS overlay code, and may even introduce errors which were not present in the original data. For this reason, this class should only be used if the standard overlay code fails to produce a correct result.
►NValidate
CFuzzyPointLocator	Finds the most likely Location of a point relative to the polygonal components of a geometry, using a tolerance value. /summary> remarks> If a point is not clearly in the Interior or Exterior, it is considered to be on the Boundary. In other words, if the point is within the tolerance of the Boundary, it is considered to be on the Boundary; otherwise, whether it is Interior or Exterior is determined directly. /remarks> <author>Martin Davis</author>
COffsetPointGenerator	Generates points offset by a given distance from both sides of the midpoint of all segments in a IGeometry. /summary>
COverlayResultValidator	Validates that the result of an overlay operation is geometrically correct within a determined tolerance. Uses fuzzy point location to find points which are definitely in either the interior or exterior of the result geometry, and compares these results with the expected ones. /summary>
CPolygonalLineworkExtracter	Extracts the LineStrings in the boundaries of all the polygonal elements in the target IGeometry. /summary> author>Martin Davis</author>
CEdgeSetNoder	Nodes a set of edges. Takes one or more sets of edges and constructs a new set of edges consisting of all the split edges created by noding the input edges together.
CLineBuilder	Forms NTS LineStrings out of a the graph of DirectedEdges created by an OverlayOp.
CMaximalEdgeRing	A ring of edges which may contain nodes of degree > 2. A MaximalEdgeRing may represent two different spatial entities: a single polygon possibly containing inversions (if the ring is oriented CW) a single hole possibly containing exversions (if the ring is oriented CCW) If the MaximalEdgeRing represents a polygon, the interior of the polygon is strongly connected. These are the form of rings used to define polygons under some spatial data models. However, under the OGC SFS model, MinimalEdgeRings are required. A MaximalEdgeRing can be converted to a list of MinimalEdgeRings using the BuildMinimalRings() method.
CMinimalEdgeRing	A ring of edges with the property that no node has degree greater than 2. These are the form of rings required to represent polygons under the OGC SFS spatial data model.
COverlayNodeFactory	Creates nodes for use in the PlanarGraphs constructed during overlay operations.
COverlayOp	Computes the geometric overlay of two IGeometrys. The overlay can be used to determine any bool combination of the geometries.
CPointBuilder	Constructs Points from the nodes of an overlay graph.
CPolygonBuilder	Forms Polygons out of a graph of {DirectedEdge}s. The edges to use are marked as being in the result Area.
►NPolygonize
CEdgeRing	Represents a ring of PolygonizeDirectedEdges which form a ring of a polygon. The ring may be either an outer shell or a hole.
CPolygonizeDirectedEdge	A DirectedEdge of a PolygonizeGraph, which represents an edge of a polygon formed by the graph. May be logically deleted from the graph by setting the marked flag.
CPolygonizeEdge	An edge of a polygonization graph.
CPolygonizeGraph	Represents a planar graph of edges that can be used to compute a polygonization, and implements the algorithms to compute the EdgeRings formed by the graph. The marked flag on DirectedEdges is used to indicate that a directed edge has be logically deleted from the graph.
CPolygonizer	Polygonizes a set of IGeometrys which contain linework that represents the edges of a planar graph.
►NPredicate
CRectangleContains	Optimized implementation of spatial predicate "contains" for cases where the first Geometry is a rectangle. As a further optimization, this class can be used directly to test many geometries against a single rectangle.
CRectangleIntersects	I Implementation of the Intersects spatial predicate optimized for the case where one IGeometry is a rectangle.
CSegmentIntersectionTester	Tests if any line segments in two sets of CoordinateSequences intersect. Optimized for use when at least one input is of small size. Short-circuited to return as soon an intersection is found.
►NRelate
CEdgeEndBuilder	An EdgeEndBuilder creates EdgeEnds for all the "split edges" created by the intersections determined for an Edge. Computes the EdgeEnds which arise from a noded Edge.
CEdgeEndBundle	A collection of EdgeStubs which obey the following invariant: They originate at the same node and have the same direction. Contains all EdgeEnds which start at the same point and are parallel.
CEdgeEndBundleStar	An ordered list of EdgeEndBundles around a RelateNode. They are maintained in CCW order (starting with the positive x-axis) around the node for efficient lookup and topology building.
CRelateComputer	Computes the topological relationship between two Geometries. RelateComputer does not need to build a complete graph structure to compute the IntersectionMatrix. The relationship between the geometries can be computed by simply examining the labelling of edges incident on each node. RelateComputer does not currently support arbitrary GeometryCollections. This is because GeometryCollections can contain overlapping Polygons. In order to correct compute relate on overlapping Polygons, they would first need to be noded and merged (if not explicitly, at least implicitly).
CRelateNode	A RelateNode is a Node that maintains a list of EdgeStubs for the edges that are incident on it.
CRelateNodeFactory	Used by the NodeMap in a RelateNodeGraph to create RelateNodes.
CRelateNodeGraph	Implements the simple graph of Nodes and EdgeEnd which is all that is required to determine topological relationships between Geometries. Also supports building a topological graph of a single Geometry, to allow verification of valid topology. It is not necessary to create a fully linked PlanarGraph to determine relationships, since it is sufficient to know how the Geometries interact locally around the nodes. In fact, this is not even feasible, since it is not possible to compute exact intersection points, and hence the topology around those nodes cannot be computed robustly. The only Nodes that are created are for improper intersections; that is, nodes which occur at existing vertices of the Geometries. Proper intersections (e.g. ones which occur between the interior of line segments) have their topology determined implicitly, without creating a Node object to represent them.
CRelateOp	Implements the SFS relate() generalized spatial predicate on two IGeometrys. The class supports specifying a custom IBoundaryNodeRule to be used during the relate computation.
►NUnion
CCascadedPolygonUnion	Provides an efficient method of unioning a collection of IPolygonal geometrys. The geometries are indexed using a spatial index, and unioned recursively in index order. For geometries with a high degree of overlap, this has the effect of reducing the number of vertices early in the process, which increases speed and robustness. This algorithm is faster and more robust than the simple iterated approach of repeatedly unioning each polygon to a result geometry. The buffer(0) trick is sometimes faster, but can be less robust and can sometimes take a long time to complete. This is particularly the case where there is a high degree of overlap between the polygons. In this case, buffer(0) is forced to compute with all line segments from the outset, whereas cascading can eliminate many segments at each stage of processing. The best situation for using buffer(0) is the trivial case where there is no overlap between the input geometries. However, this case is likely rare in practice.
CPointGeometryUnion
CUnaryUnionOp	Unions a Collection of IGeometrys or a single Geometry (which may be a IGeometryCollection) together. /summary>
CUnionInteracting	Experimental code to union MultiPolygons with processing limited to the elements which actually interact. /summary>
►NValid
CConnectedInteriorTester	This class tests that the interior of an area Geometry (Polygon or MultiPolygon) is connected. An area Geometry is invalid if the interior is disconnected. This can happen if:
CConsistentAreaTester	Checks that a {GeometryGraph} representing an area (a Polygon or MultiPolygon ) is consistent with the SFS semantics for area geometries. Checks include: Testing for rings which self-intersect (both properly and at nodes). Testing for duplicate rings. If an inconsistency if found the location of the problem is recorded.
CIndexedNestedRingTester
CIsValidOp	Implements the algorithsm required to compute the Geometry.IsValid method for Geometrys. See the documentation for the various geometry types for a specification of validity.
CQuadtreeNestedRingTester	Tests whether any of a set of LinearRings are nested inside another ring in the set, using a Quadtree index to speed up the comparisons.
CRepeatedPointTester	Implements the appropriate checks for repeated points (consecutive identical coordinates) as defined in the NTS spec.
CSimpleNestedRingTester	Tests whether any of a set of LinearRings are nested inside another ring in the set, using a simple O(n^2) comparison.
►CSweeplineNestedRingTester	Tests whether any of a set of LinearRings are nested inside another ring in the set, using a SweepLineIndex index to speed up the comparisons.
COverlapAction
CTopologyValidationError	Contains information about the nature and location of a Geometry validation error.
CBoundaryOp	Computes the boundary of a IGeometry. Allows specifying the IBoundaryNodeRule to be used. This operation will always return a IGeometry of the appropriate dimension for the boundary (even if the input geometry is empty). The boundary of zero-dimensional geometries (Points) is always the empty IGeometryCollection. /summary> <author>Martin Davis</author>
CCounter	Stores an integer count, for use as a Map entry. /summary> <author>Martin Davis</author>
CGeometryGraphOperation	The base class for operations that require GeometryGraphs.
CIsSimpleOp	Tests whether a IGeometry is simple. In general, the SFS specification of simplicity follows the rule: A Geometry is simple if and only if the only self-intersections are at boundary points.
►NPlanargraph
►NAlgorithm
CConnectedSubgraphFinder	Finds all connected Subgraphs of a PlanarGraph.
CDirectedEdge	Represents a directed edge in a PlanarGraph. A DirectedEdge may or may not have a reference to a parent Edge (some applications of planar graphs may not require explicit Edge objects to be created). Usually a client using a PlanarGraph will subclass DirectedEdge to add its own application-specific data and methods.
CDirectedEdgeStar	A sorted collection of DirectedEdges which leave a Node in a PlanarGraph.
CEdge	Represents an undirected edge of a {PlanarGraph}. An undirected edge in fact simply acts as a central point of reference for two opposite DirectedEdges. Usually a client using a PlanarGraph will subclass Edge to add its own application-specific data and methods.
CGraphComponent	The base class for all graph component classes. Maintains flags of use in generic graph algorithms. Provides two flags: marked - typically this is used to indicate a state that persists for the course of the graph's lifetime. For instance, it can be used to indicate that a component has been logically deleted from the graph. visited - this is used to indicate that a component has been processed or visited by an single graph algorithm. For instance, a breadth-first traversal of the graph might use this to indicate that a node has already been traversed. The visited flag may be set and cleared many times during the lifetime of a graph.
CNode	A node in a PlanarGraph is a location where 0 or more Edges meet. A node is connected to each of its incident Edges via an outgoing DirectedEdge. Some clients using a PlanarGraph may want to subclass Node to add their own application-specific data and methods.
CNodeMap	A map of nodes, indexed by the coordinate of the node.
CPlanarGraph	Represents a directed graph which is embeddable in a planar surface. This class and the other classes in this package serve as a framework for building planar graphs for specific algorithms. This class must be subclassed to expose appropriate methods to construct the graph. This allows controlling the types of graph components ({DirectedEdge}s, Edges and Nodes) which can be added to the graph. An application which uses the graph framework will almost always provide subclasses for one or more graph components, which hold application-specific data and graph algorithms.
CSubgraph	A subgraph of a PlanarGraph. A subgraph may contain any subset of Edges from the parent graph. It will also automatically contain all DirectedEdges and Nodes associated with those edges. No new objects are created when edges are added - all associated components must already exist in the parent graph.
►NPrecision
CCommonBits	Determines the maximum number of common most-significant bits in the mantissa of one or numbers. Can be used to compute the double-precision number which is represented by the common bits. If there are no common bits, the number computed is 0.0.
CCommonBitsOp	Provides versions of Geometry spatial functions which use common bit removal to reduce the likelihood of robustness problems. In the current implementation no rounding is performed on the reshifted result point, which means that it is possible that the returned Geometry is invalid. Client classes should check the validity of the returned result themselves.
►CCommonBitsRemover	Removes common most-significant mantissa bits from one or more IGeometrys. The CommonBitsRemover "scavenges" precision which is "wasted" by a large displacement of the geometry from the origin. For example, if a small geometry is displaced from the origin by a large distance, the displacement increases the significant figures in the coordinates, but does not affect the relative topology of the geometry. Thus the geometry can be translated back to the origin without affecting its topology. In order to compute the translation without affecting the full precision of the coordinate values, the translation is performed at the bit level by removing the common leading mantissa bits. If the geometry envelope already contains the origin, the translation procedure cannot be applied. In this case, the common bits value is computed as zero. If the geometry crosses the Y axis but not the X axis (and mutatis mutandum), the common bits for Y are zero, but the common bits for X are non-zero.
CCommonCoordinateFilter
CCoordinatePrecisionReducerFilter	Reduces the precision of the Coordinates in a ICoordinateSequence to match the supplied IPrecisionModel. /summary>
CEnhancedPrecisionOp	Provides versions of Geometry spatial functions which use enhanced precision techniques to reduce the likelihood of robustness problems.
CGeometryPrecisionReducer	Reduces the precision of a IGeometry according to the supplied IPrecisionModel, ensuring that the result is topologically valid.
CMinimumClearance	Computes the Minimum Clearance of a IGeometry. The Minimum Clearance is a measure of what magnitude of perturbation of the vertices of a geometry can be tolerated before the geometry becomes topologically invalid. The smaller the Minimum Clearance distance, the less vertex pertubation the geometry can tolerate before becoming invalid.
CPrecisionReducerCoordinateOperation
CSimpleGeometryPrecisionReducer	Reduces the precision of the coordinates of a Geometry according to the supplied {PrecisionModel}, without attempting to preserve valid topology.
CSimpleMinimumClearance	Computes the minimum clearance of a geometry or set of geometries.The Minimum Clearance is a measure of what magnitude of perturbation of its vertices can be tolerated by a geometry before it becomes topologically invalid. This class uses an inefficient O(N^2) scan. It is primarily for testing purposes.
►NSamples
►NGeometries
CBasicExample	Shows basic ways of creating and operating on geometries
CConstructionExample	Examples of constructing Geometries programmatically. The Best Practice moral here is: Use the GeometryFactory to construct Geometries whenever possible. This has several advantages: Simplifies your code. Allows you to take advantage of convenience methods provided by GeometryFactory. Insulates your code from changes in the signature of JTS constructors
CCreateOrientationDistanceMesh
CExtendedCoordinate
CExtendedCoordinateExample
CExtendedCoordinateSequence	Demonstrates how to implement a CoordinateSequence for a new kind of coordinate (an ExtendedCoordinate} in this example). In this implementation, Coordinates returned by ToArray and #get are live – parties that change them are actually changing the ExtendedCoordinateSequence's underlying data.
CExtendedCoordinateSequenceFactory	Creates ExtendedCoordinateSequenceFactory internally represented as an array of ExtendedCoordinates.
CPrecisionModelExample	An example showing the results of using different precision models in computations involving geometric constructions. A simple intersection computation is carried out in three different precision models (Floating, FloatingSingle and Fixed with 0 decimal places). The input is the same in all cases (since it is precise in all three models), The output shows the effects of rounding in the single-precision and fixed-precision models.
CSimpleMethodsExample	An example showing a simple use of JTS methods for: WKT reading intersection relate WKT output The expected output from this program is: A = POLYGON ((40 100, 40 20, 120 20, 120 100, 40 100)) B = LINESTRING (20 80, 80 60, 100 140) A intersection B = LINESTRING (40 73.33333333333334, 80 60, 90 100) A relate C = 1F20F1102
►NLab
►NClean
►CHoleRemover	Removes holes which match a given predicate.
CPredicate
CInvalidHoleRemover	Removes holes which are invalid due to not being wholly covered by the parent shell.
CInvalidHoleRemoverTest
CSmallHoleRemover
CSmallHoleRemoverTest
►NLinearReferencing
CLinearReferencingExample	Examples of Linear Referencing
►NOperation
►NDistance
CClosestPointExample	Example of computing distance and closest points between geometries using the DistanceOp class.
►NLinemerge
CLineMergeExample	Example of using the LineMerger class to sew together a set of fully noded linestrings.
►NPoligonize
CPolygonizeExample	Example of using Polygonizer class to polygonize a set of fully noded linestrings.
CSplitPolygonExample
►NPrecision
CEnhancedPrecisionOpExample	Example of using {EnhancedPrecisionOp} to avoid robustness problems.
►NSimpleTests
►NAttributes
CAttributesTest
►NGeometries
CLineStringSamples
CMultiPointSamples
CPointSamples
CPolygonSamples
CSerializationSamples
CValidationSuite
►NShapeTests
CGMLTesting
CShapeRead
►NTests
CGeometryServicesTest
CBaseSamples
CProgram
►NTechnique
CExtractLinestringByMeasure
CLinestringMeasureFilter
CLineStringSelfIntersections	Shows a technique for identifying the location of self-intersections in a non-simple LineString.
CUnionUsingBuffer	Shows a technique for using a zero-width buffer to compute unions of geometrys. The advantages of this technique are: Can avoid robustness issues. Faster for large numbers of input geometries. Handles GeometryCollections as input
►NTests
►NIO
CGitIssue12Fixture	https://github.com/NetTopologySuite/NetTopologySuite/issues/12
CGitIssue4Fixture	https://github.com/NetTopologySuite/NetTopologySuite/issues/4
►NOperation
►NIO
CShapeFileDataReaderTest
CShapeFileDataWriterTest
►NLinemerge
CLineSequencerFileTest
CLineSequencerTest
►NPerformances
CPreparedGeometryFixture	see: https://groups.google.com/d/msg/nettopologysuite/Vdis_LHdH8w/x5r-lSkiL4QJ
►NVarious
►CAffineTransformBuilderUsage
CLeastSquaresTransform	Calculates Affine and Helmert transformation using Least-Squares Regression of input and output points
CBufferTest
CCascadedPolygonUnionFixture
CCoordinateArraysTest
CCoversTest
CDbfDateTest
CFormattingTest
CGeomBinOpTest_Issue14_Simplified
CGeometriesFixture
CGraphBuilder2	A class that manages shortest path computation.
CIntesectIterationTest
CIssue103Tests
CIssue156Tests
CIssue171TestFixture
CIssue172TestFixture
CIssue173Fixture
CIssue174TestFixture
CIsValidTest
CNormalizeTest
COGCTests
COracleWKBTest
CPathFinder	A class that manages shortest path computation.
CPrecision
CReverseTest
CRobustLineIntersectorTest
CSRSConversionTest
CStackExchangeFixtures
CUnionAggregateTest
CWKTTest
►NShape
►NFractal
CKochSnowflakeBuilder
CSierpinskiCarpetBuilder
►NRandom
CRandomPointsBuilder	Creates random point sets contained in a region defined by either a rectangular or a polygonal extent.
CRandomPointsInGridBuilder	Creates random point sets where the points are constrained to lie in the cells of a grid.
CGeometricShapeBuilder
►NSimplify
CDouglasPeuckerLineSimplifier	Simplifies a line (sequence of points) using the standard Douglas-Peucker algorithm.
CDouglasPeuckerSimplifier	Simplifies a Geometry using the Douglas-Peucker algorithm.
CLineSegmentIndex	An index of LineSegments.
CLineSegmentVisitor	ItemVisitor subclass to reduce volume of query results.
CTaggedLineSegment	A LineSegment which is tagged with its location in a Geometry. Used to index the segments in a point and recover the segment locations from the index.
CTaggedLinesSimplifier	Simplifies a collection of TaggedLineStrings, preserving topology (in the sense that no new intersections are introduced). This class is essentially just a container for the common indexes used by TaggedLineStringSimplifier.
CTaggedLineString	Represents a ILineString which can be modified to a simplified shape. This class provides an attribute which specifies the minimum allowable length for the modified result.
CTaggedLineStringSimplifier	Simplifies a TaggedLineString, preserving topology (in the sense that no new intersections are introduced). Uses the recursive Douglas-Peucker algorithm.
CTopologyPreservingSimplifier	Simplifies a point and ensures that the result is a valid point having the same dimension and number of components as the input, and with the components having the same topological relationship. If the input is a polygonal geometry (IPolygon or IMultiPolygon): The result has the same number of shells and holes as the input, with the same topological structure The result rings touch at no more than the number of touching points in the input (although they may touch at fewer points). The key implication of this statement is that if the input is topologically valid, so is the simplified output. For linear geometries, if the input does not contain any intersecting line segments, this property will be preserved in the output. For all geometry types, the result will contain enough vertices to ensure validity. For polygons and closed linear geometries, the result will have at least 4 vertices; for open linestrings the result will have at least 2 vertices. All geometry types are handled. Empty and point geometries are returned unchanged. Empty geometry components are deleted. The simplification uses a maximum-distance difference algorithm similar to the Douglas-Peucker algorithm.
CVWLineSimplifier	Simplifies a linestring (sequence of points) using the Visvalingam-Whyatt algorithm. The Visvalingam-Whyatt algorithm simplifies geometry by removing vertices while trying to minimize the area changed.
CVWSimplifier	Simplifies a IGeometry using the Visvalingam-Whyatt area-based algorithm. Ensures that any polygonal geometries returned are valid. Simple lines are not guaranteed to remain simple after simplification. All geometry types are handled. Empty and point geometries are returned unchanged. Empty geometry components are deleted. The simplification tolerance is specified as a distance. This is converted to an area tolerance by squaring it
►NTests
►NIO
CGmlTest
CPostGisTest	Ported from PostGIS: http://svn.refractions.net/postgis/trunk/java/jdbc/src/examples/TestParser.java
CShapeFileEncodingTest
CShapeFileInvalidHeaderTest
►NNUnit
►NAlgorithm
►NDistance
CDiscreteHausdorffDistanceTest
CAbstractPointInRingTest
CAngleTest
CCGAlgorithmsTest
CComputeOrientationTest
CConvexHullTest
CIndexedPointInAreaStressTest
CInteriorPointTest
CIsCCWTest
CLocatePointInRingTest
CMCPointInRingTest
CMinimumBoundingCircleTest
CMinimumDiameterTest
CNonRobustLineIntersectorTest
COrientationIndexFailureTest	Tests failure cases of CGAlgorithms.computeOrientation
COrientationIndexTest
CPerturbedGridPolygonBuilder	Creates a perturbed, buffered grid and tests a set of points against using two PointInArea classes. /summary> <author>mbdavis</author>
CPointInAreaStressTester
CPointInRingTest
CPointLocatorTest
CRayCrossingCounterTest
CRectangleLineIntersectorTest
CRobustLineIntersectionTest
CRobustLineIntersectorTest
CShewchuksDeterminant
►NCoordinateSystems
►NTransformations
CGeometryTransformTest
►NDissolve
CLineDissolverTest
►NEdgeGraph
CEdgeGraphTest
►NGeometries
►NImplementation
CBasicCoordinateSequenceTest
CCoordinateArraySequenceTest
CCoordinateSequenceReversedTest
CCoordinateSequenceTestBase	General test cases for CoordinateSequences. Subclasses can set the factory to test different kinds of CoordinateSequences.
CPackedCoordinateSequenceTest
►NPrepared
CPreparedPolygonIntersectsStressTest	Stress tests PreparedPolygon.Intersects(IGeometry) to confirm it finds intersections correctly. /summary> <author>Martin Davis</author>
CPreparedPolygonPredicateStressTest	Stress tests PreparedPolygon for correctness of PreparedPolygon.Contains(IGeometry) and PreparedPolygon.Intersects(IGeometry) operation.
CStressTestHarness
►NUtility
CAffineTransformationBuilderTest	Tests AffineTransformationBuilder
CAffineTransformationTest
CAreaLengthTest
CBidirectionalComparatorTest
CCoordinateArraysTest
CCoordinateBufferTest
CCoordinateSequencesTest
CCoordinateTest
CEnvelopeTest
CGeometryCollectionEnumeratorTest
CGeometryCollectionImplTest
CGeometryFactoryTest
CGeometryImplTest
CGeometryTestFactory
CIntersectionMatrixTest
CIntervalTest
CIsRectangleTest	Test named predicate short-circuits
CLineSegmentTest
CLineStringImplTest
CMultiPointImplTest
CNormalizeTest
CPointImplTest
CPrecisionModelTest
CPredicateShortCircuitTest
CRectanglePredicateSyntheticTest
CRectanglePredicateTest
CSegmentDensifier
CTriangleTest
►NIndex
►NKdTree
CKdTreeTest
CDoubleBitsTest
CQuadtreeTest
CSIRtreeTest
CSpatialIndexTest
CSpatialIndexTester
►CSTRtreeDemo
CTestTree
CSTRtreeTest
►NIO
►NGML2
CGMLReaderTest
►NKML
CKMLWriterTest
CAverageZFilter
CSerializabilityTest
CWKBReaderTest	Tests for reading WKB.
CWKBTest	Tests the WKBReader and WKBWriter. Tests all geometries with both 2 and 3 dimensions and both byte orderings.
CWKTReaderExpTest	Tests the WKTReader with exponential notation.
CWKTReaderParseErrorTest	Tests the WKTReader with various errors
CWKTReaderTest	Test for WKTReader
CWKTWriterTest	Test for WKTWriter.
►NLinearReferencing
CAbstractIndexedLineTest	Base class for linear referencing class unit tests
CLengthIndexedLineTest	Tests the LengthIndexedLine class
CLinearLocationTest	Tests methods involving only LinearLocations
CLocationIndexedLineTest	Tests the LocationIndexedLine class
►NMathematics
CDDBasicTest	Tests basic arithmetic operations for DDs.
CDDComputeTest	Various tests involving computing known mathematical quantities using the basic DD arithmetic operations.
CDDIOTest	Tests I/O for DDs.
►NNoding
►NSnaparound
CSnapRoundingTest	Test Snap Rounding
CSegmentPointComparatorFullTest	Test IntersectionSegment::compareNodePosition using an exhaustive set of test cases
CSegmentPointComparatorTest	Test IntersectionSegment::compareNodePosition
►NOperation
►NBuffer
CBufferResultValidatorTest
CBufferTest
CBufferValidator
CTest
►NDistance
CDistanceTest
►NDistance3d
CDistance3DOpTest
CWithinDistance3DTest
►NLineMerge
CLineMergerTest
CLineSequencerTest	LineSequencer tests
►NOverlay
CFixedPrecisionSnappingTest
►NPolygonize
CPolygonizeTest
►NPredicate
CRectangleIntersectsPerformanceTest
►NRelate	Tests Geometry.Relate with different BoundaryNodeRules.
CContainsTest
CRelateBoundaryNodeRuleTest
CRelateTest
►NUnion
CCascadedPolygonUnionFileTest	Large-scale tests of CascadedPolygonUnion using data from files.
CCascadedPolygonUnionTest	Large-scale tests of CascadedPolygonUnion using synthetic datasets.
CCascadedPolygonUnionTester	Compares the results of CascadedPolygonUnion to Geometry.union() using shape similarity measures.
CUnaryUnionTest
►NValid
CIsValidTest
CValidClosedRingTest	Tests validating geometries with non-closed rings.
CValidSelfTouchingRingFormingHoleTest	Tests allowing IsValidOp to validate polygons with Self-Touching Rings forming holes. Mainly tests that configuring IsValidOp to allow validating the STR validates polygons with this condition, and does not validate polygons with other kinds of self-intersection (such as ones with Disconnected Interiors). Includes some basic tests to confirm that other invalid cases remain detected correctly, but most of this testing is left to the existing XML validation tests. /summary> author>Martin Davis</author> version>1.7</version>
CBoundaryTest	Tests BoundaryOp with different BoundaryNodeRules.
CIsSimpleTest	Tests IsSimpleOp with different IBoundaryNodeRules. /summary> <author>Martin Davis</author>
►NPerformance
►NAlgorithm
CDistanceLineLineStressTest
CMinimumBoundingCircleStressTest
CSimpleRayCrossingStressTest
►NDissolve
CLineDissolveStressTest
►NGeometries
►NPrepared
CPreparedGeometryThreadSafeTest	Tests for race conditons in the PreparedGeometry classes.
CPreparedLineIntersectsPerformanceTest
CPreparedPolygonIntersectsPerformanceTest
CTestDataBuilder
►NMathematics
CDDExpressionPerformance	Times evaluating floating-point expressions using various extended precision APIs.
CInCirclePerf
CTriPredicate
►NOperation
►NBuffer
CFileBufferResultValidatorTest
CPolygonBufferStressTest	Stress-tests buffering by repeatedly buffering a geometry using alternate positive and negative distances. In older versions of JTS this used to quickly cause failure due to robustness issues (bad noding causing topology failures). However by ver 1.13 (at least) this test should pass perfectly. This is due to the many heuristics introduced to improve buffer
►NDistance
CTestPerfDistanceLinesPoints
►NOverlay
COverlayNodingStressTest
CAreaPrecisionPerfTest
CExamplePerformanceTest	An example of the usage of the PerformanceTestRunner.
CPerformanceTestCase	A base class for classes implementing performance tests to be run by the PerformanceTestRunner. In a subclass of this class, all public methods which start with Run are executed as performance tests. Multiple test runs with different run sizes may be made. Within each run, each Run method is executed the specified number of iterations. The time to run the method is printed for each one.
CPerformanceTestRunner	Runs PerformanceTestCase classes which contain performance tests.
CThreadTestCase	Base class for test cases which depend on threading. A common example of usage is to test for race conditions.
►NPrecision
CGeometryPrecisionReducerTest
CSimpleGeometryPrecisionReducerTest
►NSimplify
CDouglasPeuckerSimplifierTest
CGeometryOperationValidator	Runs various validation tests on a the results of a geometry operation
CSameStructureTester	Test if two geometries have the same structure (but not necessarily the same coordinate sequences or adjacencies).
CTopologyPreservingSimplifierTest
CVWSimplifierTest
►NTriangulate
CBasicFunctionalityTest
CConformingDelaunayTest	Tests Delaunay Triangulatin classes
CDelaunayPerformanceTest
CDelaunayTest	Tests Delaunay Triangulatin classes
CVoronoiTest	Tests Voronoi diagram generation
►NUtilities
CPriorityQueueTest
CGeometryServiceProviderTest
CGeometryTestCase	A base class for IGeometry tests which provides various utility methods.
CGeometryUtils
CMiscellaneousTest
CMiscellaneousTest2
CPclSetup
►NPerformances
CNodingValidatorFixture
CSortedListsFixture
►NVarious
CGoogleGroupTests
CGoogleIssueTrackerTests
CGraphBuilder2Test
CHelper
CIssue102Test
CIssue117Tests
CIssue123Test
CIssue131Test
CIssue152Tests
CIssue178Fixture
CIssue179Fixture
CIssue186TestFixture
CIssue26Tests
CIssue35Tests
CIssue36Tests
CIssue37Tests
CIssue56Tests
CIssue58Tests
CIssue68Tests
CIssue86Test
CIssue94Test
CPathFinderTest
CQuadTreeTest
CSlowIntersectionTest
►NXUnit
CExternalRobustness
CExternalXUnitRunner
CFailureXUnitRunner
CGeneralXUnitRunner
CRobustXUnitRunner
CStMLFXUnitRunner
CTestBigNastyBuffer
CTestBufferExternal
CTestBufferExternal2
CTestGeosBuffer
CTestOverlay
CTestOverlayFailure
CTestRelateAA
CTestRelateAA_big
CTestRelateAC
CTestRelateLA
CTestRelateLC
CTestRelateLL
CTestRelatePA_Vivid
CTestRelatePL_Vivid
CTestRelatePP_Vivid
CTestResults
CTestRobustOverlayError
CTestRobustOverlayFixed
CTestRobustOverlayFloat
CTestRobustRelate
CTestStMLF20061018
CTestStMLF20061020
CValidateXUnitRunner
CXUnitRunner	A class designed to allow debugging of individual tests from within the vivid set mainly to aid debugging v2 side by side with v1.7.x
►NTriangulate
►NQuadEdge
CEdgeConnectedTriangleTraversal	A framework to visit sets of edge-connected QuadEdgeTriangles in breadth-first order
CIQuadEdgeLocator	An interface for classes which locate an edge in a QuadEdgeSubdivision which either contains a given Vertex V or is an edge of a triangle which contains V. Implementors may utilized different strategies for optimizing locating containing edges/triangles.
CITraversalVisitor	Interface for classes which process triangles visited during travesals of a QuadEdgeSubdivision
CITriangleVisitor	An interface for algorithms which process the triangles in a QuadEdgeSubdivision.
CLastFoundQuadEdgeLocator	Locates QuadEdges in a QuadEdgeSubdivision, optimizing the search by starting in the locality of the last edge found.
CLocateFailureException
CQuadEdge	A class that represents the edge data structure which implements the quadedge algebra. The quadedge algebra was described in a well-known paper by Guibas and Stolfi, "Primitives for the manipulation of general subdivisions and the computation of Voronoi diagrams", ACM Transactions on Graphics, 4(2), 1985, 75-123
CQuadEdgeSubdivision	A class that contains the QuadEdges representing a planar subdivision that models a triangulation. The subdivision is constructed using the quadedge algebra defined in the classs QuadEdge. All metric calculations are done in the Vertex class. In addition to a triangulation, subdivisions support extraction of Voronoi diagrams. This is easily accomplished, since the Voronoi diagram is the dual of the Delaunay triangulation
CQuadEdgeTriangle	Models a triangle formed from QuadEdges in a QuadEdgeSubdivision which forms a triangulation. The class provides methods to access the topological and geometric properties of the triangle and its neighbours in the triangulation. Triangle vertices are ordered in CCW orientation in the structure.
CQuadEdgeUtil
CVertex	Models a site (node) in a QuadEdgeSubdivision. The sites can be points on a line string representing a linear site.The vertex can be considered as a vector with a norm, length, inner product, cross product, etc. Additionally, point relations (e.g., is a point to the left of a line, the circle defined by this point and two others, etc.) are also defined in this class. It is common to want to attach user-defined data to the vertices of a subdivision. One way to do this is to subclass Vertex to carry any desired information.
CConformingDelaunayTriangulationBuilder	A utility class which creates Conforming Delaunay Trianglulations from collections of points and linear constraints, and extract the resulting triangulation edges or triangles as geometries.
CConformingDelaunayTriangulator	Computes a Conforming Delaunay Triangulation over a set of sites and a set of linear constraints.
CConstraintEnforcementException	Indicates a failure during constraint enforcement.
CConstraintVertex	A vertex in a Constrained Delaunay Triangulation. The vertex may or may not lie on a constraint. If it does it may carry extra information about the original constraint.
CConstraintVertexFactory	An interface for factories which create a ConstraintVertex
CDelaunayTriangulationBuilder	A utility class which creates Delaunay Trianglulations from collections of points and extract the resulting triangulation edges or triangles as geometries.
CIConstraintSplitPointFinder	An interface for strategies for determining the location of split points on constraint segments. The location of split points has a large effect on the performance and robustness of enforcing a constrained Delaunay triangulation. Poorly chosen split points can cause repeated splitting, especially at narrow constraint angles, since the split point will end up encroaching on the segment containing the original encroaching point. With detailed knowledge of the geometry of the constraints, it is sometimes possible to choose better locations for splitting.
CIncrementalDelaunayTriangulator	Computes a Delauanay Triangulation of a set of Vertexes, using an incrementatal insertion algorithm.
CMidpointSplitPointFinder	A simple split point finder which returns the midpoint of the split segment. This is a default strategy only. Usually a more sophisticated strategy is required to prevent repeated splitting. Other points which could be used are:
CNonEncroachingSplitPointFinder	A strategy for finding constraint split points which attempts to maximise the length of the split segments while preventing further encroachment. (This is not always possible for narrow angles).
CSegment	Models a constraint segment in a triangulation. A constraint segment is an oriented straight line segment between a start point and an end point
CSplitSegment	Models a constraint segment which can be split in two in various ways, according to certain geometric constraints.
CVertexTaggedGeometryDataMapper	Creates a map between the vertex Coordinates of a set of Geometrys, and the parent geometry, and transfers the source geometry data objects to geometry components tagged with the coordinates.
CVoronoiDiagramBuilder	A utility class which creates Voronoi Diagrams from collections of points. The diagram is returned as a IGeometryCollection of Polygons, clipped to the larger of a supplied envelope or to an envelope determined by the input sites.
►NUtilities
CAssertionFailedException
CBitConverter	A supoort class: the purpose is to integrate System.BitConverter methods not presents in .NET Compact Framework.
CCollectionUtil	Executes a transformation function on each element of a collection and returns the results in a new List.
CCoordinateArrayFilter	A CoordinateFilter that creates an array containing every coordinate in a Geometry.
CCoordinateCompare	CoordinateCompare is used in the sorting of arrays of Coordinate objects. Implements a lexicographic comparison.
CCoordinateCountFilter	A CoordinateFilter that counts the total number of coordinates in a Geometry.
CDegrees	Converts degrees to radians.
►CGeometricShapeFactory	Computes various kinds of common geometric shapes. Allows various ways of specifying the location and extent of the shapes, as well as number of line segments used to form them.
CDimensions
CGeoToolsStreamTokenizer	The StreamTokenizer class takes an input stream and parses it into "tokens", allowing the tokens to be read one at a time. The parsing process is controlled by a table and a number of flags that can be set to various states. The stream tokenizer can recognize identifiers, numbers, quoted strings, and various comment style.
CGlobal
CHexConverter
CMemory	Utility functions to report memory usage.
CPriorityQueue< T >	A priority queue over a set of IComparable{T} objects. /summary> Template Parameters T Objects to add <author>Martin Davis</author>
CRadians	Converts radians to degress.
CUniqueCoordinateArrayFilter	A CoordinateFilter that builds a set of Coordinates. The set of coordinates contains no duplicate points.
►NVersionComparisonTests
CBufferTest	Summary description for UnitTest1
CStrTreeTests	Summary description for StrTreeTests
►NWindows
►NForms
►NTest
CBasicTestForms
CBasePointShapeFactory
CCircle
CCross
CDot
CFontGlyphReader	Provides methods to read System.Drawing.Font glyphs for strings into IPolygonal geometry. /summary>
CGeometryCollectionGraphicsPath	A list of GraphicsPath which contains a heterogeneous collection of other shapes representing NTS IGeometrys. /summary>
CGraphicsPathReader	Converts a DotNet GraphicsPath or the more general GraphicsPathIterator into a IGeometry. /summary> remarks>
CGraphicsPathWriter	Writes IGeometrys int System.Drawing.Drawing2D's System.Drawing.Drawing2D.GraphicsPaths of the appropriate type. This supports rendering geometries using System.Drawing. The GraphicsPathWriter allows supplying a IPointTransformation class, to transform coordinates from model space into view space. This is useful if a client is providing its own transformation logic, rather than relying on System.Drawing.Drawing2D.Matrix. The writer supports removing duplicate consecutive points (via the RemoveDuplicatePoints property) as well as true decimation (via the Decimation property. Enabling one of these strategies can substantially improve rendering speed for large geometries. It is only necessary to enable one strategy. Using decimation is preferred, but this requires determining a distance below which input geometry vertices can be considered unique (which may not always be feasible). If neither strategy is enabled, all vertices of the input Geometry will be represented in the output GraphicsPath.
CIdentityPointTransformation	Point transformation class, copies ordinates with no transformation
CInvertYPointTransformation
CIPointShapeFactory	An interface for classes which create GraphicsPaths to represent IPoint geometries. Windows.Forms does not provide an actual point shape, so some other shape must be used to render points (e.g. such as a Rectangle or Ellipse) /summary> <author>Martin Davis</author>
CIPointTransformation	Transforms a geometry Coordinate into a PointF, possibly with a mathematical transformation of the ordinate values. Transformation from a model coordinate system to a view coordinate system can be efficiently performed by supplying an appropriate transformation.
CPolygonGraphicsPath
CSquare
CStar
CTriangle
CX
►NMedia
►NTest
CBasicTestMedia
CBasicTestMediaPath
CBasePointToPathGeometryFactory
CCirclePath
CCrossPath
CDotPath
CFontGlyphReader	Provides methods to read Typeface glyphs for strings into IPolygonal geometry. /summary>
CIdentityPointTransformation	Copies point ordinates with no transformtaion
CInvertYPointTransformation	Transforms coordinates by inverting the y ordinate and adding an offset
CIPointToPathGeometryFactory
CIPointTransformation	Transforms a geometry Coordinate into a WpfPoint, possibly with a mathematical transformation of the ordinate values. Transformation from a model coordinate system to a view coordinate system can be efficiently performed by supplying an appropriate transformation.
CPolygonWpfPathGeometry
CSquarePath
CStarPath
CTrianglePath
CWpfGeometryReader	Converts a WPF WpfGeometry into a IGeometry. /summary> remarks>
CXPath
CNtsGeometryServices	A geometry service provider class
▼NOpen
►NTopology
►NTestRunner
►NFunctions
CBaseGeometryFunction	A base for implementations of IGeometryFunction which provides most of the required structure. Extenders must supply the behaviour for the actual function invocation.
CGeometryFunctionRegistry	A registry to manage a collection of IGeometryFunctions.
CIGeometryFunction	A reification of a function which can be executed on a IGeometry, possibly with other arguments. The function may return a Geometry or a scalar value.
CStaticMethodGeometryFunction	A IGeometryFunction which calls a static MethodInfo.
CTestCaseGeometryFunctions
CTriangleFunctions
CTriangulationFunctions
CValidationFunctions
►NOperations
CArgumentConverter
CBufferValidatedGeometryOperation	A IGeometryOperation which validates the results of the IGeometry buffer() method. If an invalid result is found, an exception is thrown (this is the most convenient and noticeable way of flagging the problem when using the TestRunner). All other Geometry methods are executed normally
CGeometryFunctionOperation
CGeometryMethodOperation
CIGeometryMatcher	An interface for classes which can determine whether two geometries match, within a given tolerance.
CIGeometryOperation	Interface for classes which execute operations on Geometrys. The arguments may be presented as Strings, even if they should be calling a method with non-String arguments. Geometry will always be supplied as Geometry objects, however. This interface abstracts out the invocation of a method on a Geometry during a Test. Subclasses can provide substitute or additional methods during runs of the same test file.
CLoggingGeometryOperation	A IGeometryOperation which logs the input and output from another IGeometryOperation. The log is sent to Console.Out.
CNormalizedGeometryMatcher
CNTSTestReflectionException
COverlayValidatedGeometryOperation	A IGeometryOperation which validates the result of overlay operations. If an invalid result is found, an exception is thrown (this is the most convenient and noticeable way of flagging the problem when using the TestRunner). All other Geometry methods are executed normally. In order to eliminate the need to specify the precise result of an overlay, this class forces the final return value to be GEOMETRYCOLLECTION EMPTY. This class can be used via the -geomop command-line option or by the <geometryOperation> XML test file setting.
CPreparedGeometryOperation	A IGeometryOperation which uses IPreparedGeometrys for applicable operations. This allows testing correctness of the PreparedGeometry implementation. This class can be used via the -geomop command-line option or by the <geometryOperation> XML test file setting.
CPreparedGeometryTeeOperation
CTeeGeometryOperation	A IGeometryOperation which executes the original operation and returns that result, but also executes a separate operation (which could be multiple operations). The side operations can throw exceptions if they do not compute correct results. This relies on the availability of another reliable implementation to provide the expected result
►NResult
CBooleanResult
CBufferResultMatcher	A IResultMatcher{GeometryResult} which compares the results of buffer operations for equality, up to the given tolerance. All other operations are delagated to the standard EqualityResultMatcher{GeometryResult} algorithm.
CDoubleResult
CEqualityResultMatcher< TResult >	A See also IResultMatcher{TResult} which compares result for equality, up to the given tolerance.
CGeometryResult
CIntegerResult
CIResult
CIResult< T >
CIResultMatcher
CIResultMatcher< TResult >	An interface for classes which can determine whether two s match, within a given tolerance. The matching may also take into account the original input parameters to the geometry method.
CNullResultMatcher< TResult >	A See also IResultMatcher{TResult} which always passes. This is useful if the expected result of an operation is not known.
►NUtility
CClassUtility
CDoubleKeyMap< TKey1, TKey2, TValue >
CFunctionsUtil
CIOUtility
CMultiFormatReader	Reads a See also IGeometry from a string which is in either WKT or WKBHex format
CStringUtil
CXmlTest	Summary description for XmlTest.
CXmlTestCollection	Summary description for XmlTestCollection.
CXmlTestController	Summary description for XmlTestController.
CXmlTestDocument	Summary description for XmlTestDocument.
CXmlTestErrorEventArgs
CXmlTestEventArgs
CXmlTestExceptionManager	Summary description for XmlTestExceptionManager.
CXmlTestFactory	Summary description for XmlTestFactory.
CXmlTestInfo	Summary description for XmlTestInfo.
CXmlTestTimer
▼NRTools_NTS
►NUtil
CCharBuffer	Buffer for characters. This approximates StringBuilder but is designed to be faster for specific operations. This is about 30% faster for the operations I'm interested in (Append, Clear, Length, ToString). This trades off memory for speed.
CCharToken	Token type for characters, meaning non-word characters.
CCommentToken	Token type for comments, including line and block comments.
CEofToken	Represents end of file/stream.
CEolToken	Represents end-of-lines (line separator characters).
CFloatToken	Token type for floating point numbers, stored internally as a Double.
CIntToken	Token type for integer tokens. This handles both Int32 and Int64.
CLogger	This is a simple implementation of a Logger class. The purpose is to threshold output based on a verbosity setting, format messages similarly, and collect all message writes such that they can be redirected easily. You (and I) should probably use the some other library for this, but I haven't found one that suits my needs.
COpts	A command-line option parser similar to Perl's getopts. This is for parsing command-line options like "-name foo -type theType -v -d". This parses a string[] (like main usually takes) and collects argument information based on a parse specification.
CQuoteToken	Token type for Quotes such as "this is a quote".
CStreamTokenizer	A StreamTokenizer similar to Java's. This breaks an input stream (coming from a TextReader) into Tokens based on various settings. The settings are stored in the TokenizerSettings property, which is a StreamTokenizerSettings instance.
CStreamTokenizerSettings	This contains the settings that control the behavior of the tokenizer. This is separated from the StreamTokenizer so that common settings are easy to package and keep together.
CStreamTokenizerUntermCommentException	Exception class for unterminated block comments.
CStreamTokenizerUntermException	Exception class for unterminated tokens.
CStreamTokenizerUntermQuoteException	Exception class for unterminated quotes.
CStringToken	Abstract base class for string tokens.
CToken	Token class used by StreamTokenizer. This represents a single token in the input stream. This is subclassed to provide specific token types, such as CharToken, FloatToken, etc.
CWhitespaceToken	Token type for whitespace such as spaces and tabs.
CWordToken	Token type for words, meaning sequences of word characters.
▼NWintellect
►NPowerCollections
CBag< T >	Bag<T> is a collection that contains items of type T. Unlike a Set, duplicate items (items that compare equal to each other) are allowed in an Bag.
CBigList< T >	BigList<T> provides a list of items, in order, with indices of the items ranging from 0 to one less than the count of items in the collection. BigList<T> is optimized for efficient operations on large (>100 items) lists, especially for insertions, deletions, copies, and concatinations.
CCollectionBase< T >	CollectionBase is a base class that can be used to more easily implement the generic ICollection<T> and non-generic ICollection interfaces.
CDeque< T >
CDictionaryBase< TKey, TValue >	DictionaryBase is a base class that can be used to more easily implement the generic IDictionary<T> and non-generic IDictionary interfaces.
CListBase< T >	ListBase is an abstract class that can be used as a base class for a read-write collection that needs to implement the generic IList<T> and non-generic IList collections. The derived class needs to override the following methods: Count, Clear, Insert, RemoveAt, and the indexer. The implementation of all the other methods in IList<T> and IList are handled by ListBase.
CMultiDictionary< TKey, TValue >
CMultiDictionaryBase< TKey, TValue >	MultiDictionaryBase is a base class that can be used to more easily implement a class that associates multiple values to a single key. The class implements the generic IDictionary<TKey, ICollection<TValue>> interface.
►COrderedBag< T >	OrderedBag<T> is a collection that contains items of type T. The item are maintained in a sorted order. Unlike a OrderedSet, duplicate items (items that compare equal to each other) are allows in an OrderedBag.
CView	The OrderedBag<T>.View class is used to look at a subset of the items inside an ordered bag. It is returned from the Range, RangeTo, RangeFrom, and Reversed methods.
►COrderedDictionary< TKey, TValue >	OrderedDictionary<TKey, TValue> is a collection that maps keys of type TKey to values of type TValue. The keys are maintained in a sorted order, and at most one value is permitted for each key.
CView	The OrderedDictionary<TKey,TValue>.View class is used to look at a subset of the keys and values inside an ordered dictionary. It is returned from the Range, RangeTo, RangeFrom, and Reversed methods.
►COrderedMultiDictionary< TKey, TValue >
CView	The OrderedMultiDictionary<TKey,TValue>.View class is used to look at a subset of the keys and values inside an ordered multi-dictionary. It is returned from the Range, RangeTo, RangeFrom, and Reversed methods.
►COrderedSet< T >	OrderedSet<T> is a collection that contains items of type T. The item are maintained in a sorted order, and duplicate items are not allowed. Each item has an index in the set: the smallest item has index 0, the next smallest item has index 1, and so forth.
CView	The OrderedSet<T>.View class is used to look at a subset of the Items inside an ordered set. It is returned from the Range, RangeTo, RangeFrom, and Reversed methods.
CPair< TFirst, TSecond >	Stores a pair of objects within a single struct. This struct is useful to use as the T of a collection, or as the TKey or TValue of a dictionary.
CReadOnlyCollectionBase< T >	ReadOnlyCollectionBase is a base class that can be used to more easily implement the generic ICollection<T> and non-generic ICollection interfaces for a read-only collection: a collection that does not allow adding or removing elements.
CReadOnlyDictionaryBase< TKey, TValue >	ReadOnlyDictionaryBase is a base class that can be used to more easily implement the generic IDictionary<T> and non-generic IDictionary interfaces.
CReadOnlyListBase< T >	ReadOnlyListBase is an abstract class that can be used as a base class for a read-only collection that needs to implement the generic IList<T> and non-generic IList collections. The derived class needs to override the Count property and the get part of the indexer. The implementation of all the other methods in IList<T> and IList are handled by ListBase.
CReadOnlyMultiDictionaryBase< TKey, TValue >	MultiDictionaryBase is a base class that can be used to more easily implement a class that associates multiple values to a single key. The class implements the generic IDictionary<TKey, ICollection<TValue>> interface. The resulting collection is read-only – items cannot be added or removed.
CSet< T >	Set<T> is a collection that contains items of type T. The item are maintained in a haphazard, unpredictable order, and duplicate items are not allowed.
CTriple< TFirst, TSecond, TThird >	Stores a triple of objects within a single struct. This struct is useful to use as the T of a collection, or as the TKey or TValue of a dictionary.