/// <summary>
        /// Get Envelope in external coordinates.
        /// </summary>
        /// <param name="precisionModel"></param>
        /// <param name="envelope"></param>
        /// <returns></returns>
		public static IEnvelope GetEnvelopeExternal(PrecisionModel precisionModel, IEnvelope envelope)
		{
			// get envelose in external coordinates
			Coordinate min = new Coordinate(envelope.Minimum.X, envelope.Minimum.Y); 
			Coordinate max = new Coordinate(envelope.Maximum.X, envelope.Maximum.Y);
			// min = precisionModel.ToExternal(min);            
			// max = precisionModel.ToExternal(max);            
			Envelope bounds = new Envelope(min.X, max.X, min.Y, max.Y);
			return bounds;
		}
        /// <summary>
        /// 
        /// </summary>
        /// <param name="querySeg"></param>
        /// <returns></returns>
        public virtual IList Query(LineSegment querySeg)
        {
            Envelope env = new Envelope(querySeg.P0, querySeg.P1);

            LineSegmentVisitor visitor = new LineSegmentVisitor(querySeg);
            index.Query(env, visitor);
            IList itemsFound = visitor.Items;        

            return itemsFound;
        }
示例#3
0
        /// <summary>
        /// 
        /// </summary>
        /// <param name="node"></param>
        /// <param name="addEnv"></param>
        /// <returns></returns>
        public static Node CreateExpanded(Node node, IEnvelope addEnv)
        {
            Envelope expandEnv = new Envelope(addEnv);
            if (node != null) 
                expandEnv.ExpandToInclude(node.env);

            Node largerNode = CreateNode(expandEnv);
            if (node != null) 
                largerNode.InsertNode(node);
            return largerNode;
        }
        /// <summary>
        /// Overrides the OnMouseUp event to handle the situation where we are tyring to
        /// identify the vector features in the specified area.
        /// </summary>
        /// <param name="e"></param>
        protected override void OnMouseUp(GeoMouseArgs e)
        {
            Coordinate c1 = e.Map.PixelToProj(new System.Drawing.Point(e.X - 8, e.Y - 8));
            Coordinate c2 = e.Map.PixelToProj(new System.Drawing.Point(e.X + 8, e.Y + 8));
            Coordinate s1 = e.Map.PixelToProj(new System.Drawing.Point(e.X - 1, e.Y - 1));
            Coordinate s2 = e.Map.PixelToProj(new System.Drawing.Point(e.X + 1, e.Y + 1));
            Coordinate center = e.Map.PixelToProj(new System.Drawing.Point(e.X, e.Y));
            IEnvelope tolerant = new Envelope(c1, c2);
            IEnvelope strict = new Envelope(s1, s2);

            if (frmFeatureIdentifier == null)
            {
                frmFeatureIdentifier = new FeatureIdentifier();
            }
            frmFeatureIdentifier.SuspendLayout();
            frmFeatureIdentifier.Clear();
            Identify(e.Map.MapFrame.GetLayers(), strict, tolerant);
            frmFeatureIdentifier.ReSelect();
            frmFeatureIdentifier.ResumeLayout();
            frmFeatureIdentifier.Show();
            base.OnMouseUp(e);
        }
