Esempio n. 1
0
        public VehicleList(IEnumerable <VehicleModel> vehicles)
        {
            list = vehicles;

            //geo = new GeoVehicles(list);
            var model = new FeatureCollection();
            int count = 1;

            foreach (var item in list)
            {
                item.index = count;
                var geom  = new Point(new GeographicPosition(item.Latitude, item.Longitude));
                var props = new Dictionary <string, object>
                {
                    { "Make", item.Make },
                    { "Model", item.Model },
                    { "Year", item.Year },
                    { "Name", item.Name },
                    { "Address", item.Address },
                    { "City", item.City },
                    { "State", item.State },
                    { "Zip", item.Zip },
                    { "Phone", item.Phone },
                    { "Index", count },
                    { "Latitude", item.Latitude },
                    { "Longitude", item.Longitude }
                };
                var feature = new GeoJSON.Net.Feature.Feature(geom, props, count.ToString());
                model.Features.Add(feature);
                gs = new HtmlString(JsonConvert.SerializeObject(model));
                count++;
            }
        }
Esempio n. 2
0
        public string GetCurrentValues()
        {
            var model = new FeatureCollection();

            foreach (Claim c in claimHash.Values)
            {
                var geom  = new Point(c.location);
                var props = new Dictionary <string, object>
                {
                    { "cod", c.code },
                    { "dat", c.date },
                    { "qua", c.quality },
                    { "typ", c.type },
                    { "des", c.description },
                    { "sup", c.supply },
                    { "con", c.consumption },
                    { "cli", c.client }
                };
                var feature = new GeoJSON.Net.Feature.Feature(geom, props);
                model.Features.Add(feature);
            }
            var claimjson = JsonConvert.SerializeObject(model);

            return(claimjson);
        }
Esempio n. 3
0
 /// <summary>
 /// Initializes a new instance of the <see cref="LcboStore"/> class.
 /// </summary>
 public LcboStore()
 {
     GeoJSON = new Feature(new Point(new Position()));
     Id = 0;
     Name = String.Empty;
     Volumes = new AlcoholVolumes();
 }
Esempio n. 4
0
        public async Task <string> GetAllFarmersProfiles()
        {
            var geojsonndata = new FeatureCollection()
            {
                CRS = new GeoJSON.Net.CoordinateReferenceSystem.NamedCRS("urn:ogc:def:crs:OGC:1.3:CRS84")
            };

            using (var _context = new NARIGPCoreContext())
            {
                var farmers        = _context.Transactions.ToList();
                var farmActivities = _context.Txns.ToList();
                var query          = farmers.GroupJoin(farmActivities,
                                                       fp => fp.Id,
                                                       fa => fa.TransactionsId,
                                                       (fp, results) => new TransactionViewModel(
                                                           fp.Id,
                                                           fp.Name,
                                                           fp.Phone,
                                                           fp.Gender,
                                                           fp.AgeGroup,
                                                           fp.SubCounty,
                                                           fp.Ward,
                                                           fp.Vcgroup,
                                                           fp.C302,
                                                           fp.C11501,
                                                           fp.C11301,

                                                           fp.Geometry,
                                                           results)).ToList();

                query.ForEach(sa =>
                {
                    var transModel = new TransModel()
                    {
                        Id        = sa.Id,
                        Name      = sa.Name,
                        AgeGroup  = sa.AgeGroup,
                        Phone     = sa.Phone,
                        Gender    = sa.Gender,
                        Vcgroup   = sa.Vcgroup,
                        Ward      = sa.Ward,
                        SubCounty = sa.SubCounty,
                        C302      = sa.C302,
                        C11501    = sa.C11501,
                        C11301    = sa.C11301,
                        Long      = sa.Geometry.Coordinate.X,
                        Lat       = sa.Geometry.Coordinate.Y,
                        Txns      = sa.Results.ToList()
                    };
                    double X    = sa.Geometry.Coordinate.X;
                    double Y    = sa.Geometry.Coordinate.Y;
                    var point   = new Point(new Position(Y, X));
                    var feature = new GeoJSON.Net.Feature.Feature(point, transModel);
                    geojsonndata.Features.Add(feature);
                });
            }
            var actualJson = JsonConvert.SerializeObject(geojsonndata);

            return(actualJson);
        }
Esempio n. 5
0
 //GET /api/routing?from=31.8239,35.0375&to=31.8213,35.0965&type=f
 public async Task<IHttpActionResult> GetRouting(string from, string to, string type)
 {
     LineString lineString;
     var profile = ConvertProfile(type);
     if (profile == ProfileType.None)
     {
         var pointFrom = GetGeographicPosition(from);
         var pointTo = GetGeographicPosition(to);
         if (ModelState.IsValid == false)
         {
             return BadRequest(ModelState);
         }
         lineString = new LineString(new[] { pointFrom, pointTo });
     }
     else
     {
         lineString = await _routingGateway.GetRouting(new RoutingGatewayRequest
         {
             From = from,
             To = to,
             Profile = profile,
         });
     }
     var feature = new Feature(lineString, new FeatureProperties { Name = "Routing from " + from + " to " + to + " profile type: " + profile.ToString(), Creator = "IsraelHiking" });
     return Ok(new FeatureCollection(new List<Feature>() { feature }));
 }
        public override async Task Process(IPipeContext context)
        {
            var dataContext = context as GeoJsonContext;

            if (dataContext == null)
            {
                throw new NotSupportedException("The pipeline context must be of type DataPipelineContext");
            }

            // Save time and space only read the first line to determine if this is a Feature or a //
            // Feature collection //
            string capture = "";

            using (var reader = new StringReader(dataContext.OriginalData))
            {
                bool finishedSearch = false;
                while (!finishedSearch)
                {
                    var character = reader.ReadLine();
                    if (capture.IndexOf(',') < 0)
                    {
                        capture += character;
                    }
                    else
                    {
                        finishedSearch = true;
                    }
                }

                if (capture.Contains("FeatureCollection"))
                {
                    dataContext.Features = JsonConvert.DeserializeObject <GeoJSON.Net.Feature.FeatureCollection>(dataContext.OriginalData);
                }
                else if (capture.Contains("Feature"))
                {
                    var feature = JsonConvert.DeserializeObject <GeoJSON.Net.Feature.Feature>(dataContext.OriginalData);
                    dataContext.Features = new GeoJSON.Net.Feature.FeatureCollection(new List <GeoJSON.Net.Feature.Feature> {
                        feature
                    });
                }
                else if (capture.Contains("MultiLineString"))
                {
                    var multiline = JsonConvert.DeserializeObject <GeoJSON.Net.Geometry.MultiLineString>(dataContext.OriginalData);
                    var feature   = new GeoJSON.Net.Feature.Feature(multiline);
                    dataContext.Features = new GeoJSON.Net.Feature.FeatureCollection(new List <GeoJSON.Net.Feature.Feature> {
                        feature
                    });
                }
                else
                {
                    throw new NotSupportedException("Type of GeoJson data could not be determined.");
                }
            }

            while (this.HasNextPipe)
            {
                await this.NextPipe.Process(context);
            }
        }
Esempio n. 7
0
        /// <summary>
        /// Prints GEOJson dump of Sites
        /// </summary>
        /// <param name="requiredProperties">list of properties to include (if not found in siteproperties an empty string will be inserted)</param>
        public void Execute(string[] requiredProperties, string siteType)
        {
            Console.Write("Content-Type:  application/json\n\n");

              var features = new List<Feature>();
              FeatureCollection fc = new FeatureCollection(features);
              var filter = "";
            if( siteType != "")
                filter = "type = '"+siteType+"'";
              var sites = db.GetSiteCatalog(filter:filter);

             var siteProp = new TimeSeriesDatabaseDataSet.sitepropertiesDataTable(db);

             int id = 0;
              foreach (var s in sites)
              {
              try
              {
                  var pos = new GeographicPosition(s.latitude, s.longitude);
                  var pt = new GeoJSON.Net.Geometry.Point(pos);

                  var props = siteProp.GetDictionary(s.siteid);

                  for (int i = 0; i < requiredProperties.Length; i++)
                  {
                      if (requiredProperties[i].Trim() == "")
                          continue;
                      if (!props.ContainsKey(requiredProperties[i]))
                          props.Add(requiredProperties[i], "");
                  }

                  props.Add("siteid", s.siteid);
                  props.Add("title", s.description);
                  props.Add("state", s.state);
                  props.Add("type", s.type);

                  props.Add("region", s.responsibility.Trim());
                  props.Add("install", s.install);
                  id++;
                  var feature = new Feature(pt, props, id.ToString());

                  fc.Features.Add(feature);
              }
              catch (Exception error)
              {
                  Console.WriteLine("Error at site:"+s);
                  Console.WriteLine(error.Message);
              }
              }

            var settings = new JsonSerializerSettings();
            settings.NullValueHandling = NullValueHandling.Ignore;
              var json = Newtonsoft.Json.JsonConvert.SerializeObject(fc,
              Newtonsoft.Json.Formatting.Indented,settings);

              Console.WriteLine(json);
             //File.WriteAllText(@"c:\temp\test.json", json);
        }
