예제 #1
0
        void cmbFeatureLayer_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            var selected = cmbFeatureLayer.SelectedItem as VectorLayerViewModel;

            if (selected != null)
            {
                var layer = selected.Model as VectorLayer;
                SharpMap.Data.FeatureDataSet ds = new SharpMap.Data.FeatureDataSet();
                layer.DataSource.Open();
                layer.DataSource.ExecuteIntersectionQuery(layer.DataSource.GetExtents(), ds);
                DataTable tbl = ds.Tables[0] as SharpMap.Data.FeatureDataTable;

                var list = new ObservableCollection <DataColumnViewModel>();

                var ignore = new String[] { "BLREGHIER", "BLAUTH" };

                foreach (DataColumn col in tbl.Columns)
                {
                    var vm = new DataColumnViewModel(col);
                    if (!ignore.Contains(col.ColumnName))
                    {
                        vm.IsSelected = true;
                    }
                    list.Add(vm);
                }

                lstFields.ItemsSource = list;
            }
        }
예제 #2
0
        public void TestCreateFromFeatureDataTable()
        {
            var fds = new SharpMap.Data.FeatureDataSet();
            FeatureDataTable fdt = null;

            try
            {
                var p = new Ogr("C:\\Users\\obe.IVV-AACHEN\\Downloads\\SharpMap Codeplex\\SHPFiles\\RxLevel-Idle.shp");
                p.SRID = 4326;
                var layer = string.Empty;
                if (!string.IsNullOrEmpty(layer))
                {
                    p.LayerName = layer;
                }

                p.ExecuteIntersectionQuery(p.GetExtents(), fds);
                fdt = fds.Tables[0];
                if (fdt.Rows.Count == 0)
                {
                    throw new Exception("no data in layer");
                }
            }
            catch (Exception ex)
            {
                throw new IgnoreException("Getting data failed", ex);
            }

            Assert.DoesNotThrow(() => Ogr.CreateFromFeatureDataTable(fdt,
                                                                     ((FeatureDataRow)fdt.Rows[0]).Geometry.OgcGeometryType, 4326,
                                                                     "Mapinfo File",
                                                                     "C:\\Users\\obe.IVV-AACHEN\\Downloads\\SharpMap Codeplex\\SHPFiles\\RxLevel-Idle.tab"));
        }
예제 #3
0
        public static FeatureDataRow FindGeoNearPoint(GeoAPI.Geometries.IPoint point, VectorLayer layer, double amountGrow)
        {
            var box = new Envelope(point.Coordinate);
            box.ExpandBy(amountGrow);

            var fds = new FeatureDataSet();
            layer.DataSource.ExecuteIntersectionQuery(box, fds);

            FeatureDataRow result = null;
            var minDistance = double.MaxValue;

            foreach (FeatureDataTable fdt in fds.Tables)
            {
                foreach (FeatureDataRow fdr in fdt.Rows)
                {
                    if (fdr.Geometry != null)
                    {
                        var distance = point.Distance(fdr.Geometry);
                        if (distance < minDistance)
                        {
                            result = fdr;
                            minDistance = distance;
                        }
                    }
                }
            }

            return result;
        }
예제 #4
0
        public void TestCreateFromFeatureDataTable()
        {
            var fds = new SharpMap.Data.FeatureDataSet();
            FeatureDataTable fdt = null;
            try
            {
                var p = new Ogr("C:\\Users\\obe.IVV-AACHEN\\Downloads\\SharpMap Codeplex\\SHPFiles\\RxLevel-Idle.shp");
                p.SRID = 4326;
                var layer = string.Empty;
                if (!string.IsNullOrEmpty(layer)) p.LayerName = layer;

                p.ExecuteIntersectionQuery(p.GetExtents(), fds);
                fdt = fds.Tables[0];
                if (fdt.Rows.Count == 0)
                    throw new Exception("no data in layer");
            }
            catch (Exception ex)
            {
                throw new IgnoreException("Getting data failed", ex);
            }

            Assert.DoesNotThrow(() => Ogr.CreateFromFeatureDataTable(fdt, 
                ((FeatureDataRow)fdt.Rows[0]).Geometry.OgcGeometryType, 4326, 
                "Mapinfo File", 
                "C:\\Users\\obe.IVV-AACHEN\\Downloads\\SharpMap Codeplex\\SHPFiles\\RxLevel-Idle.tab"));
        }
예제 #5
0
        public void render2d(Project project, PictureBox picBox)
        {

            SharpMap.Map myMap = new SharpMap.Map();

            foreach (BuildLayer layer in project.getLayers())
            {
                Source source = layer.getSource();

                BoundingBox envelope = new BoundingBox(-1000.0, -1000.0, 1000.0, 1000.0);//TODO
                FeatureDataSet ds = new FeatureDataSet();
                source.DataSource.Open();
                source.DataSource.ExecuteIntersectionQuery(envelope, ds);
                source.DataSource.Close();

                FeatureDataTable features = (FeatureDataTable)ds.Tables[0];

                string label = "Trace test:\n";

                foreach (FeatureDataRow row in features)
                {
                    foreach (Object item in row.ItemArray)
                        label += " - " + item;
                    label += "\n";
                }

                setLabel(label);

                //Show map

                //Filters
                FilterGraph graph = project.getFilterGraph(source.getName());
                if (graph != null)
                {
                    foreach (FeatureFilter filter in graph.getFilters())
                    {
                        //aplicar filtro segun el tipo
                        Mogre.DefaultSceneManagerFactory dsmf = new DefaultSceneManagerFactory();
                        Mogre.SceneManager sm = dsmf.CreateInstance("scenemanager");
                        FilterEnv env = new FilterEnv(sm, "env");
                        foreach (MogreGis.Resource resource in project.getResources())
                        {
                            env.getSession().Resources.addResource(resource);
                        }
                        FeatureList list = Feature.DataTableToList(features);
                        filter.process(list, env);
                        //falta devolver la lista y procesarla ***************************************
                    }
                }

                SharpMap.Layers.VectorLayer myLayer = new SharpMap.Layers.VectorLayer(layer.getName());
                myLayer.DataSource = source.DataSource;
                myMap.Layers.Add(myLayer);
            }

            myMap.Size = new Size(picBox.Width, picBox.Height);
            myMap.ZoomToExtents();
            picBox.Image = myMap.GetMap();
            this.map = myMap;
        }
예제 #6
0
        public IFeatureReader ExecuteFeatureReader(SpatialPredicate predicate, Envelope envelope)
        {
            if (predicate != SpatialPredicate.Intersects)
                throw new NotSupportedException();

            var fds = new FeatureDataSet();
            _provider.ExecuteIntersectionQuery(envelope, fds);
            return new ProviderFeatureDataRowReader(fds.Tables[0]);
        }
 public void TestExecuteIntersectionQueryAgainstEnvelope()
 {
     using (var p = CreateProvider())
     {
         var fds = new FeatureDataSet();
         Assert.DoesNotThrow(() => p.ExecuteIntersectionQuery(p.GetExtents(), fds));
         Assert.AreEqual(1, fds.Tables.Count);
         var table = fds.Tables[0];
         Assert.AreEqual(_tableName, table.TableName);
         Assert.AreEqual(4, table.Rows.Count);
     }
 }
