private void RenderingSceneAsync(MapRenderingScene scene)
{
Task.Factory.StartNew(state =>
{
var taskScene = (MapRenderingScene)state;
var context = new RenderContext(SceneSize);
_renderer.Render(context, Map, CreateView(taskScene),
(float)Map.Projection.ToZoomFactor(taskScene.Zoom));
var image = context.BuildScene();
image.Freeze();
taskScene.SceneImage = image;
Logging.Log.TraceEvent("Wpf.MapSceneManager.Action", TraceEventType.Information,
$"RenderingSceneAsync rendered image {taskScene.Center} {taskScene.Zoom} {taskScene.Tilt}");
return(taskScene);
}, scene).ContinueWith(t =>
{
var currentScene = t.Result;
var last = GetLastScene();
if (last == null || last == currentScene)
{
Logging.Log.TraceEvent("Wpf.MapSceneManager.Action", TraceEventType.Information,
$"RenderingSceneAsync OnRenderScene {currentScene.Center} {currentScene.Zoom} {currentScene.Tilt}");
OnRenderScene(currentScene);
}
else
{
Logging.Log.TraceEvent("Wpf.MapSceneManager.Action", TraceEventType.Information,
$"RenderingSceneAsync nofting OnRenderScene {currentScene.Center} {currentScene.Zoom} {currentScene.Tilt}");
}
});
}
protected override void OnRender(DrawingContext drawingContext)
{
base.OnRender(drawingContext);
var ticksBefore = DateTime.Now.Ticks;
MapRenderingScene scene = null;
lock (_renderingScenesLock)
{
if (_renderingScenes.Count > 0)
{
scene = _renderingScenes.Pop();
}
}
if (scene != null)
{
drawingContext.PushClip(new RectangleGeometry(new Rect(RenderSize)));
RenderScene(drawingContext, RenderSize, scene);
drawingContext.Pop();
}
else
{
drawingContext.DrawRectangle(Background, null, new Rect(RenderSize));
}
var ticksAfter = DateTime.Now.Ticks;
var message = $"Rendering took: {(new TimeSpan(ticksAfter - ticksBefore).TotalMilliseconds)}ms @ zoom level {MapZoom}";
Logging.Log.TraceEvent("Wpf.MapControl.RenderPerfomance", TraceEventType.Information, message);
}
public void PreviewComplete()
{
if (_previewScene != null)
{
Map.Resume();
var newScene = new MapRenderingScene(_previewScene.Center, _previewScene.Zoom, _previewScene.Tilt)
{
PreviousScene = GetLastScene()
};
lock (_historyLock)
{
_renderedScenes.Enqueue(newScene);
while (_renderedScenes.Count > _historyCapacity)
{
_renderedScenes.Dequeue();
}
}
if (SceneSize.Width > 0 && SceneSize.Height > 0)
{
var view = CreateView(newScene);
Map.ViewChanged((float)Map.Projection.ToZoomFactor(newScene.Zoom), newScene.Center, view,
view);
Logging.Log.TraceEvent("Wpf.MapSceneManager.Action", TraceEventType.Information, $"PreviewComplete begin rendering {newScene.Center} {newScene.Zoom} {newScene.Tilt}");
RenderingSceneAsync(newScene);
}
_previewScene = null;
IsReady = true;
Logging.Log.TraceEvent("Wpf.MapSceneManager.Action", TraceEventType.Information, $"PreviewComplete {newScene.Center} {newScene.Zoom} {newScene.Tilt}");
}
}
public GeoCoordinate ToGeoCoordinates(Point point, MapRenderingScene scene)
{
var sceneView = CreateView(scene);
double x, y;
var fromMatrix = sceneView.CreateFromViewPort(SceneSize.Width, SceneSize.Height);
fromMatrix.Apply(point.X, point.Y, out x, out y);
return(Map.Projection.ToGeoCoordinates(x, y));
}
public MapSceneManager(int historyCapacity = 5)
{
_historyCapacity = historyCapacity;
_renderedScenes = new Queue <MapRenderingScene>();
_previewScene = null;
_renderer = new MapRenderer <RenderContext>(new DrawingRenderer2D());
IsReady = true;
}
public View2D CreateView(MapRenderingScene scene)
{
var zoomFactor = Map.Projection.ToZoomFactor(scene.Zoom);
var sceneCenter = Map.Projection.ToPixel(scene.Center.Latitude, scene.Center.Longitude);
var invertY = (true != !Map.Projection.DirectionY);
return(View2D.CreateFrom(sceneCenter[0], sceneCenter[1],
SceneSize.Width, SceneSize.Height, zoomFactor,
false, invertY, scene.Tilt));
}
public Point ToPixels(GeoCoordinate coordinate, MapRenderingScene scene)
{
var sceneView = CreateView(scene);
var projectionPoint = Map.Projection.ToPixel(coordinate);
double x, y;
var fromMatrix = sceneView.CreateToViewPort(SceneSize.Width, SceneSize.Height);
fromMatrix.Apply(projectionPoint[0], projectionPoint[1], out x, out y);
return(new Point(x, y));
}
private void RenderScene(DrawingContext context, Size renderSize, MapRenderingScene scene)
{
var renderRect = new Rect(renderSize);
if (scene.SceneImage == null && scene.PreviousScene?.SceneImage != null)
{
var newCenter = _mapSceneManager.ToPixels(scene.Center, scene.PreviousScene);
var oldCenter = _mapSceneManager.ToPixels(scene.PreviousScene.Center, scene.PreviousScene);
var offsetX = oldCenter.X - newCenter.X;
var offsetY = oldCenter.Y - newCenter.Y;
var scale = _mapSceneManager.Map.Projection.ToZoomFactor(scene.Zoom) / _mapSceneManager.Map.Projection.ToZoomFactor(scene.PreviousScene.Zoom);
var offsetXScale = (scene.PreviousScene.SceneImage.Width - renderSize.Width * scale) / 2 / scale;
var offsetYScale = (scene.PreviousScene.SceneImage.Height - renderSize.Height * scale) / 2 / scale;
context.PushTransform(new ScaleTransform(scale, scale));
context.PushTransform(new TranslateTransform(offsetXScale, offsetYScale));
context.PushTransform(new TranslateTransform(offsetX, offsetY));
context.DrawImage(scene.PreviousScene.SceneImage, renderRect);
context.Pop();
context.Pop();
context.Pop();
}
if (scene.SceneImage != null)
{
//context.PushOpacity(1, new DoubleAnimation(0, 1, new Duration(TimeSpan.FromMilliseconds(100))).CreateClock());
//context.DrawRectangle(Background, null, renderRect);
context.DrawImage(scene.SceneImage, renderRect);
//context.Pop();
}
//else
//{
// context.DrawRectangle(Background, null, renderRect);
//}
//if (scene.SceneImage == null)
//{
// if (scene.PreviousScene != null)
// {
// if (scene.PreviousScene.SceneImage == null)
// {
// Console.WriteLine("RenderScene scene null");
// }
// }
// else
// {
// Console.WriteLine("RenderScene scene null");
// }
//}
}
public void Preview(GeoCoordinate cener, double zoom, Degree tilt)
{
if (Map != null)
{
Logging.Log.TraceEvent("Wpf.MapSceneManager.Action", TraceEventType.Information, $"Preview {cener} {zoom} {tilt}");
IsReady = false;
Map.Pause();
_previewScene = new MapRenderingScene(cener, zoom, tilt)
{
PreviousScene = GetLastScene()
};
OnRenderScene(_previewScene);
}
}
private void OnRenderScene(MapRenderingScene scene)
{
if (scene.PreviousScene?.SceneImage != null || scene.SceneImage != null)
{
lock (_renderingScenesLock)
{
//Console.WriteLine("_renderingScenes count = "+_renderingScenes.Count);
_renderingScenes.Push(scene);
Logging.Log.TraceEvent("Wpf.MapControl.Action", TraceEventType.Information,
$"OnRenderScene Push scene {scene.Center} {scene.Zoom} {scene.Tilt}");
}
Refresh();
}
}
protected void OnRenderScene(MapRenderingScene scene)
{
var renderScene = RenderScene;
renderScene?.Invoke(scene);
}
private void AdjustMapScene()
{
var suspending = !_isSuspendNotifyMapViewChanged;
if (suspending)
{
SuspendNotifyMapViewChanged();
}
if (MapZoom < MapMinZoomLevel)
{
MapZoom = MapMinZoomLevel;
}
if (MapZoom > MapMaxZoomLevel)
{
MapZoom = MapMaxZoomLevel;
}
if (RenderSize.Width > 0 && RenderSize.Height > 0)
{
var box = MapBoundingBox ?? MaxMapBoundingBox;
var scene = new MapRenderingScene(MapCenter, MapZoom, MapTilt);
var geoLeftTop = _mapSceneManager.ToGeoCoordinates(new Point(0, RenderSize.Height), scene);
var geoRightBottom = _mapSceneManager.ToGeoCoordinates(new Point(RenderSize.Width, 0), scene);
var lat = MapCenter.Latitude;
var lon = MapCenter.Longitude;
var width = geoRightBottom.Longitude - geoLeftTop.Longitude;
var height = geoRightBottom.Latitude - geoLeftTop.Latitude;
if (width < box.DeltaLon)
{
if (geoLeftTop.Longitude < box.MinLon)
{
lon += box.MinLon - geoLeftTop.Longitude;
}
if (geoRightBottom.Longitude > box.MaxLon)
{
lon += box.MaxLon - geoRightBottom.Longitude;
}
}
else
{
lon = box.Center.Longitude;
}
if (height < box.DeltaLat)
{
if (geoLeftTop.Latitude < box.MinLat)
{
lat += box.MinLat - geoLeftTop.Latitude;
}
if (geoRightBottom.Latitude > box.MaxLat)
{
lat += box.MaxLat - geoRightBottom.Latitude;
}
}
else
{
lat = box.Center.Latitude;
}
MapCenter = new GeoCoordinate(lat, lon);
}
if (suspending)
{
ResumeNotifyMapViewChanged(false);
}
}
