Пример #1
0
        ///// <summary>
        ///// snapping specific for a tool. Called before layer specific snappping is applied.
        ///// </summary>
        ///// <param name="sourceLayer"></param>
        ///// <param name="snapSource"></param>
        ///// <param name="worldPos"></param>
        ///// <param name="Envelope"></param>
        ///// <returns></returns>
        public void Snap(ILayer sourceLayer, IGeometry snapSource, ICoordinate worldPos, IEnvelope Envelope)
        {
            SnapResult = null;
            IFeature sourceFeature = MapControl.SelectTool.FeatureEditors[0].SourceFeature;

            if (sourceFeature.Geometry != snapSource)
            {
                return;
            }
            SnapRole snapRole = SnapRole.FreeAtObject;

            if ((Control.ModifierKeys & Keys.Control) == Keys.Control)
            {
                snapRole = SnapRole.Free;
            }
            ISnapRule snapRule = new SnapRule
            {
                SourceLayer  = sourceLayer,
                TargetLayer  = sourceLayer,
                Obligatory   = true,
                SnapRole     = snapRole,
                PixelGravity = 4
            };

            SnapResult = MapControl.SnapTool.ExecuteSnapRule(
                snapRule,
                sourceFeature,
                sourceFeature.Geometry,
                new List <IFeature>
            {
                sourceFeature
            },
                worldPos,
                -1);
        }
Пример #2
0
        public ISnapResult Snap(ILayer layer, SnapRole snapRole, IGeometry snapSource, ICoordinate worldPos, IEnvelope envelope, int pixelGravity, IList <IFeature> snapTargets)
        {
            var targetVectorLayer = (VectorLayer)layer;
            var snapCandidates    = targetVectorLayer.DataSource.GetFeatures(envelope);

            if (!layer.Enabled)
            {
                return(null);
            }
            // hack preserve snapTargets functionality
            IList <IGeometry> snapTargetGeometries = new List <IGeometry>();

            if (null != snapTargets)
            {
                for (int i = 0; i < snapTargets.Count; i++)
                {
                    snapTargetGeometries.Add(snapTargets[i].Geometry);
                }
            }
            double      minDistance = double.MaxValue; // TODO: incapsulate minDistance in ISnapResult
            ISnapResult snapResult  = null;

            foreach (IFeature feature in snapCandidates)
            {
                IGeometry geometry = feature.Geometry;
                if ((null != snapTargets) && (snapTargetGeometries.IndexOf(geometry) == -1))
                {
                    continue;
                }
                if (snapRole == SnapRole.None)
                {
                    continue;
                }
                if (geometry is IPolygon)
                {
                    IPolygon polygon = (IPolygon)geometry;
                    switch (snapRole)
                    {
                    case SnapRole.Free:
                        SnappingHelper.PolygonSnapFree(ref minDistance, ref snapResult, polygon, worldPos);
                        break;

                    default:
                        //case SnapRole.FreeAtObject:
                        SnappingHelper.PolygonSnapFreeAtObject(ref minDistance, ref snapResult, polygon, worldPos);
                        break;
                    }
                }
                if (geometry is ILineString)
                {
                    ILineString lineString = (ILineString)geometry;

                    switch (snapRole)
                    {
                    case SnapRole.Free:
                        SnappingHelper.LineStringSnapFree(ref minDistance, ref snapResult, lineString, worldPos);
                        break;

                    case SnapRole.FreeAtObject:
                        SnappingHelper.LineStringSnapFreeAtObject(ref minDistance, ref snapResult, feature, lineString, worldPos);
                        break;

                    case SnapRole.TrackersNoStartNoEnd:
                        break;

                    case SnapRole.AllTrackers:
                        SnappingHelper.LineStringSnapAllTrackers(ref minDistance, ref snapResult, lineString, worldPos);
                        break;

                    case SnapRole.Start:
                        SnappingHelper.LineStringSnapStart(ref snapResult, lineString);
                        break;

                    case SnapRole.End:
                        SnappingHelper.LineStringSnapEnd(ref snapResult, lineString);
                        break;

                    case SnapRole.StartEnd:
                        SnappingHelper.LineStringSnapStartEnd(ref minDistance, ref snapResult, lineString, worldPos);
                        break;
                    }
                }
                else if (geometry is IPoint)
                {
                    SnappingHelper.PointSnap(ref snapResult, geometry);
                }
            } // foreach (IGeometry geometry in snapCandidates)
            return(snapResult);
        }
Пример #3
0
        public ISnapResult Snap(ILayer layer, SnapRole snapRole, IGeometry snapSource, ICoordinate worldPos, IEnvelope envelope, int pixelGravity, IList<IFeature> snapTargets)
        {
            var targetVectorLayer = (VectorLayer)layer;
            var snapCandidates = targetVectorLayer.DataSource.GetFeatures(envelope);

            if (!layer.Enabled)
                return null;
            // hack preserve snapTargets functionality
            IList<IGeometry> snapTargetGeometries = new List<IGeometry>();
            if (null != snapTargets)
            {
                for (int i = 0; i < snapTargets.Count; i++)
                {
                    snapTargetGeometries.Add(snapTargets[i].Geometry);
                }
            }
            double minDistance = double.MaxValue; // TODO: incapsulate minDistance in ISnapResult
            ISnapResult snapResult = null;
            foreach (IFeature feature in snapCandidates)
            {
                IGeometry geometry = feature.Geometry;
                if ((null != snapTargets) && (snapTargetGeometries.IndexOf(geometry) == -1))
                    continue;
                if (snapRole == SnapRole.None) 
                    continue;
                if (geometry is IPolygon)
                {
                    IPolygon polygon = (IPolygon)geometry;
                    switch (snapRole)
                    {
                        case SnapRole.Free:
                            SnappingHelper.PolygonSnapFree(ref minDistance, ref snapResult, polygon, worldPos);
                            break;
                        default:
                            //case SnapRole.FreeAtObject:
                            SnappingHelper.PolygonSnapFreeAtObject(ref minDistance, ref snapResult, polygon, worldPos);
                            break;
                    }
                }
                if (geometry is ILineString)
                {
                    ILineString lineString = (ILineString)geometry;

                    switch (snapRole)
                    {
                        case SnapRole.Free:
                            SnappingHelper.LineStringSnapFree(ref minDistance, ref snapResult, lineString, worldPos);
                            break;
                        case SnapRole.FreeAtObject:
                            SnappingHelper.LineStringSnapFreeAtObject(ref minDistance, ref snapResult, feature, lineString, worldPos);
                            break;
                        case SnapRole.TrackersNoStartNoEnd:
                            break;
                        case SnapRole.AllTrackers:
                            SnappingHelper.LineStringSnapAllTrackers(ref minDistance, ref snapResult, lineString, worldPos);
                            break;
                        case SnapRole.Start:
                            SnappingHelper.LineStringSnapStart(ref snapResult, lineString);
                            break;
                        case SnapRole.End:
                            SnappingHelper.LineStringSnapEnd(ref snapResult, lineString);
                            break;
                        case SnapRole.StartEnd:
                            SnappingHelper.LineStringSnapStartEnd(ref minDistance, ref snapResult, lineString, worldPos);
                            break;
                    }
                }
                else if (geometry is IPoint)
                {
                    SnappingHelper.PointSnap(ref snapResult, geometry);
                }
            } // foreach (IGeometry geometry in snapCandidates)
            return snapResult;
        }