예제 #8
0
        public void ExecuteIntersectionQuery(SharpMap.Geometries.BoundingBox box, SharpMap.Data.FeatureDataSet ds)
        {
            Rectangle r = new Rectangle((float)box.Left, (float)box.Bottom, (float)box.Right, (float)box.Top, (float)0.0, (float)0.0);

            FdoFeature[] matches = _data.Intersects(r);

            FeatureDataTable table = new FeatureDataTable();

            foreach (DataColumn col in _data.Columns)
            {
                table.Columns.Add(col.ColumnName, col.DataType, col.Expression);
            }

            //Filter the initial result set by inverting the operands. This weeds out non-matches on point intersection tests.
            IEnvelope   env  = Converter.EnvelopeFromBoundingBox(box);
            FdoGeometry poly = new FdoGeometry(Converter.CreatePolygonFromEnvelope(env));

            foreach (FdoFeature feat in matches)
            {
                FdoGeometry geom = feat.DesignatedGeometry;
                if (geom != null)
                {
                    if (geom.Contains(env) || geom.Intersects(poly))
                    {
                        FeatureDataRow row = table.NewRow();
                        bool           add = true;
                        foreach (DataColumn col in _data.Columns)
                        {
                            if (col.ColumnName == _data.GeometryColumn)
                            {
                                try
                                {
                                    row.Geometry = Converter.FromFdoGeometry(geom, _geomFactory);
                                }
                                catch //Can't help you if you fail conversion.
                                {
                                    add = false;
                                }
                            }
                            else
                            {
                                row[col.ColumnName] = feat[col.ColumnName];
                            }
                        }
                        if (add)
                        {
                            table.AddRow(row);
                        }
                    }
                }
            }
            ds.Tables.Add(table);
        }
예제 #9
0
        /// <summary>
        /// Returns all features with the view box
        /// </summary>
        /// <param name="bbox">view box</param>
        /// <param name="ds">FeatureDataSet to fill data into</param>
        public void ExecuteIntersectionQuery(SharpMap.Geometries.BoundingBox bbox, SharpMap.Data.FeatureDataSet ds)
        {
            List <Geometries.Geometry> features = new List <SharpMap.Geometries.Geometry>();

            using (SqlConnection conn = new SqlConnection(_ConnectionString))
            {
                string strSQL = "SELECT *, " + this.GeometryColumn + " AS sharpmap_tempgeometry ";
                strSQL += "FROM " + this.Table + " WHERE ";
                strSQL += GetBoxClause(bbox);

                if (_defintionQuery != null && _defintionQuery != "")
                {
                    strSQL += " AND " + this.DefinitionQuery;
                }

                using (SqlDataAdapter adapter = new SqlDataAdapter(strSQL, conn))
                {
                    conn.Open();
                    System.Data.DataSet ds2 = new System.Data.DataSet();
                    adapter.Fill(ds2);
                    conn.Close();
                    if (ds2.Tables.Count > 0)
                    {
                        FeatureDataTable fdt = new FeatureDataTable(ds2.Tables[0]);
                        foreach (System.Data.DataColumn col in ds2.Tables[0].Columns)
                        {
                            if (col.ColumnName != this.GeometryColumn && col.ColumnName != "sharpmap_tempgeometry" && !col.ColumnName.StartsWith("Envelope_"))
                            {
                                fdt.Columns.Add(col.ColumnName, col.DataType, col.Expression);
                            }
                        }
                        foreach (System.Data.DataRow dr in ds2.Tables[0].Rows)
                        {
                            SharpMap.Data.FeatureDataRow fdr = fdt.NewRow();
                            foreach (System.Data.DataColumn col in ds2.Tables[0].Columns)
                            {
                                if (col.ColumnName != this.GeometryColumn && col.ColumnName != "sharpmap_tempgeometry" && !col.ColumnName.StartsWith("Envelope_"))
                                {
                                    fdr[col.ColumnName] = dr[col];
                                }
                            }
                            if (dr["sharpmap_tempgeometry"] != DBNull.Value)
                            {
                                fdr.Geometry = SharpMap.Converters.WellKnownBinary.GeometryFromWKB.Parse((byte[])dr["sharpmap_tempgeometry"]);
                            }
                            fdt.AddRow(fdr);
                        }
                        ds.Tables.Add(fdt);
                    }
                }
            }
        }
예제 #10
0
        public void TestIndexing()
        {
            var fds = new FeatureDataSet { DataSetName = "Indexing" };
            var ds = (DataSet)fds;

            for (var i = 0; i < 10; i++)
                ds.Tables.Add(i%2 == 0 ? CreateFeatureDataTable("T" + i) : CreateDataTable("T" + i, true));

            Assert.AreEqual(10, ds.Tables.Count);
            Assert.AreEqual(5, fds.Tables.Count);
            for (var i = 0; i < 5; i++)
                Assert.IsTrue(ReferenceEquals(ds.Tables[2*i], fds.Tables[i]));
        }
예제 #11
0
        public JsonResult GetData(float w, float n, float e, float s, int z)
        {
            string format = String.Format("~/App_Data/berlin/{0}", "osmbuildings.shp");
            string path = this.HttpContext.Server.MapPath(format);
            if (!System.IO.File.Exists(path))
                throw new FileNotFoundException("file not found", path);

            Point start = this.GeoToPixel(n, w, z);
            var meta = new { n, w, s, e, x = start.X, y = start.Y, z };

            Envelope bbox = new Envelope();
            bbox.ExpandToInclude(new Coordinate(n, w));
            bbox.ExpandToInclude(new Coordinate(s, e));

            FeatureDataSet ds = new FeatureDataSet();
            using (ShapeFile provider = new ShapeFile(path))
            {
                provider.DoTrueIntersectionQuery = true;
                provider.Open();
                provider.ExecuteIntersectionQuery(bbox, ds);
                provider.Close();
            }

            int zz = MaxZoom - z;
            List<object> data = new List<object>();
            FeatureDataTable table = ds.Tables[0];
            foreach (FeatureDataRow row in table)
            {
                int c = (short)(row["height"]);
                if (c == 0)
                    c = 5; // default value for "null" (zero) heights
                int h = c * ScaleZ >> zz;
                if (h <= 1)
                    h = 1;

                IGeometry geometry = row.Geometry;
                Coordinate[] coords = geometry.Coordinates;
                int total = coords.Length;
                double[] values = new double[total * 2];
                int i = 0;
                foreach (Coordinate curr in coords)
                {
                    Point p = this.GeoToPixel(curr.X, curr.Y, z);
                    values[i++] = p.X - start.X;
                    values[i++] = p.Y - start.Y;
                }
                data.Add(new object[] { h, values });
            }

            return this.Json(new { meta, data }, JsonRequestBehavior.AllowGet);
        }
