public void RenderPointOfInterestCircle(RenderContext renderContext, float radius, IPaint fill, IPaint stroke, int level, PointOfInterest poi)
{
Point poiPosition = MercatorProjection.GetPixelRelativeToTile(poi.Position, renderContext.rendererJob.tile);
renderContext.AddToCurrentDrawingLayer(level, new ShapePaintContainer(new CircleContainer(poiPosition, radius), stroke));
renderContext.AddToCurrentDrawingLayer(level, new ShapePaintContainer(new CircleContainer(poiPosition, radius), fill));
}
private void RenderWaterBackground(RenderContext renderContext)
{
renderContext.DrawingLayers = (sbyte)0;
Point[] coordinates = GetTilePixelCoordinates(renderContext.rendererJob.tile.TileSize);
PolylineContainer way = new PolylineContainer(coordinates, renderContext.rendererJob.tile, new List <Tag>()
{
TAG_NATURAL_WATER
});
renderContext.renderTheme.MatchClosedWay(this, renderContext, way);
}
/// <summary>
/// Draws a bitmap just with outside colour, used for bitmaps outside of map area. </summary>
/// <param name="renderContext"> the RenderContext </param>
/// <returns> bitmap drawn in single colour. </returns>
private ITileBitmap CreateBackgroundBitmap(RenderContext renderContext)
{
ITileBitmap bitmap = this.graphicFactory.CreateTileBitmap(renderContext.rendererJob.tile.TileSize, renderContext.rendererJob.hasAlpha);
renderContext.canvasRasterer.CanvasBitmap = bitmap;
if (!renderContext.rendererJob.hasAlpha)
{
renderContext.canvasRasterer.Fill(renderContext.renderTheme.MapBackgroundOutside);
}
return(bitmap);
}
private void RenderWay(RenderContext renderContext, PolylineContainer way)
{
renderContext.DrawingLayers = way.Layer;
if (way.ClosedWay)
{
renderContext.renderTheme.MatchClosedWay(this, renderContext, way);
}
else
{
renderContext.renderTheme.MatchLinearWay(this, renderContext, way);
}
}
internal virtual void DrawWays(RenderContext renderContext)
{
int levelsPerLayer = renderContext.ways[0].Count;
for (int layer = 0, layers = renderContext.ways.Count; layer < layers; ++layer)
{
IList <IList <ShapePaintContainer> > shapePaintContainers = renderContext.ways[layer];
for (int level = 0; level < levelsPerLayer; ++level)
{
IList <ShapePaintContainer> wayList = shapePaintContainers[level];
for (int index = wayList.Count - 1; index >= 0; --index)
{
DrawShapePaintContainer(wayList[index]);
}
}
}
}
private void ProcessReadMapData(RenderContext renderContext, MapReadResult mapReadResult)
{
if (mapReadResult == null)
{
return;
}
foreach (PointOfInterest pointOfInterest in mapReadResult.PointOfInterests)
{
RenderPointOfInterest(renderContext, pointOfInterest);
}
foreach (Way way in mapReadResult.Ways)
{
RenderWay(renderContext, new PolylineContainer(way, renderContext.rendererJob.tile));
}
if (mapReadResult.IsWater)
{
RenderWaterBackground(renderContext);
}
}
public void RenderWaySymbol(RenderContext renderContext, Display display, int priority, IBitmap symbol, float dy, bool alignCenter, bool repeat, float repeatGap, float repeatStart, bool rotate, PolylineContainer way)
{
WayDecorator.RenderSymbol(symbol, display, priority, dy, alignCenter, repeat, repeatGap, repeatStart, rotate, way.CoordinatesAbsolute, renderContext.labels);
}
public void RenderArea(RenderContext renderContext, IPaint fill, IPaint stroke, int level, PolylineContainer way)
{
renderContext.AddToCurrentDrawingLayer(level, new ShapePaintContainer(way, stroke));
renderContext.AddToCurrentDrawingLayer(level, new ShapePaintContainer(way, fill));
}
public void RenderAreaCaption(RenderContext renderContext, Display display, int priority, string caption, float horizontalOffset, float verticalOffset, IPaint fill, IPaint stroke, Position position, int maxTextWidth, PolylineContainer way)
{
Point centerPoint = way.CenterAbsolute.Offset(horizontalOffset, verticalOffset);
renderContext.labels.Add(this.graphicFactory.CreatePointTextContainer(centerPoint, display, priority, caption, fill, stroke, null, position, maxTextWidth));
}
private void RenderPointOfInterest(RenderContext renderContext, PointOfInterest pointOfInterest)
{
renderContext.DrawingLayers = pointOfInterest.Layer;
renderContext.renderTheme.MatchNode(this, renderContext, pointOfInterest);
}
private ISet <MapElementContainer> ProcessLabels(RenderContext renderContext)
{
// if we are drawing the labels per tile, we need to establish which tile-overlapping
// elements need to be drawn.
ISet <MapElementContainer> labelsToDraw = new HashSet <MapElementContainer>();
lock (tileDependencies)
{
// first we need to get the labels from the adjacent tiles if they have already been drawn
// as those overlapping items must also be drawn on the current tile. They must be drawn regardless
// of priority clashes as a part of them has alread been drawn.
ISet <Tile> neighbours = renderContext.rendererJob.tile.Neighbours;
ISet <MapElementContainer> undrawableElements = new HashSet <MapElementContainer>();
tileDependencies.AddTileInProgress(renderContext.rendererJob.tile);
for (var i = neighbours.Count - 1; i >= 0; i--)
{
Tile neighbour = neighbours.ElementAt(i);
if (tileDependencies.IsTileInProgress(neighbour) || tileCache.ContainsKey(renderContext.rendererJob.OtherTile(neighbour)))
{
// if a tile has already been drawn, the elements drawn that overlap onto the
// current tile should be in the tile dependencies, we add them to the labels that
// need to be drawn onto this tile. For the multi-threaded renderer we also need to take
// those tiles into account that are not yet in the TileCache: this is taken care of by the
// set of tilesInProgress inside the TileDependencies.
labelsToDraw.UnionWith(tileDependencies.GetOverlappingElements(neighbour, renderContext.rendererJob.tile));
// but we need to remove the labels for this tile that overlap onto a tile that has been drawn
foreach (MapElementContainer current in renderContext.labels)
{
if (current.Intersects(neighbour.BoundaryAbsolute))
{
undrawableElements.Add(current);
}
}
// since we already have the data from that tile, we do not need to get the data for
// it, so remove it from the neighbours list.
neighbours.Remove(neighbour);
}
else
{
tileDependencies.RemoveTileData(neighbour);
}
}
// now we remove the elements that overlap onto a drawn tile from the list of labels
// for this tile
foreach (var element in undrawableElements)
{
renderContext.labels.Remove(element);
}
// at this point we have two lists: one is the list of labels that must be drawn because
// they already overlap from other tiles. The second one is currentLabels that contains
// the elements on this tile that do not overlap onto a drawn tile. Now we sort this list and
// remove those elements that clash in this list already.
ICollection <MapElementContainer> currentElementsOrdered = LayerUtil.CollisionFreeOrdered(renderContext.labels);
// now we go through this list, ordered by priority, to see which can be drawn without clashing.
IEnumerator <MapElementContainer> currentMapElementsIterator = currentElementsOrdered.GetEnumerator();
while (currentMapElementsIterator.MoveNext())
{
MapElementContainer current = currentMapElementsIterator.Current;
foreach (MapElementContainer label in labelsToDraw)
{
if (label.ClashesWith(current))
{
break;
}
}
}
labelsToDraw.UnionWith(currentElementsOrdered);
// update dependencies, add to the dependencies list all the elements that overlap to the
// neighbouring tiles, first clearing out the cache for this relation.
foreach (Tile tile in neighbours)
{
tileDependencies.RemoveTileData(renderContext.rendererJob.tile, tile);
foreach (MapElementContainer element in labelsToDraw)
{
if (element.Intersects(tile.BoundaryAbsolute))
{
tileDependencies.AddOverlappingElement(renderContext.rendererJob.tile, tile, element);
}
}
}
}
return(labelsToDraw);
}
public void RenderWayText(RenderContext renderContext, Display display, int priority, string textKey, float dy, IPaint fill, IPaint stroke, PolylineContainer way)
{
WayDecorator.RenderText(way.Tile, textKey, display, priority, dy, fill, stroke, way.CoordinatesAbsolute, renderContext.labels);
}
internal virtual bool RenderBitmap(RenderContext renderContext)
{
return(!renderContext.renderTheme.HasMapBackgroundOutside() || this.mapDatabase.SupportsTile(renderContext.rendererJob.tile));
}
/// <summary>
/// Called when a job needs to be executed.
/// </summary>
/// <param name="rendererJob">
/// the job that should be executed. </param>
public virtual SKImage ExecuteJob(RendererJob rendererJob)
{
RenderTheme renderTheme;
try
{
// Wait until RenderTheme is ready
renderTheme = rendererJob.renderThemeFuture.Result;
}
catch (Exception e)
{
LOGGER.Fatal("Error to retrieve render theme from future", e);
return(null);
}
RenderContext renderContext = null;
try
{
renderContext = new RenderContext(renderTheme, rendererJob, new CanvasRasterer(graphicFactory));
renderContext.canvasRasterer.Canvas = graphicFactory.CreateCanvas(renderContext.rendererJob.tile.TileSize, renderContext.rendererJob.tile.TileSize);
if (RenderBitmap(renderContext))
{
if (this.mapDatabase != null)
{
MapReadResult mapReadResult = this.mapDatabase.ReadMapData(rendererJob.tile);
ProcessReadMapData(renderContext, mapReadResult);
}
if (!rendererJob.labelsOnly)
{
//bitmap = this.graphicFactory.CreateTileBitmap(renderContext.rendererJob.tile.TileSize, renderContext.rendererJob.hasAlpha);
//bitmap.Timestamp = rendererJob.mapDataStore.GetDataTimestamp(renderContext.rendererJob.tile);
//renderContext.canvasRasterer.CanvasBitmap = bitmap;
if (!rendererJob.hasAlpha && rendererJob.displayModel.BackgroundColor != renderContext.renderTheme.MapBackground)
{
renderContext.canvasRasterer.Fill(renderContext.renderTheme.MapBackground);
}
renderContext.canvasRasterer.DrawWays(renderContext);
}
if (renderLabels)
{
ISet <MapElementContainer> labelsToDraw = ProcessLabels(renderContext);
// now draw the ways and the labels
renderContext.canvasRasterer.DrawMapElements(labelsToDraw, renderContext.rendererJob.tile);
}
else
{
// store elements for this tile in the label cache
this.labelStore.StoreMapItems(renderContext.rendererJob.tile, renderContext.labels);
}
//if (!rendererJob.labelsOnly && renderContext.renderTheme.HasMapBackgroundOutside())
//{
// // blank out all areas outside of map
// Rectangle insideArea = this.mapDatabase.BoundingBox.GetPositionRelativeToTile(renderContext.rendererJob.tile);
// if (!rendererJob.hasAlpha)
// {
// //renderContext.canvasRasterer.FillOutsideAreas(renderContext.renderTheme.MapBackgroundOutside, insideArea);
// }
// else
// {
// //renderContext.canvasRasterer.FillOutsideAreas(Color.Transparent, insideArea);
// }
//}
return(((SkiaCanvas)renderContext.canvasRasterer.Canvas).Image);
}
// Draws a bitmap just with outside colour, used for bitmaps outside of map area.
if (!renderContext.rendererJob.hasAlpha)
{
//renderContext.canvasRasterer.Fill(renderContext.renderTheme.MapBackgroundOutside);
}
return(((SkiaCanvas)renderContext.canvasRasterer.Canvas).Image);
}
finally
{
if (renderContext != null)
{
renderContext.Destroy();
}
}
}
public void RenderWay(RenderContext renderContext, IPaint stroke, float dy, int level, PolylineContainer way)
{
renderContext.AddToCurrentDrawingLayer(level, new ShapePaintContainer(way, stroke, dy));
}
public void RenderPointOfInterestSymbol(RenderContext renderContext, Display display, int priority, IBitmap symbol, PointOfInterest poi)
{
Point poiPosition = MercatorProjection.GetPixelAbsolute(poi.Position, renderContext.rendererJob.tile.MapSize);
renderContext.labels.Add(new SymbolContainer(poiPosition, display, priority, symbol));
}
public void RenderAreaSymbol(RenderContext renderContext, Display display, int priority, IBitmap symbol, PolylineContainer way)
{
Point centerPosition = way.CenterAbsolute;
renderContext.labels.Add(new SymbolContainer(centerPosition, display, priority, symbol));
}
public void RenderPointOfInterestCaption(RenderContext renderContext, Display display, int priority, string caption, float horizontalOffset, float verticalOffset, IPaint fill, IPaint stroke, Position position, int maxTextWidth, PointOfInterest poi)
{
Point poiPosition = MercatorProjection.GetPixelAbsolute(poi.Position, renderContext.rendererJob.tile.MapSize);
renderContext.labels.Add(this.graphicFactory.CreatePointTextContainer(poiPosition.Offset(horizontalOffset, verticalOffset), display, priority, caption, fill, stroke, null, position, maxTextWidth));
}
