class BackImporter:
def __init__ (self, model, grid):
self.__model = model
self.__grid = grid
self.__cutter = ClipHelper(grid)
self.__preprocessor = Preprocessor()
def process (self, filename, minlevel, maxlevel):
self.__minlevel = minlevel
self.__maxlevel = maxlevel
cursize = 0
progress = Progress(filename, 0, os.stat(filename)[6])
for ln in open(filename):
if ln.startswith('AF'):
self.processAF(ln)
elif ln.startswith('LF'):
self.processLF(ln)
elif ln.startswith('LM'):
self.processLM(ln)
elif ln.startswith('PF'):
self.processPF(ln)
cursize += len(ln)
progress.update(cursize)
def processAF(self, af):
#if len(af) > 64*1024:
# return
grp = af.split(';')
transtype = transform_af(grp)
if transtype:
themecode, featcode = transtype
priority = int(grp[3])
name = self.__preprocessor.nominalizeName(grp[6])
polylist = []
for poly in grp[2].split('|'):
points = poly.split(',')
poly = [(int(points[i]), int(points[i+1])) for i in range(0, len(points), 2)]
#
polyList = [poly]
for level in range(self.__maxlevel-1, self.__minlevel-1, -1):
newPolyList = []
for poly in polyList:
for mesh, clipPoly in self.__cutter.clipPolygon(poly, level):
area = XBackArea()
area.priority = priority
area.themecode = themecode
area.featcode = featcode
area.name = name
area.polylist = [clipPoly]
# save
model = self.__model[level]
parcel = model.get(mesh)
if not parcel:
parcel = XParcel()
parcel.back_area_list.append(area)
model.put(mesh, parcel)
newPolyList.append(clipPoly)
polyList = newPolyList
themecode = 0
featcode = 0
def processLF (self, lf):
grp = lf.split(';')
transtype = transform_lf(grp)
if transtype:
themecode, featcode = transtype
priority = int(grp[3])
name = self.__preprocessor.nominalizeName(grp[6])
points = grp[2].split(',')
poly = [(int(points[i]), int(points[i+1])) for i in range(0, len(points), 2)]
for level in range(self.__minlevel, self.__maxlevel):
for meshcode, segment in self.__cutter.clipPolyline(poly, level):
edge = XBackEdge()
edge.themecode = themecode
edge.featcode = featcode
edge.polyline = segment
edge.name = name
model = self.__model[level]
parcel = model.get(meshcode)
if not parcel:
parcel = XParcel()
parcel.back_edge_list.append(edge)
model.put(meshcode, parcel)
def processLM (self, lm):
grp = lm.split(';')
transtype = transform_lm(grp)
if transtype:
point = tuple([int(x) for x in grp[2].split(',')])
name = self.__preprocessor.nominalizeName(grp[3])
for level in range(self.__minlevel, self.__maxlevel):
meshcode = self.__grid.getPointMesh(point, level)
node = XBackNode()
node.themecode = transtype[0]
node.featcode = transtype[1]
node.point = point
node.name = name
model = self.__model[level]
parcel = model.get(meshcode)
if not parcel:
parcel = XParcel()
parcel.back_node_list.append(node)
model.put(meshcode, parcel)
def processPF (self, pf):
grp = pf.split(';')
transtype = transform_pf(grp)
if transtype:
themecode, featcode = transtype
point = tuple([int(x) for x in grp[2].split(',')])
name = self.__preprocessor.nominalizeName(grp[6])
for level in range(self.__minlevel, self.__maxlevel):
meshcode = self.__grid.getPointMesh(point, level)
node = XBackNode()
node.themecode = themecode
node.featcode = featcode
node.point = point
node.name = name
model = self.__model[level]
parcel = model.get(meshcode)
if not parcel:
parcel = XParcel()
parcel.back_node_list.append(node)
model.put(meshcode, parcel)
def __init__ (self, model, grid):
self.__model = model
self.__grid = grid
self.__cutter = ClipHelper(grid)
self.__preprocessor = Preprocessor()
class RoadImporter:
def __init__ (self, model, grid):
self.__model = model
self.__grid = grid
self.__clipHelper = ClipHelper(grid)
self.__preprocessor = Preprocessor()
def process (self, filename):
curSize = 0
progress = Progress(filename, 0, os.stat(filename)[6])
for ln in open(filename):
if ln.startswith('RF'):
self.processRF(ln)
curSize += len(ln)
progress.update(curSize)
def getNodeIndex(self, parcel, coordinate):
for nodeId, node in parcel.roadNodeDict.items():
if abs(node.coordinate.lat - coordinate.lat) < 0.00000001 and abs(node.coordinate.lon - coordinate.lon) < 0.00000001:
return nodeId
node = XRoadNode()
node.coordinate = coordinate
nodeId = config.ROAD_NODE_SEQ_BASE
parcel.roadNodeDict[nodeId] = node
config.ROAD_NODE_SEQ_BASE += 1
return nodeId
def processRF (self, rf):
grp = rf.split(';')
link_id = grp[1]
points = grp[2].split(',')
priority = int(grp[3])
direction = int(grp[4][0])
roadType = int(grp[5])
subtype = int(grp[6])
speed = int(grp[7])
name = self.__preprocessor.nominalizeName(grp[9])
adminArea = grp[11]
pointList = [XCoordinate(int(points[i]), int(points[i+1])) for i in range(0, len(points), 2)]
for meshCode, polyline in self.__clipHelper.clipPolyline(pointList):
parcel = self.__model.get(meshCode)
if not parcel:
parcel = XParcel()
parcel.parcelId = meshCode
link = XRoadLink()
link.fNode = self.getNodeIndex(parcel, polyline[0])
link.tNode = self.getNodeIndex(parcel, polyline[-1])
link.trafficDir = direction
link.width = 0 # width
link.speed = speed
link.priority = priority-1
link.roadType = roadType
link.subType = subtype
link.length = 0 # length
link.roadName = name
link.adminArea = adminArea
link.polyline = polyline
link.fAngle, link.tAngle = 0,0#self.__calcAngle(polyline)
parcel.roadLinkDict[config.ROAD_LINK_SEQ_BASE] = link
#for link in parcel.roadLinkDict.values():
# assert link.fNode in parcel.roadNodeDict
# assert link.tNode in parcel.roadNodeDict
self.__model.put(meshCode, parcel)
config.ROAD_LINK_SEQ_BASE += 1
def __calcAngle (self, polyline):
p1 = polyline[0]
p2 = polyline[-1]
a1 = angle(p1, XCoordinate(p1.lon+100, p1.lat), (p2.lon, p2.lat))
a2 = angle(p2, XCoordinate(p2.lon+100, p2.lat), (p1[1], p1[0]))
return (a1, a2)