示例#5
0
        /// <summary>
        /// returns only the features that have envelopes that
        /// intersect with the specified envelope.  If in indexMode, this uses the ShapeIndices to create
        /// features on demand, rather than loading all the features.  It is much faster to use selectIndices
        /// when in index mode.
        /// </summary>
        /// <param name="region">The specified region to test for intersect with</param>
        /// <param name="affectedRegion">This returns the geographic extents that contains the modified contents.</param>
        /// <returns>A List of the IFeature elements that are contained in this region</returns>
        public virtual List<IFeature> Select(IEnvelope region, out IEnvelope affectedRegion)
        {
            List<IFeature> result = new List<IFeature>();
            if(IndexMode)
            {
                ShapeRange aoi = new ShapeRange(new Extent(region));
                IEnvelope env = region.Copy();
                Extent affected = new Extent();
                List<ShapeRange> shapes = ShapeIndices;
                if(shapes != null)
                {
                    for(int shp = 0; shp < shapes.Count; shp++)
                    {
                        if (!shapes[shp].Intersects(aoi)) continue;
                        IFeature f = GetFeature(shp);
                        affected.ExpandToInclude(shapes[shp].Extent);
                        result.Add(f);
                    }
                }
                affectedRegion = affected.ToEnvelope();
                return result;
            }

            affectedRegion = new Envelope();

            foreach (IFeature feature in Features)
            {
                if (!feature.Envelope.Intersects(region)) continue;
                result.Add(feature);
                affectedRegion.ExpandToInclude(feature.Envelope);
            }
            return result;

        }
        /// <summary>
        /// Handles the Mouse Up situation
        /// </summary>
        /// <param name="e"></param>
        protected override void OnMouseUp(GeoMouseArgs e)
        {
            Stopwatch sw = new Stopwatch();
            sw.Start();
            if (_isDragging == false) return;
            _currentPoint = e.Location;
            _isDragging = false;
            //Map.Invalidate(); // Get rid of the selection box
            //Application.DoEvents();
            IEnvelope env = new Envelope(_geoStartPoint.X, e.GeographicLocation.X, _geoStartPoint.Y, e.GeographicLocation.Y);
            IEnvelope tolerant = env;
           
            if(_startPoint.X == e.X && _startPoint.Y == e.Y)
            {
                // click selection doesn't work quite right without some tiny tolerance.
                double tol = Map.MapFrame.Extents.Width/10000;
                env.ExpandBy(tol);
            }

            if (Math.Abs(_startPoint.X - e.X) < 8 && Math.Abs(_startPoint.Y - e.Y) < 8)
            {
                Coordinate c1 = e.Map.PixelToProj(new System.Drawing.Point(e.X - 4, e.Y - 4));
                Coordinate c2 = e.Map.PixelToProj(new System.Drawing.Point(e.X + 4, e.Y + 4));
                tolerant = new Envelope(c1, c2);
            }

            Map.MapFrame.SuspendEvents();
            HandleSelection(tolerant, env);
            Map.MapFrame.ResumeEvents();
            // Force an invalidate to clear the dotted lines, even if we haven't changed anything.
            e.Map.Invalidate();
            //e.Map.MapFrame.Initialize();
            sw.Stop();
           
            Debug.WriteLine("Initialize: " + sw.ElapsedMilliseconds);
            base.OnMouseUp(e);
        }
 /// <summary> 
 /// Test whether a point lies in the envelopes of both input segments.
 /// A correctly computed intersection point should return <c>true</c>
 /// for this test.
 /// Since this test is for debugging purposes only, no attempt is
 /// made to optimize the envelope test.
 /// </summary>
 /// <param name="intPt"></param>
 /// <returns><c>true</c> if the input point lies within both input segment envelopes.</returns>
 private bool IsInSegmentEnvelopes(Coordinate intPt)
 {
     Envelope env0 = new Envelope(InputLines[0, 0], InputLines[0, 1]);
     Envelope env1 = new Envelope(InputLines[1, 0], InputLines[1, 1]);
     return env0.Contains(intPt) && env1.Contains(intPt);
 }
        /// <summary>
        /// This uses extent checking (rather than full polygon intersection checking).  It will add
        /// any members that are either contained by or intersect with the specified region
        /// depending on the SelectionMode property.  The order of operation is the region
        /// acting on the feature, so Contains, for instance, would work with points.
        /// </summary>
        /// <param name="region"></param>
        /// <param name="affectedArea">The affected area of this addition</param>
        /// <returns>True if any item was actually added to the collection</returns>
        public bool AddRegion(IEnvelope region, out IEnvelope affectedArea)
        {
            bool added = false;
            SuspendChanges();
            affectedArea = new Envelope();
            Stopwatch sw = new Stopwatch();
            Stopwatch total = new Stopwatch();
            total.Start();
            foreach (IFeature f in FeatureList)
            {
                bool doAdd = false;
                if (_selectionMode == SelectionModes.IntersectsExtent)
                {
                    if (region.Intersects(f.Envelope))
                    {
                        Add(f);
                        affectedArea.ExpandToInclude(f.Envelope);
                        added = true;
                    }
                }
                else if (_selectionMode == SelectionModes.ContainsExtent)
                {
                    if (region.Contains(f.Envelope))
                    {
                        Add(f);
                        affectedArea.ExpandToInclude(f.Envelope);
                        added = true;
                    }
                }

                IGeometry reg;
                if(region.Width == 0 && region.Height == 0)
                {
                    reg = new Point(region.X, region.Y);
                }
                else if (region.Height == 0 || region.Width == 0)
                {
                    Coordinate[] coords = new Coordinate[2];
                    coords[0] = new Coordinate(region.X, region.Y);
                    coords[1] = new Coordinate(region.Bottom(), region.Right());
                    reg = new LineString(coords);
                }
                else
                {
                    reg = region.ToPolygon();
                }
                IGeometry geom = Geometry.FromBasicGeometry(f.BasicGeometry);
                switch (_selectionMode)
                {
                    case SelectionModes.Contains:
                        if(region.Contains(f.Envelope))
                        {
                         
                            doAdd = true;
                        }
                        else if (region.Intersects(f.Envelope))
                        {
                            
                            if (reg.Contains(geom)) doAdd = true;
                            
                        }
                        break;
                    case SelectionModes.CoveredBy:
                        if (reg.CoveredBy(geom)) doAdd = true;
                        break;
                    case SelectionModes.Covers:
                        if (reg.Covers(geom)) doAdd = true;
                        break;
                    case SelectionModes.Disjoint:
                        if (reg.Disjoint(geom)) doAdd = true;
                        break;
                    case SelectionModes.Intersects:
                        
                        if (region.Contains(f.Envelope))
                        {
                            doAdd = true;
                        }
                        else if (region.Intersects(f.Envelope))
                        {
                            if (reg.Intersects(geom)) doAdd = true;
                        }
                       
                        break;
                    case SelectionModes.Overlaps:
                        if (reg.Overlaps(geom)) doAdd = true;
                        break;
                    case SelectionModes.Touches:
                        if (reg.Touches(geom)) doAdd = true;
                        break;
                    case SelectionModes.Within:
                        if (reg.Within(geom)) doAdd = true;
                        break;
                }

                if (doAdd)
                {
                    Add(f);
                    affectedArea.ExpandToInclude(f.Envelope);
                    added = true;
                }
            }
            sw.Start();
            ResumeChanges();
            sw.Stop();
            total.Stop();
            Debug.WriteLine("Geometry Intersection Time: " + sw.ElapsedMilliseconds);
            Debug.WriteLine("Total Intersection Time: " + total.ElapsedMilliseconds);
            return added;
           
        }
 private IEnvelope GetEnvelope()
 {
     IEnvelope env = new Envelope();
     foreach (IFeature f in this)
     {
         env.ExpandToInclude(f.Envelope);
     }
     return env;
 }
