DotSpatial.Data

Writes the specified type.

The writer. The value.

Reads the specified type.

The reader.

A registry used to map CLR cultures and encodings to dBase language driver id (LDID) encoding specifiers.

Lookup values are taken from Esri's ArcPad Reference Guide

Gets the associated with the given dBase LDID.

The language driver id (LDID) to get a CultureInfo for. A which uses the encoding represented by by default.

Gets the which matches the given dBase LDID.

The language driver id (LDID) to get the for. An which corresponds to the the code established by Esri.

Gets a language driver id (LDID) for the given encoding.

The Encoding used to lookup the LDID. A language driver code used to specify the encoding used to write text in the dBase file. 0x57 (Windows ANSI) is returned as a default if there is no associated LDID for the given encoding.

Specifies which code page to use in a instance.

Represents a culture and encoding pair.

This base class tries to correctly implement disposable, and should help make the behaviors more consistent across classes that inherit from this class.

Unlike forms that have a disposable life cycle with a clear chain of ownership, or purely managed libraries that have in a built in reference counting system, disposable members in DotSpatial require the ability to behave in some cases like a layer that should be removed from memory as soon as it is removed from the map, and other times like a persistent object. The DisposeLock concept works like an industrial lock-out system. Each additional lock increases the lock count. When all users have released the lock, the IsDisposedLocked property will be false, and the next action like a removal from the parent layers will properly dispose the item. Users may feel free to add the lock in order to handle disposal on the layers themselves. These methods will not actually prevent Dispose from functioning, but understand that calling dispose when there is an IsDisposeLocked is true means that there will likely be a problem.

Locks dispose. This typically adds one instance of an internal reference counter.

Unlocks dispose. This typically removes one instance of an internal reference counter.

Gets a value indicating whether an existing reference is requesting that the object is not disposed of.

Disposes

Adds one request or "reference count" for this item not to be disposed. When an owner is finished, if this is 0, then dispose should be called. For now this does not prevent Dispose from being called, it is simply for tracking purposes.

Removes one reference or request to prevent an object from being automatically disposed.

Finalizes an instance of the class.

This is where the meat of the dispose work is done. Subclasses should call dispose on any disposable members or internal members (presuming they are not dispose locked).

True if the "Dispose" method was called instead of the destructor.

Gets a value indicating whether this instance has already had the Dispose method called on it.

Gets a value indicating whether there are outstanding references that may be using the item that would prefer it if you did not dispose of the item while they are still using it.

An EventArgs class for passing around an extent.

Initializes a new instance of the ExtentArgs class.

The value for this event.

Gets or sets the Extents for this event.

The ExtentsM class extends the regular X and Y extent to the X, Y and M case.

Extent works like an envelope but is faster acting, has a minimum memory profile, only works in 2D and has no events.

A very simple, 2D extent specification.

Minimum in the X dimension, usually left or minimum longitude.

Maximum in the x dimension, usually right or maximum longitude.

Minimum in the y dimension, usually bottom or minimum latitude.

Maximum in the y dimension, usually the top or maximum latitude.

Gets a Boolean that is true if the Min and Max M range should be used.

Gets a Boolean indicating whether the Z value should be used.

Creates a new instance of Extent. This introduces no error checking and assumes that the user knows what they are doing when working with this.

Creates a new extent from the specified ordinates

Given a long array of doubles, this builds an extent from a small part of that xmin, ymin, xmax, ymax

XMin, YMin, XMax, YMax order

Creates a new extent from the specified envelope

Produces a clone, rather than using this same object.

Equality test

Inequality test

Tests if this envelope is contained by the specified envelope

The coordinate to test. Boolean

Tests if this envelope is contained by the specified envelope

Copies the MinX, MaxX, MinY, MaxY values from extent.

Any IExtent implementation.

Allows equality testing for extents that is derived on the extent itself.

Expand will adjust both the minimum and maximum by the specified sizeX and sizeY

The amount to expand left and right. The amount to expand up and down.

This expand the extent by the specified padding on all bounds. So the width will change by twice the padding for instance. To Expand only x and y, use the overload with those values explicitly specified.

The double padding to expand the extent.

Expands this extent to include the domain of the specified extent

The extent to expand to include

Expands this extent to include the domain of the specified point

Spreads the values for the basic X, Y extents across the whole range of int. Repetition will occur, but it should be rare.

Integer

Calculates the intersection of this extent and the other extent. A result with a min greater than the max in either direction is considered invalid and represents no intersection.

The other extent to intersect with.

Returns true if the coordinate exists anywhere within this envelope

Tests for intersection with the specified coordinate

The double ordinate to test intersection with in the X direction The double ordinate to test intersection with in the Y direction True if a point with the specified x and y coordinates is within or on the border of this extent object. NAN values will always return false.

Tests to see if the point is inside or on the boundary of this extent.

Tests for an intersection with the specified extent

The other extent Boolean, true if they overlap anywhere, or even touch

Tests with the specified envelope for a collision

If this is undefined, it will have a min that is larger than the max, or else any value is NaN. This only applies to the X and Z terms. Check HasM or HasZ higher dimensions.

Boolean, true if the envelope has not had values set for it yet.

