public double CalculatePythagoras(DistancePoint point1, DistancePoint point2, MeasureUnit measureUnit)
{
var x = (DegreesToRadians(point2.Longitude) - DegreesToRadians(point1.Longitude)) *
Math.Cos((DegreesToRadians(point1.Latitude) + DegreesToRadians(point2.Latitude)) / 2);
var y = DegreesToRadians(point2.Latitude) - DegreesToRadians(point1.Latitude);
var d = Math.Sqrt(x * x + y * y) * GetEarthRadius(measureUnit);
return(d);
}
public void CalculateDistanceOnSamePointTest()
{
var point1 = new DistancePoint {
Latitude = 1, Longitude = 1
};
var result = instanceUnderTest.CalculateDistance(point1, point1, MeasureUnit.Km, DistanceCalculationMethod.GeodesicCurve);
Assert.AreEqual(0, result);
}
public void SamePointCaseTest()
{
var point1 = new DistancePoint
{
Latitude = 0,
Longitude = 0
};
var result = instanceUnderTest.CalculateDistance(point1, point1, MeasureUnit.Km);
Assert.AreEqual(0, result);
}
public double CalculateGeodesicCurve(DistancePoint point1, DistancePoint point2, MeasureUnit measureUnit)
{
var a = Geodesics.Domain.Constants.Constants.PointOriginDegrees - point2.Latitude;
var b = Geodesics.Domain.Constants.Constants.PointOriginDegrees - point1.Latitude;
var fi = point1.Longitude - point2.Longitude;
var cosP = Math.Cos(DegreesToRadians(a)) * Math.Cos(DegreesToRadians(b)) +
Math.Sin(DegreesToRadians(a)) * Math.Sin(DegreesToRadians(b)) * Math.Cos(DegreesToRadians(fi));
var n = RadiansToDegrees(Math.Acos(cosP));
var d = Math.PI * n * GetEarthRadius(measureUnit) / 180;
return(d);
}
public void GivenCaseTest()
{
var point1 = new DistancePoint {
Latitude = 53.297975,
Longitude = -6.372663
};
var point2 = new DistancePoint {
Latitude = 41.385101,
Longitude = -81.440440
};
var result = instanceUnderTest.CalculateDistance(point1, point2, MeasureUnit.Km);
Assert.AreEqual(5536.338682266685, result);
}
public void GenerateSDF(ref DistancePoint[,] grid)
{
//pass 0
for (int y = 0; y < _height; y++)
{
for (int x = 0; x < _width; x++)
{
DistancePoint p = grid[x, y];
Compare(ref grid, ref p, x, y, -1, 0);
Compare(ref grid, ref p, x, y, 0, -1);
Compare(ref grid, ref p, x, y, -1, -1);
Compare(ref grid, ref p, x, y, 1, -1);
grid[x, y] = p;
}
for (int x = _width - 1; x >= 0; x--)
{
DistancePoint p = grid[x, y];
Compare(ref grid, ref p, x, y, 1, 0);
grid[x, y] = p;
}
}
//pass 1
for (int y = _height - 1; y >= 0; y--)
{
for (int x = _width - 1; x >= 0; x--)
{
DistancePoint p = grid[x, y];
Compare(ref grid, ref p, x, y, 1, 0);
Compare(ref grid, ref p, x, y, 0, 1);
Compare(ref grid, ref p, x, y, -1, 1);
Compare(ref grid, ref p, x, y, 1, 1);
grid[x, y] = p;
}
for (int x = 0; x < _width; x++)
{
DistancePoint p = grid[x, y];
Compare(ref grid, ref p, x, y, -1, 0);
grid[x, y] = p;
}
}
}
public void GivenCaseInMilesTest()
{
var point1 = new DistancePoint
{
Latitude = 53.297975,
Longitude = -6.372663
};
var point2 = new DistancePoint
{
Latitude = 41.385101,
Longitude = -81.440440
};
var result = instanceUnderTest.CalculateDistance(point1, point2, MeasureUnit.Mile);
Assert.AreEqual(Math.Round(5536.338682266685 * 0.62141), Math.Round(result));
}
public void PythagorousCaseTest()
{
instanceUnderTest = new PythagorousDistanceCalculator();
var point1 = new DistancePoint
{
Latitude = 90,
Longitude = 57.295779513082323
};
var point2 = new DistancePoint
{
Latitude = -90,
Longitude = 57.295779513082323
};
var result = instanceUnderTest.CalculateDistance(point1, point2, MeasureUnit.Km);
Assert.AreEqual(Math.Round(20015.08), Math.Round(result));
}
public void CalculateDistanceWithNoCalculatorsTest()
{
var point1 = new DistancePoint {
Latitude = 1, Longitude = 1
};
var point2 = new DistancePoint {
Latitude = 1, Longitude = 2
};
try
{
var result = instanceUnderTest.CalculateDistance(point1, point2, MeasureUnit.Km, DistanceCalculationMethod.GeodesicCurve);
}
catch (ArgumentNullException) {
Assert.Pass();
}
Assert.Fail();
}
public ActionResult <DistanceResponse> Get(DistanceCalculationMethod distanceMethod, MeasureUnit measureUnit,
[FromQuery][Range(-90, 90, ErrorMessage = "Must be in [-90, 90] interval")] double point1Latitude,
[FromQuery][Range(-180, 180, ErrorMessage = "Must be in [-180, 180] interval")] double point1Longitude,
[FromQuery][Range(-90, 90, ErrorMessage = "Must be in [-90, 90] interval")] double point2Latitude,
[FromQuery][Range(-180, 180, ErrorMessage = "Must be in [-180, 180] interval")] double point2Longitude)
{
var point1 = new DistancePoint
{
Latitude = point1Latitude,
Longitude = point1Longitude
};
var point2 = new DistancePoint
{
Latitude = point2Latitude,
Longitude = point2Longitude
};
return(new ActionResult <DistanceResponse>(new DistanceResponse
{
Distance = _distanceStrategy.CalculateDistance(point1, point2, measureUnit, distanceMethod)
}));
}
public void CalculateDistanceWithMatchingCalculatorTest()
{
//setup
var point1 = new DistancePoint {
Latitude = 1, Longitude = 1
};
var point2 = new DistancePoint {
Latitude = 1, Longitude = 2
};
var inputList = new List <IDistanceCalculator>();
var mockCalculator = new Mock <IDistanceCalculator>();
mockCalculator.Setup(x => x.DistanceCalculationMethod).Returns(DistanceCalculationMethod.GeodesicCurve);
mockCalculator.Setup(x => x.CalculateDistance(point1, point2, MeasureUnit.Km)).Returns(1);
inputList.Add(mockCalculator.Object);
instanceUnderTest = new DistanceCalculationStrategy(inputList);
//execution
var result = instanceUnderTest.CalculateDistance(point1, point2, MeasureUnit.Km, DistanceCalculationMethod.GeodesicCurve);
Assert.AreEqual(1, result);
}
public void Compare(ref DistancePoint[,] grid, ref DistancePoint point, int x, int y, int offsetX, int offsetY)
{
DistancePoint other = new DistancePoint();
if (x + offsetX > 0 && y + offsetY > 0 && x + offsetX < grid.GetLength(0) && y + offsetY < grid.GetLength(1))
{
other.dx = grid[x + offsetX, y + offsetY].dx + offsetX;
other.dy = grid[x + offsetX, y + offsetY].dy + offsetY;
}
else
{
other = new DistancePoint()
{
dx = infinity, dy = infinity
};
}
if (other.distSq() < point.distSq())
{
point.dx = other.dx;
point.dy = other.dy;
}
}
public ActionResult <DistanceResponse> Get([EnumDataType(typeof(DistanceMethod))] DistanceMethod distanceMethod, [EnumDataType(typeof(MeasureUnit))] MeasureUnit measureUnit,
[FromQuery][Required][Range(-90, 90)] double point1Latitude, [FromQuery][Required][Range(-180, 180)] double point1Longitude,
[FromQuery][Required][Range(-90, 90)] double point2Latitude, [FromQuery][Required][Range(-180, 180)] double point2Longitude)
{
//Validates the model
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
//Initialises the distance point values.
var point1 = new DistancePoint(point1Latitude, point1Longitude);
var point2 = new DistancePoint(point2Latitude, point2Longitude);
//Gets the type of distance calculation method service from the factory
var distanceCalculationMethod = _distanceCalculatorFactory.GetDistanceCalculationStrategy(distanceMethod);
//Returns the response
return(new ActionResult <DistanceResponse>(new DistanceResponse
{
Distance = distanceCalculationMethod.CalculateDistance(point1, point2, measureUnit)
}));
}