示例#10
0
        /// <summary>
        /// Un-highlights or returns the features from the specified region.  The specified selectionMode
        /// will be used to determine how to choose features.
        /// </summary>
        /// <param name="tolerant">The geographic envelope in cases like cliking near points where tolerance is allowed</param>
        /// <param name="strict">The geographic region when working with absolutes, without a tolerance</param>
        /// <param name="affectedArea">The geographic envelope that will be visibly impacted by the change</param>
        /// <param name="selectionMode">The selection mode that controls how to choose members relative to the region </param>
        /// <returns>Boolean, true if members were removed from the selection.</returns>
        public override bool UnSelect(IEnvelope tolerant, IEnvelope strict, SelectionModes selectionMode, out IEnvelope affectedArea)
        {
            if (!_drawnStatesNeeded && !_editMode) AssignFastDrawnStates();
            IEnvelope region = tolerant;
            if (DataSet.FeatureType == FeatureTypes.Polygon) region = strict;
            affectedArea = new Envelope();

            bool changed = false;
            if (IsWithinLegendSelection() || _scheme.IsWithinLegendSelection())
            {
                if (_editMode)
                {

                    _selection.SelectionMode = selectionMode;
                    changed = _selection.RemoveRegion(region, out affectedArea);
                }
                else
                {
                    _selection.SelectionMode = selectionMode;
                    changed = _selection.RemoveRegion(region, out affectedArea);
                }
            }
            else
            {
                SuspendChangeEvent();
                _selection.SuspendChanges();
                List<IFeatureCategory> categories = _scheme.GetCategories().ToList();
                foreach (IFeatureCategory category in categories)
                {
                    if (!category.IsSelected) continue;
                    _selection.RegionCategory = category;
                    _selection.RemoveRegion(region, out affectedArea);
                    _selection.RegionCategory = null;
                }
                _selection.ResumeChanges();
                ResumeChangeEvent();
            }
            return changed;
        }
示例#11
0
        /// <summary>
        /// Performs an intersection of this line segment with the specified envelope
        /// </summary>
        /// <param name="inEnvelope">The envelope to compare against</param>
        /// <returns>An ILineSegment, or null if there is no intersection.</returns>
        public ILineSegment Intersection(Envelope inEnvelope)
        {

            return inEnvelope.Intersection(this);
            
        }
