gislab-elte / aegis Goto Github PK

A polyhedral surface is a contiguous collection of polygons, which share common boundary segments. For each pair of polygons that "touch", the common boundary shall be expressible as a finite collection of line strings. Each such Line string shall be part of the boundary of at most 2 polygon patches. A TIN (triangulated irregular network) is a polyhedral surface consisting only of Triangle patches.

See: OpenGIS Implementation Standard for Geographic information - Simple feature access - Part 1: Common architecture

Create the IPolyhedralSurface interface in the Core namespace, and implement the interface in the PolyhedralSurface class as a descendant of Geometry in the Geometries namespace with in-memory storage of data.

The Core.Reference package offers an offline source of the EPSG geodetic parameter dataset in text files with extraction methodology specified in the Source.Local namespace. A similar online source can be added using the EPSG web API. API specification can be found here: http://www.iogp.org/pubs/373-07-3.pdf

The interfaces found in the Source namespace must be implemented to perform query and translation of registry objects.

Cohen-Daubechies-Feauveau wavelet are the historically first family of biorthogonal wavelets. Two variants, 5/3 and 9/7 are generally used for image compression.

These two variants are to be implemented in the Numerics.Wavelet namespace. Additionally to the specific classes, a generic interface (IWavelet) should be added, which offer forward (Forward) and reverse (Reverse) transformation methods for 1D and 2D sequence of floating point values.

See: https://en.wikipedia.org/wiki/Cohen-Daubechies-Feauveau_wavelet

A k-d tree (short for k-dimensional tree) is a space-partitioning data structure for organizing points in a k-dimensional space by using binary partitioning.

Introduce the KdTree type implementing the ICoordinateIndex interface in the Core/Indexes namespace. The tree should handle 2D/3D coordinates. The constructor should consume a collection of coordinates (IEnumerable<Coordinate>) to create a balanced tree. Additionally to the specified methods, the tree should also enable nearest-neighbor searches.

See: https://en.wikipedia.org/wiki/K-d_tree

The Hadoop Distributed File System (HDFS) is supported by the HadoopFileSystem type using HTTP requests. However, the file system also offers operations which return an open stream to the file allocated on the file system, which is not supported by the build-in HTTP handlers.

To simulate the open stream in the HTTP environment, add a custom Stream type named HadoopStream, which utilizes the already available file system operation types to perform read/write queries on the remote files. The type should hide all limitations of Hadoop, and should support standard exceptions.

Cubic spline interpolation is a general interpolation technique using a polynomial of third degree.

See: https://en.wikipedia.org/wiki/Spline_interpolation#Algorithm_to_find_the_interpolating_cubic_spline

Add CubicSplineIntepolation class to the Numerics.Interpolation namespace. The class should be instantiable, with possibility for computation and query of the results (polynomial coefficients) through property. Support for applications in the form of static methods should also be added.

Singular value decomposition (SVD) is a factorization of a matrix with multiple applications such as solving linear equations, total least squares minimization, etc.

See: https://en.wikipedia.org/wiki/Singular_value_decomposition

Add SingularValueDecomposition class to the Numerics.LinearAlgebra namespace with a similar style as other decomposition classes in the namespace. Support for applications in the form of static methods should also be added.

In some cases, when processing geospatial input files, a single geometry is separated into multiple files, such as in case of the Shapefile format, or satellite imagery (e.g. Landsat, Sentinel). To enable more efficient handling of data, uses simply compress the files into a single file (e.g. ZIP) and use this as input is GIS.
To enable support for such cases, file system operations such as directory browsing, file opening and streaming should also function within the compressed file.

Introduce the CompressedFileSystem type in the Storage/FileSystems namespace to provides these functionalities within the compressed file to enable IO types to read or write the data. Use FileSystemBase as the base type. The type should rely on an existing compressed file handling package, which supports the most common compression formats (.zip has the biggest priority, but tar.gz and .7z would be also beneficiary).

The type should be tested with a compressed temporary file, and executing all possible commands within the file including reading/writing data.

Executing the RandomPolygonGeneratorCreateRandomPolygonTest() and the MonotoneSubdivisionTriangulateTest() test cases randomly throw errors.

The source of the error can be traced back to the ShamosHoeyAlgorithm, to this line:
https://github.com/robertogiachetta/aegis/blob/767329c634ce27c87f8f17bd326ba92dd8b34fe9/src/Core/Algorithms/ShamosHoeyAlgorithm.cs#L159

Further following the error results in a NullReferenceException when rotating a BinarySearchTree either left or right:
https://github.com/robertogiachetta/aegis/blob/767329c634ce27c87f8f17bd326ba92dd8b34fe9/src/Collections/SearchTrees/BinarySearchTree.cs#L375-L381
Here rightChild is null in the last line.

https://github.com/robertogiachetta/aegis/blob/767329c634ce27c87f8f17bd326ba92dd8b34fe9/src/Collections/SearchTrees/BinarySearchTree.cs#L415-L421
Here leftChild is null in the last line.

