public static void CorrectionCentroid()
        {
            //中心点数据
            List <Coordinate> centroidPoints = new List <Coordinate>(80);
            StreamReader      sr             = new StreamReader(@"D:\OneDrive\2017研究生毕业设计\数据\项目用数据\中心点80.txt");

            sr.ReadLine();//读取标题行
            while (!sr.EndOfStream)
            {
                string[] line = sr.ReadLine().Split(',');
                centroidPoints.Add(new Coordinate(double.Parse(line[1]), double.Parse(line[2])));
            }
            sr.Close();
            //Bus数据,并且构造KD树
            KdTree            myKdtree       = new KdTree(2);
            IFeatureSet       busFS          = FeatureSet.Open(@"D:\OneDrive\2017研究生毕业设计\数据\项目用数据\BusStopGauss.shp");
            List <Coordinate> busStopPoints  = new List <Coordinate>(busFS.NumRows());
            HashSet <int>     checkDuplicate = new HashSet <int>();

            foreach (var item in busFS.Features)
            {
                var c = item.Coordinates[0];
                busStopPoints.Add(c);
                myKdtree.Insert(new double[] { c.X, c.Y }, item);
            }
            Console.WriteLine("数据读取完毕,开始纠正数据");
            IFeatureSet newCentroid = new FeatureSet(FeatureType.Point);

            newCentroid.Name       = "优化过的中心点";
            newCentroid.Projection = ProjectionInfo.FromEpsgCode(GAUSS_EPSG);
            int count = 0;

            foreach (var item in centroidPoints)
            {
                var      nearsestBus = myKdtree.Nearest(new double[] { item.X, item.Y }, 3);
                bool     addSuccess  = false;
                IFeature addFeature  = null;
                for (int i = 0; i < 3; i++)
                {
                    IFeature f = nearsestBus[i] as IFeature;
                    if (f.Coordinates[0].Distance(item) < 100)
                    {
                        if (checkDuplicate.Add(f.Fid))
                        {
                            addFeature = newCentroid.AddFeature(f.BasicGeometry);
                            addSuccess = true;
                        }
                    }
                }
                if (!addSuccess)
                {
                    addFeature = newCentroid.AddFeature(new Point(item));
                    count++;
                }
            }
            Console.WriteLine("数据优化结束,共有{0}个数据没有优化", count);
            newCentroid.SaveAs("newCentroid2.shp", true);
            Console.ReadKey();
        }
        /// <summary>
        /// Builds a point feature set and adds a column and 3 points.
        /// </summary>
        /// <returns>The featureset that was build.</returns>
        public IFeatureSet BuildFeatureSet()
        {
            IFeatureSet fs = new FeatureSet(FeatureType.Point);

            fs.DataTable.Columns.Add("Test", typeof(string));
            IFeature feat = fs.AddFeature(new Point(10, 10));

            feat.DataRow["Test"] = "hello";
            feat = fs.AddFeature(new Point(10, 20));
            feat.DataRow["Test"] = "hello";
            feat = fs.AddFeature(new Point(20, 10));
            feat.DataRow["Test"] = "here";
            return(fs);
        }
        private void addLayer_Click(object sender, EventArgs e)
        {
            // Add
            Coordinate c  = new Coordinate(1, 1);
            Coordinate c1 = new Coordinate(2, 2);
            FeatureSet fs = new FeatureSet(FeatureType.Point);

            fs.AddFeature(new DotSpatial.Topology.Point(c));
            fs.AddFeature(new DotSpatial.Topology.Point(c1));
            env = fs.Extent;
            MapPointLayer layer = new MapPointLayer(fs);

            map1.MapFrame.DrawingLayers.Add(layer);
            map1.Refresh();
        }
        public void CoordinateTypeWriteOnSaveAs()
        {
            var         outfile = FileTools.GetTempFileName(".shp");
            IFeatureSet fs      = new FeatureSet();
            var         c       = new Coordinate(10.1, 20.2, 3.3, 4.4);

            fs.CoordinateType = CoordinateType.Z;
            fs.Projection     = KnownCoordinateSystems.Geographic.World.WGS1984;
            fs.DataTable.Columns.Add(new DataColumn("ID", typeof(int)));

            IFeature f = fs.AddFeature(new Point(c));

            f.DataRow.BeginEdit();
            f.DataRow["ID"] = 1;
            f.DataRow.EndEdit();

            fs.SaveAs(outfile, true);

            var actual = FeatureSet.Open(outfile);

            try
            {
                Assert.AreEqual(fs.CoordinateType, actual.CoordinateType);
            }
            finally
            {
                FileTools.DeleteShapeFile(outfile);
            }
        }