示例#12
0
        /// <summary>
        /// Executes the Erase Opaeration tool programaticaly
        /// </summary>
        /// <param name="input1">The input raster</param>
        /// <param name="input2">The input raster</param>
        /// <param name="output">The output raster</param>
        /// <param name="cancelProgressHandler">The progress handler</param>
        /// <returns></returns>
        public bool Execute(IRaster input1, IRaster input2, IRaster output, MapWindow.Tools.ICancelProgressHandler cancelProgressHandler)
        {
            //Validates the input and output data
            if (input1 == null || input2 == null || output == null)
            {
                return false;
            }

            IEnvelope envelope = new Envelope() as IEnvelope;

            envelope = UnionEnvelope(input1, input2);

            int noOfCol;
            int noOfRow;

            //Figures out which raster has smaller cells
            IRaster smallestCellRaster;
            if (input1.CellWidth < input2.CellWidth) smallestCellRaster = input1;
            else smallestCellRaster = input2;

            //Given the envelope of the two rasters we calculate the number of columns / rows
            noOfCol = Convert.ToInt32(Math.Abs(envelope.Width / smallestCellRaster.CellWidth));
            noOfRow = Convert.ToInt32(Math.Abs(envelope.Height / smallestCellRaster.CellHeight));

            //Create the new raster with the appropriate dimensions
            Raster Temp = new Raster();
            //Temp.CreateNew(output.Filename, noOfRow, noOfCol, input1.DataType);
            Temp.CreateNew(output.Filename, "", noOfCol, noOfRow, 1, input1.DataType, new string[] { "" });

            Temp.CellWidth = smallestCellRaster.CellWidth;
            Temp.CellHeight = smallestCellRaster.CellHeight;
            Temp.Xllcenter = envelope.Minimum.X + (Temp.CellWidth / 2);
            Temp.Yllcenter = envelope.Minimum.Y + (Temp.CellHeight / 2);

            MapWindow.Geometries.ICoordinate I1 = new MapWindow.Geometries.Coordinate() as MapWindow.Geometries.ICoordinate;
            RcIndex v1 = new RcIndex();
            RcIndex v2 = new RcIndex();

            double val1;
            double val2;
            int previous=0;
            int current=0;
            int max = (Temp.Bounds.NumRows + 1);
            for (int i = 0; i < Temp.Bounds.NumRows; i++)
            {
                for (int j = 0; j < Temp.Bounds.NumColumns; j++)
                {
                    I1 = Temp.CellToProj(i, j);
                    v1 = input1.ProjToCell(I1);
                    if (v1.Row <= input1.EndRow && v1.Column <= input1.EndColumn && v1.Row > -1 && v1.Column > -1)
                        val1 = input1.Value[v1.Row, v1.Column];
                    else
                        val1 = input1.NoDataValue;

                    v2 = input2.ProjToCell(I1);
                    if (v2.Row <= input2.EndRow && v2.Column <= input2.EndColumn && v2.Row > -1 && v2.Column > -1)
                        val2 = input2.Value[v2.Row, v2.Column];
                    else
                        val2 = input2.NoDataValue;

                    if (val1 == input1.NoDataValue && val2 == input2.NoDataValue)
                    {
                        Temp.Value[i, j] = Temp.NoDataValue;
                    }
                    else if (val1 != input1.NoDataValue && val2 == input2.NoDataValue)
                    {
                        Temp.Value[i, j] = val1;
                    }
                    else if (val1 == input1.NoDataValue && val2 != input2.NoDataValue)
                    {
                        Temp.Value[i, j] = val2;
                    }
                    else
                    {
                        Temp.Value[i, j] = val1;
                    }

                    if (cancelProgressHandler.Cancel == true)
                        return false;
                }
                current = Convert.ToInt32(Math.Round(i * 100D / max));
                //only update when increment in persentage
                if(current>previous)
                    cancelProgressHandler.Progress("", current, current.ToString() + "% progress completed");
                previous = current;
            }

            output = Temp;
            output.Save();
            return true;
        }
示例#13
0
        /// <summary>
        /// This method inverts the selection for the specified region.  Members already a part of the selection
        /// will be removed from the selection, while members that are not a part of the selection will be added
        /// to the selection.
        /// </summary>
        /// <param name="tolerant">The region specifying where featuers should be added or removed from the selection</param>
        /// <param name="strict">With polygon selection it is better not to allow any tolerance since the polygons already contain it</param>
        /// <param name="affectedArea">The geographic region that will be impacted by the changes</param>
        /// <param name="selectionMode">The SelectionModes enumeration that clarifies how the features should interact with the region</param>
        public override bool InvertSelection(IEnvelope tolerant, IEnvelope strict, SelectionModes selectionMode, out IEnvelope affectedArea)
        {
            if (!_drawnStatesNeeded && !_editMode) AssignFastDrawnStates();
            IEnvelope region = tolerant;
            bool changed = false;
            affectedArea = new Envelope();
            if (DataSet.FeatureType == FeatureTypes.Polygon)
            {
                region = strict;
            }
            _selection.SelectionMode = selectionMode;
            if (IsWithinLegendSelection() || _scheme.IsWithinLegendSelection())
            {
                changed = _selection.InvertSelection(region, out affectedArea);
            }
            else
            {
                List<IFeatureCategory> categories = _scheme.GetCategories().ToList();
                foreach (IFeatureCategory category in categories)
                {
                    if (!category.IsWithinLegendSelection()) continue;
                    _selection.RegionCategory = category;
                    if (_selection.AddRegion(region, out affectedArea)) changed = true;
                    _selection.RegionCategory = null;
                }
            }
         
            return changed;

        }
示例#14
0
        /// <summary>
        /// Execute the union region for output envelope 
        /// </summary>
        /// <param name="input1">input raster</param>
        /// <param name="input2">input raster</param>
        /// <returns>Envelope</returns>
        private IEnvelope UnionEnvelope(IRaster input1, IRaster input2)
        {
            IEnvelope e1 = new Envelope() as IEnvelope;
            IEnvelope e2 = new Envelope() as IEnvelope;

            e1 = input1.Bounds.Envelope;
            e2 = input2.Bounds.Envelope;
            e1.ExpandToInclude(e2);
            return (e1);

        }
 /// <summary>
 /// 
 /// </summary>
 /// <returns></returns>
 protected override IEnvelope ComputeEnvelopeInternal()
 {
     Envelope envelope = new Envelope();
     for (int i = 0; i < _geometries.Length; i++)
         envelope.ExpandToInclude(_geometries[i].EnvelopeInternal);
     return envelope;
 }
