/// <summary>
/// Method to render this layer to the map, applying <paramref name="theme"/>.
/// </summary>
/// <param name="g">The graphics object</param>
/// <param name="map">The map object</param>
/// <param name="envelope">The envelope to render</param>
/// <param name="theme">The theme to apply</param>
protected virtual void RenderInternal(Graphics g, IMapViewPort map, Envelope envelope, ITheme theme)
{
var useCache = _dataCache != null;
var ds = _dataCache;
if (ds == null || ds.Tables.Count == 0)
{
base.Render(g, map);
return;
}
foreach (var features in ds.Tables)
{
//Linestring outlines is drawn by drawing the layer once with a thicker line
//before drawing the "inline" on top.
if (Style.EnableOutline)
{
for (var i = 0; i < features.Count; i++)
{
var feature = features[i];
using (var outlineStyle = theme.GetStyle(feature) as VectorStyle)
{
ApplyStyle(g, map, outlineStyle, (graphics, map1, style) =>
{
//Draw background of all line-outlines first
var lineString = feature.Geometry as ILineString;
if (lineString != null)
{
VectorRenderer.DrawLineString(g, lineString, style.Outline,
map, style.LineOffset);
}
else if (feature.Geometry is IMultiLineString)
{
VectorRenderer.DrawMultiLineString(g, (IMultiLineString)feature.Geometry,
style.Outline, map, style.LineOffset);
}
}
);
}
}
}
for (var i = 0; i < features.Count; i++)
{
var feature = features[i];
var style = theme.GetStyle(feature);
ApplyStyle(g, map, style, (graphics, map1, vstyle) => RenderGeometry(g, map, feature.Geometry, vstyle));
}
}
}
protected void RenderGeometry(Graphics g, Map map, Geometry feature, VectorStyle style)
{
//ToDo: Add Property 'public GeometryType2 GeometryType { get; }' to remove this
GeometryType2 geometryType = feature.GeometryType;
//(GeometryType2)Enum.Parse(typeof(GeometryType2), feature.GetType().Name);
switch (geometryType)
//switch (feature.GetType().FullName)
{
case GeometryType2.Polygon:
//case "SharpMap.Geometries.Polygon":
if (style.EnableOutline)
{
VectorRenderer.DrawPolygon(g, (Polygon)feature, style.Fill, style.Outline, _clippingEnabled,
map);
}
else
{
VectorRenderer.DrawPolygon(g, (Polygon)feature, style.Fill, null, _clippingEnabled, map);
}
break;
case GeometryType2.MultiPolygon:
//case "SharpMap.Geometries.MultiPolygon":
if (style.EnableOutline)
{
VectorRenderer.DrawMultiPolygon(g, (MultiPolygon)feature, style.Fill, style.Outline,
_clippingEnabled, map);
}
else
{
VectorRenderer.DrawMultiPolygon(g, (MultiPolygon)feature, style.Fill, null, _clippingEnabled,
map);
}
break;
case GeometryType2.LineString:
//case "SharpMap.Geometries.LineString":
VectorRenderer.DrawLineString(g, (LineString)feature, style.Line, map);
break;
case GeometryType2.MultiLineString:
//case "SharpMap.Geometries.MultiLineString":
VectorRenderer.DrawMultiLineString(g, (MultiLineString)feature, style.Line, map);
break;
case GeometryType2.Point:
//case "SharpMap.Geometries.Point":
VectorRenderer.DrawPoint(g, (Point)feature, style.Symbol, style.SymbolScale, style.SymbolOffset,
style.SymbolRotation, map);
break;
case GeometryType2.MultiPoint:
//case "SharpMap.Geometries.MultiPoint":
VectorRenderer.DrawMultiPoint(g, (MultiPoint)feature, style.Symbol, style.SymbolScale,
style.SymbolOffset, style.SymbolRotation, map);
break;
case GeometryType2.GeometryCollection:
//case "SharpMap.Geometries.GeometryCollection":
foreach (Geometry geom in (GeometryCollection)feature)
{
RenderGeometry(g, map, geom, style);
}
break;
default:
break;
}
}
/// <summary>
/// Renders the layer to a graphics object
/// </summary>
/// <param name="g">Graphics object reference</param>
/// <param name="map">Map which is rendered</param>
public override void Render(Graphics g, Map map)
{
if (map.Center == null)
{
throw (new ApplicationException("Cannot render map. View center not specified"));
}
g.SmoothingMode = SmoothingMode;
BoundingBox envelope = map.Envelope; //View to render
if (CoordinateTransformation != null)
{
#if !DotSpatialProjections
CoordinateTransformation.MathTransform.Invert();
envelope = GeometryTransform.TransformBox(envelope, CoordinateTransformation.MathTransform);
CoordinateTransformation.MathTransform.Invert();
#else
envelope = GeometryTransform.TransformBox(envelope, CoordinateTransformation.Target, CoordinateTransformation.Source);
#endif
}
//List<SharpMap.Geometries.Geometry> features = this.DataSource.GetGeometriesInView(map.Envelope);
if (DataSource == null)
{
throw (new ApplicationException("DataSource property not set on layer '" + LayerName + "'"));
}
//If thematics is enabled, we use a slighty different rendering approach
if (Theme != null)
{
FeatureDataSet ds = new FeatureDataSet();
lock (_dataSource)
{
DataSource.Open();
DataSource.ExecuteIntersectionQuery(envelope, ds);
DataSource.Close();
}
foreach (FeatureDataTable features in ds.Tables)
{
if (CoordinateTransformation != null)
{
for (int i = 0; i < features.Count; i++)
#if !DotSpatialProjections
{ features[i].Geometry = GeometryTransform.TransformGeometry(features[i].Geometry,
CoordinateTransformation.
MathTransform); }
}
#else
{ features[i].Geometry = GeometryTransform.TransformGeometry(features[i].Geometry,
CoordinateTransformation.Source,
CoordinateTransformation.Target); }
#endif
//Linestring outlines is drawn by drawing the layer once with a thicker line
//before drawing the "inline" on top.
if (Style.EnableOutline)
{
//foreach (SharpMap.Geometries.Geometry feature in features)
for (int i = 0; i < features.Count; i++)
{
FeatureDataRow feature = features[i];
VectorStyle outlineStyle = Theme.GetStyle(feature) as VectorStyle;
if (outlineStyle == null)
{
continue;
}
if (!(outlineStyle.Enabled && outlineStyle.EnableOutline))
{
continue;
}
if (!(outlineStyle.MinVisible <= map.Zoom && map.Zoom <= outlineStyle.MaxVisible))
{
continue;
}
//Draw background of all line-outlines first
if (feature.Geometry is LineString)
{
VectorRenderer.DrawLineString(g, feature.Geometry as LineString, outlineStyle.Outline,
map);
}
else if (feature.Geometry is MultiLineString)
{
VectorRenderer.DrawMultiLineString(g, feature.Geometry as MultiLineString,
outlineStyle.Outline, map);
}
}
}
for (int i = 0; i < features.Count; i++)
{
FeatureDataRow feature = features[i];
VectorStyle style = Theme.GetStyle(feature) as VectorStyle;
if (style == null)
{
continue;
}
if (!style.Enabled)
{
continue;
}
if (!(style.MinVisible <= map.Zoom && map.Zoom <= style.MaxVisible))
{
continue;
}
RenderGeometry(g, map, feature.Geometry, style);
}
}
}
else
{
//if style is not enabled, we don't need to render anything
if (!Style.Enabled)
{
return;
}
Collection <Geometry> geoms = null;
// Is datasource already open?
lock (_dataSource)
{
bool alreadyOpen = DataSource.IsOpen;
// If not open yet, open it
if (!alreadyOpen)
{
DataSource.Open();
}
// Read data
geoms = DataSource.GetGeometriesInView(envelope);
// If was not open, close it
if (!alreadyOpen)
{
DataSource.Close();
}
}
if (CoordinateTransformation != null)
{
for (int i = 0; i < geoms.Count; i++)
#if !DotSpatialProjections
{ geoms[i] = GeometryTransform.TransformGeometry(geoms[i], CoordinateTransformation.MathTransform); }
}
#else
{ geoms[i] = GeometryTransform.TransformGeometry(geoms[i], CoordinateTransformation.Source, CoordinateTransformation.Target); }
#endif
//Linestring outlines is drawn by drawing the layer once with a thicker line
//before drawing the "inline" on top.
if (Style.EnableOutline)
{
foreach (Geometry geom in geoms)
{
if (geom != null)
{
//Draw background of all line-outlines first
if (geom is LineString)
{
VectorRenderer.DrawLineString(g, geom as LineString, Style.Outline, map);
}
else if (geom is MultiLineString)
{
VectorRenderer.DrawMultiLineString(g, geom as MultiLineString, Style.Outline, map);
}
}
}
}
for (int i = 0; i < geoms.Count; i++)
{
if (geoms[i] != null)
{
RenderGeometry(g, map, geoms[i], Style);
}
}
}
base.Render(g, map);
}
/// <summary>
/// Method to render <paramref name="feature"/> using <paramref name="style"/>
/// </summary>
/// <param name="g">The graphics object</param>
/// <param name="map">The map</param>
/// <param name="feature">The feature's geometry</param>
/// <param name="style">The style to apply</param>
protected void RenderGeometry(Graphics g, MapViewport map, IGeometry feature, VectorStyle style)
{
if (feature == null)
{
return;
}
var geometryType = feature.OgcGeometryType;
switch (geometryType)
{
case OgcGeometryType.Polygon:
if (style.EnableOutline)
{
VectorRenderer.DrawPolygon(g, (IPolygon)feature, style.Fill, style.Outline, _clippingEnabled,
map);
}
else
{
VectorRenderer.DrawPolygon(g, (IPolygon)feature, style.Fill, null, _clippingEnabled, map);
}
break;
case OgcGeometryType.MultiPolygon:
if (style.EnableOutline)
{
VectorRenderer.DrawMultiPolygon(g, (IMultiPolygon)feature, style.Fill, style.Outline,
_clippingEnabled, map);
}
else
{
VectorRenderer.DrawMultiPolygon(g, (IMultiPolygon)feature, style.Fill, null, _clippingEnabled,
map);
}
break;
case OgcGeometryType.LineString:
if (style.LineSymbolizer != null)
{
style.LineSymbolizer.Render(map, (ILineString)feature, g);
return;
}
VectorRenderer.DrawLineString(g, (ILineString)feature, style.Line, map, style.LineOffset);
return;
case OgcGeometryType.MultiLineString:
if (style.LineSymbolizer != null)
{
style.LineSymbolizer.Render(map, (IMultiLineString)feature, g);
return;
}
VectorRenderer.DrawMultiLineString(g, (IMultiLineString)feature, style.Line, map, style.LineOffset);
break;
case OgcGeometryType.Point:
if (style.PointSymbolizer != null)
{
VectorRenderer.DrawPoint(style.PointSymbolizer, g, (IPoint)feature, map);
return;
}
if (style.Symbol != null || style.PointColor == null)
{
VectorRenderer.DrawPoint(g, (IPoint)feature, style.Symbol, style.SymbolScale, style.SymbolOffset,
style.SymbolRotation, map);
return;
}
VectorRenderer.DrawPoint(g, (IPoint)feature, style.PointColor, style.PointSize, style.SymbolOffset, map);
break;
case OgcGeometryType.MultiPoint:
if (style.PointSymbolizer != null)
{
VectorRenderer.DrawMultiPoint(style.PointSymbolizer, g, (IMultiPoint)feature, map);
}
if (style.Symbol != null || style.PointColor == null)
{
VectorRenderer.DrawMultiPoint(g, (IMultiPoint)feature, style.Symbol, style.SymbolScale,
style.SymbolOffset, style.SymbolRotation, map);
}
else
{
VectorRenderer.DrawMultiPoint(g, (IMultiPoint)feature, style.PointColor, style.PointSize, style.SymbolOffset, map);
}
break;
case OgcGeometryType.GeometryCollection:
var coll = (IGeometryCollection)feature;
for (var i = 0; i < coll.NumGeometries; i++)
{
IGeometry geom = coll[i];
RenderGeometry(g, map, geom, style);
}
break;
default:
break;
}
}
/// <summary>
/// Method to render this layer to the map, applying <see cref="Style"/>.
/// </summary>
/// <param name="g">The graphics object</param>
/// <param name="map">The map object</param>
/// <param name="envelope">The envelope to render</param>
protected void RenderInternal(Graphics g, MapViewport map, Envelope envelope)
{
//if style is not enabled, we don't need to render anything
if (!Style.Enabled)
{
return;
}
IEnumerable <IStyle> stylesToRender = GetStylesToRender(Style);
if (stylesToRender == null)
{
return;
}
Collection <IGeometry> geoms = null;
foreach (var style in stylesToRender)
{
if (!(style is VectorStyle) || !style.Enabled)
{
continue;
}
using (var vStyle = (style as VectorStyle).Clone())
{
if (vStyle != null)
{
if (geoms == null)
{
lock (_dataSource)
{
// Is datasource already open?
bool wasOpen = DataSource.IsOpen;
if (!wasOpen)
{
DataSource.Open();
}
// Read data
geoms = DataSource.GetGeometriesInView(envelope);
if (!wasOpen)
{
DataSource.Close();
}
}
if (_logger.IsDebugEnabled)
{
_logger.DebugFormat("Layer {0}, NumGeometries {1}", LayerName, geoms.Count);
}
// Transform geometries if necessary
if (CoordinateTransformation != null)
{
for (int i = 0; i < geoms.Count; i++)
{
geoms[i] = ToTarget(geoms[i]);
}
}
}
if (vStyle.LineSymbolizer != null)
{
vStyle.LineSymbolizer.Begin(g, map, geoms.Count);
}
else
{
//Linestring outlines is drawn by drawing the layer once with a thicker line
//before drawing the "inline" on top.
if (vStyle.EnableOutline)
{
foreach (var geom in geoms)
{
if (geom != null)
{
//Draw background of all line-outlines first
if (geom is ILineString)
{
VectorRenderer.DrawLineString(g, geom as ILineString, vStyle.Outline, map, vStyle.LineOffset);
}
else if (geom is IMultiLineString)
{
VectorRenderer.DrawMultiLineString(g, geom as IMultiLineString, vStyle.Outline, map, vStyle.LineOffset);
}
}
}
}
}
foreach (IGeometry geom in geoms)
{
if (geom != null)
{
RenderGeometry(g, map, geom, vStyle);
}
}
if (vStyle.LineSymbolizer != null)
{
vStyle.LineSymbolizer.Symbolize(g, map);
vStyle.LineSymbolizer.End(g, map);
}
}
}
}
}
/// <summary>
/// Method to render this layer to the map, applying <paramref name="theme"/>.
/// </summary>
/// <param name="g">The graphics object</param>
/// <param name="map">The map object</param>
/// <param name="envelope">The envelope to render</param>
/// <param name="theme">The theme to apply</param>
protected void RenderInternal(Graphics g, MapViewport map, Envelope envelope, ITheme theme)
{
var ds = new FeatureDataSet();
lock (_dataSource)
{
// Is datasource already open?
bool wasOpen = DataSource.IsOpen;
if (!wasOpen)
{
DataSource.Open();
}
DataSource.ExecuteIntersectionQuery(envelope, ds);
if (!wasOpen)
{
DataSource.Close();
}
}
double scale = map.GetMapScale((int)g.DpiX);
double zoom = map.Zoom;
Func <MapViewport, FeatureDataRow, IStyle> evalStyle;
if (theme is IThemeEx)
{
evalStyle = new ThemeExEvaluator((IThemeEx)theme).GetStyle;
}
else
{
evalStyle = new ThemeEvaluator(theme).GetStyle;
}
foreach (FeatureDataTable features in ds.Tables)
{
// Transform geometries if necessary
if (CoordinateTransformation != null)
{
for (int i = 0; i < features.Count; i++)
{
features[i].Geometry = ToTarget(features[i].Geometry);
}
}
//Linestring outlines is drawn by drawing the layer once with a thicker line
//before drawing the "inline" on top.
if (Style.EnableOutline)
{
for (int i = 0; i < features.Count; i++)
{
var feature = features[i];
var outlineStyle = evalStyle(map, feature) as VectorStyle;
if (outlineStyle == null)
{
continue;
}
if (!(outlineStyle.Enabled && outlineStyle.EnableOutline))
{
continue;
}
var compare = outlineStyle.VisibilityUnits == VisibilityUnits.ZoomLevel ? zoom : scale;
if (!(outlineStyle.MinVisible <= compare && compare <= outlineStyle.MaxVisible))
{
continue;
}
using (outlineStyle = outlineStyle.Clone())
{
if (outlineStyle != null)
{
//Draw background of all line-outlines first
if (feature.Geometry is ILineString)
{
VectorRenderer.DrawLineString(g, feature.Geometry as ILineString, outlineStyle.Outline,
map, outlineStyle.LineOffset);
}
else if (feature.Geometry is IMultiLineString)
{
VectorRenderer.DrawMultiLineString(g, feature.Geometry as IMultiLineString,
outlineStyle.Outline, map, outlineStyle.LineOffset);
}
}
}
}
}
for (int i = 0; i < features.Count; i++)
{
var feature = features[i];
var style = evalStyle(map, feature);
if (style == null)
{
continue;
}
if (!style.Enabled)
{
continue;
}
double compare = style.VisibilityUnits == VisibilityUnits.ZoomLevel ? zoom : scale;
if (!(style.MinVisible <= compare && compare <= style.MaxVisible))
{
continue;
}
IEnumerable <IStyle> stylesToRender = GetStylesToRender(style);
if (stylesToRender == null)
{
return;
}
foreach (var vstyle in stylesToRender)
{
if (!(vstyle is VectorStyle) || !vstyle.Enabled)
{
continue;
}
using (var clone = (vstyle as VectorStyle).Clone())
{
if (clone != null)
{
RenderGeometry(g, map, feature.Geometry, clone);
}
}
}
}
}
}
protected void RenderGeometry(Graphics g, Map map, Geometry feature, VectorStyle style)
{
GeometryType2 geometryType = feature.GeometryType;
switch (geometryType)
{
case GeometryType2.Polygon:
if (style.EnableOutline)
{
VectorRenderer.DrawPolygon(g, (Polygon)feature, style.Fill, style.Outline, _clippingEnabled,
map);
}
else
{
VectorRenderer.DrawPolygon(g, (Polygon)feature, style.Fill, null, _clippingEnabled, map);
}
break;
case GeometryType2.MultiPolygon:
if (style.EnableOutline)
{
VectorRenderer.DrawMultiPolygon(g, (MultiPolygon)feature, style.Fill, style.Outline,
_clippingEnabled, map);
}
else
{
VectorRenderer.DrawMultiPolygon(g, (MultiPolygon)feature, style.Fill, null, _clippingEnabled,
map);
}
break;
case GeometryType2.LineString:
if (style.LineSymbolizer != null)
{
style.LineSymbolizer.Render(map, (LineString)feature, g);
return;
}
VectorRenderer.DrawLineString(g, (LineString)feature, style.Line, map, style.LineOffset);
return;
case GeometryType2.MultiLineString:
if (style.LineSymbolizer != null)
{
style.LineSymbolizer.Render(map, (MultiLineString)feature, g);
return;
}
VectorRenderer.DrawMultiLineString(g, (MultiLineString)feature, style.Line, map, style.LineOffset);
break;
case GeometryType2.Point:
if (style.PointSymbolizer != null)
{
VectorRenderer.DrawPoint(style.PointSymbolizer, g, (Point)feature, map);
return;
}
if (style.Symbol != null || style.PointColor == null)
{
VectorRenderer.DrawPoint(g, (Point)feature, style.Symbol, style.SymbolScale, style.SymbolOffset,
style.SymbolRotation, map);
return;
}
VectorRenderer.DrawPoint(g, (Point)feature, style.PointColor, style.PointSize, style.SymbolOffset, map);
break;
case GeometryType2.MultiPoint:
//case "SharpMap.Geometries.MultiPoint":
if (style.PointSymbolizer != null)
{
VectorRenderer.DrawMultiPoint(style.PointSymbolizer, g, (MultiPoint)feature, map);
}
if (style.Symbol != null || style.PointColor == null)
{
VectorRenderer.DrawMultiPoint(g, (MultiPoint)feature, style.Symbol, style.SymbolScale,
style.SymbolOffset, style.SymbolRotation, map);
}
else
{
VectorRenderer.DrawMultiPoint(g, (MultiPoint)feature, style.PointColor, style.PointSize, style.SymbolOffset, map);
}
break;
case GeometryType2.GeometryCollection:
//case "SharpMap.Geometries.GeometryCollection":
foreach (Geometry geom in (GeometryCollection)feature)
{
RenderGeometry(g, map, geom, style);
}
break;
default:
break;
}
}
protected void RenderInternal(Graphics g, Map map, BoundingBox envelope)
{
//if style is not enabled, we don't need to render anything
if (!Style.Enabled)
{
return;
}
using (VectorStyle vStyle = Style.Clone())
{
Collection <Geometry> geoms;
// Is datasource already open?
lock (_dataSource)
{
bool alreadyOpen = DataSource.IsOpen;
// If not open yet, open it
if (!alreadyOpen)
{
DataSource.Open();
}
// Read data
geoms = DataSource.GetGeometriesInView(envelope);
Console.Out.WriteLine(string.Format("Layer {0}, NumGeometries {1}", LayerName, geoms.Count));
// If was not open, close it
if (!alreadyOpen)
{
DataSource.Close();
}
}
if (CoordinateTransformation != null)
{
for (int i = 0; i < geoms.Count; i++)
#if !DotSpatialProjections
{ geoms[i] = GeometryTransform.TransformGeometry(geoms[i], CoordinateTransformation.MathTransform); }
}
#else
{ geoms[i] = GeometryTransform.TransformGeometry(geoms[i], CoordinateTransformation.Source, CoordinateTransformation.Target); }
#endif
if (vStyle.LineSymbolizer != null)
{
vStyle.LineSymbolizer.Begin(g, map, geoms.Count);
}
else
{
//Linestring outlines is drawn by drawing the layer once with a thicker line
//before drawing the "inline" on top.
if (vStyle.EnableOutline)
{
foreach (Geometry geom in geoms)
{
if (geom != null)
{
//Draw background of all line-outlines first
if (geom is LineString)
{
VectorRenderer.DrawLineString(g, geom as LineString, vStyle.Outline, map, vStyle.LineOffset);
}
else if (geom is MultiLineString)
{
VectorRenderer.DrawMultiLineString(g, geom as MultiLineString, vStyle.Outline, map, vStyle.LineOffset);
}
}
}
}
}
for (int i = 0; i < geoms.Count; i++)
{
if (geoms[i] != null)
{
RenderGeometry(g, map, geoms[i], vStyle);
}
}
if (vStyle.LineSymbolizer != null)
{
vStyle.LineSymbolizer.Symbolize(g, map);
vStyle.LineSymbolizer.End(g, map);
}
}
}
protected void RenderInternal(Graphics g, Map map, BoundingBox envelope, ITheme theme)
{
FeatureDataSet ds = new FeatureDataSet();
lock (_dataSource)
{
DataSource.Open();
DataSource.ExecuteIntersectionQuery(envelope, ds);
DataSource.Close();
}
foreach (FeatureDataTable features in ds.Tables)
{
if (CoordinateTransformation != null)
{
for (int i = 0; i < features.Count; i++)
#if !DotSpatialProjections
{ features[i].Geometry = GeometryTransform.TransformGeometry(features[i].Geometry,
CoordinateTransformation.
MathTransform); }
}
#else
{ features[i].Geometry = GeometryTransform.TransformGeometry(features[i].Geometry,
CoordinateTransformation.Source,
CoordinateTransformation.Target); }
#endif
//Linestring outlines is drawn by drawing the layer once with a thicker line
//before drawing the "inline" on top.
if (Style.EnableOutline)
{
//foreach (SharpMap.Geometries.Geometry feature in features)
for (int i = 0; i < features.Count; i++)
{
FeatureDataRow feature = features[i];
VectorStyle outlineStyle = Theme.GetStyle(feature) as VectorStyle;
if (outlineStyle == null)
{
continue;
}
if (!(outlineStyle.Enabled && outlineStyle.EnableOutline))
{
continue;
}
if (!(outlineStyle.MinVisible <= map.Zoom && map.Zoom <= outlineStyle.MaxVisible))
{
continue;
}
using (outlineStyle = outlineStyle.Clone())
{
//Draw background of all line-outlines first
if (feature.Geometry is LineString)
{
VectorRenderer.DrawLineString(g, feature.Geometry as LineString, outlineStyle.Outline,
map, outlineStyle.LineOffset);
}
else if (feature.Geometry is MultiLineString)
{
VectorRenderer.DrawMultiLineString(g, feature.Geometry as MultiLineString,
outlineStyle.Outline, map, outlineStyle.LineOffset);
}
}
}
}
for (int i = 0; i < features.Count; i++)
{
FeatureDataRow feature = features[i];
VectorStyle style = Theme.GetStyle(feature) as VectorStyle;
if (style == null)
{
continue;
}
if (!style.Enabled)
{
continue;
}
if (!(style.MinVisible <= map.Zoom && map.Zoom <= style.MaxVisible))
{
continue;
}
using (var clone = style.Clone())
{
RenderGeometry(g, map, feature.Geometry, clone);
}
}
}
}
protected void RenderGeometry(Graphics g, Map map, Geometry feature, VectorStyle layerstyle, RenderType renderType)
{
VectorStyle style = layerstyle;
if (feature.StyleType == 1)
{
style = new VectorStyle();
style.EnableOutline = feature.EnableOutline;
style.Fill = new SolidBrush(Color.FromArgb(feature.Fill));
style.Line = new Pen(Color.Black);
if (feature.DashStyle >= 0 && feature.DashStyle <= 4)
{
style.Line.DashStyle = (DashStyle)(feature.DashStyle);
}
else
{
style.Line.DashStyle = DashStyle.Solid;
}
style.Outline = new Pen(Color.FromArgb(feature.Outline), feature.OutlineWidth);
style.Outline.DashStyle = style.Line.DashStyle;
style.HatchStyle = feature.HatchStyle;
style.Penstyle = feature.Penstyle;
}
if (feature.PointSymbol != null)
{
style.PointSymbol = feature.PointSymbol;
}
if (feature.PointSelectSymbol != null)
{
style.PointSelectSymbol = feature.PointSelectSymbol;
}
if (style.Penstyle == 6)
{
style.Outline.CompoundArray = new float[] { 0, 2f / style.Outline.Width, 1 - 2f / style.Outline.Width, 1 };
}
GeometryType2 geometryType = feature.GeometryType;
string key = this.ID.ToString() + "_" + feature.ID.ToString();
switch (geometryType)
{
case GeometryType2.Polygon:
Brush brush = style.Fill;
if (PriceTable.ContainsKey(key))
{
brush = PriceTable[key] as SolidBrush;
}
else if (GeometryColor.ContainsKey(feature))
{
brush = new SolidBrush((Color)GeometryColor[feature]);
}
else if (style.HatchStyle >= 0)
{
brush = new HatchBrush((HatchStyle)style.HatchStyle, style.Outline.Color, style.Fill.Color);
}
if (style.EnableOutline)
{
VectorRenderer.DrawPolygon(g, (Polygon)feature, brush, style.Outline, _clippingEnabled,
map, style, renderType, Type.ToString());
}
else
{
VectorRenderer.DrawPolygon(g, (Polygon)feature, brush, null, _clippingEnabled, map, style, renderType, Type.ToString());
}
break;
case GeometryType2.MultiPolygon:
Brush brush1 = style.Fill;
if (PriceTable.ContainsKey(key))
{
brush1 = PriceTable[key] as SolidBrush;
}
else if (GeometryColor.ContainsKey(feature))
{
brush1 = new SolidBrush((Color)GeometryColor[feature]);
}
else if (style.HatchStyle >= 0)
{
brush1 = new HatchBrush((HatchStyle)style.HatchStyle, style.Outline.Color, style.Fill.Color);
}
if (style.EnableOutline)
{
VectorRenderer.DrawMultiPolygon(g, (MultiPolygon)feature, brush1, style.Outline,
_clippingEnabled, map, style, renderType, Type.ToString());
}
else
{
VectorRenderer.DrawMultiPolygon(g, (MultiPolygon)feature, brush1, null, _clippingEnabled,
map, style, renderType, Type.ToString());
}
break;
case GeometryType2.LineString:
if (style.LineSymbolizer != null)
{
style.LineSymbolizer.Render(map, (LineString)feature, g);
return;
}
//VectorRenderer.zoom = zoom;
VectorRenderer.DrawLineString(g, (LineString)feature, style.Outline, map, style.LineOffset, style, renderType);
return;
case GeometryType2.MultiLineString:
if (style.LineSymbolizer != null)
{
style.LineSymbolizer.Render(map, (MultiLineString)feature, g);
return;
}
VectorRenderer.DrawMultiLineString(g, (MultiLineString)feature, style.Outline, map, style.LineOffset, style, renderType);
break;
case GeometryType2.Point:
if (style.PointSymbolizer != null)
{
VectorRenderer.DrawPoint(style.PointSymbolizer, g, (Point)feature, map, style, renderType);
return;
}
if (style.Symbol != null || style.PointColor == null)
{
Image image = style.Symbol;
Point point = (Point)feature;
if (style.PointSymbol != null)
{
image = style.PointSymbol;
if (point.Select && style.PointSelectSymbol != null)
{
image = style.PointSelectSymbol;
}
}
if (point.IsAreaPriceMonitor)
{
if (style.PointPriceSymbol != null)
{
image = style.PointPriceSymbol;
}
if (point.Select && style.PointPriceSelectSymbol != null)
{
image = style.PointPriceSelectSymbol;
}
}
VectorRenderer.DrawPoint(g, (Point)feature, image, style.SymbolScale, style.SymbolOffset,
style.SymbolRotation, map, style, renderType);
return;
}
VectorRenderer.DrawPoint(g, (Point)feature, style.PointColor, style.PointSize, style.SymbolOffset, map, style, renderType);
break;
case GeometryType2.MultiPoint:
if (style.PointSymbolizer != null)
{
VectorRenderer.DrawMultiPoint(style.PointSymbolizer, g, (MultiPoint)feature, map, style, renderType);
}
if (style.Symbol != null || style.PointColor == null)
{
VectorRenderer.DrawMultiPoint(g, (MultiPoint)feature, style.Symbol, style.SymbolScale,
style.SymbolOffset, style.SymbolRotation, map, style, renderType);
}
else
{
VectorRenderer.DrawMultiPoint(g, (MultiPoint)feature, style.PointColor, style.PointSize, style.SymbolOffset, map, style, renderType);
}
break;
case GeometryType2.GeometryCollection:
foreach (Geometry geom in (GeometryCollection)feature)
{
RenderGeometry(g, map, geom, style, renderType);
}
break;
default:
break;
}
}
protected void RenderInternal(Graphics g, Map map, BoundingBox envelope, ITheme theme)
{
FeatureDataSet ds = new FeatureDataSet();
lock (_dataSource)
{
DataSource.Open();
DataSource.ExecuteIntersectionQuery(envelope, ds);
DataSource.Close();
}
foreach (FeatureDataTable features in ds.Tables)
{
if (CoordinateTransformation != null)
{
for (int i = 0; i < features.Count; i++)
#if !DotSpatialProjections
{ features[i].Geometry = GeometryTransform.TransformGeometry(features[i].Geometry,
CoordinateTransformation.
MathTransform); }
}
#else
{ features[i].Geometry = GeometryTransform.TransformGeometry(features[i].Geometry,
CoordinateTransformation.Source,
CoordinateTransformation.Target); }
#endif
if (Style.EnableOutline)
{
for (int i = 0; i < features.Count; i++)
{
FeatureDataRow feature = features[i];
VectorStyle outlineStyle = Theme.GetStyle(feature) as VectorStyle;
if (outlineStyle == null)
{
continue;
}
if (!(outlineStyle.Enabled && outlineStyle.EnableOutline))
{
continue;
}
if (!(outlineStyle.MinVisible <= map.Zoom && map.Zoom <= outlineStyle.MaxVisible))
{
continue;
}
outlineStyle = outlineStyle.Clone();
if (feature.Geometry is LineString)
{
VectorRenderer.DrawLineString(g, feature.Geometry as LineString, outlineStyle.Outline,
map, outlineStyle.LineOffset, Style, RenderType.All);
}
else if (feature.Geometry is MultiLineString)
{
VectorRenderer.DrawMultiLineString(g, feature.Geometry as MultiLineString,
outlineStyle.Outline, map, outlineStyle.LineOffset, Style, RenderType.All);
}
}
}
for (int i = 0; i < features.Count; i++)
{
FeatureDataRow feature = features[i];
VectorStyle style = Theme.GetStyle(feature) as VectorStyle;
if (style == null)
{
continue;
}
if (!style.Enabled)
{
continue;
}
if (!(style.MinVisible <= map.Zoom && map.Zoom <= style.MaxVisible))
{
continue;
}
RenderGeometry(g, map, feature.Geometry, style.Clone(), RenderType.All);
}
}
}
/// <summary>
/// Method to render this layer to the map, applying <see cref="Style"/>.
/// </summary>
/// <param name="g">The graphics object</param>
/// <param name="map">The map object</param>
/// <param name="envelope">The envelope to render</param>
protected void RenderInternal(Graphics g, Map map, Envelope envelope)
{
//if style is not enabled, we don't need to render anything
if (!Style.Enabled)
{
return;
}
IStyle[] stylesToRender = GetStylesToRender(Style);
if (stylesToRender == null)
{
return;
}
foreach (var style in stylesToRender)
{
if (!(style is VectorStyle) || !style.Enabled)
{
continue;
}
using (var vStyle = (style as VectorStyle).Clone())
{
if (vStyle != null)
{
Collection <IGeometry> geoms;
// Is datasource already open?
lock (_dataSource)
{
bool alreadyOpen = DataSource.IsOpen;
// If not open yet, open it
if (!alreadyOpen)
{
DataSource.Open();
}
// Read data
geoms = DataSource.GetGeometriesInView(envelope);
if (logger.IsDebugEnabled)
{
logger.DebugFormat("Layer {0}, NumGeometries {1}", LayerName, geoms.Count);
}
// If was not open, close it
if (!alreadyOpen)
{
DataSource.Close();
}
}
if (CoordinateTransformation != null)
{
for (int i = 0; i < geoms.Count; i++)
#if !DotSpatialProjections
{ geoms[i] = GeometryTransform.TransformGeometry(geoms[i], CoordinateTransformation.MathTransform,
GeometryServiceProvider.Instance.CreateGeometryFactory((int)CoordinateTransformation.TargetCS.AuthorityCode)); }
}
#else
{ geoms[i] = GeometryTransform.TransformGeometry(geoms[i],
CoordinateTransformation.Source,
CoordinateTransformation.Target,
CoordinateTransformation.TargetFactory); }
#endif
if (vStyle.LineSymbolizer != null)
{
vStyle.LineSymbolizer.Begin(g, map, geoms.Count);
}
else
{
//Linestring outlines is drawn by drawing the layer once with a thicker line
//before drawing the "inline" on top.
if (vStyle.EnableOutline)
{
foreach (var geom in geoms)
{
if (geom != null)
{
//Draw background of all line-outlines first
if (geom is ILineString)
{
VectorRenderer.DrawLineString(g, geom as ILineString, vStyle.Outline, map, vStyle.LineOffset);
}
else if (geom is IMultiLineString)
{
VectorRenderer.DrawMultiLineString(g, geom as IMultiLineString, vStyle.Outline, map, vStyle.LineOffset);
}
}
}
}
}
for (int i = 0; i < geoms.Count; i++)
{
if (geoms[i] != null)
{
RenderGeometry(g, map, geoms[i], vStyle);
}
}
if (vStyle.LineSymbolizer != null)
{
vStyle.LineSymbolizer.Symbolize(g, map);
vStyle.LineSymbolizer.End(g, map);
}
}
}
}
}
/// <summary>
/// Method to render this layer to the map, applying <paramref name="theme"/>.
/// </summary>
/// <param name="g">The graphics object</param>
/// <param name="map">The map object</param>
/// <param name="envelope">The envelope to render</param>
/// <param name="theme">The theme to apply</param>
protected void RenderInternal(Graphics g, Map map, Envelope envelope, ITheme theme)
{
var ds = new FeatureDataSet();
lock (_dataSource)
{
DataSource.Open();
DataSource.ExecuteIntersectionQuery(envelope, ds);
DataSource.Close();
}
foreach (FeatureDataTable features in ds.Tables)
{
if (CoordinateTransformation != null)
{
for (int i = 0; i < features.Count; i++)
#if !DotSpatialProjections
{ features[i].Geometry = GeometryTransform.TransformGeometry(features[i].Geometry, CoordinateTransformation.MathTransform,
GeometryServiceProvider.Instance.CreateGeometryFactory((int)CoordinateTransformation.TargetCS.AuthorityCode)); }
}
#else
{ features[i].Geometry = GeometryTransform.TransformGeometry(features[i].Geometry,
CoordinateTransformation.Source,
CoordinateTransformation.Target,
CoordinateTransformation.TargetFactory); }
#endif
//Linestring outlines is drawn by drawing the layer once with a thicker line
//before drawing the "inline" on top.
if (Style.EnableOutline)
{
for (int i = 0; i < features.Count; i++)
{
var feature = features[i];
var outlineStyle = theme.GetStyle(feature) as VectorStyle;
if (outlineStyle == null)
{
continue;
}
if (!(outlineStyle.Enabled && outlineStyle.EnableOutline))
{
continue;
}
if (!(outlineStyle.MinVisible <= map.Zoom && map.Zoom <= outlineStyle.MaxVisible))
{
continue;
}
using (outlineStyle = outlineStyle.Clone())
{
if (outlineStyle != null)
{
//Draw background of all line-outlines first
if (feature.Geometry is ILineString)
{
VectorRenderer.DrawLineString(g, feature.Geometry as ILineString, outlineStyle.Outline,
map, outlineStyle.LineOffset);
}
else if (feature.Geometry is IMultiLineString)
{
VectorRenderer.DrawMultiLineString(g, feature.Geometry as IMultiLineString,
outlineStyle.Outline, map, outlineStyle.LineOffset);
}
}
}
}
}
for (int i = 0; i < features.Count; i++)
{
var feature = features[i];
var style = theme.GetStyle(feature);
if (style == null)
{
continue;
}
if (!style.Enabled)
{
continue;
}
if (!(style.MinVisible <= map.Zoom && map.Zoom <= style.MaxVisible))
{
continue;
}
IStyle[] stylesToRender = GetStylesToRender(style);
if (stylesToRender == null)
{
return;
}
foreach (var vstyle in stylesToRender)
{
if (!(vstyle is VectorStyle) || !vstyle.Enabled)
{
continue;
}
using (var clone = (vstyle as VectorStyle).Clone())
{
if (clone != null)
{
RenderGeometry(g, map, feature.Geometry, clone);
}
}
}
}
}
}
/// <summary>
/// Method to render this layer to the map, applying <see cref="Style"/>.
/// </summary>
/// <param name="g">The graphics object</param>
/// <param name="map">The map object</param>
/// <param name="envelope">The envelope to render</param>
protected virtual void RenderInternal(Graphics g, IMapViewPort map, Envelope envelope)
{
//if style is not enabled, we don't need to render anything
if (!Style.Enabled)
{
return;
}
var stylesToRender = GetStylesToRender(Style);
if (stylesToRender == null)
{
return;
}
var useCache = _dataCache != null;
FeatureDataSet ds;
if (!useCache)
{
ds = new FeatureDataSet();
lock (_dataSource)
{
DataSource.Open();
DataSource.ExecuteIntersectionQuery(envelope, ds);
DataSource.Close();
}
}
else
{
ds = _dataCache;
}
try
{
foreach (var features in ds.Tables)
{
ApplyStyle(g, map, Style, (graphics, map1, vStyle) =>
{
if (vStyle.LineSymbolizer != null)
{
vStyle.LineSymbolizer.Begin(g, map, features.Count);
}
else
{
//Linestring outlines is drawn by drawing the layer once with a thicker line
//before drawing the "inline" on top.
if (vStyle.EnableOutline)
{
for (var i = 0;
i < features.Count;
i++)
{
var geom = features[i].Geometry;
if (geom == null)
{
continue;
}
//Draw background of all line-outlines first
var line = geom as ILineString;
if (line != null)
{
VectorRenderer
.DrawLineString(g,
line,
vStyle.Outline,
map,
vStyle
.LineOffset);
}
else if (geom is IMultiLineString)
{
VectorRenderer.DrawMultiLineString(g, (IMultiLineString)geom,
vStyle.Outline, map, vStyle.LineOffset);
}
}
}
}
for (var i = 0; i < features.Count; i++)
{
var geom = features[i].Geometry;
if (geom != null)
{
RenderGeometry(g, map, geom, vStyle);
}
}
if (vStyle.LineSymbolizer != null)
{
vStyle.LineSymbolizer.Symbolize(g, map);
vStyle.LineSymbolizer.End(g, map);
}
});
}
}
finally
{
if (!useCache)
{
ds.Dispose();
}
}
}