Esempio n. 8
0
        public FeatureCollection GetSalesData()
        {
            var model = new FeatureCollection()
            {
                CRS = new GeoJSON.Net.CoordinateReferenceSystem.NamedCRS("urn:ogc:def:crs:OGC::CRS84")
            };
            var sales = _context.So011t
                        .FromSql("EXECUTE sp_SalesData")
                        .ToList();

            sales.ForEach(x =>
            {
                SO01TViewModel sale    = new SO01TViewModel();
                sale.Client            = x.Client;
                sale.AcMgr             = x.AcMgr;
                sale.AddlDesc          = x.AddlDesc;
                sale.Comments          = x.Comments;
                sale.Country           = x.Country;
                sale.Createdby         = x.Createdby;
                sale.Createddate       = x.Createddate;
                sale.Currency          = x.Currency;
                sale.Description       = x.Description;
                sale.Dnote             = x.Dnote;
                sale.Invoice           = x.Invoice;
                sale.Invoiced          = x.Invoiced;
                sale.Modby             = x.Modby;
                sale.Moddate           = x.Moddate;
                sale.Orderby           = x.Orderby;
                sale.Ordercode         = x.Ordercode;
                sale.Orderid           = x.Orderid;
                sale.Orderdate         = x.Orderdate;
                sale.OrderItem         = x.OrderItem;
                sale.OrderType         = x.OrderItem;
                sale.OrderType         = x.OrderType;
                sale.Ordid             = x.Ordid;
                sale.Ponum             = x.Ponum;
                sale.Price             = x.Price;
                sale.ProductCateg      = x.ProductCateg;
                sale.ProductGroup      = x.ProductGroup;
                sale.ProductId         = x.ProductId;
                sale.ProductName       = x.ProductName;
                sale.Quantity          = x.Quantity;
                sale.Quotedate         = x.Quotedate;
                sale.QuoteNo           = x.QuoteNo;
                sale.SoldBy            = x.SoldBy;
                sale.Supplierproductid = x.Supplierproductid;
                sale.Tax          = x.Tax;
                sale.Type         = x.Type;
                sale.Version      = x.Version;
                sale.Xrate        = x.Xrate;
                var actualPolygon = JsonConvert.DeserializeObject <Polygon>(x.Wkt);
                var feature       = new GeoJSON.Net.Feature.Feature(actualPolygon, sale);

                model.Features.Add(feature);
            });
            return(model);
        }
Esempio n. 9
0
        public void PointFeatureSerialization() 
        {
            var point = new GeoJSON.Net.Geometry.Point(new GeoJSON.Net.Geometry.GeographicPosition(45.79012, 15.94107));
            var featureProperties = new Dictionary<string, object> { {"Name", "Foo"} };
            var model = new GeoJSON.Net.Feature.Feature(point, featureProperties);
            var serializedData = JsonConvert.SerializeObject(model, Formatting.Indented, new JsonSerializerSettings { ContractResolver = new CamelCasePropertyNamesContractResolver(), NullValueHandling = NullValueHandling.Ignore });

            Assert.IsFalse(serializedData.Contains("longitude"));
        }
Esempio n. 10
0
        public LcboStore(DbDataReader reader)
            : this()
        {
            this.Id = Convert.ToInt32(reader["id"]);

            var columnNames = reader.GetSchemaTable().Rows.OfType<DataRow>().Select(r => (string)r["ColumnName"]);

            if (columnNames.Contains("name") && reader["name"] != DBNull.Value)
            {
                this.Name = reader["name"] as string;
            }

            if (columnNames.Contains("beer_volume") && reader["beer_volume"] != DBNull.Value)
            {
                this.Volumes.Beer = Convert.ToInt32(reader["beer_volume"]);
            }

            if (columnNames.Contains("wine_volume") && reader["wine_volume"] != DBNull.Value)
            {
                this.Volumes.Wine = Convert.ToInt32(reader["wine_volume"]);
            }

            if (columnNames.Contains("spirits_volume") && reader["spirits_volume"] != DBNull.Value)
            {
                this.Volumes.Spirits = Convert.ToInt32(reader["spirits_volume"]);
            }

            if (columnNames.Contains("city") && reader["city"] != DBNull.Value)
            {
                this.City = reader["city"] as string;
            }

            if (columnNames.Contains("subdivision_id") && reader["subdivision_id"] != DBNull.Value)
            {
                this.SubdivisionId = Convert.ToInt32(reader["subdivision_id"]);
            }

            if (columnNames.Contains("location") && reader["location"] != DBNull.Value)
            {
                var location = reader["location"] as string;
                var geojsonlocation = JsonConvert.DeserializeObject<Point>(location);
                var properties = new Dictionary<string, object>
                {
                    { "name", this.Name },
                    { "city", this.City },
                    { "beerVolume", this.Volumes.Beer },
                    { "wineVolume", this.Volumes.Wine },
                    { "spiritsVolume", this.Volumes.Spirits },
                    { "totalVolume", this.Volumes.Total },
                };

                var feature = new Feature(geojsonlocation, properties);
                this.GeoJSON = feature;
            }
        }
Esempio n. 11
0
        public void PointFeatureSerialization()
        {
            var point             = new GeoJSON.Net.Geometry.Point(new GeoJSON.Net.Geometry.GeographicPosition(45.79012, 15.94107));
            var featureProperties = new Dictionary <string, object> {
                { "Name", "Foo" }
            };
            var model          = new GeoJSON.Net.Feature.Feature(point, featureProperties);
            var serializedData = GetSerialized(model);

            Assert.IsFalse(serializedData.Contains("longitude"));
        }
Esempio n. 12
0
 public void AddLine(string name, List<PointLatLng> points, ColorInfo colorInfo, Feature featureInfo)
 {
     _context.Send(_ =>
     {
         _overlay.Routes.Add(new GMapRoute(points, name)
         {
             Stroke = new Pen(Color.FromArgb((int) colorInfo.StrokeColor), colorInfo.StrokeWidth +2),
             IsHitTestVisible = true,
             Tag = featureInfo
         });
     }, null);
 }
Esempio n. 13
0
        public void PointFeatureSerialization()
        {
            var point             = new GeoJSON.Net.Geometry.Point(new GeoJSON.Net.Geometry.GeographicPosition(45.79012, 15.94107));
            var featureProperties = new Dictionary <string, object> {
                { "Name", "Foo" }
            };
            var model          = new GeoJSON.Net.Feature.Feature(point, featureProperties);
            var serializedData = JsonConvert.SerializeObject(model, Formatting.Indented, new JsonSerializerSettings {
                ContractResolver = new CamelCasePropertyNamesContractResolver(), NullValueHandling = NullValueHandling.Ignore
            });

            Assert.IsFalse(serializedData.Contains("longitude"));
        }