예제 #12
0
        public void TestSerializationOfDataset()
        {
            var fds = new FeatureDataSet { DataSetName = "Serialization", Namespace = "ns" };
            using (var p = Serialization.ProviderTest.CreateProvider("managedspatialite"))
            {
                p.Open();
                p.ExecuteIntersectionQuery(p.GetExtents(), fds);
                p.Close();
            }

            // add second datatable for multi-layer queries
            var l2 = CreateFeatureDataTable("layer 2");
            l2.ExtendedProperties.Add("dummy", 5);

            fds.Tables.Add(l2);

            // add second datatable and relation
            var l3 = CreateFeatureDataTable("layer 3");

            fds.Tables.Add(l3);
            
            fds.Relations.Add(l2.Columns["oid"], l3.Columns["oid"]);
            
            FeatureDataSet deserializedFds = null;

            Assert.DoesNotThrow(() => deserializedFds = SandD(fds, GetFormatter()));

            Assert.That(deserializedFds.Namespace, Is.EqualTo(fds.Namespace));
            Assert.That(deserializedFds.DataSetName, Is.EqualTo(fds.DataSetName));
            Assert.That(deserializedFds.Locale, Is.EqualTo(fds.Locale));
            Assert.That(deserializedFds.EnforceConstraints, Is.EqualTo(fds.EnforceConstraints));
            Assert.That(deserializedFds.Prefix, Is.EqualTo(fds.Prefix));

            Assert.That(deserializedFds.Tables.Count, Is.EqualTo(fds.Tables.Count));
            var deserializedLayer2Table = deserializedFds.Tables.First(fdt => fdt.TableName == "layer 2");
            var deserializedLayer3Table = deserializedFds.Tables.First(fdt => fdt.TableName == "layer 3");

            Assert.That(deserializedLayer2Table.ExtendedProperties.ContainsKey("dummy"),
                "DataSet.ExtendedProperties not serialized");
            Assert.That(deserializedLayer2Table.ExtendedProperties.ContainsValue("5"));

            Assert.That(deserializedFds.Relations.Count, Is.EqualTo(1), "Relations not serialized");
            Assert.That(deserializedFds.Relations[0].ParentTable, Is.EqualTo(deserializedLayer2Table), "Wrong parent relation");
            Assert.That(deserializedFds.Relations[0].ChildTable, Is.EqualTo(deserializedLayer3Table), "Wrong child relation");

            Assert.That(deserializedLayer2Table.Constraints.Count, Is.EqualTo(1), "Constraints not serialized");
            var cons = deserializedLayer2Table.Constraints[0] as UniqueConstraint;
            Assert.NotNull(cons, "Wrong contraint");
            Assert.IsTrue(cons.IsPrimaryKey, "Constraint was a primary key");
        }
예제 #13
0
        public void TestQuery()
        {
            var p =
                new SharpMap.Data.Providers.WFS("http://geo.vliz.be/geoserver/wfs?service=WFS&request=GetCapabilities",
                    "nsTmp", "elevation_10m", SharpMap.Data.Providers.WFS.WFSVersionEnum.WFS1_1_0);
            p.FeatureTypeInfo.Geometry._GeometryName = "the_geom";
            //p.FeatureTypeInfo.Geometry._GeometryType = 

            var ext = p.GetExtents();
            
            var g = p.GetGeometriesInView(new GeoAPI.Geometries.Envelope(-90, 90, -180, 180));
            Assert.That(g.Count > 0);

            var fds = new FeatureDataSet();
            Assert.DoesNotThrow(() => p.ExecuteIntersectionQuery(p.GetExtents(), fds));
        }
예제 #14
0
        public void TestCreateJoin()
        {
            var fds = new FeatureDataSet {DataSetName = "Join"};
            var ds = (DataSet) fds;

            var t1 = CreateFeatureDataTable("T1");
            fds.Tables.Add(t1);
            Assert.AreEqual(1, ((DataSet)fds).Tables.Count);

            var t2 = CreateDataTable("T2");
            ds.Tables.Add(t2);
            Assert.AreEqual(2, ds.Tables.Count);
            Assert.AreEqual(1, fds.Tables.Count);

            Assert.DoesNotThrow( () => fds.Relations.Add(t1.Columns[0], t2.Columns[0]));

        }
예제 #15
0
        private static void TestProvider(IProvider provider, GpkgContent content)
        {
            int numFeatures = 0;
            Assert.DoesNotThrow(() => numFeatures = provider.GetFeatureCount(),
                    "GetFeatureCount threw exception:\n\tConnection{0}\n\t{1}",
                    provider.ConnectionID, content.TableName);

            var extent = provider.GetExtents();

            Collection<uint> oids = null;
            Assert.DoesNotThrow(() => oids = provider.GetObjectIDsInView(extent), 
                    "GetObjectIDsInView threw exception:\n\tConnection{0}\n\t{1}", 
                    provider.ConnectionID, content.TableName);
            Assert.AreEqual(numFeatures, oids.Count);

            foreach (var oid in oids)
            {
                IGeometry geom = null;
                Assert.DoesNotThrow(() => geom = provider.GetGeometryByID(oid), 
                    "GetGeometryByID threw exception:\n\tConnection{0}\n\t{1}", 
                    provider.ConnectionID, content.TableName);
                FeatureDataRow feat = null;
                Assert.DoesNotThrow(() => feat = provider.GetFeature(oid), 
                    "GetFeature threw exception:\n\tConnection{0}\n\t{1}", 
                    provider.ConnectionID, content.TableName);
                
                Assert.IsTrue(geom.EqualsExact(feat.Geometry));

            }

            Collection<IGeometry> geoms = null;
            Assert.DoesNotThrow(() => geoms = provider.GetGeometriesInView(extent),
                    "GetFeature threw exception:\n\tConnection{0}\n\t{1}",
                    provider.ConnectionID, content.TableName);

            Assert.AreEqual(numFeatures, geoms.Count);
            
            var fds = new FeatureDataSet();
            Assert.DoesNotThrow(() => provider.ExecuteIntersectionQuery(extent, fds),
                    "GetFeature threw exception:\n\tConnection{0}\n\t{1}",
                    provider.ConnectionID, content.TableName);
            Assert.AreEqual(numFeatures, fds.Tables[0].Rows.Count);


        }
        /// <summary>
        /// This method returns a FeatureDataTable containing all the rows from the shapefile that intersect the testGeometry.
        /// The ShapeFile.ExecuteIntersectionQuery method only tests bounding boxes so we use the FilterDelegate property to add a true 
        /// intersection test using NetTopologySuite
        /// </summary>
        /// <param name="pathToShapefile">The path to the shapefile</param>
        /// <param name="testGeometry">The geometry that we want to test against</param>
        /// <returns></returns>
        public FeatureDataTable GetIntersectingFeaturesUsingFilterDelegate(string pathToShapefile, Geometry testGeometry)
        {
            //create a new shapefile provider 
            using (ShapeFile shapefile = new ShapeFile(pathToShapefile))
            {
                //create an nts GeometryFactory
                GeometryFactory geometryFactory = new GeometryFactory();

                //convert the testGeometry into the equivalent NTS geometry
                GeoAPI.Geometries.IGeometry testGeometryAsNtsGeom = GeometryConverter.ToNTSGeometry(testGeometry, geometryFactory);

                Geometry check = GeometryConverter.ToSharpMapGeometry(testGeometryAsNtsGeom);
                if (!check.Equals(testGeometry))
                    throw new ApplicationException("conversion error");

                //set the shapefile providers' FilterDelegate property to a new anonymous method
                //this delegate method will be called for each potential row
                shapefile.FilterDelegate = delegate(FeatureDataRow featureDataRow)
                                               {
                                                   //get the geometry from the featureDataRow
                                                   Geometry rowGeometry = featureDataRow.Geometry;
                                                   //convert it to the equivalent NTS geometry
                                                   GeoAPI.Geometries.IGeometry compareGeometryAsNtsGeometry =
                                                           GeometryConverter.ToNTSGeometry(rowGeometry, geometryFactory);
                                                   //do the test. Note that the testGeometryAsNtsGeometry is available here because it is 
                                                   //declared in the same scope as the anonymous method.
                                                   bool intersects =
                                                       testGeometryAsNtsGeom.Intersects(compareGeometryAsNtsGeometry);
                                                   //return the result
                                                   return intersects;
                                               };


                //create a new FeatureDataSet
                FeatureDataSet featureDataSet = new FeatureDataSet();
                //open the shapefile
                shapefile.Open();
                //call ExecuteIntersectionQuery. The FilterDelegate will be used to limit the result set
                shapefile.ExecuteIntersectionQuery(testGeometry, featureDataSet);
                //close the shapefile
                shapefile.Close();
                //return the populated FeatureDataTable
                return featureDataSet.Tables[0];
            }
        }
        private bool ProcessPoint(IProvider featureProvider, VectorLayer pointLayer, Point p, Dictionary <string, FeatureCountPair> map, Taxon taxon)
        {
            SharpMap.Data.FeatureDataSet ds = new SharpMap.Data.FeatureDataSet();
            featureProvider.ExecuteIntersectionQuery(p.GetBoundingBox(), ds);
            DataTable tbl = ds.Tables[0] as SharpMap.Data.FeatureDataTable;

            var found = false;

            for (int i = 0; i < tbl.Rows.Count; ++i)
            {
                var data = tbl.Rows[i] as FeatureDataRow;

                string featurekey = MakeFeatureKey(data, taxon);
                if (data.Geometry is MultiPolygon)
                {
                    MultiPolygon mp = data.Geometry as MultiPolygon;
                    foreach (SharpMap.Geometries.Polygon polygon in mp)
                    {
                        if (MapControl.PointInsidePolygon(p, polygon))
                        {
                            IncrementFeaturePointCount(map, featurekey, data, taxon);
                            found = true;
                        }
                    }
                }
                else if (data.Geometry is Polygon)
                {
                    var polygon = data.Geometry as Polygon;
                    if (MapControl.PointInsidePolygon(p, polygon))
                    {
                        IncrementFeaturePointCount(map, featurekey, data, taxon);
                        found = true;
                    }
                }
                else
                {
                    // ??? Dunno...
                    IncrementFeaturePointCount(map, featurekey, data, taxon);
                    found = true;
                }
            }

            return(found);
        }