This allows parsing the X and Y values from a string version of the extent as: 'X[-180|180], Y[-90|90]' Where minimum always precedes maximum. The correct M or MZ version of extent will be returned if the string has those values.

The string text to parse.

This reads the string and attempts to derive values from the text.

This centers the X and Y aspect of the extent on the specified center location.

The center coordinate to to set.

This centers the extent on the specified coordinate, keeping the width and height the same.

Sets the values for xMin, xMax, yMin and yMax.

The double Minimum in the X direction. The double Minimum in the Y direction. The double Maximum in the X direction. The double Maximum in the Y direction.

Creates a geometric envelope interface from this

Creates a string that shows the extent.

The string form of the extent.

Tests if this envelope is contained by the specified envelope

Attempts to extract the min and max from one element of text. The element should be formatted like X[1.5, 2.7] using an invariant culture.

The name of the dimension, like X. The minimum that gets assigned The maximum that gets assigned Boolean, true if the parse was successful.

This method converts the X and Y text into two doubles.

Gets the Center of this extent.

Gets or sets whether the M values are used. M values are considered optional, and not mandatory. Unused could mean either bound is NaN for some reason, or else that the bounds are invalid by the Min being less than the Max.

Max X

Max Y

Min X

Min Y

Gets MaxY - MinY. Setting this will update MinY, keeping MaxY the same. (Pinned at top left corner).

Gets MaxX - MinX. Setting this will update MaxX, keeping MinX the same. (Pinned at top left corner).

Gets MinX. Setting this will shift both MinX and MaxX, keeping the width the same.

Gets MaxY. Setting this will shift both MinY and MaxY, keeping the height the same.

Supports bounding in the M Dimension

Gets or sets the minimum M value

Gets or sets the maximum M value

Initializes a new instance of the ExtentM class.

The double Minimum in the X direction. The double Minimum in the Y direction. The double Minimum in the Measure category. The double Maximum in the X direction. The double Maximum in the Y direction. The double Maximum in the Measure category.

Initializes a new instance of the ExtentM class that is specially designed to work with shapefile formats that have a Measure value. Obviously other formats can use this as well.

An extent that contains only the x and y boundaries. The minimum M. The maximum M.

Initializes a new instance of the ExtentM class. This overload works from an envelope.

The envelope with extent values to read.

Produces a clone, rather than using this same object.

Returns a copy of this object.

Tests if this envelope is contained by the specified envelope

The coordinate to test. Boolean.

Tests if this envelope is contained by the specified envelope

Tests if this envelope is contained by the specified envelope. If either element does not support M values, then only the default X and Y contains test is used.

The envelope to test. Boolean.

Copies from the implementation of IExtent. This checks to see if IExtentM is implemented and if not, this only sets the X and Y bounds.

The double padding to expand the extent.

Expands this extent to include the domain of the specified extent. If the specified case doesn't support IExtentM or HasM is false for that extent, then this test will default to the XY case.

The extent to expand to include.

Expands this extent to include the domain of the specified point

The x ordinate to expand to. The y ordinate to expand to. The m ordinate to expand to.

Calculates the intersection of this extent and the other extent. A result with a min greater than the max in either direction is considered invalid and represents no intersection.

The other extent to intersect with.

Returns true if the coordinate exists anywhere within this envelope. If this envelope represents a valid M extent by having a max greater than min and neither value being NaN, then this will also test the coordinate for the M range.

The Coordinate to test. Boolean

Tests for intersection with the specified coordinate. If the m is double.NaN then it degenerates to only testing X and Y, even if this envelope has an M range.

The double ordinate to test intersection with in the X direction The double ordinate to test intersection with in the Y direction The optional double measure parameter to test. Boolean

Tests for an intersection with the specified extent. Both this extent and the other must implement IExtentM and HasM must be true for both, or else just the X and Y are compared.

The other extent. If the extent doesn't implement IExtentM, then this comparison simply defaults to the X Y intersect case. Boolean, true if they overlap anywhere, or even touch.

Tests with the specified envelope for a collision. If any part of the M bounds are invalid, this will default to the XY Intersect comparison.

The envelope to test. Boolean.

Since M values are optional, they can be set to an invalid state, which will behave the same as if the M bounds did not exist.

Sets the values for xMin, xMax, yMin and yMax.

Tests if this envelope is contained by the specified envelope. If either party doesn't have M constraints, they will not be used for this test.

implementation of IExtent to compare to.

Tests if this envelope is contained by the specified envelope. If either envelope doesn't support M then only the X and Y case will be tested.

The envelope to compare. Boolean.

Allows equality testing for extents that is derived on the extent itself.

Creates a string that shows the extent.

The string form of the extent.

Spreads the values for the basic X, Y extents across the whole range of int. Repetition will occur, but it should be rare.

Integer

For shapefiles, the extents may or may not have M and Z values depending on the file type. These are valid IExtent implementations, but add both the M and Z extent options. For the file format, the Z values are mandatory, and so whatever the values are will be stored. This may cause issues when viewing in ArcGIS if you have entered some bad Z envelope extents.

The Extent interface for Z dimension extent bounds.

The minimum in the Z dimension (usually the bottom)

The maximum in the Z dimension (usually the top)

Initializes a new instance of the ExtentMZ class.