Esempio n. 14
0
        public void AddPolygon(string name, List<PointLatLng> points, ColorInfo colorInfo, Feature featureInfo)
        {
            _context.Send(_ =>
            {
                _overlay.Polygons.Add(new GMapPolygon(points, name)
                {
                    Fill = new SolidBrush(Color.FromArgb((int) colorInfo.FillColor)),
                    Stroke = new Pen(Color.FromArgb((int) colorInfo.StrokeColor), colorInfo.StrokeWidth),
                    IsHitTestVisible = true,
                    Tag = featureInfo
                });

            }, null);
        }
        internal Feature CreateFeature(GeoJSON.Net.Feature.Feature geoJsonFeature)
        {
            if (geoJsonFeature.Geometry == null)
            {
                throw new NotSupportedException("The Feature must contain Geometry data to be converted");
            }

            var tileFeature = new TileFactory.Feature(convertToGeometryType(geoJsonFeature.Geometry.Type))
            {
                Id   = !string.IsNullOrEmpty(geoJsonFeature.Id) ? geoJsonFeature.Id : Guid.NewGuid().ToString(),
                Tags = geoJsonFeature.Properties
            };

            return(tileFeature);
        }
Esempio n. 16
0
        private FeatureCollection CoordsToGeoJson(List <IPosition> coordinates)
        {
            if (!coordinates.Any())
            {
                return(null);
            }
            var coords = coordinates.Select(r => new Position(r.Latitude, r.Longitude)).ToList();
            var geo    = new GeoJSON.Net.Geometry.LineString(coords);

            var feature           = new GeoJSON.Net.Feature.Feature(geo);
            var featureCollection = new FeatureCollection(new List <Feature> {
                feature
            });

            return(featureCollection);
        }
Esempio n. 17
0
        public void PolygonFeatureSerialization() 
        {
            var coordinates = new List<GeographicPosition> 
                { 
                    new GeographicPosition(52.370725881211314, 4.889259338378906), 
                    new GeographicPosition(52.3711451105601, 4.895267486572266), 
                    new GeographicPosition(52.36931095278263, 4.892091751098633), 
                    new GeographicPosition(52.370725881211314, 4.889259338378906) 
                }.ToList<IPosition>();

            var polygon = new Polygon(new List<LineString> { new LineString(coordinates) });
            var featureProperties = new Dictionary<string, object> { { "Name", "Foo" } };
            var model = new GeoJSON.Net.Feature.Feature(polygon, featureProperties);

            var serializedData = JsonConvert.SerializeObject(model, Formatting.Indented, new JsonSerializerSettings { ContractResolver = new CamelCasePropertyNamesContractResolver(), NullValueHandling = NullValueHandling.Ignore });

        }
Esempio n. 18
0
        public void CreateLineFeature(string feeder, List <Position> geom, Breaker breaker)
        {
            if (geom.Count() < 2)
            {
                return;
            }
            var lineString = new LineString(geom);
            var props      = new Dictionary <string, object>
            {
                //{ "type", "mv_line" },
                { "feed", feeder },
                { "name", breaker.name },
            };
            var feature = new GeoJSON.Net.Feature.Feature(lineString, props);

            lineFeatures.Features.Add(feature);
        }
Esempio n. 19
0
        /// <summary>
        /// Return a GeoJson from a datatable with column Geometry in Json format.
        /// </summary>
        /// <param name="dt">DataTable with columns properties and column geometry</param>
        /// <param name="GeometryColumn">Column Name of Geometry</param>
        /// <returns></returns>
        public static string fromDataset(DataTable dt, string GeometryColumn = "Geom")
        {
            var model = new FeatureCollection();

            int numColumns = dt.Columns.Count;

            string[] keys = new string[numColumns];

            for (int i = 0; i < numColumns; i++)
            {
                var columnName = dt.Columns[i].ColumnName;
                if (string.Compare(columnName, GeometryColumn, CultureInfo.InvariantCulture, CompareOptions.OrdinalIgnoreCase) != 0)
                {
                    keys[i] = columnName;
                }
            }

            foreach (DataRow row in dt.Rows)
            {
                object geom   = null;
                var    geomDB = row[GeometryColumn].ToString();
                var    json   = row[GeometryColumn].ToString();

                JsonTextReader reader = new JsonTextReader(new StringReader(json));

                while (reader.Read())
                {
                    geom = new GeometryConverter().ReadJson(reader, null, null, null);
                }

                Dictionary <string, object> props = new Dictionary <string, object>();
                for (int j = 0; j < keys.Length; j++)
                {
                    if (!string.IsNullOrEmpty(keys[j]))
                    {
                        props.Add(keys[j], row[j]);
                    }
                }

                var feature = new GeoJSON.Net.Feature.Feature((IGeometryObject)geom, props);
                model.Features.Add(feature);
            }

            return(JsonConvert.SerializeObject(model));
        }
Esempio n. 20
0
        public void LineString_Coordinate_Serialization()
        {
            string expected = "\"coordinates\":[[102.0,0.0],[103.0,1.0],[104.0,0.0],[105.0,1.0]]";
            var    feature  = new GeoJSON.Net.Feature.Feature(
                new LineString(new List <IPosition> {
                new GeographicPosition(0.0, 102.0),
                new GeographicPosition(1.0, 103.0),
                new GeographicPosition(0.0, 104.0),
                new GeographicPosition(1.0, 105.0),
            }), new Dictionary <string, object>
            {
                { "name", "Dinagat Islands" }
            });

            var serialized = GetSerialized(feature, false);

            Assert.AreNotEqual(-1, serialized.IndexOf(expected), expected + "\n" + serialized);
        }
        public static Feature Parse(Tile.Feature feature, List<string> keys, List<Tile.Value> values, int x, int y, int z, uint extent, bool convertToGeographicPosition)
        {
            Feature result = null;
            var geom = GeometryParser.ParseGeometry(feature.Geometry, feature.Type);
            var id = feature.Id;

            var positions= convertToGeographicPosition?
                geom.Select(p => p.ToGeographicPosition(x,y,z,extent)).ToList():
                geom.Select(p => new GeographicPosition(p.Latitude, p.Longitude)).ToList();

            var coordinates = positions.ToList<IPosition>();
            if (feature.Type == Tile.GeomType.Polygon)
            {
                if (coordinates.Count > 3)
                {
                    var polygon = new Polygon(new List<LineString> {new LineString(coordinates)});
                    result = new Feature(polygon);
                }
            }
            else if (feature.Type == Tile.GeomType.LineString)
            {
                var ls = new LineString(coordinates);
                result = new Feature(ls);
            }
            else if (feature.Type == Tile.GeomType.Point)
            {
                var pt = new Point(coordinates[0]);
                result = new Feature(pt);

            }

            if (result != null)
            {
                result.Id = id.ToString(CultureInfo.InvariantCulture);
                var attributes = AttributesParser.Parse(keys, values, feature.Tags);
                foreach (var item in attributes)
                {
                    result.Properties.Add(item.Key, item.Value);
                }

            }
            return result;
        }
Esempio n. 22
0
        public string GetCurrentVehicleValues()
        {
            var model = new FeatureCollection();

            foreach (Vehicle v in vehicleHash.Values)
            {
                var geom  = new Point(new Position(v.Latitude, v.Longitude));
                var props = new Dictionary <string, object>
                {
                    { "avl", v.Avl },
                    { "tim", v.Timestamp },
                    { "spe", v.Speed },
                    { "nam", vehicleNames[v.Avl] }
                };
                var feature = new GeoJSON.Net.Feature.Feature(geom, props);
                model.Features.Add(feature);
            }
            var vehiclejson = JsonConvert.SerializeObject(model);

            return(vehiclejson);
        }
