public void Test(string geoResourceName, string neyResourceName, double projectDelta, double unprojectDelta) { var latLonData = GoldData.GetReadyReader(geoResourceName); var prjData = GoldData.GetReadyReader(neyResourceName); var projection = new NeysProjection( new GeographicCoordinate( Double.Parse(prjData["ORIGIN LATITUDE"]) * Math.PI / 180.0, Double.Parse(prjData["CENTRAL MERIDIAN"]) * Math.PI / 180.0 ), Double.Parse(prjData["STANDARD PARALLEL ONE"]) * Math.PI / 180.0, new Vector2( Double.Parse(prjData["FALSE EASTING"]), Double.Parse(prjData["FALSE NORTHING"]) ), GoldData.GenerateSpheroid(prjData["DATUM"]) ); var inverse = projection.GetInverse(); while (latLonData.Read() && prjData.Read()) { var coord = latLonData.CurrentLatLon(); var coordRads = latLonData.CurrentLatLonRadians(); var expected = prjData.CurrentPoint2D(); var projected = projection.TransformValue(coordRads); Assert.AreEqual(expected.X, projected.X, projectDelta); Assert.AreEqual(expected.Y, projected.Y, projectDelta); var unProjected = inverse.TransformValue(expected); unProjected = new GeographicCoordinate(unProjected.Latitude * 180.0 / Math.PI, unProjected.Longitude * 180.0 / Math.PI); Assert.AreEqual(coord.Latitude, unProjected.Latitude, unprojectDelta); Assert.AreEqual(coord.Longitude, unProjected.Longitude, unprojectDelta); } }
public KrovakModifiedNorth( GeographicCoordinate geographicOrigin, double latitudeOfPseudoStandardParallel, double azimuthOfInitialLine, double scaleFactor, Vector2 falseProjectedOffset, ISpheroid<double> spheroid, Point2 evaluationPoint, double[] constants ) : this(new KrovakModified( geographicOrigin, latitudeOfPseudoStandardParallel, azimuthOfInitialLine, scaleFactor, falseProjectedOffset, spheroid, evaluationPoint, constants )) { Contract.Requires(spheroid != null); Contract.Requires(constants != null); Contract.Requires(constants.Length == 10); }
public void epsg3140_to_wgs() { var crs = EpsgMicroDatabase.Default.GetCrs(3140); var wgs = EpsgMicroDatabase.Default.GetCrs(4326); // source for coordinates is http://epsg.io/3140/map var ptWgs = new GeographicCoordinate(-17.785, 177.97); var pt3140 = new Point2(530138.52663372, 821498.68898981); // units in links var gen = new EpsgCrsCoordinateOperationPathGenerator(); var paths = gen.Generate(wgs, crs); var compiler = new StaticCoordinateOperationCompiler(); var txs = paths .Select(p => compiler.Compile(p)) .Where(p => p != null); var forward = txs.Single(); var actualForward = (Point2)forward.TransformValue(ptWgs); Assert.AreEqual(pt3140.X, actualForward.X, 30); Assert.AreEqual(pt3140.Y, actualForward.Y, 30); var reverse = forward.GetInverse(); var actualReverse = (GeographicCoordinate)reverse.TransformValue(pt3140); Assert.AreEqual(ptWgs.Longitude, actualReverse.Longitude, 0.01); Assert.AreEqual(ptWgs.Latitude, actualReverse.Latitude, 0.01); }
protected LambertConicBase( GeographicCoordinate geographicOrigin, Vector2 falseProjectedOffset, ISpheroid<double> spheroid ) : base(falseProjectedOffset, spheroid) { Contract.Requires(spheroid != null); GeographicOrigin = geographicOrigin; }
public void Test(string geoResourceName, string prjResourceName, double projectDelta, double unprojectDelta) { var latLonData = GoldData.GetReadyReader(geoResourceName); var prjData = GoldData.GetReadyReader(prjResourceName); var spheroid = GoldData.GenerateSpheroid(prjData["DATUM"]); PolarStereographic projection; if (null != prjData["SCALE FACTOR"]) { projection = new PolarStereographic( new GeographicCoordinate( Math.PI / 2.0, Double.Parse(prjData["LONGITUDE DOWN FROM POLE"]) * Math.PI / 180.0 ), Double.Parse(prjData["SCALE FACTOR"]), new Vector2( Double.Parse(prjData["FALSE EASTING"]), Double.Parse(prjData["FALSE NORTHING"]) ), spheroid ); } else { var latSp = Double.Parse(prjData["LATITUDE OF TRUE SCALE"]) * Math.PI / 180.0; var originLat = latSp < 0 ? -Math.PI / 2.0 : Math.PI / 2.0; projection = PolarStereographic.CreateFromStandardParallel( new GeographicCoordinate( originLat, Double.Parse(prjData["LONGITUDE DOWN FROM POLE"]) * Math.PI / 180.0 ), latSp, new Vector2( Double.Parse(prjData["FALSE EASTING"]), Double.Parse(prjData["FALSE NORTHING"]) ), spheroid ); } var inverse = projection.GetInverse(); while (latLonData.Read() && prjData.Read()) { var coord = latLonData.CurrentLatLon(); var coordRads = latLonData.CurrentLatLonRadians(); var expected = prjData.CurrentPoint2D(); var projected = projection.TransformValue(coordRads); Assert.AreEqual(expected.X, projected.X, projectDelta); Assert.AreEqual(expected.Y, projected.Y, projectDelta); var unProjected = inverse.TransformValue(expected); unProjected = new GeographicCoordinate(unProjected.Latitude * 180.0 / Math.PI, unProjected.Longitude * 180.0 / Math.PI); Assert.AreEqual(coord.Latitude, unProjected.Latitude, unprojectDelta); Assert.AreEqual(coord.Longitude, unProjected.Longitude, unprojectDelta); } }
public void epsg_example_1_3_14() { var projection = new EquidistantCylindrical(GeographicCoordinate.Zero, Vector2.Zero, new SpheroidEquatorialInvF(6378137, 298.257223563)); var input = new GeographicCoordinate(0.959931086, 0.174532925); var expected = new Point2(1113194.91, 6097230.31); var result = projection.TransformValue(input); Assert.AreEqual(expected.X, result.X, 0.004); Assert.AreEqual(expected.Y, result.Y, 0.02); }
private Point2 TransformValueNorth(GeographicCoordinate source) { var theta = source.Longitude - GeographicOrigin.Longitude; var eSinLat = Math.Sin(source.Latitude) * E; var r = Math.Tan(QuarterPi - (source.Latitude / 2.0)) * Math.Pow((1 + eSinLat) / (1 - eSinLat), EHalf) * CoefficientT; var de = r * Math.Sin(theta); var dn = r * Math.Cos(theta); return(new Point2(de + FalseProjectedOffset.X, FalseProjectedOffset.Y - dn)); }
public override Point2 TransformValue(GeographicCoordinate coordinate) { var eSinLat = Math.Sin(coordinate.Latitude) * E; return(new Point2( ((coordinate.Longitude - CentralMeridian) * Ak) + FalseProjectedOffset.X, (Math.Log( Math.Tan((coordinate.Latitude / 2.0) + QuarterPi) * Math.Pow((1.0 - eSinLat) / (1.0 + eSinLat), EHalf) ) * Ak) + FalseProjectedOffset.Y )); }
public void Vincenty_CorrectlyCalculatesDestinationCoordinates(double latA, double lonA, double bearingInRadians, double distanceInMeters, double expectedLat, double expectedLon, int maxIterations, double tolerance) { IGeographicCoordinate pointA = new GeographicCoordinate(latA, lonA); IGeographicCoordinate expected = new GeographicCoordinate(expectedLat, expectedLon); IGeographicCoordinate result = pointA.DestinationCoordinates(new Angle(bearingInRadians, AngleMeasurement.Radians), new Distance(distanceInMeters, DistanceMeasurement.Meters), maxIterations, tolerance); Assert.Equal(expected, result); }
public EquidistantCylindrical(GeographicCoordinate origin, Vector2 falseProjectedOffset, ISpheroid <double> spheroid) : base(falseProjectedOffset, spheroid) { Contract.Requires(spheroid != null); _origin = origin; var e4 = ESq * ESq; var e6 = e4 * ESq; var e8 = e6 * ESq; var e10 = e8 * ESq; var e12 = e10 * ESq; var e14 = e12 * ESq; _coefLine1 = 1.0 - (ESq / 4.0) - (3.0 / 64.0 * e4) - (5.0 / 256.0 * e6) - (175.0 / 16384.0 * e8) - (441.0 / 65536.0 * e10) - (4851.0 / 1048576.0 * e12) - (14157.0 / 4194304.0 * e14); _coefLine2 = (-3.0 / 8.0 * ESq) - (3.0 / 32.0 * e4) - (45.0 / 1024.0 * e6) - (105.0 / 4096.0 * e8) - (2205.0 / 131072.0 * e10) - (6237.0 / 524288.0 * e12) - (297297.0 / 33554432.0 * e14); _coefLine3 = (15.0 / 256.0 * e4) + (45.0 / 1024.0 * e6) + (525.0 / 16384.0 * e8) + (1575.0 / 65536.0 * e10) + (155925.0 / 8388608.0 * e12) + (495495.0 / 33554432.0 * e14); _coefLine4 = (-35.0 / 3072.0 * e6) - (175.0 / 12288.0 * e8) - (3675.0 / 262144.0 * e10) - (13475.0 / 1048576.0 * e12) - (385385.0 / 33554432.0 * e14); _coefLine5 = (315.0 / 131072.0 * e8) + (2205.0 / 524288.0 * e10) + (43659.0 / 8388608.0 * e12) + (189189.0 / 33554432.0 * e14); _coefLine6 = (-693.0 / 1310720.0 * e10) - (6237.0 / 5242880.0 * e12) - (297297.0 / 167772160.0 * e14); _coefLine7 = (1001.0 / 8388608.0 * e12) + (11011.0 / 33554432.0 * e14); _coefLine8 = (-6435.0 / 234881024.0 * e14); var sinLatOrigin = Math.Sin(_origin.Latitude); var v = MajorAxis / Math.Sqrt(1.0 - (ESq * sinLatOrigin * sinLatOrigin)); _vCosLatOrigin = v * Math.Cos(_origin.Latitude); }
public void Test(string geoResourceName, string mercResourceName, double projectDelta, double unprojectDelta) { var latLonData = GoldData.GetReadyReader(geoResourceName); var lccData = GoldData.GetReadyReader(mercResourceName); var latTrueScale = lccData["LATITUDE OF TRUE SCALE"]; Mercator projection; if (null == latTrueScale) { projection = new Mercator( Double.Parse(lccData["CENTRAL MERIDIAN"]) / 180 * Math.PI, Double.Parse(lccData["SCALE FACTOR"]), new Vector2( Double.Parse(lccData["FALSE EASTING"]), Double.Parse(lccData["FALSE NORTHING"]) ), GoldData.GenerateSpheroid(lccData["DATUM"]) ); } else { projection = new Mercator( new GeographicCoordinate( Double.Parse(latTrueScale) / 180 * Math.PI, Double.Parse(lccData["CENTRAL MERIDIAN"]) / 180 * Math.PI ), new Vector2( Double.Parse(lccData["FALSE EASTING"]), Double.Parse(lccData["FALSE NORTHING"]) ), GoldData.GenerateSpheroid(lccData["DATUM"]) ); } var inverse = projection.GetInverse(); while (latLonData.Read() && lccData.Read()) { var coord = latLonData.CurrentLatLon(); var coordRads = latLonData.CurrentLatLonRadians(); var expected = lccData.CurrentPoint2D(); var projected = projection.TransformValue(coordRads); Assert.AreEqual(expected.X, projected.X, projectDelta); Assert.AreEqual(expected.Y, projected.Y, projectDelta); var unProjected = inverse.TransformValue(expected); unProjected = new GeographicCoordinate(unProjected.Latitude * 180.0 / Math.PI, unProjected.Longitude * 180.0 / Math.PI); Assert.AreEqual(coord.Latitude, unProjected.Latitude, unprojectDelta); Assert.AreEqual(coord.Longitude, unProjected.Longitude, unprojectDelta); } }
public override Point2 TransformValue(GeographicCoordinate source) { var m = CalculateM(source.Latitude); var sinLat = Math.Sin(source.Latitude); var mScalar = Math.Cos(source.Latitude) / Math.Sqrt(ESq * sinLat * sinLat); var p = (MajorAxis * MScalarOrigin / SinLatOrigin) + MOrigin + m; var t = MajorAxis * mScalar * (source.Longitude - GeographicOrigin.Longitude) / p; return(new Point2( (p * Math.Sin(t)) + FalseProjectedOffset.X, ((MajorAxis * MScalarOrigin / SinLatOrigin) - (p * Math.Cos(t))) + FalseProjectedOffset.Y )); }
public void Vincenty_CorrectlyCalculatesBearingFromPointBearingDistance(double latA, double lonA, double bearingInRadians, double distanceInMeters, double expectedBearing, int maxIterations, double tolerance) { IGeographicCoordinate pointA = new GeographicCoordinate(latA, lonA); IAngle initialBearing = new Angle(bearingInRadians, AngleMeasurement.Radians); IDistance distance = new Distance(distanceInMeters, DistanceMeasurement.Meters); IAngle expected = new Angle(expectedBearing, AngleMeasurement.Radians); IAngle result = pointA.BearingFrom(initialBearing, distance, maxIterations, tolerance); Assert.Equal(expected, result); }
public override Point2 TransformValue(GeographicCoordinate source) { throw new NotImplementedException("I have no idea what is going on."); var sinLat = Math.Sin(source.Latitude); var q = (1 - ESq) * ( (sinLat / (1 - (ESq * sinLat * sinLat))) - ((1.0 / (2.0 * E)) * Math.Log((1 - (E * sinLat)) / (1 + (E * sinLat)))) ); return(new Point2( MajorAxis * Scale * (source.Longitude - GeographicOrigin.Longitude), MajorAxis * q / (2.0 * Scale))); }
/// <summary> /// Constructs a Mercator projection from 2 standard parallels. /// </summary> /// <param name="geographicOrigin">The geographic origin.</param> /// <param name="falseProjectedOffset">The false projected offset.</param> /// <param name="spheroid">The spheroid.</param> public Mercator( GeographicCoordinate geographicOrigin, Vector2 falseProjectedOffset, ISpheroid <double> spheroid ) : this( geographicOrigin.Longitude, CalculateScaleFactor(geographicOrigin.Latitude, spheroid.ESquared), falseProjectedOffset, spheroid ) { Contract.Requires(spheroid != null); }
public override Point2 TransformValue(GeographicCoordinate source) { var sinLat = Math.Sin(source.Latitude); var x = MajorAxis * (source.Longitude - GeographicOrigin.Longitude) * Math.Cos(source.Latitude) / Math.Sqrt(1 - (ESq * sinLat * sinLat)); var m = CalculateM(source.Latitude); var y = m - MOrigin + (x * x * Math.Tan(source.Latitude) * Math.Sqrt(1 - (ESq * sinLat * sinLat)) / (2.0 * MajorAxis)); return(new Point2( FalseProjectedOffset.X + x, FalseProjectedOffset.Y + y )); }
public PolarStereographic(GeographicCoordinate geographicOrigin, double scaleFactor, Vector2 falseProjectedOffset, ISpheroid <double> spheroid) : base(falseProjectedOffset, spheroid) { Contract.Requires(spheroid != null); ScaleFactor = scaleFactor; GeographicOrigin = geographicOrigin; CrazyEValue = CalculateCrazyEValue(E); CoefficientT = MajorAxis * 2.0 * ScaleFactor / CrazyEValue; _transform = IsNorth(geographicOrigin.Latitude) ? (Func <GeographicCoordinate, Point2>)TransformValueNorth : TransformValueSouth; }
public TransverseMercatorSouth( GeographicCoordinate naturalOrigin, Vector2 falseProjectedOffset, double scaleFactor, ISpheroid <double> spheroid ) : base( naturalOrigin, new Vector2(-falseProjectedOffset.X, -falseProjectedOffset.Y), scaleFactor, spheroid ) { Contract.Requires(spheroid != null); }
public LambertCylindricalEqualAreaSpherical(GeographicCoordinate origin, Vector2 offset, ISpheroid <double> spheroid) : base(offset, spheroid) { Contract.Requires(spheroid != null); // ReSharper disable CompareOfFloatsByEqualityOperator GeographicOrigin = origin; CosLatOrigin = Math.Cos(GeographicOrigin.Latitude); R = MajorAxis; if (E != 0) { R *= Math.Sqrt((1 - (((1.0 - ESq) / (2.0 * E)) * Math.Log((1 - E) / (1 + E)))) / 2.0); } // ReSharper restore CompareOfFloatsByEqualityOperator }
public void EpsgExample134InverseTest() { var projection = new CassiniSoldner( new GeographicCoordinate(0.182241463, -1.070468608), new Vector2(430000.00, 325000.00), new SpheroidEquatorialInvF(31706587.88, 294.2606764) ); var result = projection.GetInverse().TransformValue(new Point2(66644.94, 82536.22)); var expected = new GeographicCoordinate(0.17453293, -1.08210414); Assert.AreEqual(expected.Latitude, result.Latitude, 0.00000004); Assert.AreEqual(expected.Longitude, result.Longitude, 0.000000004); }
public void Initalize(int id, int res, float scale, bool shaded, GameObject planetObj) { m_id = id; m_res = res; m_res2 = m_res * m_res; m_scale = scale; m_geo = new GeographicCoordinate[8]; for (int i = 0; i < m_geo.Length; i++) { m_geo[i] = new GeographicCoordinate(); } m_cullVector = transform.localPosition.normalized; m_planet = new PlanetInfo() { obj = planetObj, planetComp = planetObj.GetComponent <Planet>() }; m_neighbourChunks = new PlanetChunk[27]; m_meshFilter = GetComponent <MeshFilter>(); m_meshCollider = GetComponent <MeshCollider>(); m_mcRender = new MarchingCubes { m_MCRenderShader = m_MCRenderShader, m_clearVerticesShader = m_ClearVerticesShader, m_calculateNormalsShader = m_CalculateNormalsShader, m_meshMaterial = m_meshMaterial, m_recalculateNormals = !shaded, m_chunkTransform = transform }; m_mcRender.InitalizeRenderMesh(m_res, m_res, m_res, m_scale); m_mcCollider = new MarchingCubes { m_MCColliderShader = m_MCColliderShader, m_clearVerticesShader = m_ClearVerticesShader, }; m_mcCollider.InitalizeColliderCompute(m_res, m_res, m_res, scale); m_borderMaps.borderMapx = new float[2 * m_res2]; m_borderMaps.borderMapy = new float[2 * m_res2]; m_borderMaps.borderMapz = new float[2 * m_res2]; m_borderMaps.borderMapxy = new float[3 * m_res]; m_borderMaps.borderMapyz = new float[3 * m_res]; m_borderMaps.borderMapxz = new float[3 * m_res]; m_borderMaps.borderMapxyz = new float[4]; }
public LambertConicConformal1SpWest( GeographicCoordinate geographicOrigin, double originScaleFactor, Vector2 falseProjectedOffset, ISpheroid <double> spheroid ) : base( geographicOrigin, originScaleFactor, new Vector2(-falseProjectedOffset.X, falseProjectedOffset.Y), spheroid ) { Contract.Requires(spheroid != null); }
private static IEnumerable <List <GeographicCoordinate> > ReadPagesToGeographicCoordinate(IEnumerator <Dictionary <int, Shape> > pages) { while (pages.MoveNext()) { var page = pages.Current; var points = new List <GeographicCoordinate>(page.Count); foreach (var shape in page.Values) { var p = new GeographicCoordinate(shape.Vertices[1], shape.Vertices[0]); points.Add(p); } yield return(points); } }
public override Point2 TransformValue(GeographicCoordinate source) { var lonDiff = source.Longitude - ( GeogCoordinatesAreRelativeToGreenwich ? GreenwichCenterLongitude : ParisCenterLongitude); var sinLat = Math.Sin(source.Latitude); var eSinLat = E * sinLat; var halfLat = source.Latitude / 2.0; var betaLonDiff = Beta * lonDiff; var q = C + ( Beta * Math.Log( Math.Tan(QuarterPi + halfLat) * Math.Pow((1 - eSinLat) / (1 + eSinLat), EHalf) ) ); var p = (Math.Atan(Math.Pow(Math.E, q)) * 2.0) - HalfPi; var cosP = Math.Cos(p); var sinP = Math.Sin(p); var cosL = Math.Cos(betaLonDiff); var sinL = Math.Sin(betaLonDiff); var u = (cosP * cosL * Math.Cos(SLatitude)) + (sinP * Math.Sin(SLatitude)); var v = (cosP * cosL * Math.Sin(SLatitude)) - (sinP * Math.Cos(SLatitude)); var w = cosP * sinL; var d = Math.Sqrt((u * u) + (v * v)); double lPrime, pPrime; if (0 == d) { lPrime = 0; pPrime = w < 0 ? -HalfPi : HalfPi; } else { lPrime = Math.Atan(v / (u + d)) * 2.0; pPrime = Math.Atan(w / d); } var h = -lPrime; var hi = Math.Log(Math.Tan(QuarterPi + (pPrime / 2.0))); var g = (1 - Math.Cos(2.0 * Azimuth)) / 12.0; var gi = Math.Sin(2.0 * Azimuth) / 12.0; var x = FalseProjectedOffset.X + (R * (hi + (gi * hi * hi * hi))); var y = FalseProjectedOffset.Y + (R * (h + (g * h * h * h))); return(new Point2(x, y)); }
public override Point2 TransformValue(GeographicCoordinate source) { double deltaLon = source.Longitude - GeographicOrigin.Longitude; double cosLat = Math.Cos(source.Latitude); double cosDeltaLonCosLat = Math.Cos(deltaLon) * cosLat; double sinLat = Math.Sin(source.Latitude); double rk = R * Math.Sqrt( 2.0 / (1.0 + (_sinLatOrg * sinLat) + (_cosLatOrg * cosDeltaLonCosLat)) ); double x = rk * cosLat * Math.Sin(deltaLon); double y = rk * ((_cosLatOrg * sinLat) - (_sinLatOrg * cosDeltaLonCosLat)); return(new Point2(x, y)); }
public void EpsgExample_1_3_3_C_Test() { var projection = Mercator.ConstructVariantC( new GeographicCoordinate(0.73303829, 0.89011792), new Vector2(0, 0), new SpheroidEquatorialInvF(6378245, 298.3)); var input = new GeographicCoordinate(0.9250245, 0.9250245); var expected = new Point2(165704.29, 1351950.22); var result = projection.TransformValue(input); Assert.AreEqual(expected.X, result.X, 0.04); Assert.AreEqual(expected.Y, result.Y, 0.06); }
public void EpsgExample_1_3_3_2_Test() { var projection = new PopularVisualizationPseudoMercator( new GeographicCoordinate(0, 0), new Vector2(0, 0), new SpheroidEquatorialPolar(6378137, 298.2572236) ); var input = new GeographicCoordinate(0.425542460, -1.751147016); var expected = new Point2(-11169055.58, 2800000.00); var result = projection.TransformValue(input); Assert.AreEqual(expected.X, result.X, 0.005); Assert.AreEqual(expected.Y, result.Y, 0.006); }
public void EpsgExample_1_3_3_B_InverseTest() { var projection = new Mercator( new GeographicCoordinate(0.73303829, 0.89011792), new Vector2(0, 0), new SpheroidEquatorialInvF(6378245, 298.3) ); var expected = new GeographicCoordinate(0.9250245, 0.9250245); var input = new Point2(165704.29, 5171848.07); var result = projection.GetInverse().TransformValue(input); Assert.AreEqual(expected.Latitude, result.Latitude, 0.000000006); Assert.AreEqual(expected.Longitude, result.Longitude, 0.000000005); }
public void EpsgExample221WithoutHeightTest() { var transform = new GeographicGeocentricTransformation(new SpheroidEquatorialInvF(6378137.000, 298.2572236)); var inputValue = new GeographicCoordinate(0.939151102, 0.037167659); // the actual point is 73 from the surface var expectedVector = new Vector3(3771793.968, 140253.342, 5124304.349); var expectedNormal = expectedVector.GetNormalized(); var result = transform.TransformValue(new GeographicCoordinate(inputValue.Latitude, inputValue.Longitude)); var resultVector = new Vector3(result); // so we can check that the normal is at least the same, as we remove height information var resultNormal = resultVector.GetNormalized(); Assert.AreEqual(expectedNormal.X, resultNormal.X, 0.00000003); Assert.AreEqual(expectedNormal.Y, resultNormal.Y, 0.000000002); Assert.AreEqual(expectedNormal.Z, resultNormal.Z, 0.00000003); Assert.AreEqual(resultVector.GetMagnitude(), expectedVector.GetMagnitude() - 73.0, 0.0005); // it should be about 73 units from the expected height above the surface }
public void EpsgExample1312() { var projection = new LambertConicConformal1Sp( new GeographicCoordinate(0.31415927, -1.34390352), 1, new Vector2(250000, 150000), new SpheroidEquatorialInvF(6378206.400, 294.97870)); var input = new GeographicCoordinate(0.31297535, -1.34292061); var expected = new Point2(255966.58, 142493.51); var result = projection.TransformValue(input); Assert.AreEqual(expected.X, result.X, 0.006); Assert.AreEqual(expected.Y, result.Y, 0.04); }
public void EpsgExample_1_3_3_B_Test() { var projection = new Mercator( new GeographicCoordinate(0.73303829, 0.89011792), new Vector2(0, 0), new SpheroidEquatorialInvF(6378245, 298.3) ); var input = new GeographicCoordinate(0.9250245, 0.9250245); var expected = new Point2(165704.29, 5171848.07); var result = projection.TransformValue(input); Assert.AreEqual(expected.X, result.X, 0.03); Assert.AreEqual(expected.Y, result.Y, 0.05); }
public void EpsgExample_1_3_3_2_InverseTest() { var projection = new PopularVisualizationPseudoMercator( new GeographicCoordinate(0, 0), new Vector2(0, 0), new SpheroidEquatorialPolar(6378137, 298.2572236) ); var expected = new GeographicCoordinate(0.425542460, -1.751147016); var input = new Point2(-11169055.58, 2800000.00); var result = projection.GetInverse().TransformValue(input); Assert.AreEqual(expected.Latitude, result.Latitude, 0.0000000008); Assert.AreEqual(expected.Longitude, result.Longitude, 0.0000000008); }
public override Point2 TransformValue(GeographicCoordinate source) { // common var lonDelta = source.Longitude - LongitudeOrigin; var eSinLat = E * Math.Sin(source.Latitude); var theta = Math.Tan(QuarterPi - (source.Latitude / 2.0)) / Math.Pow((1 - eSinLat) / (1 + eSinLat), EHalf); var q = H / Math.Pow(theta, B); // Q var invQ = 1 / q; var sFactor = (q - invQ) / 2.0; // S var tFactor = (q + invQ) / 2.0; // T var vFactor = Math.Sin(B * lonDelta); // V var uFactor = ((-vFactor * Math.Cos(GammaOrigin)) + (sFactor * Math.Sin(GammaOrigin))) / tFactor; // U var vScalar = A * Math.Log((1 - uFactor) / (1 + uFactor)) / (2.0 * B); // v // variant B double uScalar; if (HasHighAzimuth) { if (lonDelta == 0) { uScalar = 0; } else { uScalar = A * Math.Atan(((sFactor * Math.Cos(GammaOrigin)) + (vFactor * Math.Sin(GammaOrigin))) / Math.Cos(B * lonDelta)) / B; var signLatNeg = GeographicCenter.Latitude < 0; var signLonNeg = lonDelta < 0; var negUc = signLatNeg ^ signLonNeg; var absUc = Math.Abs(Uc); uScalar = negUc ? uScalar + absUc : uScalar - absUc; } } else { uScalar = A * Math.Atan(((sFactor * Math.Cos(GammaOrigin)) + (vFactor * Math.Sin(GammaOrigin))) / Math.Cos(B * lonDelta)) / B; var negUc = GeographicCenter.Latitude < 0; var absUc = Math.Abs(Uc); uScalar = negUc ? uScalar + absUc : uScalar - absUc; } // common var x = (vScalar * Math.Cos(AngleFromRectified)) + (uScalar * Math.Sin(AngleFromRectified)) + FalseProjectedOffset.X; var y = (uScalar * Math.Cos(AngleFromRectified)) - (vScalar * Math.Sin(AngleFromRectified)) + FalseProjectedOffset.Y; return(new Point2(x, y)); }
public void EpsgExample1311Test() { var proj = new LambertConicConformal2Sp( new GeographicCoordinate(0.48578331, -1.72787596), 0.49538262, 0.52854388, new Vector2(2000000.0, 0), new SpheroidEquatorialInvF(20925832.16, 294.97870) ); var a = new GeographicCoordinate(0.49741884, -1.67551608); var b = new Point2(2963503.91, 254759.80); var projected = proj.TransformValue(a); Assert.AreEqual(b.X, projected.X, 0.05); Assert.AreEqual(b.Y, projected.Y, 0.04); }
public void Epsg_1_3_1_5_Inverse_Test() { var projection = new LambertConicNearConformal( new GeographicCoordinate(0.604756586, 0.651880476), 0.99962560, new Vector2(300000.00, 300000.00), new SpheroidEquatorialInvF(6378249.2, 293.46602) ); var expected = new GeographicCoordinate(0.654874806, 0.595793792); var input = new Point2(15707.96, 623165.96); var result = projection.GetInverse().TransformValue(input); Assert.AreEqual(expected.Latitude, result.Latitude, 0.0000000002); Assert.AreEqual(expected.Longitude, result.Longitude, 0.00000000008); }
public LambertAzimuthalEqualAreaOblique( GeographicCoordinate geogOrigin, Vector2 falseOffset, ISpheroid <double> spheroid ) : base(geogOrigin, falseOffset, spheroid) { QOrigin = OneMinusESq * ((SinLatOrigin / (1.0 - (ESq * SinLatOrigin * SinLatOrigin))) - (OneOverTwoE * Math.Log((1.0 - ESinLatOrigin) / (1.0 + ESinLatOrigin)))); QRadiusParallel = MajorAxis * Math.Sqrt(QParallel / 2.0); BetaOrigin = Math.Asin(QOrigin / QParallel); SinBetaOrigin = Math.Sin(BetaOrigin); CosBetaOrigin = Math.Cos(BetaOrigin); D = MajorAxis * (CosLatOrigin / Math.Sqrt(1.0 - (ESq * SinLatOrigin * SinLatOrigin))) / (QRadiusParallel * CosBetaOrigin); ; }
public void EpsgExample_1_3_3_A_Test() { var projection = new Mercator( 1.91986218, 0.997, new Vector2(3900000, 900000), new SpheroidEquatorialInvF(6377397.155, 299.15281) ); var input = new GeographicCoordinate(-0.05235988, 2.09439510); var expected = new Point2(5009726.58, 569150.82); var result = projection.TransformValue(input); Assert.AreEqual(expected.X, result.X, 0.03); Assert.AreEqual(expected.Y, result.Y, 0.02); }
public override Point2 TransformValue(GeographicCoordinate source) { var deltaLon = source.Longitude - GeographicOrigin.Longitude; var cosDeltaLon = Math.Cos(deltaLon); var sinDeltaLon = Math.Sin(deltaLon); var sinLat = Math.Sin(source.Latitude); var q = OneMinusESq * ((sinLat / (1.0 - (ESq * sinLat * sinLat))) - (OneOverTwoE * Math.Log((1.0 - (E * sinLat)) / (1.0 + (E * sinLat))))); var beta = Math.Asin(q / QParallel); var cosBeta = Math.Cos(beta); var sinBeta = Math.Sin(beta); var b = QRadiusParallel * Math.Sqrt(2.0 / (1.0 + (SinBetaOrigin * sinBeta) + (CosBetaOrigin * cosBeta * cosDeltaLon))); var east = FalseProjectedOffset.X + ((b * D) * (cosBeta * sinDeltaLon)); var north = FalseProjectedOffset.Y + ((b / D) * ((CosBetaOrigin * sinBeta) - (SinBetaOrigin * cosBeta * cosDeltaLon))); return(new Point2(east, north)); }
public void EpsgExample_1_3_5_3_Test() { var projection = new TransverseMercatorSouth( new GeographicCoordinate(0, 0.506145483), new Vector2(0, 0), 1, new SpheroidEquatorialInvF(6378137, 298.25722356) ); var expected = new Point2(2847342.74, 71984.49); var input = new GeographicCoordinate(-0.449108618, 0.493625066); var result = projection.TransformValue(input); Assert.AreEqual(expected.X, result.X, 0.003); Assert.AreEqual(expected.Y, result.Y, 0.002); }
public void EpsgExample_1_3_7_1_Inverse() { var projection = new ObliqueStereographic( new GeographicCoordinate(0.910296727, 0.094032038), 0.9999079, new Vector2(155000.00, 463000.00), new SpheroidEquatorialInvF(6377397.155, 299.15281) ); var expected = new GeographicCoordinate(0.925024504, 0.104719755); var input = new Point2(196105.283, 557057.739); var result = projection.GetInverse().TransformValue(input); Assert.AreEqual(expected.Latitude, result.Latitude, 0.000000001); Assert.AreEqual(expected.Longitude, result.Longitude, 0.0000000007); }
protected LambertAzimuthalEqualArea( GeographicCoordinate geogOrigin, Vector2 falseOffset, ISpheroid <double> spheroid ) : base(falseOffset, spheroid) { GeographicOrigin = geogOrigin; OneMinusESq = 1.0 - ESq; OneMinusE = 1.0 - E; OnePlusE = 1.0 + E; OneOverTwoE = 1.0 / (2.0 * E); SinLatOrigin = Math.Sin(GeographicOrigin.Latitude); CosLatOrigin = Math.Cos(GeographicOrigin.Latitude); ESinLatOrigin = E * SinLatOrigin; QParallel = OneMinusESq * ((1.0 / OneMinusESq) - (OneOverTwoE * Math.Log(OneMinusE / OnePlusE))); }
public void EpsgExample_1_3_7_2_A_Inverse() { var projection = new PolarStereographic( new GeographicCoordinate(1.570796327, 0), 0.994, new Vector2(2000000.00, 2000000.00), new SpheroidEquatorialInvF(6378137, 298.2572236) ); var expected = new GeographicCoordinate(1.274090354, 0.767944871); var input = new Point2(3320416.75, 632668.43); var result = projection.GetInverse().TransformValue(input); Assert.AreEqual(expected.Latitude, result.Latitude, 0.0000000005); Assert.AreEqual(expected.Longitude, result.Longitude, 0.000000001); }
public void Epsg_1_3_1_5_Test() { var projection = new LambertConicNearConformal( new GeographicCoordinate(0.604756586, 0.651880476), 0.99962560, new Vector2(300000.00, 300000.00), new SpheroidEquatorialInvF(6378249.2, 293.46602) ); var input = new GeographicCoordinate(0.654874806, 0.595793792); var expected = new Point2(15707.96, 623165.96); var result = projection.TransformValue(input); Assert.AreEqual(expected.X, result.X, 0.0004); Assert.AreEqual(expected.Y, result.Y, 0.02); }
public void EpsgExample1351Test() { var projection = new TransverseMercator( new GeographicCoordinate(0.85521133, -0.03490659), new Vector2(400000.00, -100000.00), 0.9996012717, new SpheroidEquatorialInvF(6377563.396, 299.32496) ); var input = new GeographicCoordinate(0.88139127, 0.00872665); var expected = new Point2(577274.99, 69740.50); var result = projection.TransformValue(input); Assert.AreEqual(expected.X, result.X, 0.03); Assert.AreEqual(expected.Y, result.Y, 0.002); }
public NeysProjection( GeographicCoordinate geographicOrigin, double standardParallel, Vector2 falseProjectedOffset, ISpheroid<double> spheroid ) : base(new GeographicCoordinate( geographicOrigin.Latitude, geographicOrigin.Longitude > Math.PI ? (geographicOrigin.Longitude - TwoPi) : geographicOrigin.Longitude ), geographicOrigin.Latitude >= 0 ? standardParallel : -standardParallel, geographicOrigin.Latitude >= 0 ? MaximumLatitude : -MaximumLatitude, falseProjectedOffset, spheroid) { Contract.Requires(spheroid != null); }
public void gigs_sample_rev() { var degToRad = Math.PI / 180.0; var projection = new AmericanPolyconic( new GeographicCoordinate(0, -54.0 * degToRad), new Vector2(5000000, 10000000), new SpheroidEquatorialInvF(6378.137 * 1000, 298.2572221) ); var expected = new GeographicCoordinate(-6 * degToRad, -45 * degToRad); var input = new Point2(5996378.71, 9328349.94); var result = projection.GetInverse().TransformValue(input); Assert.AreEqual(expected.Latitude, result.Latitude, 0.0006); Assert.AreEqual(expected.Longitude, result.Longitude, 0.00001); }
public void EpsgExample1311InverseTest() { var proj = new LambertConicConformal2Sp( new GeographicCoordinate(0.48578331, -1.72787596), 0.49538262, 0.52854388, new Vector2(2000000.0, 0), new SpheroidEquatorialInvF(20925832.16, 294.97870) ); var a = new GeographicCoordinate(0.49741884, -1.67551608); var b = new Point2(2963503.91, 254759.80); var unProjected = proj.GetInverse().TransformValue(b); Assert.AreEqual(a.Latitude, unProjected.Latitude, 0.000000002); Assert.AreEqual(a.Longitude, unProjected.Longitude, 0.000000003); }
public void Epsg_1_3_6_1_Test() { var projection = new HotineObliqueMercator.VariantB( new GeographicCoordinate(0.069813170, 2.007128640), 0.930536611, 0.927295218, 0.99984, new Vector2(590476.87, 442857.65), new SpheroidEquatorialInvF(6377298.556, 300.8017) ); var input = new GeographicCoordinate(0.094025313, 2.021187362); var expected = new Point2(679245.73, 596562.78); var result = projection.TransformValue(input); Assert.AreEqual(expected.X, result.X, 0.003); Assert.AreEqual(expected.Y, result.Y, 0.001); }
public void EpsgExample1312Inverse() { var projection = new LambertConicConformal1Sp( new GeographicCoordinate(0.31415927, -1.34390352), 1, new Vector2(250000, 150000), new SpheroidEquatorialInvF(6378206.400, 294.97870)); Assert.That(projection.HasInverse); var inverse = projection.GetInverse(); var expected = new GeographicCoordinate(0.31297535, -1.34292061); var input = new Point2(255966.58, 142493.51); var result = inverse.TransformValue(input); Assert.AreEqual(expected.Latitude, result.Latitude, 0.00000001); Assert.AreEqual(expected.Longitude, result.Longitude, 0.00000001); }
public void Espg_1_3_2_1_InverseTest() { var projection = new Krovak( new GeographicCoordinate(0.863937979, 0.741764932), 1.370083463, 0.528627762, 0.9999, Vector2.Zero, new SpheroidEquatorialInvF(6377397.155, 299.15281) ); var expected = new GeographicCoordinate(0.876312568, 0.294084); var input = new Point2(1050538.63, 568991.00); var result = projection.GetInverse().TransformValue(input); Assert.AreEqual(expected.Latitude, result.Latitude, 0.0000000008); Assert.AreEqual(expected.Longitude, result.Longitude, 0.000001); }
public void Espg_1_3_2_2_Test() { var projection = new KrovakNorth( new GeographicCoordinate(0.863937979, 0.741764932), 1.370083463, 0.528627762, 0.9999, Vector2.Zero, new SpheroidEquatorialInvF(6377397.155, 299.15281) ); var input = new GeographicCoordinate(0.876312568, 0.294084); var expected = new Point2(-568991.00, -1050538.63); var result = projection.TransformValue(input); Assert.AreEqual(expected.X, result.X, 0.1); Assert.AreEqual(expected.Y, result.Y, 0.1); }
public KrovakNorth( GeographicCoordinate geographicOrigin, double latitudeOfPseudoStandardParallel, double azimuthOfInitialLine, double scaleFactor, Vector2 falseProjectedOffset, ISpheroid<double> spheroid ) : this(new Krovak( geographicOrigin, latitudeOfPseudoStandardParallel, azimuthOfInitialLine, scaleFactor, falseProjectedOffset, spheroid )) { Contract.Requires(spheroid != null); }
public void map_proj_working_manual_lambert_az_eq_area_spherical_example() { var projection = new LambertAzimuthalEqualAreaSpherical( new GeographicCoordinate(0, 0), new Vector2(0, 0), new Sphere(1)); Assert.That(projection.HasInverse); var inverse = projection.GetInverse(); var projectedExpected = new Point2(0.61040, 0.54826); var geographicExpected = new GeographicCoordinate(30 * Math.PI / 180.0, 40 * Math.PI / 180.0); var projectedActual = projection.TransformValue(geographicExpected); Assert.AreEqual(projectedExpected.X, projectedActual.X, 0.00001); Assert.AreEqual(projectedExpected.Y, projectedActual.Y, 0.000003); var geographicActual = inverse.TransformValue(projectedExpected); Assert.AreEqual(geographicExpected.Latitude, geographicActual.Latitude, 0.00001); Assert.AreEqual(geographicExpected.Longitude, geographicActual.Longitude, 0.000004); }
public void Epsg_1_3_6_1_Inverse_Test() { var projectionForward = new HotineObliqueMercator.VariantB( new GeographicCoordinate(0.069813170, 2.007128640), 0.930536611, 0.927295218, 0.99984, new Vector2(590476.87, 442857.65), new SpheroidEquatorialInvF(6377298.556, 300.8017) ); Assert.That(projectionForward.HasInverse); var inverse = projectionForward.GetInverse(); var expected = new GeographicCoordinate(0.094025313, 2.021187362); var input = new Point2(679245.73, 596562.78); var result = inverse.TransformValue(input); Assert.AreEqual(expected.Latitude, result.Latitude, 0.00001); Assert.AreEqual(expected.Longitude, result.Longitude, 0.0000000005); }
public void epsg_example_1_3_11() { var projection = new LambertAzimuthalEqualAreaOblique( new GeographicCoordinate(0.907571211, 0.174532925), new Vector2(4321000, 3210000), new SpheroidEquatorialInvF(6378137, 298.2572221)); var projectedExpected = new Point2(3962799.45, 2999718.85); var geographicExpected = new GeographicCoordinate(0.872664626, 0.087266463); var projectedActual = projection.TransformValue(geographicExpected); Assert.AreEqual(projectedExpected.X, projectedActual.X, 0.004); Assert.AreEqual(projectedExpected.Y, projectedActual.Y, 0.004); var inverse = projection.GetInverse(); Assert.IsNotNull(inverse); var geographicActual = inverse.TransformValue(projectedExpected); Assert.AreEqual(geographicExpected.Latitude, geographicActual.Latitude, 0.000001); Assert.AreEqual(geographicExpected.Longitude, geographicActual.Longitude, 0.00000003); }