The double Minimum in the X direction. The double Minimum in the Y direction. The double Minimum in the Measure category. The double Minimum in the Z direction. The double Maximum in the X direction. The double Maximum in the Y direction. The double Maximum in the Measure category. The double Maximum in the Z direction.

Initialize a new instance of the ExtentMZ class.

The Envelope to read the minimum and maximum values from.

Since M values are optional, they can be set to an invalid state, which will behave the same as if the M bounds did not exist.

Copies from the implementation of IExtent. This checks to see if IExtentM is implemented and if not, this only sets the X and Y bounds.

Sets the values for xZin, xMax, yMin and yMax.

Tests if this envelope is contained by the specified envelope

The coordinate to test. Boolean.

Returns true if the coordinate exists anywhere within this envelope. If this envelope represents a valid Z extent by having a max greater than min and neither value being NaN, then this will also test the coordinate for the Z range.

The Coordinate to test. Boolean

Tests for intersection with the specified coordinate. If the m is double.NaN then it degenerates to only testing M, X and Y, even if this envelope has an M range.

The double ordinate to test intersection with in the X direction. The double ordinate to test intersection with in the Y direction. The optional double measure parameter to test. The double ordinate to test intersection with in the Z direction. Boolean

Tests for an intersection with the specified extent. Both this extent and the other must implement IExtentM and HasM must be true for both, or else just the X and Y are compared.

The other extent. If the extent doesn't implement IExtentM, then this comparison simply defaults to the M, X and Y intersect case. Boolean, true if they overlap anywhere, or even touch.

Tests with the specified envelope for a collision. If any part of the Z bounds are invalid, this will default to the M, X and Y Intersect comparison.

The envelope to test. Boolean.

Calculates the intersection of this extent and the other extent. A result with a min greater than the max in either direction is considered invalid and represents no intersection.

The other extent to intersect with.

Expands this extent to include the domain of the specified extent. If the specified case doesn't support IExtentM or HasM is false for that extent, then this test will default to the M, X and Y case.

The extent to expand to include

The double padding to expand the extent.

Expands this extent to include the domain of the specified point

The x ordinate to expand to. The y ordinate to expand to. The m ordinate to expand to. The z ordinate to expand to.

Tests if this envelope is contained by the specified envelope. If either party doesn't have M constraints, they will not be used for this test.

implementation of IExtent to compare to. Boolean.

Tests if this envelope is contained by the specified envelope

The extent to test. Boolean.

Tests if this envelope is contained by the specified envelope. If either envelope doesn't support M then only the XY case will be tested.

The envelope to compare. Boolean.

Tests if this envelope is contained by the specified envelope. If either element does not support M values, then only the default XY contains test is used.

The envelope to test. Boolean.

Creates a string that shows the extent.

The string form of the extent.

Produces a clone, rather than using this same object.

Returns a copy of this object.

Allows equality testing for extents that is derived on the extent itself.

Spreads the values for the basic X, Y extents across the whole range of int. Repetition will occur for extents that are close, but should be rare.

Integer

The string template that should be used. M and Z are optional. Do use a comma to delimit terms, but the space doesn't matter. Do use square brackets to enclose numbers, and do use the | separator to separate min from max. Do place min before max in each term. The order of the terms doesn't matter. Use periods for decimals and an invariant culture.

Initializes a new instance of the ExtentParseException

The string message to parse.

Initializes a new instance of the ExtentParseException

The string message to parse. The inner exception that caused this exception.

Initializes a new instance of the ExtentParseException

The Serialization info class that holds the serialized object about which the exception is being thrown. The streaming context that contains contextual information about the source or destination.

Gets the string expression that provoked the exception.

Represents strongly named DataRow class.

This interface allows access to geometries and attributes in a more cohesive package.

Stores the shape to the GEOMETRY WKB.

Stores the geometry to the geometry wkb.

This is a cached extent. This will not reflect changes in Geometry or Shape unless they have been stored, but will reflect the most recently stored or retrieved extent from accessing either the shape or geometry. In cases where reading from WKB, this will be lazily created, but it will be cached when reading from shapefiles.

A Geometry created lazily from a WKB byte structure in the GEOMETRY field preferentially or if the field is DBNull and the shape is not null, then from the Shape object.

A Shape that is either created lazily from the WKB Geometry or directly from a shapefile.

The rest of the attributes are stored by an indexed property.

Boolean, true if the geometry has already been created, false otherwise.

Boolean, true if the shape has already been created, false otherwise.

Boolean, true if the extent has been created, false otherwise.

Creates a new instance of the FeatureRow class.

Stores the shape into the WKB for storage in a database, overwriting any existing value.

Stores the goemetry as WKB, overwriting any existing value.

Sets the geometry field to DBNull.

Gets whether the geometry is null.

Boolean, true if the column is null.

A long integer representing the FID.

The Byte form of the Geometry

From shapefiles, this should be cached. Any other source must likely create the extent from a geometry, and possibly all the way from WKB.

A lazily created and cached geometry.

Boolean, true if the extent has been created, false otherwise.

Boolean, true if the geometry has already been created, false otherwise.

Boolean, true if the shape has already been created, false otherwise.

When reading from WKB, the Shape is lazily created. When reading from sources like a shapefile, the Shape is actually pre-fetched because the value exists as a shape rather than a geometry.

