NetTopologySuite
 All Classes Namespaces Functions Variables Enumerations Enumerator Properties Pages
Class Hierarchy
This inheritance list is sorted roughly, but not completely, alphabetically:
[detail level 1234]
 ►CNetTopologySuite.Tests.NUnit.LinearReferencing.AbstractIndexedLineTestBase class for linear referencing class unit tests
 ►CNetTopologySuite.IO.Tests.AbstractIOFixture
 ►CNetTopologySuite.Tests.NUnit.Algorithm.AbstractPointInRingTest
 ►CNetTopologySuite.Index.Strtree.AbstractSTRtree< 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
 CNetTopologySuite.Geometries.Utilities.AffineTransformationBuilderBuilds an AffineTransformation defined by a set of control vectors. /summary>
 CNetTopologySuite.Tests.NUnit.Geometries.Utility.AffineTransformationBuilderTestTests AffineTransformationBuilder
 CNetTopologySuite.Tests.NUnit.Geometries.Utility.AffineTransformationTest
 CNetTopologySuite.Samples.Tests.Various.AffineTransformBuilderUsage
 CNetTopologySuite.Tests.NUnit.Algorithm.AngleTest
 ►CApplicationException
 CNetTopologySuite.Tests.NUnit.Geometries.AreaLengthTest
 CNetTopologySuite.Tests.NUnit.Performance.AreaPrecisionPerfTest
 COpen.Topology.TestRunner.Operations.ArgumentConverter
 CConsoleTestRunner.ArgumentsArguments class
 CNetTopologySuite.Index.ArrayListVisitor
 CNetTopologySuite.IO.Tests.GeoJSON.AttributesTableConverterTestThis is a test class for AttributesTableConverterTest and is intended to contain all AttributesTableConverterTest Unit Tests /summary>
 ►CNetTopologySuite.Samples.SimpleTests.BaseSamples
 CNetTopologySuite.Tests.NUnit.Geometries.Implementation.BasicCoordinateSequenceTest
 CNetTopologySuite.Samples.Geometries.BasicExampleShows basic ways of creating and operating on geometries
 CNetTopologySuite.Tests.NUnit.Triangulate.BasicFunctionalityTest
 CNetTopologySuite.Windows.Forms.Test.BasicTestForms
 CNetTopologySuite.Windows.Media.Test.BasicTestMedia
 CNetTopologySuite.Windows.Media.Test.BasicTestMediaPath
 CNetTopologySuite.Tests.NUnit.Geometries.BidirectionalComparatorTest
 ►CBinaryReader
 ►CBinaryWriter
 ►CNetTopologySuite.Index.Bintree.Bintree< 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).
 CNetTopologySuite.Utilities.BitConverterA supoort class: the purpose is to integrate System.BitConverter methods not presents in .NET Compact Framework.
 CNetTopologySuite.Operation.BoundaryOpComputes 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>
 CNetTopologySuite.Tests.NUnit.Operation.BoundaryTestTests BoundaryOp with different BoundaryNodeRules.
 CNetTopologySuite.Operation.Buffer.Validate.BufferCurveMaximumDistanceFinderFinds the approximate maximum distance from a buffer curve to the originating geometry. /summary>
 CNetTopologySuite.Operation.Buffer.Validate.BufferDistanceValidatorValidates that a given buffer curve lies an appropriate distance from the input generating it.
 CNetTopologySuite.Operation.Buffer.BufferInputLineSimplifierSimplifies a buffer input line to remove concavities with shallow depth. /summary>
 CNetTopologySuite.Operation.Buffer.BufferOpComputes the buffer of a geometry, for both positive and negative buffer distances.
 CNetTopologySuite.Operation.Buffer.Validate.BufferResultValidatorValidates that the result of a buffer operation is geometrically correct, within a computed tolerance.
 CNetTopologySuite.Tests.NUnit.Operation.Buffer.BufferResultValidatorTest
 CNetTopologySuite.VersionComparisonTests.BufferTestSummary description for UnitTest1
 CNetTopologySuite.Tests.NUnit.Operation.Buffer.BufferTest
 CNetTopologySuite.Tests.NUnit.Operation.Buffer.BufferValidator
 CNetTopologySuite.Operation.Union.CascadedPolygonUnionProvides 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.
 CNetTopologySuite.Tests.NUnit.Operation.Union.CascadedPolygonUnionFileTestLarge-scale tests of CascadedPolygonUnion using data from files.
 CNetTopologySuite.Tests.NUnit.Operation.Union.CascadedPolygonUnionTestLarge-scale tests of CascadedPolygonUnion using synthetic datasets.
 CNetTopologySuite.Tests.NUnit.Operation.Union.CascadedPolygonUnionTesterCompares the results of CascadedPolygonUnion to Geometry.union() using shape similarity measures.
 CNetTopologySuite.Algorithm.CentralEndpointIntersectorComputes 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.
 CNetTopologySuite.Algorithm.CentroidComputes 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
 CNetTopologySuite.Algorithm.CentroidAreaComputes the centroid of an area point.
 CNetTopologySuite.Algorithm.CentroidLineComputes the centroid of a linear point. Algorithm: Compute the average of the midpoints of all line segments weighted by the segment length.
 CNetTopologySuite.Algorithm.CentroidPointComputes the centroid of a point point. Algorithm: Compute the average of all points.
 CNetTopologySuite.Algorithm.CGAlgorithms3D
 CNetTopologySuite.Tests.NUnit.Algorithm.CGAlgorithmsTest
 CRTools_NTS.Util.CharBufferBuffer 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.
 COpen.Topology.TestRunner.Utility.ClassUtility
 CNetTopologySuite.Samples.Operation.Distance.ClosestPointExampleExample of computing distance and closest points between geometries using the DistanceOp class.
 ►CCollectionBase
 CNetTopologySuite.Utilities.CollectionUtilExecutes a transformation function on each element of a collection and returns the results in a new List.
 CNetTopologySuite.Precision.CommonBitsDetermines 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.
 CNetTopologySuite.Precision.CommonBitsOpProvides 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.
 CNetTopologySuite.Precision.CommonBitsRemoverRemoves 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.
 CNetTopologySuite.Tests.NUnit.Algorithm.ComputeOrientationTest
 CNetTopologySuite.Tests.NUnit.Triangulate.ConformingDelaunayTestTests Delaunay Triangulatin classes
 CNetTopologySuite.Triangulate.ConformingDelaunayTriangulationBuilderA utility class which creates Conforming Delaunay Trianglulations from collections of points and linear constraints, and extract the resulting triangulation edges or triangles as geometries.
 CNetTopologySuite.Triangulate.ConformingDelaunayTriangulatorComputes a Conforming Delaunay Triangulation over a set of sites and a set of linear constraints.
 CNetTopologySuite.Operation.Valid.ConnectedInteriorTesterThis 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:
 CNetTopologySuite.Planargraph.Algorithm.ConnectedSubgraphFinderFinds all connected Subgraphs of a PlanarGraph.
 CNetTopologySuite.Operation.Valid.ConsistentAreaTesterChecks 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.
 CConsoleTestRunner.ConsoleTestSummary description for ConsoleTest.
 CNetTopologySuite.Triangulate.ConstraintVertexFactoryAn interface for factories which create a ConstraintVertex
 CNetTopologySuite.Samples.Geometries.ConstructionExampleExamples 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
 CNetTopologySuite.Tests.NUnit.Operation.Relate.ContainsTest
 CGeoAPI.Geometries.Test.ConvertAndBackTest
 CNetTopologySuite.Algorithm.ConvexHullComputes 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.
 CNetTopologySuite.Tests.NUnit.Algorithm.ConvexHullTest
 ►CCoordinate
 CNetTopologySuite.Tests.NUnit.Geometries.CoordinateArraysTest
 CNetTopologySuite.Tests.NUnit.Geometries.CoordinateBufferTest
 CNetTopologySuite.Tests.NUnit.Geometries.Implementation.CoordinateSequenceReversedTest
 CNetTopologySuite.Tests.NUnit.Geometries.CoordinateSequencesTest
 ►CNetTopologySuite.Tests.NUnit.Geometries.Implementation.CoordinateSequenceTestBaseGeneral test cases for CoordinateSequences. Subclasses can set the factory to test different kinds of CoordinateSequences.
 CNetTopologySuite.Tests.NUnit.Geometries.CoordinateTest
 CNetTopologySuite.Operation.CounterStores an integer count, for use as a Map entry. /summary> <author>Martin Davis</author>
 CNetTopologySuite.Samples.Geometries.CreateOrientationDistanceMesh
 ►CCustomConverterBase
 CNetTopologySuite.IO.DbaseFieldDescriptorClass for holding the information assicated with a dbase field.
 CNetTopologySuite.IO.DbaseFileHeaderClass for holding the information assicated with a dbase header.
 CNetTopologySuite.IO.DbaseFileWriterThis class aids in the writing of Dbase IV files.
 CNetTopologySuite.IO.Tests.ShapeFile.Extended.DbaseReaderTestsSummary description for DbfFileReaderTests
 CNetTopologySuite.Tests.NUnit.Mathematics.DDBasicTestTests basic arithmetic operations for DDs.
 CNetTopologySuite.Tests.NUnit.Mathematics.DDComputeTestVarious tests involving computing known mathematical quantities using the basic DD arithmetic operations.
 CNetTopologySuite.Tests.NUnit.Performance.Mathematics.DDExpressionPerformanceTimes evaluating floating-point expressions using various extended precision APIs.
 CNetTopologySuite.Tests.NUnit.Mathematics.DDIOTestTests I/O for DDs.
 CNetTopologySuite.Utilities.DegreesConverts degrees to radians.
 CNetTopologySuite.Tests.NUnit.Triangulate.DelaunayPerformanceTest
 CNetTopologySuite.Tests.NUnit.Triangulate.DelaunayTestTests Delaunay Triangulatin classes
 CNetTopologySuite.Triangulate.DelaunayTriangulationBuilderA utility class which creates Delaunay Trianglulations from collections of points and extract the resulting triangulation edges or triangles as geometries.
 CNetTopologySuite.Densify.DensifierDensifies 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.
 CNetTopologySuite.GeometriesGraph.DepthA Depth object records the topological depth of the sides of an Edge for up to two Geometries.
 CNetTopologySuite.Utilities.GeometricShapeFactory.Dimensions
 CNetTopologySuite.Planargraph.DirectedEdgeStarA sorted collection of DirectedEdges which leave a Node in a PlanarGraph.
 CNetTopologySuite.Algorithm.Distance.DiscreteHausdorffDistanceAn algorithm for computing a distance metric which is an approximation to the Hausdorff Distance based on a discretization of the input IGeometry.
 CNetTopologySuite.Tests.NUnit.Algorithm.Distance.DiscreteHausdorffDistanceTest
 CNetTopologySuite.Operation.Distance3D.Distance3DOpFind 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.
 CNetTopologySuite.Tests.NUnit.Operation.Distance3d.Distance3DOpTest
 CNetTopologySuite.Tests.NUnit.Performance.Algorithm.DistanceLineLineStressTest
 CNetTopologySuite.Operation.Distance.DistanceOpComputes 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.
 CNetTopologySuite.Tests.NUnit.Operation.Distance.DistanceTest
 CNetTopologySuite.Index.Quadtree.DoubleBitsDoubleBits 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.
 CNetTopologySuite.Tests.NUnit.Index.DoubleBitsTest
 CMiscUtil.Conversion.DoubleConverterA class to allow the conversion of doubles to string representations of their exact decimal values. The implementation aims for readability over efficiency.
 COpen.Topology.TestRunner.Utility.DoubleKeyMap< TKey1, TKey2, TValue >
 CNetTopologySuite.Simplify.DouglasPeuckerLineSimplifierSimplifies a line (sequence of points) using the standard Douglas-Peucker algorithm.
 CNetTopologySuite.Simplify.DouglasPeuckerSimplifierSimplifies a Geometry using the Douglas-Peucker algorithm.
 CNetTopologySuite.Tests.NUnit.Simplify.DouglasPeuckerSimplifierTest
 CNetTopologySuite.Triangulate.QuadEdge.EdgeConnectedTriangleTraversalA framework to visit sets of edge-connected QuadEdgeTriangles in breadth-first order
 CNetTopologySuite.Operation.Relate.EdgeEndBuilderAn 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.
 ►CNetTopologySuite.GeometriesGraph.EdgeEndStarA 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.
 ►CNetTopologySuite.EdgeGraph.EdgeGraphA 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.
 CNetTopologySuite.EdgeGraph.EdgeGraphBuilderBuilds an edge graph from geometries containing edges.
 CNetTopologySuite.Tests.NUnit.EdgeGraph.EdgeGraphTest
 CNetTopologySuite.GeometriesGraph.EdgeIntersectionListA list of edge intersections along an Edge.
 CNetTopologySuite.GeometriesGraph.EdgeListA EdgeList is a list of Edges. It supports locating edges that are pointwise equals to a target edge.
 CNetTopologySuite.GeometriesGraph.EdgeNodingValidatorValidates that a collection of Edge is correctly noded. Throws an appropriate exception if an noding error is found.
 ►CNetTopologySuite.GeometriesGraph.EdgeRing
 CNetTopologySuite.Operation.Polygonize.EdgeRingRepresents a ring of PolygonizeDirectedEdges which form a ring of a polygon. The ring may be either an outer shell or a hole.
 ►CNetTopologySuite.GeometriesGraph.Index.EdgeSetIntersectorAn 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.
 CNetTopologySuite.Operation.Overlay.EdgeSetNoderNodes 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.
 CNetTopologySuite.Operation.Linemerge.EdgeStringA sequence of LineMergeDirectedEdges forming one of the lines that will be output by the line-merging process.
 CNetTopologySuite.Precision.EnhancedPrecisionOpProvides versions of Geometry spatial functions which use enhanced precision techniques to reduce the likelihood of robustness problems.
 CNetTopologySuite.Samples.Precision.EnhancedPrecisionOpExampleExample of using {EnhancedPrecisionOp} to avoid robustness problems.
 CNetTopologySuite.Tests.NUnit.Geometries.EnvelopeTest
 ►CEventArgs
 ►CException
 CNetTopologySuite.Samples.Geometries.ExtendedCoordinateExample
 CNetTopologySuite.LinearReferencing.ExtractLineByLocationExtracts the subline of a linear Geometry between two LinearLocations on the line.
 CNetTopologySuite.Samples.Technique.ExtractLinestringByMeasure
 CNetTopologySuite.Operation.Distance.FacetSequenceRepresents a sequence of facets (points or line segments) of a IGeometry specified by a subsequence of a ICoordinateSequence.
 CNetTopologySuite.Noding.FastNodingValidatorValidates that a collection of ISegmentStrings is correctly noded. Indexing is used to improve performance. /summary>
 CNetTopologySuite.Noding.FastSegmentSetIntersectionFinderFinds if two sets of ISegmentStrings intersect.
 CNetTopologySuite.Features.FeatureCollectionRepresents a feature collection. /summary>
 CNetTopologySuite.IO.Tests.GeoJSON.FeatureCollectionTestThis is a test class for FeatureCollectionTest and is intended to contain all FeatureCollectionTest Unit Tests /summary>
 CNetTopologySuite.IO.Tests.GeoJSON.FeatureConverterTestThis is a test class for FeatureConverterTest and is intended to contain all FeatureConverterTest Unit Tests /summary>
 CNetTopologySuite.Tests.NUnit.Performance.Operation.Buffer.FileBufferResultValidatorTest
 CNetTopologySuite.Tests.NUnit.Operation.Overlay.FixedPrecisionSnappingTest
 CNetTopologySuite.Windows.Forms.FontGlyphReaderProvides methods to read System.Drawing.Font glyphs for strings into IPolygonal geometry. /summary>
 CNetTopologySuite.Windows.Media.FontGlyphReaderProvides methods to read Typeface glyphs for strings into IPolygonal geometry. /summary>
 COpen.Topology.TestRunner.Utility.FunctionsUtil
 CNetTopologySuite.Operation.Overlay.Validate.FuzzyPointLocatorFinds 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>
 CNetTopologySuite.IO.GeoJsonReaderRepresents a GeoJSON Reader allowing for deserialization of various GeoJSON elements or any object containing GeoJSON elements.
 CNetTopologySuite.IO.Tests.GeoJSON.GeoJsonReaderTestThis is a test class for GeoJsonReaderTest and is intended to contain all GeoJsonReaderTest Unit Tests /summary>
 CNetTopologySuite.IO.Tests.GeoJSON.GeoJsonSerializerTestThis is a test class for GeoJsonSerializerTest and is intended to contain all GeoJsonSerializerTest Unit Tests /summary>
 CNetTopologySuite.IO.GeoJsonWriterRepresents a GeoJSON Writer allowing for serialization of various GeoJSON elements or any object containing GeoJSON elements.
 CNetTopologySuite.IO.Tests.GeoJSON.GeoJsonWriterTestThis is a test class for GeoJsonWriterTest and is intended to contain all GeoJsonWriterTest Unit Tests /summary>
 CNetTopologySuite.Samples.Tests.Various.GeomBinOpTest_Issue14_Simplified
 ►CNetTopologySuite.Shape.GeometricShapeBuilder
 ►CNetTopologySuite.Utilities.GeometricShapeFactoryComputes 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.
 CNetTopologySuite.Samples.Tests.Various.GeometriesFixture
 CNetTopologySuite.Windows.Forms.GeometryCollectionGraphicsPathA list of GraphicsPath which contains a heterogeneous collection of other shapes representing NTS IGeometrys. /summary>
 CNetTopologySuite.Tests.NUnit.Geometries.GeometryCollectionImplTest
 CNetTopologySuite.Geometries.Utilities.GeometryCollectionMapperMaps the members of a IGeometryCollection into another GeometryCollection via a defined mapping function.
 CNetTopologySuite.Geometries.Utilities.GeometryCombinerCombines IGeometrys to produce a IGeometryCollection of the most appropriate type. /summary>
 CNetTopologySuite.Geometries.Utilities.GeometryEditorA class which supports creating new IGeometrys which are modifications of existing ones, maintaining the same type structure.
 CNetTopologySuite.Tests.NUnit.Geometries.GeometryFactoryTest
 COpen.Topology.TestRunner.Functions.GeometryFunctionRegistryA registry to manage a collection of IGeometryFunctions.
 ►CNetTopologySuite.Operation.GeometryGraphOperationThe base class for operations that require GeometryGraphs.
 CNetTopologySuite.Tests.NUnit.Geometries.GeometryImplTest
 CNetTopologySuite.Operation.Distance.GeometryLocationRepresents 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.
 CNetTopologySuite.Geometries.Utilities.GeometryMapperMethods to map various collections of IGeometrys via defined mapping functions.
 CNetTopologySuite.Noding.Snapround.GeometryNoderNodes the linework in a list of IGeometrys using Snap-Rounding to a given IPrecisionModel
 CNetTopologySuite.Tests.NUnit.Simplify.GeometryOperationValidatorRuns various validation tests on a the results of a geometry operation
 CNetTopologySuite.Precision.GeometryPrecisionReducerReduces the precision of a IGeometry according to the supplied IPrecisionModel, ensuring that the result is topologically valid.
 CNetTopologySuite.Tests.NUnit.Precision.GeometryPrecisionReducerTest
 CNetTopologySuite.Tests.NUnit.GeometryServiceProviderTest
 CNetTopologySuite.Samples.SimpleTests.Tests.GeometryServicesTest
 CNetTopologySuite.Operation.Overlay.Snap.GeometrySnapperSnaps 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.
 ►CNetTopologySuite.Tests.NUnit.GeometryTestCaseA base class for IGeometry tests which provides various utility methods.
 CNetTopologySuite.Tests.NUnit.Geometries.GeometryTestFactory
 CNetTopologySuite.CoordinateSystems.Transformations.GeometryTransformHelper class for transforming Geometry objects.
 CNetTopologySuite.Geometries.Utilities.GeometryTransformerA framework for processes which transform an input Geometry into an output IGeometry, possibly changing its structure and type(s).
 CNetTopologySuite.Tests.NUnit.CoordinateSystems.Transformations.GeometryTransformTest
 CNetTopologySuite.Tests.NUnit.GeometryUtils
 ►CNetTopologySuite.Utilities.GeoToolsStreamTokenizerThe 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.
 CNetTopologySuite.Samples.Tests.IO.GitIssue12Fixturehttps://github.com/NetTopologySuite/NetTopologySuite/issues/12
 CNetTopologySuite.Samples.Tests.IO.GitIssue4Fixturehttps://github.com/NetTopologySuite/NetTopologySuite/issues/4
 CNetTopologySuite.Utilities.Global
 CNetTopologySuite.IO.GML2.GMLReaderReads 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.
 CNetTopologySuite.Tests.NUnit.IO.GML2.GMLReaderTest
 CNetTopologySuite.Tests.IO.GmlTest
 CNetTopologySuite.IO.GML2.GMLWriterWrites the GML representation of the features of NetTopologySuite model. Uses GML 2.1.1 Geometry.xsd schema for base for features
 CNetTopologySuite.Tests.Various.GoogleIssueTrackerTests
 CGisSharpBlog.NetTopologySuite.Samples.Tests.Various.GraphBuilder
 CNetTopologySuite.Samples.Tests.Various.GraphBuilder2A class that manages shortest path computation.
 CNetTopologySuite.Tests.Various.GraphBuilder2Test
 CGisSharpBlog.NetTopologySuite.Samples.Tests.Various.GraphBuilderTest
 ►CNetTopologySuite.GeometriesGraph.GraphComponentA GraphComponent is the parent class for the objects' that form a graph. Each GraphComponent can carry a Label.
 ►CNetTopologySuite.Planargraph.GraphComponentThe 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.
 ►CGraphicsPathIterator
 CNetTopologySuite.Windows.Forms.GraphicsPathReaderConverts a DotNet GraphicsPath or the more general GraphicsPathIterator into a IGeometry. /summary> remarks>
 CNetTopologySuite.Windows.Forms.GraphicsPathWriterWrites 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.
 CNetTopologySuite.Algorithm.HCoordinateRepresents a homogeneous coordinate in a 2-D coordinate space. In NTS HCoordinates are used as a clean way of computing intersections between line segments.
 CNetTopologySuite.Tests.Various.Helper
 CNetTopologySuite.Utilities.HexConverter
 CNetTopologySuite.Samples.Lab.Clean.HoleRemoverRemoves holes which match a given predicate.
 CNetTopologySuite.Noding.Snapround.HotPixelImplements 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.
 ►CNetTopologySuite.Features.IAttributesTable
 ►CIBinaryGeometryReader
 ►CIBinaryGeometryWriter
 CNetTopologySuite.Index.Strtree.IBoundableA spatial object in an AbstractSTRtree.
 CNetTopologySuite.Index.Strtree.IBoundable< Envelope, TItem >
 ►CNetTopologySuite.Index.Strtree.IBoundable< T, TItem >
 CNetTopologySuite.Algorithm.IBoundaryNodeRuleAn 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
 ►CIBufferParameters
 ►CICloneable
 ►CICollection
 ►CIComparable
 ►CIComparable< Pair< TFirst, TSecond >>
 ►CIComparable< Triple< TFirst, TSecond, TThird >>
 ►CIComparer
 ►CNetTopologySuite.Triangulate.IConstraintSplitPointFinderAn 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.
 ►CICoordinate
 ►CICoordinateFilter
 ►CICoordinateSequence
 ►CICoordinateSequenceFactory
 ►CICoordinateSequenceFilter
 ►CNetTopologySuite.CoordinateSystems.ICRSObjectBase Interface for CRSBase Object types.
 ►CIDataReader
 ►CIDataRecord
 ►CIDictionary
 ►CIDictionary< TKey, ICollection< TValue >>
 ►CIDisposable
 ►CIEnumerable
 ►CIEnumerator
 ►CIEquatable
 ►CIExpandable
 ►CNetTopologySuite.Features.IFeature
 ►CIGeometry
 ►CIGeometryCollection
 ►CIGeometryComponentFilter
 ►CNetTopologySuite.Geometries.Utilities.GeometryEditor.IGeometryEditorOperationA interface which specifies an edit operation for Geometries.
 ►CIGeometryFactory
 ►CIGeometryFilter
 ►COpen.Topology.TestRunner.Functions.IGeometryFunctionA 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.
 ►COpen.Topology.TestRunner.Operations.IGeometryMatcherAn interface for classes which can determine whether two geometries match, within a given tolerance.
 ►COpen.Topology.TestRunner.Operations.IGeometryOperationInterface 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.
 ►CIGeometryReader
 ►CIGeometryServices
 ►CIGeometryWriter
 CNetTopologySuite.Index.IIndexVisitorA visitor for nodes and items in an index.
 ►CIIntersectable
 CNetTopologySuite.Index.Strtree.AbstractSTRtree< T, TItem >.IIntersectsOp
 ►CNetTopologySuite.Index.Strtree.IItemDistance< T, TItem >A function method which computes the distance between two IBoundable{T, TItem}s in an STRtree{TItem}. Used for Nearest Neighbour searches.
 ►CIItemVisitor
 ►CNetTopologySuite.Index.IItemVisitor< T >A visitor for items in an index.
 ►CILinearRing
 ►CILineString
 ►CIList
 CNetTopologySuite.Geometries.Utilities.GeometryMapper.IMapOpAn interface for geometry functions used for mapping.
 ►CIMathTransform
 ►CIMultiLineString
 ►CIMultiPoint
 ►CIMultiPolygon
 CNetTopologySuite.Tests.NUnit.Performance.Mathematics.InCirclePerf
 CNetTopologySuite.Triangulate.IncrementalDelaunayTriangulatorComputes a Delauanay Triangulation of a set of Vertexes, using an incrementatal insertion algorithm.
 CNetTopologySuite.Operation.Distance.IndexedFacetDistanceComputes 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
 CNetTopologySuite.Operation.Valid.IndexedNestedRingTester
 CNetTopologySuite.Tests.NUnit.Algorithm.IndexedPointInAreaStressTest
 ►CNetTopologySuite.Noding.INoderComputes 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.
 CNetTopologySuite.Algorithm.InteriorPointAreaComputes a point in the interior of an areal geometry.
 CNetTopologySuite.Algorithm.InteriorPointLineComputes 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.
 CNetTopologySuite.Algorithm.InteriorPointPointComputes a point in the interior of an point point. Algorithm: Find a point which is closest to the centroid of the point.
 CNetTopologySuite.Tests.NUnit.Algorithm.InteriorPointTest
 CNetTopologySuite.Tests.NUnit.Geometries.IntersectionMatrixTest
 CNetTopologySuite.Index.Bintree.IntervalRepresents an (1-dimensional) closed interval on the Real number line.
 ►CNetTopologySuite.Index.IntervalRTree.IntervalRTreeNode< T >
 CNetTopologySuite.Index.Quadtree.IntervalSizeProvides 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.
 CNetTopologySuite.Tests.NUnit.Geometries.IntervalTest
 ►CINullable
 CNetTopologySuite.Samples.Lab.Clean.InvalidHoleRemoverRemoves holes which are invalid due to not being wholly covered by the parent shell.
 ►CIOracleArrayTypeFactory
 ►CIOracleCustomType
 ►CIOracleCustomTypeFactory
 COpen.Topology.TestRunner.Utility.IOUtility
 ►CIPoint
 ►CNetTopologySuite.Algorithm.IPointInAreaLocatorAn interface for classes which determine the Location of points in a IGeometry /summary> author>Martin Davis</author>
 ►CNetTopologySuite.Algorithm.IPointInRingAn interface for classes which test whether a Coordinate lies inside a ring.
 ►CNetTopologySuite.Algorithm.Locate.IPointOnGeometryLocatorAn interface for classes which determine the Location of points in areal geometries.
 ►CNetTopologySuite.Windows.Forms.IPointShapeFactoryAn 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>
 ►CNetTopologySuite.Windows.Media.IPointToPathGeometryFactory
 ►CNetTopologySuite.Windows.Forms.IPointTransformationTransforms 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.
 ►CNetTopologySuite.Windows.Media.IPointTransformationTransforms 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.
 ►CIPolygon
 ►CIPrecisionModel
 ►CIPreparedGeometry
 ►CNetTopologySuite.Triangulate.QuadEdge.IQuadEdgeLocatorAn 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.
 ►CIRecordSource
 ►COpen.Topology.TestRunner.Result.IResult
 ►COpen.Topology.TestRunner.Result.IResultMatcher
 CNetTopologySuite.Tests.NUnit.Algorithm.IsCCWTest
 ►CNetTopologySuite.Noding.ISegmentIntersectorProcesses possible intersections detected by a INoder.
 ►CNetTopologySuite.Noding.ISegmentSetMutualIntersectorAn 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>

 ►CNetTopologySuite.Noding.ISegmentStringAn 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>
 CNetTopologySuite.Noding.SegmentStringDissolver.ISegmentStringMergerA merging strategy which can be used to update the context data of ISegmentStrings which are merged during the dissolve process.
 ►CNetTopologySuite.Algorithm.Match.ISimilarityMeasureAn interface for classes which measures the degree of similarity between two Geometrys.
 CNetTopologySuite.Index.ISpatialIndexThe 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.
 ►CNetTopologySuite.Index.ISpatialIndex< T >
 CNetTopologySuite.Tests.NUnit.Geometries.IsRectangleTestTest named predicate short-circuits
 CNetTopologySuite.Operation.IsSimpleOpTests 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.
 CNetTopologySuite.Tests.NUnit.Operation.IsSimpleTestTests IsSimpleOp with different IBoundaryNodeRules. /summary> <author>Martin Davis</author>
 CNetTopologySuite.Tests.Various.Issue102Test
 CNetTopologySuite.Samples.Tests.Various.Issue103Tests
 CNetTopologySuite.Tests.Various.Issue117Tests
 CNetTopologySuite.Tests.Various.Issue123Test
 CNetTopologySuite.Tests.Various.Issue131Test
 CNetTopologySuite.IO.Tests.GeoJSON.Issue148
 CNetTopologySuite.Tests.Various.Issue152Tests
 CNetTopologySuite.Samples.Tests.Various.Issue156Tests
 CNetTopologySuite.IO.Tests.GeoJSON.Issue16Fixturesee: https://github.com/NetTopologySuite/NetTopologySuite/issues/16
 CNetTopologySuite.Samples.Tests.Various.Issue171TestFixture
 CNetTopologySuite.Samples.Tests.Various.Issue172TestFixture
 CNetTopologySuite.Samples.Tests.Various.Issue173Fixture
 CNetTopologySuite.Samples.Tests.Various.Issue174TestFixture
 CNetTopologySuite.Tests.Various.Issue178Fixture
 CNetTopologySuite.Tests.Various.Issue179Fixture
 CNetTopologySuite.Tests.Various.Issue186TestFixture
 CNetTopologySuite.Tests.Various.Issue26Tests
 CNetTopologySuite.Tests.Various.Issue35Tests
 CNetTopologySuite.Tests.Various.Issue36Tests
 CNetTopologySuite.Tests.Various.Issue37Tests
 CNetTopologySuite.Tests.Various.Issue56Tests
 CNetTopologySuite.Tests.Various.Issue58Tests
 CNetTopologySuite.Tests.Various.Issue68Tests
 CNetTopologySuite.Tests.Various.Issue86Test
 CNetTopologySuite.Tests.Various.Issue94Test
 CNetTopologySuite.IO.Tests.Issues
 CNetTopologySuite.Operation.Valid.IsValidOpImplements the algorithsm required to compute the Geometry.IsValid method for Geometrys. See the documentation for the various geometry types for a specification of validity.
 CNetTopologySuite.Tests.NUnit.Operation.Valid.IsValidTest
 ►CNetTopologySuite.Index.Sweepline.ISweepLineOverlapAction
 ►CITextGeometryReader
 ►CITextGeometryWriter
 ►CNetTopologySuite.IO.Helpers.ITransform
 ►CNetTopologySuite.IO.Helpers.ITransformer
 CNetTopologySuite.Triangulate.QuadEdge.ITraversalVisitorInterface for classes which process triangles visited during travesals of a QuadEdgeSubdivision
 CNetTopologySuite.Triangulate.QuadEdge.ITriangleVisitorAn interface for algorithms which process the triangles in a QuadEdgeSubdivision.
 ►CJsonConverter
 ►CJsonSerializer
 CNetTopologySuite.Index.KdTree.KdNode< T >A node of a NetTopologySuite.Index.KdTree.KdTree{T}, which represents one or more points in the same location.
 CNetTopologySuite.Index.KdTree.KdTree< T >An implementation of a 2-D KD-Tree. KD-trees provide fast range searching on point data.
 CNetTopologySuite.Tests.NUnit.Index.KdTree.KdTreeTest
 CNetTopologySuite.Index.Quadtree.KeyA 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.
 CNetTopologySuite.Index.Bintree.KeyA 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.
 CNetTopologySuite.IO.KML.KMLWriterWrites 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.
 CNetTopologySuite.Tests.NUnit.IO.KML.KMLWriterTest
 CNetTopologySuite.GeometriesGraph.LabelA 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.
 CNetTopologySuite.Samples.Tests.Various.AffineTransformBuilderUsage.LeastSquaresTransformCalculates Affine and Helmert transformation using Least-Squares Regression of input and output points
 CNetTopologySuite.LinearReferencing.LengthIndexedLineSupports 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.
 CNetTopologySuite.LinearReferencing.LengthIndexOfPoint
 CNetTopologySuite.LinearReferencing.LengthLocationMapComputes 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.
 CNetTopologySuite.LinearReferencing.LinearGeometryBuilderBuilds a linear geometry (LineString or MultiLineString) incrementally (point-by-point).
 CNetTopologySuite.LinearReferencing.LinearIteratorAn iterator over the components and coordinates of a linear geometry (LineStrings and MultiLineStrings.
 CNetTopologySuite.Tests.NUnit.LinearReferencing.LinearLocationTestTests methods involving only LinearLocations
 CNetTopologySuite.Samples.LinearReferencing.LinearReferencingExampleExamples of Linear Referencing
 CNetTopologySuite.Operation.Overlay.LineBuilderForms NTS LineStrings out of a the graph of DirectedEdges created by an OverlayOp.
 CNetTopologySuite.Dissolve.LineDissolverDissolves 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.
 CNetTopologySuite.Tests.NUnit.Dissolve.LineDissolverTest
 CNetTopologySuite.Tests.NUnit.Performance.Dissolve.LineDissolveStressTest
 ►CNetTopologySuite.Algorithm.LineIntersectorA LineIntersector is an algorithm that can both test whether two line segments intersect and compute the intersection point(s) if they do
 CNetTopologySuite.Samples.Operation.Linemerge.LineMergeExampleExample of using the LineMerger class to sew together a set of fully noded linestrings.
 CNetTopologySuite.Operation.Linemerge.LineMergerSews together a set of fully noded LineStrings.
 CNetTopologySuite.Tests.NUnit.Operation.LineMerge.LineMergerTest
 CNetTopologySuite.Geometries.Prepared.LineNode
 CNetTopologySuite.Simplify.LineSegmentIndexAn index of LineSegments.
 CNetTopologySuite.Tests.NUnit.Geometries.LineSegmentTest
 CNetTopologySuite.Operation.Linemerge.LineSequencer
 CNetTopologySuite.Samples.Tests.Operation.Linemerge.LineSequencerFileTest
 CNetTopologySuite.Tests.NUnit.Operation.LineMerge.LineSequencerTestLineSequencer tests
 CNetTopologySuite.Tests.NUnit.Geometries.LineStringImplTest
 CNetTopologySuite.Samples.Technique.LineStringSelfIntersectionsShows a technique for identifying the location of self-intersections in a non-simple LineString.
 CNetTopologySuite.Operation.Overlay.Snap.LineStringSnapperSnaps 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.
 CNetTopologySuite.Geometries.Prepared.LineTopology
 CNetTopologySuite.IO.Tests.GeoJSON.LinkedCRSTestThis is a test class for LinkedCRSTest and is intended to contain all LinkedCRSTest Unit Tests /summary>
 ►CList
 CNetTopologySuite.LinearReferencing.LocationIndexedLineSupports linear referencing along a linear IGeometry using LinearLocations as the index.
 CNetTopologySuite.LinearReferencing.LocationIndexOfLineDetermines 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).
 CNetTopologySuite.LinearReferencing.LocationIndexOfPointComputes 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.
 CRTools_NTS.Util.LoggerThis 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.
 CNetTopologySuite.Mathematics.MathUtilVarious utility functions for mathematical and numerical operations.
 CNetTopologySuite.Mathematics.MatrixImplements some 2D matrix operations (in particular, solving systems of linear equations).
 CNetTopologySuite.Geometries.Utilities.MatrixImplements some 2D matrix operations (in particular, solving systems of linear equations).
 CNetTopologySuite.IO.Handlers.MBRInfo
 CNetTopologySuite.Noding.Snapround.MCIndexPointSnapper"Snaps" all ISegmentStrings in a ISpatialIndex containing MonotoneChains to a given HotPixel.
 CNetTopologySuite.Utilities.MemoryUtility functions to report memory usage.
 CNetTopologySuite.Algorithm.MinimumBoundingCircleComputes 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.
 CNetTopologySuite.Tests.NUnit.Performance.Algorithm.MinimumBoundingCircleStressTest
 CNetTopologySuite.Tests.NUnit.Algorithm.MinimumBoundingCircleTest
 CNetTopologySuite.Precision.MinimumClearanceComputes 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.
 CNetTopologySuite.Algorithm.MinimumDiameterComputes the minimum diameter of a IGeometry.
 CNetTopologySuite.Tests.NUnit.Algorithm.MinimumDiameterTest
 CNetTopologySuite.Tests.NUnit.MiscellaneousTest
 CNetTopologySuite.Tests.NUnit.MiscellaneousTest2
 CNetTopologySuite.GeometriesGraph.Index.MonotoneChain
 CNetTopologySuite.Index.Chain.MonotoneChainMonotoneChains are a way of partitioning the segments of a linestring to allow for fast searching of intersections.
 CNetTopologySuite.Index.Chain.MonotoneChainBuilderConstructs MonotoneChains for sequences of Coordinates.
 CNetTopologySuite.GeometriesGraph.Index.MonotoneChainEdgeMonotoneChains 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.
 CNetTopologySuite.GeometriesGraph.Index.MonotoneChainIndexerMonotoneChains are a way of partitioning the segments of an edge to allow for fast searching of intersections
 ►CNetTopologySuite.Index.Chain.MonotoneChainOverlapActionThe action for the internal iterator for performing overlap queries on a MonotoneChain.
 ►CNetTopologySuite.Index.Chain.MonotoneChainSelectActionThe action for the internal iterator for performing envelope select queries on a MonotoneChain.
 COpen.Topology.TestRunner.Utility.MultiFormatReaderReads a

