private static RemoveOverlapsRequest CreateRemoveOverlapsRequest(
            IEnumerable <Feature> selectedFeatures,
            Overlaps overlapsToRemove,
            IList <Feature> targetFeaturesForVertexInsertion,            //RemoveOverlapsOptions options,
            out List <Feature> updateFeatures)
        {
            var request = new RemoveOverlapsRequest
            {
                ExplodeMultipartResults    = true,          // options.ExplodeMultipartResults,
                StoreOverlapsAsNewFeatures =
                    false                                   // options.StoreOverlapsAsNewFeatures
            };

            updateFeatures = new List <Feature>();

            var selectedFeatureList = CollectionUtils.GetCollection(selectedFeatures);

            ProtobufConversionUtils.ToGdbObjectMsgList(
                selectedFeatureList, request.SourceFeatures, request.ClassDefinitions);

            updateFeatures.AddRange(selectedFeatureList);

            foreach (var overlapsBySourceRef in overlapsToRemove.OverlapGeometries)
            {
                int classId  = (int)overlapsBySourceRef.Key.ClassId;
                int objectId = (int)overlapsBySourceRef.Key.ObjectId;

                var overlapMsg = new OverlapMsg();
                overlapMsg.OriginalFeatureRef = new GdbObjRefMsg()
                {
                    ClassHandle = classId,
                    ObjectId    = objectId
                };

                foreach (Geometry overlap in overlapsBySourceRef.Value)
                {
                    overlapMsg.Overlaps.Add(ProtobufConversionUtils.ToShapeMsg(overlap, true));
                }

                request.Overlaps.Add(overlapMsg);
            }

            if (targetFeaturesForVertexInsertion != null)
            {
                ProtobufConversionUtils.ToGdbObjectMsgList(
                    targetFeaturesForVertexInsertion, request.UpdatableTargetFeatures,
                    request.ClassDefinitions);

                updateFeatures.AddRange(targetFeaturesForVertexInsertion);
            }

            return(request);
        }
예제 #2
0
        public void CanRemoveOverlaps()
        {
            var fClass =
                new GdbFeatureClass(123, "TestFC", esriGeometryType.esriGeometryPolygon);

            var sr = SpatialReferenceUtils.CreateSpatialReference(
                WellKnownHorizontalCS.LV95,
                WellKnownVerticalCS.LN02);

            IPolygon polygon1 = GeometryFactory.CreatePolygon(
                GeometryFactory.CreatePoint(2600000, 1200000, sr),
                GeometryFactory.CreatePoint(2601000, 1201000, sr));

            polygon1.SpatialReference = sr;

            GdbFeature sourceFeature = new GdbFeature(42, fClass)
            {
                Shape = polygon1
            };

            IPolygon polygon2 = GeometryFactory.CreatePolygon(
                GeometryFactory.CreatePoint(2600500, 1200500, sr),
                GeometryFactory.CreatePoint(2601500, 1201500, sr));

            polygon2.SpatialReference = sr;

            GdbFeature targetFeature = new GdbFeature(43, fClass)
            {
                Shape = polygon2
            };

            IPolygon overlap = GeometryFactory.CreatePolygon(
                GeometryFactory.CreatePoint(2600500, 1200500, sr),
                GeometryFactory.CreatePoint(2601000, 1201000, sr));

            overlap.SpatialReference = sr;

            var sourceFeatureMsg = ProtobufGdbUtils.ToGdbObjectMsg(sourceFeature);
            var targetFeatureMsg = ProtobufGdbUtils.ToGdbObjectMsg(targetFeature);

            var objectClassMsg = ProtobufGdbUtils.ToObjectClassMsg(sourceFeature.Class);

            var removeRequest = new RemoveOverlapsRequest()
            {
                ClassDefinitions =
                {
                    objectClassMsg
                },
                SourceFeatures =
                {
                    sourceFeatureMsg
                },
                UpdatableTargetFeatures =
                {
                    targetFeatureMsg
                }
            };

            var overlapsMsg = new OverlapMsg();

            overlapsMsg.OriginalFeatureRef = new GdbObjRefMsg()
            {
                ClassHandle = sourceFeatureMsg.ClassHandle,
                ObjectId    = sourceFeatureMsg.ObjectId
            };

            overlapsMsg.Overlaps.Add(ProtobufGeometryUtils.ToShapeMsg(overlap));

            removeRequest.Overlaps.Add(overlapsMsg);

            RemoveOverlapsResponse removeResponse =
                RemoveOverlapsServiceUtils.RemoveOverlaps(removeRequest);

            Assert.AreEqual(1, removeResponse.ResultsByFeature.Count);
            ResultGeometriesByFeature resultByFeature = removeResponse.ResultsByFeature[0];

            GdbObjectReference originalObjRef = new GdbObjectReference(
                resultByFeature.OriginalFeatureRef.ClassHandle,
                resultByFeature.OriginalFeatureRef.ObjectId);

            Assert.AreEqual(new GdbObjectReference(sourceFeature), originalObjRef);

            IGeometry updatedGeometry =
                ProtobufGeometryUtils.FromShapeMsg(resultByFeature.UpdatedGeometry);

            Assert.IsNotNull(updatedGeometry);
            Assert.AreEqual(1000 * 1000 * 3 / 4, ((IArea)updatedGeometry).Area);

            Assert.AreEqual(0, resultByFeature.NewGeometries.Count);

            IFeature updatedTarget =
                ProtobufConversionUtils.FromGdbObjectMsgList(removeResponse.TargetFeaturesToUpdate,
                                                             removeRequest.ClassDefinitions)
                .Single();

            int pointCount = GeometryUtils.GetPointCount(updatedTarget.Shape);

            Assert.AreEqual(5 + 2, pointCount);
        }
