static void DecodeDelta(OsmNode[] nodes)
{
for (int i = 1; i < nodes.Length; i++)
{
nodes[i] = new OsmNode(nodes[i].id + nodes[i - 1].id, nodes[i].latCode + nodes[i - 1].latCode, nodes[i].lonCode + nodes[i - 1].lonCode, nodes[i].values);
}
}
private OsmWorldData ToWorld(OsmResponse response, float s, float w, float n, float e)
{
var nodes = new List <OsmNode>();
var ways = new List <OsmWay>();
var others = new List <OsmElement>();
foreach (var element in response.elements)
{
switch (element.type)
{
case "way":
ways.Add(OsmWay.FromElement(element));
break;
case "node":
nodes.Add(OsmNode.FromElement(element));
break;
default:
others.Add(element);
break;
}
}
return(new OsmWorldData(response.version, response.generator, new OsmRect(s, w, n, e), response.osm3s, ways,
nodes, others));
}
private void ProcessRuleForRelationNodes()
{
foreach (OsmRelation relation in osmDataSource.OsmDatabase.Relations)
{
foreach (OsmRelationMember member in relation.EnumerateMembers())
{
if (member.MemberReference.ReferenceType == OsmReferenceType.Node &&
((currentRule.Targets & RenderingRuleTargets.Nodes) != 0))
{
if (osmDataSource.OsmDatabase.HasNode(member.MemberReference.ReferenceId))
{
OsmNode node =
osmDataSource.OsmDatabase.GetNode(member.MemberReference.ReferenceId);
if (consumedNodes.Contains(node.ObjectId))
{
continue;
}
consumedNodes.Add(node.ObjectId);
if (true == ProcessNode(node, relation))
{
break;
}
}
}
}
}
}
private void ReadNode(XElement el)
{
long id = el.GetAttributeLong("id");
double lat = el.GetAttributeDouble("lat");
double lon = el.GetAttributeDouble("lon");
int version = el.GetAttributeInt("version");
DateTime timestamp = el.GetAttributeDateTime("timestamp", DateTime.MinValue);
int changeset = el.GetAttributeInt("changeset");
Dictionary <string, string> tags = new Dictionary <string, string>();
foreach (var element in el.Nodes().OfType <XElement>().Where(e => e.Name == "tag"))
{
string key = element.Attribute("k").Value;
string value = element.Attribute("v").Value;
tags.Add(key, value);
}
OsmNode node = new OsmNode()
{
Id = id,
Lat = lat,
Lon = lon,
Version = version,
Timestamp = timestamp,
Changeset = changeset,
Tags = tags,
};
NodeRead(node);
}
private bool ProcessNode(OsmNode node, OsmRelation relation)
{
// ignore untagged nodes (but not if they are part of a relation)
if (false == node.IsTagged && relation == null)
{
return(false);
}
int layer = GetOsmObjectLayerNumber(node);
if (currentRule.IsMatch(relation, node))
{
// if we are just running the first run on the rule engine
// to detect levels and types that are used in the mapWriter
if (justDetectLevelsAndTypesUsed)
{
currentRule.MarkHardwareLevelsUsed(analysis);
currentRule.Template.RegisterType(currentRule.RuleName, mapMakerSettings.TypesRegistry, false);
return(true);
}
AddRenderElementCommandForNode(node, relation, layer, currentRule);
}
return(false);
}
void makeRoad()
{
foreach (OsmWay w in ways)
{
if (w.Visible)
{
Color c = Color.cyan;
GameObject toInstantiate = buildingVisualizer;
if (!w.isBoundary)
{
toInstantiate = roadVisualizer;
}
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.Centre;
Vector3 v2 = p2 - bounds.Centre;
Debug.DrawLine(v1, v2, c);
GameObject road = Instantiate(toInstantiate, v1, Quaternion.identity);
RaycastHit hit;
road.GetComponent <LineRenderer>().SetPosition(0, v1);
road.GetComponent <LineRenderer>().SetPosition(1, v2);
road.GetComponent <LineRenderer>().startWidth = 2f;
road.GetComponent <LineRenderer>().endWidth = 2f;
}
}
}
}
void Update()
{
foreach (OsmWay w in ways)
{
if (w.Visible)
{
Color c = Color.cyan; //cyan for buildings
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.Centre;
Vector3 v2 = p2 - bounds.Centre;
Debug.DrawLine(v1, v2, c);
}
}
}
}
void Update()
{
foreach (OsmWay w in ways)
{
if (w.Visible)
{
Color c = Color.cyan;
if (!w.IsBoundary)
{
c = Color.black;
}
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);
}
}
}
}
public OsmNode FetchOsmNode(int id)
{
var xmlNode = FetchElementXml(nodeApiUrl + id.ToString());
var osmNode = new OsmNode();
//API always returns a single node.
XmlNode elementXmlNode = xmlNode.GetElementsByTagName("node")[0];
//Reading Metadata
FetchBasicAttributes(elementXmlNode, ref osmNode);
osmNode.Lat = float.Parse(elementXmlNode.Attributes["lat"].Value);
osmNode.Lon = float.Parse(elementXmlNode.Attributes["lon"].Value);
//Reading Tags
var tagList = new List<Tag>();
XmlNodeList tagXmlNodes = xmlNode.GetElementsByTagName("tag");
foreach (XmlNode tagXml in tagXmlNodes)
{
var tag = new Tag();
tag.Key = tagXml.Attributes["k"].Value;
tag.Value = tagXml.Attributes["v"].Value;
tagList.Add(tag);
}
osmNode.TagList = tagList;
return osmNode;
}
static void EncodeDelta(OsmNode[] nodes)
{
for (int i = nodes.Length - 1; i > 0; i--)
{
nodes[i] = new OsmNode(nodes[i].id - nodes[i - 1].id, nodes[i].latCode - nodes[i - 1].latCode, nodes[i].lonCode - nodes[i - 1].lonCode, nodes[i].values);
}
}
/// <summary>
/// Extracts all Nodes of importance, that are not included in any Way, from OSM API Response XML
/// </summary>
private static ICollection <OsmNode> ExtractSingleNodes(XDocument xmlData)
{
Debug.Assert(xmlData.Root != null, "xmlData.Root == null");
var nodes = new List <OsmNode>();
foreach (var nodeElement in xmlData.Root.Descendants(Constants.OsmXml.Tags.Node))
{
// filter by tags
var tags = nodeElement.Elements(Constants.OsmXml.Tags.Tag).ToArray();
if (tags.All(t => t.Attribute(Constants.OsmXml.Attributes.K).Value != Constants.OsmXml.Values.Amenity))
{
continue;
}
// create Node
var osmNode = new OsmNode
{
Id = Convert.ToInt64(nodeElement.Attribute(Constants.OsmXml.Attributes.Id).Value),
Latitude = Convert.ToDouble(nodeElement.Attribute(Constants.OsmXml.Attributes.Lat).Value),
Longitude = Convert.ToDouble(nodeElement.Attribute(Constants.OsmXml.Attributes.Lon).Value),
Tags = new Dictionary <string, string>()
};
// populate tags
foreach (var tagElement in tags)
{
osmNode.Tags.Add(tagElement.Attribute(Constants.OsmXml.Attributes.K).Value,
tagElement.Attribute(Constants.OsmXml.Attributes.V).Value);
}
nodes.Add(osmNode);
}
return(nodes);
}
void GetNodes(XmlNodeList xmlNodeList)
{
foreach (XmlNode n in xmlNodeList)
{
OsmNode node = new OsmNode(n);
nodes[node.ID] = node;
}
}
private static void WriteNode(XmlWriter writer, OsmNode osmNode)
{
writer.WriteStartElement(Constants.Constants.osmNode);
writer.WriteAttributeString(Constants.Constants.IdString, osmNode.Id.ToString(CultureInfo.InvariantCulture));
writer.WriteAttributeString(Constants.Constants.LatString, osmNode.Point.Lat.ToString(CultureInfo.InvariantCulture));
writer.WriteAttributeString(Constants.Constants.LonString, osmNode.Point.Lon.ToString(CultureInfo.InvariantCulture));
WriteTags(writer, osmNode.Tags);
writer.WriteEndElement();
}
private void AddRenderElementCommandForNode(
OsmNode node,
OsmRelation parentRelation,
int elementLayer,
RenderingRule renderingRule)
{
renderingRule.Template.RenderOsmObject(mapMakerSettings, analysis, osmDataSource.OsmDatabase, node, parentRelation, mapWriter);
mapMakerSettings.MapContentStatistics.IncrementFeaturesCount(renderingRule.RuleName);
}
private bool IsTown(OsmNode node)
{
if (node == null)
{
return(false);
}
return(node.Tags.Any(x => cityKeys.Any(y => y.Equals(x.Key, StringComparison.OrdinalIgnoreCase))));
}
private void NodeRead(OsmNode node)
{
nodeCount++;
if (nodeCount % 100 == 0)
{
UpdateStatus();
}
}
/// <inheritdoc cref="IOverpassApi"/>
public OsmNode[] LoadNodesFromOverpass(string csvQuery)
{
List <OsmNode> result = new List <OsmNode>();
string[] data = GetCvsOverPassData(csvQuery);
if (data == null || data.Length < 2)
{
return(null);
}
//first row determins the Keys of the Tags
//0 -> id, 1 -> latutide, 2 -> longitude, 3 till whatever -> keys
string[] firstRow = data[0].Split('\t');
for (int i = 0; i < data.Length; i++)
{
string[] row = data[i].Split('\t');
for (int y = 0; y < row.Length; y++)
{
row[y] = Cleanup(row[y]);
}
OsmNode rowNode = new OsmNode();
rowNode.ID = long.Parse(row[0]);
rowNode.Latitude = ParsingHelper.StringToDouble(row[1]);
rowNode.Longitude = ParsingHelper.StringToDouble(row[2]);
rowNode.Name = row[3];
for (int y = 4; y < row.Length; y++)
{
rowNode.Tags.Add(new KeyValuePair(firstRow[y], row[y]));
}
result.Add(rowNode);
}
//cleanup
HashSet <long> idHash = new HashSet <long>();
result = result.Where(x => !string.IsNullOrWhiteSpace(x.Name) && x.ID != 0 && x.Latitude != 0 && x.Longitude != 0 && idHash.Add(x.ID)).ToList();
foreach (var entry in result)
{
for (int i = 0; i < entry.Tags.Count; i++)
{
if (string.IsNullOrWhiteSpace(entry.Tags[i].Value))
{
entry.Tags.RemoveAt(i);
i--;
}
}
}
return(result.ToArray());
}
protected static OsmNode[] GetNodesForWay(IOsmDataFastAccess osmDatabase, OsmWay way)
{
OsmNode[] nodes = new OsmNode[way.NodesCount];
for (int i = 0; i < way.NodesCount; i++)
{
nodes[i] = osmDatabase.GetNode(way.Nodes[i]);
}
return(nodes);
}
public OsmObjectMother AddNode()
{
double latitude = ConstructLatitude(idCounter);
OsmNode node = new OsmNode(idCounter++, latitude, idCounter * 0.001);
osmDatabase.AddNode(node);
currentObject = node;
return(this);
}
protected override void OnObjectCreated(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 = map.nodes[way.NodeIDs[i - 1]];
OsmNode p2 = map.nodes[way.NodeIDs[i]];
Vector3 s1 = p1 - origin;
Vector3 s2 = p2 - origin;
Vector3 diff = (s2 - s1).normalized;
// 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;
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);
// first triangle v3 v4 v2
indices.Add(idx3);
indices.Add(idx4);
indices.Add(idx2);
}
}
protected override void OnObjectCreated(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++) // 在这里改成spline， procedural 点到axis（spline）到面
{
OsmNode p1 = map.nodes[way.NodeIDs[i - 1]];
OsmNode p2 = map.nodes[way.NodeIDs[i]];
Vector3 s1 = p1 - origin;
Vector3 s2 = p2 - origin;
Vector3 diff = (s2 - s1).normalized;
// Lanes need to check!
var cross = Vector3.Cross(diff, Vector3.up) * 3.7f * way.Lanes;
// points 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);
}
}
static int ReadNodesPath(byte[] buf, int ofs, out OsmNode[] nodes)
{
ulong tmp;
int p = ProtoBuf.ReadVarInt(buf, ofs, out tmp);
nodes = new OsmNode[tmp];
for (int i = 0; i < nodes.Length; i++)
{
p += OsmNode.ReadBinary(buf, ofs + p, out nodes[i]);
}
return(p);
}
public InMemoryOsmDatabase Provide()
{
InMemoryOsmDatabase osmDatabase = new InMemoryOsmDatabase();
for (int i = 0; i < pointTypesCount; i++)
{
OsmNode node = new OsmNode(i + 1, 15 + (i % width) * 0.1, 46 + (i / width) * 0.1);
node.SetTag("garmin_icon", i.ToString(CultureInfo.InvariantCulture));
osmDatabase.AddNode(node);
}
return(osmDatabase);
}
private Waypoint GetWaypointForNode(OsmNode node)
{
if (Waypoints.ContainsKey(node.Id))
{
return(Waypoints[node.Id]);
}
else
{
Waypoint nw = new Waypoint(node);
Waypoints.Add(node.Id, nw);
return(nw);
}
}
protected override void OnObjectCreated(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 = map.nodes[way.NodeIDs[i - 1]];
OsmNode p2 = map.nodes[way.NodeIDs[i]];
Vector3 s1 = p1 - origin;
Vector3 s2 = p2 - origin;
Vector3 diff = (s2 - s1).normalized;
var cross = Vector3.Cross(diff, Vector3.up) * 3.7f * way.Lanes;
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;
indices.Add(idx1);
indices.Add(idx3);
indices.Add(idx2);
indices.Add(idx3);
indices.Add(idx4);
indices.Add(idx2);
}
}
public CGpsMapperMapWriter AddCoordinates(string parameterName, int level, OsmNode node)
{
StringBuilder line = new StringBuilder();
line.AppendFormat("{0}{1}=", parameterName, level);
line.AppendFormat(CultureInfo.InvariantCulture,
"({0},{1})",
RenderCoordinateValue(node.Y),
RenderCoordinateValue(node.X));
AppendLine(line.ToString());
return(this);
}
public static void testPostgreSQL()
{
OSMPostgresqlSource sourcePostgre = new OSMPostgresqlSource(connPostGreSql);
var bbbbpostgre = sourcePostgre.Bounds;
OsmNode nooode = new OsmNode();
nooode.id = "81069";
var taagspg = nooode.GetTagsPostgreSQL(connPostGreSql);
Aram.OSMParser.Relation rel = new Aram.OSMParser.Relation("2340");
var members = rel.GetMembersPostgreSQL(connPostGreSql);
Console.WriteLine("Completed without errors.");
Console.ReadLine();
}
void DrawSpline(OsmWay w, Color c)
{
for (int i = 1; i < w.NodeIDs.Count; i++)//draw a lines between point to point
{
//OsmNode p1 = nodes[w.NodeIDs[i - 1]];
//OsmNode p2 = nodes[w.NodeIDs[i]];
//Vector3 v1 = p1 - bounds.Centre;
//Vector3 v2 = p2 - bounds.Centre;
//Debug.DrawLine(v1, v2, c);
OsmNode p = nodes[w.NodeIDs[i]];
Vector3 v = p - bounds.Centre;
}
}
private static string SingleNodeDescription(OsmNode node)
{
Debug.Assert(node != null, "node == null");
var result = node.Tags[Constants.OsmXml.Values.Amenity];
if (node.Tags.ContainsKey(Constants.OsmXml.Values.Name))
{
result += " " + node.Tags[Constants.OsmXml.Values.Name];
}
else if (node.Tags.Count == 2)
{
result += " " + node.Tags.First(x => x.Key != Constants.OsmXml.Values.Amenity).Value;
}
return(result);
}
public static void CreatePower(OsmNode towerData, OsmBounds bounds, Transform parent)
{
Vector3[] linePoints = new Vector3[2];
linePoints[0] = OsmToUnityConverter.GetPointFromUnityPointVec3(towerData.Point, bounds);
linePoints[1] = linePoints[0];
linePoints[1].y = GetPowerTowerHeight();
float width = GetPowerTowerWidth();
Color color = GetPowerTowerColor();
GameObject result = LineFactory.CreateLine(linePoints, width, color, new Material(Shader.Find("Sprites/Default")));
result.name = "<powertower>";
result.transform.parent = parent;
}
private void Parse()
{
XDocument doc = XDocument.Load(File);
XElement root = doc.Root;
foreach (var xElement in root.Elements("node"))
{
var newNode = OsmNode.FromXElement(xElement);
Nodes.Add(newNode.Id, newNode);
}
foreach (var xElement in root.Elements("way"))
{
var newWay = OsmWay.FromXElement(xElement, Nodes);
Ways.Add(newWay.Id, newWay);
}
}
public OsmWay FetchOsmWay(int id)
{
var xmlWay = FetchElementXml(wayApiUrl + id.ToString());
var osmWay = new OsmWay();
//API always returns a single way.
XmlNode elementXmlWay = xmlWay.GetElementsByTagName("way")[0];
//Reading Metadata
FetchBasicAttributes(elementXmlWay, ref osmWay);
//Reading Way Nodes
var nodeList = new List<OsmNode>();
XmlNodeList xmlNodes = xmlWay.GetElementsByTagName("nd");
foreach (XmlNode xmlNode in xmlNodes)
{
var nodeRef = int.Parse(xmlNode.Attributes["ref"].Value);
var nodeParser = new OsmNodeParser();
var node = new OsmNode();
node = nodeParser.FetchOsmNode(nodeRef);
nodeList.Add(node);
}
osmWay.NodesList = nodeList;
//Reading Way Tags
var tagList = new List<Tag>();
XmlNodeList tagXmlNodes = xmlWay.GetElementsByTagName("tag");
foreach (XmlNode tagXml in tagXmlNodes)
{
var tag = new Tag();
tag.Key = tagXml.Attributes["k"].Value;
tag.Value = tagXml.Attributes["v"].Value;
tagList.Add(tag);
}
osmWay.TagList = tagList;
return osmWay;
}
public void FetchBasicAttributes(XmlNode elementXmlNode, ref OsmNode osmNode)
{
FetchBasicAttributes(elementXmlNode, (OsmElement)osmNode);
}