See also
IGeometry

from a string which is in either WKT or WKBHex format

 CNetTopologySuite.Tests.NUnit.Geometries.MultiPointImplTest
 CNetTopologySuite.IO.Tests.GeoJSON.NamedCRSTestThis is a test class for NamedCRSTest and is intended to contain all NamedCRSTest Unit Tests /summary>
 CGeoAPI.NetTopologySuiteBootstrapperA utility class to register NTS as GeoAPI implementation to use
 ►CNetTopologySuite.Index.Bintree.NodeBase< T >The base class for nodes in a Bintree.
 ►CNetTopologySuite.Index.Quadtree.NodeBase< T >The base class for nodes in a Quadtree.
 ►CNetTopologySuite.GeometriesGraph.NodeFactory
 CNetTopologySuite.GeometriesGraph.NodeMapA map of nodes, indexed by the coordinate of the node.
 CNetTopologySuite.Planargraph.NodeMapA map of nodes, indexed by the coordinate of the node.
 CNetTopologySuite.Noding.NodingValidatorValidates that a collection of ISegmentStrings is correctly noded. Throws an appropriate exception if an noding error is found.
 CNetTopologySuite.Tests.Performances.NodingValidatorFixture
 CNetTopologySuite.Tests.NUnit.Algorithm.NonRobustLineIntersectorTest
 CNetTopologySuite.Tests.NUnit.Geometries.NormalizeTest
 CNetTopologySuite.Geometries.OctagonalEnvelopeA Bounding Container which is in the shape of an octagon.
 CNetTopologySuite.Operation.Buffer.OffsetCurveBuilderComputes 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.
 CNetTopologySuite.Operation.Buffer.OffsetCurveSetBuilderCreates 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.
 CNetTopologySuite.Operation.Buffer.OffsetCurveVertexListA list of the vertices in a constructed offset curve. /summary>
 CNetTopologySuite.Operation.Overlay.Validate.OffsetPointGeneratorGenerates points offset by a given distance from both sides of the midpoint of all segments in a IGeometry. /summary>
 CNetTopologySuite.Operation.Buffer.OldOffsetCurveBuilderComputes the raw offset curve for a single IGeometry component (ring, line or point). /summary>
 CRTools_NTS.Util.OptsA 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.
 ►COracleArrayTypeFactoryBase
 ►COracleCustomTypeBase
 CNetTopologySuite.IO.OracleGeometryReader
 CNetTopologySuite.IO.OracleGeometryWriter
 CNetTopologySuite.Tests.NUnit.Algorithm.OrientationIndexFailureTestTests failure cases of CGAlgorithms.computeOrientation
 CNetTopologySuite.Tests.NUnit.Algorithm.OrientationIndexTest
 CNetTopologySuite.Tests.NUnit.Performance.Operation.Overlay.OverlayNodingStressTest
 CNetTopologySuite.Operation.Overlay.Validate.OverlayResultValidatorValidates 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>
 ►CParseException
 CNetTopologySuite.Samples.Tests.Various.PathFinderA class that manages shortest path computation.
 CNetTopologySuite.Tests.Various.PathFinderTest
 CNetTopologySuite.Tests.NUnit.PclSetup
 ►CNetTopologySuite.Tests.NUnit.Performance.PerformanceTestCaseA 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.
 CNetTopologySuite.Tests.NUnit.Performance.PerformanceTestRunnerRuns PerformanceTestCase classes which contain performance tests.
 CNetTopologySuite.Tests.NUnit.Algorithm.PerturbedGridPolygonBuilderCreates a perturbed, buffered grid and tests a set of points against using two PointInArea classes. /summary> <author>mbdavis</author>
 ►CNetTopologySuite.GeometriesGraph.PlanarGraphThe 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
 ►CNetTopologySuite.Planargraph.PlanarGraphRepresents 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.
 CNetTopologySuite.Operation.Distance3D.PlanarPolygon3DModels 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.
 CNetTopologySuite.Mathematics.Plane3DModels a plane in 3-dimensional Cartesian space.
 CNetTopologySuite.Operation.Overlay.PointBuilderConstructs Points from the nodes of an overlay graph.
 CNetTopologySuite.Operation.Union.PointGeometryUnion
 CNetTopologySuite.Tests.NUnit.Geometries.PointImplTest
 CNetTopologySuite.Tests.NUnit.Algorithm.PointInAreaStressTester
 CNetTopologySuite.Algorithm.PointLocatorComputes the topological relationship (Location) of a single point to a Geometry.
 CNetTopologySuite.Tests.NUnit.Algorithm.PointLocatorTest
 CNetTopologySuite.Operation.Buffer.Validate.PointPairDistanceContains a pair of points and the distance between them. Provides methods to update with a new point pair with either maximum or minimum distance.
 CNetTopologySuite.Algorithm.Distance.PointPairDistanceContains a pair of points and the distance between them.
 CNetTopologySuite.Tests.NUnit.Performance.Operation.Buffer.PolygonBufferStressTestStress-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
 CNetTopologySuite.Operation.Overlay.PolygonBuilderForms Polygons out of a graph of {DirectedEdge}s. The edges to use are marked as being in the result Area.
 CNetTopologySuite.Windows.Forms.PolygonGraphicsPath
 CNetTopologySuite.Samples.Operation.Poligonize.PolygonizeExampleExample of using Polygonizer class to polygonize a set of fully noded linestrings.
 CNetTopologySuite.Operation.Polygonize.PolygonizerPolygonizes a set of IGeometrys which contain linework that represents the edges of a planar graph.
 CNetTopologySuite.Tests.NUnit.Operation.Polygonize.PolygonizeTest
 CNetTopologySuite.Windows.Media.PolygonWpfPathGeometry
 CNetTopologySuite.GeometriesGraph.PositionA Position indicates the position of a Location relative to a graph component (Node, Edge, or Area).
 CNetTopologySuite.IO.PostGis2GeometryHeader
 CNetTopologySuite.Tests.IO.PostGisTestPorted from PostGIS: http://svn.refractions.net/postgis/trunk/java/jdbc/src/examples/TestParser.java
 CNetTopologySuite.Samples.Tests.Various.Precision
 CNetTopologySuite.Samples.Geometries.PrecisionModelExampleAn 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.
 CNetTopologySuite.Tests.NUnit.Geometries.PrecisionModelTest
 CNetTopologySuite.Samples.Lab.Clean.HoleRemover.Predicate
 CNetTopologySuite.Tests.NUnit.Geometries.PredicateShortCircuitTest
 CNetTopologySuite.Geometries.Prepared.PreparedGeometryFactoryA factory for creating IPreparedGeometrys. It chooses an appropriate implementation of PreparedGeometry based on the geoemtric type of the input geometry. /summary>
 CNetTopologySuite.Samples.Tests.Performances.PreparedGeometryFixturesee: https://groups.google.com/d/msg/nettopologysuite/Vdis_LHdH8w/x5r-lSkiL4QJ
 CNetTopologySuite.Tests.NUnit.Performance.Geometries.Prepared.PreparedLineIntersectsPerformanceTest
 CNetTopologySuite.Tests.NUnit.Performance.Geometries.Prepared.PreparedPolygonIntersectsPerformanceTest
 CNetTopologySuite.Tests.NUnit.Geometries.Prepared.PreparedPolygonIntersectsStressTestStress tests PreparedPolygon.Intersects(IGeometry) to confirm it finds intersections correctly. /summary> <author>Martin Davis</author>
 CNetTopologySuite.Geometries.Prepared.PreparedPolygonLineIntersectionComputes the SpatialFunction.Intersection spatial overlay function for a target PreparedLineString relative to other IGeometry classes. /summary>
 CNetTopologySuite.Tests.NUnit.Geometries.Prepared.PreparedPolygonPredicateStressTestStress tests PreparedPolygon for correctness of PreparedPolygon.Contains(IGeometry) and PreparedPolygon.Intersects(IGeometry) operation.
 CNetTopologySuite.Utilities.PriorityQueue< T >A priority queue over a set of IComparable{T} objects. /summary>

