public static double GetMapViewportScale(this XamGeographicMap geoMap)
{
//var mapSizeScale = System.Math.Min(geoMap.ViewportRect.Width, geoMap.ViewportRect.Height);
var mapSizeScale = System.Math.Max(geoMap.ViewportRect.Width, geoMap.ViewportRect.Height);
return(mapSizeScale);
}
public static void EnableSeriesMouseDoubleClick(this XamGeographicMap geoMap, bool isEnabled = true)
{
IsSeriesMouseDoubleClickTracking = isEnabled;
if (IsSeriesMouseDoubleClickTracking)
{
if (geoMap != null)
{
geoMap.SeriesMouseLeftButtonDown += OnSeriesMouseLeftButtomDown;
}
if (geoMap != null)
{
geoMap.SeriesMouseLeftButtonUp += OnSeriesMouseLeftButtonUp;
}
//if (geoMap != null) geoMap.SeriesMouseMove += OnSeriesMouseMove;
SeriesMouseDoubleClickTimer.Start();
}
else
{
SeriesMouseDoubleClickTimer.Stop();
if (geoMap != null)
{
geoMap.SeriesMouseLeftButtonDown -= OnSeriesMouseLeftButtomDown;
}
if (geoMap != null)
{
geoMap.SeriesMouseLeftButtonUp -= OnSeriesMouseLeftButtonUp;
}
//if (geoMap != null) geoMap.SeriesMouseMove -= OnSeriesMouseMove;
}
}
public static double GetMapZoomScale(this XamGeographicMap geoMap)
{
//var mapZoomScale = System.Math.Min(geoMap.ActualWindowScaleVertical, geoMap.ActualWindowScaleHorizontal);
var mapZoomScale = geoMap.ActualWindowScale;
return(mapZoomScale);
}
public static GeoImagerySource GetGeoImagerySource(this XamGeographicMap geoMap)
{
var geoImagerySource = GeoImagerySource.OpenStreetMapImagery;
var geoMapImagery = geoMap.BackgroundContent as GeographicMapImagery;
if (geoMapImagery is MapQuestStreetImagery || geoMapImagery is MapQuestSatelliteImagery)
{
geoImagerySource = GeoImagerySource.MapQuestImagery;
}
else if (geoMapImagery is BingMapsMapImagery)
{
geoImagerySource = GeoImagerySource.BingMapsImagery;
}
else if (geoMapImagery is ArcGISOnlineMapImagery)
{
geoImagerySource = GeoImagerySource.EsriMapImagery;
}
else //if (geoMapImagery is OpenStreetMapImagery)
{
geoImagerySource = GeoImagerySource.OpenStreetMapImagery;
}
return(geoImagerySource);
}
public static double GetScaledLatitude(this XamGeographicMap geoMap, double geoLatitude)
{
var yParams = geoMap.GetLatitudeScaler();
var scaledValue = geoMap.YAxis.GetScaledValue(geoLatitude, yParams);
return(scaledValue);
}
public static void EnableMouseWheelZoomOnMapHover(this XamGeographicMap geoMap)
{
geoMap.MouseEnter += (o, e) =>
{
geoMap.Focus();
};
}
public static ScalerParams GetLatitudeScaler(this XamGeographicMap geoMap)
{
var yaxis = geoMap.YAxis;
var yParams = new ScalerParams(_unitRect, geoMap.ViewportRect, yaxis.IsInverted);
yParams.EffectiveViewportRect = geoMap.EffectiveViewport;
return(yParams);
}
public static ScalerParams GetLongitudeScaler(this XamGeographicMap geoMap)
{
var xaxis = geoMap.XAxis;
var xParams = new ScalerParams(_unitRect, geoMap.ViewportRect, xaxis.IsInverted);
xParams.EffectiveViewportRect = geoMap.EffectiveViewport;
return(xParams);
}
internal static void LoadMapImagerySettings(this XamGeographicMap geoMap)
{
if (geoMap.BackgroundContent is GeographicMapImagery)
{
(geoMap.BackgroundContent as GeographicMapImagery).LoadMapImagerySettings();
}
// MapImagerySettings = new GeoMapImagerySettings(geoMap.BackgroundContent as GeographicMapImagery);
}
public static Point GetWindowCenterPoint(this XamGeographicMap geoMap)
{
var rect = geoMap.WindowRect;
double x = rect.X + (rect.Width / 2);
double y = rect.Y + (rect.Height / 2);
return(rect.Center()); // new Point(x, y);
}
/// <summary>
/// Navigates the <see cref="XamGeographicMap"/> in South direction by specified pan factor - percentage of the current window's height
/// </summary>
public static void NavigateSouth(this XamGeographicMap geoMap, double panScaleFactor = GeoMapGlobals.MapPanScaleFactor)
{
Rect window = geoMap.WindowRect;
double panScale = window.Width * panScaleFactor;
window.Y = System.Math.Min(1.0 - window.Height, window.Y + panScale);
geoMap.NavigateTo(window);
}
/// <summary>
/// Navigates the <see cref="XamGeographicMap"/> in North direction by specified pan factor - percentage of the current window's height
/// </summary>
public static void NavigateNorth(this XamGeographicMap geoMap, double panScaleFactor = GeoMapGlobals.MapPanScaleFactor)
{
Rect window = geoMap.WindowRect;
double panScale = window.Width * panScaleFactor;
window.Y = System.Math.Max(0.0, window.Y - panScale);
geoMap.NavigateTo(window);
}
public static void ZoomMapToRegion(this XamGeographicMap geoMap, GeoRect region, TimeSpan zoomDuration)
{
Rect currentWindowRect = geoMap.WindowRect;
//GeoRegion geodeticGeoRegion = region;
var winRect = geoMap.GetZoomFromGeographic(region.ToRect());
//GeoRegion cartesianGeoRegion = ProjectMapRegion(geodeticGeoRegion, map);
//MapWindowRect = cartesianGeoRegion.ToRect();
var dTL = geoMap.WindowRect.TopLeft().DistanceVector(winRect.TopLeft());
var dTR = geoMap.WindowRect.TopRight().DistanceVector(winRect.TopRight());
var dBR = geoMap.WindowRect.BottomRight().DistanceVector(winRect.BottomRight());
var dBL = geoMap.WindowRect.BottomLeft().DistanceVector(winRect.BottomLeft());
var StartTime = DateTime.MinValue;
//var zoomInterval = zoomDuration.TotalMilliseconds / 2000.0;
var zoomInterval = zoomDuration.TotalMilliseconds / 2000.0;
var counter = 0;
var timer = new DispatcherTimer {
Interval = TimeSpan.FromMilliseconds(10)
};
timer.Tick += (o, e) =>
{
if (StartTime == DateTime.MinValue)
{
StartTime = DateTime.Now;
}
double tick = (DateTime.Now - StartTime).Ticks / TimeSpan.TicksPerMillisecond;
double duration = zoomDuration.TotalMilliseconds;
var factor = 50.0;
//TODO add logic for smooth transition between map's window Rect
//double lin = duration > 1.0 ? MathUtil.Clamp(tick / duration, 0.0, 1.0) : 1.0;
//var tLog = Math.Log(1.0 + factor * Math.E / (Math.E - 1.0));
//var trig = 0.5 - 0.5 * Math.Cos(Math.PI * factor);
//System.Diagnostics.Debug.WriteLine(" log " + tLog + " tri " + trig);
var top = geoMap.WindowRect.Top + (dTL.Y / factor);
var left = geoMap.WindowRect.Left + (dTL.X / factor);
var bottom = geoMap.WindowRect.Bottom + (dBR.Y / factor);
var right = geoMap.WindowRect.Right + (dBR.X / factor);
counter++;
var rect = new Rect(new Point(left, top), new Point(right, bottom));
if (counter > factor || winRect.Contains(rect))
{
((DispatcherTimer)o).Stop();
}
geoMap.WindowRect = rect;
};
timer.Start();
}
public static Point GetScaledLocation(this XamGeographicMap geoMap, GeoLocation geoLocation)
{
// init appropriate axis scaler parameters
var x = geoMap.GetScaledLongitude(geoLocation.Longitude);
var y = geoMap.GetScaledLongitude(geoLocation.Latitude);
var scaledLocation = new Point(x, y);
return(scaledLocation);
}
/// <summary>
/// Navigates the <see cref="XamGeographicMap"/> to specified window view rectangle
/// </summary>
public static void NavigateTo(this XamGeographicMap geoMap, Rect winRect)
{
if (geoMap == null)
{
return;
}
geoMap.WindowRect = winRect;
}
public void InitializeMap(XamGeographicMap map)
{
if (map == null)
{
throw new MapCartesianException("GeographicMap cannot be null when initializing MapCartesianProjection");
}
GeographicMap = map;
}
public static Vector GetMapDistance(this XamGeographicMap geoMap, Point geoPoint1, Point geoPoint2)
{
var mapPoint1 = geoMap.GetMapPosition(geoPoint1);
var mapPoint2 = geoMap.GetMapPosition(geoPoint2);
var distanceX = System.Math.Abs(mapPoint1.X - mapPoint2.X);
var distanceY = System.Math.Abs(mapPoint1.Y - mapPoint2.Y);
return(new Vector(distanceX, distanceY));
}
/// <summary>
/// Loads geo-imagery from specified imagery view and preserves settings of XamGeographicMap's BackgroundContent
/// <remarks>Supported imagery views: <see cref="OpenStreetMapImageryView"/>, <see cref="BingMapsImageryView"/>,
/// <see cref="EsriMapImageryView"/>, and <see cref="MapQuestImageryView"/></remarks>
/// </summary>
public static void LoadGeoImagery(this XamGeographicMap geoMap, GeoImageryViewModel imageryViewModel)
{
if (geoMap == null)
{
DebugManager.LogWarning("GeoMapImager cannot load geo-imagery when XamGeographicMap is null"); return;
}
GeoMapImager.GeoMap = geoMap;
geoMap.SaveMapImagerySettings();
geoMap.BackgroundContent = imageryViewModel.GetGeographicMapImagery();
geoMap.LoadMapImagerySettings();
}
///// <summary>
///// Loads geo-imagery from specified imagery view and preserves settings of GeographicTileSeries' TileImagery
///// <remarks>Supported imagery views: <see cref="OpenStreetMapImageryView"/>, <see cref="BingMapsImageryView"/>,
///// <see cref="EsriMapImageryView"/>, and <see cref="MapQuestImageryView"/></remarks>
///// </summary>
//public static void LoadGeoImagery(this GeographicTileSeries geoTileSeries, GeoImageryViewModel imageryViewModel)
//{
// if (geoTileSeries == null)
// {
// DebugManager.LogWarning("GeoMapImager cannot load geo-imagery when GeographicTileSeries is null"); return;
// }
// geoTileSeries.TileImagery.SaveMapImagerySettings();
// geoTileSeries.TileImagery = imageryViewModel.GetGeographicMapImagery();
// geoTileSeries.TileImagery.LoadMapImagerySettings();
//}
//private static bool IsFirstKeyReservedWarning = true;
public static void LoadGeoImagery22(this XamGeographicMap geoMap, GeoImageryViewModel imageryViewModel)
{
if (geoMap == null)
{
DebugManager.LogWarning("22 XamGeographicMap cannot be null"); return;
}
GeoMapImager.GeoMap = geoMap;
if (geoMap.BackgroundContent is GeographicMapImagery)
{
(geoMap.BackgroundContent as GeographicMapImagery).SaveMapImagerySettings();
}
}
public void InitializeMap(XamGeographicMap geoMap)
{
this.Map = geoMap;
this.Map.BackgroundContent.Opacity = 0;
this.Map.IncreaseImageryZoomMaxLevel();
this.Map.NavigateTo(GeoRegions.WorldNonAntarcticRegion);
this.Map.Series.Clear();
foreach (var mapLayer in MapLayers)
{
AddGeoMapLayer(mapLayer);
}
this.IsMapInitialized = true;
}
/// <summary>
/// Navigates the <see cref="XamGeographicMap"/> to specified geographic region of the world
/// </summary>
/// <param name="geoMap">an instance of XamGeographicMap</param>
/// <param name="geoRegion">a geographic region of the world</param>
public static void NavigateTo(this XamGeographicMap geoMap, GeoRegion geoRegion)
{
var windowRect = geoMap.GetZoomFromGeographic(geoRegion.NorthWest.ToPoint(), geoRegion.SouthEast.ToPoint());
// conversion of geographic region to window rect works when XamGeographicMap view was initialized
if (windowRect == new Rect(0, 0, 1, 1))
{
geoMap.GridAreaRectChanged += (o, e) =>
{
windowRect = geoMap.GetZoomFromGeographic(geoRegion.NorthWest.ToPoint(), geoRegion.SouthEast.ToPoint());
geoMap.WindowRect = windowRect;
};
}
else
{
geoMap.WindowRect = windowRect;
}
}
/// <summary>
/// Zoom in the <see cref="XamGeographicMap"/> by specified zoom factor - percentage of the current window view rectangle
/// </summary>
public static void ZoomIn(this XamGeographicMap geoMap, double zoomScaleFactor = GeoMapGlobals.MapZoomScaleFactor)
{
Rect window = geoMap.WindowRect;
double zoomScaleH = window.Height * zoomScaleFactor;
double zoomScaleW = window.Width * zoomScaleFactor;
//const double zoomWindowMin = 0.00005;
window.Width = System.Math.Max(GeoMapGlobals.MapWindowMinZoom, window.Width - (2 * zoomScaleW));
window.Height = System.Math.Max(GeoMapGlobals.MapWindowMinZoom, window.Height - (2 * zoomScaleH));
//if (window.Width > GeoMapAdapter.MapWindowMinZoom)
window.X = System.Math.Min(1.0, window.X + zoomScaleW);
//if (window.Height > GeoMapAdapter.MapWindowMinZoom)
window.Y = System.Math.Min(1.0, window.Y + zoomScaleH);
geoMap.NavigateTo(window);
}
/// <summary>
/// Zoom out the <see cref="XamGeographicMap"/> by specified zoom factor - percentage of the current window view rectangle
/// </summary>
public static void ZoomOut(this XamGeographicMap geoMap, double zoomScaleFactor = GeoMapGlobals.MapZoomScaleFactor)
{
Rect window = geoMap.WindowRect;
double zoomScaleH = window.Height * zoomScaleFactor;
double zoomScaleW = window.Width * zoomScaleFactor;
//const double zoomWindowMax = 1.0;
window.Width = System.Math.Min(GeoMapGlobals.MapWindowMaxZoom, window.Width + (2 * zoomScaleW));
window.Height = System.Math.Min(GeoMapGlobals.MapWindowMaxZoom, window.Height + (2 * zoomScaleH));
//if (window.Width < GeoMapAdapter.MapWindowMaxZoo)
window.X = System.Math.Max(0.0, window.X - zoomScaleW);
//if (window.Height < GeoMapAdapter.MapWindowMaxZoo)
window.Y = System.Math.Max(0.0, window.Y - zoomScaleH);
geoMap.NavigateTo(window);
}
//TODO use GeoCalc
//public static Vector GetGeoDistance(this XamGeographicMap geoMap, Point mousePoint1, Point mousePoint2)
//{
// var geoPoint1 = geoMap.GetGeoPoint(mousePoint1);
// var geoPoint2 = geoMap.GetGeoPoint(mousePoint2);
// var distanceX = System.Math.Abs(geoPoint1.X - geoPoint2.X);
// var distanceY = System.Math.Abs(geoPoint1.Y - geoPoint2.Y);
// return new Vector(distanceX, distanceY);
//}
//TODO cleanup
//public static double GetGeoDistanceX(this XamGeographicMap geoMap, Point mousePoint1, Point mousePoint2)
//{
// return geoMap.GetGeoDistance(mousePoint1, mousePoint2).X;
//}
//public static double GetGeoDistanceY(this XamGeographicMap geoMap, Point mousePoint1, Point mousePoint2)
//{
// return geoMap.GetGeoDistance(mousePoint1, mousePoint2).Y;
//}
//public static double GetGeoDistanceX(this XamGeographicMap geoMap, double mouseX1, double mouseX2)
//{
// return geoMap.GetGeoDistanceX(new Point(mouseX1, 0), new Point(mouseX2, 0));
//}
//public static double GetGeoDistanceY(this XamGeographicMap geoMap, double mouseY1, double mouseY2)
//{
// return geoMap.GetGeoDistanceY(new Point(0, mouseY1), new Point(0, mouseY2));
//}
#endregion
#region Calculation Methods for Map Postions
public static Point GetMapPosition(this XamGeographicMap geoMap, Point geoPoint)
{
return(geoMap.GetWindowPoint(geoPoint));
//var xAxis = geoMap.XAxis;
//var yAxis = geoMap.YAxis;
//var viewport = new Rect(0, 0, geoMap.ActualWidth, geoMap.ActualHeight);
//var window = geoMap.WindowRect;
//bool isInverted = xAxis.IsInverted;
//var param = new ScalerParams(window, viewport, isInverted);
//param.EffectiveViewportRect = geoMap.EffectiveViewport;
//var longitude = xAxis.GetScaledValue(geoPoint.X, param);
//isInverted = yAxis.IsInverted;
//param = new ScalerParams(window, viewport, isInverted);
//param.EffectiveViewportRect = geoMap.EffectiveViewport; //added
//var latitude = yAxis.GetScaledValue(geoPoint.Y, param);
//return new Point(longitude, latitude);
}
/// <summary>
/// Calculates geographic location of mouse cursor over the XamGeographicMap
/// </summary>
public static GeoLocation GetGeoLocation(this XamGeographicMap geoMap, Point mousePosition)
{
var geoPoint = geoMap.GetGeographicPoint(mousePosition);
return(new GeoLocation(geoPoint));
//var xAxis = geoMap.XAxis;
//var yAxis = geoMap.YAxis;
//var viewport = new Rect(0, 0, geoMap.ActualWidth, geoMap.ActualHeight);
//var window = geoMap.WindowRect;
//bool isInverted = xAxis.IsInverted;
//var param = new ScalerParams(window, viewport, isInverted);
//param.EffectiveViewportRect = geoMap.EffectiveViewport;
//var longitude = xAxis.GetUnscaledValue(mousePosition.X, param);
//isInverted = yAxis.IsInverted;
//param = new ScalerParams(window, viewport, isInverted);
//var latitude = yAxis.GetUnscaledValue(mousePosition.Y, param);
//return new GeoLocation(longitude, latitude);
}
/// <summary>
/// Loads geo-imagery from specified imagery source
/// </summary>
public static void LoadGeoImagery(this XamGeographicMap geoMap, GeoImagerySource imagerySource)
{
if (imagerySource == GeoImagerySource.BingMapsImagery)
{
geoMap.LoadGeoImagery(IGExtensions.Common.Maps.Imagery.BingMapsImageryStyle.StreetMapStyle);
}
else if (imagerySource == GeoImagerySource.MapQuestImagery)
{
geoMap.LoadGeoImagery(MapQuestImageryStyle.StreetMapStyle);
}
else if (imagerySource == GeoImagerySource.EsriMapImagery)
{
geoMap.LoadGeoImagery(EsriMapImageryStyle.WorldTopographicMap);
}
else if (imagerySource == GeoImagerySource.OpenStreetMapImagery)
{
geoMap.LoadGeoImagery(new OpenStreetMapImageryView());
}
else
{
System.Diagnostics.Debug.WriteLine("WARNING: Imagery source " + imagerySource + " is not supported by IGExtensions library.");
}
}
public static GeoImageryViewModel GetGeoImageryViewModel(this XamGeographicMap geoMap)
{
var geoImagerySource = geoMap.GetGeoImagerySource();
GeoImageryViewModel geoImageryView = new OpenStreetMapImageryView();
if (geoImagerySource == GeoImagerySource.OpenStreetMapImagery)
{
geoImageryView = new OpenStreetMapImageryView();
}
//TODO: might require refactoring based on how MapQuestImagery is implemented in XamGeoMap
else if (geoImagerySource == GeoImagerySource.MapQuestImagery)
{
if (geoMap.BackgroundContent is MapQuestStreetImagery)
{
geoImageryView = new MapQuestStreetImageryView();
}
else // if(geoMap.BackgroundContent is MapQuestStreetImagery)
{
geoImageryView = new MapQuestSatelliteImageryView();
}
}
else if (geoImagerySource == GeoImagerySource.BingMapsImagery)
{
var geoImagery = geoMap.BackgroundContent as BingMapsMapImagery;
var style = geoImagery.GetImageryStyle();
geoImageryView = new BingMapsImageryView(style);
}
else if (geoImagerySource == GeoImagerySource.EsriMapImagery)
{
var geoImagery = geoMap.BackgroundContent as ArcGISOnlineMapImagery;
//var style = geoImagery.GetImageryStyle();
//geoImageryView = new BingMapsImageryView(style);
//TODO: add ESRI
}
return(geoImageryView);
}
/// <summary>
/// Loads geo-imagery from specified imagery style of BingMaps
/// </summary>
public static void LoadGeoImagery(this XamGeographicMap geoMap, Infragistics.Controls.Maps.BingMapsImageryStyle imageryStyle)
{
var geoImageryStyle = (IGExtensions.Common.Maps.Imagery.BingMapsImageryStyle)imageryStyle;
geoMap.LoadGeoImagery(new BingMapsImageryView(geoImageryStyle));
}
/// <summary>
/// Loads geo-imagery from specified imagery style of ESRI
/// </summary>
public static void LoadGeoImagery(this XamGeographicMap geoMap, EsriMapImageryStyle imageryStyle)
{
geoMap.LoadGeoImagery(new EsriMapImageryView(imageryStyle));
}
/// <summary>
/// Loads geo-imagery from specified imagery style of MapQuest
/// </summary>
public static void LoadGeoImagery(this XamGeographicMap geoMap, MapQuestImageryStyle imageryStyle)
{
geoMap.LoadGeoImagery(new MapQuestImageryView(imageryStyle));
}