示例#16
0
 /// <summary>
 /// 
 /// </summary>
 /// <returns></returns>
 protected override object ComputeBounds() 
 {
     Envelope bounds = null;
     for (IEnumerator i = ChildBoundables.GetEnumerator(); i.MoveNext(); ) 
     {
         IBoundable childBoundable = (IBoundable) i.Current;
         if (bounds == null) 
              bounds = new Envelope((Envelope)childBoundable.Bounds);                
         else bounds.ExpandToInclude((Envelope)childBoundable.Bounds);
     }
     return bounds;
 }
        /// <summary>
        /// Executes the Erase Opaeration tool programaticaly.
        /// </summary>
        /// <param name="input1">The input raster.</param>
        /// <param name="input2">The input raster.</param>
        /// <param name="output">The output raster.</param>
        /// <param name="cancelProgressHandler">The progress handler.</param>
        /// <returns></returns>
        public bool Execute(IRaster input1, IFeatureSet input2, IRaster output, MapWindow.Tools.ICancelProgressHandler cancelProgressHandler)
        {
            //Validates the input and output data
            if (input1 == null || input2 == null || output == null)
            {
                return false;
            }

            int noOfCol = input1.NumColumns;
            int noOfRow = input1.NumRows;

            //Calculate the Intersect Envelope
            IEnvelope envelope1 = new Envelope() as IEnvelope;
            IEnvelope envelope2 = new Envelope() as IEnvelope;
            envelope1 = input1.Bounds.Envelope;
            envelope2 = input2.Envelope;
            envelope1 = envelope1.Intersection(envelope2);

            //Create the new raster with the appropriate dimensions
            IRaster Temp = Raster.Create(output.Filename, "", noOfCol, noOfRow, 1, input1.DataType, new string[] { });
            //Temp.CreateNew(output.Filename, noOfRow, noOfCol, input1.DataType);
            Temp.CellWidth = input1.CellWidth;
            Temp.CellHeight = input1.CellHeight;
            Temp.Xllcenter = envelope1.Minimum.X + (Temp.CellWidth / 2);
            Temp.Yllcenter = envelope1.Minimum.Y + (Temp.CellHeight / 2);

            MapWindow.Geometries.ICoordinate I1 = new MapWindow.Geometries.Coordinate() as MapWindow.Geometries.ICoordinate;
            RcIndex v1 = new RcIndex();
         
           // MapWindow.Analysis.Topology.Algorithm.PointLocator pointLocator1 = new MapWindow.Analysis.Topology.Algorithm.PointLocator();

            double val1;
            int previous = 0;
            int current = 0;

            
           
            int max = (Temp.Bounds.NumRows + 1);
            for (int i = 0; i < Temp.Bounds.NumRows; i++)
            {
                for (int j = 0; j < Temp.Bounds.NumColumns; j++)
                {
                    I1 = Temp.CellToProj(i, j);
                   
                    v1 = input1.ProjToCell(I1);

                    if (v1.Row <= input1.EndRow && v1.Column <= input1.EndColumn && v1.Row > -1 && v1.Column > -1)
                        val1 = input1.Value[v1.Row, v1.Column];
                    else
                        val1 = Temp.NoDataValue;

                    //test if the coordinate is inside of the polygon
                    bool isInside = false;
                    IFeature pointFeat = new Feature(new Point(I1)) as IFeature;
                        foreach (IFeature f in input2.Features)
                        {
                            if (f.Contains(pointFeat))
                            {
                                Temp.Value[i, j] = val1;
                                isInside = true;
                                break;
                            }
                        }
                 
                    if (isInside == false)
                    {
                        Temp.Value[i, j] = Temp.NoDataValue;
                    }

                    
                    
                    if (cancelProgressHandler.Cancel == true)
                        return false;
                }
                current = Convert.ToInt32(Math.Round(i * 100D / max));
                //only update when increment in percentage
                if (current > previous)
                    cancelProgressHandler.Progress("", current, current.ToString() + "% progress completed");
                previous = current;
            }

            output = Temp;
            output.Save();
            return true;
        }
示例#18
0
 /// <summary>
 /// Determines if any portion of this segment intersects the specified extent.
 /// </summary>
 /// <param name="inEnvelope">The</param>
 /// <returns>Boolean, true if this line segment intersects the specified envelope</returns>
 public bool Intersects(Envelope inEnvelope)
 {
     return inEnvelope.Intersects(this);
 }
 /// <summary>
 /// 
 /// </summary>
 /// <param name="env"></param>
 /// <param name="action"></param>
 public QueryVisitor(Envelope env, HotPixelSnapAction action)
 {
     this.env = env;
     this.action = action;
 }
