/// <summary> /// Returns the inverse of this conversion. /// </summary> /// <returns>IMathTransform that is the reverse of the current conversion.</returns> public override MathTransform Inverse() { if (_inverse == null) { _inverse = new GeocentricTransform(this._parameters, !_isInverse); } return(_inverse); }
/// <summary> /// Creates the inverse transform of this object. /// </summary> /// <returns></returns> /// <remarks>This method may fail if the transform is not one to one. However, all cartographic projections should succeed.</remarks> public override MathTransform Inverse() { if (_inverse == null) { _inverse = new DatumTransform(_toWgs94, !_isInverse); } return(_inverse); }
/// <summary> /// Returns the inverse of this conversion. /// </summary> /// <returns>IMathTransform that is the reverse of the current conversion.</returns> public override MathTransform Inverse() { if (_inverse == null) { _inverse = Clone(); _inverse.Invert(); } return(_inverse); }
// ReSharper restore InconsistentNaming /// <summary> /// Creates an instance of this class /// </summary> /// <param name="parameters">An enumeration of projection parameters</param> /// <param name="inverse">Indicator if this projection is inverse</param> protected MapProjection(IEnumerable<ProjectionParameter> parameters, MapProjection inverse) : this(parameters) { _inverse = inverse; if (_inverse != null) { inverse._inverse = this; _isInverse = !inverse._isInverse; } }
/// <summary> /// Transforms a <see cref="NetTopologySuite.Geometries.MultiPolygon"/>. /// </summary> /// <param name="polys">MultiPolygon to transform</param> /// <param name="transform">MathTransform</param> /// <param name="targetFactory">The factory to create the target geometry</param> /// <returns>Transformed MultiPolygon</returns> public static MultiPolygon TransformMultiPolygon(MultiPolygon polys, MathTransform transform, GeometryFactory targetFactory) { var polyList = new Polygon[polys.NumGeometries]; for (var i = 0; i < polys.NumGeometries; i++) { var poly = (Polygon)polys[i]; polyList[i] = TransformPolygon(poly, transform, targetFactory); } return(targetFactory.CreateMultiPolygon(polyList)); }
/// <summary> /// Transforms a <see cref="NetTopologySuite.Geometries.LinearRing"/>. /// </summary> /// <param name="r">LinearRing to transform</param> /// <param name="transform">MathTransform</param> /// <param name="targetFactory">The factory to create the target geometry</param> /// <returns>Transformed LinearRing</returns> public static LinearRing TransformLinearRing(LinearRing r, MathTransform transform, GeometryFactory targetFactory) { try { return(targetFactory.CreateLinearRing(TransformCoordinates(r.Coordinates, transform))); } catch { return(null); } }
/// <summary> /// Transforms a <see cref="NetTopologySuite.Geometries.Point"/>. /// </summary> /// <param name="p">Point to transform</param> /// <param name="transform">MathTransform</param> /// <param name="targetFactory">The factory to create the target geometry</param> /// <returns>Transformed Point</returns> public static Point TransformPoint(Point p, MathTransform transform, GeometryFactory targetFactory) { try { return(targetFactory.CreatePoint(TransformCoordinate(p.Coordinate, transform))); } catch { return(null); } }
/// <summary> /// Function to transform <paramref name="c"/> using <paramref name="transform"/> /// </summary> /// <param name="c">The array of coordinates</param> /// <param name="transform">The transformation</param> /// <returns>An array of transformed coordinates</returns> private static Coordinate[] TransformCoordinates(Coordinate[] c, MathTransform transform) { var res = new Coordinate[c.Length]; for (var i = 0; i < c.Length; i++) { var ordinates = transform.Transform(c[i].ToDoubleArray()); res[i] = new Coordinate(ordinates[0], ordinates[1]); } return(res); }
/// <summary> /// Returns the inverse of this affine transformation. /// </summary> /// <returns>IMathTransform that is the reverse of the current affine transformation.</returns> public override MathTransform Inverse() { if (_inverse == null) { //find the inverse transformation matrix - use cloned matrix array //remarks about dimensionality: if input dimension is M, and output dimension is N, then the matrix will have size [N+1][M+1]. double[,] invMatrix = InvertMatrix((double[, ])_transformMatrix.Clone()); _inverse = new AffineTransform(invMatrix); } return(_inverse); }
/// <summary> /// Initializes an instance of a CoordinateTransformation /// </summary> /// <param name="sourceCS">Source coordinate system</param> /// <param name="targetCS">Target coordinate system</param> /// <param name="transformType">Transformation type</param> /// <param name="mathTransform">Math transform</param> /// <param name="name">Name of transform</param> /// <param name="authority">Authority</param> /// <param name="authorityCode">Authority code</param> /// <param name="areaOfUse">Area of use</param> /// <param name="remarks">Remarks</param> internal CoordinateTransformation(CoordinateSystem sourceCS, CoordinateSystem targetCS, TransformType transformType, MathTransform mathTransform, string name, string authority, long authorityCode, string areaOfUse, string remarks) { TargetCS = targetCS; SourceCS = sourceCS; TransformType = transformType; MathTransform = mathTransform; Name = name; Authority = authority; AuthorityCode = authorityCode; AreaOfUse = areaOfUse; Remarks = remarks; }
/// <summary> /// Transforms a <see cref="NetTopologySuite.Geometries.Polygon"/>. /// </summary> /// <param name="p">Polygon to transform</param> /// <param name="transform">MathTransform</param> /// <param name="targetFactory">The factory to create the target geometry</param> /// <returns>Transformed Polygon</returns> public static Polygon TransformPolygon(Polygon p, MathTransform transform, GeometryFactory targetFactory) { var shell = TransformLinearRing((LinearRing)p.ExteriorRing, transform, targetFactory); LinearRing[] holes = null; var holesCount = p.NumInteriorRings; if (holesCount > 0) { holes = new LinearRing[holesCount]; for (var i = 0; i < holesCount; i++) { holes[i] = TransformLinearRing((LinearRing)p.GetInteriorRingN(i), transform, targetFactory); } } return(targetFactory.CreatePolygon(shell, holes)); }
/// <summary> /// Transforms a <see cref="Envelope"/>. /// </summary> /// <param name="box">BoundingBox to transform</param> /// <param name="transform">Math Transform</param> /// <returns>Transformed object</returns> public static Envelope TransformBox(Envelope box, MathTransform transform) { if (box == null) { return(null); } var corners = new [] { transform.Transform(box.MinX, box.MinY), transform.Transform(box.MinX, box.MaxY), transform.Transform(box.MaxX, box.MinY), transform.Transform(box.MaxX, box.MaxY) }; var result = new Envelope(new Coordinate(corners[0].x, corners[0].y)); for (var i = 1; i < 4; i++) { result.ExpandToInclude(new Coordinate(corners[i].x, corners[i].y)); } return(result); }
/// <summary> /// Transforms a <see cref="NetTopologySuite.Geometries.Geometry"/>. /// </summary> /// <param name="g">Geometry to transform</param> /// <param name="transform">MathTransform</param> /// <param name="targetFactory">The factory to create the target geometry</param> /// <returns>Transformed Geometry</returns> public static Geometry TransformGeometry(Geometry g, MathTransform transform, GeometryFactory targetFactory) { if (g == null) { return(null); } if (g is Point) { return(TransformPoint(g as Point, transform, targetFactory)); } if (g is LineString) { return(TransformLineString(g as LineString, transform, targetFactory)); } if (g is Polygon) { return(TransformPolygon(g as Polygon, transform, targetFactory)); } if (g is MultiPoint) { return(TransformMultiPoint(g as MultiPoint, transform, targetFactory)); } if (g is MultiLineString) { return(TransformMultiLineString(g as MultiLineString, transform, targetFactory)); } if (g is MultiPolygon) { return(TransformMultiPolygon(g as MultiPolygon, transform, targetFactory)); } if (g is GeometryCollection) { return(TransformGeometryCollection(g as GeometryCollection, transform, targetFactory)); } throw new ArgumentException("Could not transform geometry type '" + g.GetType() + "'"); }
/// <summary> /// Function to transform a <paramref name="c"/> using <paramref name="transform"/> /// </summary> /// <param name="c">The coordinate</param> /// <param name="transform">The transformation</param> /// <returns>A transformed coordinate</returns> public static Coordinate TransformCoordinate(Coordinate c, MathTransform transform) { var ordinates = transform.Transform(c.ToDoubleArray()); return(new Coordinate(ordinates[0], ordinates[1])); }
/// <summary> /// Returns the inverse of this conversion. /// </summary> /// <returns>IMathTransform that is the reverse of the current conversion.</returns> public override IMathTransform Inverse() { if (_inverse == null) _inverse = new GeocentricTransform(this._Parameters, !_isInverse); return _inverse; }
/// <summary> /// Creates an instance of CoordinateTransformation as an anonymous transformation without neither autohority nor code defined. /// </summary> /// <param name="sourceCS">Source coordinate system</param> /// <param name="targetCS">Target coordinate system</param> /// <param name="transformType">Transformation type</param> /// <param name="mathTransform">Math transform</param> private static CoordinateTransformation CreateTransform(CoordinateSystem sourceCS, CoordinateSystem targetCS, TransformType transformType, MathTransform mathTransform) { return(new CoordinateTransformation(sourceCS, targetCS, transformType, mathTransform, string.Empty, string.Empty, -1, string.Empty, string.Empty)); }
/// <summary> /// Transforms a <see cref="NetTopologySuite.Geometries.GeometryCollection"/>. /// </summary> /// <param name="geoms">GeometryCollection to transform</param> /// <param name="transform">MathTransform</param> /// <param name="targetFactory">The factory to create the target geometry</param> /// <returns>Transformed GeometryCollection</returns> public static GeometryCollection TransformGeometryCollection(GeometryCollection geoms, MathTransform transform, GeometryFactory targetFactory) { var geomList = new Geometry[geoms.NumGeometries]; for (var i = 0; i < geoms.NumGeometries; i++) { geomList[i] = TransformGeometry(geoms[i], transform, targetFactory); } return(targetFactory.CreateGeometryCollection(geomList)); }
/// <summary> /// Transforms a <see cref="NetTopologySuite.Geometries.MultiLineString"/>. /// </summary> /// <param name="lines">MultiLineString to transform</param> /// <param name="transform">MathTransform</param> /// <param name="targetFactory">The factory to create the target geometry</param> /// <returns>Transformed MultiLineString</returns> public static MultiLineString TransformMultiLineString(MultiLineString lines, MathTransform transform, GeometryFactory targetFactory) { var lineList = new LineString[lines.NumGeometries]; for (var i = 0; i < lines.NumGeometries; i++) { var line = (LineString)lines[i]; lineList[i] = TransformLineString(line, transform, targetFactory); } return(targetFactory.CreateMultiLineString(lineList)); }
/// <summary> /// Transforms a <see cref="NetTopologySuite.Geometries.MultiPoint"/>. /// </summary> /// <param name="points">MultiPoint to transform</param> /// <param name="transform">MathTransform</param> /// <param name="targetFactory">The factory to create the target geometry</param> /// <returns>Transformed MultiPoint</returns> public static MultiPoint TransformMultiPoint(MultiPoint points, MathTransform transform, GeometryFactory targetFactory) { return(targetFactory.CreateMultiPointFromCoords(TransformCoordinates(points.Coordinates, transform))); }