示例#1
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);
        }
示例#2
0
 private static void TestCoordinate(Coordinate c1, DotSpatial.Topology.Coordinate c2)
 {
     Assert.AreEqual(c1.X, c2.X);
     Assert.AreEqual(c1.Y, c2.Y);
     if (!double.IsNaN(c1.Z))
     {
         Assert.AreEqual(c1.Z, c2.Z);
     }
 }
示例#3
0
        /// <summary>
        /// 由点list新建shp文件
        /// </summary>
        /// <param name="point_list"></param>
        /// <param name="file_path"></param>
        public static void outputMyPoint(List <MyPoint> point_list, string file_path)
        {
            Feature    f  = new Feature();
            FeatureSet fs = new FeatureSet(f.FeatureType);

            //fs.DataTable.Columns.Add("azimuth", typeof(double));
            //fs.DataTable.Columns.Add("speed", typeof(double));
            DotSpatial.Topology.Coordinate[] coordinate = new DotSpatial.Topology.Coordinate[point_list.Count];
            for (int i = 0; i < point_list.Count; i++)
            {
                coordinate[i] = new DotSpatial.Topology.Coordinate(point_list[i].x, point_list[i].y);
                fs.Features.Add(coordinate[i]);
                //fs.DataTable.Rows[i]["azimuth"] = point_list[i].azimuth;
                //fs.DataTable.Rows[i]["speed"] = point_list[i].speed;
            }
            fs.SaveAs(file_path, true);
            //fs.Projection.SaveAs(file_path.Substring(0, file_path.Length - 4) + ".prj");
        }
示例#4
0
        public static FeatureSet SHPPointDataHandler(FeatureSet fs, IndexedDictionary <string, string[]> data)
        {
            try
            {
                DotSpatial.Topology.Coordinate ptcoor = new DotSpatial.Topology.Coordinate(Convert.ToDouble(data["Northing"][1]), Convert.ToDouble(data["Easting"][1]));
                Point pt = new Point(ptcoor);
                DotSpatial.Data.IFeature feature = fs.AddFeature(pt);

                //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];


                    if (!item.Key.Equals("Northing") || !item.Key.Equals("Easting") || !item.Key.Equals("Geometry"))
                    {
                        Debug.Write("\nProperty: " + item.Key);
                        Debug.Write("\ndataType: " + dataType);
                        Debug.Write("\nvalue: " + value);

                        feature.DataRow.BeginEdit();
                        feature.DataRow[item.Key] = value;
                        feature.DataRow.EndEdit();
                    }
                }
            }
            catch (SystemException ex)
            {
                Debug.Write("\n" + ex.ToString());
            }
            return(fs);
        }
 /// <summary>
 /// Clears the array, reducing the measure to 1 empty coordinate.
 /// </summary>
 public virtual void Clear()
 {
     _coordinates    = new Coordinate[1];
     _coordinates[0] = new Coordinate();
     IncrementVersion();
 }
 /// <summary>
 /// Creates a new array sequence dimensioned with exactly 1 coordinate, which is set to the coordinate
 /// </summary>
 /// <param name="coordinate">The ICoordinate to use when constructing this sequence</param>
 public CoordinateArraySequence(Coordinate coordinate)
 {
     Coordinate[] coords = new Coordinate[1];
     coords[0] = coordinate;
     Configure(coords);
 }
示例#7
0
 /// <summary>
 ///
 /// </summary>
 /// <param name="coord"></param>
 /// <param name="exemplar"></param>
 /// <returns></returns>
 public static IPoint CreatePointFromInternalCoord(Coordinate coord, IGeometry exemplar)
 {
     new PrecisionModel(exemplar.PrecisionModel).MakePrecise(coord);
     return(exemplar.Factory.CreatePoint(coord));
 }
示例#8
0
 /// <summary>
 /// Creates a Point using the given Coordinate; a null Coordinate will create
 /// an empty Geometry.
 /// </summary>
 /// <param name="coordinate"></param>
 public virtual IPoint CreatePoint(Coordinate coordinate)
 {
     return(new Point(coordinate, this));
 }