Row event argument class

A new event argument for events in a FeatureTable.

The FeatureRow of the event. The action occuring for this event.

The FeatureRow for this event.

The action for this event.

An EventArgs specifically tailored to FeatureSet.

Initializes a new instance of the FeatureSetEventArgs class.

The IFeatureSet that is involved in this event.

Gets the Raster associated with this event.

Callback specified when calling IFeatureSource.SearchAndModifyAttributes

FeatureSourceRowEditEvent arguments

RowEditEvent arguments

Shape geometry associated with the row

Construct FeatureSourceRowEditEventArgs

Represents the strongly named DataTable class.

Initializes a new instance of a FeatureTable class.

Adds the specified FeatureRow to this FeatureTable.

the row to add.

Generates a new feature row using only the goemetry.

The byte form of the well known text to use in creating a new, otherwise empty row. The newly created FeatureRow with the specified well known text.

Retrieves a newly generated row from this table cast as a FeatureRow.

The FeatureRow class.

Finds a FeatureRow by the FID field.

The long fid to find A FeatureRow

Removes the specified row from the table.

The FeatureRow to remove.

Generates a new feature row using only the goemetry.

The byte form of the well known text to use in creating a new, otherwise empty row. The newly created FeatureRow with the specified well known text.

This may or may not be required for proper functioning, but is not part of the public API.

A DataTable

This may not work since I stripped off the xml related auto text that seems to rely on an existing dataset

Occurs while the row is changing

Occurs after the row has been changed.

Occurs while the row is being deleted.

Occurs after the row has been deleted.

The integer number of rows in this table.

The Column containing the FID value.

The Column containing the Geometry column.

Optionally gets or sets a geometry factory to use when instantiating geometries from WKB for the rows of this table.

Accesses the FeatureRow of this table based on the specified index.

The integer index of the feature row to access. This FeatureRow

Manage the Fields associated with a dbase

Construct Fields and update the individual field data addresses

Add a field

Update the DataAddress of each field

Retrieve field by ordinal

Retrieve field by name

Get number of fields

An interface for specifying something has a Bounds property on it that is a raster bounds.

Gets or sets the image bounds being used to define the georeferencing of the image

Returns the bitmap

Attempts to create a bitmap for the entire image. This may cause memory exceptions.

A Bitmap of the image.

The geographic envelope gives the region that the image should be created for. The window gives the corresponding pixel dimensions for the image, so that images matching the resolution of the screen can be used.

The geographic extents to retrieve data for The rectangle that defines the size of the drawing area in pixels A bitmap captured from the main image

Reads the file.

The filename.

IDataProvider is what you implement to expand the data handling methods of DotSpatial

This open method is only called if this plugin has been given priority for one of the file extensions supported in the DialogReadFilter property supplied by this control. Failing to provide a DialogReadFilter will result in this plugin being added to the list of DataProviders being supplied under the Add Other Data option in the file menu.

A string specifying the complete path and extension of the file to open. A List of IDataSets to be added to the Map. These can also be groups of datasets.

Gets a dialog read filter that lists each of the file type descriptions and file extensions, delimited by the | symbol. Each will appear in DotSpatial's open file dialog filter, preceded by the name provided on this object.

Gets a dialog filter that lists each of the file type descriptions and extensions for a Save File Dialog. Each will appear in DotSpatial's open file dialog filter, preceded by the name provided on this object. In addition, the same extension mapping will be used in order to pair a string driver code to the extension.

Gets a preferably short name that identifies this data provider. Example might be GDAL. This will be prepended to each of the DialogReadFilter members from this plugin.

Gets or sets the progress handler to use.

This provides a basic description of what your provider does.

Opens a new LiDAR LAS with the specified fileName

The string file to open An IImageData object

An EventArgs specifically tailored to ImageData.

Initializes a new instance of the ImageDataEventArgs class.

The IImageData that is involved in this event.

Gets the ImageData associated with this event.

An enumeration for specifying the endian byte order to use.

Specifies big endian like mainframe or unix system.

Specifies little endian like most pc systems.

A new interface for accessing database or file features to large for memory. This allows editing only for attribute content, but allows Add, Remove, AddRange, and Query functionality that covers both vector and raster content.

Updates the file with an additional feature.

Removes the feature with the specified index

Removes the feature from the specified index location

The default implementation calls the add method repeatedly.

The set of features to add

Select function passed with a filter expression.

The string filter expression based on attributes The envelope for vector filtering. The integer start index where values should be checked. This will be updated to the last index that was checked before the return, so that paging the query can begin with that index in the next cycle. Be sure to add one before the next call. The integer maximum number of IFeature values that should be returned. A dictionary with FID keys and IFeature values.

Conditionally modify attributes as searched in a single pass via client supplied callback.

The envelope for vector filtering. Number of shapes to request from the ShapeSource in each chunk Callback on each feature

Edits the values of the specified row in the attribute table. Since not all data formats can handle the dynamic change of attributes, updating vectors can be done with Remove and Add.

The feature offest The row of new attribute values.

Edits the values of the specified rows in the attribute table.

Adding and removing shapes may make the bounds for the entire shapefile invalid. This triggers a check that ensures that the collective extents contain all the shapes.

