DotSpatial.Topology

Constants representing the dimensions of a point, a curve and a surface. Also, constants representing the dimensions of the empty point and non-empty geometries, and a wildcard dimension meaning "any dimension".

Dimension value of a point (0).

Dimension value of a curve (1).

Dimension value of a surface (2).

Dimension value of a empty point (-1).

Dimension value of non-empty geometries (= {Point, Curve, A}).

Dimension value for any dimension (= {False, True}).

An abreviated list for quick classification

None specified or custom

Point

Line

Polygon

MultiPoint

A geometric angle mesured in degrees or radians the angle will wrap around, so setting larger values will result in an appropriate angle.

The value of 3.14159 or whatever from Math.PI

Creates a new instance of an angle with the radians specified

The angle in radians

Returns a new instance of the Angle class with the same angle as this object.

Angle which has the same values

False for anything that is not an angle. Tests two angles to see if they have the same value.

An object to test. Boolean, true if the angles have the same value.

Gets a hash code

Int hash code

Returns a new angle object with an angle of Value in radians

The double value indicating the angle An Angle structure with the specified value

Returns a double specifying the radian value of the angle

The angle structure to determine the angle of A Double with the angle in radians

Returns true if the two angles are equal to each other.

An angle to compare A second angle. Boolean, true if they are equal.

Returns true if the two angles are equal to each other.

An angle to compare A second angle. Boolean, true if they are equal.

Returns the sum of the two angles, cycling if greater than 2 pi.

An angle to add A second angle to add A new Angle structure equal to the sum of the two angles

Returns the difference of two angles.

An angle to subtract from The angle to subtract A new angle structure with a sum equal to the two angles

Divides angle A by angle B

An angle to divide An angle to divide into A A new angle with the quotient of the division

Multiplies angle A by Angle B.

An angle to multiply A second angle to multiply. A new angle with the product of the two angles.

Returns the mathematical Cos of the angle specified

The Angle to find the cosign of Double, the cosign of the angle specified

Returns the mathematical Sin of the angle specified

The Angle to find the Sin of Double, the Sin of the Angle

Returns the mathematical Tan of the angle specified

The Angle to find the Tan of Double, the Tan of the Angle

Returns the mathematical ATan of the value specified

The Double to find the ATan of Angle, the ATan of the Value specified

Returns the mathematical ACos of the value specified

The Double to find the ACos of Angle, the ACos of the Value specified

Returns the mathematical ASin of the value specified

The Double to find the ASin of Angle, the ASin of the Value specified

Gets or sets the angle in degrees, ranging from -360 to 360

Gets or sets the angle in degrees ranging from 0 to 360

Only allows values from -2PI to 2PI.

Buffer styles.

Specifies a round line buffer end cap endCapStyle (Default).

Specifies a butt (or flat) line buffer end cap endCapStyle.

Specifies a square line buffer end cap endCapStyle.

The types of Precision Model which NTS supports.

Floating precision corresponds to the standard double-precision floating-point representation, which is based on the IEEE-754 standard

Floating single precision corresponds to the standard single-precision floating-point representation, which is based on the IEEE-754 standard

Fixed Precision indicates that coordinates have a fixed number of decimal places. The number of decimal places is determined by the log10 of the scale factor.

A list of DE-9IM row indices clarifying the interior, boundary or exterior.

DE-9IM row index of the interior of the first point and column index of the interior of the second point. Location value for the interior of a point. int value = 0;

DE-9IM row index of the boundary of the first point and column index of the boundary of the second point. Location value for the boundary of a point. int value = 1;

DE-9IM row index of the exterior of the first point and column index of the exterior of the second point. Location value for the exterior of a point. int value = 2;

Used for uninitialized location values. int value = -1;

Standard ordinate index values.

X Ordinate = 0.

Y Ordinate = 1.

Z Ordinate = 2.

M Ordinate = 3.

Extends the class to allow reading values in the BigEndian format.

While BigEndianBinaryReader extends BinaryReader adding methods for reading integer values and double values in the BigEndian format, this implementation overrides methods, such and and more, for reading ByteOrder.BigEndian values in the BigEndian format.

Initializes a new instance of the class.

The stream.

Initializes a new instance of the BEBinaryReader class.

The supplied stream. The character encoding. encoding is null. The stream does not support reading, the stream is null, or the stream is already closed.

Reads a 2-byte signed integer from the current stream using big endian encoding and advances the current position of the stream by two bytes.

A 2-byte signed integer read from the current stream. The stream is closed. An I/O error occurs. The end of the stream is reached.

Reads a 4-byte signed integer from the current stream using big endian encoding and advances the current position of the stream by four bytes.

A 4-byte signed integer read from the current stream. The stream is closed. An I/O error occurs. The end of the stream is reached.

Reads an 8-byte signed integer from the current stream using big endian encoding and advances the current position of the stream by eight bytes.

An 8-byte signed integer read from the current stream. The stream is closed. An I/O error occurs. The end of the stream is reached.

Reads a 4-byte floating point value from the current stream using big endian encoding and advances the current position of the stream by four bytes.

A 4-byte floating point value read from the current stream. The stream is closed. An I/O error occurs. The end of the stream is reached.

Reads an 8-byte floating point value from the current stream using big endian encoding and advances the current position of the stream by eight bytes.

An 8-byte floating point value read from the current stream. The stream is closed. An I/O error occurs. The end of the stream is reached.

Extends the class to allow writing values in the BigEndian format.

While BigEndianBinaryWriter extends adding methods for writing integer values (BigEndianBinaryWriter.WriteIntBE) and double values (BigEndianBinaryWriter.WriteDoubleBE) in the BigEndian format, this implementation overrides methods, such BinaryWriter.Write(Int32) and BinaryWriter.Write(Double)and more, for writing T:ByteOrder.BigEndian values in the BigEndian format.

Initializes a new instance of the class.

The supplied stream. output is null. The stream does not support writing, or the stream is already closed.

Initializes a new instance of the class.

The supplied stream. The character encoding. output or encoding is null. The stream does not support writing, or the stream is already closed.

Writes a two-byte signed integer to the current stream using BigEndian encoding and advances the stream position by two bytes.

The two-byte signed integer to write. The stream is closed. An I/O error occurs.

Writes a four-byte signed integer to the current stream using BigEndian encoding and advances the stream position by four bytes.

The four-byte signed integer to write. The stream is closed. An I/O error occurs.

Writes an eight-byte signed integer to the current stream using BigEndian encoding and advances the stream position by eight bytes.

The eight-byte signed integer to write. The stream is closed. An I/O error occurs.

Writes a four-byte floating-point value to the current stream using BigEndian encoding and advances the stream position by four bytes.

The four-byte floating-point value to write. The stream is closed. An I/O error occurs.

Writes an eight-byte floating-point value to the current stream using BigEndian encoding and advances the stream position by eight bytes.

The eight-byte floating-point value to write. The stream is closed. An I/O error occurs.

Writes a length-prefixed string to this stream in the current encoding of the , and advances the current position of the stream in accordance with the encoding used and the specific characters being written to the stream.

The value to write. The stream is closed. An I/O error occurs. value is null.

Writes a decimal value to the current stream and advances the stream position by sixteen bytes.

The decimal value to write. The stream is closed. An I/O error occurs.

Byte order

Big Endian

Little Endian

The original idea of comming up with a coordinate that used public accessors and an ICoordinate interface was actually quite slow, given that every access point was multiplied across many instances.

An optional place holder for a measure value if needed

The X or horizontal, or longitudinal ordinate

The Y or vertical, or latitudinal ordinate

The Z or up or altitude ordinate

Creates an empty coordinate

Creates a 2D coordinate with NaN for the Z and M values

Creates a new coordinate with the specified values

Creates a new coordinate with the values in X, Y, Z order, or X, Y order.

Constructs a new instance of the coordinate

Creates a new instance of Coordinate

Compares the X, Y and Z values with the specified item. If the Z value is NaN then only the X and Y values are considered

This should be either a Coordiante or an ICoordinate Boolean, true if the two are equal

returns the simple base.GetHashCode

Returns the underlying two dimensional array of coordinates

Returns Euclidean 2D distance from ICoordinate p.

ICoordinate with which to do the distance comparison. Double, the distance between the two locations.

Returns whether the planar projections of the two Coordinates are equal.

The ICoordinate with which to do the 2D comparison. true if the x- and y-coordinates are equal; the Z coordinates do not have to be equal.

Returns true if other has the same values for x, y and z.

The second ICoordiante for a 3D comparison true if other is a ICoordinate with the same values for x, y and z.

Returns the distance that is appropriate for N dimensions. In otherwords, if this point is three dimensional, then all three dimensions will be used for calculating the distance.

The coordinate to compare to this coordinate A double valued distance measure that is invariant to the number of coordinates The number of dimensions does not match between the points.

Returns a string of the form (x, y, z) .

string of the form (x, y, z)

Compares this object with the specified object for order. Since Coordinates are 2.5D, this routine ignores the z value when making the comparison. Returns -1 : this.x lowerthan other.x || ((this.x == other.x) AND (this.y lowerthan other.y)) 0 : this.x == other.x AND this.y = other.y 1 : this.x greaterthan other.x || ((this.x == other.x) AND (this.y greaterthan other.y))

Coordinate with which this Coordinate is being compared. A negative integer, zero, or a positive integer as this Coordinate is less than, equal to, or greater than the specified Coordinate.

If either X or Y is defined as NaN, then this coordinate is considered empty.

Duplicates this coordinate

Overloaded + operator.

Overloaded * operator.

Overloaded - operator.

Overloaded / operator.

Gets a pre-defined coordinate that has double.NaN for all the values.

Gets or sets the double value associated with the specified ordinate index

The zero-based integer index of the ordinate A double value representing a single ordinate

This is not a true length, but simply tests the Z value. If the Z value is NaN then the value is 2. Otherwise this is 3.

Useful utility functions for handling Coordinate arrays.

Finds a in a list of s which is not contained in another list of s.

The s to test. An array of s to test the input points against. A from which is not in , or null.

Compares two arrays in the forward direction of their coordinates, using lexicographic ordering.

Determines which orientation of the array is (overall) increasing. In other words, determines which end of the array is "smaller" (using the standard ordering on ). Returns an integer indicating the increasing direction. If the sequence is a palindrome, it is defined to be oriented in a positive direction.

The array of Coordinates to test. 1 if the array is smaller at the start or is a palindrome, -1 if smaller at the end.

Determines whether two arrays of equal length are equal in opposite directions.

Creates a deep copy of the argument Coordinate array.

Array of Coordinates. Deep copy of the input.

Converts the given of s into a array.

of coordinates. If contains not only s.

Converts the given of s into a array.

of coordinates.

Returns whether Equals returns true for any two consecutive coordinates in the given array.

Array of Coordinates. true if coord has repeated points; false otherwise.

Returns either the given coordinate array if its length is greater than the given amount, or an empty coordinate array.

Length amount. Array of Coordinates. New Coordinate array.

If the coordinate array argument has repeated points, constructs a new array containing no repeated points. Otherwise, returns the argument.

Reverses the coordinates in an array in-place.

Array of Coordinates.

Returns true if the two arrays are identical, both null, or pointwise equal (as compared using Coordinate.Equals).

First array of Coordinates. Second array of Coordinates. true if two Coordinates array are equals; false otherwise

Returns true if the two arrays are identical, both null, or pointwise equal, using a user-defined for s.

An array of s. Another array of s. A for s.

Returns the minimum coordinate, using the usual lexicographic comparison.

Array to search. The minimum coordinate in the array, found using CompareTo.

Shifts the positions of the coordinates until firstCoordinate is first.

Array to rearrange. Coordinate to make first.

Returns the index of in . The first position is 0; the second is 1; etc.

A to search for. A array to search. The position of coordinate, or -1 if it is not found.

Extracts a subsequence of the input array from indices to (inclusive).

The input array. The index of the start of the subsequence to extract. The index of the end of the subsequence to extract. A subsequence of the input array.

A comparator for arrays modulo their directionality. E.g. if two coordinate arrays are identical but reversed they will compare as equal under this ordering. If the arrays are not equal, the ordering returned is the ordering in the forward direction.