示例#20
0
 /// <summary>
 /// Removes any members from existing in the selected state
 /// </summary>
 /// <param name="affectedAreas">The region of the selection that was cleared</param>
 /// <returns>Boolean, true if any sub-members of the group were changed by the clear method</returns>
 public override bool ClearSelection(out IEnvelope affectedAreas)
 {
     affectedAreas = new Envelope();
     bool changed = false;
     if (!_selectionEnabled) return false;
     MapFrame.SuspendEvents();
     foreach (ILayer layer in GetLayers())
     {
         IEnvelope layerArea;
         if(layer.ClearSelection(out layerArea)) changed = true;
         affectedAreas.ExpandToInclude(layerArea);
     }
     MapFrame.ResumeEvents();
     OnSelectionChanged(); // fires only AFTER the individual layers have fired their events.
     return changed;
 }
        /// <summary>
        /// Tests each member currently in the selected features based on 
        /// the SelectionMode.  If it passes, it will remove the feature from
        /// the selection.
        /// </summary>
        /// <param name="region">The geographic region to remove</param>
        /// <param name="affectedArea">A geographic area that was affected by this change.</param>
        /// <returns>Boolean, true if the collection was changed</returns>
        public bool RemoveRegion(IEnvelope region, out IEnvelope affectedArea)
        {
            SuspendChanges();
            bool removed = false;
            affectedArea = new Envelope();

            var query = from pair in _filter.DrawnStates
                        where pair.Value.IsSelected
                        select pair.Key;
            List<IFeature> selectedFeatures = query.ToList();
            foreach (IFeature f in selectedFeatures)
            {
                bool doRemove = false;
                if (_selectionMode == SelectionModes.IntersectsExtent)
                {
                    if (region.Intersects(f.Envelope))
                    {
                        if (Remove(f))
                        {
                            removed = true;
                            affectedArea.ExpandToInclude(f.Envelope);
                        }
                    }
                }
                else if (_selectionMode == SelectionModes.ContainsExtent)
                {
                    if (region.Contains(f.Envelope))
                    {
                        if (Remove(f))
                        {
                            removed = true;
                            affectedArea.ExpandToInclude(f.Envelope);
                        }
                    }
                }
                IPolygon reg = region.ToPolygon();
                IGeometry geom = Geometry.FromBasicGeometry(f.BasicGeometry);
                switch (_selectionMode)
                {
                    case SelectionModes.Contains:
                        if (region.Intersects(f.Envelope))
                        {
                            if (reg.Contains(geom)) doRemove = true;
                        }
                        break;
                    case SelectionModes.CoveredBy: 
                        if (reg.CoveredBy(geom)) doRemove = true;
                        break;
                    case SelectionModes.Covers:
                        if (reg.Covers(geom)) doRemove = true;
                        break;
                    case SelectionModes.Disjoint:
                        if (reg.Disjoint(geom)) doRemove = true;
                        break;
                    case SelectionModes.Intersects:
                        if(region.Intersects(f.Envelope))
                        {
                            if (reg.Intersects(geom)) doRemove = true;
                        }
                        break;
                    case SelectionModes.Overlaps:
                        if (reg.Overlaps(geom)) doRemove = true;
                        break;
                    case SelectionModes.Touches: 
                        if (reg.Touches(geom)) doRemove = true;
                        break;
                    case SelectionModes.Within: 
                        if (reg.Within(geom)) doRemove = true;
                        break;
                }
                if (doRemove)
                {
                    if (Remove(f))
                    {
                        affectedArea.ExpandToInclude(f.Envelope);
                        removed = true;
                    }
                }
            }
            ResumeChanges();
            return removed;
        }
示例#22
0
 /// <summary>
 /// Adds any members found in the specified region to the selected state as long as SelectionEnabled is set to true.
 /// </summary>
 /// <param name="tolerant">The geographic region where selection occurs in cases like clicking near points where tolerance is allowed</param>
 /// <param name="strict">The geographic region in cases like selecting polygons where no tolerance is allowed</param>
 /// <param name="mode">The selection mode</param>
 /// <param name="affectedArea">The envelope affected area</param>
 /// <returns>Boolean, true if any members were added to the selection</returns>
 public override bool UnSelect(IEnvelope tolerant, IEnvelope strict, SelectionModes mode, out IEnvelope affectedArea)
 {
     affectedArea = new Envelope();
     if (!_selectionEnabled) return false;
     bool somethingChanged = false;
     SuspendEvents();
     foreach (ILayer s in GetLayers())
     {
         IEnvelope layerArea;
         if (s.UnSelect(tolerant, strict, mode, out layerArea)) somethingChanged = true;
         affectedArea.ExpandToInclude(layerArea);
     }
     ResumeEvents();
     OnSelectionChanged(); // fires only AFTER the individual layers have fired their events.
     return somethingChanged;
 }
        /// <summary>
        /// Inverts the selection based on the current SelectionMode
        /// </summary>
        /// <param name="region">The geographic region to reverse the selected state</param>
        /// <param name="affectedArea">The affected area to invert</param>
        public bool InvertSelection(IEnvelope region, out IEnvelope affectedArea)
        {
            SuspendChanges();
            bool flipped = false;
            affectedArea = new Envelope();



            IDictionary<IFeature, IDrawnState> states = Filter.DrawnStates;
            foreach (KeyValuePair<IFeature, IDrawnState> kvp in states)
            {
                bool doFlip = false;
                IFeature f = kvp.Key;
                if (SelectionMode == SelectionModes.IntersectsExtent)
                {
                    if (region.Intersects(f.Envelope))
                    {
                        kvp.Value.IsSelected = !kvp.Value.IsSelected;
                        affectedArea.ExpandToInclude(f.Envelope);
                    }
                }
                else if (SelectionMode == SelectionModes.ContainsExtent)
                {
                    if (region.Contains(f.Envelope))
                    {
                        kvp.Value.IsSelected = !kvp.Value.IsSelected;
                        affectedArea.ExpandToInclude(f.Envelope);
                    }
                }
                IPolygon reg = region.ToPolygon();
                IGeometry geom = Geometry.FromBasicGeometry(f.BasicGeometry);
                switch (SelectionMode)
                {
                    case SelectionModes.Contains:
                        if (region.Intersects(f.Envelope))
                        {
                            if (reg.Contains(geom)) doFlip = true;
                        }
                        break;
                    case SelectionModes.CoveredBy:
                        if (reg.CoveredBy(geom)) doFlip = true;
                        break;
                    case SelectionModes.Covers:
                        if (reg.Covers(geom)) doFlip = true;
                        break;
                    case SelectionModes.Disjoint:
                        if (reg.Disjoint(geom)) doFlip = true;
                        break;
                    case SelectionModes.Intersects:
                        if (region.Intersects(f.Envelope))
                        {
                            if (reg.Intersects(geom)) doFlip = true;
                        }
                        break;
                    case SelectionModes.Overlaps:
                        if (reg.Overlaps(geom)) doFlip = true;
                        break;
                    case SelectionModes.Touches:
                        if (reg.Touches(geom)) doFlip = true;
                        break;
                    case SelectionModes.Within:
                        if (reg.Within(geom)) doFlip = true;
                        break;
                }
                if (doFlip)
                {
                    flipped = true;
                    kvp.Value.IsSelected = !kvp.Value.IsSelected;
                    affectedArea.ExpandToInclude(f.Envelope);
                }
            }
            ResumeChanges();
            return flipped;
        }