The geographic extent of the feature source

Get the attribute table associated with the feature source

An enumeration listing the types of image band interpretations supported.

Alpha, Red, Green, Blue 4 bytes per pixel, 4 bands

Red, Green, Blue 3 bytes per pixel, 3 bands

Gray as one byte per pixel, 1 band

Colors encoded 1 byte per pixel, 1 band

Sets the InRamImage for this class. This is just a georeferenced .Net bitmap that also implements IGetBitmap for cross purpose use with IImageData implementations.

Initializes a new instance of an InRamImage class. This class supports a basic .Net Image plus a geographic extent as a RasterBounds. This class does not feature any byte level data access or built in file access. The expectation is that this will only be used in memory.

THe Bitmap image to use to create this image.

Returns the internal bitmap in this case. In other cases, this may have to be constructed from the unmanaged memory content.

A Bitmap that represents the entire image.

The geographic extents to retrieve data for The rectangle that defines the size of the drawing area in pixels A bitmap captured from the main image

Sets the bitmap for this InRamImage to use.

the value to set.

If byte access is required, a new class can be created that is a copy of this class for modifying values byte by byte.

Gets or sets the raster bounds

The Projection interface that acts as a useful tool for calculating pixel coordinates to geographic coordinates and vise-versa.

The Rectangle representation of the geographic extents in image coordinates

The geographic extents used for projection.

This interface specifically insists on an IRasterBounds as the Bounds property.

A very generic interface that is implemented by any dataset, regardless of what kinds of data that it has.

This interface supports the basic Reprojection content. CanReproject tests to see if the DotSpatial.Projections library exists and will return false if it does not exist. In such a case the

Reprojects all of the in-ram vertices of vectors, or else this simply updates the "Bounds" of image and raster objects This will also update the projection to be the specified projection.

The projection information to reproject the coordinates to.

Gets a value indicating whether the DotSpatial.Projections assembly is loaded. If not, this returns false, and neither ProjectionInfo nor the Reproject() method should be used.

Boolean, true if the value can reproject.

Gets or sets the projection information for this dataset

Gets or sets the proj4 string for this dataset. This exists in case the Projections library is not loaded. If the projection library is loaded, this also updates the Projection property. Setting this behaves like defining the projection and will not reproject the values.

This closes the data set. Many times this will simply do nothing, but in some cases this may close an open connection to a data source.

True if the dispose method has been called on this dataset.

Gets or sets a string name identifying this dataset

Gets or sets the progress handler to use for internal actions taken by this dataset.

Gets or sets the space time support for this dataset.

Gets or sets a string that describes as clearly as possible what type of elements are contained in this dataset.

Rendering is considered a different pathway from editing. For rendering, we can distance ourselves from the attributes all together in order to speedily grab just the indices that are within the view extent.

Returns a dictionary with the FID and Shape, but only returns shapes within the envelope.

The integer offset of the first shape to test. When this returns, the offset is set to the integer index of the last shape tested, regardless of whether or not it was returned. The integer count of the maximum number of shapes to return here. The geographic extents that can be used to limit the shapes. If this is null, then no envelope is used. The Dictionary with FID indices and Shape values

Returns array of shapes at the specified indices

Gets the integer count of the total number of shapes in the set. This may run a query, so it is better to cache the result than call this repeatedly.

The integer number of shapes in the entire source.

Should be called when done making repeated calls to GetShapes to free internal resources.

This is most likely set once per source.

LineShape

Calculates the intersection of a polygon shape without relying on the NTS geometry

Tests to see if any vertices from the other shape are coincident with a segment from this line shape.

Returns true if any segment from a line or polygon shape interesect any segments from the line or polygon shape.

A Line or Polygon shape Another line or polygon shape

Gets or sets the precision for calculating equality, but this is just a re-direction to Vertex.Epsilon

This class is strictly the vector access code. This does not handle the attributes, which must be handled independantly.

Provides common functionality for all ShapefileFeatureSource classes (Point, Line, Polygon)

Sets the fileName and creates a new ShapefileFeatureSource for the specified file.

The fileName to work with.

Sets the fileName and creates a new PolygonshapefileFeatureSource for the specified file (and builds spatial index if requested)

This deletes the files with any extension and the same base fileName.

Spatial index for faster searches

Create a ShapefileFeatureSource of the appropriate type

Create a ShapefileFeatureSource of the appropriate type spatial indexing

Update the header to include the feature extent

Update header extents from the geometries in a IShapeSource

Select the features in an IShapeSource

Conditionally modify attributes as searched in a single pass via client supplied callback.

ShapeSource for this feature source The envelope for vector filtering. Number of shapes to request from the ShapeSource in each chunk Callback on each feature

Append the geometry to the shapefile

Create an appropriate ShapeSource for this FeatureSource

Gets or sets the Filename of this polygon shapefile.

The integer maximum number of records to return in a single page of results.

Gets the spatial index if any

Get the feature type supported by this feature source

Get the shape type (without M or Z) supported by this feature source

Get the shape type (with M, and no Z) supported by this feature source

Get the shape type (with M and Z) supported by this feature source

Gets the AttributeTable for this feature source including DeletedRows

Sets the fileName and creates a new LineShapefileFeatureSource for the specified file.

The fileName to work with.