Compares two arrays in the forward direction of their coordinates, using lexicographic ordering.

Compares the specified s arrays.

The ICoordinateSequence implementation that Geometrys use by default. In this implementation, Coordinates returned by ToArray and Coordinate are live -- modifications to them are actually changing the CoordinateSequence's underlying data.

The internal representation of a list of coordinates inside a Geometry. There are some cases in which you might want Geometries to store their points using something other than the NTS Coordinate class. For example, you may want to experiment with another implementation, such as an array of x’s and an array of y’s. or you might want to use your own coordinate class, one that supports extra attributes like M-values. You can do this by implementing the ICoordinateSequence and ICoordinateSequenceFactory interfaces. You would then create a GeometryFactory parameterized by your ICoordinateSequenceFactory, and use this GeometryFactory to create new Geometries. All of these new Geometries will use your ICoordinateSequence implementation. An observation on performance: If your ICoordinateSequence is not based on an array of Coordinates, it may incur a performance penalty when its ToArray() method is called because the array needs to be built from scratch.

Returns the ordinate of a coordinate in this sequence. Ordinate indices 0 and 1 are assumed to be X and Y. Ordinates indices greater than 1 have user-defined semantics (for instance, they may contain other dimensions or measure values).

The coordinate index in the sequence. The ordinate index in the coordinate (in range [0, dimension-1]).

Sets the value for a given ordinate of a coordinate in this sequence.

The coordinate index in the sequence. The ordinate index in the coordinate (in range [0, dimension-1]). The new ordinate value.

Returns (possibly copies of) the Coordinates in this collection. Whether or not the Coordinates returned are the actual underlying Coordinates or merely copies depends on the implementation. Notice that if this implementation does not store its data as an array of Coordinates, this method will incur a performance penalty because the array needs to be built from scratch.

Expands the given Envelope to include the coordinates in the sequence. Does not modify the original envelope, but rather returns a copy of the original envelope after being modified.

The envelope use as the starting point for expansion. This envelope will not be modified. The newly created envelope that is the expanded version of the original.

Returns the dimension (number of ordinates in each coordinate) for this sequence.

Direct accessor to an ICoordinate

An integer index in this array sequence An ICoordinate for the specified index

Every time a member is added to, subtracted from, or edited in the sequence, this VersionID is incremented. This doesn't uniquely separate this sequence from other sequences, but rather acts as a way to rapidly track if changes have occured against a cached version.

Increments the version with the understanding that we are using integers. If the user uses too many version, it will cycle around. The statistical odds of accidentally reaching the same value as a previous version should be small enough to prevent conflicts.

Creates a new array sequence dimensioned with exactly 1 coordinate that is empty.

Creates a new array sequence dimensioned with exactly 1 coordinate, which is set to the coordinate

The ICoordinate to use when constructing this sequence

Creates a new CoordinateArraySequence whose members are

The existing list whose members will be copied to the array.

Constructs a sequence based on the given array (the array is not copied).

The coordinate array that will be referenced.

Constructs a sequence of a given size, populated with new Coordinates.

The size of the sequence to create.

Constructs a sequence based on the given array (the array is not copied).

The coordinate array that will be referenced.

Adds a single item to the array. This is very slow for arrays because it has to copy all the values into a new array.

Clears the array, reducing the measure to 1 empty coordinate.

Tests to see if the array contains the specified item

the ICoordinate to test True if the value is in the array.

Creates a deep copy of the object.

The deep copy.

Copies all of the members from this sequence into the specifeid array.

The array of Icoordinates to copy values to. The starting index

Expands the given Envelope to include the coordinates in the sequence. Does not modify the original envelope, but rather returns a copy of the original envelope after being modified.

The envelope use as the starting point for expansion. This envelope will not be modified. The newly created envelope that is the expanded version of the original.

Returns an enumerator object for cycling through each of the various members of the array. BEWARE! This will bypass the VersionID code. Since ICoordinateSequence does not contain the GetEnumerator methods, using an ICoordinateSequence should safely advance the version during changes.

An Enumerator for this array.

The coordinate index in the sequence. The ordinate index in the coordinate (in range [0, dimension-1]).

For arrays, this is very inneficient. This will copy all the members except for the item to a new array.

The item to remove. Boolean, true if a match was found and an item was removed, false otherwise.

Sets the value for a given ordinate of a coordinate in this sequence.

The coordinate index in the sequence. The ordinate index in the coordinate (in range [0, dimension-1]). The new ordinate value.

This method exposes the internal Array of Coordinate Objects.

Returns the string representation of the coordinate array.

Returns the length of the coordinate sequence.

Returns the dimension (number of ordinates in each coordinate) for this sequence.

CoordinateArraySequences are not ReadOnly

Direct accessor to an ICoordinate

An integer index in this array sequence An ICoordinate for the specified index

CoordinateArraySequenceEnumerator

Creates a new instance of CoordinateArraySequenceEnumerator

Does nothing

Advances the enumerator to the next member

Resets the enumerator to the original position

Gets the current member

Creates CoordinateSequences represented as an array of Coordinates.

An object that knows how to build a particular implementation of ICoordinateSequence from an array of Coordinates.

Returns a CoordinateSequence based on the given array; whether or not the array is copied is implementation-dependent.

Coordinates array, which may not be null nor contain null elements

Constructs a new coordinate sequence using a single coordinate.

A single coordinate to be used in a coordinate sequence factory. A valid ICoordinateSequence.

Constructs either an array with 1 member or an empty list, depending on the implementation.

A new seqeunce

This appears to be part of a singleton for a coordinate array sequence factory

Returns a CoordinateArraySequence based on the given array (the array is not copied).

the coordinates, which may not be null nor contain null elements.

Constructs a new coordinate sequence using a single coordinate.

A single coordinate to be used in a coordinate sequence factory. A valid ICoordinateSequence.

Constructs either an array with 1 member or an empty list, depending on the implementation.

A new seqeunce

A lightweight class used to store coordinates on the 2-dimensional Cartesian plane. It is distinct from Point, which is a subclass of Geometry. Unlike objects of type Point (which contain additional information such as an envelope, a precision model, and spatial reference system information), a Coordinate only contains ordinate values and accessor methods. Coordinates are two-dimensional points, with an additional z-ordinate. NTS does not support any operations on the z-ordinate except the basic accessor functions. Constructed coordinates will have a z-ordinate of NaN. The standard comparison functions will ignore the z-ordinate.

Creates a CoordinateF by using the X, Y and Z terms of a FloatVector

Constructs a Coordinate at (x, y, z).

X value. Y value. Z value. Measure value.

Constructs a Coordinate at (x, y, z).

X value. Y value. Z value.

Creates a Coordinate from any ICoordinate Interface

The Vector.IPoint interface to construct a coordinate from

Constructs a Coordinate at (0, 0, NaN).

Constructs a Coordinate at (x, y, NaN).

X value. Y value.

Returns whether the planar projections of the two Coordinates are equal.

ICoordinate with which to do the 2D comparison. true if the x- and y-coordinates are equal; the Z coordinates do not have to be equal.

Returns true if other has the same values for the x and y ordinates. Since Coordinates are 2.5D, this routine ignores the z value when making the comparison.

Coordinate with which to do the comparison. true if other is a Coordinate with the same values for the x and y ordinates.

Coordinate with which this Coordinate is being compared. A negative integer, zero, or a positive integer as this Coordinate is less than, equal to, or greater than the specified Coordinate.

Returns true if other has the same values for x, y and z.

ICoordinate with which to do the 3D comparison. true if other is a ICoordinate with the same values for x, y and z.

Returns a string of the form (x, y, z) .

string of the form (x, y, z)

Create a new object as copy of this instance.

Creates a new ICoordinate copy of this instance

Returns Euclidean 2D distance from ICoordinate p.

ICoordinate with which to do the distance comparison. Double, the distance between the two locations.

Returns the distance that is appropriate for N dimensions. In otherwords, if this point is three dimensional, then all three dimensions will be used for calculating the distance.

The coordinate to compare to this coordinate A double valued distance measure that is invariant to the number of coordinates The number of dimensions does not match between the points.

Return HashCode.

Value from HashCode computation.

Overloaded + operator.

Overloaded * operator.

Overloaded - operator.

Overloaded / operator.

Gets an array of double values for each of the ordinates

Direct access to the coordinate works as a float. If you only have the interface, it must involve conversions to and from a float. This may cause errors if the value being set is outside the range of the float values.

Direct access to the Y coordinate as a float

Z coordinate.

A Measure coordinate

Gets/Sets Coordinates (x, y, z) values.

Gets or sets the double value corresponding to the specific ordinate

For now this is 3D

Gets or sets the values of this CoordinateF using an array of double values

A list of Coordinates, which may be set to prevent repeated coordinates from occuring in the list.

Creates a new instance of a coordiante list

The basic constructor for a CoordinateArray allows repeated points (i.e produces a CoordinateList with exactly the same set of points).

Initial coordinates

Constructs a new list from an array of Coordinates, allowing caller to specify if repeated points are to be removed.

Array of coordinates to load into the list. If false, repeated points are removed.

Returns a deep copy of this collection.

The copied object.

Add an array of coordinates.

Coordinates to be inserted. If set to false, repeated coordinates are collapsed. If false, the array is added in reverse order.

Add an array of coordinates.

Coordinates to be inserted. If set to false, repeated coordinates are collapsed.

Add a coordinate.

Coordinate to be inserted. If set to false, repeated coordinates are collapsed.

Adds the entire range of coordinates, preventing coordinates with the identical 2D signiture from being added immediately after it's duplicate.

Ensure this coordList is a ring, by adding the start point if necessary.

Returns the Coordinates in this collection.

Coordinater as Coordinate[] array.

An ICoordinateSequence based on a list instead of an array.

Creates a new instance of a CoordinateListSequence

If this is a List of ICoordinates, the sequence will be a shallow list. Otherwise, a List is created and shallow copies of each coordinate is added.

Creates a new instance of CoordinateListSequence

The sequence to use

Adds an item to the end of the CoordinateList

An ICoordinate to add

Clears the list entirely.

Creates a deep copy of this object

CoordinateListSequence

Tests wheather or not the specified ICoordinate is contained in the list.

An ICoordinate to test Boolean, true if the list contains the item.

Copies all the members of this list into the specified array.

The array to copy values to. The 0 based integer index in the array at which copying begins

Expands the given Envelope to include the coordinates in the sequence. Does not modify the original envelope, but rather returns a copy of the original envelope after being modified.

The envelope use as the starting point for expansion. This envelope will not be modified. The newly created envelope that is the expanded version of the original.

Obtains an enumerator for cycling through the list. BEWARE! This will return an underlying list enumerator, and so code that uses a foreach process or an enumerator will bypass the Version incrementing code.

An Enumerator object for cycling through the list.

Gets a specific X, Y or Z value depending on the index specified and the ordinate specified

Removes the specified ICoordinate from the list.

An ICoordinate that should be removed from the list Boolean, true if the item was successfully removed.

Sets a specific X, Y or Z value depending on the index specified and the ordinate specified

Copies all the members to an ICoordiante[]

Gets an integer representing the number of ICoordinates currently stored in this list

This always returns 0

The CoordinateListSequence is not readonly

Direct accessor to an ICoordinate

An integer index in this array sequence An ICoordinate for the specified index

This only works as long as an enumeration is not used on the CoordinateListSequence. Since ICoordinateSequence does not support a GetEnumerator object, as long as you are using an ICoordinateSequence interface, VersionID should work.

Creates CoordinateSequences represented as an array of Coordinates.

Creates an instance of the CoordinateListSequenceFactory

Returns a CoordinateArraySequence based on the given array (the array is not copied).

the coordinates, which may not be null nor contain null elements.

Creates a new CoordinateListSequence and populates it with a single coordinate.

CoordinateMismatchException

Creates a new instance of CoordinateMismatchException

Class containing static methods for conversions between Dimension values and characters.

Converts the dimension value to a dimension symbol, for example, True => 'T'

Number that can be stored in the IntersectionMatrix. Possible values are True, False, Dontcare, 0, 1, 2. Character for use in the string representation of an IntersectionMatrix. Possible values are T, F, *, 0, 1, 2.