예제 #18
0
        public void TestExecuteIntersectionQueryAgainstEnvelopeEqualsGetOidsInView()
        {
            using (var p = CreateProvider())
            {
                var ext =p.GetExtents();
                var fds = new FeatureDataSet();
                Assert.DoesNotThrow(() => p.ExecuteIntersectionQuery(ext, fds));
                Assert.AreEqual(1, fds.Tables.Count);
                var table = fds.Tables[0];
                Assert.AreEqual(_tableName, table.TableName);
                Assert.AreEqual(4, table.Rows.Count);

                var oids = p.GetObjectIDsInView(ext);

                Assert.AreEqual(table.Rows.Count, oids.Count);
                foreach (FeatureDataRow row in table.Select())
                    Assert.IsTrue(oids.Contains((uint)(int)row[0]));
            }
        }
예제 #19
0
        public void ExecuteIntersectionQueryReturnsExpectedFeatures()
        {
            DataTable source = CreateDataTableSource();
            DataTablePoint provider = new DataTablePoint(source, "oid", "x", "y");

            var query = new Envelope(400, 600, 400, 600);

            FeatureDataTable expected = new FeatureDataTable();
            expected.TableName = "PointSource";

            foreach (DataColumn column in source.Columns)
            {
                expected.Columns.Add(column.ColumnName, column.DataType);
            }

            foreach (DataRowView rowView in source.DefaultView)
            {
                if (query.Contains(new Coordinate((double) rowView["x"], (double) rowView["y"])))
                {
                    expected.ImportRow(rowView.Row);
                }
            }

            FeatureDataSet dataSet = new FeatureDataSet();
            provider.ExecuteIntersectionQuery(query, dataSet);
            Assert.IsNotNull(dataSet);
            Assert.IsNotNull(dataSet.Tables);
            Assert.AreEqual(1, dataSet.Tables.Count);

            FeatureDataTable actual = dataSet.Tables[0];

            Assert.AreEqual(expected.Rows.Count, actual.Rows.Count);

            foreach (DataRowView expectedRowView in expected.DefaultView)
            {
                DataRow[] actualRows = actual.Select("oid = " + expectedRowView["oid"]);
                Assert.AreEqual(1, actualRows.Length);
                Assert.AreEqual(expectedRowView["oid"], actualRows[0]["oid"]);
                Assert.AreEqual(expectedRowView["x"], actualRows[0]["x"]);
                Assert.AreEqual(expectedRowView["y"], actualRows[0]["y"]);
            }
        }
예제 #20
0
        public void TestCreateFromFeatureDataTable(string filePath)
        {
            var fds = new SharpMap.Data.FeatureDataSet();

            filePath = filePath.Replace("\\", new string(System.IO.Path.DirectorySeparatorChar, 1));
            if (!System.IO.File.Exists(filePath))
            {
                throw new IgnoreException($"'{filePath}' not found.");
            }

            FeatureDataTable fdt = null;

            try
            {
                var p = new Ogr(filePath);
                p.SRID = 4326;
                var layer = string.Empty;
                if (!string.IsNullOrEmpty(layer))
                {
                    p.LayerName = layer;
                }

                p.ExecuteIntersectionQuery(p.GetExtents(), fds);
                fdt = fds.Tables[0];
                if (fdt.Rows.Count == 0)
                {
                    throw new Exception("no data in layer");
                }
            }
            catch (Exception ex)
            {
                throw new IgnoreException("Getting data failed", ex);
            }

            Assert.DoesNotThrow(() => Ogr.CreateFromFeatureDataTable(fdt,
                                                                     ((FeatureDataRow)fdt.Rows[0]).Geometry.OgcGeometryType, 4326,
                                                                     "Mapinfo File",
                                                                     filePath));
        }