示例#9
0
        private static QuadTree<byte> BuildQuadTree(StRtree Tree, Dictionary<string, byte> Countries, Coordinate TopLeft, Coordinate BottomRight, int MaxDepth, int Depth = 0)
        {
            // Bounding box for this node.
            var envelope = new Envelope(TopLeft, BottomRight);

            // Find all countries whose bounding boxes intersect with this node.
            var coarseResults = Tree.Query(envelope);

            // Of those countries, find those whose geometry actually intersects with this node.
            var fineResults = (from Tuple<string, IGeometry> r in coarseResults select r).Where(r => r.Item2.Intersects(envelope.ToPolygon()));

            // In case of either:
            // 1) No countries intersect, in which case we mark this node as empty. Or;
            // 2) Exactly one country intersects, in which case we mark this node as that country.
            var results = fineResults as IList<Tuple<string, IGeometry>> ?? fineResults.ToList();
            if (results.Count() <= 1)
            {
                var country = results.FirstOrDefault();
                var countryName = country != null ? country.Item1 : "";

                Console.WriteLine("Adding {0}, Depth {1}, {2}x{3}", countryName, Depth, BottomRight.X - TopLeft.X, BottomRight.Y - TopLeft.Y);
                ++_nleafs;
                return new QuadTreeLeaf<byte>
                {
                    Data = Countries[countryName],
                    TopLeft = TopLeft.ToGeomoirCoordinate(),
                    BottomRight = BottomRight.ToGeomoirCoordinate()
                };
            }

            // If we have reached the maximum depth and multiple countries interect
            // with this node, mark it as the country with the largest overlap.
            if (Depth >= MaxDepth)
            {
                byte label = 0;
                // Take country with largest area intersecting.
                var r = (from Tuple<string, IGeometry> t in results orderby t.Item2.Intersection(envelope.ToPolygon()).Area descending select t).First();
                if (r.Item2.Intersection(envelope.ToPolygon()).Area > 0)
                    label = Countries[r.Item1];

                ++_nleafs;
                return new QuadTreeLeaf<byte>
                {
                    Data = label,
                    TopLeft = TopLeft.ToGeomoirCoordinate(),
                    BottomRight = BottomRight.ToGeomoirCoordinate()
                };
            }

            // Split the node into 4 quadrants and recurse on each.
            var middleTop = new Coordinate((BottomRight.X + TopLeft.X) / 2, TopLeft.Y);
            var middleBottom = new Coordinate((BottomRight.X + TopLeft.X) / 2, BottomRight.Y);
            var middleLeft = new Coordinate(TopLeft.X, (BottomRight.Y + TopLeft.Y) / 2);
            var middleRight = new Coordinate(BottomRight.X, (BottomRight.Y + TopLeft.Y) / 2);
            var middle = new Coordinate(middleTop.X, middleLeft.Y);
            return new QuadTreeNode<byte>
            {
                TopLeft = TopLeft.ToGeomoirCoordinate(),
                BottomRight = BottomRight.ToGeomoirCoordinate(),
                Children = new []
                {
                    BuildQuadTree(Tree, Countries, TopLeft, middle, MaxDepth, Depth + 1),
                    BuildQuadTree(Tree, Countries, middleTop, middleRight, MaxDepth, Depth + 1),
                    BuildQuadTree(Tree, Countries, middleLeft, middleBottom, MaxDepth, Depth + 1),
                    BuildQuadTree(Tree, Countries, middle, BottomRight, MaxDepth, Depth + 1)
                }
            };
        }
