/// <summary>
/// Returns the way for the given id.
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public override Way GetWay(long id)
{
string wayKey = PrimitiveExtensions.BuildWayRedisKey(id);
RedisWay redisWay = _clientWay.GetValue(wayKey);
Way way = null;
if (redisWay != null)
{
way = PrimitiveExtensions.ConvertFrom(redisWay);
}
return(way);
}
/// <summary>
/// Returns the relation with the given id.
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public override Relation GetRelation(long id)
{
string relationKey = PrimitiveExtensions.BuildRelationRedisKey(id);
RedisRelation redisRelation = _clientRelation.GetValue(relationKey);
Relation relation = null;
if (redisRelation != null)
{
relation = PrimitiveExtensions.ConvertFrom(redisRelation);
}
return(relation);
}
/// <summary>
/// Returns the node for the given id.
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public override Node GetNode(long id)
{
string nodeKey = PrimitiveExtensions.BuildNodeRedisKey(id);
RedisNode redisNode = _clientNode.GetValue(nodeKey);
Node node = null;
if (redisNode != null)
{
node = PrimitiveExtensions.ConvertFrom(redisNode);
}
return(node);
}
/// <summary>
/// Converts the given relation to a redis relation.
/// </summary>
/// <param name="relation"></param>
/// <returns></returns>
public static RedisRelation ConvertTo(Relation relation)
{
RedisRelation redisWay = new RedisRelation();
redisWay.Id = relation.Id.Value;
redisWay.ChangeSetId = relation.ChangeSetId;
redisWay.TimeStamp = relation.TimeStamp;
redisWay.UserId = relation.UserId;
redisWay.UserName = relation.UserName;
redisWay.Version = relation.Version;
redisWay.Visible = relation.Visible;
redisWay.Tags = PrimitiveExtensions.ConvertTo(relation.Tags);
redisWay.Members = PrimitiveExtensions.ConvertTo(relation.Members);
return(redisWay);
}
/// <summary>
/// Converts the given node from a redis node.
/// </summary>
/// <param name="redisNode"></param>
/// <returns></returns>
public static Node ConvertFrom(RedisNode redisNode)
{
Node node = new Node();
node.Id = redisNode.Id.Value;
node.Latitude = redisNode.Latitude.Value;
node.Longitude = redisNode.Longitude.Value;
node.ChangeSetId = redisNode.ChangeSetId;
node.TimeStamp = redisNode.TimeStamp;
node.UserId = redisNode.UserId;
node.UserName = redisNode.UserName;
node.Version = redisNode.Version;
node.Visible = redisNode.Visible;
node.Tags = PrimitiveExtensions.ConvertFrom(redisNode.Tags);
return(node);
}
/// <summary>
/// Converts the given node to a redis node.
/// </summary>
/// <param name="node"></param>
/// <returns></returns>
public static RedisNode ConvertTo(Node node)
{
RedisNode redisNode = new RedisNode();
redisNode.Id = node.Id.Value;
redisNode.Latitude = node.Latitude.Value;
redisNode.Longitude = node.Longitude.Value;
redisNode.ChangeSetId = node.ChangeSetId;
redisNode.TimeStamp = node.TimeStamp;
redisNode.UserId = node.UserId;
redisNode.UserName = node.UserName;
redisNode.Version = node.Version;
redisNode.Visible = node.Visible;
redisNode.Tags = PrimitiveExtensions.ConvertTo(node.Tags);
return(redisNode);
}
/// <summary>
/// Returns all ways containing the given node.
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public override IList <Way> GetWaysFor(long id)
{
string listKey = PrimitiveExtensions.BuildNodeWayListRedisKey(id);
HashSet <string> wayIdStrings = _client.GetAllItemsFromSet(listKey);
List <long> wayIds = new List <long>();
if (wayIdStrings != null)
{
foreach (string wayIdString in wayIdStrings)
{
wayIds.Add(long.Parse(wayIdString, System.Globalization.NumberStyles.Any, System.Globalization.CultureInfo.InvariantCulture));
}
}
return(this.GetWays(wayIds));
}
/// <summary>
/// Returns all relations containing the given object.
/// </summary>
/// <param name="type"></param>
/// <param name="id"></param>
/// <returns></returns>
public override IList <Relation> GetRelationsFor(OsmGeoType type, long id)
{
string listKey = PrimitiveExtensions.BuildMemberRelationListRedisKey(type, id);
HashSet <string> relationIdStrings = _client.GetAllItemsFromSet(listKey);
List <long> relationIds = new List <long>();
if (relationIdStrings != null)
{
foreach (string relationIdString in relationIdStrings)
{
relationIds.Add(long.Parse(relationIdString, System.Globalization.NumberStyles.Any, System.Globalization.CultureInfo.InvariantCulture));
}
}
return(this.GetRelations(relationIds));
}
/// <summary>
/// Converts the given way to a redis way.
/// </summary>
/// <param name="way"></param>
/// <returns></returns>
public static RedisWay ConvertTo(Way way)
{
RedisWay redisWay = new RedisWay();
redisWay.Id = way.Id.Value;
redisWay.ChangeSetId = way.ChangeSetId;
redisWay.TimeStamp = way.TimeStamp;
redisWay.UserId = way.UserId;
redisWay.UserName = way.UserName;
redisWay.Version = way.Version;
redisWay.Visible = way.Visible;
redisWay.Tags = PrimitiveExtensions.ConvertTo(way.Tags);
if (way.Nodes != null)
{
redisWay.Nodes = new List <long>(way.Nodes);
}
return(redisWay);
}
/// <summary>
/// Converts the given way from a redis way.
/// </summary>
/// <param name="redisWay"></param>
/// <returns></returns>
public static Way ConvertFrom(RedisWay redisWay)
{
Way way = new Way();
way.Id = redisWay.Id.Value;
way.ChangeSetId = redisWay.ChangeSetId;
way.TimeStamp = redisWay.TimeStamp;
way.UserId = redisWay.UserId;
way.UserName = redisWay.UserName;
way.Version = redisWay.Version;
way.Visible = redisWay.Visible;
way.Tags = PrimitiveExtensions.ConvertFrom(redisWay.Tags);
if (redisWay.Nodes != null)
{
way.Nodes = new List <long>(redisWay.Nodes);
}
return(way);
}
/// <summary>
/// Returns all the nodes with the given ids.
/// </summary>
/// <param name="ids"></param>
/// <returns></returns>
public override IList <Node> GetNodes(IList <long> ids)
{
List <string> keys = new List <string>();
foreach (int id in ids)
{
string nodeKey = PrimitiveExtensions.BuildNodeRedisKey(id);
keys.Add(nodeKey);
}
List <RedisNode> redisNodes = _clientNode.GetValues(keys);
List <Node> nodes = new List <Node>();
foreach (RedisNode redisNode in redisNodes)
{
Node node = PrimitiveExtensions.ConvertFrom(redisNode);
nodes.Add(node);
}
return(nodes);
}
/// <summary>
/// Returns all ways for the given ids.
/// </summary>
/// <param name="ids"></param>
/// <returns></returns>
public override IList <Way> GetWays(IList <long> ids)
{
List <string> keys = new List <string>();
foreach (int id in ids)
{
string wayKey = PrimitiveExtensions.BuildWayRedisKey(id);
keys.Add(wayKey);
}
List <RedisWay> redisWays = _clientWay.GetValues(keys);
List <Way> ways = new List <Way>();
foreach (RedisWay redisWay in redisWays)
{
Way way = PrimitiveExtensions.ConvertFrom(redisWay);
ways.Add(way);
}
return(ways);
}
/// <summary>
/// Returns all relations for the given ids.
/// </summary>
/// <param name="ids"></param>
/// <returns></returns>
public override IList <Relation> GetRelations(IList <long> ids)
{
List <string> keys = new List <string>();
foreach (int id in ids)
{
string relationKey = PrimitiveExtensions.BuildRelationRedisKey(id);
keys.Add(relationKey);
}
List <RedisRelation> redisRelations = _clientRelation.GetValues(keys);
List <Relation> relations = new List <Relation>();
foreach (RedisRelation redisRelation in redisRelations)
{
Relation relation = PrimitiveExtensions.ConvertFrom(redisRelation);
relations.Add(relation);
}
return(relations);
}
/// <summary>
/// Builds a redis key for the relation members relation list.
/// </summary>
/// <param name="member"></param>
/// <returns></returns>
public static string BuildMemberRelationListRedisKey(RelationMember member)
{
return(PrimitiveExtensions.BuildMemberRelationListRedisKey(member.MemberType.Value, member.MemberId.Value));
}
/// <summary>
/// Builds a redis key for this given relation.
/// </summary>
/// <param name="relation"></param>
/// <returns></returns>
public static string GetRedisKey(this Relation relation)
{
return(PrimitiveExtensions.BuildRelationRedisKey(relation.Id.Value));
}
/// <summary>
/// Builds a redis key for this given way.
/// </summary>
/// <param name="way"></param>
/// <returns></returns>
public static string GetRedisKey(this Way way)
{
return(PrimitiveExtensions.BuildWayRedisKey(way.Id.Value));
}
/// <summary>
/// Builds a redis key for this given node.
/// </summary>
/// <param name="node"></param>
/// <returns></returns>
public static string GetRedisKey(this Node node)
{
return(PrimitiveExtensions.BuildNodeRedisKey(node.Id.Value));
}
/// <summary>
/// Returns all objects in the given bounding box and that pass the given filter.
/// </summary>
/// <param name="box"></param>
/// <param name="filter"></param>
/// <returns></returns>
public override IList <OsmGeo> Get(GeoCoordinateBox box, OsmSharp.Osm.Filters.Filter filter)
{
List <OsmGeo> res = new List <OsmGeo>();
// create a range or tiles around the given bounding box.
TileRange range = TileRange.CreateAroundBoundingBox(box, 14);
// build all redis keys for the given boxes.
var hashKeys = new List <string>();
foreach (Tile tile in range)
{
hashKeys.Add(tile.Id.ToString());
}
byte[][] box_members = _client.SUnion(hashKeys.ToArray());
HashSet <string> nodeKeys = new HashSet <string>();
foreach (byte[] box_member in box_members)
{
long node_id = BitConverter.ToInt64(box_member, 0);
string node_key = PrimitiveExtensions.BuildNodeRedisKey(node_id);
nodeKeys.Add(node_key);
}
List <RedisNode> redisNodes = _clientNode.GetValues(new List <string>(nodeKeys));
var nodeIds = new List <long>();
foreach (RedisNode redisNode in redisNodes)
{
// test if the node is in the given bb.
GeoCoordinate coordinate = new GeoCoordinate(redisNode.Latitude.Value, redisNode.Longitude.Value);
if (box.IsInside(coordinate))
{
res.Add(PrimitiveExtensions.ConvertFrom(redisNode));
nodeIds.Add(redisNode.Id.Value);
}
}
// 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);
}