예제 #21
0
        public JsonResult GetData(string layer, int z, int x, int y)
        {
            if (String.IsNullOrEmpty(layer))
                throw new ArgumentNullException("layer");

            Map map = ShapefileHelper.Spherical();
            IQueryable<VectorLayer> coll = map.Layers
                .AsQueryable()
                .OfType<VectorLayer>()
                .Where(l => l.Enabled && l.IsQueryEnabled)
                .Where(l => String.Equals(l.LayerName, layer));
            VectorLayer query = coll.SingleOrDefault();
            if (query == null)
                throw new ArgumentException("Layer not found: " + layer);

            if (query.SRID != 4326)
                throw new ArgumentException("Only EPSG:4326 supported");

            using (Utf8Grid grid = new Utf8Grid(UtfGridResolution, x, y, z))
            {
                Envelope bbox = this.GetBoundingBoxInLatLngWithMargin(x, y, z);
                FeatureDataSet ds = new FeatureDataSet();
                query.ExecuteIntersectionQuery(bbox, ds);
                IEnumerable<GeoJSON> data = GeoJSONHelper.GetData(ds);

                int i = 1;
                foreach (GeoJSON val in data)
                {
                    IGeometry geom = val.Geometry;
                    IDictionary<string, object> dict = val.Values;
                    grid.FillPolygon(geom, i, dict);
                    i = i + 1;
                }

                Utf8GridResults results = grid.CreateUtfGridJson();
                return this.Json(new { keys = results.Keys, data = results.Data, grid = results.Grid, }, JsonRequestBehavior.AllowGet);
            }
        }
예제 #22
0
        private IEnumerable<GeoJSON> GeoData(Map map, BoundingBox bbox)
        {
            List<GeoJSON> items = new List<GeoJSON>();

            // Only queryable data!
            IQueryable<ICanQueryLayer> collection = map.Layers
                .AsQueryable()
                .OfType<ICanQueryLayer>()
                .Where(l => l.Enabled && l.IsQueryEnabled);
            foreach (ICanQueryLayer layer in collection)
            {
                // Query for data
                FeatureDataSet ds = new FeatureDataSet();
                layer.ExecuteIntersectionQuery(bbox, ds);
                IEnumerable<GeoJSON> data = GeoJSONHelper.GetData(ds);               

                // Reproject geometries if needed
                IMathTransform transform = null;
                if (layer is VectorLayer)
                {
                    ICoordinateTransformation transformation = (layer as VectorLayer).CoordinateTransformation;
                    transform = transformation == null ? null : transformation.MathTransform;
                }
                if (transform != null)
                {
                    data = data.Select(d =>
                    {
                        Geometry converted = GeometryTransform.TransformGeometry(d.Geometry, transform);
                        d.SetGeometry(converted);
                        return d;
                    });
                }

                items.AddRange(data);
            }
            return items;
        }
예제 #23
0
        public void TestCreateFromFeatureDataTable(string filePath, int srid, string driver, string connection)
        {
            var fds = new SharpMap.Data.FeatureDataSet();
            if (!Path.IsPathRooted(filePath))
                filePath = TestUtility.GetPathToTestFile(filePath);

            if (!System.IO.File.Exists(filePath))
                throw new IgnoreException($"'{filePath}' not found.");

            FeatureDataTable fdt = null;
            try
            {
                var p = new OgrProvider(filePath);
                if (p.SRID == 0)
                    p.SRID = srid;
                else
                    srid = p.SRID;

                string layer = string.Empty;
                if (!string.IsNullOrEmpty(layer)) p.LayerName = layer;

                p.ExecuteIntersectionQuery(p.GetExtents(), fds);
                fdt = fds.Tables[0];
                if (fdt.Rows.Count == 0)
                    throw new Exception("no data in layer");
                p.Dispose();
            }
            catch (Exception ex)
            {
                throw new IgnoreException("Getting data failed", ex);
            }

            Assert.DoesNotThrow(() => OgrProvider.CreateFromFeatureDataTable(fdt, 
                ((FeatureDataRow)fdt.Rows[0]).Geometry.OgcGeometryType, srid, 
                driver, connection));
        }
예제 #24
0
 void ICanQueryLayer.ExecuteIntersectionQuery(Envelope box, FeatureDataSet ds)
 {
     if (!((ICanQueryLayer)this).IsQueryEnabled)
         return;
     ((ICanQueryLayer)_baseLayer).ExecuteIntersectionQuery(box, ds);
 }
예제 #25
0
        public void RenderLayer(IVectorLayer layer, Map map, System.Drawing.Graphics g)
        {
            if (map.Center == null)
            {
                throw (new ApplicationException("Cannot render map. View center not specified"));
            }

            g.SmoothingMode = layer.SmoothingMode;
            SharpMap.Geometries.BoundingBox envelope = map.Envelope; //View to render
            if (layer.CoordinateTransformation != null)
            {
                envelope = GeometryTransform.TransformBox(
                    envelope,
                    layer.CoordinateTransformation.MathTransform.Inverse());
            }

            //List<SharpMap.Geometries.Geometry> features = this.DataSource.GetGeometriesInView(map.Envelope);

            if (layer.DataSource == null)
            {
                throw (new ApplicationException("DataSource property not set on layer '" + layer.LayerName + "'"));
            }

            //If thematics is enabled, we use a slighty different rendering approach
            if (layer.Theme != null)
            {
                SharpMap.Data.FeatureDataSet ds = new SharpMap.Data.FeatureDataSet();
                layer.DataSource.Open();
                layer.DataSource.ExecuteIntersectionQuery(envelope, ds);
                layer.DataSource.Close();

                FeatureDataTable features = (FeatureDataTable)ds.Tables[0];

                if (layer.CoordinateTransformation != null)
                {
                    for (int i = 0; i < features.Count; i++)
                    {
                        features[i].Geometry = GeometryTransform.TransformGeometry(features[i].Geometry, layer.CoordinateTransformation.MathTransform);
                    }
                }

                //Linestring outlines is drawn by drawing the layer once with a thicker line
                //before drawing the "inline" on top.
                if (layer.Style.EnableOutline)
                {
                    //foreach (SharpMap.Geometries.Geometry feature in features)
                    for (int i = 0; i < features.Count; i++)
                    {
                        SharpMap.Data.FeatureDataRow feature = features[i];
                        //Draw background of all line-outlines first
                        if (feature.Geometry is SharpMap.Geometries.LineString)
                        {
                            IVectorStyle outlinestyle1 = layer.Theme.GetStyle(feature);
                            if (outlinestyle1.Enabled && outlinestyle1.EnableOutline)
                            {
                                SharpMap.Rendering.VectorRenderer.DrawLineString(g, feature.Geometry as LineString, outlinestyle1.Outline, map);
                            }
                        }
                        else if (feature.Geometry is SharpMap.Geometries.MultiLineString)
                        {
                            IVectorStyle outlinestyle2 = layer.Theme.GetStyle(feature);
                            if (outlinestyle2.Enabled && outlinestyle2.EnableOutline)
                            {
                                SharpMap.Rendering.VectorRenderer.DrawMultiLineString(g, feature.Geometry as MultiLineString, outlinestyle2.Outline, map);
                            }
                        }
                    }
                }

                for (int i = 0; i < features.Count; i++)
                {
                    SharpMap.Data.FeatureDataRow feature = features[i];
                    IVectorStyle style = layer.Theme.GetStyle(feature);
                    RenderGeometry(g, map, layer.ClippingEnabled, feature.Geometry, style);
                }
            }
            else
            {
                layer.DataSource.Open();

                Collection <Geometry> geoms = layer.DataSource.GetGeometriesInView(envelope);
                layer.DataSource.Close();

                if (layer.CoordinateTransformation != null)
                {
                    for (int i = 0; i < geoms.Count; i++)
                    {
                        geoms[i] = GeometryTransform.TransformGeometry(geoms[i], layer.CoordinateTransformation.MathTransform);
                    }
                }

                //Linestring outlines is drawn by drawing the layer once with a thicker line
                //before drawing the "inline" on top.
                if (layer.Style.EnableOutline)
                {
                    foreach (SharpMap.Geometries.Geometry geom in geoms)
                    {
                        if (geom != null)
                        {
                            //Draw background of all line-outlines first
                            switch (geom.GetType().FullName)
                            {
                            case "SharpMap.Geometries.LineString":
                                SharpMap.Rendering.VectorRenderer.DrawLineString(g, geom as LineString, layer.Style.Outline, map);
                                break;

                            case "SharpMap.Geometries.MultiLineString":
                                SharpMap.Rendering.VectorRenderer.DrawMultiLineString(g, geom as MultiLineString, layer.Style.Outline, map);
                                break;

                            default:
                                break;
                            }
                        }
                    }
                }

                for (int i = 0; i < geoms.Count; i++)
                {
                    if (geoms[i] != null)
                    {
                        RenderGeometry(g, map, layer.ClippingEnabled, geoms[i], layer.Style);
                    }
                }
            }


            //base.Render(g, map);
        }
