public void ContainsPoint()
{
MKMapRect rect = new MKMapRect();
MKMapPoint point = new MKMapPoint();
Assert.False(rect.Contains(point), "default");
}
void Init(Tuple <GeoAnchor, GeoAnchor> anchors)
{
// To compute the distance between two geographical co-ordinates, we first need to
// convert to MapKit co-ordinates
fromAnchorFloorplanPoint = anchors.Item1.Pixel;
fromAnchorMKPoint = MKMapPoint.FromCoordinate(anchors.Item1.LatitudeLongitude);
MKMapPoint toAnchorMKPoint = MKMapPoint.FromCoordinate(anchors.Item2.LatitudeLongitude);
// So that we can use MapKit's helper function to compute distance.
// this helper function takes into account the curvature of the earth.
var distanceBetweenPointsMeters = (nfloat)MKGeometry.MetersBetweenMapPoints(fromAnchorMKPoint, toAnchorMKPoint);
var dx = anchors.Item1.Pixel.X - anchors.Item2.Pixel.X;
var dy = anchors.Item1.Pixel.Y - anchors.Item2.Pixel.Y;
// Distance between two points in pixels (on the floorplan image)
var distanceBetweenPointsPixels = Hypot(dx, dy);
// This gives us pixels/meter
PixelsPerMeter = distanceBetweenPointsPixels / distanceBetweenPointsMeters;
// Get the 2nd anchor's eastward/southward distance in meters from the first anchor point.
var hyp = FetchRect(fromAnchorMKPoint, toAnchorMKPoint);
// Angle of diagonal to east (in geographic)
nfloat angleFromEastAndHypo = NMath.Atan2(hyp.South, hyp.East);
// Angle of diagonal to horizontal (in floorplan)
nfloat angleFromXAndHypo = NMath.Atan2(dy, dx);
// Rotation amount from the geographic anchor line segment
// to the floorplan anchor line segment
// This is angle between X axis and East direction. This angle shows how you floor plan exists in real world
radiansRotated = angleFromXAndHypo - angleFromEastAndHypo;
}
public static MKMapRect FBMapRectForBoundingBox(FBBoundingBox boundingBox)
{
MKMapPoint topLeft = MKMapPoint.FromCoordinate(new CLLocationCoordinate2D(boundingBox.x0, boundingBox.y0));
MKMapPoint botRight = MKMapPoint.FromCoordinate(new CLLocationCoordinate2D(boundingBox.xf, boundingBox.yf));
return(new MKMapRect(topLeft.X, botRight.Y, Math.Abs(botRight.X - topLeft.X), Math.Abs(botRight.Y - topLeft.Y)));
}
private void UpdateMapRect(MKMapRect visibleMapRect, bool animated)
{
if (this.Tree == null || visibleMapRect.IsNull || visibleMapRect.IsEmpty)
{
return;
}
MKMapRect clusterMapRect = new MKMapRect().World;
if (this.MarginFactor != kCKMarginFactorWorld)
{
clusterMapRect = visibleMapRect.Inset(-this.MarginFactor * visibleMapRect.Width, -this.MarginFactor * visibleMapRect.Height);
}
double zoom = this.map.GetZoom();
var algorithm = (zoom < this.MaxZoomLevel) ? this.Algorithm : new CKClusterAlgorithm();
var clusters = algorithm.ClustersInRect(clusterMapRect, zoom, this.Tree);
var toRemove = this.clusters.ToList();
foreach (var newCluster in clusters)
{
this.map.AddCluster(newCluster);
if (!visibleMapRect.Contains(MKMapPoint.FromCoordinate(newCluster.Coordinate)) || !animated)
{
continue;
}
var c = this.Clusters.ToList();
foreach (var oldCluster in c)
{
if (!clusterMapRect.Contains(MKMapPoint.FromCoordinate(oldCluster.Coordinate)))
{
continue;
}
if (this.CLLocationCoordinateEqual(newCluster.Coordinate, oldCluster.Coordinate))
{
continue;
}
if (oldCluster.Annotations.Contains(newCluster.Annotations[0]))
{
this.map.MoveCluster(newCluster, oldCluster.Coordinate, newCluster.Coordinate, null);
}
else if (newCluster.Annotations.Contains(oldCluster.Annotations[0]))
{
this.map.MoveCluster(oldCluster, oldCluster.Coordinate, newCluster.Coordinate, (finished) => { this.map.RemoveCluster(oldCluster); });
toRemove.Remove(oldCluster);
}
}
}
foreach (var cluster in toRemove)
{
this.map.RemoveCluster(cluster);
}
this.Clusters = clusters;
this.VisibleMapRect = visibleMapRect;
}
public static double GetDistance(CLLocationCoordinate2D from, CLLocationCoordinate2D to)
{
MKMapPoint a = MKMapPoint.FromCoordinate(from);
MKMapPoint b = MKMapPoint.FromCoordinate(to);
return((a.X - b.X) * (a.X - b.X) + (a.Y - b.Y) * (a.Y - b.Y));
}
public override List <CKCluster> ClustersInRect(MapKit.MKMapRect rect, double zoom, Tree.ICKAnnotationTree tree)
{
var clusters = new Dictionary <double, CKCluster>();
var annotations = tree.AnnotationsInRect(rect);
var numCells = Math.Ceiling(256 * Math.Pow(2, zoom) / this.CellSize);
foreach (var ann in annotations)
{
var point = MKMapPoint.FromCoordinate(ann.Coordinate);
var col = numCells * point.X / MKMapSize.World.Width;
var row = numCells * point.Y / MKMapSize.World.Height;
var key = numCells * row + col;
CKCluster cluster;
if (clusters.ContainsKey(key))
{
cluster = clusters[key];
}
else
{
cluster = this.ClusterWithCoordinate(ann.Coordinate);
clusters[key] = cluster;
}
cluster.AddAnnotation(ann);
}
return(clusters.Values.ToList());
}
public MKMapRect MKMapRectByAddingPoint(MKMapRect rect, MKMapPoint point)
{
return(MKMapRect.Union(rect, new MKMapRect()
{
Origin = point, Size = MKMapRect.Null.Size
}));
}
public void OnMapMessage(Map sender, XamMapz.Messaging.MapMessage message)
{
if (message is ZoomMessage)
{
// var msg = (ZoomMessage)message;
if (_mapViewDelegate.IsRegionChanging == false)
{
UpdateRegion();
}
}
else if (message is ProjectionMessage)
{
var msg = (ProjectionMessage)message;
var screenPos = MKMapPoint.FromCoordinate(msg.Position.ToCoordinate2D());
msg.ScreenPosition = new Point(screenPos.X, screenPos.Y);
}
else if (message is MoveMessage)
{
if (_mapViewDelegate.IsRegionChanging == false)
{
var msg = (MoveMessage)message;
NativeMap.CenterCoordinate = msg.Target.ToCoordinate2D();
}
}
}
void Init (Tuple<GeoAnchor, GeoAnchor> anchors)
{
// To compute the distance between two geographical co-ordinates, we first need to
// convert to MapKit co-ordinates
fromAnchorFloorplanPoint = anchors.Item1.Pixel;
fromAnchorMKPoint = MKMapPoint.FromCoordinate (anchors.Item1.LatitudeLongitude);
MKMapPoint toAnchorMKPoint = MKMapPoint.FromCoordinate (anchors.Item2.LatitudeLongitude);
// So that we can use MapKit's helper function to compute distance.
// this helper function takes into account the curvature of the earth.
var distanceBetweenPointsMeters = (nfloat)MKGeometry.MetersBetweenMapPoints (fromAnchorMKPoint, toAnchorMKPoint);
var dx = anchors.Item1.Pixel.X - anchors.Item2.Pixel.X;
var dy = anchors.Item1.Pixel.Y - anchors.Item2.Pixel.Y;
// Distance between two points in pixels (on the floorplan image)
var distanceBetweenPointsPixels = Hypot (dx, dy);
// This gives us pixels/meter
PixelsPerMeter = distanceBetweenPointsPixels / distanceBetweenPointsMeters;
// Get the 2nd anchor's eastward/southward distance in meters from the first anchor point.
var hyp = FetchRect (fromAnchorMKPoint, toAnchorMKPoint);
// Angle of diagonal to east (in geographic)
nfloat angleFromEastAndHypo = NMath.Atan2 (hyp.South, hyp.East);
// Angle of diagonal to horizontal (in floorplan)
nfloat angleFromXAndHypo = NMath.Atan2 (dy, dx);
// Rotation amount from the geographic anchor line segment
// to the floorplan anchor line segment
// This is angle between X axis and East direction. This angle shows how you floor plan exists in real world
radiansRotated = angleFromXAndHypo - angleFromEastAndHypo;
}
// MapKit alternative
public static double MKGetDistanceBetween(Airport airport1, Airport airport2)
{
CLLocationCoordinate2D loc1 = new CLLocationCoordinate2D(airport1.Latitude, airport1.Longitude);
CLLocationCoordinate2D loc2 = new CLLocationCoordinate2D(airport2.Latitude, airport2.Longitude);
MKMapPoint point1 = MKMapPoint.FromCoordinate(loc1);
MKMapPoint point2 = MKMapPoint.FromCoordinate(loc2);
return(MKGeometry.MetersBetweenMapPoints(point1, point2) / MetersPerNauticalMile);
}
public override async Task <IEnumerable <Geoposition> > CalculateRoute(Geoposition from, Geoposition to)
{
IEnumerable <Geoposition> result = Enumerable.Empty <Geoposition>();
var nativeFrom = CoordinateConverter.ConvertToNative(from);
var nativeTo = CoordinateConverter.ConvertToNative(to);
var userPlaceMark = new MKPlacemark(nativeFrom, new Foundation.NSDictionary());
var incidencePlaceMark = new MKPlacemark(nativeTo, new Foundation.NSDictionary());
var sourceItem = new MKMapItem(userPlaceMark);
var destItem = new MKMapItem(incidencePlaceMark);
var request = new MKDirectionsRequest
{
Source = sourceItem,
Destination = destItem,
TransportType = MKDirectionsTransportType.Automobile
};
var directions = new MKDirections(request);
MKPolyline polyRoute = null;
directions.CalculateDirections((response, error) =>
{
if (error != null)
{
System.Diagnostics.Debug.WriteLine(error.LocalizedDescription);
}
else
{
if (response.Routes.Any())
{
var firstRoute = response.Routes.First();
polyRoute = firstRoute.Polyline;
}
}
});
do
{
await Task.Delay(100);
}while (directions.Calculating);
if (polyRoute != null)
{
result = polyRoute.Points.Select(s =>
{
CLLocationCoordinate2D coordinate = MKMapPoint.ToCoordinate(s);
return(CoordinateConverter.ConvertToAbstraction(coordinate));
});
}
return(result);
}
public override IEnumerable <Position> GetCurrentUserRoute()
{
var positions = _currentUserRoute?.Points.Select(r =>
{
var coord = MKMapPoint.ToCoordinate(r);
return(CoordinateConverter.ConvertToAbstraction(coord));
});
return(positions);
}
public void ShowCluster(CKCluster cluster, bool animated)
{
MKMapRect mapRect = MKMapRect.Null;
foreach (var annoation in cluster.Annotations)
{
mapRect = MKMapRectByAddingPoint(mapRect, MKMapPoint.FromCoordinate(annoation.Coordinate));
}
_internalMap.SetVisibleMapRect(mapRect, animated);
}
private async Task <IEnumerable <Position> > RequestMKMapRoutePoints(RouteModel route, CLLocationCoordinate2D from, CLLocationCoordinate2D to)
{
IEnumerable <Position> result = Enumerable.Empty <Position>();
var userPlaceMark = new MKPlacemark(from, new Foundation.NSDictionary());
var incidencePlaceMark = new MKPlacemark(to, new Foundation.NSDictionary());
var sourceItem = new MKMapItem(userPlaceMark);
var destItem = new MKMapItem(incidencePlaceMark);
var request = new MapKit.MKDirectionsRequest
{
Source = sourceItem,
Destination = destItem,
TransportType = MKDirectionsTransportType.Automobile
};
var directions = new MKDirections(request);
MKPolyline polyRoute = null;
directions.CalculateDirections((response, error) =>
{
if (error != null)
{
System.Diagnostics.Debug.WriteLine(error.LocalizedDescription);
}
else
{
if (response.Routes.Any())
{
var firstRoute = response.Routes.First();
polyRoute = firstRoute.Polyline;
route.Distance += firstRoute.Distance;
route.Duration += firstRoute.ExpectedTravelTime / 60;
}
}
});
do
{
await Task.Delay(100);
}while (directions.Calculating);
if (polyRoute != null)
{
result = polyRoute.Points.Select(s =>
{
CLLocationCoordinate2D coordinate = MKMapPoint.ToCoordinate(s);
return(CoordinateConverter.ConvertToAbstraction(coordinate));
});
}
return(result);
}
void SetMapToCoordinate(CLLocationCoordinate2D coordinate)
{
var region = new MKCoordinateRegion(coordinate, currentSpan);
currentRegion = region;
var newCenterPoint = MKMapPoint.FromCoordinate(coordinate);
map.SetVisible(new MKMapRect(newCenterPoint.X, newCenterPoint.Y, currentSpan.LatitudeDelta, currentSpan.LongitudeDelta));
map.SetRegion(region);
}
// Two points in rectangular co-ordinate system create a rectange
static EastSouthDistance FetchRect(MKMapPoint fromAnchorMKPoint, MKMapPoint toPoint)
{
double latitude = MKMapPoint.ToCoordinate(fromAnchorMKPoint).Latitude;
nfloat metersPerMapPoint = (nfloat)MKGeometry.MetersPerMapPointAtLatitude(latitude);
var eastSouthDistance = new EastSouthDistance {
East = (nfloat)(toPoint.X - fromAnchorMKPoint.X) * metersPerMapPoint,
South = (nfloat)(toPoint.Y - fromAnchorMKPoint.Y) * metersPerMapPoint
};
return(eastSouthDistance);
}
public static FBBoundingBox FBBoundingBoxForMapRect(MKMapRect mapRect)
{
CLLocationCoordinate2D topLeft = MKMapPoint.ToCoordinate(mapRect.Origin);
CLLocationCoordinate2D botRight = MKMapPoint.ToCoordinate(new MKMapPoint(mapRect.MaxX, mapRect.MaxY));
double minLat = botRight.Latitude;
double maxLat = topLeft.Latitude;
double minLon = topLeft.Longitude;
double maxLon = botRight.Longitude;
return(FBBoundingBoxMake(minLat, minLon, maxLat, maxLon));
}
private void RefreshMap(CLLocationCoordinate2D centerCoords)
{
_mapRegion = new MKCoordinateRegion(centerCoords, _mapSpan);
var center = MKMapPoint.FromCoordinate(centerCoords);
map.SetVisible(new MKMapRect(center.X, center.Y, _mapSpan.LatitudeDelta, _mapSpan.LongitudeDelta));
map.SetRegion(_mapRegion);
map.AddAnnotation(centerCoords, WKInterfaceMapPinColor.Green);
}
public void CenterOnLocations(List <LatitudeLongitude> locations
, bool with_animation = false)
{
if (locations == null || locations.Count == 0)
{
return;
}
var minLat = locations.Select(el => el.Latitude).Min();
var minLong = locations.Select(el => el.Longitude).Min();
var maxLat = locations.Select(el => el.Latitude).Max();
var maxLong = locations.Select(el => el.Longitude).Max();
var coordinateMin = new CLLocationCoordinate2D(minLat, minLong);
var coordinateMax = new CLLocationCoordinate2D(maxLat, maxLong);
var upperLeft = MKMapPoint.FromCoordinate(coordinateMin);
var lowerRight = MKMapPoint.FromCoordinate(coordinateMax);
var mapRect = new MKMapRect(upperLeft.X
, upperLeft.Y
, lowerRight.X - upperLeft.X
, lowerRight.Y - upperLeft.Y);
var region = MKCoordinateRegion.FromMapRect(mapRect);
MapViewControl.SetVisibleMapRect(mapRect
, new UIEdgeInsets(50, 20, 100, 20)
, true);
try
{
if (region.Center.Latitude > -89 && region.Center.Latitude < 89 && region.Center.Longitude > -179 && region.Center.Longitude < 179)
{
if (region.Span.LatitudeDelta < 0)
{
region.Span.LatitudeDelta = 0.0;
}
if (region.Span.LongitudeDelta < 0)
{
region.Span.LongitudeDelta = 0.0;
}
MapViewControl.SetRegion(region, with_animation);
}
}
catch (Exception)
{
//UIAlertView alert = new UIAlertView("Exception", String.Format("{0} \n {1}?", e.Message, e.StackTrace), null, "Cancel");
//alert.Show();
}
}
public void ContainsPoint()
{
MKMapRect rect = new MKMapRect();
MKMapPoint point = new MKMapPoint();
if (TestRuntime.CheckXcodeVersion(8, 0))
{
Assert.True(rect.Contains(point), "default");
}
else
{
Assert.False(rect.Contains(point), "default");
}
}
private void CleanClustersOutsideMapRect(List <MapCluster> clusters, MKMapRect mapRect)
{
var clustersToRemove = new List <MapCluster>();
foreach (var cluster in clusters)
{
if (!mapRect.Contains(MKMapPoint.FromCoordinate(cluster.ClusterCoordinate)))
{
clustersToRemove.Add(cluster);
}
}
clusters.RemoveAll(clustersToRemove.Contains);
}
public MKMapRect CKCreateRectFromSpan(CLLocationCoordinate2D center, double span)
{
double halfSpan = span / 2;
double latitude = Math.Min(center.Latitude + halfSpan, 90);
double longitude = Math.Max(center.Longitude - halfSpan, -180);
MKMapPoint a = MKMapPoint.FromCoordinate(new CLLocationCoordinate2D(latitude, longitude));
latitude = Math.Max(center.Latitude - halfSpan, -90);
longitude = Math.Min(center.Longitude + halfSpan, 180);
MKMapPoint b = MKMapPoint.FromCoordinate(new CLLocationCoordinate2D(latitude, longitude));
return(new MKMapRect(Math.Min(a.X, b.X), Math.Min(a.Y, b.Y), Math.Abs(a.X - b.X), Math.Abs(a.Y - b.Y)));
}
public static void ShowCluster(this MKMapView map, CKCluster cluster, UIEdgeInsets insets, bool animated)
{
MKMapRect zoomRect = MKMapRect.Null;
foreach (var annotation in cluster.Annotations)
{
var pointRect = new MKMapRect();
pointRect.Origin = MKMapPoint.FromCoordinate(annotation.Coordinate);
pointRect.Size = new MKMapSize(0.1d, 0.1d);
zoomRect = MKMapRect.Union(zoomRect, pointRect);
}
map.SetVisibleMapRect(zoomRect, insets, animated);
}
public MKMapView setMapRegion(MKMapView map)
{
MKMapRect zoomRect = new MKMapRect(double.PositiveInfinity, double.PositiveInfinity, 0, 0);
foreach (MKAnnotation annotation in map.Annotations)
{
if (annotation.Coordinate.Latitude != 0)
{
MKMapPoint annotationPoint = MKMapPoint.FromCoordinate(annotation.Coordinate);
MKMapRect pointRect = new MKMapRect(annotationPoint.X, annotationPoint.Y, 0.1, 0.1);
zoomRect = MKMapRect.Union(zoomRect, pointRect);
}
}
map.SetVisibleMapRect(zoomRect, new UIEdgeInsets(40, 20, 20, 20), true);
return(map);
}
public void MetersBetweenMapPoints()
{
MKMapPoint a = new MKMapPoint();
Assert.That(MKGeometry.MetersBetweenMapPoints(a, a), Is.EqualTo(0.0), "a-a");
MKMapPoint b = new MKMapPoint(1000, 1000);
Assert.That(MKGeometry.MetersBetweenMapPoints(b, b), Is.EqualTo(0.0), "b-b");
Assert.That(MKGeometry.MetersBetweenMapPoints(a, b), Is.EqualTo(18.153).Within(0.001), "a-b");
Assert.That(MKGeometry.MetersBetweenMapPoints(b, a), Is.EqualTo(18.153).Within(0.001), "b-a");
MKMapPoint c = new MKMapPoint(Double.NaN, Double.NaN);
Assert.That(MKGeometry.MetersBetweenMapPoints(a, c), Is.NaN, "NaN");
}
public static bool Insert(CKNode node, MKAnnotation annotation)
{
var point = MKMapPoint.FromCoordinate(annotation.Coordinate);
if (!node.Bound.Contains(point))
{
return(false);
}
if (node.Count < node.Capacity)
{
CKPoint tPoint = new CKPoint();
tPoint.Annotation = annotation;
tPoint.Point = point;
CKNode.Add(node, tPoint);
return(true);
}
if (node.NW == null)
{
CKNode.Subdivide(node);
}
if (CKNode.Insert(node.NW, annotation))
{
return(true);
}
if (CKNode.Insert(node.NE, annotation))
{
return(true);
}
if (CKNode.Insert(node.SW, annotation))
{
return(true);
}
if (CKNode.Insert(node.SE, annotation))
{
return(true);
}
return(false);
}
public static RadarBounds GetRadarBounds(this MKMapView map)
{
CLLocationCoordinate2D center = map.CenterCoordinate;
var topLeft = MKMapPoint.FromCoordinate(new CLLocationCoordinate2D(center.Latitude + (map.Region.Span.LatitudeDelta / 2.0), center.Longitude - (map.Region.Span.LongitudeDelta / 2.0)));
var bottomRight = MKMapPoint.FromCoordinate(new CLLocationCoordinate2D(center.Latitude - (map.Region.Span.LatitudeDelta / 2.0), center.Longitude + (map.Region.Span.LongitudeDelta / 2.0)));
var bounds = new RadarBounds {
MinLat = center.Latitude + (map.Region.Span.LatitudeDelta / 2.0),
MaxLat = center.Latitude - (map.Region.Span.LatitudeDelta / 2.0),
MinLon = center.Longitude - (map.Region.Span.LongitudeDelta / 2.0),
MaxLon = center.Longitude + (map.Region.Span.LongitudeDelta / 2.0),
Height = Math.Abs(topLeft.Y - bottomRight.Y),
Width = Math.Abs(topLeft.X - bottomRight.X)
};
return(bounds);
}
public static MKCoordinateRegion CoordinateRegionForCoordinates(
CLLocationCoordinate2D[] coordinates,
MKMapSize margin)
{
var rect = default(MKMapRect);
foreach (var coordinate in coordinates)
{
var point = MKMapPoint.FromCoordinate(coordinate);
var pointRect = new MKMapRect(
point.X - margin.Width / 2,
point.Y - margin.Height / 2,
margin.Width,
margin.Height);
rect = rect != default(MKMapRect) ? MKMapRect.Union(rect, pointRect) : pointRect;
}
return(MKCoordinateRegion.FromMapRect(rect));
}
// Convert the specified geographic coordinate to floorplan point
public CGPoint Convert(CLLocationCoordinate2D coordinate)
{
// Get the distance east & south with respect to the first anchor point in meters
EastSouthDistance rect = FetchRect(fromAnchorMKPoint, MKMapPoint.FromCoordinate(coordinate));
// Convert the east-south anchor point distance to pixels (still in east-south)
var scaleTransform = CGAffineTransform.MakeScale(PixelsPerMeter, PixelsPerMeter);
CGPoint pixelsXYInEastSouth = scaleTransform.TransformPoint(new CGPoint(rect.East, rect.South));
// Rotate the east-south distance to be relative to floorplan horizontal
// This gives us an xy distance in pixels from the anchor point.
var rotateTransform = CGAffineTransform.MakeRotation(radiansRotated);
CGPoint xy = rotateTransform.TransformPoint(pixelsXYInEastSouth);
// From Anchor point may not be top letf corner.
// however, we need the pixels from the (0, 0) of the floorplan
// so we adjust by the position of the anchor point in the floorplan
xy.X += fromAnchorFloorplanPoint.X;
xy.Y += fromAnchorFloorplanPoint.Y;
return(xy);
}
private void MapTapped(MKMapView mapView, UITapGestureRecognizer tappedGesture)
{
var mapview = tappedGesture.View as MKMapView;
CLLocationCoordinate2D coord2D = mapView.ConvertPoint(tappedGesture.LocationInView(mapView), mapView);
var mapPoint = MKMapPoint.FromCoordinate(coord2D);
foreach (IMKOverlay overlay in mapview.Overlays)
{
var renderer = (MKOverlayPathRenderer)mapview.RendererForOverlay(overlay);
if (renderer == null)
{
return;
}
var polyTouched = renderer.Path.ContainsPoint(renderer.PointForMapPoint(mapPoint), true);
if (polyTouched)
{
//Do something
}
}
}
void LoadRoute()
{
var filePath = NSBundle.MainBundle.PathForResource("route", "csv", "os4Maps","");
var fileContents = System.IO.File.ReadAllText(filePath);
var pointStrings = fileContents.Split('\n');
MKMapPoint northEastPoint = new MKMapPoint(), southWestPoint = new MKMapPoint();
var pointArr = new List<MKMapPoint>();
var coordArr = new List<CLLocationCoordinate2D>();
// start with the widest possible viewport
var tl = new CLLocationCoordinate2D (-90, 180);
// top left
var br = new CLLocationCoordinate2D (90, -180);
foreach (var s in pointStrings)
{
string[] latlonArr = s.Split(',');
double latitude = Convert.ToDouble(latlonArr[0]);
double longitude = Convert.ToDouble(latlonArr[1]);
CLLocationCoordinate2D coordinate = new CLLocationCoordinate2D (latitude, longitude);
// narrow the viewport bit-by-bit
tl.Longitude = Math.Min (tl.Longitude, coordinate.Longitude);
tl.Latitude = Math.Max (tl.Latitude, coordinate.Latitude);
br.Longitude = Math.Max (br.Longitude, coordinate.Longitude);
br.Latitude = Math.Min (br.Latitude, coordinate.Latitude);
coordArr.Add(coordinate);
// Can't find MonoTouch **MKMapPointForCoordinate**
// MKMapPoint point = ???????? (coordinate);
// if (northEastPoint.X == 0 & northEastPoint.Y == 0)
// {
// Debug.WriteLine("First Point: {0},{1}",point.X, point.Y);
// northEastPoint = point;
// southWestPoint = point;
// }
// else
// {
// if (point.X > northEastPoint.X)
// northEastPoint.X = point.X;
// if(point.Y > northEastPoint.Y)
// northEastPoint.Y = point.Y;
// if (point.X < southWestPoint.X)
// southWestPoint.X = point.X;
// if (point.Y < southWestPoint.Y)
// southWestPoint.Y = point.Y;
// }
// pointArr.Add(point);
}
// Can't use MKMapRect without the **MKMapPointForCoordinate**
//_routeRect = new MKMapRect (southWestPoint.X, southWestPoint.Y, northEastPoint.X - southWestPoint.X, northEastPoint.Y - southWestPoint.Y);
//Debug.WriteLine("RouteRect: {0},{1};{2},{3}", _routeRect.Origin.X, _routeRect.Origin.Y, _routeRect.Size.Width, _routeRect.Size.Height);
CLLocationCoordinate2D[] clar = coordArr.ToArray();
RouteLine = MKPolyline.FromCoordinates (clar);
// divide the range by two to get the center
var center = new CLLocationCoordinate2D { Latitude = tl.Latitude - (tl.Latitude - br.Latitude) * 0.5, Longitude = tl.Longitude + (br.Longitude - tl.Longitude) * 0.5 };
// calculate the span, with 20% margin so pins aren't on the edge
var span = new MKCoordinateSpan { LatitudeDelta = Math.Abs (tl.Latitude - br.Latitude) * 1.2, LongitudeDelta = Math.Abs (br.Longitude - tl.Longitude) * 1.2 };
RouteRegion = new MKCoordinateRegion { Center = center, Span = span };
}
public static CLLocationCoordinate2D ToCLLocationCoordinate(this MKMapPoint mapPoint)
{
return(new CLLocationCoordinate2D(mapPoint.X, mapPoint.Y));
}
// Two points in rectangular co-ordinate system create a rectange
static EastSouthDistance FetchRect (MKMapPoint fromAnchorMKPoint, MKMapPoint toPoint)
{
double latitude = MKMapPoint.ToCoordinate (fromAnchorMKPoint).Latitude;
nfloat metersPerMapPoint = (nfloat)MKGeometry.MetersPerMapPointAtLatitude (latitude);
var eastSouthDistance = new EastSouthDistance {
East = (nfloat)(toPoint.X - fromAnchorMKPoint.X) * metersPerMapPoint,
South = (nfloat)(toPoint.Y - fromAnchorMKPoint.Y) * metersPerMapPoint
};
return eastSouthDistance;
}