Esempio n. 23
0
        public void PolygonFeatureSerialization()
        {
            var coordinates = new List <GeographicPosition>
            {
                new GeographicPosition(52.370725881211314, 4.889259338378906),
                new GeographicPosition(52.3711451105601, 4.895267486572266),
                new GeographicPosition(52.36931095278263, 4.892091751098633),
                new GeographicPosition(52.370725881211314, 4.889259338378906)
            }.ToList <IPosition>();

            var polygon = new Polygon(new List <LineString> {
                new LineString(coordinates)
            });
            var featureProperties = new Dictionary <string, object> {
                { "Name", "Foo" }
            };
            var model = new GeoJSON.Net.Feature.Feature(polygon, featureProperties);

            var serializedData = JsonConvert.SerializeObject(model, Formatting.Indented, new JsonSerializerSettings {
                ContractResolver = new CamelCasePropertyNamesContractResolver(), NullValueHandling = NullValueHandling.Ignore
            });
        }
        public TreeModel(Feature feature)
        {
            this.feature = feature;

            this.Ort = feature.Properties["ort"].ToString();
            this.deuText = feature.Properties["deuText"].ToString();
            this.wisText = feature.Properties["wisText"].ToString();
            this.treeId = feature.Properties["treeId"].ToString();
            this.baumNr = Convert.ToInt32(feature.Properties["baumNr"].ToString());
            this.stadtteil = feature.Properties["stadtteil"].ToString();
            this.strasse = feature.Properties["strasse"].ToString();
            this.treeType = feature.Properties["treeType"].ToString();
            this.stUmfang = Convert.ToDouble(feature.Properties["stUmfang"].ToString());
            this.kroneDm = Convert.ToDouble(feature.Properties["kroneDm"].ToString());
            this.typ = feature.Properties["typ"].ToString();

            var point = (GeoJSON.Net.Geometry.Point)feature.Geometry;
            var coords = (GeoJSON.Net.Geometry.GeographicPosition)point.Coordinates;
            this.Location = new Geopoint(new BasicGeoposition()
            {
                Latitude = coords.Latitude,
                Longitude = coords.Longitude
            });
        }
        public static Feature ToGeoJSON(this VectorTileFeature vectortileFeature, int x, int y, int z)
        {
            IGeometryObject geom = null;

            switch (vectortileFeature.GeometryType)
            {
                case Tile.GeomType.Point:
                    var projectedPoints = ProjectPoints(vectortileFeature.Geometry, x, y, z, vectortileFeature.Extent);
                    geom = GetPointGeometry(projectedPoints);
                    break;
                case Tile.GeomType.LineString:
                    var projectedLines = ProjectLines(vectortileFeature.Geometry, x, y, z, vectortileFeature.Extent);
                    geom = GetLineGeometry(projectedLines);
                    break;
                case Tile.GeomType.Polygon:
                    // todo: Call method ClassifyRings.Classify first...
                    // and process the classified rings...
                    var rings = ClassifyRings.Classify(vectortileFeature.Geometry);
                    var projectedPolygons = ProjectPolygons(rings, x, y, z, vectortileFeature.Extent);

                    // var projectedPolygons = ProjectLines(vectortileFeature.Geometry, x, y, z, vectortileFeature.Extent);
                    geom = GetPolygonGeometry(projectedPolygons);
                    break;
            }

            var result = new Feature(geom);

            // add attributes
            foreach (var item in vectortileFeature.Attributes)
            {
                result.Properties.Add(item.Key, item.Value);

            }
            result.Id = vectortileFeature.Id;
            return result;
        }
Esempio n. 26
0
        /*
         * GeoJSON Feature Representation of a beacon
         */
        public Feature toGeoJSONFeature()
        {
            var properties = new Dictionary<String, object>();
            properties.Add("Beacon Type", beaconType);
            properties.Add("Element Id", elementId);

            var feature = new Feature(BeaconCoordinates, properties);
            return feature;
        }
Esempio n. 27
0
        public async Task <ActionResult <FeatureCollection> > GetGeoJsonAsync(string id, ODataQueryOptions <RouteInstance> q, [FromQuery] string language)
        {
            var userClaim   = User.Claims.SingleOrDefault(c => c.Type == ClaimTypes.NameIdentifier);
            var userIdClaim = int.Parse(userClaim != null ? userClaim.Value : "-1");

            var guid = Guid.Parse(id);
            var map  = await _context.Maps.SingleOrDefaultAsync(m => m.MapGuid == guid);

            if (map == null)
            {
                return(NotFound());
            }
            if (string.IsNullOrWhiteSpace(map.SharingLinkName))
            {
                if (!User.Claims.Any())
                {
                    return(Forbid());
                }
                var adminClaim = (User.Claims.SingleOrDefault(c => c.Type == "admin").Value ?? "false");

                if ((userIdClaim < 0 || map.UserId != userIdClaim) && !string.Equals(adminClaim, "true", StringComparison.OrdinalIgnoreCase))
                {
                    return(Forbid());
                }
            }

            var routes = _context.RouteInstances
                         .Include(ri => ri.Route)
                         .ThenInclude(r => r.RouteType)
                         .AsQueryable();

            var types = await _context.RouteTypes.ToListAsync();

            var colours = new Dictionary <int, LineStyle>();

            types.ForEach(t =>
            {
                colours.Add(t.TypeId, new LineStyle {
                    Color = Color32.Parse(t.Colour)
                });
            });

            if (q.Filter != null)
            {
                var                  model  = Startup.GetEdmModel();
                IEdmType             type   = model.FindDeclaredType("OVDB_database.Models.RouteInstance");
                IEdmNavigationSource source = model.FindDeclaredEntitySet("Products");
                var                  parser = new ODataQueryOptionParser(model, type, source, new Dictionary <string, string> {
                    { "$filter", q.Filter.RawValue }
                });
                var context = new ODataQueryContext(model, typeof(RouteInstance), q.Context.Path);
                var filter  = new FilterQueryOption(q.Filter.RawValue, context, parser);
                routes = q.Filter.ApplyTo(routes, new ODataQuerySettings()) as IQueryable <RouteInstance>;
            }
            routes = routes.Where(r => r.RouteInstanceMaps.Any(rim => rim.MapId == map.MapId) || r.Route.RouteMaps.Any(rm => rm.MapId == map.MapId));
            var collection     = new FeatureCollection();
            var routesList     = new List <Route>();
            var routesToReturn = new Dictionary <int, int>();
            await routes.ForEachAsync(r =>
            {
                if (!routesToReturn.ContainsKey(r.RouteId))
                {
                    routesToReturn.Add(r.RouteId, 0);
                    routesList.Add(r.Route);
                }
                routesToReturn[r.RouteId] += 1;
            });


            routesList.ForEach(r =>
            {
                try
                {
                    var multi = r.Coordinates.Split("###").ToList();
                    var lines = new List <GeoJSON.Net.Geometry.LineString>();
                    multi.ForEach(block =>
                    {
                        var coordinates = block.Split('\n').Where(a => !string.IsNullOrWhiteSpace(a)).ToList();
                        var coords      = coordinates.Select(r => new Position(double.Parse(r.Split(',')[1], CultureInfo.InvariantCulture), double.Parse(r.Split(',')[0], CultureInfo.InvariantCulture))).ToList();
                        if (coords.Count >= 2)
                        {
                            var geo = new GeoJSON.Net.Geometry.LineString(coords);
                            lines.Add(geo);
                        }
                    });
                    GeoJSON.Net.Feature.Feature feature;
                    if (lines.Count == 1)
                    {
                        feature = new GeoJSON.Net.Feature.Feature(lines.Single());
                    }
                    else
                    {
                        var multiLineString = new MultiLineString(lines);
                        feature             = new GeoJSON.Net.Feature.Feature(multiLineString);
                    }
                    feature.Properties.Add("id", r.RouteId);
                    feature.Properties.Add("totalInstances", routesToReturn[r.RouteId]);

                    if (map.ShowRouteOutline)
                    {
                        feature.Properties.Add("o", 1);
                    }
                    if (map.ShowRouteInfo)
                    {
                        if (language == "nl" && !string.IsNullOrWhiteSpace(r.NameNL))
                        {
                            feature.Properties.Add("name", r.NameNL);
                        }
                        else
                        {
                            feature.Properties.Add("name", r.Name);
                        }
                        if (language == "nl" && !string.IsNullOrWhiteSpace(r.RouteType.NameNL))
                        {
                            feature.Properties.Add("type", r.RouteType.NameNL);
                        }
                        else
                        {
                            feature.Properties.Add("type", r.RouteType.Name);
                        }
                        if (language == "nl" && !string.IsNullOrWhiteSpace(r.DescriptionNL))
                        {
                            feature.Properties.Add("description", r.DescriptionNL);
                        }
                        else
                        {
                            feature.Properties.Add("description", r.Description);
                        }
                        feature.Properties.Add("lineNumber", r.LineNumber);
                        feature.Properties.Add("operatingCompany", r.OperatingCompany);
                        if (r.OverrideDistance.HasValue)
                        {
                            feature.Properties.Add("distance", r.OverrideDistance);
                        }
                        else
                        {
                            feature.Properties.Add("distance", r.CalculatedDistance);
                        }
                    }
                    if (map.UserId == userIdClaim)
                    {
                        feature.Properties.Add("owner", true);
                    }
                    if (!string.IsNullOrWhiteSpace(r.OverrideColour))
                    {
                        feature.Properties.Add("stroke", r.OverrideColour);
                    }
                    else
                    {
                        feature.Properties.Add("stroke", r.RouteType.Colour);
                    }
                    collection.Features.Add(feature);
                }
                catch (Exception ex)
                {
                    Console.WriteLine(ex.Message);
                    throw;
                }
            });

            return(collection);
        }