Chan's algorithm is an optimal output-sensitive convex hull computation algorithm. It is therefore more efficient thatn the Graham scan algorithm.

See: https://en.wikipedia.org/wiki/Chan%27s_algorithm

Add the ChansAlgorithm class to the Core.Algorithms namespace. The class should be instantiable, with possibility for computation and query of the results (the list of coordinates of the convex hull) through property. Support for applications in the form of static methods should also be added.

Geographic Offset by Interpolation of Gridded Data is a collection of coordinate operations applied over a predefined spatial grided data set with latitude and longitude offsets. This include the following grid: NADCON which is used by the US National Geodetic Survey for transformation between US systems; NTv2 which originated in the national mapping agency of Canada and was subsequently adopted in Australia, New Zealand and then several other countries; and OSTN used in Great Britain.

See: OGP Publication 373-7-2 – Geomatics Guidance Note number 7, part 2, page 145.

Add coordinate operations implementing these interpolations as descendants of CoordinateTransformation<GeoCoordinate> in the Core.Reference/Collections.Formula namespace in the Transformations folder. The interpolation should be defined in a base class for all offsets (i.e. GeographicOffsetByInterpolation), and subclasses (e.g. NTv2GeographicOffsetByInterpolation) should load the different grid files. Grid files can be added to the Core.Reference/Resources folder as built-in resources.

The Cyrus-Beck algorithm is a generalized line clipping algorithm, an advancement of the Cohen-Sutherland algorithm using a polygonal clipping window.

See: https://en.wikipedia.org/wiki/Cyrus%E2%80%93Beck_algorithm

Add CyrusBeckAlgorithm class to the Core.Algorithms namespace. The class should be instantiable, with possibility for computation and query of the results (clipped line strings) through property. Support for applications in the form of static methods should also be added.

Geographic offsets are simple 2D/3D transformations between two geographic coordinate reference systems used for purposes where low accuracy can be tolerated.

See: OGP Publication 373-7-2 – Geomatics Guidance Note number 7, part 2, page 144.

Add GeographicOffset2D and GeographicOffset3D classes as descendants of CoordinateTransformation<GeoCoordinate> in the Core.Reference/Collections.Formula namespace in the Transformations folder.

Cubic Hermite spline interpolation is a general interpolation technique using a third-degree polynomial specified in Hermite form.

See: https://en.wikipedia.org/wiki/Spline_interpolation#Algorithm_to_find_the_interpolating_cubic_spline

Add CubicHermiteSplineIntepolation class to the Numerics.Interpolation namespace. The class should be instantiable, with possibility for computation and query of the results (polynomial coefficients) through property. Support for applications in the form of static methods should also be added.

Upgrading SimpleInjector to version 5, automatic verification is enabled. A cyclic graph is found for the defined injections of the reference systems.

The configuration is invalid. Creating the instance for type IReferenceCollection<CompoundReferenceSystem> failed. The configuration is invalid. The type LocalCompoundReferenceSystemCollection is directly or indirectly depending on itself. The cyclic graph contains the following types: LocalCompoundReferenceSystemCollection -> LocalReferenceSystemCollection -> LocalCompoundReferenceSystemCollection.

GeoAPI project provides a set of interfaces for geospatial applications to facilitate compatibility. GeoAPI is defined according to the OGC Simple Features Access specification. Although the API is built in Java, the NetTopologySuite project created a .NET (core) version. Although the AEGIS core model is inline with OGC SFA, it it not GeoAPI compliant.

See: https://github.com/NetTopologySuite/GeoAPI

Compatibility for GeoAPI should be enabled by creating the proper wrappers (implementing GeoAPI interfaces) and extension methods to enable transformation of IGeometry instances. Implementation should be done in the Core.GeoAPI package.

A quadtree is a tree data structure in which each internal node has exactly four children. This is achieved by recursively subdividing it into four quadrants (regions).

Add the Quadtree type implementing the ISpatialIndex interface to the Core/Indexes namespace. The type should offer two construction possibilities: 1) specifying an Envelope as the space of the tree or 2) specifying a geometry collection. It must also be enabled to add geometries outside the space of the tree (requiring complete rebuilding of the structure).

See: https://en.wikipedia.org/wiki/Quadtree

A recursive height and balance update of AVL trees was implemented in #28 as a fix.

Refactor it into an iterative approach to boost runtime performance.

An Octree is a tree data structure in which each internal node has exactly eight children. Octrees are most often used to partition a three dimensional space by recursively subdividing it into eight octants. Octrees are the three-dimensional analog of quadtrees.

Add the Octree type implementing the ISpatialIndex interface to the Core/Indexes namespace. The type should offer two construction possibilities: 1) specifying an Envelope as the space of the tree or 2) specifying a geometry collection. It must also be enabled to add geometries outside the space of the tree (requiring complete rebuilding of the structure).

See: http://en.wikipedia.org/wiki/Octree