示例#10
0
        private void map1_MouseDown(object sender, MouseEventArgs e)
        {
            switch (shapeType)
            {
            case "Point":
                if (e.Button == MouseButtons.Left)
                {
                    if ((pointmouseClick))
                    {
                        //This method is used to convert the screen cordinate to map coordinate
                        //e.location is the mouse click point on the map control
                        DotSpatial.Topology.Coordinate coord = map1.PixelToProj(e.Location);

                        //Create a new point
                        //Input parameter is clicked point coordinate
                        DotSpatial.Topology.Point point = new DotSpatial.Topology.Point(coord);

                        //Add the point into the Point Feature
                        //assigning the point feature to IFeature because via it only we can set the attributes.
                        IFeature currentFeature = pointF.AddFeature(point);

                        //increase the point id
                        pointID = pointID + 1;

                        //set the ID attribute
                        currentFeature.DataRow["ID"] = pointID;

                        //refresh the map
                        map1.ResetBuffer();
                    }
                }

                else
                {
                    //mouse right click
                    map1.Cursor     = Cursors.Default;
                    pointmouseClick = false;
                }
                break;

            case "line":
                if (e.Button == MouseButtons.Left)
                {
                    //left click - fill array of coordinates
                    //coordinate of clicked point
                    DotSpatial.Topology.Coordinate coord = map1.PixelToProj(e.Location);
                    if (linemouseClick)
                    {
                        //first time left click - create empty line feature
                        if (firstClick)
                        {
                            //Create a new List called lineArray.
                            //This list will store the Coordinates
                            //We are going to store the mouse click coordinates into this array.
                            List <DotSpatial.Topology.Coordinate> lineArray = new List <DotSpatial.Topology.Coordinate>();

                            //Create an instance for LineString class.
                            //We need to pass collection of list coordinates
                            LineString lineGeometry = new LineString(lineArray);

                            //Add the linegeometry to line feature
                            IFeature lineFeature = lineF.AddFeature(lineGeometry);

                            //add first coordinate to the line feature
                            lineFeature.Coordinates.Add(coord);
                            //set the line feature attribute
                            lineID = lineID + 1;
                            lineFeature.DataRow["LineID"] = lineID;
                            firstClick = false;
                        }
                        else
                        {
                            //second or more clicks - add points to the existing feature
                            IFeature existingFeature = lineF.Features[lineF.Features.Count - 1];
                            existingFeature.Coordinates.Add(coord);

                            //refresh the map if line has 2 or more points
                            if (existingFeature.Coordinates.Count >= 2)
                            {
                                lineF.InitializeVertices();
                                map1.ResetBuffer();
                            }
                        }
                    }
                }
                else
                {
                    //right click - reset first mouse click
                    firstClick = true;
                    map1.ResetBuffer();
                }
                break;

            case "polygon":

                if (e.Button == MouseButtons.Left)
                {
                    //left click - fill array of coordinates
                    DotSpatial.Topology.Coordinate coord = map1.PixelToProj(e.Location);

                    if (polygonmouseClick)
                    {
                        //first time left click - create empty line feature
                        if (firstClick)
                        {
                            //Create a new List called polygonArray.

                            //this list will store the Coordinates
                            //We are going to store the mouse click coordinates into this array.

                            List <DotSpatial.Topology.Coordinate> polygonArray = new List <DotSpatial.Topology.Coordinate>();

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

                            //Add the polygonGeometry instance to PolygonFeature
                            IFeature polygonFeature = polygonF.AddFeature(polygonGeometry);

                            //add first coordinate to the polygon feature
                            polygonFeature.Coordinates.Add(coord);

                            //set the polygon feature attribute
                            polygonID = polygonID + 1;
                            polygonFeature.DataRow["PolygonID"] = polygonID;
                            firstClick = false;
                        }
                        else
                        {
                            //second or more clicks - add points to the existing feature
                            IFeature existingFeature = (IFeature)polygonF.Features[polygonF.Features.Count - 1];

                            existingFeature.Coordinates.Add(coord);

                            //refresh the map if line has 2 or more points
                            if (existingFeature.Coordinates.Count >= 3)
                            {
                                //refresh the map
                                polygonF.InitializeVertices();
                                map1.ResetBuffer();
                            }
                        }
                    }
                }
                else
                {
                    //right click - reset first mouse click
                    firstClick = true;
                }
                break;
            }
        }