Sets the fileName and creates a new LineShapefileFeatureSource for the specified file (and builds spatial index if requested)

Retrieves specific shapes.

Common functionality for retrieving specific shapes.

Cached contents of shape index file

Creates a new instance of the ShapefileShapeSource with the specified shapefile as the source.

Creates a new instance of the ShapefileShapeSource with the specified shapefile as the source and supplied spatial and shape indices.

Cache Index File in memory so we don't have to read it in every call to GetShapes

Get the shape at the specified index. Must be implemented by all shape sources derived from ShapefileShapeSource

Get the shape type (without M or Z) supported by this shape source

Get the shape type (with M, and no Z) supported by this shape source

Get the shape type (with M and Z) supported by this shape source

Creates a new instance of the LineShapefileShapeSource with the specified line shapefile as the source.

The string fileName

Creates a new instance of the LineShapefileShapeSource with the specified polygon shapefile as the source and provided indices

General purpose Expression utilities

Create a function delegate representing a unary operation

The parameter type The return type Body factory Compiled function delegate

Create a function delegate representing a binary operation

The first parameter type The second parameter type The return type Body factory Compiled function delegate

Create a function delegate representing a binary operation

The first parameter type The second parameter type The return type Body factory If no matching operation is possible, attempt to convert TArg1 and TArg2 to TResult for a match? For example, there is no "decimal operator /(decimal, int)", but by converting TArg2 (int) to TResult (decimal) a match is found. Compiled function delegate

The Operator class provides easy access to the standard operators (addition, etc) for generic types, using type inference to simplify usage.

Indicates if the supplied value is non-null, for reference-types or Nullable<T>

True for non-null values, else false

Increments the accumulator only if the value is non-null. If the accumulator is null, then the accumulator is given the new value; otherwise the accumulator and value are added.

The current total to be incremented (can be null) The value to be tested and added to the accumulator True if the value is non-null, else false - i.e. "has the accumulator been updated?"

Evaluates unary negation (-) for the given type; this will throw an InvalidOperationException if the type T does not provide this operator, or for Nullable<TInner> if TInner does not provide this operator.

Evaluates bitwise not (~) for the given type; this will throw an InvalidOperationException if the type T does not provide this operator, or for Nullable<TInner> if TInner does not provide this operator.

Evaluates bitwise or (|) for the given type; this will throw an InvalidOperationException if the type T does not provide this operator, or for Nullable<TInner> if TInner does not provide this operator.

Evaluates bitwise and (&) for the given type; this will throw an InvalidOperationException if the type T does not provide this operator, or for Nullable<TInner> if TInner does not provide this operator.

Evaluates bitwise xor (^) for the given type; this will throw an InvalidOperationException if the type T does not provide this operator, or for Nullable<TInner> if TInner does not provide this operator.

Performs a conversion between the given types; this will throw an InvalidOperationException if the type T does not provide a suitable cast, or for Nullable<TInner> if TInner does not provide this cast.

Evaluates binary addition (+) for the given type; this will throw an InvalidOperationException if the type T does not provide this operator, or for Nullable<TInner> if TInner does not provide this operator.

Evaluates binary addition (+) for the given type(s); this will throw an InvalidOperationException if the type T does not provide this operator, or for Nullable<TInner> if TInner does not provide this operator.

Evaluates binary subtraction (-) for the given type; this will throw an InvalidOperationException if the type T does not provide this operator, or for Nullable<TInner> if TInner does not provide this operator.

Evaluates binary subtraction(-) for the given type(s); this will throw an InvalidOperationException if the type T does not provide this operator, or for Nullable<TInner> if TInner does not provide this operator.

Evaluates binary multiplication (*) for the given type; this will throw an InvalidOperationException if the type T does not provide this operator, or for Nullable<TInner> if TInner does not provide this operator.

Evaluates binary multiplication (*) for the given type(s); this will throw an InvalidOperationException if the type T does not provide this operator, or for Nullable<TInner> if TInner does not provide this operator.

Evaluates binary division (/) for the given type; this will throw an InvalidOperationException if the type T does not provide this operator, or for Nullable<TInner> if TInner does not provide this operator.

Evaluates binary division (/) for the given type(s); this will throw an InvalidOperationException if the type T does not provide this operator, or for Nullable<TInner> if TInner does not provide this operator.

Evaluates binary equality (==) for the given type; this will throw an InvalidOperationException if the type T does not provide this operator, or for Nullable<TInner> if TInner does not provide this operator.

Evaluates binary inequality (!=) for the given type; this will throw an InvalidOperationException if the type T does not provide this operator, or for Nullable<TInner> if TInner does not provide this operator.

Evaluates binary greater-than (>) for the given type; this will throw an InvalidOperationException if the type T does not provide this operator, or for Nullable<TInner> if TInner does not provide this operator.

Evaluates binary less-than (<) for the given type; this will throw an InvalidOperationException if the type T does not provide this operator, or for Nullable<TInner> if TInner does not provide this operator.

Evaluates binary greater-than-on-eqauls (>=) for the given type; this will throw an InvalidOperationException if the type T does not provide this operator, or for Nullable<TInner> if TInner does not provide this operator.