Beispiel #5
0
        public override string CreateFeature(ProjectionInfo proj_info, string directory)
        {
            if (FlowRate != null)
            {
                string filename = Path.Combine(directory, this.Name + ".shp");
                var    grid     = (Owner as Modflow).Grid as MFGrid;

                FeatureSet fs = new FeatureSet(FeatureType.Point);
                fs.Name       = this.Name;
                fs.Projection = proj_info;
                fs.DataTable.Columns.Add(new DataColumn("CELL_ID", typeof(int)));
                fs.DataTable.Columns.Add(new DataColumn("Layer", typeof(int)));
                fs.DataTable.Columns.Add(new DataColumn("Row", typeof(int)));
                fs.DataTable.Columns.Add(new DataColumn("Column", typeof(int)));
                fs.DataTable.Columns.Add(new DataColumn("ID", typeof(int)));

                fs.DataTable.Columns.Add(new DataColumn("Elevation", typeof(float)));
                for (int i = 0; i < NBDTIM; i++)
                {
                    fs.DataTable.Columns.Add(new DataColumn("Flux Rate" + (i + 1), typeof(float)));
                }

                fs.DataTable.Columns.Add(new DataColumn("Name", typeof(string)));
                fs.DataTable.Columns.Add(new DataColumn(RegularGrid.ParaValueField, typeof(int)));

                var mat = FlowRate;
                for (int i = 0; i < FlowRate.Size[2]; i++)
                {
                    int layer = (int)mat[0, 0, i];
                    int row   = (int)mat[1, 0, i];
                    int col   = (int)mat[2, 0, i];

                    var      coor    = grid.LocateCentroid(col, row);
                    Point    geom    = new Point(coor);
                    IFeature feature = fs.AddFeature(geom);
                    feature.DataRow.BeginEdit();
                    feature.DataRow["CELL_ID"]   = grid.Topology.GetID(row - 1, col - 1);
                    feature.DataRow["Layer"]     = layer;
                    feature.DataRow["Row"]       = row;
                    feature.DataRow["Column"]    = col;
                    feature.DataRow["ID"]        = (i + 1);
                    feature.DataRow["Elevation"] = grid.GetElevationAt(row - 1, col - 1, layer - 1);
                    feature.DataRow["Name"]      = "Flow " + (i + 1);
                    for (int j = 0; j < NBDTIM; j++)
                    {
                        feature.DataRow["Flux Rate" + (j + 1)] = mat[j + 4, 0, i];
                    }
                    feature.DataRow[RegularGrid.ParaValueField] = 0;
                    feature.DataRow.EndEdit();
                }
                fs.SaveAs(filename, true);
                fs.Close();

                return(filename);
            }
            else
            {
                return(null);
            }
        }
Beispiel #6
0
        /// <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(FeatureType.Point);
            Random     r     = new Random();
            int        i     = 0;

            while (i < numberOfPoints)
            {
                // 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;
                var    env  = constrainingFeature.Geometry.EnvelopeInternal;

                var c = new Coordinate
                {
                    X = (rndx * (env.Right() - env.MinX)) + env.MinX,
                    Y = (rndy * (env.MaxY - env.Bottom())) + env.Bottom()
                };

                // check if the point falls within the polygon featureset
                Point p = new Point(c);
                if (constrainingFeature.Geometry.Intersects(p))
                {
                    fsOut.AddFeature(p);
                    i++;
                }
            }

            return(fsOut);
        }
        public static void CentroidToShapefile()
        {
            OpenFileDialog ofd = new OpenFileDialog();

            ofd.Filter           = "文本文件|*.txt;*.csv";
            ofd.RestoreDirectory = true;
            if (ofd.ShowDialog() == DialogResult.OK)
            {
                StreamReader sr = new StreamReader(ofd.FileName);
                //string[] header = sr.ReadLine().Split(',');
                IFeatureSet oFS = new FeatureSet(FeatureType.Point);
                oFS.Projection = ProjectionInfo.FromEpsgCode(4326);
                oFS.Name       = "BusStop";
                oFS.DataTable.Columns.Add("Name", typeof(string));
                while (!sr.EndOfStream)
                {
                    string[] line         = sr.ReadLine().Split(',');
                    double   x            = double.Parse(line[2]);
                    double   y            = double.Parse(line[3]);
                    var      xyCorrection = CoordinateTransformUtil.bd09towgs84(x, y);
                    var      fe           = oFS.AddFeature(new Point(xyCorrection[0], xyCorrection[1]));
                    fe.DataRow.BeginEdit();
                    fe.DataRow["Name"] = line[0];
                    fe.DataRow.EndEdit();
                }
                oFS.SaveAs("BusStop.shp", true);
                sr.Close();
                Console.WriteLine("Shapefile转换成功!");
                Console.ReadKey();
            }
        }
Beispiel #8
0
        /// <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 static void CreatePolygonFeatureSetAnd2AttributeColumns()
        {
            // See comments below this code for an updated version.

            // define the feature type for this file
            FeatureSet fs = new FeatureSet(FeatureType.Polygon);


            // Add Some Columns
            fs.DataTable.Columns.Add(new DataColumn("ID", typeof(int)));
            fs.DataTable.Columns.Add(new DataColumn("Text", typeof(string)));

            // create a geometry (square polygon)
            List <Coordinate> vertices = new List <Coordinate>();

            vertices.Add(new Coordinate(0, 0));
            vertices.Add(new Coordinate(0, 100));
            vertices.Add(new Coordinate(100, 100));
            vertices.Add(new Coordinate(100, 0));
            Polygon geom = new Polygon(vertices);

            // add the geometry to the featureset.
            IFeature feature = fs.AddFeature(geom);

            // now the resulting features knows what columns it has
            // add values for the columns
            feature.DataRow.BeginEdit();
            feature.DataRow["ID"]   = 1;
            feature.DataRow["Text"] = "Hello World";
            feature.DataRow.EndEdit();


            // save the feature set
            fs.SaveAs("d:\\test.shp", true);
        }
Beispiel #10
0
        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);
        }
