public Point GetCanvasCoord(Geometry.Point2D worldCoord)
{
double x = worldCoord.x / Scale + Origin.X;
double y = Origin.Y - worldCoord.y / Scale;
return(new Point(x, y));
}
protected void OnPointPicked(Geometry.Point2D p)
{
if (PointPicked != null)
{
PointPicked(p);
}
}
public override void MouseLUpHandler(object sender, MouseButtonEventArgs e)
{
if (_isStarted && !_isEnded && !_isDragging) // 第一次点击
{
_isDragging = true;
_mouseDownOrigin = MapControl.Current.GetWorldCoord(e.GetPosition(MapControl.Current));
_mouseDownBegin = _mouseDownOrigin;
_clickPoints.Add(_mouseDownBegin);
}
else if (_isEnded) // 结束点击
{
//_clickPoints.Remove(_mouseDownOrigin);
this.Render();
if (_clickPoints.Count > 1)
{
TongJi.Geometry.Polygon areaPoly = new Geometry.Polygon(_clickPoints);
_areaLabel.Text = "面积：" + areaPoly.Area.ToString("0.000") + "m²";
Canvas.SetLeft(_areaLabel, MapControl.Current.GetCanvasCoord(_clickPoints.ElementAt(_clickPoints.Count - 1)).X + 10);
Canvas.SetTop(_areaLabel, MapControl.Current.GetCanvasCoord(_clickPoints.ElementAt(_clickPoints.Count - 1)).Y + 15);
}
}
else // 中间点击
{
_mouseDownOrigin = MapControl.Current.GetWorldCoord((e.GetPosition(MapControl.Current)));
_clickPoints.Add(_mouseDownOrigin);
this.Render();
}
}
public override void MouseLDownHandler(object sender, MouseButtonEventArgs e)
{
if (_isDragging == false)
{
_isDragging = true;
_mouseDownOrigin = MapControl.Current.GetWorldCoord(e.GetPosition(MapControl.Current));
return;
}
_mouseDownEnd = MapControl.Current.GetWorldCoord(e.GetPosition(MapControl.Current));
var extent = new Geometry.Extent2D(_mouseDownOrigin, _mouseDownEnd);
bool success = IsWindow ? MapControl.Current.AllHitTest(extent) : MapControl.Current.PartHitTest(extent);
if (success)
{
if ((Keyboard.Modifiers & ModifierKeys.Shift) == ModifierKeys.Shift) // mod 20120810
{
SelectionSet.SubtractSelection(MapControl.Current.HitTestMultiResult.Select(x => x.Key).ToArray());
}
else
{
SelectionSet.AddSelection(MapControl.Current.HitTestMultiResult.Select(x => x.Key).ToArray()); // mod 20120725
}
}
else
{
//SelectionSet.ClearSelection();
}
_isDragging = false;
_selRect.Visibility = Visibility.Collapsed;
}
public override void MouseMoveHandler(object sender, MouseEventArgs e)
{
if (!_isEnded && _isDragging)
{
_mouseDownEnd = MapControl.Current.GetWorldCoord(e.GetPosition(MapControl.Current));
}
this.Render();
}
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 override void MouseMoveHandler(object sender, MouseEventArgs e)
{
if (_isDragging)
{
_selRect.Visibility = Visibility.Visible;
_mouseDownEnd = MapControl.Current.GetWorldCoord(e.GetPosition(MapControl.Current));
this.Render();
}
}
public void LocateCanvas(Geometry.Point2D location)
{
double ext = 500;
Geometry.Point2D pt1 = new Geometry.Point2D(location.x + ext, location.y + ext);
Geometry.Point2D pt2 = new Geometry.Point2D(location.x - ext, location.y - ext);
Geometry.Extent2D extent = new Geometry.Extent2D(pt2, pt1);
this.Zoom(extent);
}
public override void MouseLDownHandler(object sender, MouseButtonEventArgs e)
{
if (!_isStarted)
{
_isStarted = true;
_isDragging = true;
Point pos = e.GetPosition(MapControl.Current);
_mouseDownOrigin = MapControl.Current.GetWorldCoord(pos);
}
else
{
_isStarted = false;
}
}
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);
}
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 static void cleanpoly(double epsilon = 1)
{
foreach (var road in display.CityModel.Roads)
{
var points = road.Alignment.Points;
var ready = new List <Geometry.Point2D>();
Geometry.Point2D temp = points.First().Move(new Geometry.Vector2D(100, 100));
foreach (var point in points)
{
if (point.DistTo(temp) < epsilon)
{
ready.Add(point);
}
else
{
temp = point;
}
}
ready.ForEach(x => points.Remove(x));
}
foreach (var parcel in display.CityModel.Parcels)
{
var points = parcel.Domain.Points;
var ready = new List <Geometry.Point2D>();
Geometry.Point2D temp = points.First().Move(new Geometry.Vector2D(100, 100));
foreach (var point in points)
{
if (point.DistTo(temp) < epsilon)
{
ready.Add(point);
}
else
{
temp = point;
}
}
ready.ForEach(x => points.Remove(x));
}
}
public bool HitTest(Point canvasPos)
{
Geometry.Point2D worldPos = GetWorldCoord(canvasPos);
var layers = Enumerable.Reverse(Layers).ToList(); // test from top layers
foreach (MapLayer layer in layers)
{
if (layer.Visibility == Visibility.Visible)
{
Feature f = layer.HitTest(worldPos);
if (f != null)
{
HitTestLayerResult = layer.LayerData;
HitTestFeatureResult = f;
HitTestMultiResult.Clear();
HitTestMultiResult.Add(HitTestFeatureResult, HitTestLayerResult);
return(true);
}
}
}
return(false);
}
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}