/// <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);
}