Beispiel #11
0
        public static IFeatureSet RoadNetworkToShapefile(RoadNetwork rn, string writefilename)
        {
            FeatureSet fs       = new FeatureSet(FeatureType.Line);
            string     filename = Path.GetFileNameWithoutExtension(writefilename);

            fs.Name = filename;
            fs.DataTable.Columns.Add("RoadID", typeof(long));
            fs.DataTable.Columns.Add("RoadName", typeof(string));
            fs.DataTable.Columns.Add("RoadFunction", typeof(byte));
            fs.DataTable.Columns.Add("RoadLength", typeof(double));
            fs.DataTable.Columns.Add("RoadAttribute", typeof(string));
            for (int i = 0; i < rn.RoadCount; i++)
            {
                Road r  = rn.GetRoadByIndex(i);
                var  fe = fs.AddFeature(r);
                fe.DataRow.BeginEdit();
                fe.DataRow["RoadID"]       = r.RoadID;
                fe.DataRow["RoadName"]     = r.RoadName;
                fe.DataRow["RoadFunction"] = r.RoadFunction;
                fe.DataRow["RoadLength"]   = r.RoadLength;
                string attr = string.Empty;
                for (int j = 0; j < r.RoadAttribute.Count; j++)
                {
                    attr += r.RoadAttribute[j].RoadFunction.ToString() + r.RoadAttribute[j].RoadAtrribute.ToString();
                    if (j != r.RoadAttribute.Count - 1)
                    {
                        attr += "|";
                    }
                }
                fe.DataRow["RoadAttribute"] = attr;
                fe.DataRow.EndEdit();
            }
            fs.SaveAs(writefilename, true);
            return(fs);
        }
        public void GetShapefile(string filepath)
        {
            FeatureSet fs = new FeatureSet(FeatureType.Point);

            fs.DataTable.Columns.Add(new DataColumn("ID", typeof(string)));
            fs.DataTable.Columns.Add(new DataColumn("Name", typeof(string)));
            fs.DataTable.Columns.Add(new DataColumn("Lat", typeof(double)));
            fs.DataTable.Columns.Add(new DataColumn("Lon", typeof(double)));
            fs.DataTable.Columns.Add(new DataColumn("Contam", typeof(string)));
            fs.DataTable.Columns.Add(new DataColumn("Trend", typeof(double)));
            fs.DataTable.Columns.Add(new DataColumn("Trending", typeof(string)));
            fs.DataTable.Columns.Add(new DataColumn("Rsquared", typeof(double)));
            fs.DataTable.Columns.Add(new DataColumn("MCL", typeof(double)));
            fs.DataTable.Columns.Add(new DataColumn("Units", typeof(string)));
            fs.DataTable.Columns.Add(new DataColumn("NumSamp", typeof(int)));
            fs.DataTable.Columns.Add(new DataColumn("LastDate", typeof(string)));
            fs.DataTable.Columns.Add(new DataColumn("Result", typeof(double)));
            fs.DataTable.Columns.Add(new DataColumn("Link", typeof(string)));



            for (int a = 0; a < WellList.Count; a++)
            {
                int        c        = WellList[a].GetTopTrendIndex(3);
                Coordinate vertices = new Coordinate();
                vertices.X = WellList[a].LonDouble[c];
                vertices.Y = WellList[a].LatDouble[c];
                DotSpatial.Topology.Point Geom = new DotSpatial.Topology.Point(vertices);
                fs.AddFeature(Geom);
                fs.DataTable.Rows[a].BeginEdit();
                fs.DataTable.Rows[a]["ID"]       = WellList[a].ID;
                fs.DataTable.Rows[a]["Name"]     = WellList[a].Names[c];
                fs.DataTable.Rows[a]["Lat"]      = WellList[a].LatDouble[c];
                fs.DataTable.Rows[a]["Lon"]      = WellList[a].LonDouble[c];
                fs.DataTable.Rows[a]["Contam"]   = WellList[a].Contaminate;
                fs.DataTable.Rows[a]["Trending"] = WellList[a].Trending[c];
                fs.DataTable.Rows[a]["Trend"]    = WellList[a].Trends[c];
                fs.DataTable.Rows[a]["Rsquared"] = WellList[a].R2[c];
                fs.DataTable.Rows[a]["MCL"]      = WellList[a].MCL;
                fs.DataTable.Rows[a]["Units"]    = WellList[a].Latest[c].UNITS;
                fs.DataTable.Rows[a]["NumSamp"]  = WellList[a].SampsByName[c].Count;
                fs.DataTable.Rows[a]["LastDate"] = WellList[a].RecentSampleDate[c];
                fs.DataTable.Rows[a]["Result"]   = WellList[a].Results[c];
                fs.DataTable.Rows[a]["Link"]     = WellList[a].ChartURL[c];
                fs.DataTable.Rows[a].EndEdit();
            }

            fs.Projection =
                KnownCoordinateSystems.Geographic.NorthAmerica.NorthAmericanDatum1983;

            fs.SaveAs(savepath, true);

            //IFeatureSet buff = new FeatureSet();
            //buff = fs.Buffer(.003, true);
            //string filepathB = filepath.Replace(".shp", "buffer.shp");
            //buff.Projection =
            //KnownCoordinateSystems.Geographic.NorthAmerica.NorthAmericanDatum1983;
            //buff.SaveAs(filepathB, true);
        }
