ClemensFischer/XAML-Map-Control
1
0
Fork 0
mirror of https://github.com/ClemensFischer/XAML-Map-Control.git synced 2025-12-06 07:12:04 +01:00
Code Issues Actions Packages Projects Releases Wiki Activity

Version 4.12. Revised projections

Browse source
This commit is contained in:
ClemensF 2018-12-20 21:55:12 +01:00
parent 8cafe207cb
commit 90aa92def0
25 changed files with 390 additions and 167 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
MapControl/Shared/AzimuthalEquidistantProjection.cs
View file

@ -10,7 +10,7 @@ using System.Windows;
namespace MapControl
{
/// <summary>
/// Transforms map coordinates according to the Azimuthal Equidistant Projection.
/// Spherical Azimuthal Equidistant Projection.
/// </summary>
public class AzimuthalEquidistantProjection : AzimuthalProjection
{
@ -35,7 +35,7 @@ namespace MapControl
GetAzimuthDistance(ProjectionCenter, location, out azimuth, out distance);
distance *= Wgs84EquatorialRadius;
distance *= TrueScale * 180d / Math.PI;
return new Point(distance * Math.Sin(azimuth), distance * Math.Cos(azimuth));
}
@ -48,7 +48,7 @@ namespace MapControl
}
var azimuth = Math.Atan2(point.X, point.Y);
var distance = Math.Sqrt(point.X * point.X + point.Y * point.Y) / Wgs84EquatorialRadius;
var distance = Math.Sqrt(point.X * point.X + point.Y * point.Y) / (TrueScale * 180d / Math.PI);
return GetLocation(ProjectionCenter, azimuth, distance);
}

4
MapControl/Shared/AzimuthalProjection.cs
View file