Esempio n. 28
0
        public async Task <ActionResult <FeatureCollection> > GetSingleRouteGeoJsonAsync(int id, Guid guid, [FromQuery] string language)
        {
            var route = await _context.Routes.Include(r => r.RouteType).Include(r => r.RouteCountries).SingleOrDefaultAsync(r =>
                                                                                                                            r.RouteId == id &&
                                                                                                                            r.Share == guid);

            if (route == null)
            {
                return(NotFound());
            }


            var collection = new FeatureCollection();

            var multi = route.Coordinates.Split("###").ToList();
            var lines = new List <GeoJSON.Net.Geometry.LineString>();

            multi.ForEach(block =>
            {
                var coordinates = block.Split('\n').Where(a => !string.IsNullOrWhiteSpace(a)).ToList();
                var coords      = coordinates.Select(r => new Position(double.Parse(r.Split(',')[1], CultureInfo.InvariantCulture), double.Parse(r.Split(',')[0], CultureInfo.InvariantCulture))).ToList();
                if (coords.Count >= 2)
                {
                    var geo = new GeoJSON.Net.Geometry.LineString(coords);
                    lines.Add(geo);
                }
            });
            GeoJSON.Net.Feature.Feature feature;
            if (lines.Count == 1)
            {
                feature = new GeoJSON.Net.Feature.Feature(lines.Single());
            }
            else
            {
                var multiLineString = new MultiLineString(lines);
                feature = new GeoJSON.Net.Feature.Feature(multiLineString);
            }
            if (language == "nl" && !string.IsNullOrWhiteSpace(route.NameNL))
            {
                feature.Properties.Add("name", route.NameNL);
            }
            else
            {
                feature.Properties.Add("name", route.Name);
            }
            if (language == "nl" && !string.IsNullOrWhiteSpace(route.RouteType.NameNL))
            {
                feature.Properties.Add("type", route.RouteType?.NameNL);
            }
            else
            {
                feature.Properties.Add("type", route.RouteType?.Name);
            }
            if (language == "nl" && !string.IsNullOrWhiteSpace(route.DescriptionNL))
            {
                feature.Properties.Add("description", route.DescriptionNL);
            }
            else
            {
                feature.Properties.Add("description", route.Description ?? "Unknown");
            }
            feature.Properties.Add("lineNumber", route.LineNumber);
            feature.Properties.Add("operatingCompany", route.OperatingCompany);;
            if (!string.IsNullOrWhiteSpace(route.OverrideColour))
            {
                feature.Properties.Add("stroke", route.OverrideColour);
            }
            else
            {
                feature.Properties.Add("stroke", route.RouteType?.Colour ?? "#000");
            }

            collection.Features.Add(feature);

            return(collection);
        }
 private static bool FeatureRepresentsCircle(Feature feature)
 {
     return feature.Geometry.Type == GeoJSONObjectType.Point && feature.Properties.ContainsKey("radius");
 }
Esempio n. 30
0
        public string BuildingsToGeoJson()
        {
            var fc = new FeatureCollection();

            var buildings = Buildings.Where(w => w.LocationDataWKT != "");

            foreach (var building in buildings)
            {
                string wkt     = building.LocationDataWKT;
                string geoType = wkt.Substring(0, wkt.IndexOf("(")).Trim();
                string coord   = wkt.Replace(geoType, "").Replace("(", "").Replace(")", "").Replace(", ", ",").Trim();

                IGeometryObject geometry = null;

                if (geoType == "POLYGON")
                {
                    geometry = new Polygon(new List <LineString>
                    {
                        new LineString(
                            coord.Split(',')
                            .Select(s => s.Split(' '))
                            .Select(a => new GeographicPosition(double.Parse(a[1]), double.Parse(a[0])))
                            )
                    });
                }
                else if (geoType == "POINT")
                {
                    geometry = new Point(
                        coord.Split(',')
                        .Select(s => s.Split(' '))
                        .Select(a => new GeographicPosition(double.Parse(a[1]), double.Parse(a[0]))).First()
                        );
                }
                else
                {
                    throw new Exception("Invalid GeoJson geoType.  Value: " + geoType);
                }

                var props = new Dictionary <string, object>
                {
                    { "id", building.GroupRiskBuildingId },

                    // Building info
                    { "groupRiskBuildingId", building.GroupRiskBuildingId },
                    { "buildingId", building.BuildingId },

                    { "policyId", building.PolicyId },
                    { "groupId", building.GroupId },
                    { "locationId", building.LocationId },

                    { "constructionType", building.ConstructionType },
                    { "pmlValue", building.PmlValue },

                    // Location info
                    { "groupRiskLocationId", building.GroupRiskLocationId },
                    { "protectionClass", building.ProtectionClass },
                    { "grade", building.Grade },
                    { "area", building.Area },
                    { "stories", building.Stories },
                    { "address1", building.Address1 },
                    { "address2", building.Address2 },
                    { "address3", building.Address3 },
                    { "city", building.City },
                    { "state", building.State },
                    { "postalCode", building.PostalCode },

                    { "isDirty", building.IsDirty.ToString() }
                };

                if (geometry != null)
                {
                    var feature = new GeoJSON.Net.Feature.Feature(geometry, props);
                    fc.Features.Add(feature);
                }
            }

            return(JsonConvert.SerializeObject(fc));
        }
Esempio n. 31
0
        public string RiskGroupToGeoJson()
        {
            var fc = new FeatureCollection();

            string wkt = LocationDataWKT;

            if (!String.IsNullOrEmpty(wkt))
            {
                IGeometryObject geometry = null;

                string geoType = wkt.Substring(0, wkt.IndexOf("(")).Trim();

                string wktPrepared = String.Empty;

                if (geoType == "POINT")
                {
                    wktPrepared = wkt.Replace(geoType, "").Trim().Replace("((", "").Replace("))", "").Replace("(", "").Replace(")", "");

                    var input = wktPrepared;

                    geometry = input.Split(',')
                               .Select(s => s.Split(' '))
                               .Select(a => new GeographicPosition(double.Parse(a[1]), double.Parse(a[0])))
                               .Select(a => new Point(a))
                               .FirstOrDefault();
                }
                else if (geoType == "POLYGON")
                {
                    wktPrepared = wkt.Replace(geoType, "").Trim().Replace("((", "").Replace("))", "").Replace(", ", ",");

                    string[] input = Regex.Split(wktPrepared, @",");

                    List <GeographicPosition> geometryList = input
                                                             .Select(s => s.Split(' '))
                                                             .Select(a => new GeographicPosition(double.Parse(a[1]), double.Parse(a[0])))
                                                             .ToList();

                    geometry = new Polygon(new List <LineString> {
                        new LineString(geometryList)
                    });
                }
                else if (geoType == "MULTIPOINT")
                {
                    wktPrepared = wkt.Replace(geoType, "").Trim().Replace("((", "").Replace("))", "").Replace("(", "").Replace(", ", ",");

                    string[] points = Regex.Split(wktPrepared, @"\),");

                    List <Point> geometryList = points
                                                .Select(s => s.Split(' '))
                                                .Select(a => new GeographicPosition(double.Parse(a[1]), double.Parse(a[0])))
                                                .Select(a => new Point(a))
                                                .ToList();

                    geometry = new MultiPoint(geometryList);
                }
                else if (geoType == "MULTIPOLYGON")
                {
                    wktPrepared = wkt.Replace(geoType, "").Trim().Replace("(((", "").Replace(")))", "").Replace("(", "");

                    string[] polys = Regex.Split(wktPrepared, @"\)\),");

                    List <Polygon> polyList = new List <Polygon>();

                    foreach (var element in polys.Select(s => s.Split(',')))
                    {
                        List <GeographicPosition> posList = element
                                                            .Select(s => s.Trim().Split(' '))
                                                            .Select(a => new GeographicPosition(double.Parse(a[1]), double.Parse(a[0])))
                                                            .ToList();

                        polyList.Add(new Polygon(new List <LineString> {
                            new LineString(posList)
                        }));
                    }

                    geometry = new MultiPolygon(polyList);
                }
                else
                {
                    throw new Exception("Invalid GeoJson geoType.  Value: " + geoType);
                }

                var props = new Dictionary <string, object>
                {
                    { "id", this.GroupId },

                    // Building info
                    { "policyInScope", this.PolicyInScope },
                    { "startDate", this.StartDate },
                    { "endDate", this.EndDate },
                    { "groupRiskPolicyId", this.GroupRiskPolicyId },
                    { "policyid", this.PolicyId }
                };

                if (geometry != null)
                {
                    var feature = new GeoJSON.Net.Feature.Feature(geometry, props);
                    fc.Features.Add(feature);
                }
            }
            return(JsonConvert.SerializeObject(fc));
        }