示例#24
0
 /// <summary>
 /// This will draw any features that intersect this region.  To specify the features
 /// directly, use OnDrawFeatures.  This will not clear existing buffer content.
 /// For that call Initialize instead.
 /// </summary>
 /// <param name="args">A GeoArgs clarifying the transformation from geographic to image space</param>
 /// <param name="regions">The geographic regions to draw</param>
 public void DrawRegions(MapArgs args, List<IEnvelope> regions)
 {
     if (FeatureSet == null) return;
     if(FeatureSet.IndexMode)
     {
         // First determine the number of features we are talking about based on region.
         List<int> drawIndices = new List<int>();
         foreach (IEnvelope region in regions)
         {
             if (region != null)
             {
                 // We need to consider labels that go off the screen.  figure a region
                 // that is larger.
                 IEnvelope sur = new Envelope(region.Copy());
                 sur.ExpandBy(region.Width, region.Height);
                 Extent r = new Extent(sur);
                 // Use union to prevent duplicates.  No sense in drawing more than we have to.
                 drawIndices = drawIndices.Union(FeatureSet.SelectIndices(r)).ToList();
             }
         }
         List<Rectangle> clips = args.ProjToPixel(regions);
         DrawFeatures(args, drawIndices, clips, true);
     }
     else
     {
         // First determine the number of features we are talking about based on region.
         List<IFeature> drawList = new List<IFeature>();
         foreach (IEnvelope region in regions)
         {
             if (region != null)
             {
                 // We need to consider labels that go off the screen.  figure a region
                 // that is larger.
                 IEnvelope r = region.Copy();
                 r.ExpandBy(region.Width, region.Height);
                 // Use union to prevent duplicates.  No sense in drawing more than we have to.
                 drawList = drawList.Union(FeatureSet.Select(r)).ToList();
             }
         }
         List<Rectangle> clipRects = args.ProjToPixel(regions);
         DrawFeatures(args, drawList, clipRects, true);
     }
     
 }