Converts the dimension symbol to a dimension value, for example, '*' => Dontcare

Character for use in the string representation of an IntersectionMatrix. Possible values are T, F, *, 0, 1, 2. Number that can be stored in the IntersectionMatrix. Possible values are True, False, Dontcare, 0, 1, 2.

This is enumerates not only the specific types, but very specifically that the types are the Topology variety, and not simply the vector variety

A non-geometry rectangle that strictly shows extents

A collective group of geometries

A closed linestring that doesn't self intersect

Any linear collection of points joined by line segments

A collection of independant LineStrings that are not connected

A Grouping of points

A Collection of unconnected polygons

A single coordinate location

At least one Linear Ring shell with any number of linear ring "holes"

Any other type

Shapefile Shape types enumeration

Null Shape

Point

LineString

Polygon

MultiPoint

PointMZ

PolyLineMZ

PolygonMZ

MultiPointMZ

PointM

LineStringM

PolygonM

MultiPointM

MultiPatch

PointZ

LineStringZ

PolygonZ

MultiPointZ

Field Types

Integer

Integer List

Real

Real List

String

String List

Wide String

Side String List

Binary

Date

Time

DateTime

Invalid

Vector Geometry Types

Unknown

Well Known Binary Point

Well Known Binary LineString

Well Known Binary Polygon

Well Known Binary MultiPoint

Well Known Binary MultiLineString

Well Known Binary MultiPolygon

Well Known Binary Geometry Collection

Well Known Binary Linear Ring /* non-standard, just for createGeometry() */

Well Known Binary Point with Z value

Well Known Binary Line String with Z values

Well Known Binary Polygon with Z values

Well Known Binary MultiPoint with Z values

Well Known Binary LineString with z values

Well Known Binary MultiPolygon with z values

Defines a rectangular region of the 2D coordinate plane. It is often used to represent the bounding box of a Geometry, e.g. the minimum and maximum x and y values of the Coordinates. Notice that Envelopes support infinite or half-infinite regions, by using the values of Double.PositiveInfinity and Double.NegativeInfinity. When Envelope objects are created or initialized, the supplies extent values are automatically sorted into the correct order.

An IRectangle is not as specific to being a geometry, and can apply to anything as long as it is willing to support a double valued height, width, X and Y value.

Gets or sets the difference between the maximum and minimum y values. Setting this will change only the minimum Y value, leaving the Top alone

max y - min y, or 0 if this is a null Envelope.

Gets or Sets the difference between the maximum and minimum x values. Setting this will change only the Maximum X value, and leave the minimum X alone

max x - min x, or 0 if this is a null Envelope.

In the precedent set by controls, envelopes support an X value and a width. The X value represents the Minimum.X coordinate for this envelope.

In the precedent set by controls, envelopes support a Y value and a height. the Y value represents the Top of the envelope, (Maximum.Y) and the Height represents the span between Maximum and Minimum Y.

Creates a copy of the current envelope.

An IEnvelope Interface that is a duplicate of this envelope

Sets maxx to a value less than minx usually, maxx = -1 and minx = 0, maxy = -1 and miny = 0

True only if the M coordinates are not NaN and the max is greater than the min.

Boolean

True only of the Z ordinates are not NaN and the max is greater than the min.

Boolean

Because the envelope class attempts to protect users from accidentally manipulating the minimum/maximum conditions in an undesirable way, the init method should effectively initialize the existing envelope based on the new coordinates. This is how values are "Set" for the envelope. It is expected that this method will do a check to prevent larger values from being assigned to "maximum".

The first coordinate to test the second coordinate to test

This is a coordinate defining the minimum bound in any number of dimensions as controlled by NumOrdinates.

This is a coordinate defining the maximum bound in any number of dimensions as controlled by NumOrdinates.

Gets the number of ordinates that define both coordinates of this envelope.

Returns true if this Envelope is a "null" envelope.

true if this Envelope is uninitialized or is the envelope of the empty point. This is usually defined as having a maxx less than a minx, like maxx = -1 and minx = 0.

Occurs when there is a basic change in the envelope.

Creates a null Envelope.

Creates an Envelope for a region defined by maximum and minimum values.

The first x-value. The second x-value. The first y-value. The second y-value.

Creates an Envelope for a region defined by maximum and minimum values.

The first x-value. The second x-value. The first y-value. The second y-value. The first z-value. The second z-value.

Creates an Envelope for a region defined by an Vector.IEnvelope

The IEnvelope to create an envelope from

Creates an Envelope for a region defined by two Coordinates.

The first Coordinate. The second Coordinate.

Creates an Envelope for a region defined by a single Coordinate.

The Coordinate.

This is a special constructor. This will not fire the OnEnvelopeChanged event, and expects values to be ordered as: XMin, XMax, YMin, YMax, ZMin, ZMax, higher dimenions... This constructor.

The ordinal extents. The minimum m value. The max M value.

This is a special constructor. This will not fire the OnEnvelopeChanged event, and expects values to be ordered as: XMin, XMax, YMin, YMax, ZMin, ZMax, higher dimenions... This constructor sets M bounds to be 0.

The ordinal extents.

Initialize an Envelope of any dimension for a region defined by two Coordinates. The number of ordinates (dimension) of the coordinates must match. M values will also be considered.

The first Coordinate. The second Coordinate.

This initializes the values without passing any coordinates and creates the default, 2D null envelope.

This is an internal method forcing assignments to the internal coordinates

The coordinate to use for the minimum in X, Y, Z etc. The coordinate to use for the maximum in X, Y, Z etc.

Initialize to a null Envelope.

Initialize an Envelope for a region defined by maximum and minimum values.

The first x-value. The second x-value. The first y-value. The second y-value.

This will set all 3 dimensions. Be warned, the Z dimensions are just place holders for any topology opperations and do not have any true functionality. Whichever is smaller becomes the minimum and whichever is larger becomes the maximum.

An X coordinate Another X coordinate A Y coordinate Another Y coordinate A Z coordinate Another Z coordinate

Initialize an Envelope for a region defined by a single Coordinate.

The Coordinate.

Initialize an Envelope from an existing Envelope.

The Envelope to initialize from.

True only if the M coordinates are not NaN and the max is greater than the min.

Boolean

True only of the Z ordinates are not NaN and the max is greater than the min.

Boolean

Creates a copy of the current envelope.

An object satisfying ICloneable

Makes this Envelope a "null" envelope.

Internaly, envelopes that vioate that sacred criteria of min being less than max will be counted as a null case

Creates a copy of the current envelope.

An IEnvelope Interface that is a duplicate of this envelope

Test the point q to see whether it intersects the Envelope defined by p1-p2.

One extremal point of the envelope. Another extremal point of the envelope. Point to test for intersection. true if q intersects the envelope p1-p2.

Test the envelope defined by p1-p2 for intersection with the envelope defined by q1-q2

One extremal point of the envelope Point. Another extremal point of the envelope Point. One extremal point of the envelope Q. Another extremal point of the envelope Q. true if Q intersects Point

Generates a string form of this envelope.

This should not be an extension method because it overrides ToString.

Fires the EnvelopeChanged event

Specifies that this is in fact an envelope

Gets the Horizontal boundaries in geographic coordinates

Gets the vertical boundaries in geographic coordinates

Gets the minimum coordinate

Gets the maximum coordinate

Gets the number of ordinates for this envelope.

Returns true if this Envelope is a "null" envelope.

true if this Envelope is uninitialized or is the envelope of the empty point.

Gets or sets the difference between the maximum and minimum y values. Setting this will only change the _yMin value (leaving the top alone)

max y - min y, or 0 if this is a null Envelope. To resemble the precedent set by the dot net framework controls, this is left as a property

Gets or Sets the difference between the maximum and minimum x values. Setting this will change only the Maximum X value, and leave the minimum X alone

max x - min x, or 0 if this is a null Envelope.

Gets or sets the Left extent of the envelope, keeping the width the same. In the precedent set by controls, envelopes support an X value and a width. The X value represents the Minimum.X coordinate for this envelope.

Gets or sets the Y coordinate for the top of the envelope. (YMax) In the precedent set by controls, envelopes support a Y value and a height. the Y value represents the Top of the envelope, (Maximum.Y) and the Height represents the span between Maximum and Minimum Y.

Occurs when there is a basic change in the envelope.

My concept for the Envelope is that there are several methods that are derived calculations. These are so straight forward that it is unlikey that "new" implementations of those derived values will be needed or wanted. However, we want lots of different kinds of things to be able to "become" an envelope with a minimum of fuss.

Calculates the area of this envelope. Because the word Area, like Volume, is dimension specific, this method only looks at the X and Y ordinates, and requires at least 2 ordinates.

The IEnvelope to use with this method The 2D area as a double value.

Gets a linear ring built clockwise around the border, starting from the TopLeft.

The IEnvelope to use with this method

Gets an array of 4 line segments working clockwise from the top segment.

The IEnvelope to use with this method

Gets the minY, which is Y - Height.

The IEnvelope that this calculation is for.

Gets an ILineSegment from the top right corner to the bottom right corner

The IEnvelope to use with this method

Gets the bottom left corner of this rectangle as a 2D coordinate.

The IEnvelope that this calculation is for. An ICoordinate at the lower left corner of this rectangle

Gets the bottom right corner of this rectangle as a 2D coordinate

The IEnvelope that this calculation is for. An ICoordinate at the lower right corner of this rectangle

Gets the coordinate defining the center of this envelope in all of the dimensions of this envelope.

The IEnvelope to find the center for An ICoordinate

Gets the left value for this rectangle. This should be the X coordinate, but is added for clarity.

The IEnvelope that this calculation is for.

Gets an ILineSegment from the bottom left to the top left corners

The IEnvelope that is being extended by this method

Gets the right value, which is X + Width.

The IEnvelope that this calculation is for.

Gets an ILineSegment from the bottom right corner to the bottom left corner

The IEnvelope to use with this method

Converts this envelope into a linear ring.

The IEnvelope to use with this method A Linear ring describing the border of this envelope.

Gets an ILineSegment from the top left to the top right corners

The IEnvelope to use with this method

Calculates the TopLeft 2D coordinate from this envelope.

The IEnvelope to use with this method

Technically an Evelope object is not actually a geometry. This creates a polygon from the extents.

The IEnvelope to use with this method A Polygon, which technically qualifies as an IGeometry

Calcualte the TopRight 2D Coordinate from this envelope

The IEnvelope to use with this method An ICoordinate in the position of maximum X, Maximum Y

Changes the envelope extent by the specified amount relative to it's current extent in that dimension (preserving the aspect ratio). So Zoom(10) on a 100 unit wide envelope creates a 110 unit wide envlope, while Zoom(-10) on a 100 unit wide envelope creates a 90 unit wide envelope. Zoom(-100) on an envelope makes it 100% smaller, or effectively a point. Tragically, a point cannot be "zoomed" back in, so a check should be used to ensure that the envelope is not currently a point before attempting to zoom in.

The IEnvelope that this zoom method modifies Positive 50 makes the envelope 50% larger Negative 50 makes the envelope 50% smaller perCent = -50 compact the envelope a 50% (make it smaller). perCent = 200 enlarge envelope by 2.

Returns a new envelope that is a copy of this envelope, but modified to include the specified coordinate.

Calculates the union of the current box and the given box.

Moves the envelope to the indicated coordinate.

The IEnvelope to use with this method The new center coordinate.

Resizes the envelope to the indicated point.

The IEnvelope to use with this method The new width. The new height.

Moves and resizes the current envelope.

The IEnvelope to use with this method The new centre coordinate. The new width. The new height.

This handles setting the center and scale in N dimensions. The size is equivalent to the span in each dimension, while the center is the central position in each dimension. The envelope will have values in each dimension where either the existing envelope or both the specified center and size values have been specified. If only the existing envelope and a size is specified for dimension 3, for example, the existing center will be used.

The envelope to modify The center position. This can also be null. The size (or span) in each dimension. This can also be null.

Despite the naming of the extents, this will force the larger of the two x values to become Xmax etc.

