public void method() { Console.WriteLine("SmallCSharpeExample starts"); int epsgWgs84 = 4326; int epsgSweRef = 3006; // alternative to the above two hardcodings: use the library "Programmerare.CrsTransformations.Constants" // and constants EpsgNumber.WORLD__WGS_84__4326 and EpsgNumber.SWEDEN__SWEREF99_TM__3006 // from the class Programmerare.CrsConstants.ConstantsByAreaNameNumber.v9_7.EpsgNumber CrsCoordinate centralStockholmWgs84 = CrsCoordinateFactory.LatLon(59.330231, 18.059196, epsgWgs84); ICrsTransformationAdapter crsTransformationAdapter = CrsTransformationAdapterCompositeFactory.Create().CreateCrsTransformationMedian(); // If the NuGet configuration includes all (currently three) adapter implementations, then the // above created 'Composite' implementation will below use all three 'leaf' implementations // and return a coordinate with a median longitude and a median latitude CrsTransformationResult centralStockholmResultSweRef = crsTransformationAdapter.Transform(centralStockholmWgs84, epsgSweRef); if (centralStockholmResultSweRef.IsSuccess) { Console.WriteLine(centralStockholmResultSweRef.OutputCoordinate); // Console output from the above code row: // CrsCoordinate(xEastingLongitude=674032.357177155, yNorthingLatitude=6580821.99121561, crsIdentifier=CrsIdentifier(crsCode='EPSG:3006', isEpsgCode=True, epsgNumber=3006)) } Console.WriteLine("SmallCSharpeExample ends"); Console.ReadLine(); }
private void AssertTransformationResultFailure( CrsTransformationResult result, CrsCoordinate inputCoordinate, //CrsCoordinate expectedOutputCoordinate, ICrsTransformationAdapter crsTransformationAdapterSource ) { Assert.IsNotNull(result); Assert.IsFalse(result.IsSuccess); Assert.IsNotNull(result.Exception); InvalidOperationException e = Assert.Throws <InvalidOperationException>( () => { var coord = result.OutputCoordinate; }, "Should not try to get output coordinate unless the result was a success" ); Assert.AreEqual(inputCoordinate, result.InputCoordinate); IList <CrsTransformationResult> subresults = result.TransformationResultChildren; Assert.IsNotNull(subresults); Assert.AreEqual(0, subresults.Count); // Leaf should have no children Assert.AreEqual(this.crsTransformationAdapter, result.CrsTransformationAdapterResultSource); AssertStatisticsForLeaf(result); }
public void TransformToCoordinate_ShouldReturnFirstResult_WhenUsingFirstSuccessCompositeAdapter() { CrsTransformationAdapterComposite firstSuccessCompositeAdapter = crsTransformationAdapterCompositeFactory.CreateCrsTransformationFirstSuccess(allLeafAdapters); CrsCoordinate resultCoordinate = firstSuccessCompositeAdapter.TransformToCoordinate(inputCoordinateSweref99, EpsgNumber.WORLD__WGS_84__4326); Assert.IsNotNull(resultCoordinate); // The assumption below (according to the setup code in the "before" method in this JUnit class) // is that the first adapter in the above list allLeafAdapters will return the result outputCoordinateWgs84ForImplementation_1 Assert.AreEqual( outputCoordinateWgs84ForImplementation_1.YNorthingLatitude, resultCoordinate.YNorthingLatitude, SMALL_DELTA_VALUE_FOR_COMPARISONS ); Assert.AreEqual( outputCoordinateWgs84ForImplementation_1.XEastingLongitude, resultCoordinate.XEastingLongitude, SMALL_DELTA_VALUE_FOR_COMPARISONS ); AssertCompositeResultHasLeafSubResults( firstSuccessCompositeAdapter, 1 // expectedNumberOfLeafResults ); }
public void SetUpBase() { crsTransformationAdapterCompositeFactory = CrsTransformationAdapterCompositeFactory.Create(); adapterDotSpatial = new CrsTransformationAdapterDotSpatial(); adapterProjNet = new CrsTransformationAdapterProjNet(); adapterMightyLittleGeodesy = new CrsTransformationAdapterMightyLittleGeodesy(); allAdapters = new List <ICrsTransformationAdapter> { // Regarding the order of the items in the list below: // DotSpatial should be the first since it is assumed in the test by the subclass CompositeStrategyFirstSuccessTest adapterDotSpatial, adapterProjNet, adapterMightyLittleGeodesy }; wgs84coordinate = CrsCoordinateFactory.CreateFromYNorthingLatitudeAndXEastingLongitude(wgs84Lat, wgs84Lon, EpsgNumber.WORLD__WGS_84__4326); resultCoordinateDotSpatial = adapterDotSpatial.TransformToCoordinate(wgs84coordinate, EpsgNumber.SWEDEN__SWEREF99_TM__3006); resultCoordinateProjNet = adapterProjNet.TransformToCoordinate(wgs84coordinate, EpsgNumber.SWEDEN__SWEREF99_TM__3006); resultCoordinateMightyLittleGeodesy = adapterMightyLittleGeodesy.TransformToCoordinate(wgs84coordinate, EpsgNumber.SWEDEN__SWEREF99_TM__3006); allCoordinateResultsForTheDifferentImplementations = new List <CrsCoordinate> { resultCoordinateDotSpatial, resultCoordinateMightyLittleGeodesy, resultCoordinateProjNet }; }
public void Transform_ShouldReturnMedianResult_WhenUsingMedianCompositeAdapter() { CrsCoordinate expectedCoordinateWithMedianLatitudeAndLongitude = CalculateMedianCoordinate(base.allCoordinateResultsForTheDifferentImplementations); ICrsTransformationAdapter medianCompositeAdapter = crsTransformationAdapterCompositeFactory.CreateCrsTransformationMedian( allAdapters ); CrsTransformationResult medianResult = medianCompositeAdapter.Transform(wgs84coordinate, EpsgNumber.SWEDEN__SWEREF99_TM__3006); Assert.IsNotNull(medianResult); Assert.IsTrue(medianResult.IsSuccess); Assert.AreEqual(base.allCoordinateResultsForTheDifferentImplementations.Count, medianResult.TransformationResultChildren.Count); CrsCoordinate coordinateReturnedByMedianAdapter = medianResult.OutputCoordinate; // The same transformation as above has been done in the base class for the individual adapters Assert.AreEqual( expectedCoordinateWithMedianLatitudeAndLongitude.XEastingLongitude, coordinateReturnedByMedianAdapter.XEastingLongitude, delta ); Assert.AreEqual( expectedCoordinateWithMedianLatitudeAndLongitude.YNorthingLatitude, coordinateReturnedByMedianAdapter.YNorthingLatitude, delta ); }
// ------------------------------------------------------------------------------------- private TestResult RunAllTransformationsOfTheCoordinatesInTheGeneratedCsvFile( ICrsTransformationAdapter crsTransformationAdapter, IList <EpsgCrsAndAreaCodeWithCoordinates> coordinatesFromGeneratedCsvFile ) { var stopWatch = new Stopwatch(); stopWatch.Start(); IList <TestResultItem> testResultItems = new List <TestResultItem>(); int counter = 0; foreach (EpsgCrsAndAreaCodeWithCoordinates item in coordinatesFromGeneratedCsvFile) { CrsCoordinate inputCoordinateWGS84 = CrsCoordinateFactory.CreateFromXEastingLongitudeAndYNorthingLatitude(item.centroidX, item.centroidY, EpsgNumber.WORLD__WGS_84__4326); CrsTransformationResult resultOfTransformationFromWGS84 = crsTransformationAdapter.Transform(inputCoordinateWGS84, item.epsgCrsCode); CrsTransformationResult resultOfTransformationBackToWGS84 = null; if (resultOfTransformationFromWGS84.IsSuccess) { resultOfTransformationBackToWGS84 = crsTransformationAdapter.Transform(resultOfTransformationFromWGS84.OutputCoordinate, EpsgNumber.WORLD__WGS_84__4326); } testResultItems.Add(new TestResultItem(item, inputCoordinateWGS84, resultOfTransformationFromWGS84, resultOfTransformationBackToWGS84)); if (counter++ % 500 == 0) // just to show some progress { Console.WriteLine(this.GetType().Name + " , counter: " + counter + " (of the total " + coordinatesFromGeneratedCsvFile.Count + ") for adapter " + crsTransformationAdapter.GetType().Name); // to show some progress } // if(counter > 300) break; } long totalNumberOfSecondsForAllTransformations = (long)stopWatch.Elapsed.TotalSeconds; Console.WriteLine("Total number of seconds for method runAllTransformationsOfTheCoordinatesInTheGeneratedCsvFile: " + totalNumberOfSecondsForAllTransformations); return(new TestResult(crsTransformationAdapter, totalNumberOfSecondsForAllTransformations, testResultItems)); }
public void Transform_ShouldReturnAverageResult_WhenUsingAverageCompositeAdapter() { CrsCoordinate coordinateWithAverageLatitudeAndLongitude = CalculateAverageCoordinate( base.allCoordinateResultsForTheDifferentImplementations ); ICrsTransformationAdapter averageCompositeAdapter = crsTransformationAdapterCompositeFactory.CreateCrsTransformationAverage( allAdapters ); CrsTransformationResult averageResult = averageCompositeAdapter.Transform(wgs84coordinate, EpsgNumber.SWEDEN__SWEREF99_TM__3006); Assert.IsNotNull(averageResult); Assert.IsTrue(averageResult.IsSuccess); Assert.AreEqual(base.allCoordinateResultsForTheDifferentImplementations.Count, averageResult.TransformationResultChildren.Count); CrsCoordinate coordinateReturnedByCompositeAdapter = averageResult.OutputCoordinate; Assert.AreEqual( coordinateWithAverageLatitudeAndLongitude.XEastingLongitude, coordinateReturnedByCompositeAdapter.XEastingLongitude, delta ); Assert.AreEqual( coordinateWithAverageLatitudeAndLongitude.YNorthingLatitude, coordinateReturnedByCompositeAdapter.YNorthingLatitude, delta ); // assertEquals(coordinateWithAverageLatitudeAndLongitude, coordinateReturnedByCompositeAdapter); // Expected :Coordinate(xEastingLongitude=674032.3572074446, yNorthingLatitude=6580821.991903967, crsIdentifier=CrsIdentifier(crsCode=EPSG:3006, isEpsgCode=true, epsgNumber=3006)) // Actual :Coordinate(xEastingLongitude=674032.3572074447, yNorthingLatitude=6580821.991903967, crsIdentifier=CrsIdentifier(crsCode=EPSG:3006, isEpsgCode=true, epsgNumber=3006)) }
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 ); }
private void TransformToCoordinate_ShouldThrowException_WhenCoordinateIsNotValid( CrsCoordinate unvalidInputCoordinate ) { foreach (ICrsTransformationAdapter crsTransformationAdapter in crsTransformationAdapterImplementations) { //Exception exception = Assert.Throws<Exception>( () => { // crsTransformationAdapter.TransformToCoordinate(unvalidInputCoordinate, base.epsgNumberForSweref99TM); //} //, //"Exception was not thrown but SHOULD have been thrown for implementation " + crsTransformationAdapter.AdapteeType + " and coordinate " + unvalidInputCoordinate //); // The above 'Assert.Throws' test for a specific exception type // while the code below (with 'Assert.That' and then Assert.That' works for any exception Assert.That( () => crsTransformationAdapter.TransformToCoordinate( unvalidInputCoordinate, base.epsgNumberForSweref99TM ), Throws.Exception // testing that the thrown exception type is one of the following: .TypeOf<ArgumentOutOfRangeException>().Or .TypeOf<NotSupportedException>().Or .TypeOf<ArgumentException>().Or .TypeOf<Exception>() ); } }
private void AssertEqualCoordinate( CrsCoordinate c1, CrsCoordinate c2 ) { Assert.AreEqual(c1.YNorthingLatitude, c2.YNorthingLatitude, SMALL_DELTA_VALUE_FOR_COMPARISONS); Assert.AreEqual(c1.XEastingLongitude, c2.XEastingLongitude, SMALL_DELTA_VALUE_FOR_COMPARISONS); }
public void SetUpCrsTransformationAdapterTest() { unvalidCrsCode = "This string is NOT a correct crs/EPSG code"; validInputCoordinate = CrsCoordinateFactory.LatLon( 60.0, // ok wgs84 latitude 20.0, // ok wgs84 longitude epsgNumberForWgs84 // OK ); }
public void TransformToCoordinate_ShouldThrowException_WhenCrsCodeIsNotValid() { CrsCoordinate unvalidInputCoordinate = CrsCoordinateFactory.LatLon( 60.0, // ok wgs84 latitude 20.0, // ok wgs84 longitude unvalidCrsCode ); TransformToCoordinate_ShouldThrowException_WhenCoordinateIsNotValid(unvalidInputCoordinate); }
public void Transform_ShouldReturnSuccessFalseButNotThrowException_WhenLatitudeIsNotValid() { CrsCoordinate unvalidInputCoordinate = CrsCoordinateFactory.LatLon( -9999999999.0, // NOT ok wgs84 latitude 20.0, // ok wgs84 longitude epsgNumberForWgs84 ); Transform_ShouldReturnSuccessFalseButNotThrowException_WhenCoordinateIsNotValid(unvalidInputCoordinate); }
private void AssertEqualCoordinates(CrsCoordinate coordinate1, CrsCoordinate coordinate2) { Assert.AreEqual(coordinate1.XEastingLongitude, coordinate2.XEastingLongitude, deltaTolerance); Assert.AreEqual(coordinate1.YNorthingLatitude, coordinate2.YNorthingLatitude, deltaTolerance); Assert.AreEqual(coordinate1.CrsIdentifier, coordinate2.CrsIdentifier); // data class Assert.AreEqual(coordinate1.CrsIdentifier.EpsgNumber, coordinate2.CrsIdentifier.EpsgNumber); Assert.AreEqual(coordinate1.GetHashCode(), coordinate2.GetHashCode()); Assert.AreEqual(coordinate1, coordinate2); }
public void Transform_FromRT90_ToWgs84() { resultWgs84 = crsTransformationAdapter.TransformToCoordinate(coordinateRT90, epsgWGS84); AssertCoordinateResult( resultWgs84, coordinateWgs84, maxLatLongDifferenceForSuccessfulTest ); }
private void AssertCoordinateResult( CrsCoordinate actual, CrsCoordinate expected, double maxDeltaDifference ) { Assert.IsNotNull(coordinateSweref99); Assert.AreEqual(expected.Y, actual.Y, maxDeltaDifference); Assert.AreEqual(expected.X, actual.X, maxDeltaDifference); }
public void CoordinateWithNineDecimals_ShouldBeEqualToCoordinateConstructedWithTheSameValues_WhenTheOnlyDifferenceIsSomeAdditionalZeroes() { CrsCoordinate c1 = CrsCoordinateFactory.CreateFromLatitudeLongitude(59.123456789, 18.123456789000); CrsCoordinate c2 = CrsCoordinateFactory.CreateFromLatitudeLongitude(59.123456789000, 18.123456789); Assert.AreEqual( c1, c2 ); Assert.AreEqual( c1.GetHashCode(), c2.GetHashCode() ); }
/** * Iterates the test results and counts the number of successes and failures * including considering a maximum delta difference between the coordinates * when having transformed back and forth. * While iterating, lines of strings are also created, with the resulting coordinates. * Depennding on a bool parameter, those string lines are either written to * a file, or compared with a previous created file. * * @param testResult * @param deltaLimitForSuccess * @param createNewRegressionFileInfo if false, then instead compare with previous regression file */ private void HandleTestResults( TestResult testResult, double deltaLimitForSuccess, bool shouldCreateNewRegressionFile, string fileNameSuffixExcludingExtension ) { Console.WriteLine("-------------------------------"); Console.WriteLine("testResults for " + testResult.Adapter.GetType().Name); Console.WriteLine("seconds: " + testResult.TotalNumberOfSecondsForAllTransformations); IList <TestResultItem> testResultItems = testResult.TestResultItems; int countOfFailures = 0; int countOfSuccess = 0; bool isSuccess; IList <string> linesWithCurrentResults = new List <string>(); foreach (TestResultItem testResultItem in testResultItems) { string resultString = testResultItem.GetResultStringForRegressionFile(); linesWithCurrentResults.Add(resultString); isSuccess = testResultItem.IsSuccessfulTransformationFromWGS84(); if (isSuccess) { isSuccess = testResultItem.IsSuccessfulTransformationBackToWGS84(); if (isSuccess) { CrsCoordinate inputCoordinateWGS84 = testResultItem.GetInputCoordinateWGS84(); CrsCoordinate wgs84Again = testResultItem.GetCoordinateOutputTransformationBackToWGS84(); double deltaLong = Math.Abs(inputCoordinateWGS84.XEastingLongitude - wgs84Again.XEastingLongitude); double deltaLat = Math.Abs(inputCoordinateWGS84.YNorthingLatitude - wgs84Again.YNorthingLatitude); isSuccess = deltaLong < deltaLimitForSuccess && deltaLat < deltaLimitForSuccess; } } if (isSuccess) { countOfSuccess++; } else { countOfFailures++; } } Console.WriteLine("countOfSuccess: " + countOfSuccess); Console.WriteLine("countOfFailures: " + countOfFailures); Console.WriteLine("-------------------------------"); FileInfo file = GetFileForRegressionResults(testResult.Adapter, fileNameSuffixExcludingExtension); if (shouldCreateNewRegressionFile) { CreateNewRegressionFile(file, linesWithCurrentResults); } }
private void VerifyThatTheCreatedAdapterIsRealObject( ICrsTransformationAdapter crsTransformationAdapter ) { Assert.IsNotNull(crsTransformationAdapter); // below trying to use the created object to really make sure it works CrsCoordinate coordinateWgs84 = CrsCoordinateFactory.CreateFromYNorthingLatitudeAndXEastingLongitude(59.330231, 18.059196, EpsgNumber.WORLD__WGS_84__4326); CrsTransformationResult resultSweref99 = crsTransformationAdapter.Transform(coordinateWgs84, EpsgNumber.SWEDEN__SWEREF99_TM__3006); Assert.IsNotNull(resultSweref99); Assert.IsTrue(resultSweref99.IsSuccess); }
public void TransformToCoordinate_WhenInputCoordinateIsNull() { CrsIdentifier crsWgs84 = coordinateWgs84.CrsIdentifier; Assert.IsNotNull(crsWgs84); CrsCoordinate nullCordinate = null; // TransformToCoordinate SHOULD (unlike the transform method) // throw exception ArgumentNullException exception = Assert.Throws <ArgumentNullException>(() => { crsTransformationAdapter.TransformToCoordinate(nullCordinate, crsWgs84); }); }
public void TransformResultConstruction_ShouldThrowException_WhenParametersSuccessTrueAndOutputCoordinateNull() { CrsCoordinate outputCoordinateNull = null; ArgumentException exception = Assert.Throws<ArgumentException>( () => { CreateCrsTransformationResult( outputCoordinateNull, // outputCoordinate = null, then success should be false ! null, true ); } , "unvalid TransformResult object construction should throw exception when success true is combined with null as output coordinate" ); }
public void Coordinate_ShouldBeCreatedWithWGS84asDefaultCrs_WhenNotSpecifyingCrs() { CrsCoordinate coordinate = CrsCoordinateFactory.CreateFromLongitudeLatitude(xLongitude, yLatitude); Assert.AreEqual( epsgNumberWgs84, // EpsgNumber.WORLD__WGS_84__4326, coordinate.CrsIdentifier.EpsgNumber ); // The tets below is the same as above except that the factory method use the reversed order for lat/lon parameters coordinate = CrsCoordinateFactory.CreateFromLatitudeLongitude(yLatitude, xLongitude); Assert.AreEqual( epsgNumberWgs84, // EpsgNumber.WORLD__WGS_84__4326, coordinate.CrsIdentifier.EpsgNumber ); }
private void TransformToCoordinate_ShouldReturnTheOriginalCoordinate_WhenTransformingBackAgainFromTheResult( ICrsTransformationAdapter crsTransformationAdapter, CrsCoordinate inputCoordinateOriginalCRS, int epsgNumberForTransformTargetCRS ) { double delta = GetDeltaValueForComparisons(inputCoordinateOriginalCRS.CrsIdentifier); CrsCoordinate outputCoordinateForTransformTargetCRS = crsTransformationAdapter.TransformToCoordinate(inputCoordinateOriginalCRS, epsgNumberForTransformTargetCRS); CrsCoordinate outputCoordinateOriginalCRS = crsTransformationAdapter.TransformToCoordinate(outputCoordinateForTransformTargetCRS, inputCoordinateOriginalCRS.CrsIdentifier.EpsgNumber); Assert.AreEqual(inputCoordinateOriginalCRS.XEastingLongitude, outputCoordinateOriginalCRS.XEastingLongitude, delta); Assert.AreEqual(inputCoordinateOriginalCRS.YNorthingLatitude, outputCoordinateOriginalCRS.YNorthingLatitude, delta); Assert.AreEqual(inputCoordinateOriginalCRS.CrsIdentifier.EpsgNumber, outputCoordinateOriginalCRS.CrsIdentifier.EpsgNumber); }
public void TransformResult_WhenInputCoordinateIsNull() { CrsIdentifier crsWgs84 = coordinateWgs84.CrsIdentifier; Assert.IsNotNull(crsWgs84); CrsCoordinate nullCordinate = null; CrsTransformationResult result = crsTransformationAdapter.Transform(nullCordinate, crsWgs84); AssertTransformationResultFailure( result, nullCordinate, crsTransformationAdapter ); }
public void FindTheNumberOfEpsgCodesPotentiallySupported() { IList <EpsgCrsAndAreaCodeWithCoordinates> coordinatesFromGeneratedCsvFile = CoordinateTestDataGeneratedFromEpsgDatabaseTest.GetCoordinatesFromGeneratedCsvFile(); int totalNumberOfSeconds; foreach (ICrsTransformationAdapter leafAdapter in base.crsTransformationAdapterLeafImplementations) { var stopWatch = new Stopwatch(); stopWatch.Start(); int numberOfFailures = 0; int numberOfSuccesses = 0; for (int i = 0; i < coordinatesFromGeneratedCsvFile.Count; i++) { EpsgCrsAndAreaCodeWithCoordinates epsgCrsAndAreaCodeWithCoordinates = coordinatesFromGeneratedCsvFile[i]; CrsCoordinate coordinateInputWgs84 = CrsCoordinateFactory.LatLon( epsgCrsAndAreaCodeWithCoordinates.centroidY, epsgCrsAndAreaCodeWithCoordinates.centroidX ); CrsTransformationResult resultOutputFromWgs4 = leafAdapter.Transform( coordinateInputWgs84, epsgCrsAndAreaCodeWithCoordinates.epsgCrsCode ); if (resultOutputFromWgs4.IsSuccess) { numberOfSuccesses++; //WriteLine("Success " + DateTime.Now + " " + leafAdapter.AdapteeType + " " + resultOutputFromWgs4.OutputCoordinate); } else { //WriteLine("Failure " + DateTime.Now + " " + leafAdapter.AdapteeType); numberOfFailures++; } if (i % 500 == 0) { //WriteLine("number of rows iterated so far: " + i + " (for leafAdapter " + leafAdapter.AdapteeType + " )"); totalNumberOfSeconds = (int)stopWatch.Elapsed.TotalSeconds; //WriteLine("Number of seconds so far (for the above adapter) : " + totalNumberOfSeconds); //if(i > 500) break; } } totalNumberOfSeconds = (int)stopWatch.Elapsed.TotalSeconds; WriteLine("---------------------"); WriteLine("Result for adapter: " + leafAdapter.AdapteeType); WriteLine("numberOfSuccesses: " + numberOfSuccesses); WriteLine("numberOfFailures: " + numberOfFailures); WriteLine("Number of seconds: " + totalNumberOfSeconds); WriteLine("---------------------"); } }
private void AssertDiffsAreGreaterThanSmallDelta( CrsCoordinate resultCoordinateIndividualImplementation, CrsCoordinate coordinateWithExpectedWeightedValues ) { double diffLatIndividualImplementation = Math.Abs( coordinateWithExpectedWeightedValues.YNorthingLatitude - resultCoordinateIndividualImplementation.YNorthingLatitude ); double diffLonIndividualImplementation = Math.Abs( coordinateWithExpectedWeightedValues.XEastingLongitude - resultCoordinateIndividualImplementation.XEastingLongitude ); Assert.That(diffLatIndividualImplementation, Is.GreaterThan(SMALL_DELTA_VALUE)); Assert.That(diffLonIndividualImplementation, Is.GreaterThan(SMALL_DELTA_VALUE)); }
private void TransformToCoordinate_ShouldReturnCorrectWgs84coordinate_WhenTransformingFromRT90( ICrsTransformationAdapter crsTransformationAdapter ) { double rt90_Y = 6580994; double rt90_X = 1628294; double wgs84Lat_expected = 59.330231; double wgs84Lon_expected = 18.059196; CrsCoordinate inputCoordinate = CrsCoordinateFactory.CreateFromXEastingLongitudeAndYNorthingLatitude(rt90_X, rt90_Y, base.epsgNumberForRT90); CrsCoordinate outputCoordinate = crsTransformationAdapter.TransformToCoordinate(inputCoordinate, base.epsgNumberForWgs84); Assert.AreEqual(wgs84Lat_expected, outputCoordinate.YNorthingLatitude, 0.1); Assert.AreEqual(wgs84Lon_expected, outputCoordinate.XEastingLongitude, 0.1); }
protected void SetUpbase( ICrsTransformationAdapter crsTransformationAdapter, CrsTransformationAdapteeType expectedCrsTransformationAdapteeType, double maxMeterDifferenceForSuccessfulTest, double maxLatLongDifferenceForSuccessfulTest ) { this.crsTransformationAdapter = crsTransformationAdapter; this.expectedCrsTransformationAdapteeType = expectedCrsTransformationAdapteeType; this.maxMeterDifferenceForSuccessfulTest = maxMeterDifferenceForSuccessfulTest; this.maxLatLongDifferenceForSuccessfulTest = maxLatLongDifferenceForSuccessfulTest; coordinateWgs84 = CrsCoordinateFactory.LatLon(wgs84Lat, wgs84Lon, epsgWGS84); coordinateSweref99 = CrsCoordinateFactory.LatLon(sweref99Y, sweref99X, epsgSweref99); coordinateRT90 = CrsCoordinateFactory.LatLon(rt90Y, rt90X, epsgRT9025gonv); }
public void TransformResultConstruction_ShouldThrowException_WhenParametersExceptionIsNotNullAndSuccessIsTrue() { Exception someException = new Exception("this is an exception"); CrsCoordinate outputCoordinateNull = null; ArgumentException exception = Assert.Throws<ArgumentException>( () => { CreateCrsTransformationResult( outputCoordinateNull, someException, // when there is an exception as above then the below success SHOULD BE false ! true ); } , "unvalid TransformResult object construction should throw exception when an exception parameter is combined with success true" ); }
private CrsTransformationResult CreateCrsTransformationResult( CrsCoordinate outputCoordinate, ICrsTransformationAdapter adapter, CrsCoordinate inputCoordinateNotUsedInThisTest ) { Exception exceptionNull = null; bool isSuccessTrue = true; return CrsTransformationResult._CreateCrsTransformationResult( inputCoordinateNotUsedInThisTest, outputCoordinate, exceptionNull, isSuccessTrue, adapter, CrsTransformationResultStatistic._CreateCrsTransformationResultStatistic(new List<CrsTransformationResult>()) ); }