/// <summary> /// Creates a new feature. /// </summary> /// <param name="parent"></param> /// <param name="filter"></param> /// <param name="meta"></param> protected Feature( string name, Filter filter, IDictionary<string, IList<string>> meta) { _name = name; _filter = filter; _meta = meta; }
/// <summary> /// Returns all data within the given tile /// </summary> /// <param name="tile">The tile to fetch geometries from</param> /// <param name="filter">Filtering options for the results</param> /// <returns>An OsmGeoCollection object containing the data within the given tile</returns> public override OsmGeoCollection GetCollection(Tile tile, Filter filter) { var tiles = new List<Tile>(); tiles.Add(tile); return GetCollection(tiles, filter); }
/// <summary> /// Returns the objects that exist withing the given box and evaluate the filter to true. /// </summary> /// <param name="box"></param> /// <param name="filter"></param> /// <returns></returns> public IList<OsmGeo> Get(GeoCoordinateBox box, Filter filter) { this.ReadFromDocument(); IList<OsmGeo> res = new List<OsmGeo>(); foreach (Node node in _nodes.Values) { if (filter.Evaluate(node) && node.Shape.Inside(box)) { res.Add(node); } } foreach (Way way in _ways.Values) { if (filter.Evaluate(way) && way.Shape.Inside(box)) { res.Add(way); } } foreach (Relation relation in _relations.Values) { if (filter.Evaluate(relation) && relation.Shape.Inside(box)) { res.Add(relation); } } return res; }
/// <summary> /// Creates the existence feature. /// </summary> /// <param name="filter"></param> /// <param name="meta"></param> public static void Create(Filter filter, IDictionary<string, IList<string>> meta) { _instance = new ExistenceFeature(filter, meta); }
/// <summary> /// Creates a new existence feature. /// </summary> /// <param name="filter"></param> /// <param name="meta"></param> private ResidentialFeature(Filter filter, IDictionary<string, IList<string>> meta) : base("Map.ExistenceFeature.PhysicalFeature.LandFeature.UrbanFeature.ResidentialFeature", filter, meta) { }
/// <summary> /// Creates a new existence feature. /// </summary> /// <param name="filter"></param> /// <param name="meta"></param> private ForestFeature(Filter filter, IDictionary<string, IList<string>> meta) : base("Map.ExistenceFeature.PhysicalFeature.LandFeature.NatureFeature.ForestFeature", filter, meta) { }
/// <summary> /// Returns all the objects within a given bounding box and filtered by a given filter. /// </summary> /// <param name="box"></param> /// <param name="filter"></param> /// <returns></returns> public override IList<OsmGeo> Get(GeoCoordinateBox box, Filter filter) { List<OsmGeo> res = new List<OsmGeo>(); // load all nodes and keep the ids in a collection. HashSet<long> ids = new HashSet<long>(); foreach (Node node in _nodes.Values) { if ((filter == null || filter.Evaluate(node)) && box.Contains(new GeoCoordinate(node.Latitude.Value, node.Longitude.Value))) { res.Add(node); ids.Add(node.Id.Value); } } // load all ways that contain the nodes that have been found. res.AddRange(this.GetWaysFor(ids).Cast<OsmGeo>()); // the .Cast<> is here for Windows Phone. // get relations containing any of the nodes or ways in the current results-list. List<Relation> relations = new List<Relation>(); HashSet<long> relationIds = new HashSet<long>(); foreach (OsmGeo osmGeo in res) { IList<Relation> relationsFor = this.GetRelationsFor(osmGeo); foreach (Relation relation in relationsFor) { if (!relationIds.Contains(relation.Id.Value)) { relations.Add(relation); relationIds.Add(relation.Id.Value); } } } // recursively add all relations containing other relations as a member. do { res.AddRange(relations.Cast<OsmGeo>()); // the .Cast<> is here for Windows Phone. List<Relation> newRelations = new List<Relation>(); foreach (OsmGeo osmGeo in relations) { IList<Relation> relationsFor = this.GetRelationsFor(osmGeo); foreach (Relation relation in relationsFor) { if (!relationIds.Contains(relation.Id.Value)) { newRelations.Add(relation); relationIds.Add(relation.Id.Value); } } } relations = newRelations; } while (relations.Count > 0); if (filter != null) { List<OsmGeo> filtered = new List<OsmGeo>(); foreach (OsmGeo geo in res) { if (filter.Evaluate(geo)) { filtered.Add(geo); } } } return res; }
/// <summary> /// Creates a new SQLite target /// </summary> /// <param name="in_memory">Is the DB in memory? (default is false)</param> /// <param name="path">The path to the DB, or its descriptor in memory (if any)</param> /// <param name="password">The DB password (if any)</param> /// <param name="create_schema">Do the db tables need to be created?</param> /// <param name="geo_filter">The geos filter to be used</param> /// <param name="tag_filter">The tags filter to be used</param> public SQLiteOsmStreamTarget(bool in_memory = false, string path = null, string password = null, bool create_schema = false, Filter geo_filter = null, TagFilter tag_filter = null) { if (geo_filter == null) { geo_filter = Filter.Any(); } _geo_filter = geo_filter; if (tag_filter == null) { tag_filter = TagFilter.Any(); } _tag_filter = tag_filter; _connection_string = SQLiteSchemaTools.BuildConnectionString(in_memory, path, password); _create_and_detect_schema = create_schema; ConnectionOwner = false; }
/// <summary> /// Creates the existence feature. /// </summary> /// <param name="filter"></param> /// <param name="meta"></param> public static void Create(Filter filter, IDictionary<string, IList<string>> meta) { _instance = new MunicipalityFeature(filter, meta); }
/// <summary> /// Creates a new existence feature. /// </summary> /// <param name="filter"></param> /// <param name="meta"></param> private MunicipalityFeature(Filter filter, IDictionary<string, IList<string>> meta) : base("Map.ExistenceFeature.AdministrativeFeature.PlaceFeature.MunicipalityFeature", filter, meta) { }
/// <summary> /// Creates the existence feature. /// </summary> /// <param name="filter"></param> /// <param name="meta"></param> public static void Create(Filter filter, IDictionary<string, IList<string>> meta) { _instance = new PublicTransportFeature(filter, meta); }
/// <summary> /// Creates a new existence feature. /// </summary> /// <param name="filter"></param> /// <param name="meta"></param> private PublicTransportFeature(Filter filter, IDictionary<string, IList<string>> meta) : base("Map.ExistenceFeature.PhysicalFeature.LandFeature.ManMadeFeature.PublicTransportFeature", filter, meta) { }
/// <summary> /// Returns all objects inside the given boundingbox and according to the given filter. /// </summary> /// <param name="box"></param> /// <param name="filter"></param> /// <returns></returns> public abstract IList<OsmGeo> Get(GeoCoordinateBox box, Filter filter);
/// <summary> /// Returns all the objects in this dataset that evaluate the filter to true. /// </summary> /// <param name="box"></param> /// <param name="filter"></param> /// <returns></returns> public OsmGeoCollection GetCollection(GeoCoordinateBox box, Filter filter) { var geos = Get(box, filter); var collection = new OsmGeoCollection(); foreach (var geo in geos) { if (geo.Type == OsmGeoType.Node) { var node = geo as Node; collection.Nodes.Add(node.Id.Value, node); } else if (geo.Type == OsmGeoType.Way) { var way = geo as Way; collection.Ways.Add(way.Id.Value, way); } else if (geo.Type == OsmGeoType.Relation) { var relation = geo as Relation; if (!collection.Relations.ContainsKey(relation.Id.Value)) { collection.Relations.Add(relation.Id.Value, relation); } } } return collection; }
/// <summary> /// Creates a new existence feature. /// </summary> /// <param name="filter"></param> /// <param name="meta"></param> private SuburbFeature(Filter filter, IDictionary<string, IList<string>> meta) : base("Map.ExistenceFeature.AdministrativeFeature.PlaceFeature.SuburbFeature", filter, meta) { }
/// <summary> /// Creates a new combined filter. /// </summary> /// <param name="filter1"></param> /// <param name="op"></param> /// <param name="filter2"></param> public FilterCombined(Filter filter1, FilterCombineOperatorEnum op, Filter filter2) { _op = op; _filter1 = filter1; _filter2 = filter2; }
/// <summary> /// Creates a new existence feature. /// </summary> /// <param name="filter"></param> /// <param name="meta"></param> private BorderFeature(Filter filter, IDictionary<string, IList<string>> meta) : base("Map.ExistenceFeature.AdministrativeFeature.BorderFeature", filter, meta) { }
/// <summary> /// Creates a new existence feature. /// </summary> /// <param name="filter"></param> /// <param name="meta"></param> private ArtificialWayFeature(Filter filter, IDictionary<string, IList<string>> meta) : base("Map.ExistenceFeature.PhysicalFeature.ArtificialWayFeature", filter, meta) { }
/// <summary> /// Creates a new SQLite target /// </summary> /// <param name="connection_string">The SQLite connection string to use</param> /// <param name="create_schema">Should we detect if the db tables exist and attempt to create them?</param> /// <param name="geo_filter">The geos filter to be used</param> /// <param name="tag_filter">The tags filter to be used</param> public SQLiteOsmStreamTarget(string connection_string, bool create_schema = false, Filter geo_filter = null, TagFilter tag_filter = null) { if (geo_filter == null) { geo_filter = Filter.Any(); } _geo_filter = geo_filter; if (tag_filter == null) { tag_filter = TagFilter.Any(); } _tag_filter = tag_filter; _connection_string = connection_string; _create_and_detect_schema = create_schema; ConnectionOwner = false; }
/// <summary> /// Creates the existence feature. /// </summary> /// <param name="filter"></param> /// <param name="meta"></param> public static void Create(Filter filter, IDictionary<string, IList<string>> meta) { _instance = new ArtificialWayFeature(filter, meta); }
/// <summary> /// Returns all the objects within a given bounding box and filtered by a given filter. /// </summary> /// <param name="box"></param> /// <param name="filter"></param> /// <returns></returns> public IList<OsmGeo> Get(GeoCoordinateBox box, Filter filter) { return new List<OsmGeo>(); }
/// <summary> /// Creates a new existence feature. /// </summary> /// <param name="filter"></param> /// <param name="meta"></param> private PlaceOfWorshipFeature(Filter filter, IDictionary<string, IList<string>> meta) : base("Map.ExistenceFeature.PhysicalFeature.LandFeature.ManMadeFeature.PlaceOfWorshipFeature", filter, meta) { }
/// <summary> /// Returns all objects with the given bounding box and valid for the given filter; /// </summary> /// <param name="box"></param> /// <param name="filter"></param> /// <returns></returns> public override IList<OsmGeo> Get(GeoCoordinateBox box, Filter filter) { // initialize connection. OracleConnection con = this.CreateConnection(); List<OsmGeo> res = new List<OsmGeo>(); // calculate bounding box parameters to query db. long latitudeMin = (long)(box.MinLat * 10000000.0); long longitudeMin = (long)(box.MinLon * 10000000.0); long latitudeMax = (long)(box.MaxLat * 10000000.0); long longitudeMax = (long)(box.MaxLon * 10000000.0); IList<long> boxes = new List<long>(); TileRange tileRange = TileRange.CreateAroundBoundingBox(box, 14); foreach (Tile tile in tileRange) { boxes.Add((long)tile.Id); } // STEP 1: query nodes table. //id latitude longitude changeset_id visible timestamp tile version //string sql // = "SELECT node.id, node.latitude, node.longitude, node.changeset_id, node.timestamp, node.version, " + // "node.usr, node.usr_id, node.visible FROM node WHERE (tile IN ({4})) AND (visible = 1) AND (latitude BETWEEN {0} AND {1} AND longitude BETWEEN {2} AND {3})"; // remove this nasty BETWEEN operation because it depends on the database (!) what results are returned (including or excluding bounds!!!) string sql = "SELECT id, latitude, longitude, changeset_id, visible, timestamp, tile, version, usr, usr_id " + "FROM node WHERE (tile IN ({4})) AND (visible = 1) AND (latitude >= {0} AND latitude < {1} AND longitude >= {2} AND longitude < {3})"; sql = string.Format(sql, latitudeMin.ToString(System.Globalization.CultureInfo.InvariantCulture), latitudeMax.ToString(System.Globalization.CultureInfo.InvariantCulture), longitudeMin.ToString(System.Globalization.CultureInfo.InvariantCulture), longitudeMax.ToString(System.Globalization.CultureInfo.InvariantCulture), this.ConstructIdList(boxes)); // TODO: parameters. var com = new OracleCommand(sql); com.Connection = con; OracleDataReader reader = com.ExecuteReader(); Node node = null; var nodes = new Dictionary<long, Node>(); var nodeIds = new List<long>(); while (reader.Read()) { // load/parse data. long returned_id = reader.GetInt64(0); int latitude_int = reader.GetInt32(1); int longitude_int = reader.GetInt32(2); long? changeset_id = reader.IsDBNull(3) ? null : (long?)reader.GetInt64(3); bool? visible = reader.IsDBNull(4) ? null : (bool?)(reader.GetInt32(4) == 1); DateTime? timestamp = reader.IsDBNull(5) ? null : (DateTime?)reader.GetDateTime(5); long tile = reader.GetInt64(6); ulong? version = reader.IsDBNull(7) ? null : (ulong?)(ulong)reader.GetInt64(7); string usr = reader.IsDBNull(8) ? null : reader.GetString(8); long? usr_id = reader.IsDBNull(9) ? null : (long?)reader.GetInt64(9); if (!nodes.ContainsKey(returned_id)) { // create node. node = new Node(); node.Id = returned_id; node.Version = version; node.UserId = usr_id; node.TimeStamp = timestamp; node.ChangeSetId = changeset_id; node.Visible = visible; node.Latitude = ((double)latitude_int) / 10000000.0; node.Longitude = ((double)longitude_int) / 10000000.0; node.UserName = usr; nodeIds.Add(node.Id.Value); nodes.Add(node.Id.Value, node); } } reader.Close(); // STEP2: Load all node tags. this.LoadNodeTags(nodes); res.AddRange(nodes.Values); // load all ways that contain the nodes that have been found. res.AddRange(this.GetWaysFor(nodeIds)); // get relations containing any of the nodes or ways in the current results-list. List<Relation> relations = new List<Relation>(); HashSet<long> relationIds = new HashSet<long>(); foreach (OsmGeo osmGeo in res) { IList<Relation> relationsFor = this.GetRelationsFor(osmGeo); foreach (Relation relation in relationsFor) { if (!relationIds.Contains(relation.Id.Value)) { relations.Add(relation); relationIds.Add(relation.Id.Value); } } } // recursively add all relations containing other relations as a member. do { res.AddRange(relations); // add previous relations-list. List<Relation> newRelations = new List<Relation>(); foreach (OsmGeo osmGeo in relations) { IList<Relation> relationsFor = this.GetRelationsFor(osmGeo); foreach (Relation relation in relationsFor) { if (!relationIds.Contains(relation.Id.Value)) { newRelations.Add(relation); relationIds.Add(relation.Id.Value); } } } relations = newRelations; } while (relations.Count > 0); if (filter != null) { List<OsmGeo> filtered = new List<OsmGeo>(); foreach (OsmGeo geo in res) { if (filter.Evaluate(geo)) { filtered.Add(geo); } } } return res; }
/// <summary> /// Creates the existence feature. /// </summary> /// <param name="filter"></param> /// <param name="meta"></param> public static void Create(Filter filter, IDictionary<string, IList<string>> meta) { _instance = new PlaceOfWorshipFeature(filter, meta); }
/// <summary> /// Creates a new existence feature. /// </summary> /// <param name="filter"></param> /// <param name="meta"></param> private ExistenceFeature(Filter filter, IDictionary<string, IList<string>> meta) : base("Map.ExistenceFeature",filter,meta) { }
/// <summary> /// Returns all objects in the given bounding box that are valid according to the given filter. /// </summary> /// <param name="box"></param> /// <param name="filter"></param> /// <returns></returns> public IList<OsmGeo> Get(GeoCoordinateBox box, Filter filter) { // initialize connection. OracleConnection con = this.CreateConnection(); List<OsmGeo> base_list = new List<OsmGeo>(); // calculate bounding box parameters to query db. long latitude_min = (long)(box.MinLat * 10000000.0); long longitude_min = (long)(box.MinLon * 10000000.0); long latitude_max = (long)(box.MaxLat * 10000000.0); long longitude_max = (long)(box.MaxLon * 10000000.0); // TODO: improve this to allow loading of bigger bb's. uint x_min = lon2x(box.MinLon); uint x_max = lon2x(box.MaxLon); uint y_min = lat2y(box.MinLat); uint y_max = lat2y(box.MaxLat); IList<long> boxes = new List<long>(); for (uint x = x_min; x <= x_max; x++) { for (uint y = y_min; y <= y_max; y++) { boxes.Add(this.xy2tile(x, y)); } } // STEP 1: query nodes table. //id latitude longitude changeset_id visible timestamp tile version string sql = "SELECT * FROM node WHERE (visible = 1) AND (tile IN ({4})) AND (latitude BETWEEN {0} AND {1} AND longitude BETWEEN {2} AND {3})"; sql = string.Format(sql, latitude_min.ToString(), latitude_max.ToString(), longitude_min.ToString(), longitude_max.ToString(), this.ConstructIdList(boxes)); // TODO: parameters. OracleCommand com = new OracleCommand(sql); com.Connection = con; OracleDataReader reader = com.ExecuteReader(); Node node = null; Dictionary<long, Node> nodes = new Dictionary<long, Node>(); List<long> node_ids = new List<long>(); while (reader.Read()) { // load/parse data. long returned_id = reader.GetInt64(0); int latitude_int = reader.GetInt32(1); int longitude_int = reader.GetInt32(2); long changeset_id = reader.GetInt64(3); bool visible = reader.GetInt64(4)==1; DateTime timestamp = reader.GetDateTime(5); long tile = reader.GetInt64(6); long version = reader.GetInt64(7); // create node. node = OsmBaseFactory.CreateNode(returned_id); node.Version = version; //node.UserId = user_id; node.TimeStamp = timestamp; node.ChangeSetId = changeset_id; node.Coordinate = new GeoCoordinate( ((double)latitude_int) / 10000000.0, ((double)longitude_int) / 10000000.0); nodes.Add(node.Id,node); node_ids.Add(node.Id); } reader.Close(); // STEP2: Load all node tags. this.LoadNodeTags(nodes); // STEP3: Load all ways for the given nodes. IList<Way> ways = this.GetWaysForNodes(nodes); // Add all objects to the base list. foreach (Node node_result in nodes.Values.ToList<Node>()) { base_list.Add(node_result); } foreach (Way way in ways) { base_list.Add(way); } return base_list; }
/// <summary> /// Returns the objects that evaluate the filter to true. /// </summary> /// <param name="filter"></param> /// <returns></returns> public IList<OsmBase> Get(Filter filter) { this.ReadFromDocument(); IList<OsmBase> res = new List<OsmBase>(); foreach (Node node in _nodes.Values) { if (filter.Evaluate(node)) { res.Add(node); } } foreach (Way way in _ways.Values) { if (filter.Evaluate(way)) { res.Add(way); } } foreach (Relation relation in _relations.Values) { if (filter.Evaluate(relation)) { res.Add(relation); } } return res; }
/// <summary> /// Creates a new existence feature. /// </summary> /// <param name="filter"></param> /// <param name="meta"></param> private UtilitiesFeature(Filter filter, IDictionary<string, IList<string>> meta) : base("Map.ExistenceFeature.PhysicalFeature.LandFeature.ManMadeFeature.UtilitiesFeature", filter, meta) { }
/// <summary> /// Returns all data in the given bounding box. /// </summary> /// <param name="box"></param> /// <param name="filter"></param> /// <returns></returns> public override IList<OsmGeo> Get(GeoCoordinateBox box, Filter filter) { IList<OsmGeo> objects = _source.Get(box, filter); foreach (OsmGeo osmGeo in objects) { switch(osmGeo.Type) { case OsmGeoType.Node: _nodesCache.Add(osmGeo.Id.Value, osmGeo as Node); break; case OsmGeoType.Way: _waysCache.Add(osmGeo.Id.Value, osmGeo as Way); break; case OsmGeoType.Relation: _relationsCache.Add(osmGeo.Id.Value, osmGeo as Relation); break; } } return objects; }
/// <summary> /// Gets all geometries in the tile /// </summary> /// <param name="tile">The tile to fetch geometries from</param> /// <param name="filter">Filtering options for the results</param> /// <returns>Matching OsmGeos</returns> public IList<OsmGeo> Get(Tile tile, Filter filter) { var tiles = new List<Tile>(); tiles.Add(tile); return Get(tiles, filter); }