Esempio n. 32
0
 public static JFeature.Feature Feature2JG(Feature feature)
 {
     JGeometry.IGeometryObject igeometry = Geometry2JG(feature.geometry);
     JFeature.Feature          jFeature  = new JFeature.Feature(igeometry, feature.attributes, feature.featureID.ToString());
     return(jFeature);
 }
Esempio n. 33
0
        public void Test()
        {
            var route      = new Route();
            var collection = new FeatureCollection();
            var multi      = route.Coordinates.Split("###").ToList();
            var lines      = new List <GeoJSON.Net.Geometry.LineString>();

            multi.ForEach(block =>
            {
                var coordinates = block.Split('\n').Where(a => !string.IsNullOrWhiteSpace(a)).ToList();
                var coords      = coordinates.Select(r => new Position(double.Parse(r.Split(',')[1], CultureInfo.InvariantCulture), double.Parse(r.Split(',')[0], CultureInfo.InvariantCulture))).ToList();
                if (coords.Count >= 2)
                {
                    var geo = new GeoJSON.Net.Geometry.LineString(coords);
                    lines.Add(geo);
                }
            });
            GeoJSON.Net.Feature.Feature feature;
            if (lines.Count == 1)
            {
                feature = new GeoJSON.Net.Feature.Feature(lines.Single());
            }
            else
            {
                var multiLineString = new MultiLineString(lines);
                feature = new GeoJSON.Net.Feature.Feature(multiLineString);
            }
            if (!string.IsNullOrWhiteSpace(route.Name))
            {
                feature.Properties.Add("name", route.Name);
            }
            if (!string.IsNullOrWhiteSpace(route.NameNL))
            {
                feature.Properties.Add("nameNL", route.NameNL);
            }
            if (!string.IsNullOrWhiteSpace(route.Description))
            {
                feature.Properties.Add("description", route.Description);
            }
            if (!string.IsNullOrWhiteSpace(route.DescriptionNL))
            {
                feature.Properties.Add("descriptionNL", route.DescriptionNL);
            }
            if (route.FirstDateTime.HasValue)
            {
                feature.Properties.Add("firstDateTime", route.FirstDateTime.Value.ToString("o"));
            }
            if (!string.IsNullOrWhiteSpace(route.LineNumber))
            {
                feature.Properties.Add("lineNumber", route.LineNumber);
            }
            if (!string.IsNullOrWhiteSpace(route.OperatingCompany))
            {
                feature.Properties.Add("operatingCompany", route.OperatingCompany);
            }
            if (!string.IsNullOrWhiteSpace(route.OverrideColour))
            {
                feature.Properties.Add("name", route.OverrideColour);
            }
            if (route.RouteCountries.Any())
            {
                feature.Properties.Add("countries", string.Join(',', route.RouteCountries.Select(c => c.Country.Name)));
            }
            if (route.RouteMaps.Any())
            {
                feature.Properties.Add("maps", string.Join(',', route.RouteMaps.Select(c => c.Map.Name)));
            }
            if (route.RouteTypeId.HasValue)
            {
                feature.Properties.Add("type", route.RouteType.Name);
            }
            collection.Features.Add(feature);
        }
Esempio n. 34
0
        private FeatureCollection ConvertGpxContentToGeoJson(byte[] content)
        {
            var collection = new FeatureCollection();
            using (var stream = new MemoryStream(content))
            {
                XmlSerializer xmlSerializer = new XmlSerializer(typeof(gpxType));
                var gpx = xmlSerializer.Deserialize(stream) as gpxType;
                foreach (var point in gpx.wpt ?? new wptType[0])
                {
                    var feature = new Feature(new Point(CreateGeoPosition(point)), CreateNameProperties(point.name));
                    collection.Features.Add(feature);
                }
                foreach (var track in gpx.trk ?? new trkType[0])
                {
                    if (track.trkseg.Length == 1)
                    {
                        var lineStringFeature = new Feature(new LineString(track.trkseg[0].trkpt.Select(point => CreateGeoPosition(point))), CreateNameProperties(track.name));
                        collection.Features.Add(lineStringFeature);
                        continue;
                    }
                    var lineStringList = new List<LineString>();
                    foreach (var segment in track.trkseg)
                    {
                        lineStringList.Add(new LineString(segment.trkpt.Select(point => CreateGeoPosition(point))));
                    }
                    var feature = new Feature(new MultiLineString(lineStringList), CreateNameProperties(track.name));
                    collection.Features.Add(feature);
                }

                foreach (var route in gpx.rte ?? new rteType[0])
                {
                    var lineStringFeature = new Feature(new LineString(route.rtept.Select(point => CreateGeoPosition(point))), CreateNameProperties(route.name));
                    collection.Features.Add(lineStringFeature);
                }
            }
            return collection;
        }
Esempio n. 35
0
        public void GenerateMapData()
        {
            // init road data
            var roads = RoadSegment.ParseRoadData(File.ReadAllText(Path.Combine(dataDir, "r0.txt")));

            // serialize as geojson
            FeatureCollection trafficData = new FeatureCollection();
            foreach (RoadSegment road in roads)
            {
                // find the sensor and determine color
                var sensor = sensorData.Where(s => s.ID == road.ID).FirstOrDefault();
                List<IPosition> segments = new List<IPosition>();
                for (int i = 0; i < road.Nodes.Count; i++)
                {
                    segments.Add(new GeographicPosition(road.Nodes[i].Lat, road.Nodes[i].Lon));
                }

                var featureProperties = new Dictionary<string, object> { { "id", road.ID }, { "l", road.Semt }, { "s", sensor == null ? -1 : sensor.Speed } };
                var feat = new Feature(new LineString(segments), featureProperties);
                trafficData.Features.Add(feat);
            }
            var serializedData = JsonConvert.SerializeObject(trafficData);
            var dateTime = String.Format("{2:00}/{3:00}/{4} {0:00}:{1:00}", acqTimeLocal.Hour, acqTimeLocal.Minute,acqTimeLocal.Day,acqTimeLocal.Month,acqTimeLocal.Year);

            StringBuilder sb = new StringBuilder();
            sb.Append("var mapData=" + serializedData + ";\r\n");
            sb.Append("var acqTime='" + dateTime + "';\r\n");
            sb.Append("var trafficIndex=" + trafficIndex + ";\r\n");

            File.WriteAllText(Path.Combine(dataDir, "tkmData.js"), sb.ToString());
        }
