public void Test(string sourceResourceName, string targetResourceName, double projectDelta, double unprojectDelta) { var sourceData = GoldData.GetReadyReader(sourceResourceName); var targetData = GoldData.GetReadyReader(targetResourceName); var sourceCrs = GoldData.GetCrs(sourceData); var targetCrs = GoldData.GetCrs(targetData); Assert.IsNotNull(sourceCrs); Assert.IsNotNull(targetCrs); var operationGenerator = new HelmertCrsCoordinateOperationPathGenerator(); var operationPath = operationGenerator.Generate(sourceCrs, targetCrs).First(); Assert.IsNotNull(operationPath); var compiler = new StaticCoordinateOperationCompiler(); var forward = new CompiledConcatenatedTransformation<GeographicCoordinate, Point2>(compiler.Compile(operationPath) as IEnumerable<ITransformation>); var inverse = forward.GetInverse(); while (sourceData.Read() && targetData.Read()) { var geogreaphicExpected = sourceData.CurrentLatLon(); var projectedExpected = targetData.CurrentPoint2D(); var projected = forward.TransformValue(geogreaphicExpected); Assert.AreEqual(projectedExpected.X, projected.X, projectDelta); Assert.AreEqual(projectedExpected.Y, projected.Y, projectDelta); var geographic = inverse.TransformValue(projectedExpected); Assert.AreEqual(geogreaphicExpected.Latitude, geographic.Latitude, unprojectDelta); Assert.AreEqual(geogreaphicExpected.Longitude, geographic.Longitude, unprojectDelta); } }
public StaticCoordinateOperationCompiler.StepCompilationResult Compile(StaticCoordinateOperationCompiler.StepCompilationParameters stepParameters) { if(stepParameters == null) throw new ArgumentNullException("stepParameters"); Contract.EndContractBlock(); return CompileInverse(stepParameters) ?? CompileForwards(stepParameters); }
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); }
private static StaticCoordinateOperationCompiler.StepCompilationResult CreateHelmertStep(TransformationCompilationParams opData, Helmert7Transformation helmert) { Contract.Requires(opData != null); Contract.Requires(helmert != null); if (opData.StepParams.RelatedInputCrs is ICrsGeocentric && opData.StepParams.RelatedOutputCrs is ICrsGeocentric) { return(new StaticCoordinateOperationCompiler.StepCompilationResult( opData.StepParams, opData.StepParams.RelatedOutputCrsUnit ?? opData.StepParams.RelatedInputCrsUnit ?? opData.StepParams.InputUnit, helmert)); } var spheroidFrom = ExtractSpheroid(opData.StepParams.RelatedInputCrs) ?? ExtractSpheroid(opData.StepParams.RelatedOutputCrs); if (null == spheroidFrom) { return(null); } var spheroidTo = ExtractSpheroid(opData.StepParams.RelatedOutputCrs) ?? spheroidFrom; ITransformation transformation = new GeocentricTransformationGeographicWrapper(spheroidFrom, spheroidTo, helmert); var unitConversion = StaticCoordinateOperationCompiler.CreateCoordinateUnitConversion(opData.StepParams.InputUnit, OgcAngularUnit.DefaultRadians); if (null != unitConversion) { transformation = new ConcatenatedTransformation(new[] { unitConversion, transformation }); } return(new StaticCoordinateOperationCompiler.StepCompilationResult( opData.StepParams, OgcAngularUnit.DefaultRadians, transformation)); }
private static StaticCoordinateOperationCompiler.StepCompilationResult CreateGeographicTopocentric(TransformationCompilationParams opData) { Contract.Requires(opData != null); var outputUnit = opData.StepParams.RelatedOutputCrsUnit; if (null == outputUnit) { return(null); } var latParam = new KeywordNamedParameterSelector("LAT"); var lonParam = new KeywordNamedParameterSelector("LON"); var hParam = new KeywordNamedParameterSelector("H"); opData.ParameterLookup.Assign(latParam, lonParam, hParam); GeographicHeightCoordinate origin; if (!TryCreateGeographicHeightCoordinate(latParam.Selection, lonParam.Selection, hParam.Selection, OgcAngularUnit.DefaultRadians, opData.StepParams.RelatedOutputCrsUnit, out origin)) { origin = GeographicHeightCoordinate.Zero; } var spheroidIn = opData.StepParams.ConvertRelatedInputSpheroidUnit(outputUnit); if (null == spheroidIn) { return(null); } var spheroidOut = opData.StepParams.ConvertRelatedOutputSpheroidUnit(outputUnit); if (null == spheroidOut) { return(null); } var geographicGeocentric = new GeographicGeocentricTransformation(spheroidIn); var topocentricOrigin = geographicGeocentric.TransformValue(origin); var transformations = new List <ITransformation>() { geographicGeocentric, new GeocentricTopocentricTransformation(topocentricOrigin, spheroidOut) }; var inputUnitConversion = StaticCoordinateOperationCompiler.CreateCoordinateUnitConversion(opData.StepParams.InputUnit, OgcAngularUnit.DefaultRadians); if (null != inputUnitConversion) { transformations.Insert(0, inputUnitConversion); } return(new StaticCoordinateOperationCompiler.StepCompilationResult( opData.StepParams, outputUnit, new ConcatenatedTransformation(transformations) )); }
private static StaticCoordinateOperationCompiler.StepCompilationResult CreateGeocentricTranslation(TransformationCompilationParams opData) { Contract.Requires(opData != null); var xParam = new KeywordNamedParameterSelector("XAXIS", "X"); var yParam = new KeywordNamedParameterSelector("YAXIS", "Y"); var zParam = new KeywordNamedParameterSelector("ZAXIS", "Z"); opData.ParameterLookup.Assign(xParam, yParam, zParam); Vector3 delta; if (!TryCreateVector3(xParam.Selection, yParam.Selection, zParam.Selection, out delta)) { return(null); } if (opData.StepParams.RelatedInputCrs is ICrsGeocentric && opData.StepParams.RelatedOutputCrs is ICrsGeocentric) { // assume the units are correct return(new StaticCoordinateOperationCompiler.StepCompilationResult( opData.StepParams, opData.StepParams.RelatedOutputCrsUnit ?? opData.StepParams.RelatedInputCrsUnit ?? opData.StepParams.InputUnit, new GeocentricTranslation(delta))); } // TODO: need to handle unit here var inputSpheroid = opData.StepParams.RelatedInputSpheroid; if (null == inputSpheroid) { return(null); } // TODO: may even need to convert units while translating // TODO: need to handle unit here var outputSpheroid = opData.StepParams.RelatedOutputSpheroid; if (null == outputSpheroid) { return(null); } ITransformation transformation = new GeographicGeocentricTranslation(inputSpheroid, delta, outputSpheroid); var conv = StaticCoordinateOperationCompiler.CreateCoordinateUnitConversion(opData.StepParams.InputUnit, OgcAngularUnit.DefaultRadians); if (null != conv) { transformation = new ConcatenatedTransformation(new[] { conv, transformation }); } return(new StaticCoordinateOperationCompiler.StepCompilationResult( opData.StepParams, OgcAngularUnit.DefaultRadians, transformation)); }
private StaticCoordinateOperationCompiler.StepCompilationResult CompileInverse(StaticCoordinateOperationCompiler.StepCompilationParameters stepParameters) { Contract.Requires(stepParameters != null); if (!stepParameters.CoordinateOperationInfo.IsInverseOfDefinition || !stepParameters.CoordinateOperationInfo.HasInverse) { return(null); } var inverseOperationInfo = stepParameters.CoordinateOperationInfo.GetInverse(); if (null == inverseOperationInfo) { return(null); } var expectedOutputUnits = stepParameters.RelatedOutputCrsUnit ?? stepParameters.RelatedInputCrsUnit ?? stepParameters.InputUnit; var forwardCompiledStep = CompileForwardToTransform(new StaticCoordinateOperationCompiler.StepCompilationParameters( inverseOperationInfo, expectedOutputUnits, stepParameters.RelatedOutputCrs, stepParameters.RelatedInputCrs )); if (null == forwardCompiledStep) { return(null); } var forwardCompiledOperation = forwardCompiledStep.Transformation; if (!forwardCompiledOperation.HasInverse) { return(null); } var inverseCompiledOperation = forwardCompiledOperation.GetInverse(); var resultTransformation = inverseCompiledOperation; // make sure that the input units are correct var unitConversion = StaticCoordinateOperationCompiler.CreateCoordinateUnitConversion(stepParameters.InputUnit, forwardCompiledStep.OutputUnit); if (null != unitConversion) { resultTransformation = new ConcatenatedTransformation(new[] { unitConversion, resultTransformation }); } return(new StaticCoordinateOperationCompiler.StepCompilationResult( stepParameters, expectedOutputUnits, resultTransformation )); }
public TestRunner() { _epsgPathGenerator = new EpsgCrsCoordinateOperationPathGenerator(); _epsgPathGenerator.CrsFilters = new List<Predicate<EpsgCrs>> { IsNotDeprecated }; _epsgPathGenerator.OpFilters = new List<Predicate<ICoordinateOperationInfo>>{ IsNotDeprecated, IsNotRestricted }; _coordinateOperationCompiler = new StaticCoordinateOperationCompiler(); }
private static StaticCoordinateOperationCompiler.StepCompilationResult CreateTunisiaMiningGrid(TransformationCompilationParams opData) { Contract.Requires(opData != null); ITransformation transformation = new TunisiaMiningGrid(); var conv = StaticCoordinateOperationCompiler.CreateCoordinateUnitConversion(opData.StepParams.InputUnit, OgcAngularUnit.DefaultGrads); if (null != conv) { transformation = new ConcatenatedTransformation(new[] { conv, transformation }); } return(new StaticCoordinateOperationCompiler.StepCompilationResult( opData.StepParams, OgcLinearUnit.DefaultKilometer, transformation)); }
private static StaticCoordinateOperationCompiler.StepCompilationResult CreateMadridToEd50Polynomial(TransformationCompilationParams opData) { Contract.Requires(opData != null); var a0Param = new FullMatchParameterSelector("A0"); var a1Param = new FullMatchParameterSelector("A1"); var a2Param = new FullMatchParameterSelector("A2"); var a3Param = new FullMatchParameterSelector("A3"); var b00Param = new FullMatchParameterSelector("B00"); var b0Param = new FullMatchParameterSelector("B0"); var b1Param = new FullMatchParameterSelector("B1"); var b2Param = new FullMatchParameterSelector("B2"); var b3Param = new FullMatchParameterSelector("B3"); opData.ParameterLookup.Assign(a0Param, a1Param, a2Param, a3Param, b00Param, b0Param, b1Param, b2Param, b3Param); double a0, a1, a2, a3, b00, b0, b1, b2, b3; TryGetCoefficientValue(a0Param.Selection, out a0); TryGetCoefficientValue(a1Param.Selection, out a1); TryGetCoefficientValue(a2Param.Selection, out a2); TryGetCoefficientValue(a3Param.Selection, out a3); TryGetCoefficientValue(b00Param.Selection, out b00); TryGetCoefficientValue(b0Param.Selection, out b0); TryGetCoefficientValue(b1Param.Selection, out b1); TryGetCoefficientValue(b2Param.Selection, out b2); TryGetCoefficientValue(b3Param.Selection, out b3); ITransformation transformation = new MadridEd50Polynomial(a0, a1, a2, a3, b00, b0, b1, b2, b3); var conv = StaticCoordinateOperationCompiler.CreateCoordinateUnitConversion(opData.StepParams.InputUnit, OgcAngularUnit.DefaultDegrees); if (null != conv) { transformation = new ConcatenatedTransformation(new[] { conv, transformation }); } return(new StaticCoordinateOperationCompiler.StepCompilationResult( opData.StepParams, OgcAngularUnit.DefaultDegrees, transformation)); }
public void epsg3079_to_epsg3575() { var from = EpsgMicroDatabase.Default.GetCrs(3079); var to = EpsgMicroDatabase.Default.GetCrs(3575); var wgs = EpsgMicroDatabase.Default.GetCrs(4326); var somePlaceInMichigan = new GeographicCoordinate(40.4, -91.8); var expected3079 = new Point2(6992.885640195105, -644.956855237484); var expected3575 = new Point2(-5244224.354585549, 1095575.5476152631); var gen = new EpsgCrsCoordinateOperationPathGenerator(); var fromPath = gen.Generate(from, wgs).First(); var toPath = gen.Generate(to, wgs).First(); var compiler = new StaticCoordinateOperationCompiler(); var fromTx = compiler.Compile(fromPath); var toTx = compiler.Compile(toPath); var a = (GeographicCoordinate)fromTx.TransformValue(expected3079); Assert.AreEqual(somePlaceInMichigan.Latitude, a.Latitude, 0.01); Assert.AreEqual(somePlaceInMichigan.Longitude, a.Longitude, 0.01); var b = (Point2)fromTx.GetInverse().TransformValue(somePlaceInMichigan); Assert.AreEqual(expected3079.X, b.X, 0.01); Assert.AreEqual(expected3079.Y, b.Y, 0.01); var d = (Point2)toTx.GetInverse().TransformValue(somePlaceInMichigan); Assert.AreEqual(expected3575.X, d.X, 0.01); Assert.AreEqual(expected3575.Y, d.Y, 0.01); var c = (GeographicCoordinate)toTx.TransformValue(expected3575); Assert.AreEqual(somePlaceInMichigan.Latitude, c.Latitude, 0.01); Assert.AreEqual(somePlaceInMichigan.Longitude, c.Longitude, 0.01); var allTotalPaths = gen.Generate(from, to).ToList(); var totalPath = allTotalPaths.First(); var totalTx = compiler.Compile(totalPath); var actual3575 = (Point2)totalTx.TransformValue(expected3079); Assert.AreEqual(expected3575.X, actual3575.X, 1); Assert.AreEqual(expected3575.Y, actual3575.Y, 1); }
private StaticCoordinateOperationCompiler.StepCompilationResult CompileForwards(StaticCoordinateOperationCompiler.StepCompilationParameters stepParameters) { Contract.Requires(stepParameters != null); var forwardCompiledOperation = CompileForwardToTransform(stepParameters); if (null == forwardCompiledOperation) return null; ITransformation resultTransformation = forwardCompiledOperation; // make sure that the input units are correct var actualInputUnits = stepParameters.InputUnit; var desiredInputUnits = OgcAngularUnit.DefaultRadians; if (null != desiredInputUnits && !UnitEqualityComparer.Default.Equals(actualInputUnits, desiredInputUnits)) { var conv = SimpleUnitConversionGenerator.FindConversion(actualInputUnits, desiredInputUnits); if (null != conv) { var conversionTransformation = new AngularElementTransformation(conv); resultTransformation = new ConcatenatedTransformation(new[] { conversionTransformation, resultTransformation }); } } var outputUnits = stepParameters.RelatedOutputCrsUnit ?? stepParameters.RelatedInputCrsUnit ?? OgcLinearUnit.DefaultMeter; return new StaticCoordinateOperationCompiler.StepCompilationResult( stepParameters, outputUnits, resultTransformation ); }
private ConversionResult ExecuteStaticEpsg(TestCase testCase) { var result = new ConversionResult(); try { var paths = _epsgPathGenerator.Generate(testCase.Source, testCase.Target) .OrderBy(x => GetEpsgAccuracy(x) ?? 999); var compiler = new StaticCoordinateOperationCompiler(); var compiledPaths = paths .Select(x => compiler.Compile(x)); var bestCompiledPath = compiledPaths.FirstOrDefault(x => x != null); var transformation = bestCompiledPath; if (transformation == null) throw new InvalidOperationException("No compiled transformation"); result.ResultData = transformation.TransformValues(testCase.InputCoordinates).ToArray(); } catch (Exception ex) { result.Exception = ex; } return result; }
public void epsg3857_to_wgs() { var crs = EpsgMicroDatabase.Default.GetCrs(3857); var wgs = EpsgMicroDatabase.Default.GetCrs(4326); var ptWgs = new GeographicCoordinate(45,10); var pt3857 = new Point2(1113194, 5621521); 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 actualZeroMeters = (Point2)forward.TransformValue(GeographicCoordinate.Zero); Assert.AreEqual(0, actualZeroMeters.X); Assert.AreEqual(0, actualZeroMeters.Y, 0.0000001); var actualForward = (Point2)forward.TransformValue(ptWgs); Assert.AreEqual(pt3857.X, actualForward.X, 30); Assert.AreEqual(pt3857.Y, actualForward.Y, 30); var reverse = forward.GetInverse(); var actualZeroDegrees = (GeographicCoordinate)reverse.TransformValue(Point2.Zero); Assert.AreEqual(0, actualZeroDegrees.Longitude); Assert.AreEqual(0, actualZeroDegrees.Latitude); var actualReverse = (GeographicCoordinate)reverse.TransformValue(pt3857); Assert.AreEqual(ptWgs.Longitude, actualReverse.Longitude, 0.0001); Assert.AreEqual(ptWgs.Latitude, actualReverse.Latitude, 0.0001); }
private StaticCoordinateOperationCompiler.StepCompilationResult CompileInverse(StaticCoordinateOperationCompiler.StepCompilationParameters stepParameters) { Contract.Requires(stepParameters != null); if (!stepParameters.CoordinateOperationInfo.IsInverseOfDefinition || !stepParameters.CoordinateOperationInfo.HasInverse) return null; var inverseOperationInfo = stepParameters.CoordinateOperationInfo.GetInverse(); if (null == inverseOperationInfo) return null; var forwardCompiledOperation = CompileForwardToTransform(new StaticCoordinateOperationCompiler.StepCompilationParameters( inverseOperationInfo, OgcAngularUnit.DefaultRadians, stepParameters.RelatedOutputCrs, stepParameters.RelatedInputCrs )); if (null == forwardCompiledOperation || !forwardCompiledOperation.HasInverse) return null; var inverseCompiledOperation = forwardCompiledOperation.GetInverse(); ITransformation resultTransformation = inverseCompiledOperation; // make sure that the input units are correct var actualInputUnits = stepParameters.InputUnit; /*var projectionSpheroid = stepParameters.RelatedInputSpheroid as ISpheroidInfo; var desiredInputUnits = null == projectionSpheroid ? stepParameters.RelatedInputCrsUnit : projectionSpheroid.AxisUnit;*/ var desiredInputUnits = stepParameters.RelatedInputCrsUnit; if (null != desiredInputUnits && !UnitEqualityComparer.Default.Equals(actualInputUnits, desiredInputUnits)) { var conv = SimpleUnitConversionGenerator.FindConversion(actualInputUnits, desiredInputUnits); if (null != conv) { var conversionTransformation = new LinearElementTransformation(conv); resultTransformation = new ConcatenatedTransformation(new[] { conversionTransformation, resultTransformation }); } } // the result units will be radians return new StaticCoordinateOperationCompiler.StepCompilationResult( stepParameters, OgcAngularUnit.DefaultRadians, resultTransformation ); }
public void epsg4326_to_5072() { var wgs = EpsgMicroDatabase.Default.GetCrs(4326); var nad83Albers = EpsgMicroDatabase.Default.GetCrs(5072); var gen = new EpsgCrsCoordinateOperationPathGenerator(); var paths = gen.Generate(wgs, nad83Albers); var compiler = new StaticCoordinateOperationCompiler(); var txs = paths.Select(p => compiler.Compile(p)).Where(p => p != null); var forward = txs.Single(); var transformed = (Point2)forward.TransformValue(new GeographicCoordinate(39, -105)); Assert.AreEqual(-771063, transformed.X, 1); Assert.AreEqual(1811448, transformed.Y, 1); }
private StaticCoordinateOperationCompiler.StepCompilationResult CompileForwards(StaticCoordinateOperationCompiler.StepCompilationParameters stepParameters) { Contract.Requires(stepParameters != null); var forwardCompiledStep = CompileForwardToTransform(stepParameters); if (null == forwardCompiledStep) return null; return new StaticCoordinateOperationCompiler.StepCompilationResult( stepParameters, forwardCompiledStep.OutputUnit, forwardCompiledStep.Transformation ); }
public HttpResponseMessage Draw(double? minLon, double? maxLon, double? minLat, double? maxLat, int? maxImgWidth, int? maxImgHeight) { var shapefilePath = HostingEnvironment.MapPath("~/App_Data/builtupp_usa/builtupp_usa.shp"); ITransformation<GeographicCoordinate, Point2> transformation = null; var targetCrs = EpsgMicroDatabase.Default.GetCrs(3005); LongitudeDegreeRange dataLongitudeRange; Range dataLatitudeRange; using (var shapeFile = Shapefile.Open(shapefilePath)) { dataLongitudeRange = new LongitudeDegreeRange(shapeFile.Extent.MinX, shapeFile.Extent.MaxX); dataLatitudeRange = new Range(shapeFile.Extent.MinY, shapeFile.Extent.MaxY); var dataCrs = EpsgMicroDatabase.Default.GetCrs(4326); var pathGenerator = new EpsgCrsCoordinateOperationPathGenerator(); var paths = pathGenerator.Generate(dataCrs, targetCrs); var compiler = new StaticCoordinateOperationCompiler(); var firstTransfom = paths.Select(p => { return compiler.Compile(p); }).First(x => x != null); transformation = firstTransfom as ITransformation<GeographicCoordinate, Point2>; if (transformation == null && firstTransfom is IEnumerable<ITransformation>) transformation = new CompiledConcatenatedTransformation<GeographicCoordinate, Point2>((IEnumerable<ITransformation>)firstTransfom); } var geoMbrMin = new GeographicCoordinate(minLat ?? dataLatitudeRange.Low, minLon ?? dataLongitudeRange.Start); var geoMbrMax = new GeographicCoordinate(maxLat ?? dataLatitudeRange.High, maxLon ?? dataLongitudeRange.End); var geoMbrTL = new GeographicCoordinate(geoMbrMax.Latitude, geoMbrMin.Longitude); var geoMbrTR = new GeographicCoordinate(geoMbrMin.Latitude, geoMbrMax.Longitude); var projectedMbrPoints = new[] { geoMbrMin, geoMbrMax, geoMbrTL, geoMbrTR, new GeographicCoordinate(geoMbrMin.Latitude, Math.Abs(geoMbrMin.Longitude + geoMbrMax.Longitude) / 2.0) } .Select(transformation.TransformValue) .ToArray(); var projectedExtent = new Mbr( new Point2(projectedMbrPoints.Min(x => x.X), projectedMbrPoints.Min(x => x.Y)), new Point2(projectedMbrPoints.Max(x => x.X), projectedMbrPoints.Max(x => x.Y)) ); var geogMapOrigin = new GeographicCoordinate(dataLatitudeRange.Mid, dataLongitudeRange.Mid); var mapOrigin = transformation.TransformValue(geogMapOrigin); var mapOffset = new Vector2(0/*-(mapOrigin.X - projectedExtent.X.Mid)*/, projectedExtent.Height / 2.0); var imageSizeLimits = new Vector2(maxImgWidth ?? 300, maxImgHeight ?? 300); if (imageSizeLimits.X > 4096 || imageSizeLimits.Y > 4096) throw new ArgumentException("Image size too large"); var dataRatio = new Vector2(projectedExtent.Width / imageSizeLimits.X, projectedExtent.Height / imageSizeLimits.Y); var lowCorner = projectedExtent.Min; Vector2 desiredImageSize; double imageScaleFactor; if (dataRatio.Y < dataRatio.X) { imageScaleFactor = imageSizeLimits.X / projectedExtent.Width; desiredImageSize = new Vector2(imageSizeLimits.X, (int)(projectedExtent.Height * imageScaleFactor)); } else { imageScaleFactor = imageSizeLimits.Y / projectedExtent.Height; desiredImageSize = new Vector2((int)(projectedExtent.Width * imageScaleFactor), imageSizeLimits.Y); } using (var image = new System.Drawing.Bitmap((int)desiredImageSize.X, (int)desiredImageSize.Y)) using (var graphics = Graphics.FromImage(image)) { graphics.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.HighQuality; var shapeSource = new PointShapefileShapeSource(shapefilePath); var shapeReader = new ShapeReader(shapeSource); using (var shapeEnumerator = shapeReader.GetEnumerator()) { var sourceCoordinates = ReadPagesToGeographicCoordinate(shapeEnumerator).SelectMany(x => x); var pointColor = Color.Black; var circleFillBrush = new SolidBrush(Color.FromArgb(64,16,64,128)); var featureRadius = 3.0; var featureDiameter = featureRadius * 2; var featureDiameterFloat = (float)featureDiameter; var topLeftOffset = new Vector2(-featureRadius,-featureRadius); foreach (var transformedPoint in transformation.TransformValues(sourceCoordinates)) { var offsetPoint = transformedPoint.Difference(lowCorner).Add(mapOffset); var scaledPoint = offsetPoint.GetScaled(imageScaleFactor); var screenPoint = new Point2(scaledPoint.X, image.Height - scaledPoint.Y); var drawTopLeft = screenPoint.Add(topLeftOffset); graphics.FillEllipse(circleFillBrush, (float)drawTopLeft.X, (float)drawTopLeft.Y, featureDiameterFloat, featureDiameterFloat); } } var result = new HttpResponseMessage(HttpStatusCode.OK); byte[] imageBytes; using (var memoryStream = new MemoryStream()) { image.Save(memoryStream, ImageFormat.Png); imageBytes = memoryStream.ToArray(); } result.Content = new ByteArrayContent(imageBytes); result.Content.Headers.ContentType = new System.Net.Http.Headers.MediaTypeHeaderValue("image/png"); return result; } }
private Helmert7Transformation ExtractHelmert7Transformation(EpsgCoordinateTransformInfo transform) { var method = transform.Method; Contract.Assume(method != null); var compiler = new StaticCoordinateOperationCompiler(); var compileRequest = new CoordinateOperationCrsPathInfo( new[] { transform.SourceCrs, transform.TargetCrs }, new[] { transform }); var compileResult = compiler.Compile(compileRequest); if (compileResult == null) return null; var transformSteps = (compileResult as IEnumerable<ITransformation>) ?? ArrayUtil.CreateSingleElementArray(compileResult); var exposedSteps = transformSteps.Select(step => { if (step is GeocentricTransformationGeographicWrapper) { return ((GeocentricTransformationGeographicWrapper)step).GeocentricCore; } return step; }); foreach (var step in exposedSteps) { if (step is Helmert7Transformation) { return step as Helmert7Transformation; } if (step is GeocentricTranslation) { return new Helmert7Transformation(((GeocentricTranslation)step).Delta); } if (step is GeographicGeocentricTranslation) { return new Helmert7Transformation(((GeographicGeocentricTranslation)step).Delta); } } return null; }
private StaticCoordinateOperationCompiler.StepCompilationResult CompileForwardToTransform(StaticCoordinateOperationCompiler.StepCompilationParameters stepParameters) { Contract.Requires(stepParameters != null); string operationName = null; IEnumerable<INamedParameter> parameters = null; var parameterizedOperation = stepParameters.CoordinateOperationInfo as IParameterizedCoordinateOperationInfo; if (null != parameterizedOperation) { if (null != parameterizedOperation.Method) operationName = parameterizedOperation.Method.Name; parameters = parameterizedOperation.Parameters; } if (String.IsNullOrEmpty(operationName)) operationName = stepParameters.CoordinateOperationInfo.Name; if (String.IsNullOrEmpty(operationName)) return null; var parameterLookup = new NamedParameterLookup(parameters ?? Enumerable.Empty<INamedParameter>()); var compilationParams = new TransformationCompilationParams(stepParameters, parameterLookup, operationName); var normalizedName = _coordinateOperationNameComparer.Normalize(compilationParams.OperationName); if (normalizedName.StartsWith("POSITIONVECTORTRANSFORMATION")) return CreatePositionVectorTransformation(compilationParams); if (normalizedName.StartsWith("COORDINATEFRAMEROTATION")) return CreateCoordinateFrameRotationTransformation(compilationParams); if (normalizedName.StartsWith("MOLODENSKYBADEKAS")) return CreateMolodenskyBadekas(compilationParams); if (normalizedName.Equals("GEOGRAPHICOFFSET") || (normalizedName.StartsWith("GEOGRAPHIC") && normalizedName.EndsWith("OFFSET"))) return CreateGeographicOffset(compilationParams); if (normalizedName.StartsWith("GEOCENTRICTRANSLATION")) return CreateGeocentricTranslation(compilationParams); if (normalizedName.Equals("VERTICALOFFSET")) return CreateVerticalOffset(compilationParams); if (normalizedName.Equals("MADRIDTOED50POLYNOMIAL")) return CreateMadridToEd50Polynomial(compilationParams); if (normalizedName.Equals("SIMILARITYTRANSFORMATION")) return CreateSimilarityTransformation(compilationParams); if (normalizedName.Equals("AFFINEPARAMETRICTRANSFORMATION")) return CreateAffineParametricTransformation(compilationParams); if (normalizedName.Equals("GEOGRAPHIC3DTO2DCONVERSION") || normalizedName.Equals("GEOGRAPHIC2DTO3DCONVERSION")) return CreateGeographicDimensionChange(compilationParams); if (normalizedName.Equals("TUNISIAMININGGRID")) return CreateTunisiaMiningGrid(compilationParams); if (normalizedName.StartsWith("GEOCENTRICTOPOCENTRIC")) return CreateGeocentricTopocentric(compilationParams); if (normalizedName.StartsWith("GEOGRAPHICTOPOCENTRIC")) return CreateGeographicTopocentric(compilationParams); if (normalizedName.StartsWith("VERTICALPERSPECTIVE")) { return CreateVerticalPerspective(compilationParams); } return null; }
private static StaticCoordinateOperationCompiler.StepCompilationResult CreateMolodenskyBadekas(TransformationCompilationParams opData) { Contract.Requires(opData != null); var xTransParam = new KeywordNamedParameterSelector("XAXIS", "TRANS"); var yTransParam = new KeywordNamedParameterSelector("YAXIS", "TRANS"); var zTransParam = new KeywordNamedParameterSelector("ZAXIS", "TRANS"); var xRotParam = new KeywordNamedParameterSelector("XAXIS", "ROT"); var yRotParam = new KeywordNamedParameterSelector("YAXIS", "ROT"); var zRotParam = new KeywordNamedParameterSelector("ZAXIS", "ROT"); var scaleParam = new KeywordNamedParameterSelector("SCALE"); var ord1Param = new KeywordNamedParameterSelector("ORDINATE1"); var ord2Param = new KeywordNamedParameterSelector("ORDINATE2"); var ord3Param = new KeywordNamedParameterSelector("ORDINATE3"); if (!opData.ParameterLookup.Assign(xTransParam, yTransParam, zTransParam, xRotParam, yRotParam, zRotParam, scaleParam, ord1Param, ord2Param, ord3Param)) { return(null); } Vector3 translation, rotation; Point3 ordinate; double scale; if (!TryCreateVector3(xTransParam.Selection, yTransParam.Selection, zTransParam.Selection, out translation)) { return(null); } if (!TryCreateVector3(xRotParam.Selection, yRotParam.Selection, zRotParam.Selection, OgcAngularUnit.DefaultRadians, out rotation)) { return(null); } if (!TryCreatePoint3(ord1Param.Selection, ord2Param.Selection, ord3Param.Selection, out ordinate)) { return(null); } if (!NamedParameter.TryGetDouble(scaleParam.Selection, out scale)) { return(null); } var molodensky = new MolodenskyBadekasTransformation(translation, rotation, ordinate, scale); if (opData.StepParams.RelatedInputCrs is ICrsGeocentric && opData.StepParams.RelatedOutputCrs is ICrsGeocentric) { return(new StaticCoordinateOperationCompiler.StepCompilationResult( opData.StepParams, opData.StepParams.RelatedOutputCrsUnit ?? opData.StepParams.RelatedInputCrsUnit ?? opData.StepParams.InputUnit, molodensky)); } // TODO: need to handle units here var spheroidFrom = opData.StepParams.RelatedInputSpheroid; if (null == spheroidFrom) { return(null); } // TODO: need to handle units here var spheroidTo = opData.StepParams.RelatedOutputSpheroid; if (null == spheroidTo) { return(null); } ITransformation transformation = new GeocentricTransformationGeographicWrapper(spheroidFrom, spheroidTo, molodensky); var conv = StaticCoordinateOperationCompiler.CreateCoordinateUnitConversion(opData.StepParams.InputUnit, OgcAngularUnit.DefaultRadians); if (null != conv) { transformation = new ConcatenatedTransformation(new[] { conv, transformation }); } return(new StaticCoordinateOperationCompiler.StepCompilationResult( opData.StepParams, OgcAngularUnit.DefaultRadians, transformation)); }
private ITransformation<GeographicCoordinate, Point2> CompileForwardToTransform(StaticCoordinateOperationCompiler.StepCompilationParameters stepParameters) { Contract.Requires(stepParameters != null); string operationName = null; IEnumerable<INamedParameter> parameters = null; var parameterizedOperation = stepParameters.CoordinateOperationInfo as IParameterizedCoordinateOperationInfo; if (null != parameterizedOperation) { if (null != parameterizedOperation.Method) operationName = parameterizedOperation.Method.Name; parameters = parameterizedOperation.Parameters; } if (null == operationName) operationName = stepParameters.CoordinateOperationInfo.Name; Func<ProjectionCompilationParams, ITransformation<GeographicCoordinate, Point2>> projectionCompiler; if (String.IsNullOrEmpty(operationName) || !_transformationCreatorLookup.TryGetValue(operationName, out projectionCompiler) || null == projectionCompiler) return null; var parameterLookup = new NamedParameterLookup(parameters ?? Enumerable.Empty<INamedParameter>()); var projectionCompilationParams = new ProjectionCompilationParams(stepParameters, parameterLookup, operationName); return projectionCompiler(projectionCompilationParams); }
private StaticCoordinateOperationCompiler.StepCompilationResult CompileInverse(StaticCoordinateOperationCompiler.StepCompilationParameters stepParameters) { Contract.Requires(stepParameters != null); if (!stepParameters.CoordinateOperationInfo.IsInverseOfDefinition || !stepParameters.CoordinateOperationInfo.HasInverse) return null; var inverseOperationInfo = stepParameters.CoordinateOperationInfo.GetInverse(); if (null == inverseOperationInfo) return null; var expectedOutputUnits = stepParameters.RelatedOutputCrsUnit ?? stepParameters.RelatedInputCrsUnit ?? stepParameters.InputUnit; var forwardCompiledStep = CompileForwardToTransform(new StaticCoordinateOperationCompiler.StepCompilationParameters( inverseOperationInfo, expectedOutputUnits, stepParameters.RelatedOutputCrs, stepParameters.RelatedInputCrs )); if (null == forwardCompiledStep) return null; var forwardCompiledOperation = forwardCompiledStep.Transformation; if (!forwardCompiledOperation.HasInverse) return null; var inverseCompiledOperation = forwardCompiledOperation.GetInverse(); var resultTransformation = inverseCompiledOperation; // make sure that the input units are correct var unitConversion = StaticCoordinateOperationCompiler.CreateCoordinateUnitConversion(stepParameters.InputUnit, forwardCompiledStep.OutputUnit); if (null != unitConversion) resultTransformation = new ConcatenatedTransformation(new[] { unitConversion, resultTransformation }); return new StaticCoordinateOperationCompiler.StepCompilationResult( stepParameters, expectedOutputUnits, resultTransformation ); }
public TransformationCompilationParams( StaticCoordinateOperationCompiler.StepCompilationParameters stepParams, NamedParameterLookup parameterLookup, string operationName ) { Contract.Requires(stepParams != null); Contract.Requires(parameterLookup != null); Contract.Requires(!String.IsNullOrEmpty(operationName)); StepParams = stepParams; ParameterLookup = parameterLookup; OperationName = operationName; }