Beispiel #13
0
        public static FeatureSet SHPLineDataHandler(FeatureSet fs, IndexedDictionary <string, string[]> data)
        {
            try
            {
                Debug.Write("\nCoor: " + Convert.ToDouble(data["coordinates"][1]) + "| " + Convert.ToDouble(data["coordinates"][2]) + "| " + Convert.ToDouble(data["coordinates"][3]) + "| " + Convert.ToDouble(data["coordinates"][4]));
                DotSpatial.Topology.Coordinate        ptcoor1  = new DotSpatial.Topology.Coordinate(Convert.ToDouble(data["coordinates"][1]), Convert.ToDouble(data["coordinates"][2]));
                DotSpatial.Topology.Coordinate        ptcoor2  = new DotSpatial.Topology.Coordinate(Convert.ToDouble(data["coordinates"][3]), Convert.ToDouble(data["coordinates"][4]));
                List <DotSpatial.Topology.Coordinate> lineCoor = new List <DotSpatial.Topology.Coordinate>();
                lineCoor.Add(ptcoor1);
                lineCoor.Add(ptcoor2);
                LineString line = new LineString(lineCoor);
                DotSpatial.Data.IFeature feature = fs.AddFeature(line);

                //remove geometry
                data.Remove("Geometry");
                //now fill in rest of the columns
                foreach (var item in data)
                {
                    string dataType = data[item.Key][0];
                    string value    = data[item.Key][1];
                    Debug.Write("\n~~~~~~~~~~~~~~~~~~~~~~~~~~~SHP null AND dOUBLE DEBUG~~~~~~~~~~~~~~~~ VALUE : " + value + " =" + (string.IsNullOrEmpty(value)));
                    //check if value is null - double dont accept string null values. need to fix it before sending.
                    if (value.Equals("null") && dataType.Equals("Double"))
                    {
                        //for double
                        double d;
                        if (double.TryParse(value, out d))
                        {
                            // valid number
                            Debug.Write("\n~~~~VALID");
                        }
                        else
                        {
                            // not a valid number
                            Debug.Write("\n~~~~VALID Assigning 0");
                            value = "0";
                        }
                    }


                    if (!item.Key.Equals("Geometry") || !item.Key.Equals("coordinates"))
                    {
                        Debug.Write("\n~~SHP WRITE Property: " + item.Key);
                        Debug.Write("\n~~SHP WRITE dataType: " + dataType);
                        Debug.Write("\n~~SHP WRITE value: " + value);

                        feature.DataRow.BeginEdit();
                        feature.DataRow[item.Key] = value;
                        feature.DataRow.EndEdit();
                    }
                    Debug.Write("\n~~~~~~~~~~~~~~~~~~~~~~~~~~~SHP null AND dOUBLE DEBUG~~~~~~~~~~~~~~~~\n");
                }
            }
            catch (SystemException ex)
            {
                Debug.Write("\n" + ex.ToString());
            }
            return(fs);
        }
Beispiel #14
0
        private void mapMain_MouseClick(object sender, MouseEventArgs e)
        {
            if (e.Button == MouseButtons.Left)
            {
                //left click - fill array of coordinates
                Coordinate coord = mapMain.PixelToProj(e.Location);

                if (polygonmouseClick == true)
                {
                    if (firstClick == true)
                    {
                        //Creat a list to contain the polygon coordinates
                        List <Coordinate> polygonArray = new List <Coordinate>();

                        //Create an instance for LinearRing class.
                        //We pass the polygon List to the constructor of this class
                        LinearRing polygonGeometry = new LinearRing(polygonArray);

                        //add polygonGeomety instance to polygonFeature
                        IFeature polygonFeature = polygonF.AddFeature(polygonGeometry);

                        //add first coordinate
                        polygonFeature.Coordinates.Add(coord);

                        //add to the list of coordinates
                        xCoordinates.Add(coord.X);
                        yCoordinates.Add(coord.Y);

                        //set the polygon feature attribute
                        polygonID = polygonID + 1;
                        polygonFeature.DataRow["PolygonID"] = polygonID;
                        firstClick = false;

                        //Add volume data column
                        polygonFeature.DataRow["Volume"] = 0;
                    }
                    else
                    {
                        //second or more clicks-add points to the existing feature
                        IFeature existingFeature = (IFeature)polygonF.Features[polygonF.Features.Count - 1];

                        existingFeature.Coordinates.Add(coord);

                        //add to the list of coordinates
                        xCoordinates.Add(coord.X);
                        yCoordinates.Add(coord.Y);

                        //refresh the map if line has 2 or more points
                        if (existingFeature.Coordinates.Count != 0)
                        {
                            //refresh the map
                            polygonF.InitializeVertices();
                            mapMain.ResetBuffer();
                        }
                    }
                }
            }
        }
Beispiel #15
0
        public void SavePointToShapefileWithMandZ(CoordinateType c)
        {
            var fileName = FileTools.GetTempFileName(".shp");

            try
            {
                var fs = new FeatureSet(FeatureType.Point)
                {
                    Projection     = KnownCoordinateSystems.Geographic.World.WGS1984,
                    CoordinateType = c
                };

                fs.AddFeature(new Point(new CoordinateZM(1, 2, 7, 4)));

                Assert.DoesNotThrow(() => fs.SaveAs(fileName, true));

                var loaded = FeatureSet.Open(fileName);

                if (c == CoordinateType.Regular)
                {
                    Assert.IsTrue(loaded.Features[0].Geometry.Coordinates[0] is Coordinate);
                    Assert.IsFalse(loaded.Features[0].Geometry.Coordinates[0] is CoordinateZ);
                    Assert.IsFalse(loaded.Features[0].Geometry.Coordinates[0] is CoordinateM);
                }
                else if (c == CoordinateType.M)
                {
                    Assert.IsTrue(loaded.Features[0].Geometry.Coordinates[0] is CoordinateM);
                    Assert.IsFalse(loaded.Features[0].Geometry.Coordinates[0] is CoordinateZ);

                    if (loaded.Features[0].Geometry.Coordinates[0] is CoordinateM cm)
                    {
                        Assert.AreEqual(4, cm.M);
                        Assert.AreEqual(4, loaded.Features[0].Geometry.MinM());
                        Assert.AreEqual(4, loaded.Features[0].Geometry.MaxM());
                    }
                }
                else if (c == CoordinateType.Z)
                {
                    Assert.IsTrue(loaded.Features[0].Geometry.Coordinates[0] is CoordinateZM);

                    if (loaded.Features[0].Geometry.Coordinates[0] is CoordinateZM cm)
                    {
                        Assert.AreEqual(7, cm.Z);
                        Assert.AreEqual(7, loaded.Features[0].Geometry.MinZ());
                        Assert.AreEqual(7, loaded.Features[0].Geometry.MaxZ());

                        Assert.AreEqual(4, cm.M);
                        Assert.AreEqual(4, loaded.Features[0].Geometry.MinM());
                        Assert.AreEqual(4, loaded.Features[0].Geometry.MaxM());
                    }
                }
            }
            finally
            {
                FileTools.DeleteShapeFile(fileName);
            }
        }