예제 #26
0
 public void ExecuteIntersectionQuery(SharpMap.Geometries.Geometry geom, SharpMap.Data.FeatureDataSet ds)
 {
     ExecuteIntersectionQuery(geom.GetBoundingBox(), ds);
 }
예제 #27
0
        /// <summary>
        /// Returns the data associated with all the geometries that are intersected by 'geom'
        /// </summary>
        /// <param name="geometry">Geometry to intersect with</param>
        /// <param name="ds">FeatureDataSet to fill data into</param>
        public void ExecuteIntersectionQuery(Geometry geometry, FeatureDataSet ds)
        {
            if (CoordinateTransformation != null)
            {
#if !DotSpatialProjections
                CoordinateTransformation.MathTransform.Invert();
                geometry = GeometryTransform.TransformGeometry(geometry, CoordinateTransformation.MathTransform);
                CoordinateTransformation.MathTransform.Invert();
#else
                geometry = GeometryTransform.TransformGeometry(geometry, CoordinateTransformation.Target, CoordinateTransformation.Source);
#endif
            }

            lock (_dataSource)
            {
                _dataSource.Open();
                _dataSource.ExecuteIntersectionQuery(geometry, ds);
                _dataSource.Close();
            }
        }
예제 #28
0
        protected void RenderInternal(Graphics g, Map map, BoundingBox envelope, ITheme theme)
        {
            FeatureDataSet ds = new FeatureDataSet();
            lock (_dataSource)
            {
                DataSource.Open();
                DataSource.ExecuteIntersectionQuery(envelope, ds);
                DataSource.Close();
            }

            foreach (FeatureDataTable features in ds.Tables)
            {


                if (CoordinateTransformation != null)
                    for (int i = 0; i < features.Count; i++)
#if !DotSpatialProjections
                    features[i].Geometry = GeometryTransform.TransformGeometry(features[i].Geometry,
                                                                                CoordinateTransformation.
                                                                                    MathTransform);
#else
                    features[i].Geometry = GeometryTransform.TransformGeometry(features[i].Geometry,
                                                                                CoordinateTransformation.Source,
                                                                                CoordinateTransformation.Target);

#endif

                //Linestring outlines is drawn by drawing the layer once with a thicker line
                //before drawing the "inline" on top.
                if (Style.EnableOutline)
                {
                    //foreach (SharpMap.Geometries.Geometry feature in features)
                    for (int i = 0; i < features.Count; i++)
                    {
                        FeatureDataRow feature = features[i];
                        VectorStyle outlineStyle = Theme.GetStyle(feature) as VectorStyle;
                        if (outlineStyle == null) continue;
                        if (!(outlineStyle.Enabled && outlineStyle.EnableOutline)) continue;
                        if (!(outlineStyle.MinVisible <= map.Zoom && map.Zoom <= outlineStyle.MaxVisible)) continue;

                        //Draw background of all line-outlines first
                        if (feature.Geometry is LineString)
                        {
                            VectorRenderer.DrawLineString(g, feature.Geometry as LineString, outlineStyle.Outline,
                                                                map, outlineStyle.LineOffset);
                        }
                        else if (feature.Geometry is MultiLineString)
                        {
                            VectorRenderer.DrawMultiLineString(g, feature.Geometry as MultiLineString,
                                                                outlineStyle.Outline, map, outlineStyle.LineOffset);
                        }
                    }
                }

                for (int i = 0; i < features.Count; i++)
                {
                    FeatureDataRow feature = features[i];
                    VectorStyle style = Theme.GetStyle(feature) as VectorStyle;
                    if (style == null) continue;
                    if (!style.Enabled) continue;
                    if (!(style.MinVisible <= map.Zoom && map.Zoom <= style.MaxVisible)) continue;
                    RenderGeometry(g, map, feature.Geometry, style);
                }
            }
        }