示例#25
0
 public override bool Select(IEnvelope tolerant, IEnvelope strict, SelectionModes mode, out IEnvelope affectedArea)
 {
     
     affectedArea = new Envelope();
     if (!_selectionEnabled) return false;
     bool somethingChanged = false;
     MapFrame.SuspendEvents();
     
     foreach (ILayer s in GetLayers())
     {
         if (s.SelectionEnabled == false) continue;
         IEnvelope layerArea;
         
         if(s.Select(tolerant, strict, mode, out layerArea)) somethingChanged = true;
         
         
         affectedArea.ExpandToInclude(layerArea);
        
     }
     Stopwatch sw = new Stopwatch();
     sw.Start();
     MapFrame.ResumeEvents();
     sw.Stop();
     Debug.WriteLine("ResumeEvents: " + sw.ElapsedMilliseconds);
     OnSelectionChanged(); // fires only AFTER the individual layers have fired their events.
    
     return somethingChanged;
 }
        /// <summary>
        /// Opens a *.mwprj file.
        /// </summary>
        /// <param name="filename">The string filename of the mwprj file to parse.</param>
        public virtual void Open(string filename)
        {

            _doc.Open(filename);

            Directory.SetCurrentDirectory(Path.GetDirectoryName(filename));

            // Main document Properties
            _name = _doc.ReadText("name");
            _type = _doc.ReadText("type");
            _version = _doc.ReadText("version");
            _configPath = _doc.ReadText("ConfigurationPath");
            _projection = _doc.ReadText("ProjectProjection");
            _mapUnits = _doc.ReadText("MapUnits");
            _backColor = _doc.ReadColor("ViewBackColor");
            _useDefaultBackColor = _doc.ReadBool("ViewBackColor_UseDefault");
            _scaleBar = new ScaleBarInfo();
            _scaleBar.Visible = _doc.ReadBool("ShowFloatingScaleBar");
            _scaleBar.Position = (ScaleBarPositions)Enum.Parse(typeof(ScaleBarPositions), _doc.ReadText("FloatingScaleBarPosition"));
            _scaleBar.Unit = _doc.ReadText("FloatingScaleBarUnit");
            _scaleBar.ForeColor = _doc.ReadColor("FloatingScaleBarForecolor");
            _scaleBar.BackColor = _doc.ReadColor("FloatingScaleBarBackcolor");
            _resizeBehavior = (ResizeBehaviors)_doc.ReadInteger("MapResizeBehavior");
            _statusBar.GetFromProjection = _doc.ReadBool("ShowStatusBarCoords_Projected");
            _statusBar.Alternate = _doc.ReadText("ShowStatusBarCoords_Alternate");

            if (_doc.NavigateToChild("Plugins"))
            {
                foreach (XmlElement plugin in _doc.CurrentElement.ChildNodes)
                {
                    PluginInfo pi = new PluginInfo(plugin.GetAttribute("SettingsString"), plugin.GetAttribute("Key"));
                    _plugins.Add(pi);
                }
                _doc.NavigateToParent();
            }
            if (_doc.NavigateToChild("ApplicationPlugins"))
            {
                foreach (XmlElement plugin in _doc.CurrentElement.ChildNodes)
                {
                    PluginInfo pi = new PluginInfo(plugin.GetAttribute("SettingsString"), plugin.GetAttribute("Key"));
                    _plugins.Add(pi);
                }
                _doc.NavigateToParent();
            }
            if (_doc.NavigateToChild("Extents"))
            {
                double xMin = _doc.ReadDouble("xMin");
                double xMax = _doc.ReadDouble("xMax");
                double yMin = _doc.ReadDouble("yMin");
                double yMax = _doc.ReadDouble("yMax");
                _extents = new Envelope(xMin, xMax, yMin, yMax);
            }
        }
示例#27
0
        /// <summary>
        /// 
        /// </summary>
        /// <param name="index"></param>
        /// <returns></returns>
        private Node CreateSubnode(int index)
        {
            // create a new subquad in the appropriate quadrant
            double minx = 0.0;
            double maxx = 0.0;
            double miny = 0.0;
            double maxy = 0.0;

            switch (index) 
            {
                case 0:
                    minx = env.Minimum.X;
                    maxx = centre.X;
                    miny = env.Minimum.Y;
                    maxy = centre.Y;
                    break;
                case 1:
                    minx = centre.X;
                    maxx = env.Maximum.X;
                    miny = env.Minimum.Y;
                    maxy = centre.Y;
                    break;
                case 2:
                    minx = env.Minimum.X;
                    maxx = centre.X;
                    miny = centre.Y;
                    maxy = env.Maximum.Y;
                    break;
                case 3:
                    minx = centre.X;
                    maxx = env.Maximum.X;
                    miny = centre.Y;
                    maxy = env.Maximum.Y;
                    break;
	            default:
		            break;
            }
            Envelope sqEnv = new Envelope(minx, maxx, miny, maxy);
            Node node = new Node(sqEnv, level - 1);
            return node;
        }
示例#28
0
 /// <summary>
 /// Removes any members from existing in the selected state
 /// </summary>
 public bool ClearSelection(out IEnvelope affectedArea)
 {
     affectedArea = new Envelope();
     if (MapFrame == null) return false;
     return MapFrame.ClearSelection(out affectedArea);
 }
示例#29
0
 /// <summary>
 /// 
 /// </summary>
 /// <param name="testExtents"></param>
 /// <returns></returns>
 public IEnvelope PixelToProj(RectangleF testExtents)
 {
     Coordinate UL = PixelToProj(new PointF(testExtents.Left, testExtents.Top));
     Coordinate LR = PixelToProj(new PointF(testExtents.Right, testExtents.Bottom));
     IEnvelope result = new Envelope(UL.X, UL.Y, (LR.X - UL.X), (LR.Y - UL.Y));
     return result;
 }
示例#30
0
        /// <summary>
        /// Adds any members found in the specified region to the selected state as long as SelectionEnabled is set to true.
        /// </summary>
        /// <param name="strict">The tight envelope to use for polygons</param>
        /// <param name="tolerant">The geographic region where selection occurs that is tolerant for point or linestrings</param>
        /// <param name="mode">The selection mode</param>
        /// <param name="affectedArea">The envelope affected area</param>
        /// <returns>Boolean, true if any members were added to the selection</returns>
        public bool UnSelect(IEnvelope tolerant, IEnvelope strict, SelectionModes mode, out IEnvelope affectedArea)
        {
            affectedArea = new Envelope();
            if (MapFrame == null) return false;
            return MapFrame.UnSelect(tolerant, strict, mode, out affectedArea);

        }