Beispiel #16
0
        private IFeature ExtractGeographicData(XmlNode c)
        {
            string         geoData = "";
            IBasicGeometry geo     = null;

            string[] pointValue = null;
            if (typeGeometry == DotSpatial.Topology.FeatureType.Point)
            {
                foreach (XmlNode e in c)
                {
                    if (e.LocalName == Geometry)
                    {
                        geoData = e.InnerText;
                    }
                }
                string point = Convert.ToString(geoData);
                pointValue = point.Split(' ');
                geo        = new Point(Convert.ToDouble(pointValue[0]), Convert.ToDouble(pointValue[1]));
            }

            if (typeGeometry == DotSpatial.Topology.FeatureType.Polygon)
            {
                foreach (XmlNode e in c)
                {
                    if (e.LocalName == Geometry)
                    {
                        var t = e.FirstChild.OuterXml;
                        var s = new XmlSerializer(typeof(MultiSurfaceType));
                        MultiSurfaceType multi = s.Deserialize(new StringReader(t)) as MultiSurfaceType;
                        geo = GetPolygon(multi);
                        // geoData = e.InnerText;
                    }
                }
            }

            if (typeGeometry == DotSpatial.Topology.FeatureType.Line)
            {
                foreach (XmlNode e in c)
                {
                    if (e.LocalName == Geometry)
                    {
                        var t = e.FirstChild.OuterXml;
                        var s = new XmlSerializer(typeof(MultiLineStringType));
                        MultiLineStringType multi = s.Deserialize(new StringReader(t)) as MultiLineStringType;
                        geo = GetPolyline(multi);
                        // geoData = e.InnerText;
                    }
                }
            }



            IFeature feat = fea.AddFeature(geo);

            return(feat);
        }
Beispiel #17
0
        private FeatureSet getFeatureSetFromRegularGrid(int Cols, int Rows, double MinLatitude, double MinLongitude, int ColsPerLongitude, int RowsPerLatitude)
        {
            try
            {
                FeatureSet fs = new FeatureSet();
                fs.DataTable.Columns.Add("Col", typeof(int));
                fs.DataTable.Columns.Add("Row", typeof(int));
                for (int i = 0; i < Cols; i++)
                {
                    for (int j = 0; j < Rows; j++)
                    {
                        Feature           f             = new Feature();
                        List <Coordinate> lstCoordinate = new List <Coordinate>();
                        Coordinate        coordinate    = new Coordinate();
                        coordinate.X = MinLongitude + i * (1.0000 / Convert.ToDouble(ColsPerLongitude));
                        coordinate.Y = MinLatitude + j * (1.0000 / Convert.ToDouble(RowsPerLatitude));
                        lstCoordinate.Add(coordinate);

                        coordinate   = new Coordinate();
                        coordinate.X = MinLongitude + (i + 1) * (1.0000 / Convert.ToDouble(ColsPerLongitude));
                        coordinate.Y = MinLatitude + j * (1.0000 / Convert.ToDouble(RowsPerLatitude));
                        lstCoordinate.Add(coordinate);


                        coordinate   = new Coordinate();
                        coordinate.X = MinLongitude + (i + 1) * (1.0000 / Convert.ToDouble(ColsPerLongitude));
                        coordinate.Y = MinLatitude + (j + 1) * (1.0000 / Convert.ToDouble(RowsPerLatitude));
                        lstCoordinate.Add(coordinate);

                        coordinate   = new Coordinate();
                        coordinate.X = MinLongitude + i * (1.0000 / Convert.ToDouble(ColsPerLongitude));
                        coordinate.Y = MinLatitude + (j + 1) * (1.0000 / Convert.ToDouble(RowsPerLatitude));
                        lstCoordinate.Add(coordinate);

                        coordinate   = new Coordinate();
                        coordinate.X = MinLongitude + i * (1.0000 / Convert.ToDouble(ColsPerLongitude));
                        coordinate.Y = MinLatitude + j * (1.0000 / Convert.ToDouble(RowsPerLatitude));
                        lstCoordinate.Add(coordinate);



                        DotSpatial.Topology.Polygon p = new DotSpatial.Topology.Polygon(lstCoordinate.ToArray());
                        f.BasicGeometry = p;
                        fs.AddFeature(f);
                        fs.DataTable.Rows[i * Rows + j]["Col"] = i;
                        fs.DataTable.Rows[i * Rows + j]["Row"] = j;
                    }
                }
                return(fs);
            }
            catch
            {
                return(null);
            }
        }