Evaluates binary less-than-or-equal (<=) for the given type; this will throw an InvalidOperationException if the type T does not provide this operator, or for Nullable<TInner> if TInner does not provide this operator.

Evaluates integer division (/) for the given type; this will throw an InvalidOperationException if the type T does not provide this operator, or for Nullable<TInner> if TInner does not provide this operator.

This operation is particularly useful for computing averages and similar aggregates.

Provides standard operators (such as addition) that operate over operands of different types. For operators, the return type is assumed to match the first operand.

Returns a delegate to convert a value between two types; this delegate will throw an InvalidOperationException if the type T does not provide a suitable cast, or for Nullable<TInner> if TInner does not provide this cast.

Returns a delegate to evaluate binary addition (+) for the given types; this delegate will throw an InvalidOperationException if the type T does not provide this operator, or for Nullable<TInner> if TInner does not provide this operator.

Returns a delegate to evaluate binary subtraction (-) for the given types; this delegate will throw an InvalidOperationException if the type T does not provide this operator, or for Nullable<TInner> if TInner does not provide this operator.

Returns a delegate to evaluate binary multiplication (*) for the given types; this delegate will throw an InvalidOperationException if the type T does not provide this operator, or for Nullable<TInner> if TInner does not provide this operator.

Returns a delegate to evaluate binary division (/) for the given types; this delegate will throw an InvalidOperationException if the type T does not provide this operator, or for Nullable<TInner> if TInner does not provide this operator.

Provides standard operators (such as addition) over a single type

Returns the zero value for value-types (even full Nullable<TInner>) - or null for reference types

Returns a delegate to evaluate unary negation (-) for the given type; this delegate will throw an InvalidOperationException if the type T does not provide this operator, or for Nullable<TInner> if TInner does not provide this operator.

Returns a delegate to evaluate bitwise not (~) for the given type; this delegate will throw an InvalidOperationException if the type T does not provide this operator, or for Nullable<TInner> if TInner does not provide this operator.

Returns a delegate to evaluate bitwise or (|) for the given type; this delegate will throw an InvalidOperationException if the type T does not provide this operator, or for Nullable<TInner> if TInner does not provide this operator.

Returns a delegate to evaluate bitwise and (&) for the given type; this delegate will throw an InvalidOperationException if the type T does not provide this operator, or for Nullable<TInner> if TInner does not provide this operator.

Returns a delegate to evaluate bitwise xor (^) for the given type; this delegate will throw an InvalidOperationException if the type T does not provide this operator, or for Nullable<TInner> if TInner does not provide this operator.

Returns a delegate to evaluate binary addition (+) for the given type; this delegate will throw an InvalidOperationException if the type T does not provide this operator, or for Nullable<TInner> if TInner does not provide this operator.

Returns a delegate to evaluate binary subtraction (-) for the given type; this delegate will throw an InvalidOperationException if the type T does not provide this operator, or for Nullable<TInner> if TInner does not provide this operator.

Returns a delegate to evaluate binary multiplication (*) for the given type; this delegate will throw an InvalidOperationException if the type T does not provide this operator, or for Nullable<TInner> if TInner does not provide this operator.

Returns a delegate to evaluate binary division (/) for the given type; this delegate will throw an InvalidOperationException if the type T does not provide this operator, or for Nullable<TInner> if TInner does not provide this operator.

Returns a delegate to evaluate binary equality (==) for the given type; this delegate will throw an InvalidOperationException if the type T does not provide this operator, or for Nullable<TInner> if TInner does not provide this operator.

Returns a delegate to evaluate binary inequality (!=) for the given type; this delegate will throw an InvalidOperationException if the type T does not provide this operator, or for Nullable<TInner> if TInner does not provide this operator.

Returns a delegate to evaluate binary greater-then (>) for the given type; this delegate will throw an InvalidOperationException if the type T does not provide this operator, or for Nullable<TInner> if TInner does not provide this operator.

Returns a delegate to evaluate binary less-than (<) for the given type; this delegate will throw an InvalidOperationException if the type T does not provide this operator, or for Nullable<TInner> if TInner does not provide this operator.

Returns a delegate to evaluate binary greater-than-or-equal (>=) for the given type; this delegate will throw an InvalidOperationException if the type T does not provide this operator, or for Nullable<TInner> if TInner does not provide this operator.

Returns a delegate to evaluate binary less-than-or-equal (<=) for the given type; this delegate will throw an InvalidOperationException if the type T does not provide this operator, or for Nullable<TInner> if TInner does not provide this operator.

PointShape

Calculates the intersection of a polygon shape without relying on the NTS geometry

Returns true if any vertices overlap

Gets or sets the precision for calculating equality, but this is just a re-direction to Vertex.Epsilon

This class is strictly the vector access code. This does not handle the attributes, which must be handled independantly.

Sets the fileName and creates a new PointShapefileFeatureSource for the specified file.

The fileName to work with.

Sets the fileName and creates a new PointshapefileFeatureSource for the specified file (and builds spatial index if requested)

Retrieves specific shapes.

Creates a new instance of the PointShapefileShapeSource with the specified point shapefile as the source.

The string fileName

Creates a new instance of the PointShapefileShapeSource with the specified polygon shapefile as the source and provided indices

Polygon contains algorithms for the case where the current feature type is a polygon. The shape may be single or multi-part.