Esempio n. 36
0
        public async Task<Feature> BoundaryGeoJson(int subdivId)
        {
            var result = new Feature(new Point(new Position()));
            var query = @"select ST_AsGeoJSON(boundry, 15, 4) as boundary
                            from subdivisions
                            where id = @subdivId";

            using (var conn = new Npgsql.NpgsqlConnection(connString))
            {
                using (var cmd = conn.CreateCommand())
                {
                    cmd.CommandText = query;
                    conn.Open();
                    cmd.Parameters.AddWithValue("@subdivId", subdivId);
                    var boundary = await cmd.ExecuteScalarAsync() as string;
                    if (boundary.Contains("\"type\":\"MultiPolygon\""))
                    {
                        var multipolygon = JsonConvert.DeserializeObject<MultiPolygon>(boundary);
                        result = new Feature(multipolygon);
                    }
                    else if (boundary.Contains("\"type\":\"Polygon\""))
                    {
                        var polygon = JsonConvert.DeserializeObject<Polygon>(boundary);
                        result = new Feature(polygon);
                    }
                }
            }

            return result;
        }
Esempio n. 37
0
        public void InfoForQGIS()
        {
            FeatureCollection lv_line         = new FeatureCollection();
            FeatureCollection lv_service_line = new FeatureCollection();
            FeatureCollection substation      = new FeatureCollection();
            FeatureCollection substation_text = new FeatureCollection();
            FeatureCollection mv_pole         = new FeatureCollection();
            FeatureCollection mv_pole_text    = new FeatureCollection();
            FeatureCollection lv_pole         = new FeatureCollection();
            FeatureCollection lv_pole_text    = new FeatureCollection();
            FeatureCollection client          = new FeatureCollection();
            FeatureCollection client_text     = new FeatureCollection();

            FeatureCollection aux      = new FeatureCollection();
            FeatureCollection aux_text = new FeatureCollection();

            //string feeder_ex = "('O-145','O-242','O-243')";
            DataTable btlines = ExecuteSelectQuery("select codigo,circuito,alm,sed,ckto,utm from els_2018.linea where estado = 'Existente'and tipo = 'BT' and uso != 'Servicio' and sed !=''");

            //DataTable btlines = ExecuteSelectQuery("select codigo,circuito,alm,sed,ckto,utm from els_2018.linea where estado = 'Existente'and tipo = 'BT' and sed !='' and uso != 'Servicio' and alm in "+ feeder_ex);
            for (int i = 0; i < btlines.Rows.Count; ++i)
            {
                List <Position> geom   = new List <Position>();
                string          utm    = btlines.Rows[i]["utm"].ToString();
                string[]        strArr = utm.Split(' ');
                for (int count = 0; count <= strArr.Length - 1; count++)
                {
                    string[] pos = strArr[count].Split(',');
                    Position p   = ToLatLon(Convert.ToDouble(pos[0]), Convert.ToDouble(pos[1]), "19S");
                    geom.Add(p);
                }
                if (geom.Count() < 2)
                {
                    continue;
                }

                var lineString = new LineString(geom);
                //here we need the information about the circuit
                var props = new Dictionary <string, object>
                {
                    { "feed", btlines.Rows[i]["alm"].ToString() },
                    { "sub", btlines.Rows[i]["sed"].ToString() },
                    { "cir", btlines.Rows[i]["ckto"].ToString() }
                };
                var feature = new GeoJSON.Net.Feature.Feature(lineString, props);
                lv_line.Features.Add(feature);
            }

            DataTable btsevicelines = ExecuteSelectQuery("select codigo,circuito,alm,sed,ckto,utm from els_2018.linea where estado = 'Existente'and tipo = 'BT' and uso = 'Servicio' and sed !=''");

            //DataTable btsevicelines = ExecuteSelectQuery("select codigo,circuito,alm,sed,ckto,utm from els_2018.linea where estado = 'Existente'and tipo = 'BT' and sed !='' and uso = 'Servicio' and alm in " + feeder_ex);
            for (int i = 0; i < btsevicelines.Rows.Count; ++i)
            {
                List <Position> geom   = new List <Position>();
                string          utm    = btsevicelines.Rows[i]["utm"].ToString();
                string[]        strArr = utm.Split(' ');
                for (int count = 0; count <= strArr.Length - 1; count++)
                {
                    string[] pos = strArr[count].Split(',');
                    Position p   = ToLatLon(Convert.ToDouble(pos[0]), Convert.ToDouble(pos[1]), "19S");
                    geom.Add(p);
                }
                if (geom.Count() < 2)
                {
                    continue;
                }

                var lineString = new LineString(geom);
                var props      = new Dictionary <string, object>
                {
                    //{ "type", "lv_service_line" },
                    { "feed", btsevicelines.Rows[i]["alm"].ToString() },
                    { "sub", btsevicelines.Rows[i]["sed"].ToString() },
                    { "cir", btsevicelines.Rows[i]["ckto"].ToString() }
                };
                var feature = new GeoJSON.Net.Feature.Feature(lineString, props);
                lv_service_line.Features.Add(feature);
            }

            DataTable substations = ExecuteSelectQuery("select codigo,id,etiqueta,alm,utm_x,utm_y,utm_s_x,utm_s_y from els_2018.subestacion where estado = 'Existente' and id != '' and etiqueta != '' and utm_s_x != 0");

            //DataTable substations = ExecuteSelectQuery("select codigo,id,etiqueta,alm,utm_x,utm_y,utm_s_x,utm_s_y from els_2018.subestacion where estado = 'Existente' and id != '' and etiqueta != '' and utm_s_x != 0 and alm IN " + feeder_ex);
            for (int i = 0; i < substations.Rows.Count; ++i)
            {
                Position p     = ToLatLon(Convert.ToDouble(substations.Rows[i]["utm_x"]), Convert.ToDouble(substations.Rows[i]["utm_y"]), "19S");
                var      geom  = new Point(p);
                var      props = new Dictionary <string, object>
                {
                    //{ "type", "sub" },
                    { "feed", substations.Rows[i]["alm"].ToString() },
                    { "name", substations.Rows[i]["id"].ToString() },
                };
                var feature = new GeoJSON.Net.Feature.Feature(geom, props);
                substation.Features.Add(feature);

                //label feature
                Position p_lbl     = ToLatLon(Convert.ToDouble(substations.Rows[i]["utm_s_x"]), Convert.ToDouble(substations.Rows[i]["utm_s_y"]), "19S");
                var      geom_lbl  = new Point(p_lbl);
                var      props_lbl = new Dictionary <string, object>
                {
                    //{ "type", "sub_lbl" },
                    { "feed", substations.Rows[i]["alm"].ToString() },
                    { "name", substations.Rows[i]["id"].ToString() },
                };
                var feature_lbl = new GeoJSON.Net.Feature.Feature(geom_lbl, props_lbl);
                substation_text.Features.Add(feature_lbl);
            }

            DataTable poles = ExecuteSelectQuery("select tipo_uso, etiqueta, alm, sed, utm_x, utm_y, utm_s_x, utm_s_y from els_2018.poste where estado = 'Existente' and utm_x != 0 and (tipo_uso = 'Red Secundaria' or tipo_uso = 'Red Primaria' or tipo_uso = 'Alumbrado Publico')");

            //DataTable poles = ExecuteSelectQuery("select tipo_uso, etiqueta, alm, sed, utm_x, utm_y, utm_s_x, utm_s_y from els_2018.poste where estado = 'Existente' and utm_x != 0 and (tipo_uso = 'Red Secundaria' or tipo_uso = 'Red Primaria' or tipo_uso = 'Alumbrado Publico') and alm IN " + feeder_ex);
            for (int i = 0; i < poles.Rows.Count; ++i)
            {
                string type, type_lbl;
                if (poles.Rows[i]["tipo_uso"].ToString() == "Red Primaria")
                {
                    type = "mv_pole"; type_lbl = "mv_pole_lbl"; aux = mv_pole; aux_text = mv_pole_text;
                }
                else
                {
                    type = "lv_pole"; type_lbl = "lv_pole_lbl"; aux = lv_pole; aux_text = lv_pole_text;
                }
                Position p     = ToLatLon(Convert.ToDouble(poles.Rows[i]["utm_x"]), Convert.ToDouble(poles.Rows[i]["utm_y"]), "19S");
                var      geom  = new Point(p);
                var      props = new Dictionary <string, object>
                {
                    //{ "type", type },
                    { "feed", poles.Rows[i]["alm"].ToString() },
                    { "name", poles.Rows[i]["etiqueta"].ToString() },
                };
                var feature = new GeoJSON.Net.Feature.Feature(geom, props);
                aux.Features.Add(feature);

                //for labels
                Position p_lbl     = ToLatLon(Convert.ToDouble(poles.Rows[i]["utm_s_x"]), Convert.ToDouble(poles.Rows[i]["utm_s_y"]), "19S");
                var      geom_lbl  = new Point(p_lbl);
                var      props_lbl = new Dictionary <string, object>
                {
                    //{ "type", type_lbl },
                    { "feed", poles.Rows[i]["alm"].ToString() },
                    { "name", poles.Rows[i]["etiqueta"].ToString() },
                };
                var feature_lbl = new GeoJSON.Net.Feature.Feature(geom_lbl, props_lbl);
                aux_text.Features.Add(feature_lbl);
            }

            DataTable clients = ExecuteSelectQuery("select circuito,alm,sed,ckto,suministro,utm_x,utm_y,utm_s_x,utm_s_y from els_2018.punto_servicio where estado = 'Existente' and suministro != ' '");

            //DataTable clients = ExecuteSelectQuery("select circuito,alm,sed,ckto,suministro,utm_x,utm_y,utm_s_x,utm_s_y from els_2018.punto_servicio where estado = 'Existente' and suministro != ' ' and alm IN " + feeder_ex);
            for (int i = 0; i < clients.Rows.Count; ++i)
            {
                Position p     = ToLatLon(Convert.ToDouble(clients.Rows[i]["utm_x"]), Convert.ToDouble(clients.Rows[i]["utm_y"]), "19S");
                var      geom  = new Point(p);
                var      props = new Dictionary <string, object>
                {
                    //{ "type", "client" },
                    { "feed", clients.Rows[i]["alm"].ToString() },
                    { "name", clients.Rows[i]["ckto"].ToString() },
                };
                var feature = new GeoJSON.Net.Feature.Feature(geom, props);
                client.Features.Add(feature);

                //labels
                Position p_lbl    = ToLatLon(Convert.ToDouble(clients.Rows[i]["utm_s_x"]), Convert.ToDouble(clients.Rows[i]["utm_s_y"]), "19S");
                var      geom_lbl = new Point(p_lbl);
                string   sum      = clients.Rows[i]["suministro"].ToString();
                sum = sum.Replace(" ", "\n");
                var props_lbl = new Dictionary <string, object>
                {
                    //{ "type", "client_lbl" },
                    { "feed", clients.Rows[i]["alm"].ToString() },
                    { "name", sum },
                };
                var feature_lbl = new GeoJSON.Net.Feature.Feature(geom_lbl, props_lbl);
                client_text.Features.Add(feature_lbl);
            }

            File.WriteAllText(@"C:\cygwin64\home\tony\giscada\lv_line.geojson", JsonConvert.SerializeObject(lv_line));
            File.WriteAllText(@"C:\cygwin64\home\tony\giscada\lv_service_line.geojson", JsonConvert.SerializeObject(lv_service_line));
            File.WriteAllText(@"C:\cygwin64\home\tony\giscada\substation.geojson", JsonConvert.SerializeObject(substation));
            File.WriteAllText(@"C:\cygwin64\home\tony\giscada\substation_text.geojson", JsonConvert.SerializeObject(substation_text));
            File.WriteAllText(@"C:\cygwin64\home\tony\giscada\mv_pole.geojson", JsonConvert.SerializeObject(mv_pole));
            File.WriteAllText(@"C:\cygwin64\home\tony\giscada\mv_pole_text.geojson", JsonConvert.SerializeObject(mv_pole_text));
            File.WriteAllText(@"C:\cygwin64\home\tony\giscada\lv_pole.geojson", JsonConvert.SerializeObject(lv_pole));
            File.WriteAllText(@"C:\cygwin64\home\tony\giscada\lv_pole_text.geojson", JsonConvert.SerializeObject(lv_pole_text));
            File.WriteAllText(@"C:\cygwin64\home\tony\giscada\client.geojson", JsonConvert.SerializeObject(client));
            File.WriteAllText(@"C:\cygwin64\home\tony\giscada\client_text.geojson", JsonConvert.SerializeObject(client_text));
        }
