C# Feature.GetShape方法代码示例

        void CheckOverlayWithinBounds(Feature feature)
        {
            var errors = new List<string>();
            _geoArray = GeoArray.FromWellKnownText(feature.GetWellKnownText());
            OnPropertyChanged("GeoArray");
#if false
            if (_writeKML)
            {
                var kml = new KMLRoot();
                var folder = new Folder("Overlay Segment Test");
                var segments = _geoArray.Segments.ToArray();
                for (var segment = 0; segment < segments.Length; segment++)
                {
                    segments[segment].Placemark.name = string.Format("Segment {0}", segment);
                    folder.Add(segments[segment].Placemark);
                }
                kml.Document.Add(folder);
                var savePath = Path.Combine(System.Environment.GetFolderPath(System.Environment.SpecialFolder.MyDocuments), "Overlay Segment Tests", "OverlaySegmentTest.kml");
                kml.Save(savePath);
                _writeKML = false;
            }
#endif
            if (_geoArray.HasCrossingSegments && !AreCrossingSegmentsAllowed) errors.Add("Perimeter segments may not cross");
            if (_locationBoundsRectangle != null && !_locationBoundsRectangle.Contains(feature.GetShape())) errors.Add("Perimeter must be within location bounds");
            var areaStyle = errors.Count > 0 ? _errorAreaStyle : _normalAreaStyle;
            _wpfMap.EditOverlay.EditShapesLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle = areaStyle;
            _wpfMap.EditOverlay.EditShapesLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;
            Errors = errors.Count == 0 ? string.Empty : string.Join("\n", errors);
            HasErrors = errors.Count > 0;
            if (HasErrors) Debug.WriteLine(string.Format("Errors: {0}", Errors));
        }

 protected override IEnumerable<Feature> CalculateResizeControlPointsCore(Feature feature)
 {
     // Override the base method and modify the control points for resizing if the shape is the "custom"
     var resizeControlPoints = new Collection<Feature>();
     var polygonShape = feature.GetShape() as PolygonShape;
     if (polygonShape != null) foreach (var vertex in polygonShape.OuterRing.Vertices) resizeControlPoints.Add(new Feature(vertex, feature.Id));
     return resizeControlPoints;
 }

 protected override void DeleteCore(Feature feature)
 {
     int level = QTreeHelper.GetAppropriateLevel(maxExtent, feature.GetBoundingBox());
     ulong location = QTreeHelper.GetLocation(maxExtent, feature.GetShape(), level);
     if (location == 0 && qtree.ContainsKey(location))
     {
         qtree.Remove(location);
     }
 }

 protected override Feature ResizeFeatureCore(Feature sourceFeature, PointShape sourceControlPoint, PointShape targetControlPoint)
 {
     // Override the base method and modify the logic for resizing if the shape is the "custom"
     var polygonShape = sourceFeature.GetShape() as PolygonShape;
     if (polygonShape != null)
     {
         // If the rectangle is horizontal or vertical, it will use the custom method.
         if (string.Equals(polygonShape.GetBoundingBox().GetWellKnownText(), polygonShape.GetWellKnownText()))
         {
             var fixedPointIndex = GetFixedPointIndex(polygonShape, sourceControlPoint);
             var fixedPointShape = new PointShape(polygonShape.OuterRing.Vertices[fixedPointIndex]);
             var newRectangleShape = new LineShape(new[] { new Vertex(fixedPointShape), new Vertex(targetControlPoint) }).GetBoundingBox();
             return base.ResizeFeatureCore(new Feature(newRectangleShape.GetWellKnownBinary(), sourceFeature.Id, sourceFeature.ColumnValues),
                                           targetControlPoint,
                                           targetControlPoint);
         }
     }
     return base.ResizeFeatureCore(sourceFeature, sourceControlPoint, targetControlPoint);
 }

 protected override void AddCore(Feature feature)
 {
     int level = QTreeHelper.GetAppropriateLevel(maxExtent, feature.GetBoundingBox());
     ulong location = QTreeHelper.GetLocation(maxExtent, feature.GetShape(), level);
     if (location != 0)
     {
         QuadCell cell = QTreeHelper.GetCellByLocation(maxExtent, location);
         lock (sync)
         {
             if (!qtree.ContainsKey(location))
             {
                 lock (sync)
                 {
                     QuadTreeNode node = new QuadTreeNode(cell.Location, cell.BoundingBox, feature.Id);
                     qtree.Add(location, node);
                 }
                 if (maxLevel < level)
                 {
                     maxLevel = level;
                 }
             }
         }
     }
 }

 //public static string GetLocation(RectangleShape extent, BaseShape shape, int level)
 //{
 //    RectangleShape extentBoundingBox = SquaredExtent(extent);
 //    RectangleShape shapeBoundingBox = shape.GetBoundingBox();
 //    string location = string.Empty;
 //    if (shapeBoundingBox.IsWithin(extentBoundingBox))
 //    {
 //        location += "0";
 //        int currentlevel = 1;
 //        while (currentlevel < level)
 //        {
 //            RectangleShape upperLeft = GetUpperLeftQuater(extentBoundingBox);
 //            RectangleShape uppperRight = GetUpperRightQuater(extentBoundingBox);
 //            RectangleShape lowerLeft = GetLowerLeftQuater(extentBoundingBox);
 //            RectangleShape lowerRight = GetLowerRightQuater(extentBoundingBox);
 //            if (shapeBoundingBox.IsWithin(upperLeft))
 //            {
 //                location += "1";
 //                currentlevel++;
 //                extentBoundingBox = upperLeft;
 //            }
 //            else if (shapeBoundingBox.IsWithin(uppperRight))
 //            {
 //                location += "2";
 //                currentlevel++;
 //                extentBoundingBox = uppperRight;
 //            }
 //            else if (shapeBoundingBox.IsWithin(lowerLeft))
 //            {
 //                location += "3";
 //                currentlevel++;
 //                extentBoundingBox = lowerLeft;
 //            }
 //            else if (shapeBoundingBox.IsWithin(lowerRight))
 //            {
 //                location += "4";
 //                currentlevel++;
 //                extentBoundingBox = lowerRight;
 //            }
 //            else
 //            {
 //                break;
 //            }
 //        }
 //    }
 //    return location;
 //}
 public static int GetAppropriateLevel(RectangleShape extent, Feature feature)
 {
     return GetAppropriateLevel(extent, feature.GetShape());
 }

 public static ulong GetLocation(RectangleShape extent, Feature feature, int level)
 {
     return GetLocation(extent, feature.GetShape(), level);
 }

 public static Collection<QuadCell> GetIntersectingCells(RectangleShape extent, Feature feature, int startLevel, int endLevel)
 {
     return GetIntersectingCells(extent, feature.GetShape(), startLevel, endLevel);
 }

        internal static Collection<LineShape> GetLineShapes(Feature feature)
        {
            Collection<LineShape> lineShapes = new Collection<LineShape>();

            LineBaseShape lineBaseShape = feature.GetShape() as LineBaseShape;
            if (lineBaseShape is MultilineShape)
            {
                MultilineShape multiLineShape = lineBaseShape as MultilineShape;
                lineShapes = multiLineShape.Lines;
            }
            else if (lineBaseShape is LineShape)
            {
                lineShapes.Add((LineShape)lineBaseShape);
            }
            else
            {
                throw new NotSupportedException("Only the data which includes the line shapes is supported.");
            }

            return lineShapes;
        }