Calculates the intersection of a polygon shape without relying on the NTS geometry

This cycles through all the vertices, which are stored as {X1, Y1, X2, Y2...Xn, Yn} and tests if any of those vertices falls within the polygon shape.

For each coordinate in the other part, if it falls in the extent of this polygon, a ray crossing test is used for point in polygon testing. If it is not in the extent, it is skipped.

The part of the polygon to analyze polygon The other part Boolean, true if any coordinate falls inside the polygon

Gets or sets the precision for calculating equality, but this is just a re-direction to Vertex.Epsilon

DataFormats

Lines, Points and Polygons make up standard static vector formats. These are drawn dynamically based on the symbolizer.

Rasters are grids of integers, doubles, floats, or other numeric value types. These can be symbolized and represented as images, but not drawn directly.

Images specifically have pixels coordinates that store a color. These are drawn directly.

This represents an extended format that does not have a formal definition in DotSpatial.

This can be used as a component to work as a DataManager. This also provides the very important DefaultDataManager property, which is where the developer controls what DataManager should be used for their project.

IDataManager

This can help determine what kind of file format a file is, without actually opening the file.

The string fileName to test A DataFormats enum

Instead of opening the specified file, this simply determines the correct provider, and requests that the provider check the feature type for vector formats.

The string fileName to test A FeatureTypes enum

Checks a dialog filter and returns a list of just the extensions.

The Dialog Filter to read extensions from A list of extensions

Attempts to call the open fileName method for any IDataProvider plugin that matches the extension on the string.

A String fileName to attempt to open.

Attempts to call the open fileName method for any IDataProvider plugin that matches the extension on the string.

A String fileName to attempt to open. A boolean value that if true will attempt to force a load of the data into memory. This value overrides the property on this DataManager.

Attempts to call the open fileName method for any IDataProvider plugin that matches the extension on the string.

A String fileName to attempt to open. A boolean value that if true will attempt to force a load of the data into memory. This value overrides the property on this DataManager. Specifies the progressHandler to receive progress messages. This value overrides the property on this DataManager.

Opens the file as an Image and returns an IImageData object for interacting with the file.

The string fileName An IImageData object

Opens the file as an Image and returns an IImageData object

The string fileName to open The progressHandler to receive progress updates An IImageData

Opens the specified fileName, returning an IRaster. This will return null if a manager either returns the wrong data format.

The string fileName to open An IRaster loaded from the specified file.

Opens the specified fileName, returning an IRaster. This will return null if a manager either returns the wrong data format.

The string fileName to open boolean, true if this should be loaded into ram a progress interface An IRaster loaded from the specified file

Opens a specified file as an IFeatureSet

The string fileName to open boolean, true if this should be loaded into ram a progress interface An IFeatureSet loaded from the specified file

Creates a new image using an appropriate data provider

The string fileName to open an image for The integer number of rows The integer number of columns The color band type. An IImageData interface allowing access to image data

Creates a new image using an appropriate data provider

The string fileName to open an image for The integer number of rows The integer number of columns Boolean, true if the entire file should be created in memory The color band type. An IImageData interface allowing access to image data

Creates a new image using an appropriate data provider

The string fileName to open an image for The integer number of rows The integer number of columns Boolean, true if the entire file should be created in memory A Progress handler The color band type. An IImageData interface allowing access to image data

Creates a new class of vector that matches the given fileName.

The string fileName from which to create a vector. Specifies the type of feature for this vector file An IFeatureSet that allows working with the dataset.

Creates a new class of vector that matches the given fileName.

The string fileName from which to create a vector. Specifies the type of feature for this vector file Overrides the default progress handler with the specified progress handler An IFeatureSet that allows working with the dataset.

Creates a new raster using the specified raster provider and the Data Manager's Progress Handler, as well as its LoadInRam property.

The fileName of the new file to create. The string code identifying the driver to use to create the raster The number of columns in the raster The number of rows in the raster The number of bands in the raster The data type for the raster Any additional, driver specific options for creation An IRaster representing the created raster.

Gets or sets the list of IDataProviders that should be used in the project.

Gets or sets the dialog read filter to use for opening data files.

Gets or sets the dialog write filter to use for saving data files.

Sets the default condition for how this data manager should try to load layers. This will be overridden if the inRam property is specified as a parameter.

Gets or sets the dialog read filter to use for opening data files that are specifically raster formats.

Gets or sets the dialog write filter to use for saving raster files.

Gets or sets the dialog read filter to use for opening vector files.

Gets or sets the dialog write filter to use for saving vector files.

Gets or sets the dialog read filter to use for opening image files.

Gets or sets the dialog write filter to use for saving image files.

Gets or sets a dictionary of IDataProviders keyed by the extension. The standard order is to try to load the data using a PreferredProvider. If that fails, then it will check the list of dataProviders, and finally, if that fails, it will check the plugin Data Providers in directories.

Gets or sets a progress handler for any open operations that are intiated by this DataManager.

Occurs after the directory providers have been loaded into the project.

Creates a new instance of the DataManager class. A data manager is more or less just a list of data providers to use. The very important DataManager.DefaultDataManager property controls which DataManager will be used to load data. By default, each DataManager sets itself as the default in its constructor.