public static IGeometry Project(IGeometry geometry, ProjectionInfo pStart, ProjectionInfo pEnd)
 {
     var featureSet = new FeatureSet();
     featureSet.AddFeature(geometry.ToDotSpatial());
     featureSet.Projection = pStart;
     featureSet.Reproject(pEnd);
     return
         GeometryConverter.ToGeoAPI(
             ((featureSet.Features[0].BasicGeometry as DotSpatial.Topology.IGeometry)));
 }

        /// <summary>
        /// Creates a new polygon featureset that is created by buffering each of the individual shapes.
        /// </summary>
        /// <param name="self">The IFeatureSet to buffer</param>
        /// <param name="distance">The double distance to buffer</param>
        /// <param name="copyAttributes">Boolean, if this is true, then the new featureset will have
        /// the same attributes as the original.</param>
        /// <returns>The newly created IFeatureSet</returns>
        public static IFeatureSet Buffer(this IFeatureSet self, double distance, bool copyAttributes)
        {
            // Dimension the new, output featureset.  Buffered shapes are polygons, even if the
            // original geometry is a point or a line.
            IFeatureSet result = new FeatureSet(FeatureType.Polygon);

            result.CopyTableSchema(self);
            result.Projection = self.Projection;
            // Cycle through the features, and buffer each one separately.
            foreach (IFeature original in self.Features)
            {
                // Actually calculate the buffer geometry.
                IFeature buffer = original.Buffer(distance);

                // Add the resulting polygon to the featureset
                result.Features.Add(buffer);

                // If copyAttributes is true, then this will copy those attributes from the original.
                if (copyAttributes)
                {
                    // Accessing the attributes should automatically load them from the datasource if
                    // they haven't been loaded already.
                    buffer.CopyAttributes(original);
                }
            }
            return result;
        }

 /// <summary>
 /// Creates a specified number of random point features inside a single polygon feature. 
 /// </summary>
 /// <param name="ConstrainingFeature">Random points will be generated inside this polygon feature.</param>
 /// <param name="NumberOfPoints">The number of points to be randomly generated.</param>
 /// <returns>A point feature set with the randomly created features.</returns>
 public static FeatureSet RandomPoints(Feature ConstrainingFeature, int NumberOfPoints)
 {
     //This function generates random points within the boundaries of one polygon feature
     FeatureSet fsOut = new FeatureSet();
     fsOut.FeatureType = FeatureType.Point;
     Coordinate c = new Coordinate();
     Random r = new Random();
     int i = 0;
     while (i < NumberOfPoints)
     {
         c = new Coordinate();
         //make a random point somewhere in the rectangular extents of the feature
         double rndx = r.Next(0, 100000) / 100000.0;
         double rndy = r.Next(0, 100000) / 100000.0;
         c.X = rndx * (ConstrainingFeature.Envelope.Right() - ConstrainingFeature.Envelope.Left()) + ConstrainingFeature.Envelope.Left();
         c.Y = rndy * (ConstrainingFeature.Envelope.Top() - ConstrainingFeature.Envelope.Bottom()) + ConstrainingFeature.Envelope.Bottom();
         //check if the point falls within the polygon featureset
         if (ConstrainingFeature.Intersects(c))
         {
             fsOut.AddFeature(new Feature(c));
             i++;
         }
     }
     return fsOut;
 }

        public void CreateFromFeatureSet(FeatureSet fs, string imgField, string OnCLickFiled,string aRefField, string OnMouseOverField, string OnMouseOutField, string dxField, string dyField)
        {

            SetMarkNumber(fs.Features.Count);

            int i = 0;

            foreach (Feature f in fs.Features)
            {
                if (f.Coordinates.Count>0)
                {
                    _crds[i] = f.Coordinates[0];
                    _imgs[i] = Convert.ToString(f.DataRow[imgField]);
                    
                    if (OnCLickFiled != "" & OnCLickFiled != null) _OnClick[i] = Convert.ToString(f.DataRow[OnCLickFiled]);
                    if (aRefField != "" & aRefField != null) _aRef[i] = Convert.ToString(f.DataRow[aRefField]);
                    if (OnMouseOverField != "" & OnMouseOverField != null) _OnMouseOver[i] = Convert.ToString(f.DataRow[OnMouseOverField]);
                    if (OnMouseOutField != "" & OnMouseOutField != null) _OnMouseOut[i] = Convert.ToString(f.DataRow[OnMouseOutField]);

                    _dxy[i].X = Convert.ToInt32(f.DataRow[dxField]);
                    _dxy[i].Y = Convert.ToInt32(f.DataRow[dyField]);
                }

                i++;
            }

        }

        public PointClassification ClassifyPoint(double latitude, double longitude)
        {
            FeatureSet pFeatureSet = new FeatureSet();
            pFeatureSet.Projection = KnownCoordinateSystems.Geographic.World.WGS1984;

            DotSpatial.Topology.Point pPoint = new DotSpatial.Topology.Point(longitude, latitude);
            FeatureSet pPointFeatureSet = new FeatureSet(DotSpatial.Topology.FeatureType.Point);
            pPointFeatureSet.Projection = KnownCoordinateSystems.Geographic.World.WGS1984;
            pPointFeatureSet.AddFeature(pPoint);

            Extent pAffectedExtent = null;
            var result = fsWorldCountries.Select(pPointFeatureSet.Extent, out pAffectedExtent);

            foreach (IFeature feature in result)
            {
                PointClassification classification = new PointClassification();
                classification.CountryCode = feature.DataRow["ADM0_A3"].ToString();
                if (classification.CountryCode.Length == 3) classification.CountryCode = ConvertISOCountryCode(classification.CountryCode);
                classification.CountrySubdivision = feature.DataRow["NAME"].ToString();
                classification.CountryName = feature.DataRow["ADMIN"].ToString();
                return classification;
            }

            return null;
            // System.Diagnostics.Debug.WriteLine(featureL);
        }

 /// <summary>
 /// Generates an empty featureset that has the combined fields from this featureset
 /// and the specified featureset.
 /// </summary>
 /// <param name="self">This featureset</param>
 /// <param name="other">The other featureset to combine fields with.</param>
 /// <returns></returns>
 public static IFeatureSet CombinedFields(this IFeatureSet self, IFeatureSet other)
 {
     IFeatureSet result = new FeatureSet(self.FeatureType);
     Dictionary<string, DataColumn> resultColumns = new Dictionary<string, DataColumn>();
     foreach (DataColumn dc in self.DataTable.Columns)
     {
         string name = dc.ColumnName;
         int i = 1;
         while (resultColumns.ContainsKey(name))
         {
             name = dc.ColumnName + i;
             i++;
         }
         resultColumns.Add(name, dc);
     }
     foreach (DataColumn dc in other.DataTable.Columns)
     {
         string name = dc.ColumnName;
         int i = 1;
         while (resultColumns.ContainsKey(name))
         {
             name = dc.ColumnName + i;
             i++;
         }
         resultColumns.Add(name, dc);
     }
     foreach (KeyValuePair<string, DataColumn> pair in resultColumns)
     {
         result.DataTable.Columns.Add(new DataColumn(pair.Key, pair.Value.DataType));
     }
     return result;
 }

 /// <summary>
 /// Creates a new Line Feature Set parameter
 /// </summary>
 /// <param name="name">The name of the parameter</param>
 public LineFeatureSetParam(string name)
 {
     Name = name;
     Value = new FeatureSet();
     ParamVisible = ShowParamInModel.Always;
     ParamType = "DotSpatial LineFeatureSet Param";
     DefaultSpecified = false;
 }

 /// <summary>
 /// Add the features from SourceFeatures to the TargetFeatures feature set. 
 /// </summary>
 /// <param name="TargetFeatures">Feature set to which features will be added.</param>
 /// <param name="SourceFeatures">Source of features to add to the target feature set. </param>
 /// <returns>A point feature set with the randomly created features.</returns>
 public static FeatureSet AppendFeatures(FeatureSet TargetFeatures, FeatureSet SourceFeatures)
 {
     //Add the features from SourceFeatures to the TargetFeatures feature set
     //Note: we use the ShapeIndices here rather than for each feature in featureset.features as a memory management technique.
     //Dan Ames 2/27/2013
     IFeature SF;
     for (Int16 j = 0; j <= SourceFeatures.ShapeIndices.Count - 1; j++)
     {
         SF = SourceFeatures.GetFeature(j);
         TargetFeatures.AddFeature(SF).CopyAttributes(SourceFeatures.GetFeature(j));   //by default this will try to copy attributes over that have the same name.
     }
     return TargetFeatures;
 }

        public void GetAttributes_WithFieldNames()
        {
            var fs = new FeatureSet(FeatureType.Point);
            fs.DataTable.Columns.Add("Column1");
            fs.DataTable.Columns.Add("Column2");
            fs.AddFeature(new Point(0, 0));

            var fl = new PointLayer(fs);

            var target = new IndexSelection(fl);
            var attributesTable = target.GetAttributes(0, 1, new[] {"Column1"});
            Assert.AreEqual(1, attributesTable.Columns.Count);
            Assert.AreEqual("Column1", attributesTable.Columns[0].ColumnName);
        }

 /// <summary>
 /// The Voronoi Graph calculation creates a delaunay tesselation where
 /// each point is effectively converted into triangles.
 /// </summary>
 /// <param name="points">The points to use for creating the tesselation.</param>
 /// <returns>The generated line featureset.</returns>
 public static IFeatureSet DelaunayLines(IFeatureSet points)
 {
     double[] vertices = points.Vertex;
     VoronoiGraph gp = Fortune.ComputeVoronoiGraph(vertices);
     FeatureSet result = new FeatureSet();
     foreach (VoronoiEdge edge in gp.Edges)
     {
         Coordinate c1 = edge.RightData.ToCoordinate();
         Coordinate c2 = edge.LeftData.ToCoordinate();
         LineString ls = new LineString(new List<Coordinate> { c1, c2 });
         Feature f = new Feature(ls);
         result.AddFeature(f);
     }
     return result;
 }

 public static System.Data.Entity.Spatial.DbGeometry Project(System.Data.Entity.Spatial.DbGeometry source,
     ProjectionInfo pStart, ProjectionInfo pEnd)
 {
     var wkt = source.WellKnownValue.WellKnownText;
     var wktReader = new WKTReader();
     var geometry = wktReader.Read(wkt);
     var featureSet = new FeatureSet();
     featureSet.Features.Add(geometry.ToDotSpatial());
     featureSet.Projection = pStart;
     featureSet.Reproject(pEnd);
     var projected =
         (featureSet.Features.First().BasicGeometry as IGeometry).ToGeoAPI();
     var wktWriter = new WKTWriter();
     var projectedWkt = wktWriter.Write(projected);
     return System.Data.Entity.Spatial.DbGeometry.FromText(projectedWkt);
 }

        /// <summary>
        /// The Voronoi Graph calculation creates the lines that form a voronoi diagram.
        /// </summary>
        /// <param name="points">The points to use for creating the tesselation.</param>
        /// <returns>An IFeatureSet that is the resulting set of lines in the diagram.</returns>
        public static IFeatureSet VoronoiLines(IFeatureSet points)
        {
            double[] vertices = points.Vertex;
            VoronoiGraph gp = Fortune.ComputeVoronoiGraph(vertices);

            HandleBoundaries(gp, points.Extent.ToEnvelope());

            FeatureSet result = new FeatureSet();
            foreach (VoronoiEdge edge in gp.Edges)
            {
                Coordinate c1 = edge.VVertexA.ToCoordinate();
                Coordinate c2 = edge.VVertexB.ToCoordinate();
                LineString ls = new LineString(new List<Coordinate> { c1, c2 });
                Feature f = new Feature(ls);
                result.AddFeature(f);
            }
            return result;
        }

        private void backgroundWorker1_DoWork(object sender, DoWorkEventArgs e)
        {
            changeButtonStatus(false);

            if (!string.IsNullOrEmpty(textBox1.Text))
            {

                Feature f = new Feature();
                fs = new FeatureSet(f.FeatureType);

                var dataTable = new DataTable();

                dataTable.Columns.Add(new DataColumn("X", typeof(double)));
                dataTable.Columns.Add(new DataColumn("Y", typeof(double)));
                dataTable.Columns.Add(new DataColumn("Z", typeof(double)));

                for (int i = 0; i < textBox1.Lines.Length; i++)
                {
                    var data = textBox1.Lines[i].Split(',').Where(c => !string.IsNullOrEmpty(c))
                        .Select(c => Convert.ToDouble(c)).ToArray();

                    if (data.Length == 3)
                    {
                        var c = new Coordinate(data);
                        //var c = new Coordinate(Convert.ToDouble(data[0]), Convert.ToDouble(data[1]), Convert.ToDouble(data[2]));
                        fs.Features.Add(c);

                        dataTable.Rows.Add(data[0],data[1],data[2]);
                    }

                    backgroundWorker1.ReportProgress((i + 1));

                }


                dataTable.TableName = "ImportData";
                fs.DataTable = dataTable;
                fs.Name = "Imported Data";
            }

            changeButtonStatus(true);
        }

        /// <summary>
        /// Erase features from one feature set where they are intersected by another feature set. 
        /// </summary>
        /// <param name="TargetFeatures">Features which will be erased in part or whole.</param>
        /// <param name="SourceFeatures">Features which represent areas to erase.</param>
        /// <param name="cancelProgressHandler">Optional parameter to report progress and cancel entire process if needed.</param>
        /// <returns>A point feature set with the randomly created features.</returns>
        public static FeatureSet EraseFeatures(IFeatureSet TargetFeatures, IFeatureSet SourceFeatures, ICancelProgressHandler cancelProgressHandler = null)
        {
            if (TargetFeatures == null || SourceFeatures == null)
            {
                return null;
            }
            //Erase features from one feature set where they are intersected by another feature set
            //Note: we use the ShapeIndices here rather than for each feature in featureset.features as a memory management technique.
            //The current version does not preserve any attribute info. 
            //Dan Ames 2/27/2013
            FeatureSet ResultFeatures = new FeatureSet();                   //the resulting featureset
            IFeature TF, SF;                                                //a single output feature
            ResultFeatures.CopyTableSchema(TargetFeatures);                 //set up the data table in the new feature set

            for (Int16 i = 0; i <= TargetFeatures.ShapeIndices.Count - 1; i++)
            {
                TF = TargetFeatures.GetFeature(i);                          //get the full undifferenced feature
                for (Int16 j = 0; j <= SourceFeatures.ShapeIndices.Count - 1; j++)
                {
                    SF = SourceFeatures.GetFeature(j);
                    if (SF.Envelope.Intersects(TF.Envelope))
                    {
                        TF = TF.Difference(SF);                             //clip off any pieces of SF that overlap FR
                    }
                    if (TF == null)
                    {                                                       //sometimes difference leaves nothing left of a feature
                        break;
                    }
                }
                if (TF != null)
                {
                    ResultFeatures.AddFeature(TF).CopyAttributes(TargetFeatures.GetFeature(i));  //add the fully clipped feature to the results
                }
                if (cancelProgressHandler != null)
                {
                    if (cancelProgressHandler.Cancel) { return null; }
                    int progress = Convert.ToInt32(i * 100 / TargetFeatures.ShapeIndices.Count);
                    cancelProgressHandler.Progress(String.Empty, progress, String.Empty);
                }
            }
            return ResultFeatures;
        }

        private IFeatureSet CreatefilterFeatureSet()
        { 
            IFeatureSet  data1 = new FeatureSet(FeatureType.Point);
            data1.Projection = _originalData.Projection;
            data1.DataTable.Columns.Add(new System.Data.DataColumn(this.Field, typeof(double)));
            data1.DataTable.Columns.Add(new System.Data.DataColumn("Repeat", typeof(string)));
            List<int> listt = _originalData.SelectIndexByAttribute(Filterfields);
           


            foreach (int index in listt)
            {
                IFeature fea1 = _originalData.GetFeature(index);
                IFeature d=data1.AddFeature((IBasicGeometry)fea1);
                d.DataRow[this.Field] = fea1.DataRow[this.Field];
            }


            return data1;
        }

 /// <summary>
 /// Generates an empty featureset that has the combined fields from this featureset
 /// and the specified featureset.
 /// </summary>
 /// <param name="self">This featureset</param>
 /// <param name="other">The other featureset to combine fields with.</param>
 /// <returns></returns>
 public static IFeatureSet CombinedFields(this IFeatureSet self, IFeatureSet other)
 {
     IFeatureSet result = new FeatureSet(self.FeatureType);
     var uniqueNames = new HashSet<string>();
     foreach (var fs in new []{self, other})
     {
         foreach (DataColumn dc in fs.DataTable.Columns)
         {
             var name = dc.ColumnName;
             var i = 1;
             while (uniqueNames.Contains(name))
             {
                 name = dc.ColumnName + i;
                 i++;
             }
             uniqueNames.Add(name);
             result.DataTable.Columns.Add(new DataColumn(name, dc.DataType));
         }   
     }
     return result;
 }

        /// <summary>
        /// Creates a specified number of random point features inside multiple polygon features in a feature set. 
        /// </summary>
        /// <param name="ConstrainingFeatures">Random points will be generated inside all features in this feature set.</param>
        /// <param name="NumberOfPoints">The number of points to be randomly generated.</param>
        /// <param name="cancelProgressHandler">Optional parameter to report progress and cancel entire process if needed.</param>
        /// <returns>A point feature set with the randomly created features.</returns>
        public static IFeatureSet RandomPoints(IFeatureSet ConstrainingFeatures, int NumberOfPoints, IFeatureSet fsOut = null, ICancelProgressHandler cancelProgressHandler = null)
        {
            //This function generates random points within the boundaries of all polygon features in a feature set
            if (fsOut == null)
            {
                fsOut = new FeatureSet();
            }
            fsOut.FeatureType = FeatureType.Point;
            Coordinate c = new Coordinate();
            Random r = new Random();
            int i = 0;
            while (i < NumberOfPoints)
            {
                c = new Coordinate();
                //make a random point somewhere in the rectangular extents of the feature set
                double rndx = r.Next(0, 100000) / 100000.0;
                double rndy = r.Next(0, 100000) / 100000.0;
                c.X = rndx * (ConstrainingFeatures.Extent.MaxX - ConstrainingFeatures.Extent.MinX) + ConstrainingFeatures.Extent.MinX;
                c.Y = rndy * (ConstrainingFeatures.Extent.MaxY - ConstrainingFeatures.Extent.MinY) + ConstrainingFeatures.Extent.MinY;

                //check if the point falls within the polygon featureset
                foreach (Feature f in ConstrainingFeatures.Features)
                {
                    if (f.Intersects(c))
                    {
                        fsOut.AddFeature(new Feature(c));
                        i++;
                    }
                }
                if (cancelProgressHandler != null)
                {
                    if (cancelProgressHandler.Cancel) { return null; }
                    int progress = Convert.ToInt32(i * 100 / NumberOfPoints);
                    cancelProgressHandler.Progress(String.Empty, progress, String.Empty);
                }
            }
            return fsOut;
        }

 internal FeatureSet CreateFeatureSet()
 {
     FeatureSet featureSet = new FeatureSet(FeatureType.Line);
     featureSet.Projection = KnownCoordinateSystems.Geographic.World.WGS1984;
     foreach (ReferentielMultiLineString mls in this.MultiLineStrings)
     {
         List<LineString> lineStrings = new List<LineString>();
         foreach (ReferentielLineString ls in mls.LineStrings)
         {
             List<Coordinate> coordinates = new List<Coordinate>();
             for (int i = 0; i < (ls.Segements.Count - 1); i++)
             {
                 coordinates.Add(ls.Segements[i].CoordDeb);
             }
             coordinates.Add(ls.Segements.Last().CoordDeb);
             coordinates.Add(ls.Segements.Last().CoordFin);
             LineString fsLs = new LineString(coordinates);
             lineStrings.Add(fsLs);
         }
         MultiLineString fsMls = new MultiLineString(lineStrings);
         featureSet.AddFeature(fsMls);
     }
     return featureSet;
 }

        /// <summary>
        /// Allows for new behavior during deactivation.
        /// </summary>
        protected override void OnDeactivate()
        {
            if (_standBy) { return; }

            // Don't completely deactivate, but rather go into standby mode
            // where we draw only the content that we have actually locked in.
            _standBy = true;
            if (_coordinateDialog != null) { _coordinateDialog.Hide(); }
            if (_coordinates != null && _coordinates.Count > 1)
            {
                LineString ls = new LineString(_coordinates);
                FeatureSet fs = new FeatureSet(FeatureType.Line);
                fs.Features.Add(new Feature(ls));
                MapLineLayer gll = new MapLineLayer(fs)
                                       {
                                           Symbolizer =
                                               {
                                                   ScaleMode = ScaleMode.Symbolic,
                                                   Smoothing = true
                                               },
                                           MapFrame = Map.MapFrame
                                       };
                _tempLayer = gll;
                Map.MapFrame.DrawingLayers.Add(gll);
                Map.MapFrame.Invalidate();
                Map.Invalidate();
            }

            base.Deactivate();
        }

        private XPathNodeIterator CreateFields(XPathNavigator nav, DotSpatial.Topology.FeatureType type)
        {

            string exp = @"/wfs:FeatureCollection/child::*[name() = 'gml:featureMember' or name() = 'gml:featureMembers']/child::*";
            XPathNodeIterator iterator = nav.Select(exp, _nsmgr);
            fea = new FeatureSet(type);
            if (iterator.Count > 0)
            {
                foreach (string fieldName in fields.Keys)
                {
                    if (fieldName != Geometry)
                    {
                        fea.DataTable.Columns.Add(new DataColumn(fieldName, GetType(fieldName)));
                    }
                }
            }
            return iterator;
        }