/// <summary>${utility_ScaleHelper_method_GetSmDpi_D}</summary>
/// <remarks>${utility_ScaleHelper_method_GetSmDpi_remarks}</remarks>
/// <param name="referViewBounds">${utility_ScaleHelper_method_GetSmDpi_param_referViewBounds}</param>
/// <param name="referViewer">${utility_ScaleHelper_method_GetSmDpi_param_referViewer}</param>
/// <param name="referScale">${utility_ScaleHelper_method_GetSmDpi_param_referScale}</param>
/// <param name="unit">${utility_ScaleHelper_method_GetSmDpi_param_unit}</param>
/// <param name="datumAxis">${utility_ScaleHelper_method_GetSmDpi_param_datumAxis}</param>
public static double GetSmDpi(Rectangle2D referViewBounds, Rect referViewer, double referScale, Unit unit = Unit.Degree, double datumAxis = 6378137)
{
int ratio = 10000;
double num1 = referViewBounds.Width / referViewer.Width;//横向分辨率
double num2 = referViewBounds.Height / referViewer.Height;//纵向分辨率
if (unit == Unit.Undefined)
{
unit = Unit.Degree;
}
if (datumAxis <= 0||datumAxis==double.NaN)
{
datumAxis = 6378137;
}
//地图单位为经纬度
if (unit == Unit.Degree)
{
double referResolution = num1 > num2 ? num1 : num2;//取横向或纵向分辨率中的较大者，用于计算DPI
var dpi = 0.0254 * ratio / referResolution / referScale / ((Math.PI * 2 * datumAxis) / 360) / ratio;
return dpi;
}
else
{
var dpi = 0.0254 * ratio / num1 / referScale / ratio;
return dpi;
}
}
/// <summary>${utility_JsonHelper_method_FromRectangle2D_D}</summary>
public static string FromRectangle2D(Rectangle2D rectangle2D)
{
if (rectangle2D.IsEmpty)
{
return "{}";
}
return string.Format(CultureInfo.InvariantCulture, "{{\"rightTop\":{{\"y\":{0},\"x\":{1}}},\"leftBottom\":{{\"y\":{2},\"x\":{3}}}}}", rectangle2D.Top, rectangle2D.Right, rectangle2D.Bottom, rectangle2D.Left);
}
private Point2D ClipLineSegment(Point2D p0, Point2D p1, Rectangle2D box)
{
Point2D point = new Point2D(p1.X, p1.Y);
if (p1.X < box.Left)
{
point = EdgeIntersection(p0, p1, box.Left, false);
}
else if (p1.X > box.Right)
{
point = EdgeIntersection(p0, p1, box.Right, false);
}
if (point.Y < box.Bottom)
{
return EdgeIntersection(p0, p1, box.Bottom, true);
}
if (point.Y > box.Top)
{
point = EdgeIntersection(p0, p1, box.Top, true);
}
return point;
}
/// <summary>${ui_action_MapAction_event_onMouseUp_D}</summary>
/// <param name="e">${ui_action_MapAction_event_onMouseUp_param_e}</param>
public override void OnMouseLeftButtonUp(MouseButtonEventArgs e)
{
if (Rectangle == null)
{
return;
}
Rectangle2D zoomBounds = (Rectangle2D)Rectangle.GetValue(ElementsLayer.BBoxProperty);
if (zoomBounds.IsEmpty || zoomBounds.Width == 0.0 || zoomBounds.Height == 0.0)
{
return;
}
Point2D center = zoomBounds.Center;
Rectangle2D currentBounds = Map.ViewBounds;
double whRatioCurrent = currentBounds.Width / currentBounds.Height;
double whRatioZoomBox = zoomBounds.Width / zoomBounds.Height;
Rectangle2D newBounds = Rectangle2D.Empty;
if (whRatioZoomBox > whRatioCurrent) // use width
{
double multiplier = currentBounds.Width / zoomBounds.Width;
double newWidth = currentBounds.Width * multiplier;
newBounds = new Rectangle2D(new Point2D(center.X - (newWidth / 2), center.Y - (newWidth / 2)),
new Point2D(center.X + (newWidth / 2), center.Y + (newWidth / 2)));
}
else// use height
{
double multiplier = currentBounds.Height / zoomBounds.Height;
double newHeight = currentBounds.Height * multiplier;
newBounds = new Rectangle2D(new Point2D(center.X - (newHeight / 2), center.Y - (newHeight / 2)),
new Point2D(center.X + (newHeight / 2), center.Y + (newHeight / 2)));
}
if (!newBounds.IsEmpty)
{
Map.ZoomTo(newBounds);
}
base.OnMouseLeftButtonUp(e);
}
/// <summary>${mapping_ArbitraryLayer_method_addChild_UIElement_Rectangle2D_D}</summary>
/// <param name="element">${mapping_ArbitraryLayer_method_addChild_UIElement_pararm_element}</param>
/// <param name="bbox">${mapping_ArbitraryLayer_method_addChild_UIElement_Rectangle2D_param_bbox}</param>
public void AddChild(UIElement element, Rectangle2D bbox)
{
if (!(element is ShapeElement))
{
ElementsLayer.SetBBox(element, bbox);
}
Children.Add(element);
}
/// <example>${mapping_ArbitraryLayer_method_setbbox_Example_D}<code inline="false" title="" description="" lang="CS"></code><code title="Example1" description="" lang="C#">Ellipse myellipse = new Ellipse();
/// Rectangle2D ellbounds = new Rectangle2D(left, bottom, right, top);
/// myellipse.SetValue(ElementsLayer.BBoxProperty, ellbounds);
/// this.ElementsLayer.AddChild(myellipse);</code><code title="Example2" description="" lang="CS"><ELLIPSE id=dxCrLf <SPAN x:Name="MyEllipse"></SPAN> namespace:ElementsLayer.BBox="left, bottom, right, top"&gt;
/// </ELLIPSE></code></example>
/// <summary>${mapping_ArbitraryLayer_method_setbbox_D}</summary>
/// <param name="obj">${mapping_ArbitraryLayer_method_setbbox_param_obj}</param>
/// <param name="value">${mapping_ArbitraryLayer_method_setbbox_param_value}</param>
public static void SetBBox(DependencyObject obj, Rectangle2D value)
{
obj.SetValue(BBoxProperty, value);
}
/// <summary>${core_Rectangle2D_method_intersectsWith_D}</summary>
/// <returns>${core_Rectangle2D_method_intersectsWith_return}</returns>
/// <param name="rect">${core_Rectangle2D_method_intersectsWith_param_rect}</param>
public bool IntersectsWith(Rectangle2D rect)
{
if ((this._width < 0.0) || (rect.Width < 0.0))
{
return false;
}
return (rect.Left <= this.Right) && (rect.Right >= this.Left) && (rect.Bottom <= this.Top) && (rect.Top >= this.Bottom);
}
/// <summary>${core_Rectangle2D_method_union_Rectangle2D_D}</summary>
/// <param name="rect">${core_Rectangle2D_method_union_Rectangle2D_param_rect}</param>
public void Union(Rectangle2D rect)
{
if (this.IsEmpty)
{
this = rect;
}
else if (!rect.IsEmpty)
{
double minLeft = Math.Min(this.Left, rect.Left);
double minBottom = Math.Min(this.Bottom, rect.Bottom);
if ((rect.Width == double.PositiveInfinity) || (this.Width == double.PositiveInfinity))
{
this._width = double.PositiveInfinity;
}
else
{
double maxRight = Math.Max(this.Right, rect.Right);
this._width = Math.Max((double)(maxRight - minLeft), (double)0.0);
}
if ((rect.Height == double.PositiveInfinity) || (this.Height == double.PositiveInfinity))
{
this._height = double.PositiveInfinity;
}
else
{
double maxHeight = Math.Max(this.Top, rect.Top);
this._height = Math.Max((double)(maxHeight - minBottom), (double)0.0);
}
this._x = minLeft;
this._y = minBottom;
}
}
private void RemoveTiles(Rectangle2D bounds, double resolution)
{
if (!bounds.IsEmpty)
{
if (base.Container == null)
{
pendingTiles.Clear();
}
else
{
int level = MathUtil.GetIndex(resolution, realResolutions);
int[] span = this.GetTileSpanWithin(bounds, resolution);
if ((span[2] >= 0) || (span[3] >= 0))
{
int startCloumn = span[0];
int startRow = span[1];
int endCloumn = span[2];
int endRow = span[3];
for (int i = base.Container.Children.Count - 1; i >= 0; i--)
{
UIElement element = base.Container.Children[i];
Image image = element as Image;
if (image != null)
{
Tile tile = (Tile)image.Tag;
bool flag = (level != -1) ? (level != tile.Level) : (!DoubleUtil.AreClose(resolution, tile.Resolution));
//只要分级别，不管在map上还是layer上，都用level判断。否则用Resolution判断
if ((tile.Row < (startRow - 1)) || (tile.Row > (endRow + 1)) || (tile.Column < (startCloumn - 1)) || (tile.Column > (endCloumn + 1)) || flag)
{
string key = null;
if (image.Source != null)
{
key = (image.Source as BitmapImage).UriSource.OriginalString;
if (pendingTiles.ContainsKey(key))
{
pendingTiles.Remove(key);
}
}
if (tile.Progress < 100)
{
if (image.Source is BitmapImage)
{
(image.Source as BitmapImage).UriSource = null;
}
image.Source = null;
base.Container.Children.Remove(image);
}
else
{
image.SetValue(LayerContainer.OutdatedProperty, true);
}
}
}
}
}
}
}
}
//由bounds获取tile的起始和结束行列号
//[startColumn,startRow,endColumn,endRow] //Returns [0,0,-1,-1] if fails
private int[] GetTileSpanWithin(Rectangle2D bounds, double resolution)
{
bounds.Intersect(this.Bounds);
if (!bounds.IsEmpty)
{
double x = this.Origin.X;
double y = this.Origin.Y;
int startColumn = (int)Math.Floor((double)(((bounds.Left - x) + (resolution * 0.5)) / (resolution * this.TileSize)));
int startRow = (int)Math.Floor((double)(((y - bounds.Top) + (resolution * 0.5)) / (resolution * this.TileSize)));
startColumn = (startColumn < 0) ? 0 : startColumn;
startRow = (startColumn < 0) ? 0 : startRow;
int endColumn = (int)Math.Floor((double)(((bounds.Right - x) - (resolution * 0.5)) / (resolution * this.TileSize)));
int endRow = (int)Math.Floor((double)(((y - bounds.Bottom) - (resolution * 0.5)) / (resolution * this.TileSize)));
return new int[] { startColumn, startRow, endColumn, endRow };
//if (GetCachedResolutions() != null)
//{
// return new int[] { startColumn, startRow, endColumn, endRow };
//}
//else
//{
// return new int[] { startColumn - 1, startRow - 1, endColumn + 1, endRow + 1 };
//}//动态的话，上下左右各扩充一张,但边缘处不美观
}
return new int[4] { 0, 0, -1, -1 };
}
/// <summary>${ui_action_MapAction_event_onMouseWheel_D}</summary>
/// <param name="e">${ui_action_MapAction_event_onMouseWheel_param_e}</param>
protected override void OnMouseWheel(MouseWheelEventArgs e)
{
base.OnMouseWheel(e);
if (_mouseWheelTimer.IsEnabled)
{
_mouseWheelTimer.Stop();
}
_mouseWheelTimer.Start();
if (_isWheeling)
{
return;
}
_isWheeling = true;
if (zoomEffectContainer != null && ZoomEffectEnabled == true)
{
this.zoomEffectContainer.Margin = new Thickness(curMousePos.X - 44, curMousePos.Y - 34, 0, 0);
if (e.Delta > 0)
{
zoomEffect.beginZoomin();
}
else
{
zoomEffect.beiginZoomout();
}
}
if (this.Action != null)
{
this.Action.OnMouseWheel(e);
if (!e.Handled && EnableWheel)
{
e.Handled = true;
base.Focus();
Point2D pnt = ScreenToMap(curMousePos);
double newResolution = GetNextResolution(e.Delta > 0);
Rectangle2D newBounds = new Rectangle2D(pnt.X - curMousePos.X * newResolution, pnt.Y - (currentSize.Height - curMousePos.Y) * newResolution, pnt.X + (currentSize.Width - curMousePos.X) * newResolution, pnt.Y + curMousePos.Y * newResolution);
ZoomTo(newBounds);
}
}
}
internal PolylineElementClip(Rectangle2D clipBox)
{
this.boundary = clipBox;
}
private void MyMap_ViewBoundsChanged(object sender, ViewBoundsEventArgs e)
{
#region Ellipse
Ellipse myellipse = new Ellipse();
myellipse.Fill = new SolidColorBrush(Colors.Red);
Rectangle2D ellbounds = new Rectangle2D(119.5, 21, 122.5, 26);
this.arbitrarylayer.AddChild(myellipse, ellbounds);
MyEllipseStory.Stop();
Storyboard.SetTarget(myDoubleAnimation, myellipse);
MyEllipseStory.Begin();
#endregion
#region Pushpin
Pushpin beijing = new Pushpin();
beijing.Location = new Point2D(116.2, 39.6);
this.arbitrarylayer.AddChild(beijing);
Pushpin ulanBator = new Pushpin();
ulanBator.Location = new Point2D(106.5, 47.6);
ulanBator.Background = new SolidColorBrush(Colors.Blue);
this.arbitrarylayer.AddChild(ulanBator);
Pushpin moscow = new Pushpin();
moscow.Location = new Point2D(37.4, 55.5);
moscow.Background = new SolidColorBrush(Colors.Yellow);
this.arbitrarylayer.AddChild(moscow);
Pushpin prague = new Pushpin();
prague.Location = new Point2D(14.3, 50.1);
prague.Background = new SolidColorBrush(Colors.Orange);
this.arbitrarylayer.AddChild(prague);
Pushpin berlin = new Pushpin();
berlin.Location = new Point2D(13.3, 52.3);
berlin.Background = new SolidColorBrush(Colors.Purple);
this.arbitrarylayer.AddChild(berlin);
#endregion
#region PolygonElement
PolygonElement line = new PolygonElement();
line.Stroke = new SolidColorBrush(Colors.Yellow);
line.StrokeThickness = 3;
line.Opacity = 1;
line.StrokeDashArray = new DoubleCollection { 3, 3 };
line.StrokeEndLineCap = PenLineCap.Triangle;
Point2DCollection points = new Point2DCollection();
points.Add(new Point2D(121.3, 25));
points.Add(new Point2D(116.2, 39.6));
points.Add(new Point2D(106.5, 47.6));
points.Add(new Point2D(37.4, 55.5));
points.Add(new Point2D(14.3, 50.1));
points.Add(new Point2D(13.3, 52.3));
points.Add(new Point2D(0.1, 51.3));
line.Point2Ds = points;
this.arbitrarylayer.AddChild(line);
#endregion
#region PolygonElement
PolygonElement polygon = new PolygonElement();
polygon.Stroke = new SolidColorBrush(Colors.Purple);
polygon.Opacity = 0.5;
polygon.Fill = this.British;
Point2DCollection gonpoints = new Point2DCollection();
gonpoints.Add(new Point2D(-8, 61));
gonpoints.Add(new Point2D(-6, 55));
gonpoints.Add(new Point2D(-8, 50));
gonpoints.Add(new Point2D(2, 50));
gonpoints.Add(new Point2D(1, 61));
polygon.Point2Ds = gonpoints;
this.arbitrarylayer.AddChild(polygon);
#endregion
#region Button
Button btn = new Button();
btn.Height = 32;
btn.Width = 32;
btn.Content = "点击";
btn.Click += new RoutedEventHandler(btn_Click);
Rectangle2D btnbounds = new Rectangle2D(95, 29, 115, 38);
btn.SetValue(ElementsLayer.BBoxProperty, btnbounds);
this.arbitrarylayer.AddChild(btn);
#endregion
}
private static void OnLocationChangedCallback(DependencyObject d, DependencyPropertyChangedEventArgs eventArgs)
{
Rectangle2D bounds = new Rectangle2D((Point2D)eventArgs.NewValue, (Point2D)eventArgs.NewValue);
ElementsLayer.SetBBox(d, bounds);
}
/// <summary>${core_Rectangle2D_method_containsRectangle2D_D}</summary>
/// <returns>${core_Rectangle2D_method_containsRectangle2D_return_sl}</returns>
/// <param name="rect">${core_Rectangle2D_method_containsRectangle2D_param_rect}</param>
public bool Contains(Rectangle2D rect)
{
if (rect.IsEmpty)
{
return false;
}
return (this.Left <= rect.Left) && (rect.Right <= this.Right) && (this.Bottom <= rect.Bottom) && (rect.Top <= this.Top);
}
internal bool Within(Rectangle2D other)
{
return ((((this.Left >= other.Left) && (this.Right <= other.Right)) && (this.Bottom >= other.Bottom)) && (this.Top <= other.Top));
}
private void children_CollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
{
if (e.Action == NotifyCollectionChangedAction.Add)
{
if (!this.fullBounds.IsEmpty)
{
UpdateFullBounds(e.NewItems);
}
}
else
{
if (e.Action == NotifyCollectionChangedAction.Reset)
{
base.Container.Children.Clear();
}
else
{
base.Container.Children.Remove(e.OldItems[0] as UIElement);
}
this.fullBounds = Rectangle2D.Empty;
}
this.Invalidate();
}
private IList<Point2DCollection> ClipPointCollection(Point2DCollection points, Rectangle2D box)
{
List<Point2DCollection> list = new List<Point2DCollection>();
Rectangle2D rect = points.GetBounds();
if (((rect.Right < box.Left) || (rect.Top < box.Bottom)) || ((rect.Left > box.Right) || (rect.Bottom > box.Top)))
{
return null;
}//全部在外,不相交
if (box.Contains(rect))
{
list.Add(points);
return list;
}//全部在内
if (points.Count < 2)
{
return null;
}
Point2DCollection item = null;
bool flag = box.Contains(points[0]);
if (flag)
{
item = new Point2DCollection();
list.Add(item);
item.Add(points[0]);
}//第一个点在内
for (int i = 0; i < (points.Count - 1); i++)
{
Point2D head = points[i];
Point2D end = points[i + 1];
bool flag2 = box.Contains(end);
if (flag && flag2)
{
item.Add(end);
}//同时在内。那么else则有三种情况,head内end外，head外edn内，hean外end外
else
{
if (flag != flag2)
{
if (flag)
{
item.Add(this.ClipLineSegment(head, end, box));
}//head内end外，添加交点
else
{
item = new Point2DCollection();
list.Add(item);
item.Add(this.ClipLineSegment(head, end, box));
item.Add(end);
}//head外edn内，添加交点和end点
}
else
{
Rectangle2D segmentBox = new Rectangle2D(Math.Min(head.X, end.X), Math.Min(head.Y, end.Y), Math.Max(head.X, end.X), Math.Max(head.Y, end.Y));
if (segmentBox.IntersectsWith(box))
{
item = new Point2DCollection();
list.Add(item);
//与四条边框求交点,在中间就添加上去
Point2D point3 = EdgeIntersection(head, end, box.Left, false);
Point2D point4 = EdgeIntersection(head, end, box.Right, false);
Point2D point5 = EdgeIntersection(head, end, box.Bottom, true);
Point2D point6 = EdgeIntersection(head, end, box.Top, true);
if ((point6.X >= box.Left) && (point6.X <= box.Right))
{
item.Add(point6);
}
if ((point5.X >= box.Left) && (point5.X <= box.Right))
{
item.Add(point5);
}
if ((point4.Y >= box.Bottom) && (point4.Y <= box.Top))
{
item.Add(point4);
}
if ((point3.Y >= box.Bottom) && (point3.Y <= box.Top))
{
item.Add(point3);
}
if (item.Count < 2)
{
list.Remove(item);
}
}//hean外end外，添加两个交点
}
flag = flag2;
}
}
for (int j = list.Count - 1; j >= 0; j--)
{
Point2DCollection pts = list[j];
if (pts.Count < 2)
{
list.RemoveAt(j);
}
}
if (list.Count == 0)
{
return null;
}
return list;
}
private void UpdateFullBounds(IEnumerable items)
{
foreach (object obj2 in items)
{
UIElement element = (UIElement)obj2;
Rectangle2D rect2D = GetBBox(element);
if (element is ShapeElement)
{
rect2D = ((ShapeElement)element).Bounds;
}
if (fullBounds.IsEmpty)
{
fullBounds = rect2D;
}
else
{
fullBounds.Union(rect2D);
}
}
}
internal void SetClip(SuperMap.Web.Core.Geometry clippedGeometry, Rectangle2D clipbox)
{
this.ClippedGeometry = clippedGeometry;
this.ClipBox = clipbox;
this.InvalidatePath(this.Resolution, this.OriginX, this.OriginY);
if (this.Feature.dOldInflate > 0.0)
return;
//当线宽的外接矩形超过范围时，线不需偏移，重置偏移值为0
this.Feature.dOldInflate = this.Feature.dInflate;
this.Feature.dInflate = 0;
}
private static string convertToString(Rectangle2D rect)
{
if (rect.IsEmpty)
{
return null;
}
CultureInfo invariantCulture = CultureInfo.InvariantCulture;
string listSeparator = invariantCulture.TextInfo.ListSeparator;
return string.Format(invariantCulture, "{0}{4}{1}{4}{2}{4}{3}", new object[] { rect.Left, rect.Bottom, rect.Right, rect.Top, listSeparator });
}
private static Rectangle2D GetBounds(XElement element)
{
if (element == null)
return Rectangle2D.Empty;
Rectangle2D rect = new Rectangle2D(
(element.Attribute("minx") == null) ? double.MinValue : double.Parse(element.Attribute("minx").Value, CultureInfo.InvariantCulture),
(element.Attribute("miny") == null) ? double.MinValue : double.Parse(element.Attribute("miny").Value, CultureInfo.InvariantCulture),
(element.Attribute("maxx") == null) ? double.MinValue : double.Parse(element.Attribute("maxx").Value, CultureInfo.InvariantCulture),
(element.Attribute("maxy") == null) ? double.MinValue : double.Parse(element.Attribute("maxy").Value, CultureInfo.InvariantCulture)
);
return rect;
}
private void RaiseTileLoad(Tile tile, Rectangle2D bounds)
{
if (TileLoaded != null)
{
TileLoadEventArgs loadTileArgs = new TileLoadEventArgs();
loadTileArgs.Column = tile.Column;
loadTileArgs.ImageSource = tile.Image.Source;
loadTileArgs.Level = tile.Level;
loadTileArgs.Row = tile.Row;
loadTileArgs.Bounds = bounds;
TileLoaded(this, loadTileArgs);
}
}
/// <summary>${ui_action_MapAction_event_onMouseMove_D}</summary>
/// <param name="e">${ui_action_MapAction_event_onMouseMove_param_e}</param>
public override void OnMouseMove(MouseEventArgs e)
{
if (isDrawing)
{
Point2D item = Map.ScreenToMap(e.GetPosition(Map));
double width = Math.Abs(item.X - startPt.X);
double height = Math.Abs(startPt.Y - item.Y);
double r = Math.Sqrt(width * width + height * height);
this._radius = r;
Rectangle2D bounds = new Rectangle2D(startPt.X - r, startPt.Y - r, startPt.X + r, startPt.Y + r);//圆
ellipse.SetValue(ElementsLayer.BBoxProperty, bounds);
}
base.OnMouseMove(e);
}
private double GetValueFromMap(Rectangle2D bounds)
{
if (((this.layerResolutions == null) || (this.layerResolutions.Length == 0)) || ((this.Map == null) || (bounds.IsEmpty)))
{
return -1.0;
}
double num = bounds.Width / this.Map.ActualWidth;
double t = this.Map.Resolution;
for (int i = 0; i < (this.layerResolutions.Length - 1); i++)
{
double num3 = this.layerResolutions[i];
double num4 = this.layerResolutions[i + 1];
if (num >= num3)
{
return (double)i;
}
if ((num < num3) && (num > num4))
{
return (i + ((num3 - num) / (num3 - num4)));
}
}
return Convert.ToDouble((int)(this.layerResolutions.Length - 1));
}
/// <summary>${core_Rectangle2D_method_intersect_D}</summary>
/// <param name="rect">${core_Rectangle2D_method_intersect_param_rect}</param>
public void Intersect(Rectangle2D rect)
{
if (!this.IntersectsWith(rect))
{
this = s_empty;
}
else
{
double maxLeft = Math.Max(this.Left, rect.Left);
double maxBottom = Math.Max(this.Bottom, rect.Bottom);
this._width = Math.Max((Math.Min(this.Right, rect.Right) - maxLeft), (double)0.0);
this._height = Math.Max((Math.Min(this.Top, rect.Top) - maxBottom), (double)0.0);
this._x = maxLeft;
this._y = maxBottom;
}
}
internal void SetClip(Point2DCollection clippedPoint2Ds, Rectangle2D clipbox)
{
this.ClippedPoint2Ds = clippedPoint2Ds;
this.ClipBox = clipbox;
this.InvalidatePath(this.Resolution, this.OriginX, this.OriginY);
}
internal void SetElementReference(FeatureElement element)
{
if (element == null)
{
this.ElementReference = null;
}
else
{
this.ElementReference = new WeakReference(element);
Canvas.SetZIndex(element, this.zIndex);
if (this.geometry != null)
{
Rectangle2D biggerBounds = new Rectangle2D(this.geometry.Bounds.Left, this.geometry.Bounds.Bottom, this.geometry.Bounds.Right, this.geometry.Bounds.Top);
//拓宽GeoLine的外接矩形
if (this.Layer != null && (!double.IsNaN(this.Layer.Resolution)) && this.Style !=null && this.Style is LineStyle)
{
LineStyle lineStyle = this.Style as LineStyle;
if (!double.IsNaN(lineStyle.StrokeThickness))
{
Double dInflate = this.Layer.Resolution * lineStyle.StrokeThickness;
biggerBounds.Inflate(dInflate, dInflate);
this.dInflate = dInflate;
}
}
SuperMap.Web.Mapping.LayerContainer.SetBounds(element, biggerBounds);
}
}
}
/// <summary>${mapping_HeatMapLayer_constructor_None_D}</summary>
public HeatMapLayer()
{
heatPoints = new HeatPointCollection();
heatPoints.CollectionChanged += new NotifyCollectionChangedEventHandler(heatPoints_CollectionChanged);
fullBounds = Rectangle2D.Empty;
//设置GradientStops的默认值
GradientStopCollection stops = new GradientStopCollection();
stops.Add(new GradientStop() { Color = Color.FromArgb(0, 0, 0, 0), Offset = 0 });
stops.Add(new GradientStop() { Color = new Color() { A = 0xff, R = 0xff, G = 0x42, B = 0x00 }, Offset = 0.75 });
stops.Add(new GradientStop() { Color = new Color() { A = 0xff, R = 0xff, G = 0xff, B = 0x00 }, Offset = .5 });
stops.Add(new GradientStop() { Color = new Color() { A = 0xff, R = 0x1a, G = 0xa4, B = 0x03 }, Offset = .25 });
GradientStops = stops;
//初始化后台线程
worker = new BackgroundWorker { WorkerReportsProgress = true, WorkerSupportsCancellation = true };
worker.ProgressChanged += new ProgressChangedEventHandler(worker_ProgressChanged);
worker.RunWorkerCompleted += new RunWorkerCompletedEventHandler(worker_RunWorkerCompleted);
worker.DoWork += new DoWorkEventHandler(worker_DoWork);
}
/// <summary>${core_Rectangle2D_method_equals_D}</summary>
/// <returns>${core_Rectangle2D_method_equals_return}</returns>
/// <overloads>${core_Rectangle2D_method_equals_overloads}</overloads>
/// <param name="rectangle">${core_Rectangle2D_method_equals_param_rectangle}</param>
public bool Equals(Rectangle2D rectangle)
{
return (this == rectangle);
}