Esempio n. 38
0
        /// <summary>
        /// Creates the geojson export.
        /// </summary>
        /// <param name="results">The results.</param>
        /// <param name="exportProperties">The export properties.</param>
        public void CreateExport(IRecordSet results, string geometryFieldName)
        {
            if (results != null)
            {
                ICursor cursor;
                cursor = results.get_Cursor(false);
                IRow row = cursor.NextRow();
                int rowCount = 0;

                //create an empty list of geojson features
                var geoJsonFeatures = new List<GeoJSON.Net.Feature.Feature>();

                //get the index of the geometry field
                int fieldIndex = row.Fields.FindField(geometryFieldName);
                if (fieldIndex == -1)
                    throw new Exception("Could not locate geometry field:shape");

                if (row != null)
                {

                    while (row != null)
                    {

                        //use the factory to convert the esri geometry to the geojson geometry
                        IGeometryObject geoJsonGeom = null;
                        if (row.get_Value(fieldIndex) != null)
                        {
                            GeoJsonGeometryFactory geomFactory = new GeoJsonGeometryFactory();
                            geoJsonGeom = geomFactory.GetGeometry(row.get_Value(fieldIndex) as IGeometry);
                        }

                        //use the factory to convert esri row to geojson attributes
                        var atts = new GeoJsonAttributeFactory().GetAttributes(row);

                        //create the feature and add it to the collection - use the unique key from the row or create one
                        GeoJSON.Net.Feature.Feature f = null;
                        if (row.Table.HasOID)
                        {
                            f = new GeoJSON.Net.Feature.Feature(geoJsonGeom, atts) { Id = row.get_Value(row.Fields.FindField(row.Table.OIDFieldName)).ToString() };
                        }
                        else
                        {
                            f = new GeoJSON.Net.Feature.Feature(geoJsonGeom, atts) { Id = Guid.NewGuid().ToString() };
                        }

                        geoJsonFeatures.Add(f);

                        row = cursor.NextRow();

                        rowCount++;
                    }
                }

                //initialise the geoJsonFeatureCollection
                var fc = new FeatureCollection(geoJsonFeatures);

                //to keep the export small, use formatting = none and exclude null values
                //todo - allow the null value handling and indentation to be exposed
                _geoJson = JsonConvert.SerializeObject(fc, Formatting.None, new JsonSerializerSettings { DefaultValueHandling = DefaultValueHandling.Ignore });
            }
        }
Esempio n. 39
0
        /// <summary>
        /// Calculates the route.
        /// </summary>
        /// <param name="transportMode">The transport mode.</param>
        /// <param name="start">The start point.</param>
        /// <param name="end">The end point.</param>
        /// <returns>
        /// A new <see cref="RouteModel" /> with the route details.
        /// </returns>
        public RouteModel CalculatePointToPoint(VehicleEnum transportMode, GeoCoordinate start, GeoCoordinate end)
        {
            // calculate route.
            var startPoint = router.Resolve(transportMode, start);
            var endPoint = router.Resolve(transportMode, end);
            var route = router.Calculate(transportMode, startPoint, endPoint);

            if (route == null)
            {
                throw new RoutingException("No matching route found.");
            }

            var coordinates = route.Entries
                .Select(x => new GeographicPosition(x.Latitude, x.Longitude))
                .ToList();

            var lineString = new LineString(coordinates);

            var feature = new Feature(
                lineString,
                new Dictionary<string, object>
                    {
                        { "name", "Test route result." },
                        { "distance", route.TotalDistance },
                        { "journeytime", route.TotalTime },
                    });

            var generator = new InstructionGenerator();
            var instructions = generator.Generate(route, interpreter, new SimpleEnglishLanguageGenerator());

            return new RouteModel
                       {
                           Results = new ResultSet(feature)
                       };
        }