@ -67,7 +67,7 @@ namespace MapControl
}
/// <summary>
/// Calculates azimuth and distance in radians from location1 to location2.
/// Calculates azimuth and spherical distance in radians from location1 to location2.
/// The returned distance has to be multiplied with an appropriate earth radius.
/// </summary>
public static void GetAzimuthDistance(Location location1, Location location2, out double azimuth, out double distance)
@ -89,7 +89,7 @@ namespace MapControl
}
/// <summary>
/// Calculates the Location of the point given by azimuth and distance in radians from location.
/// Calculates the Location of the point given by azimuth and spherical distance in radians from location.
/// </summary>
public static Location GetLocation(Location location, double azimuth, double distance)
{

5
MapControl/Shared/BoundingBox.cs
View file

@ -56,11 +56,6 @@ namespace MapControl
get { return North - South; }
}
public bool HasValidBounds
{
get { return South < North && West < East; }
}
public virtual BoundingBox Clone()
{
return new BoundingBox(South, West, North, East);

6
MapControl/Shared/CenteredBoundingBox.cs
View file

@ -2,6 +2,8 @@
// © 2018 Clemens Fischer
// Licensed under the Microsoft Public License (Ms-PL)
using System;
namespace MapControl
{
public class CenteredBoundingBox : BoundingBox
@ -12,8 +14,8 @@ namespace MapControl
public CenteredBoundingBox(Location center, double width, double height)
{
Center = center;
this.width = width;
this.height = height;
this.width = Math.Max(width, 0d);
this.height = Math.Max(height, 0d);
}
public Location Center { get; private set; }

6
MapControl/Shared/EquirectangularProjection.cs
View file

@ -10,7 +10,7 @@ using System.Windows;
namespace MapControl
{
/// <summary>
/// Transforms map coordinates according to the Equirectangular Projection.
/// Equirectangular Projection.
/// Longitude and Latitude values are transformed identically to X and Y.
/// </summary>
public class EquirectangularProjection : MapProjection
@ -23,8 +23,8 @@ namespace MapControl
public EquirectangularProjection(string crsId)
{
CrsId = crsId;
IsCylindrical = true;
TrueScale = 1;
IsNormalCylindrical = true;
TrueScale = 1d;
}
public override Vector GetMapScale(Location location)

6
MapControl/Shared/GnomonicProjection.cs
View file

@ -10,7 +10,7 @@ using System.Windows;
namespace MapControl
{
/// <summary>
/// Transforms map coordinates according to the Gnomonic Projection.
/// Spherical Gnomonic Projection.
/// </summary>
public class GnomonicProjection : AzimuthalProjection
{
@ -36,7 +36,7 @@ namespace MapControl
GetAzimuthDistance(ProjectionCenter, location, out azimuth, out distance);
var mapDistance = distance < Math.PI / 2d
? Wgs84EquatorialRadius * Math.Tan(distance)
? Math.Tan(distance) * TrueScale * 180d / Math.PI
: double.PositiveInfinity;
return new Point(mapDistance * Math.Sin(azimuth), mapDistance * Math.Cos(azimuth));
@ -51,7 +51,7 @@ namespace MapControl
var azimuth = Math.Atan2(point.X, point.Y);
var mapDistance = Math.Sqrt(point.X * point.X + point.Y * point.Y);
var distance = Math.Atan(mapDistance / Wgs84EquatorialRadius);
var distance = Math.Atan(mapDistance / (TrueScale * 180d / Math.PI));
return GetLocation(ProjectionCenter, azimuth, distance);
}

2
MapControl/Shared/LocationEx.cs
View file

@ -62,7 +62,7 @@ namespace MapControl
var lat2 = Math.Asin(sinLat1 * cosS12 + cosLat1 * sinS12 * cosAz1);
var lon2 = lon1 + Math.Atan2(sinS12 * sinAz1, (cosLat1 * cosS12 - sinLat1 * sinS12 * cosAz1));
return new Location(lat2 / Math.PI * 180d, lon2 / Math.PI * 180d);
return new Location(lat2 * 180d / Math.PI, lon2 * 180d / Math.PI);
}
public static LocationCollection CalculateMeridianLocations(this Location location, double latitude2, double resolution = 1d)

5
MapControl/Shared/MapBase.cs
View file

@ -347,8 +347,6 @@ namespace MapControl
/// fits into the current viewport. The TargetHeading property is set to zero.
/// </summary>
public void ZoomToBounds(BoundingBox boundingBox)
{
if (boundingBox != null && boundingBox.HasValidBounds)
{
var rect = MapProjection.BoundingBoxToRect(boundingBox);
var center = new Point(rect.X + rect.Width / 2d, rect.Y + rect.Height / 2d);
@ -359,7 +357,6 @@ namespace MapControl
TargetCenter = MapProjection.PointToLocation(center);
TargetHeading = 0d;
}
}
private void MapLayerPropertyChanged(UIElement oldLayer, UIElement newLayer)
{
@ -451,7 +448,7 @@ namespace MapControl
if (!targetCenter.Equals(Center))
{
var targetCenterLongitude = MapProjection.IsCylindrical
var targetCenterLongitude = MapProjection.IsNormalCylindrical
? Location.NearestLongitude(targetCenter.Longitude, Center.Longitude)
: targetCenter.Longitude;

6
MapControl/Shared/MapImageLayer.cs
View file

@ -256,7 +256,7 @@ namespace MapControl
boundingBox = ParentMap.MapProjection.ViewportRectToBoundingBox(rect);
if (boundingBox != null && boundingBox.HasValidBounds)
if (boundingBox != null)
{
if (!double.IsNaN(MinLatitude) && boundingBox.South < MinLatitude)
{
@ -289,7 +289,7 @@ namespace MapControl
private void AdjustBoundingBox(double longitudeOffset)
{
if (Math.Abs(longitudeOffset) > 180d && boundingBox != null && boundingBox.HasValidBounds)
if (Math.Abs(longitudeOffset) > 180d && boundingBox != null)
{
var offset = 360d * Math.Sign(longitudeOffset);
@ -300,7 +300,7 @@ namespace MapControl
{
var bbox = GetBoundingBox(element);
if (bbox != null && bbox.HasValidBounds)
if (bbox != null)
{
SetBoundingBox(element, new BoundingBox(bbox.South, bbox.West + offset, bbox.North, bbox.East + offset));
}

4
MapControl/Shared/MapPanel.cs
View file

@ -247,7 +247,7 @@ namespace MapControl
var projection = parentMap.MapProjection;
pos = projection.LocationToViewportPoint(location);
if (projection.IsCylindrical &&
if (projection.IsNormalCylindrical &&
(pos.X < 0d || pos.X > parentMap.RenderSize.Width ||
pos.Y < 0d || pos.Y > parentMap.RenderSize.Height))
{
@ -311,7 +311,7 @@ namespace MapControl
var center = new Point(rect.X + rect.Width / 2d, rect.Y + rect.Height / 2d);
var pos = projection.ViewportTransform.Transform(center);
if (projection.IsCylindrical &&
if (projection.IsNormalCylindrical &&
(pos.X < 0d || pos.X > parentMap.RenderSize.Width ||
pos.Y < 0d || pos.Y > parentMap.RenderSize.Height))
{

12
MapControl/Shared/MapProjection.cs
View file

@ -23,6 +23,9 @@ namespace MapControl
public const double PixelPerDegree = TileSize / 360d;
public const double Wgs84EquatorialRadius = 6378137d;
public const double Wgs84Flattening = 1d / 298.257223563;
public static readonly double Wgs84Eccentricity = Math.Sqrt((2d - Wgs84Flattening) * Wgs84Flattening);
public const double MetersPerDegree = Wgs84EquatorialRadius * Math.PI / 180d;
/// <summary>
@ -33,7 +36,7 @@ namespace MapControl
/// <summary>
/// Indicates if this is a normal cylindrical projection.
/// </summary>
public bool IsCylindrical { get; protected set; } = false;
public bool IsNormalCylindrical { get; protected set; } = false;
/// <summary>
/// Indicates if this is a web mercator projection, i.e. compatible with MapTileLayer.
@ -57,12 +60,13 @@ namespace MapControl
public Matrix ViewportTransform { get; private set; }
/// <summary>
/// Gets the transform matrix from viewport coordinates to cartesian map coordinates (pixels).
/// Gets the transform matrix from viewport coordinates (pixels) to cartesian map coordinates.
/// </summary>
public Matrix InverseViewportTransform { get; private set; }
/// <summary>
/// Gets the scaling factor from cartesian map coordinates to viewport coordinates.
/// Gets the scaling factor from cartesian map coordinates to viewport coordinates (pixels)
/// at the projection's point of true scale.
/// </summary>
public double ViewportScale { get; private set; }
@ -151,7 +155,7 @@ namespace MapControl
/// </summary>
public virtual string WmsQueryParameters(BoundingBox boundingBox)
{
if (string.IsNullOrEmpty(CrsId) || !boundingBox.HasValidBounds)
if (string.IsNullOrEmpty(CrsId))
{
return null;
}

2
MapControl/Shared/MapShape.cs
View file

@ -106,7 +106,7 @@ namespace MapControl
{
var longitudeOffset = 0d;
if (parentMap.MapProjection.IsCylindrical && Location != null)
if (parentMap.MapProjection.IsNormalCylindrical && Location != null)
{
var viewportPosition = LocationToViewportPoint(Location);

12
MapControl/Shared/OrthographicProjection.cs
View file

@ -10,7 +10,7 @@ using System.Windows;
namespace MapControl
{
/// <summary>
/// Transforms map coordinates according to the Orthographic Projection.
/// Spherical Orthographic Projection.
/// </summary>
public class OrthographicProjection : AzimuthalProjection
{
@ -34,10 +34,11 @@ namespace MapControl
var lat0 = ProjectionCenter.Latitude * Math.PI / 180d;
var lat = location.Latitude * Math.PI / 180d;
var dLon = (location.Longitude - ProjectionCenter.Longitude) * Math.PI / 180d;
var s = TrueScale * 180d / Math.PI;
return new Point(
Wgs84EquatorialRadius * Math.Cos(lat) * Math.Sin(dLon),
Wgs84EquatorialRadius * (Math.Cos(lat0) * Math.Sin(lat) - Math.Sin(lat0) * Math.Cos(lat) * Math.Cos(dLon)));
s * Math.Cos(lat) * Math.Sin(dLon),
s * (Math.Cos(lat0) * Math.Sin(lat) - Math.Sin(lat0) * Math.Cos(lat) * Math.Cos(dLon)));
}
public override Location PointToLocation(Point point)
@ -47,8 +48,9 @@ namespace MapControl
return ProjectionCenter;
}
var x = point.X / Wgs84EquatorialRadius;
var y = point.Y / Wgs84EquatorialRadius;
var s = TrueScale * 180d / Math.PI;
var x = point.X / s;
var y = point.Y / s;
var r2 = x * x + y * y;
if (r2 > 1d)

6
MapControl/Shared/StereographicProjection.cs
View file

@ -10,7 +10,7 @@ using System.Windows;
namespace MapControl
{
/// <summary>
/// Transforms map coordinates according to the Gnomonic Projection.
/// Spherical Stereographic Projection.
/// </summary>
public class StereographicProjection : AzimuthalProjection
{
@ -35,7 +35,7 @@ namespace MapControl
GetAzimuthDistance(ProjectionCenter, location, out azimuth, out distance);
var mapDistance = 2d * Wgs84EquatorialRadius * Math.Tan(distance / 2d);
var mapDistance = Math.Tan(distance / 2d) * TrueScale * 360d / Math.PI;
return new Point(mapDistance * Math.Sin(azimuth), mapDistance * Math.Cos(azimuth));
}
@ -49,7 +49,7 @@ namespace MapControl
var azimuth = Math.Atan2(point.X, point.Y);
var mapDistance = Math.Sqrt(point.X * point.X + point.Y * point.Y);
var distance = 2d * Math.Atan(mapDistance / (2d * Wgs84EquatorialRadius));
var distance = 2d * Math.Atan(mapDistance / (TrueScale * 360d / Math.PI));
return GetLocation(ProjectionCenter, azimuth, distance);
}

16
MapControl/Shared/WebMercatorProjection.cs
View file

@ -10,10 +10,8 @@ using System.Windows;
namespace MapControl
{
/// <summary>
/// Transforms map coordinates according to the Web (or Pseudo) Mercator Projection, EPSG:3857.
/// Longitude values are transformed linearly to X values in meters, by multiplying with TrueScale.
/// Latitude values in the interval [-MaxLatitude .. MaxLatitude] are transformed to Y values in meters
/// in the interval [-R*pi .. R*pi], R=Wgs84EquatorialRadius.
/// Spherical Mercator Projection, EPSG:3857.
/// See "Map Projections - A Working Manual" (https://pubs.usgs.gov/pp/1395/report.pdf), p.41-44.
/// </summary>
public class WebMercatorProjection : MapProjection
{
@ -25,16 +23,16 @@ namespace MapControl
public WebMercatorProjection(string crsId)
{
CrsId = crsId;
IsCylindrical = true;
IsNormalCylindrical = true;
IsWebMercator = true;
MaxLatitude = YToLatitude(180d);
}
public override Vector GetMapScale(Location location)
{
var scale = ViewportScale / Math.Cos(location.Latitude * Math.PI / 180d);
var k = 1d / Math.Cos(location.Latitude * Math.PI / 180d); // p.44 (7-3)
return new Vector(scale, scale);
return new Vector(ViewportScale * k, ViewportScale * k);
}
public override Point LocationToPoint(Location location)
@ -63,12 +61,12 @@ namespace MapControl
return double.PositiveInfinity;
}
return Math.Log(Math.Tan((latitude + 90d) * Math.PI / 360d)) / Math.PI * 180d;
return Math.Log(Math.Tan((latitude + 90d) * Math.PI / 360d)) * 180d / Math.PI;
}
public static double YToLatitude(double y)
{
return 90d - Math.Atan(Math.Exp(-y * Math.PI / 180d)) / Math.PI * 360d;
return 90d - Math.Atan(Math.Exp(-y * Math.PI / 180d)) * 360d / Math.PI;
}
}
}

35
MapControl/Shared/WorldMercatorProjection.cs
View file

@ -10,17 +10,12 @@ using System.Windows;
namespace MapControl
{
/// <summary>
/// Transforms map coordinates according to the "World Mercator" Projection, EPSG:3395.
/// Longitude values are transformed linearly to X values in meters, by multiplying with TrueScale.
/// Latitude values are transformed according to the elliptical versions of the Mercator equations,
/// as shown in "Map Projections - A Working Manual" (https://pubs.usgs.gov/pp/1395/report.pdf), p.44.
/// Elliptical Mercator Projection, EPSG:3395.
/// See "Map Projections - A Working Manual" (https://pubs.usgs.gov/pp/1395/report.pdf), p.44-45.
/// </summary>
public class WorldMercatorProjection : MapProjection
{
public const double Wgs84Flattening = 1d / 298.257223563;
public static readonly double Wgs84Eccentricity = Math.Sqrt((2d - Wgs84Flattening) * Wgs84Flattening);
public static double MinLatitudeDelta = 1d / Wgs84EquatorialRadius; // corresponds to 1 meter
public static double ConvergenceTolerance = 1e-6;
public static int MaxIterations = 10;
public WorldMercatorProjection()
@ -31,7 +26,7 @@ namespace MapControl
public WorldMercatorProjection(string crsId)
{
CrsId = crsId;
IsCylindrical = true;
IsNormalCylindrical = true;
MaxLatitude = YToLatitude(180d);
}
@ -39,9 +34,9 @@ namespace MapControl
{
var lat = location.Latitude * Math.PI / 180d;
var eSinLat = Wgs84Eccentricity * Math.Sin(lat);
var scale = ViewportScale * Math.Sqrt(1d - eSinLat * eSinLat) / Math.Cos(lat);
var k = Math.Sqrt(1d - eSinLat * eSinLat) / Math.Cos(lat); // p.44 (7-8)
return new Vector(scale, scale);
return new Vector(ViewportScale * k, ViewportScale * k);
}
public override Point LocationToPoint(Location location)
@ -72,24 +67,24 @@ namespace MapControl
var lat = latitude * Math.PI / 180d;
return Math.Log(Math.Tan(lat / 2d + Math.PI / 4d) * ConformalFactor(lat)) / Math.PI * 180d;
return Math.Log(Math.Tan(lat / 2d + Math.PI / 4d)
* ConformalFactor(lat)) * 180d / Math.PI; // p.44 (7-7)
}
public static double YToLatitude(double y)
{
var t = Math.Exp(-y * Math.PI / 180d);
var lat = Math.PI / 2d - 2d * Math.Atan(t);
var latDelta = 1d;
var t = Math.Exp(-y * Math.PI / 180d); // p.44 (7-10)
var lat = Math.PI / 2d - 2d * Math.Atan(t); // p.44 (7-11)
var relChange = 1d;
for (int i = 0; i < MaxIterations && latDelta > MinLatitudeDelta; i++)
for (var i = 0; i < MaxIterations && relChange > ConvergenceTolerance; i++)
{
var newLat = Math.PI / 2d - 2d * Math.Atan(t * ConformalFactor(lat));
latDelta = Math.Abs(newLat - lat);
var newLat = Math.PI / 2d - 2d * Math.Atan(t * ConformalFactor(lat)); // p.44 (7-9)
relChange = Math.Abs(1d - newLat / lat);
lat = newLat;
}
return lat / Math.PI * 180d;
return lat * 180d / Math.PI;
}
private static double ConformalFactor(double lat)

2
MapControl/UWP/MapGraticule.UWP.cs
View file

@ -26,7 +26,7 @@ namespace MapControl
{
var projection = ParentMap.MapProjection;
if (projection.IsCylindrical)
if (projection.IsNormalCylindrical)
{
if (path == null)
{

6
MapControl/WPF/MapGraticule.WPF.cs
View file

@ -44,7 +44,7 @@ namespace MapControl
var lineDistance = GetLineDistance();
var labelFormat = GetLabelFormat(lineDistance);
if (projection.IsCylindrical)
if (projection.IsNormalCylindrical)
{
DrawCylindricalGraticule(drawingContext, projection, lineDistance, labelFormat);
}
@ -58,9 +58,6 @@ namespace MapControl
private void DrawCylindricalGraticule(DrawingContext drawingContext, MapProjection projection, double lineDistance, string labelFormat)
{
var boundingBox = projection.ViewportRectToBoundingBox(new Rect(ParentMap.RenderSize));
if (boundingBox.HasValidBounds)
{
var latLabelStart = Math.Ceiling(boundingBox.South / lineDistance) * lineDistance;
var lonLabelStart = Math.Ceiling(boundingBox.West / lineDistance) * lineDistance;
var latLabels = new List<Label>((int)((boundingBox.North - latLabelStart) / lineDistance) + 1);
@ -108,4 +105,3 @@ namespace MapControl
}
}
}
}

84
MapProjections/Shared/GeoApiProjection.cs
View file

@ -3,14 +3,12 @@
// Licensed under the Microsoft Public License (Ms-PL)
using System;
using System.Text;
#if !WINDOWS_UWP
using System.Windows;
#endif
using GeoAPI.CoordinateSystems;
using GeoAPI.CoordinateSystems.Transformations;
using GeoAPI.Geometries;
using ProjNet.Converters.WellKnownText;
using ProjNet.CoordinateSystems;
using ProjNet.CoordinateSystems.Transformations;
@ -21,17 +19,17 @@ namespace MapControl.Projections
/// </summary>
public class GeoApiProjection : MapProjection
{
private ICoordinateTransformation coordinateTransform;
private IMathTransform mathTransform;
private IMathTransform inverseTransform;
private IProjectedCoordinateSystem coordinateSystem;
public IMathTransform MathTransform { get; private set; }
public IMathTransform InverseTransform { get; private set; }
/// <summary>
/// Gets or sets the underlying ICoordinateTransformation instance.
/// Setting this property updates the CrsId property.
/// Gets or sets the IProjectedCoordinateSystem of the MapProjection.
/// </summary>
public ICoordinateTransformation CoordinateTransform
public IProjectedCoordinateSystem CoordinateSystem
{
get { return coordinateTransform; }
get { return coordinateSystem; }
set
{
if (value == null)
@ -39,15 +37,45 @@ namespace MapControl.Projections
throw new ArgumentNullException("The property value must not be null.");
}
coordinateTransform = value;
mathTransform = coordinateTransform.MathTransform;
inverseTransform = mathTransform.Inverse();
coordinateSystem = value;
if (coordinateTransform.TargetCS != null &&
!string.IsNullOrEmpty(coordinateTransform.TargetCS.Authority) &&
coordinateTransform.TargetCS.AuthorityCode > 0)
var coordinateTransform = new CoordinateTransformationFactory()
.CreateFromCoordinateSystems(GeographicCoordinateSystem.WGS84, coordinateSystem);
MathTransform = coordinateTransform.MathTransform;
InverseTransform = MathTransform.Inverse();
CrsId = (!string.IsNullOrEmpty(coordinateSystem.Authority) && coordinateSystem.AuthorityCode > 0)
? string.Format("{0}:{1}", coordinateSystem.Authority, coordinateSystem.AuthorityCode)
: null;
if (!IsWebMercator)
{
CrsId = string.Format("{0}:{1}", coordinateTransform.TargetCS.Authority, coordinateTransform.TargetCS.AuthorityCode);
IsWebMercator = CrsId == "EPSG:3857" || CrsId == "EPSG:900913";
}
var projection = coordinateSystem.Projection;
var scaleFactor = projection.GetParameter("scale_factor");
if (scaleFactor != null)
{
TrueScale = scaleFactor.Value * MetersPerDegree;
}
if (!IsNormalCylindrical)
{
var centralMeridian = projection.GetParameter("central_meridian") ?? projection.GetParameter("longitude_of_origin");
var centralParallel = projection.GetParameter("latitude_of_origin") ?? projection.GetParameter("central_parallel");
var falseEasting = projection.GetParameter("false_easting");
var falseNorthing = projection.GetParameter("false_northing");
if (centralMeridian != null && centralMeridian.Value == 0d &&
centralParallel != null && centralParallel.Value == 0d &&
(falseEasting == null || falseEasting.Value == 0d) &&
(falseNorthing == null || falseNorthing.Value == 0d))
{
IsNormalCylindrical = true;
}
}
}
}
@ -55,40 +83,34 @@ namespace MapControl.Projections
/// <summary>
/// Gets or sets an OGC Well-known text representation of a projected coordinate system,
/// i.e. a PROJCS[...] string as used by https://epsg.io or http://spatialreference.org.
/// Setting this property updates the CoordinateTransform property.
/// Setting this property updates the CoordinateSystem property with an IProjectedCoordinateSystem created from the WKT string.
/// </summary>
public string WKT
{
get { return coordinateTransform?.TargetCS?.WKT; }
set
{
var sourceCs = GeographicCoordinateSystem.WGS84;
var targetCs = (ICoordinateSystem)CoordinateSystemWktReader.Parse(value, Encoding.UTF8);
CoordinateTransform = new CoordinateTransformationFactory().CreateFromCoordinateSystems(sourceCs, targetCs);
}
get { return CoordinateSystem?.WKT; }
set { CoordinateSystem = (IProjectedCoordinateSystem)new CoordinateSystemFactory().CreateFromWkt(value); }
}
public override Point LocationToPoint(Location location)
{
if (mathTransform == null)
if (MathTransform == null)
{
throw new InvalidOperationException("The CoordinateTransformation property is not set.");
throw new InvalidOperationException("The CoordinateSystem property is not set.");
}
var coordinate = mathTransform.Transform(new Coordinate(location.Longitude, location.Latitude));
var coordinate = MathTransform.Transform(new Coordinate(location.Longitude, location.Latitude));
return new Point(coordinate.X, coordinate.Y);
}
public override Location PointToLocation(Point point)
{
if (inverseTransform == null)
if (InverseTransform == null)
{
throw new InvalidOperationException("The CoordinateTransformation property is not set.");
throw new InvalidOperationException("The CoordinateSystem property is not set.");
}
var coordinate = inverseTransform.Transform(new Coordinate(point.X, point.Y));
var coordinate = InverseTransform.Transform(new Coordinate(point.X, point.Y));
return new Location(coordinate.Y, coordinate.X);
}

129
MapProjections/Shared/PolarStereographicProjection.cs Normal file
View file

@ -0,0 +1,129 @@
// XAML Map Control - https://github.com/ClemensFischer/XAML-Map-Control
// © 2018 Clemens Fischer
// Licensed under the Microsoft Public License (Ms-PL)
using System;
#if !WINDOWS_UWP
using System.Windows;
#endif
namespace MapControl.Projections
{
/// <summary>
/// Elliptical Polar Stereographic Projection with a given scale factor at the pole and
/// optional false easting and northing, as used by the UPS North and UPS South projections.
/// See "Map Projections - A Working Manual" (https://pubs.usgs.gov/pp/1395/report.pdf), p.160-162.
/// </summary>
public class PolarStereographicProjection : MapProjection
{
public static double ConvergenceTolerance = 1e-6;
public static int MaxIterations = 10;
private readonly bool north;
private readonly double scaleFactor;
private readonly double falseEasting;
private readonly double falseNorthing;
public PolarStereographicProjection(string crsId, bool north, double scaleFactor = 1d, double falseEasting = 0d, double falseNorthing = 0d)
{
CrsId = crsId;
TrueScale = scaleFactor * MetersPerDegree;
this.north = north;
this.scaleFactor = scaleFactor;
this.falseEasting = falseEasting;
this.falseNorthing = falseNorthing;
}
public override Vector GetMapScale(Location location)
{
var lat = (north ? location.Latitude : -location.Latitude) * Math.PI / 180d;
var a = Wgs84EquatorialRadius;
var e = Wgs84Eccentricity;
var s = Math.Sqrt(Math.Pow(1 + e, 1 + e) * Math.Pow(1 - e, 1 - e));
var t = Math.Tan(Math.PI / 4d - lat / 2d) / ConformalFactor(lat);
var rho = 2d * a * scaleFactor * t / s;
var eSinLat = e * Math.Sin(lat);
var m = Math.Cos(lat) / Math.Sqrt(1d - eSinLat * eSinLat);
var k = rho / (a * m);
return new Vector(ViewportScale * k, ViewportScale * k);
}
public override Point LocationToPoint(Location location)
{
var lat = location.Latitude * Math.PI / 180d;
var lon = location.Longitude * Math.PI / 180d;
if (north)
{
lon = Math.PI - lon;
}
else
{
lat = -lat;
}
var a = Wgs84EquatorialRadius;
var e = Wgs84Eccentricity;
var s = Math.Sqrt(Math.Pow(1 + e, 1 + e) * Math.Pow(1 - e, 1 - e));
var t = Math.Tan(Math.PI / 4d - lat / 2d) / ConformalFactor(lat);
var rho = 2d * a * scaleFactor * t / s;
return new Point(rho * Math.Sin(lon) + falseEasting, rho * Math.Cos(lon) + falseNorthing);
}
public override Location PointToLocation(Point point)
{
point.X -= falseEasting;
point.Y -= falseNorthing;
var lon = Math.Atan2(point.X, point.Y);
var rho = Math.Sqrt(point.X * point.X + point.Y * point.Y);
var a = Wgs84EquatorialRadius;
var e = Wgs84Eccentricity;
var s = Math.Sqrt(Math.Pow(1 + e, 1 + e) * Math.Pow(1 - e, 1 - e));
var t = rho * s / (2d * a * scaleFactor);
var lat = Math.PI / 2d - 2d * Math.Atan(t);
var relChange = 1d;
for (int i = 0; i < MaxIterations && relChange > ConvergenceTolerance; i++)
{
var newLat = Math.PI / 2d - 2d * Math.Atan(t * ConformalFactor(lat));
relChange = Math.Abs(1d - newLat / lat);
lat = newLat;
}
if (north)
{
lon = Math.PI - lon;
}
else
{
lat = -lat;
}
return new Location(lat * 180d / Math.PI, lon * 180d / Math.PI);
}
private static double ConformalFactor(double lat)
{
var eSinLat = Wgs84Eccentricity * Math.Sin(lat);
return Math.Pow((1d - eSinLat) / (1d + eSinLat), Wgs84Eccentricity / 2d);
}
}
public class UpsNorthProjection : PolarStereographicProjection
{
public UpsNorthProjection() : base("EPSG:32661", true, 0.994, 2e6, 2e6)
{
}
}
public class UpsSouthProjection : PolarStereographicProjection
{
public UpsSouthProjection() : base("EPSG:32761", false, 0.994, 2e6, 2e6)
{
}
}
}

19
MapProjections/Shared/UtmProjection.cs
View file

@ -3,21 +3,12 @@
// Licensed under the Microsoft Public License (Ms-PL)
using System;
#if !WINDOWS_UWP
using System.Windows;
#endif
using ProjNet.CoordinateSystems;
namespace MapControl.Projections
{
public class UtmProjection : GeoApiProjection
{
private const string wktFormat = "PROJCS[\"WGS 84 / UTM zone {0}\", GEOGCS[\"WGS 84\", DATUM[\"WGS_1984\", SPHEROID[\"WGS 84\", 6378137, 298.257223563, AUTHORITY[\"EPSG\", \"7030\"]], AUTHORITY[\"EPSG\", \"6326\"]], PRIMEM[\"Greenwich\", 0, AUTHORITY[\"EPSG\", \"8901\"]], UNIT[\"degree\", 0.01745329251994328, AUTHORITY[\"EPSG\", \"9122\"]], AUTHORITY[\"EPSG\", \"4326\"]], UNIT[\"metre\", 1, AUTHORITY[\"EPSG\", \"9001\"]], PROJECTION[\"Transverse_Mercator\"], PARAMETER[\"latitude_of_origin\", 0], PARAMETER[\"central_meridian\", {1}], PARAMETER[\"scale_factor\", 0.9996], PARAMETER[\"false_easting\", 500000], PARAMETER[\"false_northing\", {2}], AUTHORITY[\"EPSG\", \"{3}\"], AXIS[\"Easting\", EAST], AXIS[\"Northing\", NORTH]]";
public UtmProjection()
{
TrueScale = 0.9996 * MetersPerDegree;
}
private string zone;
public string Zone
@ -48,7 +39,7 @@ namespace MapControl.Projections
public void SetZone(int zoneNumber, bool north)
{
if (zoneNumber < 1 || zoneNumber > 60)
if (zoneNumber < 1 || zoneNumber > 61)
{
throw new ArgumentException("Invalid UTM zone number.");
}
@ -57,12 +48,8 @@ namespace MapControl.Projections
if (zone != zoneName)
{
var centralMeridian = zoneNumber * 6 - 183;
var falseNorthing = north ? 0 : 10000000;
var authorityCode = (north ? 32600 : 32700) + zoneNumber;
zone = zoneName;
WKT = string.Format(wktFormat, zone, centralMeridian, falseNorthing, authorityCode);
CoordinateSystem = ProjectedCoordinateSystem.WGS84_UTM(zoneNumber, north);
}
}

33
MapProjections/Shared/WebMercatorProjection.cs Normal file
View file

@ -0,0 +1,33 @@
// XAML Map Control - https://github.com/ClemensFischer/XAML-Map-Control
// © 2018 Clemens Fischer
// Licensed under the Microsoft Public License (Ms-PL)
using System;
#if !WINDOWS_UWP
using System.Windows;
#endif
using ProjNet.CoordinateSystems;
namespace MapControl.Projections
{
/// <summary>
/// Spherical Mercator Projection implemented by setting the CoordinateSystem property of a GeoApiProjection.
/// See "Map Projections - A Working Manual" (https://pubs.usgs.gov/pp/1395/report.pdf), p.41-44.
/// </summary>
public class WebMercatorProjection : GeoApiProjection
{
public WebMercatorProjection()
{
IsWebMercator = true;
IsNormalCylindrical = true;
CoordinateSystem = ProjectedCoordinateSystem.WebMercator;
}
public override Vector GetMapScale(Location location)
{
var k = 1d / Math.Cos(location.Latitude * Math.PI / 180d); // p.44 (7-3)
return new Vector(ViewportScale * k, ViewportScale * k);
}
}
}

48
MapProjections/Shared/WorldMercatorProjection.cs Normal file
View file

@ -0,0 +1,48 @@
// XAML Map Control - https://github.com/ClemensFischer/XAML-Map-Control
// © 2018 Clemens Fischer
// Licensed under the Microsoft Public License (Ms-PL)
using System;
#if !WINDOWS_UWP
using System.Windows;
#endif
namespace MapControl.Projections
{
/// <summary>
/// Elliptical Mercator Projection implemented by setting the WKT property of a GeoApiProjection.
/// See "Map Projections - A Working Manual" (https://pubs.usgs.gov/pp/1395/report.pdf), p.44-45.
/// </summary>
public class WorldMercatorProjection : GeoApiProjection
{
public WorldMercatorProjection()
{
IsNormalCylindrical = true;
WKT = "PROJCS[\"WGS 84 / World Mercator\","
+ "GEOGCS[\"WGS 84\","
+ "DATUM[\"WGS_1984\", SPHEROID[\"WGS 84\", 6378137, 298.257223563, AUTHORITY[\"EPSG\", \"7030\"]], AUTHORITY[\"EPSG\", \"6326\"]],"
+ "PRIMEM[\"Greenwich\", 0, AUTHORITY[\"EPSG\", \"8901\"]],"
+ "UNIT[\"degree\", 0.0174532925199433, AUTHORITY[\"EPSG\", \"9122\"]],"
+ "AUTHORITY[\"EPSG\", \"4326\"]],"
+ "PROJECTION[\"Mercator_1SP\"],"
+ "PARAMETER[\"latitude_of_origin\", 0],"
+ "PARAMETER[\"central_meridian\", 0],"
+ "PARAMETER[\"scale_factor\", 1],"
+ "PARAMETER[\"false_easting\", 0],"
+ "PARAMETER[\"false_northing\", 0],"
+ "UNIT[\"metre\", 1, AUTHORITY[\"EPSG\", \"9001\"]],"
+ "AXIS[\"Easting\", EAST],"
+ "AXIS[\"Northing\", NORTH],"
+ "AUTHORITY[\"EPSG\", \"3395\"]]";
}
public override Vector GetMapScale(Location location)
{
var lat = location.Latitude * Math.PI / 180d;
var eSinLat = Wgs84Eccentricity * Math.Sin(lat);
var k = Math.Sqrt(1d - eSinLat * eSinLat) / Math.Cos(lat); // p.44 (7-8)
return new Vector(ViewportScale * k, ViewportScale * k);
}
}
}

6
MapProjections/UWP/MapProjections.UWP.csproj
View file

@ -43,9 +43,15 @@
<Compile Include="..\Shared\GeoApiProjection.cs">
<Link>GeoApiProjection.cs</Link>
</Compile>
<Compile Include="..\Shared\PolarStereographicProjection.cs">
<Link>PolarStereographicProjection.cs</Link>
</Compile>
<Compile Include="..\Shared\UtmProjection.cs">
<Link>UtmProjection.cs</Link>
</Compile>
<Compile Include="..\Shared\WebMercatorProjection.cs">
<Link>WebMercatorProjection.cs</Link>
</Compile>
<Compile Include="Properties\AssemblyInfo.cs" />
<EmbeddedResource Include="Properties\MapProjections.UWP.rd.xml" />
</ItemGroup>

9
MapProjections/WPF/MapProjections.WPF.csproj
View file

@ -56,9 +56,18 @@
<Compile Include="..\Shared\GeoApiProjection.cs">
<Link>GeoApiProjection.cs</Link>
</Compile>
<Compile Include="..\Shared\PolarStereographicProjection.cs">
<Link>PolarStereographicProjection.cs</Link>
</Compile>
<Compile Include="..\Shared\UtmProjection.cs">
<Link>UtmProjection.cs</Link>
</Compile>
<Compile Include="..\Shared\WebMercatorProjection.cs">
<Link>WebMercatorProjection.cs</Link>
</Compile>
<Compile Include="..\Shared\WorldMercatorProjection.cs">
<Link>WorldMercatorProjection.cs</Link>
</Compile>
<Compile Include="Properties\AssemblyInfo.cs">
<SubType>Code</SubType>
</Compile>