예제 #29
0
        /// <summary>
        /// Renders the layer to a graphics object
        /// </summary>
        /// <param name="g">Graphics object reference</param>
        /// <param name="map">Map which is rendered</param>
        public override void Render(Graphics g, Map map)
        {
            if (map.Center == null)
                throw (new ApplicationException("Cannot render map. View center not specified"));

            g.SmoothingMode = SmoothingMode;
            BoundingBox envelope = map.Envelope; //View to render
            if (CoordinateTransformation != null)
            {
            #if !DotSpatialProjections
                CoordinateTransformation.MathTransform.Invert();
                envelope = GeometryTransform.TransformBox(envelope, CoordinateTransformation.MathTransform);
                CoordinateTransformation.MathTransform.Invert();
            #else
                envelope = GeometryTransform.TransformBox(envelope, CoordinateTransformation.Target, CoordinateTransformation.Source);
            #endif
            }

            //List<SharpMap.Geometries.Geometry> features = this.DataSource.GetGeometriesInView(map.Envelope);

            if (DataSource == null)
                throw (new ApplicationException("DataSource property not set on layer '" + LayerName + "'"));

            //If thematics is enabled, we use a slighty different rendering approach
            if (Theme != null)
            {
                FeatureDataSet ds = new FeatureDataSet();
                DataSource.Open();
                DataSource.ExecuteIntersectionQuery(envelope, ds);
                DataSource.Close();

                FeatureDataTable features = ds.Tables[0];

                if (CoordinateTransformation != null)
                    for (int i = 0; i < features.Count; i++)
            #if !DotSpatialProjections
                        features[i].Geometry = GeometryTransform.TransformGeometry(features[i].Geometry,
                                                                                   CoordinateTransformation.
                                                                                       MathTransform);
            #else
                        features[i].Geometry = GeometryTransform.TransformGeometry(features[i].Geometry,
                                                                                   CoordinateTransformation.Source,
                                                                                   CoordinateTransformation.Target);

            #endif

                //Linestring outlines is drawn by drawing the layer once with a thicker line
                //before drawing the "inline" on top.
                if (Style.EnableOutline)
                {
                    //foreach (SharpMap.Geometries.Geometry feature in features)
                    for (int i = 0; i < features.Count; i++)
                    {
                        FeatureDataRow feature = features[i];
                        VectorStyle outlineStyle = Theme.GetStyle(feature) as VectorStyle;
                        if (outlineStyle == null) continue;
                        if (!(outlineStyle.Enabled && outlineStyle.EnableOutline)) continue;
                        if (!(outlineStyle.MinVisible <= map.Zoom && map.Zoom <= outlineStyle.MaxVisible)) continue;

                        //Draw background of all line-outlines first
                        if (feature.Geometry is LineString)
                        {
                            VectorRenderer.DrawLineString(g, feature.Geometry as LineString, outlineStyle.Outline,
                                                              map);
                        }
                        else if (feature.Geometry is MultiLineString)
                        {
                                VectorRenderer.DrawMultiLineString(g, feature.Geometry as MultiLineString,
                                                                   outlineStyle.Outline, map);
                        }
                    }
                }

                for (int i = 0; i < features.Count; i++)
                {
                    FeatureDataRow feature = features[i];
                    VectorStyle style = Theme.GetStyle(feature) as VectorStyle;
                    if (style == null) continue;
                    if (!style.Enabled) continue;
                    if (!(style.MinVisible <= map.Zoom && map.Zoom <= style.MaxVisible)) continue;
                    RenderGeometry(g, map, feature.Geometry, style);
                }
            }
            else
            {
                //if style is not enabled, we don't need to render anything
                if (!Style.Enabled) return;

                DataSource.Open();

                Collection<Geometry> geoms = DataSource.GetGeometriesInView(envelope);
                DataSource.Close();

                if (CoordinateTransformation != null)
                    for (int i = 0; i < geoms.Count; i++)
            #if !DotSpatialProjections
                        geoms[i] = GeometryTransform.TransformGeometry(geoms[i], CoordinateTransformation.MathTransform);
            #else
                        geoms[i] = GeometryTransform.TransformGeometry(geoms[i], CoordinateTransformation.Source, CoordinateTransformation.Target);
            #endif

                //Linestring outlines is drawn by drawing the layer once with a thicker line
                //before drawing the "inline" on top.
                if (Style.EnableOutline)
                {
                    foreach (Geometry geom in geoms)
                    {
                        if (geom != null)
                        {
                            //Draw background of all line-outlines first
                            if (geom  is LineString)
                                VectorRenderer.DrawLineString(g, geom as LineString, Style.Outline, map);
                            else if (geom is MultiLineString)
                                VectorRenderer.DrawMultiLineString(g, geom as MultiLineString, Style.Outline, map);
                        }
                    }
                }

                for (int i = 0; i < geoms.Count; i++)
                {
                    if (geoms[i] != null)
                        RenderGeometry(g, map, geoms[i], Style);
                }
            }

            base.Render(g, map);
        }
예제 #30
0
 private void mapImage_MapQueriedDataSet(SharpMap.Data.FeatureDataSet data)
 {
     dataGridView1.DataSource = data as System.Data.DataSet;
 }
예제 #31
0
        private void ExecuteIntersectionQuery(Coordinate pt, FeatureDataSet ds)
        {

            if (CoordinateTransformation != null)
            {
#if !DotSpatialProjections
                if (ReverseCoordinateTransformation != null)
                {
                    pt = GeometryTransform.TransformCoordinate(pt, ReverseCoordinateTransformation.MathTransform);
                }
                else
                {
                    CoordinateTransformation.MathTransform.Invert();
                    pt = GeometryTransform.TransformCoordinate(pt, CoordinateTransformation.MathTransform);
                    CoordinateTransformation.MathTransform.Invert();
                }
#else
                pt = GeometryTransform.TransformCoordinate(pt, 
                    CoordinateTransformation.Target, 
                    CoordinateTransformation.Source);
#endif
            }
            
            //Setup resulting Table
            var dt = new FeatureDataTable();
            dt.Columns.Add("Ordinate X", typeof(Double));
            dt.Columns.Add("Ordinate Y", typeof(Double));
            for (int i = 1; i <= Bands; i++)
                dt.Columns.Add(string.Format("Value Band {0}", i), typeof(Double));

            //Get location on raster
            Double[] buffer = new double[1];
            Int32[] bandMap = new int[Bands];
            for (int i = 1; i <= Bands; i++) bandMap[i - 1] = i;

            var geoTransform = new GeoTransform(_gdalDataset);
            var imgPt = geoTransform.GroundToImage(pt);
            Int32 x = Convert.ToInt32(imgPt.X);
            Int32 y = Convert.ToInt32(imgPt.Y);

            //Test if raster ordinates are within bounds
            if (x < 0) return;
            if (y < 0) return;
            if (x >= _imageSize.Width) return;
            if (y >= _imageSize.Height) return;

            //Create new row, add ordinates and location geometry
            FeatureDataRow dr = dt.NewRow();
            dr.Geometry = Factory.CreatePoint(pt);
            dr[0] = pt.X;
            dr[1] = pt.Y;

            //Add data from raster
            for (int i = 1; i <= Bands; i++)
            {
                Band band = _gdalDataset.GetRasterBand(i);
                //DataType dtype = band.DataType;
                CPLErr res = band.ReadRaster(x, y, 1, 1, buffer, 1, 1, 0, 0);
                if (res == CPLErr.CE_None)
                {
                    dr[1 + i] = buffer[0];
                }
                else
                {
                    dr[1 + i] = Double.NaN;
                }
            }
            //Add new row to table
            dt.Rows.Add(dr);

            //Add table to dataset
            ds.Tables.Add(dt);
        }
 public FeatureDataViewManager(FeatureDataSet dataSet, Boolean locked)
 {
     throw new NotImplementedException();
 }
예제 #33
0
파일: MsSql.cs 프로젝트: lishxi/_SharpMap
		/// <summary>
		/// Returns the features that intersects with 'geom' [NOT IMPLEMENTED]
		/// </summary>
		/// <param name="geom"></param>
		/// <param name="ds">FeatureDataSet to fill data into</param>
		public void ExecuteIntersectionQuery(SharpMap.Geometries.Geometry geom, FeatureDataSet ds)
		{
			throw new NotImplementedException();
		}
예제 #34
0
 void ICanQueryLayer.ExecuteIntersectionQuery(IGeometry geometry, FeatureDataSet ds)
 {
     if (!((ICanQueryLayer)this).IsQueryEnabled)
         return;
     ((ICanQueryLayer)_baseLayer).ExecuteIntersectionQuery(geometry, ds);
 }
예제 #35
0
        /// <summary>
        /// Copies the structure of the FeatureDataSet,
        /// including all FeatureDataTable schemas, relations,
        /// and constraints. Does not copy any data.
        /// </summary>
        /// <returns></returns>
        public new FeatureDataSet Clone()
        {
            FeatureDataSet copy = base.Clone() as FeatureDataSet;

            return(copy);
        }