예제 #3
0
        public static CalculateOverlapsResponse CalculateOverlaps(
            [NotNull] CalculateOverlapsRequest request,
            [CanBeNull] ITrackCancel trackCancel)
        {
            var watch = Stopwatch.StartNew();

            IList <IFeature> sourceFeatures =
                ProtobufConversionUtils.FromGdbObjectMsgList(
                    request.SourceFeatures, request.ClassDefinitions);

            IList <IFeature> targetFeatures =
                ProtobufConversionUtils.FromGdbObjectMsgList(
                    request.TargetFeatures, request.ClassDefinitions);

            _msg.DebugStopTiming(watch, "Unpacked feature lists from request params");

            Overlaps selectableOverlaps = RemoveOverlapsUtils.GetSelectableOverlaps(
                sourceFeatures, targetFeatures, trackCancel);

            watch = Stopwatch.StartNew();

            var result = new CalculateOverlapsResponse();

            foreach (var overlapByGdbRef
                     in selectableOverlaps.OverlapsBySourceRef)
            {
                var gdbObjRefMsg = ProtobufGdbUtils.ToGdbObjRefMsg(overlapByGdbRef.Key);

                var overlap = overlapByGdbRef.Value;

                var overlapsMsg = new OverlapMsg()
                {
                    OriginalFeatureRef = gdbObjRefMsg
                };

                foreach (IGeometry geometry in overlap)
                {
                    // TODO: At some point the SR-XY tol/res should be transferred separately (via class-lookup?)
                    var shapeFormat = ShapeMsg.FormatOneofCase.EsriShape;
                    var srFormat    = SpatialReferenceMsg.FormatOneofCase.SpatialReferenceEsriXml;

                    overlapsMsg.Overlaps.Add(
                        ProtobufGeometryUtils.ToShapeMsg(
                            geometry, shapeFormat, srFormat));

                    if (_msg.IsVerboseDebugEnabled)
                    {
                        _msg.VerboseDebug(
                            $"Calculated overlap: {GeometryUtils.ToString(geometry)}");
                    }
                }

                result.Overlaps.Add(overlapsMsg);
            }

            foreach (var notification in selectableOverlaps.Notifications)
            {
                result.Notifications.Add(notification.Message);
            }

            _msg.DebugStopTiming(watch, "Packed overlaps into response");

            return(result);
        }