The IEnvelope to use with this method An X coordinate A Y coordinate A Z coordinate Another X coordinate Another Y coordinate Another Z coordinate

The two dimensional overload for consistency with other code. Despite the names, this will force the smallest X coordinate given to become maxX.

The IEnvelope to use with this method An X coordinate A Y coordinate Another X coordinate Another Y coordinate

Gets the maxY value, which should be Y.

The IEnvelope that this calculation is for. The double value representing the Max Y value of this rectangle

Translates this envelope by given amounts in the X and Y direction.

The IEnvelope to use with this method The amount to translate along the X axis. The amount to translate along the Y axis.

Translates the envelope by given amounts up to the minimum dimension between the envelope and the shift coordinate. (e.g., A 2D envelope will only be shifted in 2 dimensions because it has no Z, while a 2D coordinate can only shift a cube based on the X and Y positions, leaving the Z info alone.

The IEnvelope to use with this method This does nothing to a "NULL" envelope

Overlaps is defined as intersecting, but having some part of each envelope that is also outside of the other envelope. Therefore it would amount to saying "Intersects And Not Contains And Not Within"

The IEnvelope to use with this method

For a point, or coordinate, this is a degenerate case and will simply perform an intersection test instead.

The IEnvelope to use with this method

For a point, or coordinate, this is a degenerate case and will simply perform an intersection test instead.

The IEnvelope to use with this method The x coordinate The y coordinate Boolean, true if the specified point intersects with this envelope

Evaluates if the specified coordinate is found inside or on the border. This will test all the dimensions shared by both the envelope and point.

Returns true if the given point lies in or on the envelope.

The IEnvelope that this is for the x-coordinate of the point which this Envelope is being checked for containing. the y-coordinate of the point which this Envelope is being checked for containing. true if (x, y) lies in the interior or on the boundary of this Envelope.

Returns true if the other IEnvelope is within this envelope in all dimensions. If the boundaries touch, this will true. This will test the number of dimensions that is the smallest dimensionality. This will ignore M values.

The first envelope (this object when extending) the Envelope which this Envelope is being checked for containing. true if other is contained in this Envelope.

Computes the distance between this and another Envelope. The distance between overlapping Envelopes is 0. Otherwise, the distance is the hyper Euclidean distance between the closest points. M values are ignored, but every dimension is considered, up to the minimum of the number of ordinates between the two envelopes. Use Distance with a dimension specified to force 2D distance calculations.

The first envelope (this object when extending) The other envelope to calculate the distance to The distance between this and another Envelope. Null cases produce a distance of -1

Sometimes only two dimensions are important, and the full dimensionality is not needed. The Distance 2D performs the same distance check but only in X and Y, regardless of how many dimensions exist in the envelopes. Both envelopes should have at least two ordinates however. (Not a criteria of the Distance() method)

The first envelope (this object when extending) The other envelope to calculate the distance to

Calculates the distance specifically in 3D, even if the envelope exists in higher dimensions. The NumOrdinates of both envelopes must be at least 3.

The first envelope (this object when extending) The other envelope to calculate the distance to

Uses the specified distance to expand the envelope by that amount in all dimensions.

Uses the dimensions of the specified distances coordinate to specify the amount to expand the envelopes in each ordinate. This will apply the method to the minimum dimensions between the distances coordinate and this envelope. (eg. A 2D distances coordinate will not affect Z values in the envelope).

The first envelope (this object when extending) The distance to expand the envelope.

Expands this envelope by a given distance in all directions. Both positive and negative distances are supported.

The first envelope (this object when extending) The distance to expand the envelope along the the X axis. The distance to expand the envelope along the the Y axis.

Enlarges the boundary of the Envelope so that it contains (p). Does nothing if (p) is already on or within the boundaries. This executes to the minimum of dimensions between p and this envelope.

The first envelope (this object when extending) The Coordinate.

Enlarges the boundary of the Envelope so that it contains (x, y). Does nothing if (x, y) is already on or within the boundaries.

The first envelope (this object when extending) The value to lower the minimum x to or to raise the maximum x to. The value to lower the minimum y to or to raise the maximum y to.

Enlarges the boundary of the Envelope so that it contains other. Does nothing if other is wholly on or within the boundaries.

The first envelope (this object when extending) the Envelope to merge with.

Returns the intersection of the specified segment with this bounding box. If there is no intersection, then this returns null. If the intersection is a corner, then the LineSegment will be degenerate, that is both the coordinates will be the same. Otherwise, the segment will be returned so that the direction is the same as the original segment.

The IEnvelope to use with this method The LineSegment to intersect. An ILineSegment that is cropped to fit within the bounding box.

Finds an envelope that represents the intersection between this envelope and the specified IEnvelope. The number of dimensions of the returned envelope is the maximum of the NumOrdinates between the two envelopes, since a 2D envelope will only constrain a cube in 2 dimensions, and allow the z bounds to remain unaltered.

The IEnvelope that is being extended by this method An IEnvelope to compare against an IEnvelope that bounds the intersection area

Using an envelope intersection has some optimizations by checking against the envelope of the geometry. In the worst case scenario, the envelope crops the geometry, and a new geometry is created. This will be much faster if the envelope contains the geometries envelope, however, simply returning the original geometry.

The IEnvelope that is being extended by this method A geometric intersection against the area of this envelope A geometry, cropped to the space of this envelope if necessary.

Check if the point p overlaps (lies inside) the region of this Envelope.

The IEnvelope that is being extended by this method the Coordinate to be tested. true if the point overlaps this Envelope.

Check if the point (x, y) overlaps (lies inside) the region of this Envelope.

The IEnvelope that is being extended by this method the x-ordinate of the point. the y-ordinate of the point. true if the point overlaps this Envelope.

This should only be used if the Intersection is not actually required because it uses the Intersection method and returns false if the return value is null.

The IEnvelope that is being extended by this method The segment to be tested against this envelope. The line segment to compare against.

Tests for intersection (any overlap) between the two envelopes. In cases of unequal dimensions, the smaller dimension is used (e.g., if a 2D rectangle doesn't intersect a cube in its own plane, this would return false.)

The IEnvelope that is being extended by this method the Envelope which this Envelope is being checked for overlapping. true if the Envelopes overlap.

EnumerableEM

cycles through any strong typed collection where the type implements ICLoneable and clones each member, inserting that member into the new list.

The type of the values in the list. The original enumerable collection of type T. A deep copy of the list.

A Generic Safe Casting method that should simply exist as part of the core framework

The type of the member to attempt to cast to. The original object to attempt to System.Convert. An output variable of type T.

InsufficientDimensionsException

Creates a new instance of InsufficientDimensionsException

Creates a new instance of InsufficientDimesionsException, but specifies the name of the argument, or a similar string like "both envelopes".

The string name of the argument to introduce in to exception message

IFloatVector3

Copies the X, Y and Z values from the CoordinateF without doing a conversion.

X, Y Z

Creates a new FloatVector3 with the specified values

X Y Z

Uses the X, Y and Z values from the coordinate to create a new FloatVector3

The coordinate to obtain X, Y and Z values from

tests to see if the specified object has the same X, Y and Z values

Not sure what I should be doing here since Int can't really contain this much info very well

Adds all the scalar members of the the two vectors

Left hand side Right hand side

Adds the specified v

A FloatVector3 to add to this vector

Subtracts all the scalar members of the the two vectors

Left hand side Right hand side

Subtracts the specified value

A FloatVector3

Returns the Cross Product of two vectors lhs and V

Vector, the first input vector Vector, the second input vector A FloatVector3 containing the cross product of lhs and V

Multiplies all the scalar members of the the two vectors

Left hand side Right hand side

Multiplies the source vector by a scalar.

Multiplies this vector by a scalar value.

The scalar to multiply by

Normalizes the vectors

Adds the vectors lhs and V using vector addition, which adds the corresponding components

One vector to be added A second vector to be added The sum of the vectors

Tests two float vectors for equality.

The left hand side FloatVector3 to test. The right hand side FloatVector3 to test. Returns true if X, Y and Z are all equal.

Tests two float vectors for inequality.

The left hand side FloatVector3 to test. The right hand side FloatVector3 to test. Returns true if any of X, Y and Z are unequal.

Returns the Cross Product of two vectors lhs and rhs

Vector, the first input vector Vector, the second input vector A FloatVector3 containing the cross product of lhs and V

Divides the components of vector lhs by the respective components ov vector V and returns the resulting vector.

FloatVector3 Dividend (Numbers to be divided) FloatVector3 Divisor (Numbers to divide by) A FloatVector3 quotient of lhs and V To prevent divide by 0, if a 0 is in V, it will return 0 in the result

Multiplies each component of vector lhs by the Scalar value

A vector representing the vector to be multiplied Double, the scalar value to mulitiply the vector components by A FloatVector3 representing the vector product of vector lhs and the Scalar

Returns the Inner Product also known as the dot product of two vectors, lhs and V

The input vector The vector to take the inner product against lhs a Double containing the dot product of lhs and V

Multiplies the vectors lhs and V using vector multiplication, which adds the corresponding components

A scalar to multpy to the vector A vector to be multiplied The scalar product for the vectors

Multiplies each component of vector lhs by the Scalar value

A vector representing the vector to be multiplied Double, the scalar value to mulitiply the vector components by A FloatVector3 representing the vector product of vector lhs and the Scalar

Subtracts FloatVector3 V from FloatVector3 lhs

A FloatVector3 to subtract from A FloatVector3 to subtract The FloatVector3 difference lhs - V

Gets the length of the vector

Gets the square of length of this vector

Converts a Well-Known Binary byte data to a Geometry.

Initialize reader with a standard GeometryFactory.

Initialize reader with the given GeometryFactory.

Geometry builder.

Basic implementation of Geometry. Clone returns a deep copy of the object. Binary Predicates: Because it is not clear at this time what semantics for spatial analysis methods involving GeometryCollections would be useful, GeometryCollections are not supported as arguments to binary predicates (other than ConvexHull) or the Relate method. Set-Theoretic Methods: The spatial analysis methods will return the most specific class possible to represent the result. If the result is homogeneous, a Point, LineString, or Polygon will be returned if the result contains a single element; otherwise, a MultiPoint, MultiLineString, or MultiPolygon will be returned. If the result is heterogeneous a GeometryCollection will be returned. Representation of Computed Geometries: The SFS states that the result of a set-theoretic method is the "point-set" result of the usual set-theoretic definition of the operation (SFS 3.2.21.1). However, there are sometimes many ways of representing a point set as a Geometry. The SFS does not specify an unambiguous representation of a given point set returned from a spatial analysis method. One goal of NTS is to make this specification precise and unambiguous. NTS will use a canonical form for Geometrys returned from spatial analysis methods. The canonical form is a Geometry which is simple and noded: Simple means that the Geometry returned will be simple according to the NTS definition of IsSimple. Noded applies only to overlays involving LineStrings. It means that all intersection points on LineStrings will be present as endpoints of LineStrings in the result. This definition implies that non-simple geometries which are arguments to spatial analysis methods must be subjected to a line-dissolve process to ensure that the results are simple. Constructed Points And The Precision Model: The results computed by the set-theoretic methods may contain constructed points which are not present in the input Geometry s. These new points arise from intersections between line segments in the edges of the input Geometrys. In the general case it is not possible to represent constructed points exactly. This is due to the fact that the coordinates of an intersection point may contain twice as many bits of precision as the coordinates of the input line segments. In order to represent these constructed points explicitly, NTS must truncate them to fit the PrecisionModel. Unfortunately, truncating coordinates moves them slightly. Line segments which would not be coincident in the exact result may become coincident in the truncated representation. This in turn leads to "topology collapses" -- situations where a computed element has a lower dimension than it would in the exact result. When NTS detects topology collapses during the computation of spatial analysis methods, it will throw an exception. If possible the exception will report the location of the collapse.

and are not overridden, so that when two topologically equal Geometries are added to Collections and Dictionaries, they remain distinct. This behaviour is desired in many cases.

This has the methods and properties associated with any topology

Supports the specific methods associated with relationships, usually returning a boolean style test if the relationship is true.

Contains

Returns true if other.within(this) returns true.

The Geometry with which to compare this Geometry. true if this Geometry contains other. CoveredBy

Returns true if this geometry is covered by the specified geometry. The CoveredBy predicate has the following equivalent definitions: - Every point of this geometry is a point of the other geometry. - The DE-9IM Intersection Matrix for the two geometries is T*F**F*** or *TF**F*** or **FT*F*** or **F*TF***. - g.Covers(this) (CoveredBy is the inverse of Covers). Notice the difference between CoveredBy and Within: CoveredBy is a more inclusive relation.

The Geometry with which to compare this Geometry. true if this Geometry is covered by . Covers

Returns true if this geometry covers the specified geometry. The Covers predicate has the following equivalent definitions: - Every point of the other geometry is a point of this geometry. - The DE-9IM Intersection Matrix for the two geometries is T*****FF* or *T****FF* or ***T**FF* or ****T*FF*. - g.CoveredBy(this) (Covers is the inverse of CoveredBy). Notice the difference between Covers and Contains: Covers is a more inclusive relation. In particular, unlike Contains it does not distinguish between points in the boundary and in the interior of geometries.

For most situations, Covers should be used in preference to Contains. As an added benefit, Covers is more amenable to optimization, and hence should be more performant. The Geometry with which to compare this Geometry true if this Geometry covers Crosses

Returns true if the DE-9IM intersection matrix for the two Geometrys is T*T****** (for a point and a curve, a point and an area or a line and an area) 0******** (for two curves).

The Geometry with which to compare this Geometry. true if the two Geometrys cross. For this function to return true, the Geometry s must be a point and a curve; a point and a surface; two curves; or a curve and a surface. Disjoint

Returns true if the DE-9IM intersection matrix for the two Geometrys is DE-9IM: FF*FF****.

The Geometry with which to compare this Geometry. true if the two Geometrys are disjoint. Intersects

Returns true if disjoint returns false.

The Geometry with which to compare this Geometry. true if the two Geometrys intersect. Overlaps

Returns true if the DE-9IM intersection matrix for the two Geometrys is T*T***T** (for two points or two surfaces) 1*T***T** (for two curves).

The Geometry with which to compare this Geometry. true if the two Geometrys overlap. For this function to return true, the Geometry s must be two points, two curves or two surfaces. Relate

Returns true if the elements in the DE-9IM intersection matrix for the two Geometrys match the elements in intersectionPattern , which may be: 0 1 2 T ( = 0, 1 or 2) F ( = -1) * ( = -1, 0, 1 or 2) For more information on the DE-9IM, see the OpenGIS Simple Features Specification.

The Geometry with which to compare this Geometry. The pattern against which to check the intersection matrix for the two Geometrys. true if the DE-9IM intersection matrix for the two Geometrys match intersectionPattern.

Returns the DE-9IM intersection matrix for the two Geometrys.

The Geometry with which to compare this Geometry A matrix describing the intersections of the interiors, boundaries and exteriors of the two Geometrys. Touches

Returns true if the DE-9IM intersection matrix for the two Geometrys is FT*******, F**T***** or F***T****.

The Geometry with which to compare this Geometry. true if the two Geometrys touch; Returns false if both Geometrys are points. Within

Returns true if the DE-9IM intersection matrix for the two Geometrys is T*F**F***.

The Geometry with which to compare this Geometry. true if this Geometry is within other.

An interface for supporting the functions specific to geometry overlay opperations

Difference

Returns a Geometry representing the points making up this Geometry that do not make up other. This method returns the closure of the resultant Geometry.

The Geometry with which to compute the difference. The point set difference of this Geometry with other. Intersection

Returns a Geometry representing the points shared by this Geometry and other.

The Geometry with which to compute the intersection. The points common to the two Geometrys. SymmetricDifference

Returns a set combining the points in this Geometry not in other, and the points in other not in this Geometry. This method returns the closure of the resultant Geometry.

The Geometry with which to compute the symmetric difference. The point set symmetric difference of this Geometry with other. Union

Returns a Geometry representing all the points in this Geometry and other.

The Geometry with which to compute the union. A set combining the points of this Geometry and the points of other.

This is a lightweight version of the components that represent the strictly data related commands.

This returns the index'th BasicGeometry where index is between 0 and NumGeometries - 1. If there is only one geometry, this will return this object.

An integer index between 0 and NumGeometries - 1 specifying the basic geometry A BasicGeometry representing only the specific sub-geometry specified

Returns the string that is the valid GML markup string.

A String containing the valid GML

Returns the Well-known Binary representation of this Geometry. For a definition of the Well-known Binary format, see the OpenGIS Simple Features Specification.

The Well-known Binary representation of this Geometry. ToString

Returns the Well-known Text representation of this Geometry. For a definition of the Well-known Text format, see the OpenGIS Simple Features Specification.

The Well-known Text representation of this Geometry.

Forces the cached envelope to be re-calculated using the coordinates.

Coordinates

Using an IList guarantees that we can access indexed coordinates, but the actual implementation can be either in the form of an array or a list.

Returns this Geometry's bounding box. If this Geometry is the empty point, returns an empty Point. If the Geometry is a point, returns a non-empty Point. Otherwise, returns a Polygon whose points are (minx, miny), (maxx, miny), (maxx, maxy), (minx, maxy), (minx, miny).

NumGeometries

Returns the number of Geometries in a Geometry Collection, or 1, if the geometry is not a collection

NumPoints

Returns the count of this geometry's vertices. The geometries contained by composite geometries must be geometries. That is, they must implement NumPoints.

Clarifies the subtype of geometry in string format in accordance with OGC convenction, but most internal identification simply uses the type identification.

Specifies either a Point, Line, Polygon or Empty feature type for simple flow control

Performs an operation with or on this Geometry's coordinates. If you are using this method to modify the point, be sure to call GeometryChanged() afterwards. Notice that you cannot use this method to modify this Geometry if its underlying CoordinateSequence's Get method returns a copy of the Coordinate, rather than the actual Coordinate stored (if it even stores Coordinates at all).

The filter to apply to this Geometry's coordinates

Performs an operation with or on this Geometry and its subelement Geometrys (if any). Only GeometryCollections and subclasses have subelement Geometry's.

The filter to apply to this Geometry (and its children, if it is a GeometryCollection).

Performs an operation with or on this Geometry and its component Geometry's. Only GeometryCollections and Polygons have component Geometry's; for Polygons they are the LinearRings of the shell and holes.

The filter to apply to this Geometry.

Returns a buffer region around this Geometry having the given width. The buffer of a Geometry is the Minkowski sum or difference of the Geometry with a disc of radius distance.

The width of the buffer, interpreted according to the PrecisionModel of the Geometry. All points whose distance from this Geometry are less than or equal to distance. Buffer

Returns a buffer region around this Geometry having the given width. The buffer of a Geometry is the Minkowski sum or difference of the Geometry with a disc of radius distance.

The width of the buffer, interpreted according to the PrecisionModel of the Geometry. Cap Style to use for compute buffer. All points whose distance from this Geometry are less than or equal to distance. Buffer

Returns a buffer region around this Geometry having the given width and with a specified number of segments used to approximate curves. The buffer of a Geometry is the Minkowski sum of the Geometry with a disc of radius distance. Curves in the buffer polygon are approximated with line segments. This method allows specifying the accuracy of that approximation.

The width of the buffer, interpreted according to the PrecisionModel of the Geometry. The number of segments to use to approximate a quadrant of a circle. All points whose distance from this Geometry are less than or equal to distance. Buffer

The width of the buffer, interpreted according to the PrecisionModel of the Geometry. The number of segments to use to approximate a quadrant of a circle. Cap Style to use for compute buffer. All points whose distance from this Geometry are less than or equal to distance.

Clears any cached envelopes

Given the specified test point, this returns the closest point in this geometry.

ConvexHull

Returns the smallest convex Polygon that contains all the points in the Geometry. This obviously applies only to Geometry s which contain 3 or more points.

the minimum-area convex polygon containing this Geometry's points.

Returns whether this Geometry is greater than, equal to, or less than another Geometry having the same class.

A Geometry having the same class as this Geometry. A positive number, 0, or a negative number, depending on whether this object is greater than, equal to, or less than o, as defined in "Normal Form For Geometry" in the NTS Technical Specifications. Distance

Returns the minimum distance between this Geometry and the Geometry g.

The Geometry from which to compute the distance. Equals

Returns true if the DE-9IM intersection matrix for the two Geometrys is T*F**FFF*.

The Geometry with which to compare this Geometry. true if the two Geometrys are equal. EqualsExact

Returns true if the two Geometrys are exactly equal, up to a specified tolerance. Two Geometries are exactly within a tolerance equal iff: they have the same class, they have the same values of Coordinates, within the given tolerance distance, in their internal Coordinate lists, in exactly the same order. If this and the other Geometrys are composites and any children are not Geometrys, returns false.

The Geometry with which to compare this Geometry Distance at or below which two Coordinates will be considered equal. true if this and the other Geometry are of the same class and have equal internal data. EqualsExact

Returns true if the two Geometrys are exactly equal. Two Geometries are exactly equal iff: they have the same class, they have the same values of Coordinates in their internal Coordinate lists, in exactly the same order. If this and the other Geometrys are composites and any children are not Geometrys, returns false. This provides a stricter test of equality than equals.

The Geometry with which to compare this Geometry. true if this and the other Geometry are of the same class and have equal internal data.

Notifies this Geometry that its Coordinates have been changed by an external party. When GeometryChanged is called, this method will be called for this Geometry and its component Geometries.

Notifies this Geometry that its Coordinates have been changed by an external party (using a CoordinateFilter, for example). The Geometry will flush and/or update any information it has cached (such as its Envelope).

GetGeometryN

Returns an element Geometry from a GeometryCollection, or this, if the geometry is not a collection.

The index of the geometry element. The n'th geometry contained in this geometry. IsWithinDistance

Tests whether the distance from this Geometry to another is less than or equal to a specified value.

the Geometry to check the distance to. the distance value to compare. true if the geometries are less than distance apart. Normalize

Converts this Geometry to normal form (or canonical form ). Normal form is a unique representation for Geometry s. It can be used to test whether two Geometrys are equal in a way that is independent of the ordering of the coordinates within them. Normal form equality is a stronger condition than topological equality, but weaker than pointwise equality. The definitions for normal form use the standard lexicographical ordering for coordinates. "Sorted in order of coordinates" means the obvious extension of this ordering to sequences of coordinates.

Returns the feature representation as GML 2.1.1 XML document. This XML document is based on Geometry.xsd schema. NO features or XLink are implemented here!

Area

Returns the area of this Geometry. Areal Geometries have a non-zero area. They override this function to compute the area. Others return 0.0

The area of the Geometry. Boundary

Returns the boundary, or the empty point if this Geometry is empty. For a discussion of this function, see the OpenGIS Simple Features Specification. As stated in SFS Section 2.1.13.1, "the boundary of a Geometry is a set of Geometries of the next lower dimension."

The closure of the combinatorial boundary of this Geometry.

Returns the dimension of this Geometrys inherent boundary.

The dimension of the boundary of the class implementing this interface, whether or not this object is the empty point. Returns Dimension.False if the boundary is the empty point. Centroid

Computes the centroid of this Geometry. The centroid is equal to the centroid of the set of component Geometries of highest dimension (since the lower-dimension geometries contribute zero "weight" to the centroid).

A Point which is the centroid of this Geometry. Coordinate

Returns a vertex of this Geometry

Dimension

Gets or sets the DotSpatial.Geometries.Dimensions of this Geometry.

EnvelopeInternal

Returns the interior geometry

Factory

Gets the factory which contains the context in whcih this geometry was created

InteriorPoint

Computes an interior point of this Geometry. An interior point is guaranteed to lie in the interior of the Geometry, if it possible to calculate such a point exactly. Otherwise, the point may lie on the boundary of the point.

IsEmpty

Returns whether or not the set of points in this geometry is empty

IsRectangle

Essentially is false for anything other than a polygon, which does a check to see if the polygon in question is a rectangle.

IsSimple

Returns false if the Geometry not simple. Subclasses provide their own definition of "simple". If this Geometry is empty, returns true. In general, the SFS specifications of simplicity seem to follow the following rule: A Geometry is simple if the only self-intersections are at boundary points. For all empty Geometrys, IsSimple==true.

IsValid

Tests the validity of this Geometry. Subclasses provide their own definition of "valid"

Length

Returns the length of this Geometry. Linear geometries return their length. Areal geometries return their perimeter. Others return 0.0

There used to be a class for precision model stuff, but for Interface purposes, this will be communicated as a an enumeration which can later be converted into a full fledged PrecisionModel.

SRID

Gets/Sets the ID of the Spatial Reference System used by the Geometry. NTS supports Spatial Reference System information in the simple way defined in the SFS. A Spatial Reference System ID (SRID) is present in each Geometry object. Geometry provides basic accessor operations for this field, but no others. The SRID is represented as an integer.

UserData

Gets/Sets the user data object for this point, if any. A simple scheme for applications to add their own custom data to a Geometry. An example use might be to add an object representing a Coordinate Reference System. Notice that user data objects are not present in geometries created by construction methods.

Creates a sort of default geometry object from the default geometry factory, or creates a new one if one doesn't exist yet.

A predefined with == .

Returns an element Geometry from a GeometryCollection, or this, if the geometry is not a collection.

The index of the geometry element. The n'th geometry contained in this geometry.

This returns the index'th BasicGeometry where index is between 0 and NumGeometries - 1. If there is only one geometry, this will return this object.

An integer index between 0 and NumGeometries - 1 specifying the basic geometry A BasicGeometry representing only the specific sub-geometry specified

Returns the minimum distance between this Geometry and the Geometry g.

The Geometry from which to compute the distance.

Tests whether the distance from this Geometry to another is less than or equal to a specified value.

the Geometry to check the distance to. the distance value to compare. true if the geometries are less than distance apart.

Given the specified test point, this returns the closest point in this geometry.

Notifies this Geometry that its Coordinates have been changed by an external party. When GeometryChanged is called, this method will be called for this Geometry and its component Geometries.

Returns true if the DE-9IM intersection matrix for the two Geometrys is FF*FF****.

The Geometry with which to compare this Geometry. true if the two Geometrys are disjoint.

Returns true if the DE-9IM intersection matrix for the two Geometrys is FT*******, F**T***** or F***T****.

The Geometry with which to compare this Geometry. true if the two Geometrys touch; Returns false if both Geometrys are points.

Returns true if disjoint returns false.

The Geometry with which to compare this Geometry. true if the two Geometrys intersect.

Returns true if the DE-9IM intersection matrix for the two Geometrys is T*T****** (for a point and a curve, a point and an area or a line and an area) 0******** (for two curves).

Returns true if the DE-9IM intersection matrix for the two Geometrys is T*F**F***.

The Geometry with which to compare this Geometry. true if this Geometry is within other.

Returns true if the DE-9IM intersection matrix for the two Geometrys is T*T***T** (for two points or two surfaces) 1*T***T** (for two curves).

The Geometry with which to compare this Geometry. true if the two Geometrys overlap. For this function to return true, the Geometry s must be two points, two curves or two surfaces.

The Geometry with which to compare this Geometry. true if this Geometry is covered by .

Returns the DE-9IM intersection matrix for the two Geometrys.

The Geometry with which to compare this Geometry A matrix describing the intersections of the interiors, boundaries and exteriors of the two Geometrys.

Returns true if the DE-9IM intersection matrix for the two Geometrys is T*F**FFF*.

The Geometry with which to compare this Geometry. true if the two Geometrys are equal.

Returns the Well-known Text representation of this Geometry. For a definition of the Well-known Text format, see the OpenGIS Simple Features Specification.

The Well-known Text representation of this Geometry.

Returns the Well-known Binary representation of this Geometry. For a definition of the Well-known Binary format, see the OpenGIS Simple Features Specification.

The Well-known Binary representation of this Geometry.

Returns the feature representation as GML 2.1.1 XML document. This XML document is based on Geometry.xsd schema. NO features or XLink are implemented here!

Returns a GML string for this geometry

A String with the GML

Returns the smallest convex Polygon that contains all the points in the Geometry. This obviously applies only to Geometry s which contain 3 or more points.

the minimum-area convex polygon containing this Geometry's points.

Returns a Geometry representing the points shared by this Geometry and other.

The Geometry with which to compute the intersection. The points common to the two Geometrys.

Forces the cached envelope to be re-calculated using the coordinates.

Clears any cached envelopes

Returns a Geometry representing all the points in this Geometry and other.

The Geometry with which to compute the union. A set combining the points of this Geometry and the points of other.

Returns a Geometry representing the points making up this Geometry that do not make up other. This method returns the closure of the resultant Geometry.

The Geometry with which to compute the difference. The point set difference of this Geometry with other.

Returns a set combining the points in this Geometry not in other, and the points in other not in this Geometry. This method returns the closure of the resultant Geometry.

The Geometry with which to compute the symmetric difference. The point set symmetric difference of this Geometry with other.

The Geometry with which to compare this Geometry. true if this and the other Geometry are of the same class and have equal internal data.

The filter to apply to this Geometry's coordinates

Performs an operation with or on this Geometry and its subelement Geometrys (if any). Only GeometryCollections and subclasses have subelement Geometry's.

The filter to apply to this Geometry (and its children, if it is a GeometryCollection).

The filter to apply to this Geometry.

Returns whether this Geometry is greater than, equal to, or less than another Geometry. If their classes are different, they are compared using the following ordering: Point (lowest), MultiPoint, LineString, LinearRing, MultiLineString, Polygon, MultiPolygon, GeometryCollection (highest). If the two Geometrys have the same class, their first elements are compared. If those are the same, the second elements are compared, etc.

A Geometry with which to compare this Geometry A positive number, 0, or a negative number, depending on whether this object is greater than, equal to, or less than o, as defined in "Normal Form For Geometry" in the NTS Technical Specifications.

Returns whether this Geometry is greater than, equal to, or less than another Geometry having the same class.

Returns a buffer region around this Geometry having the given width. The buffer of a Geometry is the Minkowski sum or difference of the Geometry with a disc of radius distance.

The width of the buffer, interpreted according to the PrecisionModel of the Geometry. All points whose distance from this Geometry are less than or equal to distance.

Returns true if other.within(this) returns true.

The Geometry with which to compare this Geometry. true if this Geometry contains other.

This is convenient for casting troublesome basic geometries into fully fledged geometries without having to parse them each time. It uses the constructors, and effectively the default factory.

Returns true if the array contains any non-empty Geometrys.

an array of Geometrys; no elements may be null true if any of the Geometrys IsEmpty methods return false.

Returns true if the array contains any null elements.

an array to validate. true if any of arrays elements are null.

Returns the Well-known Text representation of this Geometry. For a definition of the Well-known Text format, see the OpenGIS Simple Features Specification.

The Well-known Text representation of this Geometry.

Allows each geometry to control any custom behavior that cannot be solved with MemberwiseClone. The Coordinates of the geometry are already duplicated.

Returns whether the two Geometrys are equal, from the point of view of the EqualsExact method. Called by EqualsExact . In general, two Geometry classes are considered to be "equivalent" only if they are the same class. An exception is LineString , which is considered to be equivalent to its subclasses.

The Geometry with which to compare this Geometry for equality. true if the classes of the two Geometry s are considered to be equal by the equalsExact method.

Throws an exception if g's class is GeometryCollection. (Its subclasses do not trigger an exception).

The Geometry to check; throws ArgumentException if g is a GeometryCollection but not one of its subclasses.

Returns the minimum and maximum x and y values in this Geometry , or a null Envelope if this Geometry is empty. Unlike EnvelopeInternal, this method calculates the Envelope each time it is called; EnvelopeInternal caches the result of this method.

This Geometrys bounding box; if the Geometry is empty, Envelope.IsNull will return true.

Returns the first non-zero result of CompareTo encountered as the two Collections are iterated over. If, by the time one of the iterations is complete, no non-zero result has been encountered, returns 0 if the other iteration is also complete. If b completes before a, a positive number is returned; if a before b, a negative number.

The left hand side ArrayList to compare. The right hand side ArrayList to compare. The first non-zero compareTo result, if any; otherwise, zero.

Tests the specified IEnvelope for an intersection with this Geometry

The IEnvelope to test True if the envelope intersects this geometry

Tests the specified location to see if it intersects with this geometry

The double X coordinate to test The double Y coordinate to test Boolean, true if the specified coordinates intersect this geometry

Returns this Geometrys bounding box. If this Geometry is the empty point, returns an empty Point. If the Geometry is a point, returns a non-empty Point. Otherwise, returns a Polygon whose points are (minx, miny), (maxx, miny), (maxx, maxy), (minx, maxy), (minx, miny).

An empty Point (for empty Geometrys), a Point (for Points) or a Polygon (in all other cases).

Gets the factory which contains the context in which this point was created.

The factory for this point.

Gets/Sets the user data object for this point, if any. A simple scheme for applications to add their own custom data to a Geometry. An example use might be to add an object representing a Coordinate Reference System. notice that user data objects are not present in geometries created by construction methods.

Clarifies which subtype of geometry we are working with

Returns the PrecisionModel used by the Geometry.

the specification of the grid of allowable points, for this Geometry and all other Geometrys.

Returns a vertex of this Geometry.

a Coordinate which is a vertex of this Geometry. Returns null if this Geometry is empty.

Returns this Geometry s vertices. If you modify the coordinates in this array, be sure to call GeometryChanged afterwards. The Geometrys contained by composite Geometrys must be Geometry's; that is, they must implement Coordinates.

The vertices of this Geometry.

Returns the count of this Geometrys vertices. The Geometry s contained by composite Geometrys must be Geometry's; that is, they must implement NumPoints.

The number of vertices in this Geometry.

Returns the number of Geometryes in a GeometryCollection, or 1, if the geometry is not a collection.

false if this Geometry has any points of self-tangency, self-intersection or other anomalous points.

Tests the validity of this Geometry. Subclasses provide their own definition of "valid".

true if this Geometry is valid.

Returns whether or not the set of points in this Geometry is empty.

true if this Geometry equals the empty point.

Returns the area of this Geometry. Areal Geometries have a non-zero area. They override this function to compute the area. Others return 0.0

The area of the Geometry.

Returns the length of this Geometry. Linear geometries return their length. Areal geometries return their perimeter. They override this function to compute the length. Others return 0.0

The length of the Geometry.

A Point which is in the interior of this Geometry.

Returns the dimension of this Geometry.

The dimension of the class implementing this interface, whether or not this object is the empty point.

Returns the dimension of this Geometrys inherent boundary.

The dimension of the boundary of the class implementing this interface, whether or not this object is the empty point. Returns Dimension.False if the boundary is the empty point.

Returns the minimum and maximum x and y values in this Geometry , or a null Envelope if this Geometry is empty.

This Geometrys bounding box; if the Geometry is empty, Envelope.IsNull will return true.

Gets the IEnvelope that contains this geometry

The closure of the combinatorial boundary of this Geometry.

A Point which is the centroid of this Geometry.

This will be overridden by the specific feature type since this is abstract

Geometry classes support the concept of applying an IGeometryComponentFilter filter to the Geometry. The filter is applied to every component of the Geometry which is itself a Geometry. (For instance, all the LinearRings in Polygons are visited.) An IGeometryComponentFilter filter can either record information about the Geometry or change the Geometry in some way. IGeometryComponentFilter is an example of the Gang-of-Four Visitor pattern.

Performs an operation with or on geom.

A Geometry to which the filter is applied.

Basic implementation of GeometryCollection.

Specific topology functions for Mutigeometry code

Returns the number of geometries contained by this .

Returns the iTh element in the collection.

Return true if all features in collection are of the same type.

Gets a System.Array of all the geometries in this collection

Represents an empty GeometryCollection.

Internal representation of this GeometryCollection.

The Geometrys for this GeometryCollection, or null or an empty array to create the empty point. Elements may be empty Geometrys, but not nulls. For create this is used a standard with == .

This should only be used by derived classes because it does not actually set the geometries

Specifies the factory that should be used when creating shapes in this multigeometry

The Geometrys for this GeometryCollection, or null or an empty array to create the empty point. Elements may be empty Geometrys, but not nulls.

If the input geometry is a singular basic geometry, this will become a collection of 1 geometry. If the input geometry is a multi- basic geometry, this will simply ensure that each member is upgraded to a full geometry.

Creates a new Geometry Collection

Given the specified test point, this checks each segment, and will return the closest point on the specified segment.

The point to test.

This returns the index'th BasicGeometry where index is between 0 and NumGeometries - 1. If there is only one geometry, this will return this object.

An integer index between 0 and NumGeometries - 1 specifying the basic geometry A BasicGeometry representing only the specific sub-geometry specified

Returns a GeometryCollectionEnumerator: this IEnumerator returns the parent geometry as first element. In most cases is more useful the code geometryCollectionInstance.Geometries.GetEnumerator(): this returns an IEnumerator over geometries composing GeometryCollection.

Handles the duplication process for geometry collections

Collects all coordinates of all subgeometries into an Array. Notice that while changes to the coordinate objects themselves may modify the Geometries in place, the returned Array as such is only a temporary container which is not synchronized back.

The collected coordinates.

Uses an Enumeration to clarify the type of geometry

Returns the area of this GeometryCollection.

Returns the length of this GeometryCollection.

Return true if all features in collection are of the same type.

Returns the iTh element in the collection.

Returns the number of geometries contained by this .

Gets the Envelope that envelops this GeometryCollection

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.

The number of Geometrys in the the GeometryCollection.

The GeometryCollection being iterated over.

Indicates whether or not the first element (the GeometryCollection ) has been returned.

The index of the Geometry that will be returned when next is called.

The iterator over a nested GeometryCollection, or null if this GeometryCollectionIterator is not currently iterating over a nested GeometryCollection.

Constructs an iterator over the given GeometryCollection.

The collection over which to iterate; also, the first element returned by the iterator.

A GeometryCollectionNotSupportedException Class

Creates a new instance of GeometryCollectionNotSupportedException

Supplies a set of utility methods for building Geometry objects from lists of Coordinates.

Factory for Geometry stuff

Generic constructor that parses a list and tries to form a working object that implements MapWindow.Interfaces.IGeometry

some list of things An object that implements DotSpatial.Geometries.IGeometry

Method to produce a point given a coordinate

An object that implements DotSpatial.Geometries.ICoordinate An object that implements DotSpatial.Geometries.IPoint

Creates a new object that implements DotSpatial.Geometries.MultiLineString given an array of objects that implement DotSpatial.Geometries.ILineStringBase

The Array of objects that implement DotSpatial.Geometries.IlineStringBase A new MultiLineString that implements IMultiLineString

Creates an object that implements DotSpatial.Geometries.IGeometryCollection from an array of objects that implement DotSpatial.Geometries.IGeometry

An array of objects that implement DotSpatial.Geometries.IGeometry A new object that implements DotSpatial.Geometries.IGeometryCollection

Creates an object that implements DotSpatial.Geometries.IMultiPolygon from an array of objects that implement DotSpatial.Geometries.IPolygon

An Array of objects that implement DotSpatial.Geometries.IPolygon An object that implements DotSpatial.Geometries.IMultiPolygon

Creates an object that implements DotSpatial.Geometries.ILinearRing from an array of DotSpatial.Geometries.ICoordinates

An array of objects that implement ICoordinate An object that implements DotSpatial.Geometries.ILinearRing

Creates an object that implements DotSpatial.Geometries.IMultiPoint from an array of objects that implement DotSpatial.Geometries.ICoordinate

An array of objects that implement DotSpatial.Geometries.ICoordinate An object that implements DotSpatial.Geometries.IMultiPoint

Creates an object that implements DotSpatial.Geometries.IMultiPoint from an array of objects that implement DotSpatial.Geometries.ICoordinate

An array of objects that implement DotSpatial.Geometries.ICoordinate An object that implements DotSpatial.Geometries.IMultiPoint

Creates an object that implements DotSpatial.Geometries.ILineString from an array of objects that implement DotSpatial.Geometries.ICoordinate

An array of objects that implement DotSpatial.Geometries.ICoordinate A DotSpatial.Geometries.ILineString

Creates an object that implements DotSpatial.Geometries.IGeometry that is a copy of the specified object that implements DotSpatial.Geometries.IGeometry

An object that implements DotSpatial.Geometries.IGeometry An copy of the original object that implements DotSpatial.Geometries.IGeometry

Creates an object that implements DotSpatial.Geometries.IPolygon given a specified DotSpatial.Geometries.ILinearRing shell and an array of DotSpatial.Geometries.ILinearRing that represent the holes

The outer perimeter of the polygon, represented by an object that implements DotSpatial.Geometries.ILinearRing The interior holes in the polygon, represented by an array of objects that implements DotSpatial.Geometries.ILinearRing An object that implements DotSpatial.Geometries.IPolygon

Floating reference

CoordinateSequenceFactory that can manufacture a coordinate sequence

A predefined with == .

A shortcut for .

A predefined with == .

Constructs a GeometryFactory that generates Geometries having the given PrecisionModel, spatial-reference ID, and CoordinateSequence implementation.

Constructs a GeometryFactory object from any valid IGeometryFactory interface

Constructs a GeometryFactory pertaining to a specific _coordinateSequenceFactory using any valid IGeometryFactory and ICoordinateSequenceFactory interface

An IGeometryFactory Interface An ICoordianteSequenceFactory interface

Constructs a GeometryFactory that generates Geometries having the given CoordinateSequence implementation, a double-precision floating PrecisionModel and a spatial-reference ID of 0.

Constructs a GeometryFactory that generates Geometries having the given {PrecisionModel} and the default CoordinateSequence implementation.

The PrecisionModel to use.

Constructs a GeometryFactory that generates Geometries having the given PrecisionModel and spatial-reference ID, and the default CoordinateSequence implementation.

The PrecisionModel to use. The SRID to use.

Constructs a GeometryFactory that generates Geometries having a floating PrecisionModel and a spatial-reference ID of 0.

Creates a Point using the given Coordinate; a null Coordinate will create an empty Geometry.

Creates a MultiLineString using the given LineStrings; a null or empty array will create an empty MultiLineString.

LineStrings, each of which may be empty but not null-

Creates a GeometryCollection using the given Geometries; a null or empty array will create an empty GeometryCollection.

Geometries, each of which may be empty but not null.

Creates a MultiPolygon using the given Polygons; a null or empty array will create an empty Polygon. The polygons must conform to the assertions specified in the OpenGIS Simple Features Specification for SQL.

Polygons, each of which may be empty but not null.

Creates a LinearRing using the given Coordinates; a null or empty array will create an empty LinearRing. The points must form a closed and simple linestring. Consecutive points must not be equal.

An array without null elements, or an empty array, or null.

Creates a MultiPoint using the given Points; a null or empty array will create an empty MultiPoint.

An array without null elements, or an empty array, or null.

Creates an object that implements DotSpatial.Geometries.IMultiPoint from an array of objects that implement DotSpatial.Geometries.ICoordinate

An array of objects that implement DotSpatial.Geometries.ICoordinate An object that implements DotSpatial.Geometries.IMultiPoint

Constructs a Polygon with the given exterior boundary and interior boundaries.

The outer boundary of the new Polygon, or null or an empty LinearRing if the empty point is to be created. The inner boundaries of the new Polygon, or null or empty LinearRing s if the empty point is to be created.

Build an appropriate Geometry, MultiGeometry, or GeometryCollection to contain the Geometrys in it. If geomList contains a single Polygon, the Polygon is returned. If geomList contains several Polygons, a MultiPolygon is returned. If geomList contains some Polygons and some LineStrings, a GeometryCollection is returned. If geomList is empty, an empty GeometryCollection is returned. Notice that this method does not "flatten" Geometries in the input, and hence if any MultiGeometries are contained in the input a GeometryCollection containing them will be returned.

The Geometrys to combine. A Geometry of the "smallest", "most type-specific" class that can contain the elements of geomList.

Creates a LineString using the given Coordinates; a null or empty array will create an empty LineString. Consecutive points must not be equal.

An array without null elements, or an empty array, or null.

A clone of g based on a CoordinateSequence created by this GeometryFactory's CoordinateSequenceFactory.

Converts the List to an array.

The List of Points to convert. The List in array format.

Converts the List to an array.

The list of Geometry's to convert. The List in array format.

Converts the List to an array.

The List of LinearRings to convert. The List in array format.

Converts the List to an array.

The List of LineStrings to convert. The List in array format.

Converts the List to an array.

The List of Polygons to convert. The List in array format.

Converts the List to an array.

The List of MultiPolygons to convert. The List in array format.

Converts the List to an array.

The List of MultiLineStrings to convert. The List in array format.

Converts the List to an array.

The List of MultiPoints to convert. The List in array format.

If the Envelope is a null Envelope, returns an empty Point. If the Envelope is a point, returns a non-empty Point. If the Envelope is a rectangle, returns a Polygon whose points are (minx, miny), (maxx, miny), (maxx, maxy), (minx, maxy), (minx, miny).

The Envelope to convert to a Geometry. An empty Point (for null Envelope s), a Point (when min x = max x and min y = max y) or a Polygon (in all other cases) throws a TopologyException if coordinates is not a closed linestring, that is, if the first and last coordinates are not equal.

Creates a MultiPoint using the given CoordinateSequence; a null or empty CoordinateSequence will create an empty MultiPoint.

A CoordinateSequence possibly empty, or null.

A default IGeometryFactory.

Returns the Fixed geometry factory

The floating IGeometryFactory

A floating Single IGeometryFactory

Returns the PrecisionModel that Geometries created by this factory will be associated with.

A GeometryEditorOperation which modifies the coordinate list of a Geometry. Operates on Geometry subclasses which contains a single coordinate list.

A interface which specifies an edit operation for Geometries.

Supports creating a new Geometry which is a modification of an existing one. Geometry objects are intended to be treated as immutable. This class allows you to "modify" a Geometry by traversing it and creating a new Geometry with the same overall structure but possibly modified components. The following kinds of modifications can be made: The values of the coordinates may be changed. Changing coordinate values may make the result Geometry invalid; this is not checked by the GeometryEditor. The coordinate lists may be changed (e.g. by adding or deleting coordinates). The modifed coordinate lists must be consistent with their original parent component (e.g. a LinearRing must always have at least 4 coordinates, and the first and last coordinate must be equal). Components of the original point may be deleted (e.g. holes may be removed from a Polygon, or LineStrings removed from a MultiLineString). Deletions will be propagated up the component tree appropriately. Notice that all changes must be consistent with the original Geometry's structure (e.g. a Polygon cannot be collapsed into a LineString). The resulting Geometry is not checked for validity. If validity needs to be enforced, the new Geometry's IsValid should be checked.

The factory used to create the modified Geometry.

Creates a new GeometryEditor object which will create an edited Geometry with the same {GeometryFactory} as the input Geometry.

Creates a new GeometryEditor object which will create the edited Geometry with the given GeometryFactory.

The GeometryFactory to create the edited Geometry with.

Edit the input Geometry with the given edit operation. Clients will create subclasses of GeometryEditorOperation or CoordinateOperation to perform required modifications.

The Geometry to edit. The edit operation to carry out. A new Geometry which is the result of the editing.

A GeometryEditorOperation which modifies the coordinate list of a Geometry. Operates on Geometry subclasses which contains a single coordinate list.

A interface which specifies an edit operation for Geometries.

Edits a Geometry by returning a new Geometry with a modification. The returned Geometry might be the same as the Geometry passed in.

The Geometry to modify. The factory with which to construct the modified Geometry (may be different to the factory of the input point). A new Geometry which is a modification of the input Geometry.

Edits the array of Coordinates from a Geometry.

The coordinate array to operate on. The point containing the coordinate list. An edited coordinate array (which may be the same as the input).

Writes the GML representation of the features of Topology model. Uses GML 2.1.1 Geometry.xsd schema for base for features.

Returns an XmlReader with feature informations. Use XmlDocument.Load(XmlReader) for obtain a XmlDocument to work.

Writes a GML feature into a generic Stream, such a FileStream or other streams.

Sets corrent length for Byte Stream.

Formatter for double values of coordinates

This is the simpler interface to implement

This is a BasicGeometry that contains information about a specific point. The easier way to do this is have the IPoint inherit the IBasicGeometry and the store implementations for ICoordinate.

Adds any topology functions to the basic Vector ICoordinate

Return HashCode.

A Measure coordinate

A 1D coordinate only has a valid X. A 2D coordinate has X and Y, while a 3D coordinate has X, Y, and Z. Presumably this is open ended and could support higher coordinates, but this coordinate is not responsible for storing values beyond its dimension and may cause exceptions if a value higher than the dimension is used.

Gets a double value for the specified zero based ordinate.

The zero based integer ordinate. A double value.

Gets or sets the values as a one dimensional array of doubles.

The X coordinate

The Y coordinate

The Z coordinate

This supports some of the basic data-related capabilities of a polygon, but no topology functions. Each of these uses the specifically different nomenclature so that the parallel concepts in a full Polygon can return the appropriate datatype. Since Polygon will Implement IPolygonBase, it is the responsibility of the developer to perform the necessary casts when returning this set from the more complete topology classes.

Gets the list of Interior Rings in the form of ILineStringBase objects

Gets the exterior ring of the polygon as an ILineStringBase.

Gets the count of holes or interior rings

ICoordinateF

Gets or sets the X coordinate using a single precision floating point

Gets or sets the Y coordinate using a single precision floating point value

Gets or sets the Z coordinate using a single precision floating point value

Geometry classes support the concept of applying a coordinate filter to every coordinate in the Geometry. A coordinate filter can either record information about each coordinate or change the coordinate in some way. Coordinate filters implement the interface ICoordinateFilter. ICoordinateFilter is an example of the Gang-of-Four Visitor pattern. Coordinate filters can be used to implement such things as coordinate transformations, centroid and envelope computation, and many other functions.

Performs an operation with or on coord.

Coordinate to which the filter is applied.

GeometryCollection classes support the concept of applying a IGeometryFilter to the Geometry. The filter is applied to every element Geometry. A IGeometryFilter can either record information about the Geometry or change the Geometry in some way. IGeometryFilter is an example of the Gang-of-Four Visitor pattern.

Performs an operation with or on geom.

A Geometry to which the filter is applied.

A Dimensionally Extended Nine-Intersection Model (DE-9IM) matrix. This class can used to represent both computed DE-9IM's (like 212FF1FF2) as well as patterns for matching them (like T*T******). Methods are provided to: Set and query the elements of the matrix in a convenient fashion convert to and from the standard string representation (specified in SFS Section 2.1.13.2). Test to see if a matrix matches a given pattern string. For a description of the DE-9IM, see the OpenGIS Simple Features Specification for SQL.

Adds one matrix to another. Addition is defined by taking the maximum dimension value of each position in the summand matrices.

The matrix to add.

Changes the value of one of this IntersectionMatrixs elements.

The row of this IntersectionMatrix, indicating the interior, boundary or exterior of the first Geometry The column of this IntersectionMatrix, indicating the interior, boundary or exterior of the second Geometry The new value of the element

Changes the elements of this IntersectionMatrix to the dimension symbols in dimensionSymbols.

Nine dimension symbols to which to set this IntersectionMatrix s elements. Possible values are {T, F, *, 0, 1, 2}

Changes the specified element to minimumDimensionValue if the element is less.

The row of this IntersectionMatrix , indicating the interior, boundary or exterior of the first Geometry. The column of this IntersectionMatrix , indicating the interior, boundary or exterior of the second Geometry. The dimension value with which to compare the element. The order of dimension values from least to greatest is True, False, Dontcare, 0, 1, 2.

If row >= 0 and column >= 0, changes the specified element to minimumDimensionValue if the element is less. Does nothing if row is smaller to 0 or column is smaller to 0.

For each element in this IntersectionMatrix, changes the element to the corresponding minimum dimension symbol if the element is less.

Nine dimension symbols with which to compare the elements of this IntersectionMatrix. The order of dimension values from least to greatest is Dontcare, True, False, 0, 1, 2.

Changes the elements of this IntersectionMatrix to dimensionValue.

The dimension value to which to set this IntersectionMatrix s elements. Possible values True, False, Dontcare, 0, 1, 2}.

Returns the value of one of this IntersectionMatrixs elements.

The row of this IntersectionMatrix, indicating the interior, boundary or exterior of the first Geometry. The column of this IntersectionMatrix, indicating the interior, boundary or exterior of the second Geometry. The dimension value at the given matrix position.

Returns true if this IntersectionMatrix is FF*FF****.

true if the two Geometrys related by this IntersectionMatrix are disjoint.

Returns true if isDisjoint returns false.

true if the two Geometrys related by this IntersectionMatrix intersect.

Returns true if this IntersectionMatrix is FT*******, F**T***** or F***T****.

The dimension of the first Geometry. The dimension of the second Geometry. true if the two Geometry s related by this IntersectionMatrix touch; Returns false if both Geometrys are points.

Returns true if this IntersectionMatrix is T*T****** (for a point and a curve, a point and an area or a line and an area) 0******** (for two curves).

The dimension of the first Geometry. The dimension of the second Geometry. true if the two Geometry s related by this IntersectionMatrix cross. For this function to return true, the Geometrys must be a point and a curve; a point and a surface; two curves; or a curve and a surface.

Returns true if this IntersectionMatrix is T*F**F***.

true if the first Geometry is within the second.

Returns true if this IntersectionMatrix is T*****FF*.

true if the first Geometry contains the second.

Returns true if this IntersectionMatrix is T*****FF* or *T****FF* or ***T**FF* or ****T*FF*.

true if the first Geometry covers the second

Returns true if this IntersectionMatrix is T*F**FFF*.

The dimension of the first Geometry. The dimension of the second Geometry. true if the two Geometry s related by this IntersectionMatrix are equal; the Geometrys must have the same dimension for this function to return true.

Returns true if this IntersectionMatrix is T*T***T** (for two points or two surfaces) 1*T***T** (for two curves).

The dimension of the first Geometry. The dimension of the second Geometry. true if the two Geometry s related by this IntersectionMatrix overlap. For this function to return true, the Geometrys must be two points, two curves or two surfaces.

Returns whether the elements of this IntersectionMatrix satisfies the required dimension symbols.

Nine dimension symbols with which to compare the elements of this IntersectionMatrix. Possible values are {T, F, *, 0, 1, 2}. true if this IntersectionMatrix matches the required dimension symbols.

Transposes this IntersectionMatrix.

This IntersectionMatrix as a convenience,

Returns a nine-character String representation of this IntersectionMatrix.

The nine dimension symbols of this IntersectionMatrix in row-major order.

A closed, non-self intersecting Linestring

This adds the basic functionality of a

Retrieves a topologically complete IPoint for the n'th coordinate in the 0 based index of point values.

Integer index specifying the point to retrieve IPoint to retrieve

Returns an ILineString that has its coordinates completely reversed

Returns true if the given point is a vertex of this LineString.

The Coordinate to check. true if pt is one of this LineString's vertices.

Gets a topologically complete IPoint for the first coordinate

Gets a topologically complete IPoint for the last coordinate

If the first coordinate is the same as the final coordinate, then the linestring is closed.

If the coordinates listed for the linestring are both closed and simple then they qualify as a linear ring.

Returns the value of the angle between the and the .

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.

This is a low-level place holder for a linestring with only two points. This does not inherit geometry (Use ILineString for those features). The Idea is that this provides just enough information to communicate the definition of a LineSegment.

The first of two coordinates that defines the segment

The second of two endpoints that defines the segment

Returns an ICoordinate for the point specified by index i.

Integer point index. 0 returns the first point, 1 returns the second. ICoordinate

Sets the two coordinates to match the coordinates in the specified ILineSegment

Sets the two coordinates of this ILineString based on the ICoordinate values passed.

An ICoordinate that specifies the startpoint of the segment An ICoordinate that specifies the location of the endpoint of the segment

Determines the orientation of a LineSegment relative to this segment. The concept of orientation is specified as follows: Given two line segments A and L, A is to the left of a segment L if A lies wholly in the closed half-plane lying to the left of L A is to the right of a segment L if A lies wholly in the closed half-plane lying to the right of L otherwise, A has indeterminate orientation relative to L. This happens if A is collinear with L or if A crosses the line determined by L.

The LineSegment to compare. 1 if seg is to the left of this segment, -1 if seg is to the right of this segment, 0 if seg has indeterminate orientation relative to this segment.

Reverses the direction of the line segment.

Puts the line segment into a normalized form. This is useful for using line segments in maps and indexes when topological equality rather than exact equality is desired.

Computes the distance between this line segment and another one.

Computes the distance between this line segment and a point.

Computes the perpendicular distance between the (infinite) line defined by this line segment and a point.

Compute the projection factor for the projection of the point p onto this LineSegment. The projection factor is the constant k by which the vector for this segment must be multiplied to equal the vector for the projection of p.

Compute the projection of a point onto the line determined by this line segment. Notice that the projected point may lie outside the line segment. If this is the case, the projection factor will lie outside the range [0.0, 1.0].

Project a line segment onto this line segment and return the resulting line segment. The returned line segment will be a subset of the target line line segment. This subset may be null, if the segments are oriented in such a way that there is no projection. Notice that the returned line may have zero length (i.e. the same endpoints). This can happen for instance if the lines are perpendicular to one another.

The line segment to project. The projected line segment, or null if there is no overlap.

Computes the closest point on this line segment to another point.

The point to find the closest point to. A Coordinate which is the closest point on the line segment to the point p.

Computes the closest points on a line segment.

A pair of Coordinates which are the closest points on the line segments.

Computes an intersection point between two segments, if there is one. There may be 0, 1 or many intersection points between two segments. If there are 0, null is returned. If there is 1 or more, a single one is returned (chosen at the discretion of the algorithm). If more information is required about the details of the intersection, the {RobustLineIntersector} class should be used.

An intersection point, or null if there is none.

Performs an intersection of this line segment with the specified envelope

The envelope to compare against An ILineSegment, or null if there is no intersection.

Determines if any portion of this segment intersects the specified extent.

The Boolean, true if this line segment intersects the specified envelope

Returns true if other is topologically equal to this LineSegment (e.g. irrespective of orientation).

A LineSegment with which to do the comparison. true if other is a LineSegment with the same values for the x and y ordinates.

Returns Well Known Text for a LineString with just 2 points

String: Well Known Text

Computes the length of the line segment.

The length of the line segment.

Tests whether the segment is horizontal.

true if the segment is horizontal.

Tests whether the segment is vertical.

true if the segment is vertical. The angle this segment makes with the x-axis (in radians).

IMatrix

Performs the matrix multiplication against the specified matrix

Gets the number of rows

Gets the number of columns

Operations on 3D vectors can be carried out using a 4D Matrix. This interface provides access to methods that are specific to 3D vector opperations.

IMatrix4

Multiplies every value in the specified n x m matrix by the specified double inScalar.

The double precision floating point to multiply all the members against A new n x m matrix

This replaces the underlying general multiplication with a more specific type.

Gets or sets the values for this matrix of double precision coordinates

Specifies amount to rotate

Multiplies the current matrix by a rotation matrix corresponding to the specified angle to create rotation in the Z direction.

The angle to rotate in degrees.

Rotates the current matrix around the Y axis by multiplying the current matrix by a rotation matrix.

Translates the matrix by the specified amount in each of the directions by multiplying by a translation matrix created from the specified values.

The translation in the X coordinate The translation in the Y coordinate The translation in the Z coordinate

A type specific Geometry collection that deals with ILineStrings

Changes the default indexer to assume that the members are ILineString instead of simply IGeometry

A type specific MultiGeometry that specifically uses points

Gets or sets the point that resides at the specified index

A zero-based integer index specifying the point to get or set

specifically for handling

Internal representation of this IntersectionMatrix.

Creates an IntersectionMatrix with Null location values.

Creates an IntersectionMatrix with the given dimension symbols.

A string of nine dimension symbols in row major order.

Creates an IntersectionMatrix with the same elements as other.

An IntersectionMatrix to copy.