def makeWay(self, w, wayId, strings):
way = []
startNodeId, length, isCycle, elevation = w
if not str(elevation) in strings:
strings.append(str(elevation))
# id, id=1
way.append(self.makeVar("V", 1, wayId, int2str))
# keys, id=2
keys = join([int2str(el) for el in [1, 2, 4]])
way.append(self.makeVar("S", 2, keys))
# ways, id=3
vals = join([
int2str(el) for el in [
strings.index(str(elevation)), 3,
strings.index(self.elevClassifier(elevation))
]
])
way.append(self.makeVar("S", 3, vals))
# info, id=4
info = self.makeWayInfo()
way.append(self.makeVar("S", 4, info))
# refs, id=8
refs = sint2str(startNodeId) + sint2str(1) * (length - 1)
if isCycle:
refs += sint2str(-(length - 1))
way.append(self.makeVar("S", 8, refs))
return join(way)
def makeDenseNodes(self, startNodeId, nodeList):
dense = []
Lon = [
nodeList[0][0] // self.granularity,
]
Lat = [
nodeList[0][1] // self.granularity,
]
last_lon = Lon[0]
last_lat = Lat[0]
for lon, lat in nodeList[1:]:
lon = lon // self.granularity
lat = lat // self.granularity
lon_diff = lon - last_lon
lat_diff = lat - last_lat
Lon.append(lon_diff)
Lat.append(lat_diff)
last_lon = lon
last_lat = lat
# id, id=1
id = sint2str(startNodeId) + sint2str(1) * (len(Lon) - 1)
dense.append(self.makeVar("S", 1, id))
# denseinfo, id=5
dense.append(self.makeVar("S", 5, self.makeDenseInfo(len(Lon))))
# lat, id=8
LAT = join([sint2str(l) for l in Lat])
dense.append(self.makeVar("S", 8, LAT))
# lon, id=9
LON = join([sint2str(l) for l in Lon])
dense.append(self.makeVar("S", 9, LON))
return join(dense)
def makeWayData(self, way, idDelta, first):
startNodeId, length, isCycle, elevation = way
data = []
data.append(sint2str(idDelta))
# version information
if first:
# first way
data.append(self.makeVersionChunk(first=True))
else:
data.append(self.makeVersionChunk(first=False))
# node references
wayRefSection = self.makeWayReferenceSection(startNodeId, length,
isCycle)
wayRefSectionLen = len(wayRefSection)
data.append(int2str(wayRefSectionLen))
data.append(wayRefSection)
# tags
# ele = <elevation>
eleTag = self.makeStringPair("ele", str(elevation))
contourTag = self.makeStringPair("contour", "elevation")
elevClassifierTag = self.makeStringPair("contour_ext",
self.elevClassifier(elevation))
data.append(self.stringTable.stringOrIndex(eleTag))
data.append(self.stringTable.stringOrIndex(contourTag))
data.append(self.stringTable.stringOrIndex(elevClassifierTag))
return join(data)
def makeTimestampDataset(self):
timestampDataset = [
writableInt(0xdc),
]
timestampData = sint2str(self.timestamp)
timestampDataset.append(int2str(len(timestampData)))
timestampDataset.append(timestampData)
return join(timestampDataset)
def makeDenseInfo(self, times):
denseInfo = []
# version, id=1
version = int2str(1) * times
denseInfo.append(self.makeVar("S", 1, version))
# timestamp, id=2
timestamp = sint2str(self.timestamp) + (sint2str(0) * (times - 1))
denseInfo.append(self.makeVar("S", 2, timestamp))
# changeset, id=3
changeset = sint2str(1) * times
denseInfo.append(self.makeVar("S", 3, changeset))
# uid, id=4
uid = sint2str(0) * times
denseInfo.append(self.makeVar("S", 4, uid))
# user_sid, id=5
user_sid = sint2str(0) * times
denseInfo.append(self.makeVar("S", 5, user_sid))
return join(denseInfo)
def makeBBoxDataset(self):
# bbox dataset, with length
bboxDataset = [
writableInt(0xdb),
]
bboxData = join([sint2str(int(i * HUNDREDNANO)) for i in self.bbox])
bboxDataset.append(int2str(len(bboxData)))
bboxDataset.append(bboxData)
return join(bboxDataset)
def makeVersionChunk(self, first=False):
data = []
# version
data.append(int2str(1))
# timestamp = self.timestamp or 0, if self.timestamp, write changeset and
# uid
# timestamp is delta coded
if first and self.writeTimestamp:
data.append(sint2str(self.timestamp))
else:
data.append(sint2str(0))
if self.writeTimestamp:
# changeset, delta coded
if first:
data.append(sint2str(1))
else:
data.append(sint2str(0))
# userid, username = ("", ""), string pair -> 0x00,0x00,0x00
data.append(self.stringTable.stringOrIndex(writableInt(0x00) * 3))
return join(data)
def makeNodeData(self, node, lastNode, idDelta):
data = []
data.append(sint2str(idDelta))
# version information
if lastNode == None:
# first node since reset
data.append(self.makeVersionChunk(first=True))
else:
data.append(self.makeVersionChunk(first=False))
# lon, lat
lon, lat = node
if lastNode != None:
deltaLon = sint2str(lon - lastNode[0])
deltaLat = sint2str(lat - lastNode[1])
else:
deltaLon = sint2str(lon)
deltaLat = sint2str(lat)
data.append(deltaLon)
data.append(deltaLat)
# no tags, so data is complete now
return join(data)
def makeWayReferenceSection(self, startNodeId, length, isCycle):
nodeIdDeltas = []
# the first node id, delta coded
nodeIdDeltas.append(startNodeId - self.lastNodeId)
nodeIdDeltas.extend([
1,
] * (length - 1))
if isCycle:
nodeIdDeltas.append(-(length - 1))
self.lastNodeId = startNodeId
else:
self.lastNodeId = startNodeId + length - 1
return join([sint2str(nodeIdDelta) for nodeIdDelta in nodeIdDeltas])
def makeHeaderBBox(self):
bbox = []
left, bottom, right, top = [sint2str(int(i * NANO)) for i in self.bbox]
# left, id=1
bbox.append(self.makeVarIdent("V", 1))
bbox.append(left)
# right, id=2
bbox.append(self.makeVarIdent("V", 2))
bbox.append(right)
# top, id=3
bbox.append(self.makeVarIdent("V", 3))
bbox.append(top)
# bottom, id=4
bbox.append(self.makeVarIdent("V", 4))
bbox.append(bottom)
return join(bbox)
