/// <summary>
/// On way found.
/// </summary>
/// <param name="way">Way.</param>
/// <param name="rawData">Raw data.</param>
/// <param name="infos">Infos.</param>
protected void OnWayFound(OSMWay way, byte[] rawData, ElementDebugInfos infos)
{
if (this.FoundWayRaw != null)
{
this.FoundWayRaw(way, rawData, infos);
}
}
public static void CreateBuilding(OSMWay way, OSMapInfo mapInfo, Material material)
{
// Create an instance of the object and place it in the centre of its points
GameObject go = new GameObject();
Vector3 localOrigin = GetCenter(way, mapInfo);
go.transform.position = localOrigin - mapInfo.Bounds.Center;
// Add the mesh filter and renderer components to the object
MeshFilter mf = go.AddComponent <MeshFilter>();
MeshRenderer mr = go.AddComponent <MeshRenderer>();
// Apply the material
mr.material = material;
// Create the collections for the object's vertices, indices, UVs etc.
List <Vector3> vectors = new List <Vector3>();
List <Vector3> normals = new List <Vector3>();
List <Vector2> uvs = new List <Vector2>();
List <int> indices = new List <int>();
// Call the child class' object creation code
OnObjectCreated(mapInfo, way, localOrigin, vectors, normals, uvs, indices);
// Apply the data to the mesh
mf.mesh.vertices = vectors.ToArray();
mf.mesh.normals = normals.ToArray();
mf.mesh.triangles = indices.ToArray();
mf.mesh.uv = uvs.ToArray();
}
public static void SaveCandidateIncomingConnections(CandidatePoint candidate, string filename)
{
int counter = -1;
OSMDB result = new OSMDB();
OSMNode osmCandidate = new OSMNode(counter--, candidate.MapPoint.Latitude, candidate.MapPoint.Longitude);
osmCandidate.Tags.Add(new OSMTag("observation", candidate.ObservationProbability.ToString()));
osmCandidate.Tags.Add(new OSMTag("time", candidate.Layer.TrackPoint.Time.ToString()));
result.Nodes.Add(osmCandidate);
foreach (var connection in candidate.IncomingConnections)
{
OSMNode from = new OSMNode(counter--, connection.From.MapPoint.Latitude, connection.From.MapPoint.Longitude);
from.Tags.Add(new OSMTag("observation", connection.From.ObservationProbability.ToString()));
from.Tags.Add(new OSMTag("time", connection.From.Layer.TrackPoint.Time.ToString()));
result.Nodes.Add(from);
OSMWay osmConnection = new OSMWay(counter--, new long[] { from.ID, osmCandidate.ID });
osmConnection.Tags.Add(new OSMTag("transmission", connection.TransmissionProbability.ToString()));
result.Ways.Add(osmConnection);
}
result.Save(filename);
}
/// <summary>
/// On way found.
/// </summary>
/// <param name="way">Way.</param>
protected void OnWayFound(OSMWay way)
{
if (this.FoundWay != null)
{
this.FoundWay(way);
}
}
public Bridge(Intersection from, Intersection to, OSMWay way, OSMData osm)
{
this.from = from;
this.to = to;
this.way = way;
//this.osm = osm;
//Calculate pathway for street
//Polyline pathway = new Polyline();
//OSMNode node;
//foreach (long nodeId in way.GetWayNodesFromTo(from, to))
//{
// if (osm.nodes.TryGetValue(nodeId, out node))
// {
// pathway.Add(new Vertex(node + Vector3.up * 0.1f));
// }
//}
//pathway = pathway.InterpolateHeights();
//this.street = new Street(from, to, way, osm, pathway);
this.street = new Street(from, to, way, osm);
}
public OSMData(string osmXMLpath)
{
XmlTextReader xmlReader = new XmlTextReader(osmXMLpath);
xmlReader.MoveToContent();
while (xmlReader.Read())
{
if (xmlReader.NodeType.Equals(XmlNodeType.Element))
{
switch (xmlReader.LocalName)
{
case "node":
OSMNode n = ParseOSMNode(xmlReader);
nodes.Add(n.Id, n);
break;
case "way":
OSMWay way = ParseOSMWay(xmlReader);
ways.Add(way.Id, way);
break;
case "relation":
OSMRelation relation = ParseOSMRelation(xmlReader);
relations.Add(relation.Id, relation);
break;
default:
//ignore other nodes
break;
}
}
}
UnityEngine.Debug.Log("New OSMDATA: " + nodes.Count + " Nodes " + ways.Count + " Ways " + relations.Count + " Relations");
Console.AddMessage("New OSMDATA: " + nodes.Count + " Nodes " + ways.Count + " Ways " + relations.Count + " Relations");
}
/// <summary>
/// Creates a new instance of OSMRoute based on specific OSMWay
/// </summary>
/// <param name="way">The way that defines geomery and tags</param>
/// <param name="roadType">The RoadType of this OSMRoute</param>
public OSMRoad(OSMWay way, RoadType roadType) : base(way.ID)
{
_tags = way.Tags;
_nodes = new List <long>(way.Nodes);
RoadType = roadType;
Speed = RoadType.Speed;
if (Tags.ContainsTag("maxspeed"))
{
string[] chunks = Tags["maxspeed"].Value.Split(' ');
double numericSpeed = 0;
if (double.TryParse(chunks[0], out numericSpeed))
{
if (chunks.Length == 2 && chunks[1] == "mph")
{
Speed = numericSpeed * MphConversionFactor;
}
else
{
Speed = numericSpeed;
}
}
}
}
public CarriageWay(OSMWay way)
{
if (way.Tags["highway"] == "path" ||
way.Tags["highway"] == "footway" ||
way.Tags["highway"] == "pedestrian"
)
{
streetMember.Add(new PathStreetMember());
}
else
{
if (way.Tags.ContainsKey("lanes"))
{
int lanes;
if (int.TryParse(way.Tags["lanes"], out lanes))
{
createCarLanes(lanes);
}
}
else
{
createCarLanes(1);
}
//Gutter
streetMember.Add(new Gutter());
bool createFoot = false;
bool createBike = false;
if (way.Tags.ContainsKey("foot"))
{
if (way.Tags["foot"] == "yes" || way.Tags["foot"] == "designated" || way.Tags["foot"] == "1" || way.Tags["foot"] == "true")
{
createFoot = true;
}
}
if (way.Tags.ContainsKey("bicycle"))
{
if (way.Tags["bicycle"] == "yes" || way.Tags["bicycle"] == "designated" || way.Tags["bicycle"] == "1" || way.Tags["bicycle"] == "true")
{
createBike = true;
}
}
if (createFoot || createBike)
{
streetMember.Add(new Curb());
}
if (createBike)
{
streetMember.Add(new BikeLane());
}
if (createFoot)
{
streetMember.Add(new WalkWay());
}
}
}
void GetWays(XmlNodeList wayNodes)
{
foreach (XmlNode wayNode in wayNodes)
{
OSMWay way = new OSMWay(wayNode);
ways.Add(way);
}
}
//void Update()
//{
// foreach (OSMWay w in ways)
// {
// if (w.Visible)
// {
// Color c = Color.cyan; // cyan for building
// if (!w.isBoundary)
// {
// c = Color.red; // red for roads
// }
// for (int i = 1; i < w.NodeIDs.Count; i++)
// {
// OSMNode p1 = nodes[w.NodeIDs[i - 1]];
// OSMNode p2 = nodes[w.NodeIDs[i]];
// Vector3 v1 = p1 - bounds.Center;
// Vector3 v2 = p2 - bounds.Center;
// Debug.DrawLine(v1, v2, c);
// }
// }
// }
//}
void GetWays(XmlNodeList xmlNodeList)
{
foreach (XmlNode node in xmlNodeList)
{
OSMWay way = new OSMWay(node);
ways.Add(way);
}
}
public static bool TryCreateFromOSM(OSMWay way, Tile tile)
{
if (way.Tags.ContainsKey("building"))
{
Buildings.Add(new Building(way, tile.Query.OSM), tile);
return(true);
}
return(false);
}
private static void OnObjectCreated(OSMapInfo mapInfo, OSMWay way, Vector3 origin, List <Vector3> vectors, List <Vector3> normals, List <Vector2> uvs, List <int> indices)
{
for (int i = 1; i < way.NodeIDs.Count; i++)
{
OSMNode p1 = mapInfo.Nodes[way.NodeIDs[i - 1]];
OSMNode p2 = mapInfo.Nodes[way.NodeIDs[i]];
Vector3 s1 = p1 - origin;
Vector3 s2 = p2 - origin;
Vector3 diff = (s2 - s1).normalized;
// elongate the road a little bit
s1 -= diff;
s2 += diff;
// https://en.wikipedia.org/wiki/Lane
// According to the article, it's 3.7m in Canada
var cross = Vector3.Cross(diff, Vector3.up) * 3.7f * way.Lanes;
// Create points that represent the width of the road
Vector3 v1 = s1 + cross;
Vector3 v2 = s1 - cross;
Vector3 v3 = s2 + cross;
Vector3 v4 = s2 - cross;
vectors.Add(v1);
vectors.Add(v2);
vectors.Add(v3);
vectors.Add(v4);
uvs.Add(new Vector2(0, 0));
uvs.Add(new Vector2(1, 0));
uvs.Add(new Vector2(0, 1));
uvs.Add(new Vector2(1, 1));
normals.Add(Vector3.up);
normals.Add(Vector3.up);
normals.Add(Vector3.up);
normals.Add(Vector3.up);
int idx1, idx2, idx3, idx4;
idx4 = vectors.Count - 1;
idx3 = vectors.Count - 2;
idx2 = vectors.Count - 3;
idx1 = vectors.Count - 4;
// first triangle v1, v3, v2
indices.Add(idx1);
indices.Add(idx3);
indices.Add(idx2);
// second v3, v4, v2
indices.Add(idx3);
indices.Add(idx4);
indices.Add(idx2);
}
}
/// <summary>
/// Raises the WayRead event
/// </summary>
/// <param name="node">The OSMWay read from the database</param>
protected void OnWayRead(OSMWay way)
{
OSMWayReadHandler temp = WayRead;
if (temp != null)
{
temp(way);
}
}
public void AddWay(OSMWay way)
{
if (way != null)
{
if (!ways.Keys.Contains(way.Id))
{
ways.Add(way.Id, way);
}
}
}
public OSMWay(OSMWay copy)
{
this.wayId = copy.wayId;
this.roadType = copy.roadType;
this.streetName = copy.streetName;
this.tigerCfcc = copy.tigerCfcc;
this.tigerCounty = copy.tigerCounty;
this.tigerNameBase = copy.tigerNameBase;
this.tigerNameDirectionSuffix = copy.tigerNameDirectionSuffix;
this.closedShape = copy.closedShape;
}
/// <summary>
/// Get length of the OSMWay in meters
/// </summary>
/// <param name="way"></param>
/// <param name="db"></param>
/// <returns></returns>
static double GetLength(OSMWay way, OSMDB db)
{
double result = 0;
for (int i = 0; i < way.Nodes.Count - 1; i++)
{
result += LK.GeoUtils.Calculations.GetDistance2D(db.Nodes[way.Nodes[i]], db.Nodes[way.Nodes[i + 1]]);
}
return(result);
}
public Vector3 GetCenter(OSMWay way)
{
Vector3 total = Vector3.zero;
foreach (var id in way.NodeIDs)
{
total += map.nodes[id];
}
return(total / way.NodeIDs.Count);
}
private static Vector3 GetCenter(OSMWay way, OSMapInfo mapInfo)
{
Vector3 total = Vector3.zero;
foreach (ulong nodeID in way.NodeIDs)
{
total += mapInfo.Nodes[nodeID];
}
return(total / way.NodeIDs.Count);
}
private static Vector3 CalcWayCenter(OSMapInfo mapInfo, OSMWay pSpace)
{
Vector3 wayCenter = new Vector3();
foreach (ulong nodeId in pSpace.NodeIDs)
{
wayCenter += mapInfo.Nodes[nodeId].WorldCoord;
}
wayCenter /= pSpace.NodeIDs.Count;
return(wayCenter);
}
/// <summary>
/// Exctract nodes from the way and adds them into UsedNodes list
/// </summary>
/// <param name="way"></param>
void ExtractUsedNodes(OSMWay way)
{
foreach (long nodeID in way.Nodes)
{
if (_usedNodes.ContainsKey(nodeID) == false)
{
_usedNodes.Add(nodeID, new List <long>());
}
_usedNodes[nodeID].Add(way.ID);
}
}
public static bool TryCreateFromOSM(OSMWay way, Tile tile)
{
if (way.Tags.ContainsKey("natural"))
{
if (way.Tags["natural"] == "water")
{
waters.Add(new Water(way, tile.Query.OSM), tile);
return(true);
}
}
return(false);
}
/// <summary>
/// Saves path to the OSMDB
/// </summary>
/// <param name="path">The list of polylines that represent matched path</param>
/// <returns>OSMDB with path converted to the OSM format</returns>
public OSMDB SaveToOSM(IList <Polyline <IPointGeo> > path)
{
_db = new OSMDB();
_dbCounter = -1;
IPointGeo lastPoint = null;
OSMNode node = null;
foreach (var line in path)
{
if (line.Nodes.Count == 0)
{
continue;
}
if (line.Nodes.Count == 1)
{
throw new Exception();
}
OSMWay way = new OSMWay(_dbCounter--);
way.Tags.Add(new OSMTag("way-id", ((PolylineID)line).WayID.ToString()));
way.Tags.Add(new OSMTag("order", (_db.Ways.Count + 1).ToString()));
_db.Ways.Add(way);
foreach (var point in line.Nodes)
{
if (point != lastPoint)
{
lastPoint = point;
PointEx pt = (PointEx)point;
node = new OSMNode(_dbCounter--, pt.Latitude, pt.Longitude);
if (pt.NodeID != 0)
{
node.Tags.Add(new OSMTag("node-id", pt.NodeID.ToString()));
}
if (pt.Time != DateTime.MinValue)
{
node.Tags.Add(new OSMTag("time", pt.Time.ToString()));
}
if (pt.Crossroad)
{
node.Tags.Add(new OSMTag("crossroad", "yes"));
}
_db.Nodes.Add(node);
}
way.Nodes.Add(node.ID);
}
}
return(_db);
}
/// <summary>
/// Callback function for OSMXmlDataReader, checks whether the way matches desired RoadTypes and adds the matched road into DB
/// </summary>
/// <param name="way">The way read form the OSM file</param>
void WayRead(OSMWay way)
{
foreach (RoadType roadType in _acceptedRoads)
{
if (roadType.Match(way) && _ways.ContainsKey(way.ID) == false)
{
ExtractUsedNodes(way);
_storage.Ways.Add(new OSMRoad(way, roadType));
_ways.Add(way.ID, way.ID);
}
}
}
public Street(Intersection from, Intersection to, OSMWay way, OSMData osm, Polyline pathway)
{
this.from = from;
this.to = to;
this.way = way;
//this.osm = osm;
//Creation of the pathway is handled outside (by bridge)
this.pathway = pathway;
centerLine = new Polyline(pathway.Vertices);
//Needs centerLine, therefore after that
from.AddStreet(this);
to.AddStreet(this);
/*Default is oneway=no, except for highway=motorway which implies oneway=yes. junction=roundabout also implies oneway=yes. highway=motorway_link has been a discussion a few times before, and it's best to add the oneway=* tag on those all the time, one way or not. --Eimai 12:59, 8 January 2009 (UTC)
* Should this be indicated in the page? --Seav 10:49, 14 January 2009 (UTC)
* Other implicit oneway=yes cases are: highway=motorway_link, highway=trunk_link and highway=primary_link. --Beldin 21:55, 22 April 2009 (UTC)*/
if (way.Tags.ContainsKey("oneway"))
{
if (way.Tags["oneway"] == "yes" || way.Tags["oneway"] == "1" || way.Tags["oneway"] == "true")
{
isOneWay = true;
}
}
if (way.Tags.ContainsKey("highway"))
{
if (way.Tags["highway"] == "motorway")
{
isOneWay = true;
}
}
if (way.Tags.ContainsKey("junction"))
{
if (way.Tags["junction"] == "roundabout")
{
isOneWay = true;
}
}
if (isOneWay)
{
carriageways[0] = new CarriageWay(way);
}
else
{
carriageways[0] = new CarriageWay(way);
carriageways[1] = new CarriageWay(way);
}
}
private void DrawWay(OSMapInfo mapInfo, OSMWay way, Color color)
{
for (int i = 1; i < way.NodeIDs.Count; i++)
{
OSMNode p1 = mapInfo.Nodes[way.NodeIDs[i - 1]];
OSMNode p2 = mapInfo.Nodes[way.NodeIDs[i]];
Vector3 v1 = p1 - mapInfo.Bounds.Center;
Vector3 v2 = p2 - mapInfo.Bounds.Center;
Debug.DrawLine(v1, v2, color);
}
}
private void ConnectHighwayNodesFromWay(OSMWay osmWay)
{
if (osmWay.Visible && osmWay.NodeIDs.Count > 0)
{
HighwayNode currentNode = NavInfo.Nodes[osmWay.NodeIDs[0]];
for (int i = 1; i < osmWay.NodeIDs.Count; ++i)
{
HighwayNode nextNode = NavInfo.Nodes[osmWay.NodeIDs[i]];
currentNode.Neighbours.Add(nextNode);
nextNode.Neighbours.Add(currentNode);
currentNode = nextNode;
}
}
}
private void WriteWay(OSMWay way, out byte[] writtenData)
{
if (!this._waysStarted)
{
this.Reset();
this._stream.WriteByte((byte)O5MFileByteMarker.Reset);
this._waysStarted = true;
}
this._stream.WriteByte((byte)O5MFileByteMarker.Way);
var bytes = new List <byte>();
var diffId = (long)way.Id - this._lastWayId;
var idBytes = VarintBitConverter.GetVarintBytes(diffId);
bytes.AddRange(idBytes);
this._lastWayId = (long)way.Id;
this.WriteVersionData(way, bytes);
if (way.NodeRefs.Count == 0)
{
bytes.Add(0x00);
}
else
{
var nodeRefsBytes = new List <byte>();
foreach (var nodeRef in way.NodeRefs)
{
var nextReferenceDiff = (long)nodeRef - this._lastReferenceId;
var nodeRefBytes = VarintBitConverter.GetVarintBytes(nextReferenceDiff);
this._lastReferenceId = (long)nodeRef;
nodeRefsBytes.AddRange(nodeRefBytes);
}
var nodeRefsBytesCountBytes = VarintBitConverter.GetVarintBytes((ulong)nodeRefsBytes.Count);
bytes.AddRange(nodeRefsBytesCountBytes);
bytes.AddRange(nodeRefsBytes);
}
this.WriteTags(way, bytes);
var length = VarintBitConverter.GetVarintBytes((ulong)bytes.Count);
this._stream.Write(length, 0, length.Length);
writtenData = bytes.ToArray();
this._stream.Write(writtenData, 0, bytes.Count);
}
/// <summary>
/// Writes the specific OSMWay to the output
/// </summary>
/// <param name="way">The OSMWay to be written.</param>
public void WriteWay(OSMWay way)
{
_xmlWriter.WriteStartElement("way");
WriteOSMObjectAttributes(way);
foreach (var nodeRef in way.Nodes)
{
_xmlWriter.WriteStartElement("nd");
_xmlWriter.WriteAttributeString("ref", nodeRef.ToString(System.Globalization.NumberFormatInfo.InvariantInfo));
_xmlWriter.WriteEndElement();
}
WriteOSMObjectTags(way);
_xmlWriter.WriteEndElement();
}
private void ReadWay()
{
string attId = _xmlReader.GetAttribute("id");
if (attId == null)
{
throw new XmlException("Attribute 'id' is missing.");
}
int wayId = int.Parse(attId, System.Globalization.CultureInfo.InvariantCulture);
OSMWay way = new OSMWay(wayId);
if (false == _xmlReader.IsEmptyElement)
{
_xmlReader.Read();
while (_xmlReader.NodeType != XmlNodeType.EndElement)
{
switch (_xmlReader.NodeType)
{
case XmlNodeType.Element:
switch (_xmlReader.Name)
{
case "nd":
way.Nodes.Add(ReadWayNd());
continue;
case "tag":
way.Tags.Add(ReadTag());
continue;
default:
_xmlReader.Skip();
continue;
}
default:
_xmlReader.Skip();
break;
}
}
}
OnWayRead(way);
_xmlReader.Skip();
}
public static OSMMap ParseMap(XmlDocument doc, ref XmlTextReader xmlReader, ref OSMMap osmMap)
{
//osmMap = new OSMMap();
XmlNode rootnode = doc.ReadNode(xmlReader);
OSMMap.ParseOSMHeader(rootnode, ref osmMap);
int nodeCount = 0;
int wayCount = 0;
int relationCount = 0;
foreach (XmlNode node in rootnode.ChildNodes)
{
switch (node.Name)
{
case "bounds":
osmMap.AddBounds(OSMMap.ParseBounds(node, ref osmMap));
break;
case "node":
nodeCount++;
osmMap.AddNode(OSMNode.ParseNode(node));
break;
case "way":
wayCount++;
osmMap.AddWay(OSMWay.ParseWay(node, ref osmMap));
break;
case "relation":
relationCount++;
osmMap.AddRelation(OSMRelation.ParseRelation(node, ref osmMap));
break;
default:
break;
}
}
//Console.WriteLine("nodeCount = {0} = {1}", nodeCount, osmMap.nodes.Count);
//Console.WriteLine("wayCount = {0} = {1}", wayCount, osmMap.ways.Count);
//Console.WriteLine("relationCount = {0} = {1}", relationCount, osmMap.relations.Count);
return(osmMap);
}
