private void DrawFeature(IFeature feature)
{
if (LayerData.GeoType == "1")
{
Geometry.Point2D pos = new Geometry.Point2D(feature.GeoData);
AddSpot(new Point(pos.x, pos.y), feature);
AddLable(new Point(pos.x, pos.y), LayerLableStyle.GetLable(feature));
}
else if (LayerData.GeoType == "2")
{
Geometry.Polyline poly = new Geometry.Polyline(feature.GeoData);
if (IsRoad())
{
AddRoadStroke(poly.Points.Select(p => new Point(p.x, p.y)).ToArray(), feature);
}
if (!IsRoad())
{
AddPolyline(poly.Points.Select(p => new Point(p.x, p.y)).ToArray(), feature);
}
else
{
AddRoadFill(poly.Points.Select(p => new Point(p.x, p.y)).ToArray(), feature);
}
string text = LayerLableStyle.GetLable(feature);
double linearRepeatInterval = LayerLableStyle.LinearRepeatInterval;
double length = poly.Length;
List <double> positions = new List <double>(); // mod 20130528 与SVG同步
if (length > 0 && length < 2 * linearRepeatInterval)
{
positions.Add(length / 2);
}
else
{
int index = 1;
while (index * linearRepeatInterval < length)
{
positions.Add(index * linearRepeatInterval);
index++;
}
}
foreach (double position in positions)
{
Geometry.Point2D tempPt = poly.GetPointAtDist(position);
double tanVal = poly.GetFirstDerivative(position);
double rotation = Math.Atan(tanVal);
double angle = 180 / Math.PI * rotation;
AddLable(new Point(tempPt.x, tempPt.y), text, angle);
}
}
else if (LayerData.GeoType == "4")
{
Geometry.Polygon poly = new Geometry.Polygon(feature.GeoData);
Geometry.Point2D center = poly.Centroid; // mod 20130507
AddPolygon(poly.Points.Select(p => new Point(p.x, p.y)).ToArray(), feature);
AddLable(new Point(center.x, center.y), LayerLableStyle.GetLable(feature));
}
}
public Dictionary <Feature, VectorLayer> PartHitTest(Geometry.Extent2D extent)
{
Dictionary <Feature, VectorLayer> multiResult = new Dictionary <Feature, VectorLayer>();
if (LayerData.GeoType == "1")
{
foreach (Feature f in LayerData.Features)
{
Geometry.Point2D p = new Geometry.Point2D(f.GeoData);
if (extent.IsPointIn(p))
{
multiResult.Add(f, LayerData);
}
}
}
else if (LayerData.GeoType == "2")
{
foreach (Feature f in LayerData.Features)
{
Geometry.Polyline poly = new Geometry.Polyline(f.GeoData);
foreach (var point in poly.Points)
{
if (extent.IsPointIn(point))
{
multiResult.Add(f, LayerData);
break;
}
}
}
}
else if (LayerData.GeoType == "4")
{
foreach (Feature f in LayerData.Features)
{
Geometry.Polygon poly = new Geometry.Polygon(f.GeoData);
foreach (var point in poly.Points)
{
if (extent.IsPointIn(point))
{
multiResult.Add(f, LayerData);
break;
}
}
}
}
return(multiResult);
}
/// <summary>
/// Perform the 'get' operation.
/// </summary>
/// <param name="polyline"></param>
/// <returns></returns>
/// <since>6.0</since>
public Commands.Result Get(out Geometry.Polyline polyline)
{
IntPtr ptr_this = NonConstPointer();
polyline = null;
using (var points = new SimpleArrayPoint3d())
{
IntPtr ptr_points = points.NonConstPointer();
var rc = (Commands.Result)UnsafeNativeMethods.RHC_RhinoGetPolyline2(ptr_this, ptr_points, IntPtr.Zero);
if (rc == Commands.Result.Success)
{
polyline = new Geometry.Polyline(points.ToArray());
}
return(rc);
}
}
public override void ApplyFluidTheme(IDataFluidTheme theme)
{
if (LayerData.GeoType == "2")
{
foreach (var feature in Features)
{
var f = feature.Key;
var geometry = feature.Value.Geometry as PathGeometry;
var poly = new Geometry.Polyline(f.GeoData);
double length = poly.Length;
if (length < 10)
{
continue;
}
double velocity = theme.GetVelocity(f);
double time = length / velocity;
double space = 1 / theme.GetDensity(f);
int spotCount = (int)(length / space) + 1;
var color = theme.GetColor(f);
for (int i = 0; i < spotCount; i++)
{
PointAnimationUsingPath paup = new PointAnimationUsingPath();
paup.PathGeometry = geometry;
paup.Duration = new Duration(new TimeSpan(0, 0, 0, 0, (int)(time * 1000)));
paup.RepeatBehavior = RepeatBehavior.Forever;
paup.BeginTime = new TimeSpan(0, 0, 0, 0, (int)(time / spotCount * i * 1000));
ColorAnimation ca = new ColorAnimation(color.Item1, color.Item2, new Duration(new TimeSpan(0, 0, 0, 0, (int)(time * 1000))));
ca.RepeatBehavior = RepeatBehavior.Forever;
ca.BeginTime = new TimeSpan(0, 0, 0, 0, (int)(time / spotCount * i * 1000));
double radius = theme.GetDiameter(f) / 2;
var fill = new SolidColorBrush(color.Item1);
EllipseGeometry spot = new EllipseGeometry(new Point(), radius, radius);
GeometryDrawing spotDrawing = new GeometryDrawing(fill, null, spot);
this.AddOverlayChildren(spotDrawing);
spot.BeginAnimation(EllipseGeometry.CenterProperty, paup);
fill.BeginAnimation(SolidColorBrush.ColorProperty, ca);
}
}
}
}
public Feature HitTest(Geometry.Point2D worldPos)
{
Feature result = null;
if (LayerData.GeoType == "1")
{
foreach (Feature f in LayerData.Features)
{
Geometry.Point2D p = new Geometry.Point2D(f.GeoData);
if (p.DistTo(worldPos) < 5 * MapControl.Current.Scale)
{
result = f;
break;
}
}
}
else if (LayerData.GeoType == "2")
{
foreach (Feature f in LayerData.Features)
{
Geometry.Polyline poly = new Geometry.Polyline(f.GeoData);
if (poly.DistToPoint(worldPos) < 5 * MapControl.Current.Scale)
{
result = f;
break;
}
}
}
else if (LayerData.GeoType == "4")
{
foreach (Feature f in LayerData.Features)
{
Geometry.Polygon poly = new Geometry.Polygon(f.GeoData);
if (poly.IsPointIn(worldPos))
{
result = f;
break;
}
}
}
return(result);
}
public virtual void SetData(VectorLayer layer)
{
LayerData = layer;
LayerStyle = GetLayerStyle(layer);
LayerLableStyle = GetLabelStyle(layer);
Features.Clear();
Overlays.Clear();
Children.Clear();
LabelLayer = new MapLayer();
if (layer.GeoType == "1")
{
foreach (Feature feature in layer.Features)
{
Geometry.Point2D pos = new Geometry.Point2D(feature.GeoData);
AddSpot(new Point(pos.x, pos.y), feature);
AddLable(new Point(pos.x, pos.y), LayerLableStyle.GetLable(feature));
}
}
else if (layer.GeoType == "2")
{
if (IsRoad())
{
foreach (Feature feature in layer.Features)
{
Geometry.Polyline polyline = new Geometry.Polyline(feature.GeoData);
AddRoadStroke(polyline.Points.Select(p => new Point(p.x, p.y)).ToArray(), feature);
}
}
foreach (Feature feature in layer.Features)
{
Geometry.Polyline poly = new Geometry.Polyline(feature.GeoData);
if (!IsRoad())
{
AddPolyline(poly.Points.Select(p => new Point(p.x, p.y)).ToArray(), feature);
}
else
{
AddRoadFill(poly.Points.Select(p => new Point(p.x, p.y)).ToArray(), feature);
}
}
foreach (Feature feature in layer.Features) // mod 20130516 最后统一加标签
{
Geometry.Polyline poly = new Geometry.Polyline(feature.GeoData);
string text = LayerLableStyle.GetLable(feature);
double linearRepeatInterval = LayerLableStyle.LinearRepeatInterval;
double length = poly.Length;
//double scale = 4; // 这个时候出现主窗口的Scale是不合适的。
List <double> positions = new List <double>(); // mod 20130528 与SVG同步
if (length > 0 && length < 2 * linearRepeatInterval)
{
positions.Add(length / 2);
}
else
{
int index = 1;
while (index * linearRepeatInterval < length)
{
positions.Add(index * linearRepeatInterval);
index++;
}
}
foreach (double position in positions)
{
Geometry.Point2D tempPt = poly.GetPointAtDist(position);
double tanVal = poly.GetFirstDerivative(position);
double rotation = Math.Atan(tanVal);
double angle = 180 / Math.PI * rotation;
AddLable(new Point(tempPt.x, tempPt.y), text, angle);
}
}
}
else if (layer.GeoType == "4")
{
foreach (Feature feature in layer.Features)
{
Geometry.Polygon poly = new Geometry.Polygon(feature.GeoData);
Geometry.Point2D center = poly.Centroid;
AddPolygon(poly.Points.Select(p => new Point(p.x, p.y)).ToArray(), feature);
AddLable(new Point(center.x, center.y), LayerLableStyle.GetLable(feature));
}
}
}
public string Render(int width = 0, int height = 0)
{
SetSvgCanvas(_svgWriter, _extents, width, height);
var layers = _map.Layers.OrderBy(l => GetLayerOrder(l.Name)).ToList();
foreach (VectorLayer layer in layers)
{
// Run overlay procedure
var order = GetLayerOrder(layer.Name);
if (_overlayRenderProcedures.ContainsKey(order))
{
_overlayRenderProcedures[order]();
}
// Set SVG styles using layer style config
var layerConfig = GetLayerConfigByName(layer.Name);
SetVectorStyles(_svgWriter, layerConfig);
var themeFilter = _themeFilters.ContainsKey(layer.Name) ? _themeFilters[layer.Name] : null;
if (layer.GeoType == "1")
{
foreach (Feature feature in layer.Features)
{
// Set SVG styles using theme
SetVectorStyles(_svgWriter, themeFilter, feature);
Geometry.Point2D pos = new Geometry.Point2D(feature.GeoData);
AddCircle(20, pos.x, pos.y);
}
SetTextStyles(_svgWriter, layerConfig);
foreach (Feature feature in layer.Features)
{
Geometry.Point2D pos = new Geometry.Point2D(feature.GeoData);
AddText(GetLabel(layerConfig, feature), pos.x, pos.y);
}
}
else if (layer.GeoType == "2")
{
if (layerConfig != null && layerConfig.StrokeBundle != null && layerConfig.StrokeBundle.Strokes.Count > 0)
{
foreach (VectorStyle strokeStyle in layerConfig.StrokeBundle.Strokes)
{
// Set SVG styles using this bundle element style
SetVectorStyles(_svgWriter, strokeStyle);
foreach (Feature feature in layer.Features)
{
Geometry.Polyline poly = new Geometry.Polyline(feature.GeoData);
AddPolyline(poly.Points);
}
}
}
else
{
foreach (Feature feature in layer.Features)
{
// Set SVG styles using theme
SetVectorStyles(_svgWriter, themeFilter, feature);
_svgWriter.SetFill("none");
Geometry.Polyline poly = new Geometry.Polyline(feature.GeoData);
AddPolyline(poly.Points);
}
}
// Whatever case, add label in the end in case of overlapping with shapes
if (layerConfig != null && layerConfig.LabelStyle != null)
{
SetTextStyles(_svgWriter, layerConfig);
foreach (Feature feature in layer.Features)
{
// Add label every specified length
Geometry.Polyline poly = new Geometry.Polyline(feature.GeoData);
string text = GetLabel(layerConfig, feature);
double linearRepeatInterval = layerConfig.LabelStyle.LinearRepeatInterval;
double length = poly.Length;
List <double> positions = new List <double>();
if (length > 0 && length < 2 * linearRepeatInterval)
{
positions.Add(length / 2);
}
else
{
int index = 1;
while (index * linearRepeatInterval < length)
{
positions.Add(index * linearRepeatInterval);
index++;
}
}
foreach (double position in positions)
{
Geometry.Point2D pos = poly.GetPointAtDist(position);
double tan = poly.GetFirstDerivative(position);
double rotation = Math.Atan(tan);
double angle = -180 / Math.PI * rotation;
AddText(text, pos.x, pos.y, angle);
}
}
}
}
else if (layer.GeoType == "4")
{
foreach (Feature feature in layer.Features)
{
// Set SVG styles using theme
SetVectorStyles(_svgWriter, themeFilter, feature);
Geometry.Polygon poly = new Geometry.Polygon(feature.GeoData);
AddPolygon(poly.Points);
}
SetTextStyles(_svgWriter, layerConfig);
foreach (Feature feature in layer.Features)
{
Geometry.Polygon poly = new Geometry.Polygon(feature.GeoData);
Geometry.Point2D center = poly.Centroid;
AddText(GetLabel(layerConfig, feature), center.x, center.y);
}
}
}
return(_svgWriter.ToString());
}
){kind=link}