Beispiel #18
0
        public void MergeFeature(FeatureSet m_MergeFeaSet)
        {
            if (m_MergeFeaSet.Features.Count < 2 || m_CurrentFeaLyr == null)
            {
                return;
            }

            //确保目标图层只选中编辑的那一个要素,因为后面会把选中要素移除
            //m_CurrentFeaLyr.UnSelectAll();
            //m_CurrentFeaLyr.Selection.Clear();

            //merge
            IFeature MergeFea = m_MergeFeaSet.GetFeature(0);

            for (int i = 0; i < m_MergeFeaSet.Features.Count; i++)
            {
                var fea = m_MergeFeaSet.GetFeature(i);
                MergeFea = MergeFea.Union(fea.Geometry);
                if (MergeFea == null)
                {
                    break;
                }
            }
            lFeaM = m_InputFeaSet.AddFeature(MergeFea.Geometry);
            m_CurrentFeaLyr.RemoveSelectedFeatures();

            MainWindow.m_DotMap.ResetBuffer();
            MainWindow.m_DotMap.Refresh();


            if (MessageBox.Show("Save edit?", "", MessageBoxButton.YesNo) == MessageBoxResult.Yes)
            {
                m_CurrentFeaLyr.FeatureSet.Save();
                MessageBox.Show("Save successfully!");
            }
            //移除图层重新加载,因为底层bug 移动节点之后选择要素会报错。
            MainWindow.m_AddFeaType          = Enum.FeaType.None;
            MainWindow.m_DotMap.FunctionMode = FunctionMode.None;
            MainWindow.m_DotMap.Cursor       = System.Windows.Forms.Cursors.Default;
            string      shpPath = m_CurrentFeaLyr.FeatureSet.FilePath;
            string      name    = m_CurrentFeaLyr.LegendText;
            var         symbol  = m_CurrentFeaLyr.Symbolizer;
            var         extent  = m_CurrentFeaLyr.Extent;
            IFeatureSet s       = Shapefile.Open(shpPath);

            MainWindow.m_DotMap.Layers.Remove(m_CurrentFeaLyr as IMapLayer);
            var result = MainWindow.m_DotMap.Layers.Add(s);

            result.Symbolizer = symbol;
            result.Projection = MainWindow.m_DotMap.Projection;
            result.LegendText = name;
            //result.Select((result as FeatureLayer).FeatureSet.Features[(result as FeatureLayer).FeatureSet.Features.Count - 1]);
            this.Close();
        }
Beispiel #19
0
        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))));
        }
        public void SavePointToShapefileWithMandZ(CoordinateType c)
        {
            var fileName = FileTools.GetTempFileName(".shp");

            try
            {
                var fs = new FeatureSet(FeatureType.Point)
                {
                    Projection     = KnownCoordinateSystems.Geographic.World.WGS1984,
                    CoordinateType = c
                };

                fs.AddFeature(new Point(new Coordinate(1, 2, 7, 4)));

                Assert.DoesNotThrow(() => fs.SaveAs(fileName, true));

                var loaded = FeatureSet.Open(fileName);

                if (c == CoordinateType.Regular)
                {
                    // regular coordinates don't have m values
                    Assert.AreEqual(double.NaN, loaded.Features[0].Geometry.Coordinates[0].M);
                    Assert.AreEqual(double.NaN, loaded.Features[0].Geometry.EnvelopeInternal.Minimum.M);
                    Assert.AreEqual(double.NaN, loaded.Features[0].Geometry.EnvelopeInternal.Maximum.M);
                }
                else
                {
                    // m or z coordinates have m values
                    Assert.AreEqual(4, loaded.Features[0].Geometry.Coordinates[0].M);
                    Assert.AreEqual(4, loaded.Features[0].Geometry.EnvelopeInternal.Minimum.M);
                    Assert.AreEqual(4, loaded.Features[0].Geometry.EnvelopeInternal.Maximum.M);
                }

                if (c == CoordinateType.Z)
                {
                    // z coordinates have z values
                    Assert.AreEqual(7, loaded.Features[0].Geometry.Coordinates[0].Z);
                    Assert.AreEqual(7, loaded.Features[0].Geometry.EnvelopeInternal.Minimum.Z);
                    Assert.AreEqual(7, loaded.Features[0].Geometry.EnvelopeInternal.Maximum.Z);
                }
                else
                {
                    // regular and m coordinates don't have z values
                    Assert.AreEqual(double.NaN, loaded.Features[0].Geometry.Coordinates[0].Z);
                    Assert.AreEqual(double.NaN, loaded.Features[0].Geometry.EnvelopeInternal.Minimum.Z);
                    Assert.AreEqual(double.NaN, loaded.Features[0].Geometry.EnvelopeInternal.Maximum.Z);
                }
            }
            finally
            {
                FileTools.DeleteShapeFile(fileName);
            }
        }
Beispiel #21
0
        private void SetupResultsMapGroup(Core.Result.IResultSet set)
        {
            if (this.resultsGroup == null)
            {
                this.resultsGroup                  = new DotSpatial.Controls.MapGroup();
                this.resultsGroup.LegendText       = "Results";
                this.resultsGroup.SelectionEnabled = true;
                this.resultsGroup.IsVisible        = false;
                this.map.Layers.Add(this.resultsGroup);
            }

            if (set == null)
            {
                if (this.resultsLayer != null)
                {
                    this.resultsGroup.Layers.Remove(this.resultsLayer);
                    this.resultsLayer = null;
                }
                this.curResultsSet          = null;
                this.resultsGroup.IsVisible = false;
                return;
            }

            this.resultsGroup.IsVisible = true;
            if (this.resultsGroup.Layers.Count > 0)
            {
                this.resultsGroup.Layers.Clear();
            }

            this.curResultsSet = set;

            FeatureSet featureSet = new FeatureSet(FeatureType.Line);

            featureSet.Projection = this.map.Projection;
            featureSet.DataTable.Columns.Add(new DataColumn("LayerName", typeof(string)));

            foreach (var layer in this.curResultsSet.LayerNames)
            {
                var points = this.curResultsSet.GetDataset(layer);
                List <Coordinate> coords = new List <Coordinate>();
                for (int i = 0; i <= points.GetUpperBound(0); i++)
                {
                    coords.Add(new Coordinate(points[i, 0], points[i, 1]));
                }
                var feature = featureSet.AddFeature(new LineString(coords));
                feature.DataRow["LayerName"] = layer;
            }

            this.resultsLayer = new MapLineLayer(featureSet);
            this.resultsLayer.Symbology.EditorSettings.ExcludeExpression = "[LayerName] <> ''";

            this.resultsGroup.Layers.Add(this.resultsLayer);
        }