예제 #36
0
 /// <summary>
 /// Returns the data associated with all the geometries that are intersected by 'geom'
 /// </summary>
 /// <param name="geometry">Geometry to intersect with</param>
 /// <param name="ds">FeatureDataSet to fill data into</param>
 public void ExecuteIntersectionQuery(IGeometry geometry, FeatureDataSet ds)
 {
     foreach (Layer layer in Layers)
     {
         if (layer is ICanQueryLayer)
         {
             FeatureDataSet dsTmp = new FeatureDataSet();
             ((ICanQueryLayer)layer).ExecuteIntersectionQuery(geometry, dsTmp);
             ds.Tables.AddRange(dsTmp.Tables.ToArray());
         }
     }
 }
예제 #37
0
        /// <summary>
        /// Copies the structure of the FeatureDataSet, including all FeatureDataTable schemas, relations, and constraints. Does not copy any data.
        /// </summary>
        /// <returns></returns>
        public new FeatureDataSet Clone()
        {
            FeatureDataSet cln = ((FeatureDataSet)(base.Clone()));

            return(cln);
        }
예제 #38
0
        public override void Render(IGraphics g, Map map)
        {
            try
            {
                _shapeFile.Open();
                var ds = new FeatureDataSet();
                _shapeFile.ExecuteIntersectionQuery(map.Envelope, ds);

                var dt = ds.Tables[0];
                foreach (FeatureDataRow fdr in dt.Rows)
                {
                    if (fdr.Geometry.EnvelopeInternal.Intersects(map.Envelope))
                    {
                        var file = fdr[_fieldName] as string;
                        if (!Path.IsPathRooted(file))
                            file = Path.Combine(Path.GetDirectoryName(_fileName), file);

                        if (_logger.IsDebugEnabled)
                            _logger.Debug("Drawing " + file);

                        OpenDataset(file);

                        base.Render(g, map);
                        _envelope = null;
                        if (_gdalDataset != null)
                        {
                            _gdalDataset.Dispose();
                            _gdalDataset = null;
                        }
                    }
                }

            }
            catch (Exception)
            {
                
                _shapeFile.Close();
            }
        }
예제 #39
0
        private static IEnumerable<GeoJSON> QueryData(BoundingBox bbox, ICanQueryLayer layer)
        {
            if (layer == null)
                throw new ArgumentNullException("layer");

            // Query for data
            FeatureDataSet ds = new FeatureDataSet();
            layer.ExecuteIntersectionQuery(bbox, ds);
            IEnumerable<GeoJSON> data = GeoJSONHelper.GetData(ds);

            // Reproject geometries if needed
            IMathTransform transform = null;
            if (layer is VectorLayer)
            {
                ICoordinateTransformation transformation = (layer as VectorLayer).CoordinateTransformation;
                transform = transformation == null ? null : transformation.MathTransform;
            }
            if (transform != null)
            {
                GeometryFactory gf = new GeometryFactory();
                data = data.Select(d =>
                    {
                        Geometry converted = GeometryTransform.TransformGeometry(d.Geometry, transform, gf);
                        d.SetGeometry(converted);
                        return d;
                    });
            }
            return data;
        }
예제 #40
0
 /// <summary>
 /// Returns the data associated with the centroid of the bounding box.
 /// </summary>
 /// <param name="box">Envelope to intersect with</param>
 /// <param name="ds">FeatureDataSet to fill data into</param>
 public void ExecuteIntersectionQuery(Envelope box, FeatureDataSet ds)
 {
     var pt = new Coordinate(box.MinX + 0.5 * box.Width,
                           box.MaxY - 0.5 * box.Height);
     ExecuteIntersectionQuery(pt, ds);
 }
예제 #41
0
        private FeatureDataRow FindGeoNearPoint(object/*Coordinate*/ coord)
        {
            var mapPosition = (Coordinate) coord;
            var env = new Envelope(mapPosition);
            env.ExpandBy(5 * Map.PixelWidth);
            var g = NetTopologySuite.Geometries.Prepared.PreparedGeometryFactory.Prepare(Map.Factory.ToGeometry(env));

            var fdrs = new List<Tuple<double, FeatureDataRow>>();
            var fds = new FeatureDataSet();
            var tableCount = 0;

            var layersToQuery = GetLayersToQuery(Map);

            for (var i = layersToQuery.Count - 1; i >= 0; i--)
            {
                if (_cts.Token.IsCancellationRequested)
                {
                    Logger.Debug("Cancellation requested");
                    return null;
                }

                var l = layersToQuery[i];
                if (l.Enabled && l.MinVisible < Map.Zoom &&
                    l.MaxVisible >= Map.Zoom)
                {
                    if (!l.IsQueryEnabled) continue;
                    l.ExecuteIntersectionQuery(env, fds);
                    for (var j = tableCount; j < fds.Tables.Count; j++)
                    {
                        var fdt = fds.Tables[j];
                        for (var k = 0; k < fdt.Rows.Count; k++)
                        {
                            var fdr = (FeatureDataRow) fdt.Rows[k];
                            if (g.Intersects(fdr.Geometry))
                            {
                                var distance = g.Geometry.InteriorPoint.Distance(fdr.Geometry);
                                if (fdr.Geometry.Dimension == Dimension.Surface)
                                    distance += 5* Map.PixelWidth;
                                fdrs.Add(Tuple.Create(distance, fdr));
                            }
                        }
                    }
                    tableCount = fds.Tables.Count;
                }

            }
            if (fdrs.Count > 0)
            {
                fdrs.Sort((t1, t2) => t1.Item1.CompareTo(t2.Item1));
                return fdrs[0].Item2;
            }
            return null;
        }
예제 #42
0
 /// <summary>
 /// Returns the data associated with all the geometries that are intersected by 'geom'
 /// </summary>
 /// <param name="geometry">Geometry to intersect with</param>
 /// <param name="ds">FeatureDataSet to fill data into</param>
 public void ExecuteIntersectionQuery(Geometry geometry, FeatureDataSet ds)
 {
     ExecuteIntersectionQuery(geometry.EnvelopeInternal, ds);
 }
예제 #43
0
        /// <summary>
        /// Returns the data associated with all the geometries that are intersected by 'geom'
        /// </summary>
        /// <param name="box">Geometry to intersect with</param>
        /// <param name="ds">FeatureDataSet to fill data into</param>
        public void ExecuteIntersectionQuery(BoundingBox box, FeatureDataSet ds)
        {
            if (CoordinateTransformation != null)
            {
            #if !DotSpatialProjections
                CoordinateTransformation.MathTransform.Invert();
                box = GeometryTransform.TransformBox(box, CoordinateTransformation.MathTransform);
                CoordinateTransformation.MathTransform.Invert();
            #else
                box = GeometryTransform.TransformBox(box, CoordinateTransformation.Target, CoordinateTransformation.Source);
            #endif
            }

            _dataSource.Open();
            _dataSource.ExecuteIntersectionQuery(box, ds);
            _dataSource.Close();
        }