public IEnumerable <Parking> GetParkingsByGeo(GeoPoint point, double radius, int parkingsToTake)
{
var parkings = new List <DistanceParking>();
// Go over all the parkings and calculate the distance
foreach (var parking in ParkingCache.Values)
{
var location = new GeoPoint(parking.Longtitude, parking.Latitude);
var distance = location.Distance(point);
if (distance <= radius)
{
parkings.Add(new DistanceParking()
{
Distance = distance, Parking = parking
});
}
}
if (parkingsToTake < 0)
{
return(parkings.Select(dist => dist.Parking));
}
else
{
parkings.Sort(new DistanceComparer());
return(parkings.Take(parkingsToTake > parkings.Count ? parkings.Count : parkingsToTake).Select(dist => dist.Parking));
}
}
public RoutePath(GeoPoint from, GeoPoint to, float speed)
{
mFrom = from;
mTo = to;
mDistance = GeoPoint.Distance(mFrom, mTo);
mSpeed = speed;
}
private bool OnSetLength(double length)
{
if (length > Precision.eps)
{
lineLength = length;
}
else
{
return(false);
}
if (curveInput.Fixed)
{
base.MultiSolutionCount = 2;
objectPoint = base.CurrentMousePosition;
GeoVector v = line.EndPoint - line.StartPoint;
if (!v.IsNullVector())
{
v.Norm();
}
else
{
v = new GeoVector(1.0, 0.0, 0.0);
}
GeoPoint endPoint = line.StartPoint + length * v;
GeoPoint endPointOpp = line.StartPoint - length * v;
if (!nextSol)
{
if (objectPoint.Distance(endPoint) > objectPoint.Distance(endPointOpp))
{
endPoint = endPointOpp;
}
}
else
{
if (objectPoint.Distance(endPoint) < objectPoint.Distance(endPointOpp))
{
endPoint = endPointOpp;
}
}
line.EndPoint = endPoint;
return(true);
}
base.MultiSolutionCount = 0;
return(false);
}
public void Distance(GeoPoint a, GeoPoint b, double expectedDistance)
{
var actual = GeoPoint.Distance(a, b);
var actualInverse = GeoPoint.Distance(b, a);
Assert.AreEqual(actual, actualInverse, "dist(b,a) should equal dist(a,b)");
double faultTolerance = expectedDistance * 0.005;
Assert.AreEqual(expectedDistance, actual.ToKilometers(), faultTolerance);
}
public virtual Task Distance_on_converted_geometry_type_lhs(bool async)
{
var point = new GeoPoint(1, 0);
return(AssertQuery(
async,
ss => ss.Set <GeoPointEntity>().Select(
e => new { e.Id, Distance = point.Distance(e.Location) }),
elementSorter: e => e.Id,
elementAsserter: (e, a) => { Assert.Equal(e.Id, a.Id); }));
}
public static void BuildPath(GeoPoint from, GeoPoint to, int steps, ref List <Vector3> vertices, ref float distance)
{
distance = GeoPoint.Distance(from, to);
Quaternion q0 = Quaternion.FromToRotation(from.ToSphericalCartesian(), from.ToSphericalCartesian());
Quaternion q1 = Quaternion.FromToRotation(from.ToSphericalCartesian(), to.ToSphericalCartesian());
float tStep = 1.0f / (float)steps;
for (int i = 0; i <= steps; i++)
{
Quaternion q = Quaternion.Slerp(q0, q1, i * tStep);
Vector3 v = q * from.ToSphericalCartesian();
vertices.Add(v);
}
}
protected void UpdateCurrentTownId(List <AreaTestInfo> results, int townId, GeoPoint point, int fileId,
bool isCoverage)
{
var distance = 0.0;
if (townId == _currentTownId)
{
if (_lastLon > 0 && _lastLat > 0)
{
distance = point.Distance(new GeoPoint(_lastLon, _lastLat));
}
_lastLon = point.Longtitute;
_lastLat = point.Lattitute;
}
else
{
_currentTownId = townId;
_lastLon = -1.0;
_lastLat = -1.0;
}
var item = results.FirstOrDefault(x => x.TownId == townId);
if (item == null)
{
results.Add(new AreaTestInfo
{
FileId = fileId,
TownId = townId,
Distance = distance,
Count = 1,
CoverageCount = isCoverage ? 1 : 0
});
}
else
{
item.Distance += distance;
item.Count++;
if (isCoverage)
{
item.CoverageCount++;
}
}
}
public void WithinRadiusTest(GeoLocation sample)
{
const double radius = 100;
Console.WriteLine($"Searching for places within {radius} km of {sample.Name}");
var within = _places.WithinRadius(sample.Point, radius).OrderBy(p => p.Value).ToArray();
Console.WriteLine("Found " + within.Length);
foreach (var keyValuePair in within)
{
var kms = keyValuePair.Value.ToKilometers();
Console.WriteLine($"{keyValuePair.Key} at distance {kms} km");
Assert.IsTrue(keyValuePair.Value.ToKilometers() <= radius);
}
//Double check and print any errors
var withinNames = new HashSet <string>(within.Select(kvp => kvp.Key));
int failures = 0;
foreach (var keyValuePair in _places)
{
var name = keyValuePair.Key;
var distance = GeoPoint.Distance(sample.Point, keyValuePair.Value);
if (distance.ToKilometers() > radius && withinNames.Contains(name))
{
failures++;
Console.WriteLine("false positive: " + name + ", d=" + distance);
}
if (distance.ToKilometers() <= radius && !withinNames.Contains(name))
{
failures++;
Console.WriteLine("false negative: " + name + ", d=" + distance);
}
}
Assert.IsTrue(failures == 0, "failures: " + failures);
}
private bool WithinRanage(GeoPoint searchElement, GeoPoint listElement, float range)
{
var d = searchElement.Distance(listElement.ToVector2());
return(d <= range);
}
////////////////////////////////////////////////////////////////////////
//--------------------------------- REVISIONS --------------------------
// Date Name Tracking # Description
// --------- ------------------- ------------- ------------------
// 18JUN2009 James Shen Initial Creation
////////////////////////////////////////////////////////////////////////
/**
*
* @param mapDirection
* @param X
* @param Y
* @param Width
* @param Height
*/
private void DrawRouteImage(MapDirection mapDirection, int x, int y,
int width, int height)
{
if (!_routeDrawWaypointOnly)
{
_sutherlandHodgman = new SutherlandHodgman(_screenBounds);
ArrayList polyline = new ArrayList();
int minLevel = NeedShowLevel(mapDirection.Polyline.NumLevels, GetZoom());
for (int i = 0; i < mapDirection.Polyline.GetVertexCount(); i++)
{
int level = mapDirection.Polyline.GetLevel(i);
if (level >= minLevel)
{
polyline.Add(mapDirection.Polyline.GetVertex(i));
}
}
ArrayList clippedPts = _sutherlandHodgman.ClipPline(polyline);
GeoPoint newPt1;
GeoPoint newPt2;
GeoPoint drawPt1 = new GeoPoint(0, 0), drawPt2 = new GeoPoint(0, 0);
const int steps = 1;
int numOfTiles = MAP_TILE_WIDTH / _mapDrawingTileWidth;
Rectangle drawArea = new Rectangle();
Rectangle intersectRect = new Rectangle(0, 0, width, height);
int xIndex;
for (xIndex = 0; xIndex < numOfTiles; xIndex++)
{
int yIndex;
for (yIndex = 0; yIndex < numOfTiles; yIndex++)
{
bool hasPt1 = false;
GeoLatLng pt1 = null;
_routeGraphics2D.Clear(Color.White);
drawArea.X = xIndex * _mapDrawingTileWidth;
drawArea.Y = yIndex * _mapDrawingTileWidth;
drawArea.Width = drawArea.Height = _mapDrawingTileWidth;
drawArea = intersectRect.Intersection(drawArea);
int totalPointSize = clippedPts.Count;
if (!drawArea.IsEmpty())
{
_routeGraphics2D.SetClip(0, 0,
drawArea.Width, drawArea.Height);
try
{
for (int j = 0; j < totalPointSize; j += steps)
{
GeoLatLng pt = (GeoLatLng)clippedPts[j];
int level = minLevel;
if (hasPt1 == false)
{
if (level >= minLevel)
{
{
{
hasPt1 = true;
pt1 = pt;
continue;
}
}
}
}
if (hasPt1)
{
if (level >= minLevel)
{
GeoLatLng pt2 = pt;
newPt1 = FromLatLngToMapPixel(pt1);
newPt2 = FromLatLngToMapPixel(pt2);
newPt1.X -= x + xIndex * _mapDrawingTileWidth;
newPt1.Y -= y + yIndex * _mapDrawingTileWidth;
newPt2.X -= x + xIndex * _mapDrawingTileWidth;
newPt2.Y -= y + yIndex * _mapDrawingTileWidth;
drawPt1.X = (int)newPt1.X;
drawPt1.Y = (int)newPt1.Y;
drawPt2.X = (int)newPt2.X;
drawPt2.Y = (int)newPt2.Y;
if ((drawPt1.Distance(drawPt2) > 0))
{
_routeGraphics2D.DrawLine(RoutePen, (int)drawPt1.X,
(int)drawPt1.Y,
(int)drawPt2.X, (int)drawPt2.Y);
pt1 = pt2;
if (_readListener != null)
{
_readListener.readProgress(j,
totalPointSize);
}
}
}
}
}
}
catch (Exception)
{
}
}
_routeGraphics.DrawRGB(_routeGraphics2D.GetRGB(), 0,
_mapDrawingTileWidth,
xIndex * _mapDrawingTileWidth,
yIndex * _mapDrawingTileWidth,
_mapDrawingTileWidth,
_mapDrawingTileWidth, true);
}
}
}
else
{
_routeGraphics.SetColor(TRANSPARENCY);
_routeGraphics.FillRect(0, 0, MAP_TILE_WIDTH, MAP_TILE_WIDTH);
}
}
public Airport GetRandomAirportCloseTo(Airport airport)
{
return(_airports.Values.Where(a => !a.IsUnlocked).OrderBy(a => GeoPoint.Distance(a.Location, airport.Location)).Take(5).OrderBy(qu => Guid.NewGuid()).First());
}