Beispiel #22
0
        /// <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

            resultFeatures.CopyTableSchema(targetFeatures); // set up the data table in the new feature set

            for (short i = 0; i <= targetFeatures.ShapeIndices.Count - 1; i++)
            {
                var tf = targetFeatures.GetFeature(i); // get the full undifferenced feature
                for (short j = 0; j <= sourceFeatures.ShapeIndices.Count - 1; j++)
                {
                    var sf = sourceFeatures.GetFeature(j);
                    if (sf.Geometry.Envelope.Intersects(tf.Geometry.Envelope))
                    {
                        tf = tf.Difference(sf.Geometry); // 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.Geometry).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);
        }
Beispiel #23
0
        public static MemoryStream GenerateShapeFile(Collection <NatureArea> natureAreas, int epsgCode)
        {
            // Return empty memory stream if there are no nature areas or no epsg code:
            if (natureAreas.Count == 0 || epsgCode < 0)
            {
                return(new MemoryStream());
            }

            // Define a new set of features and set projection:
            FeatureSet featureSets = new FeatureSet {
                Projection = ProjectionInfo.FromEpsgCode(epsgCode)
            };

            // Add data columns
            featureSets.DataTable.Columns.Add(new DataColumn("LocalId", typeof(string)));
            featureSets.DataTable.Columns.Add(new DataColumn("Nivå", typeof(string)));
            featureSets.DataTable.Columns.Add(new DataColumn("NiN", typeof(string)));

            // Create geometry objects:
            foreach (var natureArea in natureAreas)
            {
                if (natureArea.Area == null)
                {
                    continue;
                }
                IFeature feature = featureSets.AddFeature(DotSpatialGeometry.GetGeometry(natureArea.Area));

                // Adding values for the data columns
                feature.DataRow.BeginEdit();
                feature.DataRow["LocalId"] = natureArea.UniqueId.LocalId.ToString();
                feature.DataRow["Nivå"]    = Naturnivå.TilNavn(natureArea.Nivå);
                feature.DataRow["NiN"]     = FormatNatureAreaTypes(natureArea.Parameters);
                feature.DataRow.EndEdit();
            }

            // Create temporary directory:
            string tempDirectoryPath = GetTempDirectoryPath();

            // Save the feature set:
            featureSets.SaveAs(tempDirectoryPath + "\\TempShapeFiles\\data.shp", true);

            // Zip all shape files:
            ZipFile.CreateFromDirectory(tempDirectoryPath + "\\TempShapeFiles", tempDirectoryPath + "\\data.zip");

            // Read the zip file:
            var bytes = File.ReadAllBytes(tempDirectoryPath + "\\data.zip");

            // Delete the temporary directory:
            Directory.Delete(tempDirectoryPath, true);

            return(new MemoryStream(bytes));
        }
Beispiel #24
0
        // metric coordinates
        public static IFeatureSet CreateUserInputLayer(double lon, double lat, double radius, string workdir)
        {
            FeatureSet infs = new FeatureSet(DotSpatial.Topology.FeatureType.Point);

            infs.Projection = KnownCoordinateSystems.Projected.WorldSpheroid.Mercatorsphere;
            DotSpatial.Data.Feature center = new DotSpatial.Data.Feature(new Coordinate(lon, lat));
            infs.AddFeature(center);

            var fs = infs.Buffer(radius, false);

            fs.SaveAs(WORKSPACE_DIR + workdir + "/usr.shp", true);
            return(fs);
        }
Beispiel #25
0
        public void AddMustNotReplaceFeatureRow()
        {
            var     parent   = new FeatureSet(FeatureType.Point);
            var     target   = parent.Features;
            DataRow expected = null;

            target.FeatureAdded += (sender, args) => expected = args.Feature.DataRow;

            var addedFeature = parent.AddFeature(Point.Empty);
            var actual       = addedFeature.DataRow;

            Assert.AreEqual(expected, actual);
        }
Beispiel #26
0
        /// <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
            for (short j = 0; j <= sourceFeatures.ShapeIndices.Count - 1; j++)
            {
                var sf = sourceFeatures.GetFeature(j);
                targetFeatures.AddFeature(sf.Geometry).CopyAttributes(sf); // by default this will try to copy attributes over that have the same name.
            }

            return(targetFeatures);
        }
Beispiel #27
0
        /// <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);                                                   //TODO jany_ why call get feature twice instead of using sf to copy attributes?
                TargetFeatures.AddFeature(SF.Geometry).CopyAttributes(SourceFeatures.GetFeature(j)); //by default this will try to copy attributes over that have the same name.
            }
            return(TargetFeatures);
        }
        /// <summary>
        /// Get X,Y axis expressed by longitude and latitude
        /// </summary>
        /// <returns>mat[2][], mat[0] is longitude, mat[1] is latitude </returns>
        public float[][] GetLonLatAxis()
        {
            var lonlat = new float[2][];

            lonlat[0] = new float[ColumnCount];
            lonlat[1] = new float[RowCount];

            var         wgs84  = ProjectionInfo.FromEpsgCode(4326);
            IFeatureSet fs_lon = new FeatureSet(FeatureType.Point);

            fs_lon.Projection = this.Projection;
            for (int c = 0; c < ColumnCount; c++)
            {
                var   vertice = LocateCentroid(c + 1, 1);
                Point pt      = new Point(vertice);
                fs_lon.AddFeature(pt);
            }
            if (fs_lon.Projection != null)
            {
                fs_lon.Reproject(wgs84);
            }
            for (int c = 0; c < ColumnCount; c++)
            {
                var fea = fs_lon.GetFeature(c).Geometry.Coordinate;
                lonlat[0][c] = (float)fea.X;
            }


            IFeatureSet fs_lat = new FeatureSet(FeatureType.Point);

            fs_lat.Projection = this.Projection;
            for (int r = 0; r < RowCount; r++)
            {
                var   vertice = LocateCentroid(1, r + 1);
                Point pt      = new Point(vertice);
                fs_lat.AddFeature(pt);
            }
            if (fs_lat.Projection != null)
            {
                fs_lat.Reproject(wgs84);
            }
            for (int r = 0; r < RowCount; r++)
            {
                var fea = fs_lat.GetFeature(r).Geometry.Coordinate;
                lonlat[1][r] = (float)fea.Y;
            }

            return(lonlat);
        }
        public void Add_MustNotReplaceFeatureRow()
        {
            var parent = new FeatureSet(FeatureType.Point);
            var target = parent.Features;
            DataRow expected = null;
            target.FeatureAdded += delegate(object sender, FeatureEventArgs args)
                                       {
                                           expected = args.Feature.DataRow;
                                       };

            var addedFeature = parent.AddFeature(new Point());
            var actual = addedFeature.DataRow;

            Assert.AreEqual(expected, actual);
        }