Template Parameters
TObjects to add

<author>Martin Davis</author>

 CNetTopologySuite.Tests.NUnit.Utilities.PriorityQueueTest
 CNetTopologySuite.Samples.SimpleTests.Program
 CNetTopologySuite.Triangulate.QuadEdge.QuadEdgeA 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
 CNetTopologySuite.Triangulate.QuadEdge.QuadEdgeSubdivisionA 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
 CNetTopologySuite.Triangulate.QuadEdge.QuadEdgeTriangleModels 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.
 CNetTopologySuite.Triangulate.QuadEdge.QuadEdgeUtil
 CNetTopologySuite.GeometriesGraph.QuadrantOpUtility functions for working with quadrants, which are numbered as follows:
 CNetTopologySuite.Operation.Valid.QuadtreeNestedRingTesterTests whether any of a set of LinearRings are nested inside another ring in the set, using a Quadtree index to speed up the comparisons.
 CNetTopologySuite.Tests.Various.QuadTreeTest
 CNetTopologySuite.Tests.NUnit.Index.QuadtreeTest
 CNetTopologySuite.Utilities.RadiansConverts radians to degress.
 CNetTopologySuite.IO.Tests.RandomGeometryHelper
 CNetTopologySuite.Algorithm.RayCrossingCounterCounts the number of segments crossed by a horizontal ray extending to the right from a given point, in an incremental fashion
 CNetTopologySuite.Operation.Predicate.RectangleContainsOptimized 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.
 CNetTopologySuite.Operation.Predicate.RectangleIntersectsI Implementation of the Intersects spatial predicate optimized for the case where one IGeometry is a rectangle.
 CNetTopologySuite.Tests.NUnit.Operation.Predicate.RectangleIntersectsPerformanceTest
 CNetTopologySuite.Algorithm.RectangleLineIntersectorComputes whether a rectangle intersects line segments.
 CNetTopologySuite.Tests.NUnit.Algorithm.RectangleLineIntersectorTest
 CNetTopologySuite.Tests.NUnit.Geometries.RectanglePredicateSyntheticTest
 CNetTopologySuite.Tests.NUnit.Geometries.RectanglePredicateTest
 CNetTopologySuite.Tests.NUnit.Operation.Relate.RelateBoundaryNodeRuleTest
 CNetTopologySuite.Operation.Relate.RelateComputerComputes 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).
 CNetTopologySuite.Operation.Relate.RelateNodeGraphImplements 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.
 CNetTopologySuite.Tests.NUnit.Operation.Relate.RelateTest
 CNetTopologySuite.Operation.Valid.RepeatedPointTesterImplements the appropriate checks for repeated points (consecutive identical coordinates) as defined in the NTS spec.
 CNetTopologySuite.Algorithm.RobustDeterminantImplements 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
 CNetTopologySuite.Tests.NUnit.Algorithm.RobustLineIntersectionTest
 CNetTopologySuite.Tests.NUnit.Algorithm.RobustLineIntersectorTest
 CNetTopologySuite.Tests.NUnit.Simplify.SameStructureTesterTest if two geometries have the same structure (but not necessarily the same coordinate sequences or adjacencies).
 CNetTopologySuite.Triangulate.SegmentModels a constraint segment in a triangulation. A constraint segment is an oriented straight line segment between a start point and an end point
 CNetTopologySuite.Tests.NUnit.Geometries.SegmentDensifier
 CNetTopologySuite.Operation.Predicate.SegmentIntersectionTesterTests 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.
 CNetTopologySuite.GeometriesGraph.Index.SegmentIntersectorComputes the intersection of line segments, and adds the intersection to the edges containing the segments.
 CNetTopologySuite.Noding.SegmentPointComparatorImplements 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.
 CNetTopologySuite.Tests.NUnit.Noding.SegmentPointComparatorFullTestTest IntersectionSegment::compareNodePosition using an exhaustive set of test cases
 CNetTopologySuite.Tests.NUnit.Noding.SegmentPointComparatorTestTest IntersectionSegment::compareNodePosition
 CNetTopologySuite.Noding.SegmentStringDissolverDissolves a noded collection of ISegmentStrings to produce a set of merged linework with unique segments.
 CNetTopologySuite.Noding.SegmentStringUtilUtility methods for processing ISegmentStrings /summary> <author>Martin Davis</author>
 CNetTopologySuite.Tests.NUnit.IO.SerializabilityTest
 CNetTopologySuite.IO.Tests.ShapeFile.Extended.ShapeDataReaderTests
 CNetTopologySuite.IO.ShapefileThis class is used to read and write ESRI Shapefiles.
 CNetTopologySuite.IO.ShapefileDataWriterA simple test class for write a complete (shp, shx and dbf) shapefile structure.
 CNetTopologySuite.Tests.IO.ShapeFileEncodingTest
 CNetTopologySuite.IO.ShapefileHeaderClass that represents a shape file header record.
 CNetTopologySuite.Tests.IO.ShapeFileInvalidHeaderTest
 ►CNetTopologySuite.IO.Handlers.ShapeHandlerAbstract class that defines the interfaces that other 'Shape' handlers must implement.
 CNetTopologySuite.IO.Handlers.ShapeLocationInFileInfo
 ►CNetTopologySuite.IO.ShapeReaderContains methods for reading a single Geometry in binary ESRI shapefile format.
 CNetTopologySuite.IO.Tests.ShapeFile.Extended.ShapeReaderTests
 ►CNetTopologySuite.IO.ShapeWriterContains methods for writing a single Geometry in binary ESRI shapefile format.
 CNetTopologySuite.Tests.NUnit.Algorithm.ShewchuksDeterminant
 CNetTopologySuite.Geometries.Utilities.ShortCircuitedGeometryVisitorA visitor to IGeometry elements which componets, which allows short-circuiting when a defined condition holds.
 CNetTopologySuite.Precision.SimpleGeometryPrecisionReducerReduces the precision of the coordinates of a Geometry according to the supplied {PrecisionModel}, without attempting to preserve valid topology.
 CNetTopologySuite.Tests.NUnit.Precision.SimpleGeometryPrecisionReducerTest
 CNetTopologySuite.Samples.Geometries.SimpleMethodsExampleAn 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

 CNetTopologySuite.Precision.SimpleMinimumClearanceComputes 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.
 CNetTopologySuite.Operation.Valid.SimpleNestedRingTesterTests whether any of a set of LinearRings are nested inside another ring in the set, using a simple O(n^2) comparison.
 CNetTopologySuite.Tests.NUnit.Performance.Algorithm.SimpleRayCrossingStressTest
 CNetTopologySuite.Tests.NUnit.Index.SIRtreeTest
 CNetTopologySuite.Tests.Various.SlowIntersectionTest
 CNetTopologySuite.Samples.Lab.Clean.SmallHoleRemover
 CNetTopologySuite.Operation.Overlay.Snap.SnapIfNeededOverlayOpPerforms 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.
 CNetTopologySuite.Operation.Overlay.Snap.SnapOverlayOpPerforms 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.
 CNetTopologySuite.Tests.NUnit.Noding.Snaparound.SnapRoundingTestTest Snap Rounding
 CNetTopologySuite.Tests.Performances.SortedListsFixture
 CNetTopologySuite.Index.IntervalRTree.SortedPackedIntervalRTree< T >A static index on a set of 1-dimensional intervals, using an R-Tree packed based on the order of the interval midpoints.
 CNetTopologySuite.Tests.NUnit.Index.SpatialIndexTest
 CNetTopologySuite.Tests.NUnit.Index.SpatialIndexTester
 CNetTopologySuite.Samples.Operation.Poligonize.SplitPolygonExample
 CNetTopologySuite.Triangulate.SplitSegmentModels a constraint segment which can be split in two in various ways, according to certain geometric constraints.
 CNetTopologySuite.Samples.Tests.Various.StackExchangeFixtures
 CRTools_NTS.Util.StreamTokenizerSettingsThis 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.
 CNetTopologySuite.Tests.NUnit.Geometries.Prepared.StressTestHarness
 COpen.Topology.TestRunner.Utility.StringUtil
 ►CSTRtree
 CNetTopologySuite.Tests.NUnit.Index.STRtreeDemo
 CNetTopologySuite.Tests.NUnit.Index.STRtreeTest
 CNetTopologySuite.VersionComparisonTests.StrTreeTestsSummary description for StrTreeTests
 CNetTopologySuite.Planargraph.SubgraphA 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.
 CNetTopologySuite.Index.Sweepline.SweepLineIndexA sweepline implements a sorted index on a set of intervals. It is used to compute all overlaps between the interval in the index.
 CNetTopologySuite.Index.Sweepline.SweepLineInterval
 CNetTopologySuite.Operation.Valid.SweeplineNestedRingTesterTests whether any of a set of LinearRings are nested inside another ring in the set, using a SweepLineIndex index to speed up the comparisons.
 CNetTopologySuite.GeometriesGraph.Index.SweepLineSegment
 CNetTopologySuite.Simplify.TaggedLinesSimplifierSimplifies 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.
 CNetTopologySuite.Simplify.TaggedLineStringRepresents 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.
 CNetTopologySuite.Simplify.TaggedLineStringSimplifierSimplifies a TaggedLineString, preserving topology (in the sense that no new intersections are introduced). Uses the recursive Douglas-Peucker algorithm.
 CNetTopologySuite.IO.Tests.GeoJSON.Test
 CNetTopologySuite.Tests.NUnit.Operation.Buffer.Test
 COpen.Topology.TestRunner.Functions.TestCaseGeometryFunctions
 CNetTopologySuite.Tests.NUnit.Performance.Geometries.Prepared.TestDataBuilder
 CConsoleTestRunner.TestInfoSummary description for TestInfo.
 CConsoleTestRunner.TestOptionsParserSummary description for TestOptionsParser.
 CNetTopologySuite.Tests.NUnit.Performance.Operation.Distance.TestPerfDistanceLinesPoints
 CNetTopologySuite.Tests.XUnit.TestResults
 CConsoleTestRunner.TestRunnerSummary description for TestRunner.
 ►CNetTopologySuite.Tests.NUnit.Performance.ThreadTestCaseBase class for test cases which depend on threading. A common example of usage is to test for race conditions.
 ►CRTools_NTS.Util.TokenToken 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.
 CNetTopologySuite.IO.TopoJsonReaderRepresents a TopoJSON Reader, used to deserialize TopoJSON elements
 CNetTopologySuite.IO.TopoJSON.Fixtures.TopoJsonReaderFixture
 CNetTopologySuite.IO.TopoJsonWriterRepresents a TopoJSON Writer, uesd to serialize TopoJSON elements.
 CNetTopologySuite.IO.TopoJSON.Fixtures.TopoJsonWriterFixture
 CNetTopologySuite.GeometriesGraph.TopologyLocationA TopologyLocation is the labelling of a GraphComponent's topological relationship to a single Geometry.
 CNetTopologySuite.Simplify.TopologyPreservingSimplifierSimplifies 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.

 CNetTopologySuite.Tests.NUnit.Simplify.TopologyPreservingSimplifierTest
 CNetTopologySuite.Operation.Valid.TopologyValidationErrorContains information about the nature and location of a Geometry validation error.
 CNetTopologySuite.IO.Geometries.TopoObject
 CNetTopologySuite.Geometries.TriangleRepresents a planar triangle, and provides methods for calculating various properties of triangles.
 COpen.Topology.TestRunner.Functions.TriangleFunctions
 CNetTopologySuite.Tests.NUnit.Geometries.TriangleTest
 COpen.Topology.TestRunner.Functions.TriangulationFunctions
 CNetTopologySuite.Tests.NUnit.Performance.Mathematics.TriPredicate
 CNetTopologySuite.Operation.Union.UnaryUnionOpUnions a Collection of IGeometrys or a single Geometry (which may be a IGeometryCollection) together. /summary>
 CNetTopologySuite.Tests.NUnit.Operation.Union.UnaryUnionTest
 CNetTopologySuite.Operation.Union.UnionInteractingExperimental code to union MultiPolygons with processing limited to the elements which actually interact. /summary>
 CNetTopologySuite.Samples.Technique.UnionUsingBufferShows 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
 COpen.Topology.TestRunner.Functions.ValidationFunctions
 CNetTopologySuite.Tests.NUnit.Operation.Valid.ValidClosedRingTestTests validating geometries with non-closed rings.
 CNetTopologySuite.Tests.NUnit.Operation.Valid.ValidSelfTouchingRingFormingHoleTestTests 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>
 CNetTopologySuite.Mathematics.Vector3DRepresents a vector in 3-dimensional Cartesian space.
 CNetTopologySuite.Triangulate.VertexTaggedGeometryDataMapperCreates 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.
 CNetTopologySuite.Triangulate.VoronoiDiagramBuilderA 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.
 CNetTopologySuite.Tests.NUnit.Triangulate.VoronoiTestTests Voronoi diagram generation
 CNetTopologySuite.Simplify.VWLineSimplifierSimplifies 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.
 CNetTopologySuite.Simplify.VWSimplifierSimplifies 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
 CNetTopologySuite.Tests.NUnit.Simplify.VWSimplifierTest
 CNetTopologySuite.Tests.NUnit.Operation.Distance3d.WithinDistance3DTest
 CNetTopologySuite.IO.WKBHexFileReaderReads 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.
 CNetTopologySuite.Tests.NUnit.IO.WKBReaderTestTests for reading WKB.
 CNetTopologySuite.Tests.NUnit.IO.WKBTestTests the WKBReader and WKBWriter. Tests all geometries with both 2 and 3 dimensions and both byte orderings.
 CNetTopologySuite.IO.WKTFileReaderReads a sequence of IGeometrys in WKT format from a text file. /summary>
 CNetTopologySuite.Tests.NUnit.IO.WKTReaderExpTestTests the WKTReader with exponential notation.
 CNetTopologySuite.Tests.NUnit.IO.WKTReaderParseErrorTestTests the WKTReader with various errors
 CNetTopologySuite.Tests.NUnit.IO.WKTReaderTestTest for WKTReader
 CNetTopologySuite.Tests.NUnit.IO.WKTWriterTestTest for WKTWriter.
 CNetTopologySuite.Windows.Media.WpfGeometryReaderConverts a WPF WpfGeometry into a IGeometry. /summary> remarks>
 COpen.Topology.TestRunner.XmlTestSummary description for XmlTest.
 COpen.Topology.TestRunner.XmlTestControllerSummary description for XmlTestController.
 COpen.Topology.TestRunner.XmlTestDocumentSummary description for XmlTestDocument.
 COpen.Topology.TestRunner.XmlTestExceptionManagerSummary description for XmlTestExceptionManager.
 COpen.Topology.TestRunner.XmlTestFactorySummary description for XmlTestFactory.
 COpen.Topology.TestRunner.XmlTestInfoSummary description for XmlTestInfo.
 COpen.Topology.TestRunner.XmlTestTimer
 ►CNetTopologySuite.Tests.XUnit.XUnitRunnerA 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