public void Transform_FromSweref99_ToWgs84() { resultWgs84 = crsTransformationAdapter.TransformToCoordinate(coordinateSweref99, epsgWGS84); AssertCoordinateResult( resultWgs84, coordinateWgs84, maxLatLongDifferenceForSuccessfulTest ); // testing the same transform as above but with the overloaded // method taking a string as last parameter instead of integer AssertCoordinateResult( crsTransformationAdapter.TransformToCoordinate(coordinateSweref99, crsCodeWGS84), coordinateWgs84, maxLatLongDifferenceForSuccessfulTest ); // testing the same transform as above but with the overloaded // method taking a string as last parameter instead of string or integer AssertCoordinateResult( crsTransformationAdapter.TransformToCoordinate(coordinateSweref99, CrsIdentifierFactory.CreateFromEpsgNumber(epsgWGS84)), coordinateWgs84, maxLatLongDifferenceForSuccessfulTest ); }
public void TransformResult_FromRT90_ToSweref99() { CrsTransformationResult result = crsTransformationAdapter.Transform(coordinateRT90, epsgSweref99); AssertTransformationResultSuccess( result, coordinateRT90, coordinateSweref99, crsTransformationAdapter, maxMeterDifferenceForSuccessfulTest ); // testing the same transform as above but with the overloaded // method taking a string as last parameter instead of integer AssertTransformationResultSuccess( crsTransformationAdapter.Transform(coordinateRT90, crsCodeSweref99), coordinateRT90, coordinateSweref99, crsTransformationAdapter, maxMeterDifferenceForSuccessfulTest ); // testing the same transform as above but with the overloaded // method taking a string as last parameter instead of string or integer AssertTransformationResultSuccess( crsTransformationAdapter.Transform(coordinateRT90, CrsIdentifierFactory.CreateFromEpsgNumber(epsgSweref99)), coordinateRT90, coordinateSweref99, crsTransformationAdapter, maxMeterDifferenceForSuccessfulTest ); }
public void CreateFromCrsCode_ShouldThrowException_WhenCrsCodeIsNull() { ArgumentException exception = Assert.Throws<ArgumentNullException>( () => { CrsIdentifierFactory.CreateFromCrsCode(null); } , "CRS code must not be null" ); }
public void CrsIdentifierFactory_ShouldThrowException_WhenCrsCodeInputIsOnlyWhitespace() { ArgumentException exception = Assert.Throws<ArgumentException>( () => { CrsIdentifierFactory.CreateFromCrsCode(" "); // should fail } , "Must not be empty string" ); AssertExceptionMessageWhenArgumentWasNullOrEmptyString(exception, "non-empty"); }
public void CrsIdentifierFactory_ShouldThrowException_WhenEpsgNumberIsNegative() { ArgumentException exception = Assert.Throws<ArgumentException>( () => { CrsIdentifierFactory.CreateFromEpsgNumber(-1); // should fail } , "EPSG must not be negative" ); AssertExceptionMessageWhenArgumentWasNullOrEmptyString(exception, "non-positive"); }
public void CrsIdentifierFactory_ShouldThrowException_WhenCrsCodeIsEpsgWithNegativeNumber() { ArgumentException exception = Assert.Throws<ArgumentException>( () => { CrsIdentifierFactory.CreateFromCrsCode(GetCrsCodeIncludingUppercasedEpsgPrefix(-123)); // should fail } , "EPSG must not be negative" ); AssertExceptionMessageWhenArgumentWasNullOrEmptyString(exception, "non-positive"); }
public void method2() { int epsgNumber = 4326; string crsCode = "EPSG:" + epsgNumber; CrsIdentifier crsIdentifier; // namespace Programmerare.CrsTransformations.Identifier crsIdentifier = CrsIdentifierFactory.CreateFromEpsgNumber(epsgNumber); // Alternative: crsIdentifier = CrsIdentifierFactory.CreateFromCrsCode(crsCode); double latitude = 59.330231; double longitude = 18.059196; CrsCoordinate crsCoordinate; // namespace Programmerare.CrsTransformations.Coordinate // All the below methods are alternatives for creating the same coordinate // with the above latitude/longitude and coordinate reference system. // No class or object is used for the methods below because of the following static import: // using static Programmerare.CrsTransformations.Coordinate.CrsCoordinateFactory; crsCoordinate = LatLon(latitude, longitude, epsgNumber); crsCoordinate = LatLon(latitude, longitude, crsCode); crsCoordinate = LatLon(latitude, longitude, crsIdentifier); crsCoordinate = LonLat(longitude, latitude, epsgNumber); crsCoordinate = LonLat(longitude, latitude, crsCode); crsCoordinate = LonLat(longitude, latitude, crsIdentifier); crsCoordinate = YX(latitude, longitude, epsgNumber); crsCoordinate = YX(latitude, longitude, crsCode); crsCoordinate = YX(latitude, longitude, crsIdentifier); crsCoordinate = XY(longitude, latitude, epsgNumber); crsCoordinate = XY(longitude, latitude, crsCode); crsCoordinate = XY(longitude, latitude, crsIdentifier); crsCoordinate = NorthingEasting(latitude, longitude, epsgNumber); crsCoordinate = NorthingEasting(latitude, longitude, crsCode); crsCoordinate = NorthingEasting(latitude, longitude, crsIdentifier); crsCoordinate = EastingNorthing(longitude, latitude, epsgNumber); crsCoordinate = EastingNorthing(longitude, latitude, crsCode); crsCoordinate = EastingNorthing(longitude, latitude, crsIdentifier); crsCoordinate = CreateFromYNorthingLatitudeAndXEastingLongitude(latitude, longitude, epsgNumber); crsCoordinate = CreateFromYNorthingLatitudeAndXEastingLongitude(latitude, longitude, crsCode); crsCoordinate = CreateFromYNorthingLatitudeAndXEastingLongitude(latitude, longitude, crsIdentifier); crsCoordinate = CreateFromXEastingLongitudeAndYNorthingLatitude(longitude, latitude, epsgNumber); crsCoordinate = CreateFromXEastingLongitudeAndYNorthingLatitude(longitude, latitude, crsCode); crsCoordinate = CreateFromXEastingLongitudeAndYNorthingLatitude(longitude, latitude, crsIdentifier); CrsIdentifier targetCrs = CrsIdentifierFactory.CreateFromEpsgNumber(3006); CrsTransformationResult crsTransformationResult = crsTransformationAdapter.Transform(crsCoordinate, targetCrs); // see more example code further down in this webpage }
private void crsIdentifierCode() { // public factory methods: crsIdentifier = CrsIdentifierFactory.CreateFromEpsgNumber(4326); crsIdentifier = CrsIdentifierFactory.CreateFromCrsCode("EPSG:4326"); // public properties: crsCode = crsIdentifier.CrsCode; epsgNumber = crsIdentifier.EpsgNumber; isEpsgCode = crsIdentifier.IsEpsgCode; }
public void CrsIdentifierFactory_ShouldThrowException_WhenCrsCodeInputIsNull() { ArgumentException exception = Assert.Throws<ArgumentNullException>( () => { CrsIdentifierFactory.CreateFromCrsCode(null); // should fail } , "Must not be null" ); // F# code invoked above may throw exception like this: // nullArg "crsCode" // Resulting message: "Value cannot be null. Parameter name: crsCode" AssertExceptionMessageWhenArgumentWasNullOrEmptyString(exception, "cannot be null"); }
public void CrsIdentifier_ShouldReturnEpsgNumberAndUppercasedEpsgPrefixedWhitespaceTrimmedCrsCodeAndBeConsideredAsEpsg_WhenCreatedFromLowecasedEpsgCodeWithSurroundingWhitespace() { int inputEpsgNumber = 4326; string inputCrsCode = " epsg:" + inputEpsgNumber + " "; CrsIdentifier crsIdentifier = CrsIdentifierFactory.CreateFromCrsCode(inputCrsCode); // the input should become trimmed and return string with uppercased "EPSG:" prefix Assert.AreEqual( GetCrsCodeIncludingUppercasedEpsgPrefix(inputEpsgNumber), crsIdentifier.CrsCode ); Assert.AreEqual(true, crsIdentifier.IsEpsgCode); Assert.AreEqual(inputEpsgNumber, crsIdentifier.EpsgNumber); }
public void CrsIdentifier_ShouldReturnEpsgNumberAndEpsgPrefixedCrsCodeAndBeConsideredAsEpsg_WhenCreatedFromEpsgNumber() { int inputEpsgNumber = 3006; // No validation that the number is actually an existing EPSG but any positive integer // is assumed to be a EPSG number CrsIdentifier crsIdentifier = CrsIdentifierFactory.CreateFromEpsgNumber(inputEpsgNumber); Assert.AreEqual( inputEpsgNumber, // expected crsIdentifier.EpsgNumber ); Assert.AreEqual(GetCrsCodeIncludingUppercasedEpsgPrefix(inputEpsgNumber), crsIdentifier.CrsCode); Assert.AreEqual(true, crsIdentifier.IsEpsgCode); }
public void crsIdentifier_shouldNotBeEqual_whenDifferentNonEpsgCrsCode() { Assert.AreNotEqual( CrsIdentifierFactory.CreateFromCrsCode("abc"), CrsIdentifierFactory.CreateFromCrsCode("abd") ); }
public void CrsIdentifier_ShouldNotBeEqual_WhenDifferentCrsCode() { Assert.AreNotEqual( CrsIdentifierFactory.CreateFromCrsCode("EPSG:987"), CrsIdentifierFactory.CreateFromCrsCode("EPSG:986") ); }
public void CrsIdentifier_ShouldReturnWhitespaceTrimmedCrsCodeAndNotBeConsideredAsEpsg_WhenCreatedFromNonEpsgString() { CrsIdentifier crsIdentifier = CrsIdentifierFactory.CreateFromCrsCode(" abc "); Assert.AreEqual("abc", crsIdentifier.CrsCode); Assert.AreEqual(false, crsIdentifier.IsEpsgCode); }
public void CrsIdentifiers_ShouldBeEqual_WhenCreatedFromEpsgNumberAndCorrespondingCrsCode() { CrsIdentifier fromEpsgNumber = CrsIdentifierFactory.CreateFromEpsgNumber(3006); CrsIdentifier fromCrsCode = CrsIdentifierFactory.CreateFromCrsCode(" epsg:3006 "); Assert.AreEqual(fromEpsgNumber, fromCrsCode); Assert.AreEqual(fromEpsgNumber.GetHashCode(), fromCrsCode.GetHashCode()); }
public void SetUp() { weightFactory = CrsTransformationAdapterWeightFactory.Create(); crsTransformationAdapterCompositeFactory = CrsTransformationAdapterCompositeFactory.Create(); double[] outputLatitudes = { 59.1, 59.2, 59.3, 59.4, 59.6, }; expectedMedianLatitude = 59.3; expectedAverageLatitude = 59.32; double[] outputLongitudes = { 18.2, 18.3, 18.4, 18.8, 18.9 }; expectedMedianLongitude = 18.4; expectedAverageLongitude = 18.52; outputCoordinateWgs84ForImplementation_1 = CrsCoordinateFactory.CreateFromLatitudeLongitude(outputLatitudes[0], outputLongitudes[3]); outputCoordinateWgs84ForImplementation_2 = CrsCoordinateFactory.CreateFromLatitudeLongitude(outputLatitudes[2], outputLongitudes[1]); outputCoordinateWgs84ForImplementation_3 = CrsCoordinateFactory.CreateFromLatitudeLongitude(outputLatitudes[4], outputLongitudes[4]); outputCoordinateWgs84ForImplementation_4 = CrsCoordinateFactory.CreateFromLatitudeLongitude(outputLatitudes[1], outputLongitudes[0]); outputCoordinateWgs84ForImplementation_5 = CrsCoordinateFactory.CreateFromLatitudeLongitude(outputLatitudes[3], outputLongitudes[2]); outputCoordinates = new List <CrsCoordinate> { outputCoordinateWgs84ForImplementation_1, outputCoordinateWgs84ForImplementation_2, outputCoordinateWgs84ForImplementation_3, outputCoordinateWgs84ForImplementation_4, outputCoordinateWgs84ForImplementation_5 }; mock1 = new Mock <ICrsTransformationAdapter>(); mock2 = new Mock <ICrsTransformationAdapter>(); mock3 = new Mock <ICrsTransformationAdapter>(); mock4 = new Mock <ICrsTransformationAdapter>(); mock5 = new Mock <ICrsTransformationAdapter>(); leafAdapterImplementation_1 = mock1.Object; leafAdapterImplementation_2 = mock2.Object; leafAdapterImplementation_3 = mock3.Object; leafAdapterImplementation_4 = mock4.Object; leafAdapterImplementation_5 = mock5.Object; inputCoordinateSweref99 = CrsCoordinateFactory.CreateFromYNorthingLatitudeAndXEastingLongitude(6580822.0, 674032.0, EpsgNumber.SWEDEN__SWEREF99_TM__3006); CrsTransformationResult leafResult1 = CrsTransformationResult._CreateCrsTransformationResult( inputCoordinateSweref99, outputCoordinateWgs84ForImplementation_1, null, true, leafAdapterImplementation_1, CrsTransformationResultStatistic._CreateCrsTransformationResultStatistic(new List <CrsTransformationResult>()) ); CrsTransformationResult leafResult2 = CrsTransformationResult._CreateCrsTransformationResult( inputCoordinateSweref99, outputCoordinateWgs84ForImplementation_2, null, true, leafAdapterImplementation_2, CrsTransformationResultStatistic._CreateCrsTransformationResultStatistic(new List <CrsTransformationResult>()) ); CrsTransformationResult leafResult3 = CrsTransformationResult._CreateCrsTransformationResult( inputCoordinateSweref99, outputCoordinateWgs84ForImplementation_3, null, true, leafAdapterImplementation_3, CrsTransformationResultStatistic._CreateCrsTransformationResultStatistic(new List <CrsTransformationResult>()) ); CrsTransformationResult leafResult4 = CrsTransformationResult._CreateCrsTransformationResult( inputCoordinateSweref99, outputCoordinateWgs84ForImplementation_4, null, true, leafAdapterImplementation_4, CrsTransformationResultStatistic._CreateCrsTransformationResultStatistic(new List <CrsTransformationResult>()) ); CrsTransformationResult leafResult5 = CrsTransformationResult._CreateCrsTransformationResult( inputCoordinateSweref99, outputCoordinateWgs84ForImplementation_5, null, true, leafAdapterImplementation_5, CrsTransformationResultStatistic._CreateCrsTransformationResultStatistic(new List <CrsTransformationResult>()) ); crsIdentifierWGS84 = CrsIdentifierFactory.CreateFromEpsgNumber(EpsgNumber.WORLD__WGS_84__4326); mock1.Setup(leaf => leaf.Transform(inputCoordinateSweref99, crsIdentifierWGS84)).Returns(leafResult1); mock2.Setup(leaf => leaf.Transform(inputCoordinateSweref99, crsIdentifierWGS84)).Returns(leafResult2); mock3.Setup(leaf => leaf.Transform(inputCoordinateSweref99, crsIdentifierWGS84)).Returns(leafResult3); mock4.Setup(leaf => leaf.Transform(inputCoordinateSweref99, crsIdentifierWGS84)).Returns(leafResult4); mock5.Setup(leaf => leaf.Transform(inputCoordinateSweref99, crsIdentifierWGS84)).Returns(leafResult5); //mock1.Setup(leaf => leaf.LongNameOfImplementation).Returns("1"); //mock2.Setup(leaf => leaf.LongNameOfImplementation).Returns("2"); //mock3.Setup(leaf => leaf.LongNameOfImplementation).Returns("3"); //mock4.Setup(leaf => leaf.LongNameOfImplementation).Returns("4"); //mock5.Setup(leaf => leaf.LongNameOfImplementation).Returns("5"); mock1.Setup(leaf => leaf.AdapteeType).Returns(CrsTransformationAdapteeType.LEAF_DOT_SPATIAL_2_0_0_RC1); mock2.Setup(leaf => leaf.AdapteeType).Returns(CrsTransformationAdapteeType.LEAF_PROJ_NET_2_0_0); mock3.Setup(leaf => leaf.AdapteeType).Returns(CrsTransformationAdapteeType.LEAF_MIGHTY_LITTLE_GEODESY_1_0_2); // The type must be different but there are only three concrete types as above to use // but then instead can use the ones below (and the purpose of this enum is to use it as key in a dictionary/hashtable) mock4.Setup(leaf => leaf.AdapteeType).Returns(CrsTransformationAdapteeType.UNSPECIFIED_LEAF); mock5.Setup(leaf => leaf.AdapteeType).Returns(CrsTransformationAdapteeType.UNSPECIFIED); allLeafAdapters = new List <ICrsTransformationAdapter> { leafAdapterImplementation_1, leafAdapterImplementation_2, leafAdapterImplementation_3, leafAdapterImplementation_4, leafAdapterImplementation_5 }; }
public void Coordinates_ShouldBeEqual_WhenUsingCrsIdentifierAndDifferentFactoryMethodsWithParametersInDifferentOrder() { CrsIdentifier crsIdentifier = CrsIdentifierFactory.CreateFromEpsgNumber(3006); CrsCoordinate coordinate1 = CrsCoordinateFactory.CreateFromXEastingLongitudeAndYNorthingLatitude(xLongitude, yLatitude, crsIdentifier); CrsCoordinate coordinate2 = CrsCoordinateFactory.CreateFromYNorthingLatitudeAndXEastingLongitude(yLatitude, xLongitude, crsIdentifier); AssertEqualCoordinates(coordinate1, coordinate2); }
public void Coordinates_ShouldBeEqual_WhenCreatedWithTheSameValuesButDifferentFactoryMethods() { CrsIdentifier crsIdentifier = CrsIdentifierFactory.CreateFromEpsgNumber(epsgNumberSweref99); string epsgCode = EpsgPrefix + epsgNumberSweref99; CrsCoordinate expectedCoordinate = CrsCoordinateFactory.CreateFromXEastingLongitudeAndYNorthingLatitude(xLongitude, yLatitude, epsgNumberSweref99); // all should be equal to each other, so one of them was chosen above // as the "expected" and then the others are compared with it in the below assertions // ----------------------------------------------------------------------- // the last parameter (epsgNumber) is an integer in the first below assertions: AssertEqualCoordinates(expectedCoordinate, CrsCoordinateFactory.LonLat(xLongitude, yLatitude, epsgNumberSweref99) ); AssertEqualCoordinates(expectedCoordinate, CrsCoordinateFactory.XY(xLongitude, yLatitude, epsgNumberSweref99) ); AssertEqualCoordinates(expectedCoordinate, CrsCoordinateFactory.EastingNorthing(xLongitude, yLatitude, epsgNumberSweref99) ); // the below four assertions are using x/y values in the opposite order // compared to the above three assertions AssertEqualCoordinates(expectedCoordinate, CrsCoordinateFactory.CreateFromYNorthingLatitudeAndXEastingLongitude(yLatitude, xLongitude, epsgNumberSweref99) ); AssertEqualCoordinates(expectedCoordinate, CrsCoordinateFactory.LatLon(yLatitude, xLongitude, epsgNumberSweref99) ); AssertEqualCoordinates(expectedCoordinate, CrsCoordinateFactory.YX(yLatitude, xLongitude, epsgNumberSweref99) ); AssertEqualCoordinates(expectedCoordinate, CrsCoordinateFactory.NorthingEasting(yLatitude, xLongitude, epsgNumberSweref99) ); // ----------------------------------------------------------------------- // epsg code (string parameter) is the last parameter below AssertEqualCoordinates(expectedCoordinate, CrsCoordinateFactory.CreateFromXEastingLongitudeAndYNorthingLatitude(xLongitude, yLatitude, epsgCode) ); AssertEqualCoordinates(expectedCoordinate, CrsCoordinateFactory.LonLat(xLongitude, yLatitude, epsgCode) ); AssertEqualCoordinates(expectedCoordinate, CrsCoordinateFactory.XY(xLongitude, yLatitude, epsgCode) ); AssertEqualCoordinates(expectedCoordinate, CrsCoordinateFactory.EastingNorthing(xLongitude, yLatitude, epsgCode) ); // the below four assertions are using x/y values in the opposite order // compared to the above four assertions AssertEqualCoordinates(expectedCoordinate, CrsCoordinateFactory.CreateFromYNorthingLatitudeAndXEastingLongitude(yLatitude, xLongitude, epsgCode) ); AssertEqualCoordinates(expectedCoordinate, CrsCoordinateFactory.LatLon(yLatitude, xLongitude, epsgCode) ); AssertEqualCoordinates(expectedCoordinate, CrsCoordinateFactory.YX(yLatitude, xLongitude, epsgCode) ); AssertEqualCoordinates(expectedCoordinate, CrsCoordinateFactory.NorthingEasting(yLatitude, xLongitude, epsgCode) ); // ----------------------------------------------------------------------- // crsIdentifier obkect is the last parameter below AssertEqualCoordinates(expectedCoordinate, CrsCoordinateFactory.CreateFromXEastingLongitudeAndYNorthingLatitude(xLongitude, yLatitude, crsIdentifier) ); AssertEqualCoordinates(expectedCoordinate, CrsCoordinateFactory.LonLat(xLongitude, yLatitude, crsIdentifier) ); AssertEqualCoordinates(expectedCoordinate, CrsCoordinateFactory.XY(xLongitude, yLatitude, crsIdentifier) ); AssertEqualCoordinates(expectedCoordinate, CrsCoordinateFactory.EastingNorthing(xLongitude, yLatitude, crsIdentifier) ); // the below four assertions are using x/y values in the opposite order // compared to the above four assertions AssertEqualCoordinates(expectedCoordinate, CrsCoordinateFactory.CreateFromYNorthingLatitudeAndXEastingLongitude(yLatitude, xLongitude, crsIdentifier) ); AssertEqualCoordinates(expectedCoordinate, CrsCoordinateFactory.LatLon(yLatitude, xLongitude, crsIdentifier) ); AssertEqualCoordinates(expectedCoordinate, CrsCoordinateFactory.YX(yLatitude, xLongitude, crsIdentifier) ); AssertEqualCoordinates(expectedCoordinate, CrsCoordinateFactory.NorthingEasting(yLatitude, xLongitude, crsIdentifier) ); }
public void CrsIdentifier_ShouldNotBeEqual_WhenDifferentEpsgNumber() { Assert.AreNotEqual( CrsIdentifierFactory.CreateFromEpsgNumber(123), CrsIdentifierFactory.CreateFromEpsgNumber(124) ); }
public void FindPotentialBuggyImplementationsHelper( int minEpsgCrsCode, int maxEpsgCrsCode, double?optionalDelta = null ) { int numberIfEpsgCodesToConsiderInIteration = maxEpsgCrsCode - minEpsgCrsCode; bool manyWillBeIterated = numberIfEpsgCodesToConsiderInIteration > 100; double deltaDiffToUse = manyWillBeIterated ? deltaDiff : double.MinValue; if (optionalDelta.HasValue) { deltaDiffToUse = optionalDelta.Value; } var crsTransformationAdapterCompositeFactory = CrsTransformationAdapterCompositeFactory.Create(); CrsTransformationAdapterComposite crsTransformationComposite = crsTransformationAdapterCompositeFactory.CreateCrsTransformationMedian(); verifyThreeImplementations(crsTransformationComposite); // to make sure that the above factory really creates an object which will use three implementations IList <CrsTransformationResult> transformResultsWithLargeDifferences = new List <CrsTransformationResult>(); CrsIdentifier wgs84 = CrsIdentifierFactory.CreateFromEpsgNumber(EpsgNumber.WORLD__WGS_84__4326); var stopWatch = new Stopwatch(); stopWatch.Start(); IList <EpsgCrsAndAreaCodeWithCoordinates> coordinatesFromGeneratedCsvFile = CoordinateTestDataGeneratedFromEpsgDatabaseTest.GetCoordinatesFromGeneratedCsvFile(); int seconds = (int)stopWatch.Elapsed.TotalSeconds; WriteLine("Time for reading the content of the input file: " + seconds); stopWatch.Restart(); int totalNumberOfSeconds; WriteLine("number of rows to iterate: " + coordinatesFromGeneratedCsvFile.Count); for (int i = 0; i < coordinatesFromGeneratedCsvFile.Count; i++) { if (manyWillBeIterated && (i % 100 == 0)) { //WriteLine("number of rows iterated so far: " + i); totalNumberOfSeconds = (int)stopWatch.Elapsed.TotalSeconds; //WriteLine("Number of seconds so far: " + totalNumberOfSeconds); // if (i > 50) break; } EpsgCrsAndAreaCodeWithCoordinates epsgCrsAndAreaCodeWithCoordinates = coordinatesFromGeneratedCsvFile[i]; if ( epsgCrsAndAreaCodeWithCoordinates.epsgCrsCode < minEpsgCrsCode || epsgCrsAndAreaCodeWithCoordinates.epsgCrsCode > maxEpsgCrsCode ) { continue; } if (!manyWillBeIterated) { //Console.WriteLine("iterated epsgCrsCode: " + epsgCrsAndAreaCodeWithCoordinates.epsgCrsCode); } CrsCoordinate coordinateInputWgs84 = CrsCoordinateFactory.CreateFromYNorthingLatitudeAndXEastingLongitude(epsgCrsAndAreaCodeWithCoordinates.centroidY, epsgCrsAndAreaCodeWithCoordinates.centroidX, wgs84); CrsTransformationResult resultOutputFromWgs4 = crsTransformationComposite.Transform(coordinateInputWgs84, epsgCrsAndAreaCodeWithCoordinates.epsgCrsCode); if (!resultOutputFromWgs4.IsSuccess) { continue; } CrsTransformationResult resultWhenTransformedBackToWgs84 = crsTransformationComposite.Transform(resultOutputFromWgs4.OutputCoordinate, wgs84); if (!resultWhenTransformedBackToWgs84.IsSuccess) { continue; } CrsTransformationResultStatistic crsTransformationResultStatistic = resultWhenTransformedBackToWgs84.CrsTransformationResultStatistic; Assert.IsNotNull(crsTransformationResultStatistic); Assert.IsTrue(crsTransformationResultStatistic.IsStatisticsAvailable); if ( crsTransformationResultStatistic.MaxDifferenceForXEastingLongitude > deltaDiffToUse || crsTransformationResultStatistic.MaxDifferenceForYNorthingLatitude > deltaDiffToUse ) { transformResultsWithLargeDifferences.Add(resultWhenTransformedBackToWgs84); } else { if (!manyWillBeIterated) { //Console.WriteLine("NOT 'big' difference for EPSG " + epsgCrsAndAreaCodeWithCoordinates.epsgCrsCode); int count = crsTransformationComposite.TransformationAdapterChildren.Count; //Console.WriteLine("Number of implementations not having big difference: " + count); } } } WriteLine("Number of iterated rows/coordinates: " + coordinatesFromGeneratedCsvFile.Count); WriteLine("Number of results with 'large' differences: " + transformResultsWithLargeDifferences.Count); for (int i = 0; i < transformResultsWithLargeDifferences.Count; i++) { CrsTransformationResult transformResult = transformResultsWithLargeDifferences[i]; WriteLine("----------------------------------------"); WriteLine("epsg " + transformResult.InputCoordinate.CrsIdentifier.CrsCode); WriteLine("MaxDiffYLatitude : " + transformResult.CrsTransformationResultStatistic.MaxDifferenceForYNorthingLatitude); WriteLine("MaxDiffYLongitude: " + transformResult.CrsTransformationResultStatistic.MaxDifferenceForXEastingLongitude); IList <CrsTransformationResult> subResults = transformResult.TransformationResultChildren; for (int j = 0; j < subResults.Count; j++) { CrsTransformationResult subTransformResult = subResults[j]; if (subTransformResult.IsSuccess) { WriteLine(subTransformResult.OutputCoordinate + " , " + subTransformResult.CrsTransformationAdapterResultSource.AdapteeType); } } } }