Beispiel #30
0
        private static IFeatureSet UnionAll(IFeatureSet fs)
        {
            FeatureSet fsunion = new FeatureSet();

            fsunion.CopyTableSchema(fs);
            fsunion.Projection = fs.Projection;
            IFeature f = fs.Features[0];

            for (int i = 1; i < fs.Features.Count; i++)
            {
                f = f.Union(fs.Features[i], fsunion, FieldJoinType.LocalOnly);
            }
            fsunion.AddFeature(f.Geometry); //TODO jany_ why union feature if only geometry is used to create new feature?
            return(fsunion);
        }
Beispiel #31
0
        private static IFeatureSet UnionAll(IFeatureSet fs)
        {
            FeatureSet fsunion = new FeatureSet();

            fsunion.CopyTableSchema(fs);
            fsunion.Projection = fs.Projection;
            IFeature f = fs.Features[0];

            for (int i = 1; i < fs.Features.Count; i++)
            {
                f = f.Union(fs.Features[i], fsunion, FieldJoinType.LocalOnly);
            }
            fsunion.AddFeature(f);
            return(fsunion);
        }
Beispiel #32
0
        public void CoordinateType_WriteOnSaveAs()
        {
            var outfile = FileTools.GetTempFileName(".shp");
            IFeatureSet fs = new FeatureSet();
            var c = new Coordinate(10.1, 20.2, 3.3, 4.4);
            IFeature f = new Feature(c);

            fs.CoordinateType = CoordinateType.Z;
            fs.Projection = KnownCoordinateSystems.Geographic.World.WGS1984;
            fs.DataTable.Columns.Add(new DataColumn(("ID"), typeof(int)));

            f = fs.AddFeature(f);

            f.ShapeType = ShapeType.PointZ;

            f.DataRow.BeginEdit();
            f.DataRow["ID"] = 1;
            f.DataRow.EndEdit();

            fs.SaveAs(outfile, true);

            var actual = FeatureSet.Open(outfile);
            try
            {
                Assert.AreEqual(fs.CoordinateType, actual.CoordinateType);
            }
            finally 
            {
                FileTools.DeleteShapeFile(outfile);
            }
        }
Beispiel #33
0
        public void UtmProjection_SamePoints_AfterSaveLoadShapeFile()
        {
            var fs = new FeatureSet(FeatureType.Point)
            {
                Projection = KnownCoordinateSystems.Projected.UtmWgs1984.WGS1984UTMZone33N // set any UTM projection
            };

            const double originalX = 13.408056;
            const double originalY = 52.518611;

            var wgs = KnownCoordinateSystems.Geographic.World.WGS1984;
            var c = new[] { originalX, originalY };
            var z = new[] { 0.0 };
            Reproject.ReprojectPoints(c, z, wgs, fs.Projection, 0, 1);

            var pt = new Point(c[0], c[1]);
            fs.AddFeature(pt);
            var tmpFile = FileTools.GetTempFileName(".shp");
            fs.SaveAs(tmpFile, true);

            try
            {
                // Now try to open saved shapefile
                // Points must have same location in WGS1984
                var openFs = FeatureSet.Open(tmpFile);
                var fs0 = (Point) openFs.Features[0].BasicGeometry;
                var c1 = new[] {fs0.X, fs0.Y};
                Reproject.ReprojectPoints(c1, z, openFs.Projection, wgs, 0, 1); // reproject back to wgs1984

                Assert.IsTrue(Math.Abs(originalX - c1[0]) < 1e-8);
                Assert.IsTrue(Math.Abs(originalY - c1[1]) < 1e-8);
            }
            finally
            {
                FileTools.DeleteShapeFile(tmpFile);
            }
        }