| | 45 | import codecs |
| | 46 | |
| | 47 | |
| | 48 | # the file name where the report for the wiki goes, needs to be configurable |
| | 49 | wikiReportFN = 'C:/data/wikiReport.txt' |
| | 50 | # comment to disable side effect |
| | 51 | sideEffects = { |
| | 52 | 'addRouteToNetwork': None, |
| | 53 | 'removeNameRefKey_xx-yyAndcreated_by': None, |
| | 54 | 'modifyNoteTo_xx-yy': None, |
| | 55 | 'flipOrderOfMembers': None, # such that ways go from lower rXn_ref to higher rXn_ref |
| | 56 | #'sortRouteRelations': None, |
| | 57 | #'sortNetworkRelations': None, |
| | 58 | #'removeNodesFromRoutes': None, |
| | 59 | #'addNodes2Routes': None, |
| | 60 | #'selectObjects': None, |
| | 61 | #'zoomToSelection': None, |
| | 62 | #'downloadReferrersForNodes': None, # This will download all ways and relations for nodes with an rXn_ref |
| | 63 | #'downloadReferrersForWays': None, # This will download all relations for ways that have an endnode with an rXn_ref |
| | 64 | 'downloadIncompleteMembers': None, |
| | 65 | 'createWikiReport': None, |
| | 66 | 'reportWhenWaysAreUsedInAnotherRelationToo': None, |
| | 67 | 'addFixmeTODOtags': None, # This will add todo tags to the data containing problems, |
| | 68 | # the intention is that these tags are removed before uploading, |
| | 69 | # once the reported problems are resolved |
| | 70 | #'createGarminGPX': None, # not implemented yet |
| | 71 | #'checkOneWays = False, # not implemented yet |
| | 72 | } |
| | 73 | |
| | 74 | logVerbosity = 30 |
| | 75 | ''' |
| | 76 | 10: only report problems that require attention |
| | 77 | 20: report on collection |
| | 78 | 30: report on network nodes |
| | 79 | 40: report on which routes are being checked |
| | 80 | 50: report everything |
| | 81 | ''' |
| | 122 | elif len(members) == 3: |
| | 123 | # road is splitting or recombining |
| | 124 | if inBranch: |
| | 125 | inBranch = False |
| | 126 | else: |
| | 127 | inBranch = True |
| | 128 | # road is splitting, which is the member we need next? |
| | 129 | # probably the one not going against a oneway restriction |
| | 130 | for member in members: |
| | 131 | if member in processedMembers: continue |
| | 132 | way = member.getWay() |
| | 133 | oneway = way.get('oneway') |
| | 134 | if oneway: |
| | 135 | oneway = oneway.lower() |
| | 136 | else: |
| | 137 | oneway = '' |
| | 138 | if oneway and not(oneway == 'no'): |
| | 139 | ob=way.get('oneway:bicycle') |
| | 140 | if ob: |
| | 141 | ob = ob.lower() |
| | 142 | else: |
| | 143 | ob = '' |
| | 144 | bo=way.get('bicycle:oneway') |
| | 145 | if bo: |
| | 146 | bo = bo.lower() |
| | 147 | else: |
| | 148 | bo = '' |
| | 149 | co=way.get('cycleway_opposite') |
| | 150 | if co: |
| | 151 | co = co.lower() |
| | 152 | else: |
| | 153 | co = '' |
| | 154 | onewayForBicycle = oneway in ['yes', '1', 'true', '-1'] and not(ob in ['yes', '1', 'true'] or |
| | 155 | bo in ['yes', '1', 'true'] or |
| | 156 | co in ['yes', '1', 'true']) |
| | 157 | if oneway == '-1': pass # TODO this also needs to be taken in consideration |
| | 158 | if way.getNode(0).getUniqueId() == nextNode: |
| | 159 | break |
| 125 | | def checkRCNroute(route): |
| 126 | | commandsList = [] |
| 127 | | reNumberDashNumber = re.compile(r'\d+-\d+') |
| 128 | | newRelation = Relation(route) |
| 129 | | relationChanged = False |
| 130 | | created_by = route.get('created_by') |
| 131 | | if created_by: |
| 132 | | print 'removing created_by' |
| 133 | | newRelation.remove('created_by') |
| 134 | | relationChanged = True |
| 135 | | name = route.get('name') |
| 136 | | if name: |
| 137 | | if reNumberDashNumber.match(name): |
| 138 | | print 'removing name when it is of the form ##-##' |
| | 216 | def checkPTroute(route, aDownloadWasNeeded): |
| | 217 | if aDownloadWasNeeded: |
| | 218 | return None, False, '' |
| | 219 | fixme = route.get('fixme') |
| | 220 | |
| | 221 | newRelation = Relation(route); commandslist = []; i=0; roundabout = [] |
| | 222 | wayssequence = []; stopssequence = [] |
| | 223 | unusedways = []; unservedstops = [] |
| | 224 | routeMembers = route.getMembers() |
| | 225 | modified = False |
| | 226 | for member in routeMembers: |
| | 227 | if member.isWay(): |
| | 228 | wayssequence.append(member) |
| | 229 | unusedways.append(member.getWay()) |
| | 230 | elif member.isNode() and (member.getNode().get("highway") in ['bus_stop', 'bus_station'] or member.getNode().get("public_transport") in ['platform']): |
| | 231 | stopssequence.append(member.getNode()) |
| | 232 | unservedstops.append(member.getNode()) |
| | 233 | print(checkForContinuity(wayssequence)) |
| | 234 | def checkRxNroute(route, networklevel, aDownloadWasNeeded): |
| | 235 | if aDownloadWasNeeded: |
| | 236 | return None, False, '' |
| | 237 | if 'removeNameRefKey_xx-yyAndcreated_by' in sideEffects: |
| | 238 | commandsList = [] |
| | 239 | reNumberDashNumber = re.compile(r'\d+\s-\s\d+') |
| | 240 | newRelation = Relation(route) |
| | 241 | relationChanged = False |
| | 242 | created_by = route.get('created_by') |
| | 243 | if created_by: |
| | 244 | print 'removing created_by' |
| | 245 | newRelation.remove('created_by') |
| | 246 | relationChanged = True |
| | 247 | name = route.get('name') |
| | 248 | if name: |
| | 249 | #if reNumberDashNumber.match(name): |
| | 250 | print 'removing name' |
| 141 | | else: |
| 142 | | name = '' |
| 143 | | ref = route.get('ref') |
| 144 | | if ref: |
| 145 | | if reNumberDashNumber.match(ref): |
| 146 | | print 'removing ref when it is of the form ##-##' |
| 147 | | newRelation.remove('ref') |
| 148 | | relationChanged = True |
| 149 | | else: |
| 150 | | ref = '' |
| 151 | | if relationChanged: |
| 152 | | commandsList.append(Command.ChangeCommand(route, newRelation)) |
| 153 | | |
| 154 | | Main.main.undoRedo.add(Command.SequenceCommand("Removing name and/or ref and/or created_by" + name + '/' + ref, commandsList)) |
| 155 | | commandsList = [] |
| 156 | | |
| 157 | | fixme = route.get('fixme') == 'incomplete' |
| 158 | | rcn_refs = []; route_relation_names = []; memberslist = []; roleInNetwork = '' |
| | 253 | else: |
| | 254 | name = '' |
| | 255 | ref = route.get('ref') |
| | 256 | if ref: |
| | 257 | if reNumberDashNumber.match(ref): |
| | 258 | print 'removing ref when it is of the form ##-##' |
| | 259 | newRelation.remove('ref') |
| | 260 | relationChanged = True |
| | 261 | else: |
| | 262 | ref = '' |
| | 263 | if relationChanged: |
| | 264 | commandsList.append(Command.ChangeCommand(route, newRelation)) |
| | 265 | |
| | 266 | Main.main.undoRedo.add(Command.SequenceCommand("Removing name and/or ref and/or created_by" + name + '/' + ref, commandsList)) |
| | 267 | commandsList = [] |
| | 268 | |
| | 269 | fixme = route.get('fixme') |
| | 270 | rXn_refs = []; actual_rXn_refs = []; route_relation_names = [] |
| | 271 | memberslist = []; waymembersinlist = 0; roleInNetwork = '' |
| 162 | | nodesForSorting = {}; beginAndEndNodes = [] |
| 163 | | newRelation = Relation(route); commandslist = []; modified = False; i=0; roundabout = [] |
| 164 | | |
| 165 | | for member in route.getMembers(): |
| | 274 | allWaysgoingFromLowerToHigherBeyondEndOfRoute = []; allWaysgoingFromHigherToLowerBeyondEndOfRoute = [] |
| | 275 | nodesWithrXn_ref = {}; likelyCandidateNodesForActualStartOfRoute = {} |
| | 276 | tentacle = 0; tentacles = {}; routeHasStarted = False; high_rXn_refEncountered = 0 |
| | 277 | rXn_refAsInt = None |
| | 278 | # tentacles is a nested list of all the segments of ways wich are present before the actual start of the route |
| | 279 | # sequence, UID of node with rXn_ref, list with ways, reference to next tentacle sequence |
| | 280 | # 1st level: rXn_refs |
| | 281 | # 2nd level: rXn_ref, tentacle sequence, ways, next tentacle |
| | 282 | # {40: [[1, [5n], 2], |
| | 283 | # [2, [3n], 3], |
| | 284 | # [3, [3n, 5n, 7n, 8n], 0], |
| | 285 | # [4, [4n], 0] |
| | 286 | # ], |
| | 287 | # 58: [[1, [2n], 0], |
| | 288 | # [2, [7n], 1] |
| | 289 | # ] |
| | 290 | # } |
| | 291 | newRelation = Relation(route); commandslist = []; i=0; roundabout = [] |
| | 292 | |
| | 293 | if 'sortRouteRelations' in sideEffects: nodesForSorting = {}; beginAndEndNodes = [] |
| | 294 | routeMembers = route.getMembers() |
| | 295 | modified = False |
| | 296 | |
| | 297 | for member in routeMembers: |
| | 298 | memberslist.append(member) |
| 181 | | endnodeId = endnode.getId() |
| 182 | | if not(endnodeId in nodesForSorting): |
| 183 | | nodesForSorting[endnodeId] = [] |
| 184 | | nodesForSorting[endnodeId].append(member) |
| 185 | | |
| 186 | | rcn_ref = endnode.get('rcn_ref') |
| 187 | | if rcn_ref: |
| 188 | | rcn_refAsInt = int(rcn_ref) |
| 189 | | beginAndEndNodes.append([rcn_refAsInt, endnodeId]) |
| 190 | | if not(rcn_refAsInt in rcn_refs): |
| 191 | | rcn_refs.append(rcn_refAsInt) |
| | 322 | endnodeId = endnode.getUniqueId() |
| | 323 | if 'sortRouteRelations' in sideEffects: |
| | 324 | if not(endnodeId in nodesForSorting): |
| | 325 | nodesForSorting[endnodeId] = [] |
| | 326 | nodesForSorting[endnodeId].append(member) |
| | 327 | |
| | 328 | rXn_ref = endnode.get(networklevel + '_ref') |
| | 329 | if rXn_ref: |
| | 330 | rXn_ref_digits = '' |
| | 331 | for character in rXn_ref: |
| | 332 | try: |
| | 333 | int(character) |
| | 334 | rXn_ref_digits += character |
| | 335 | except: pass |
| | 336 | if rXn_ref_digits and rXn_ref_digits==rXn_ref: |
| | 337 | rXn_refAsInt = int(rXn_ref_digits) |
| | 338 | else: |
| | 339 | rXn_refAsInt = -1 |
| | 340 | |
| | 341 | print rXn_ref |
| | 342 | if 'sortRouteRelations' in sideEffects: beginAndEndNodes.append([rXn_refAsInt, endnodeId]) |
| | 343 | # keep track of distinct rXn_ref numbers in a list |
| | 344 | if not(rXn_refAsInt in rXn_refs): |
| | 345 | if len(rXn_refs): high_rXn_refEncountered += 1; tentacle = 0 |
| | 346 | rXn_refs.append(rXn_refAsInt) |
| | 347 | if rXn_refAsInt == -1: |
| | 348 | actual_rXn_refs.append(rXn_ref) |
| | 349 | else: |
| | 350 | actual_rXn_refs.append(str(rXn_refAsInt).zfill(2)) |
| 214 | | elif not(referrer.get('type') in ['route']): |
| 215 | | route_relation_names.append('Node not assigned to network yet') |
| 216 | | # build 2 structures to help check for continuity on ways |
| | 367 | break |
| | 368 | if networkNotFoundForNode: |
| | 369 | route_relation_names.append('Node not assigned to network yet') |
| | 370 | if 'selectObjects' in sideEffects: Main.main.getCurrentDataSet().setSelected(endnode) |
| | 371 | if 'zoomToSelection' in sideEffects: AutoScaleAction.zoomToSelection() |
| | 372 | if 'downloadReferrersForNodes' in sideEffects: |
| | 373 | aDownloadWasNeeded = True |
| | 374 | print "Downloading referrers for ", endnode.get(networklevel + '_ref'), ' ', wayNodes |
| | 375 | DownloadReferrersAction.downloadReferrers(mv.editLayer, wayNodes) |
| | 376 | return None, False, '' |
| | 377 | else: |
| | 378 | print "Would download referrers for ", endnode.get(networklevel + '_ref'), ' ', wayNodes |
| | 379 | |
| | 380 | # *** Now let's process the ways *** |
| | 381 | # build at least 2 structures to help check for continuity on ways |
| | 382 | # possibly there are 'tentacles' before the start or after the end when there are split network nodes |
| | 383 | if logVerbosity > 49: |
| | 384 | print 'L2H', allWaysgoingFromLowerToHigher |
| | 385 | print 'H2L', allWaysgoingFromHigherToLower |
| | 386 | print 'L2H', allWaysgoingFromLowerToHigherBeyondEndOfRoute |
| | 387 | print 'H2L', allWaysgoingFromHigherToLowerBeyondEndOfRoute |
| | 388 | |
| | 391 | else: |
| | 392 | if not(routeHasStarted): |
| | 393 | if role: |
| | 394 | if role in ['forward']: |
| | 395 | firstNode=wayNodes[0] |
| | 396 | else: |
| | 397 | firstNode=wayNodes[-1] |
| | 398 | firstNodeUid = firstNode.getUniqueId() |
| | 399 | print firstNodeUid, firstNodeUid in likelyCandidateNodesForActualStartOfRoute |
| | 400 | if firstNodeUid in likelyCandidateNodesForActualStartOfRoute: print likelyCandidateNodesForActualStartOfRoute[firstNodeUid] |
| | 401 | print likelyCandidateNodesForActualStartOfRoute |
| | 402 | if firstNodeUid in likelyCandidateNodesForActualStartOfRoute and likelyCandidateNodesForActualStartOfRoute[firstNodeUid]>1: |
| | 403 | routeHasStarted = True |
| | 404 | if firstNode.get(networklevel + '_ref'): |
| | 405 | if logVerbosity > 49: print 'rXn_ref', firstNode.get(networklevel + '_ref'), 'found in ', firstNode.getUniqueId() |
| | 406 | # This is not the first member anymore and the first node has an rXn_ref and the member has a role, |
| | 407 | # so we have to assign what we thought was the start of the route to one of our tentacles |
| | 408 | tentacle +=1; reference = 0; interestingNodeId = None; tentacledescription = [] |
| | 409 | if allWaysgoingFromLowerToHigher: |
| | 410 | prevRole = allWaysgoingFromLowerToHigher[-1].getRole() |
| | 411 | if logVerbosity > 49: print 'prevRoleL2H', prevRole |
| | 412 | if prevRole in ['forward']: |
| | 413 | interestingNodeId = allWaysgoingFromLowerToHigher[-1].getWay().getNodes()[-1].getUniqueId() |
| | 414 | elif prevRole in ['backward']: |
| | 415 | interestingNodeId = allWaysgoingFromLowerToHigher[-1].getWay().getNodes()[0].getUniqueId() |
| | 416 | elif allWaysgoingFromHigherToLower: |
| | 417 | prevRole = allWaysgoingFromHigherToLower[-1].getRole() |
| | 418 | if logVerbosity > 49: print 'prevRoleH2L', prevRole |
| | 419 | if prevRole in ['forward']: |
| | 420 | interestingNodeId = allWaysgoingFromHigherToLower[-1].getWay().getNodes()[0].getUniqueId() |
| | 421 | elif prevRole in ['backward']: |
| | 422 | interestingNodeId = allWaysgoingFromHigherToLower[-1].getWay().getNodes()[-1].getUniqueId() |
| | 423 | if interestingNodeId and firstNode.getUniqueId() == interestingNodeId: |
| | 424 | reference = tentacle+1 |
| | 425 | if allWaysgoingFromLowerToHigher: |
| | 426 | tentacledescription = [tentacle, allWaysgoingFromLowerToHigher, reference] |
| | 427 | elif allWaysgoingFromHigherToLower: |
| | 428 | tentacledescription = [tentacle, allWaysgoingFromHigherToLower, reference] |
| | 429 | allWaysgoingFromLowerToHigher = []; allWaysgoingFromHigherToLower = []; branch = None |
| | 430 | if tentacledescription: |
| | 431 | if rXn_refAsInt and not(rXn_refAsInt in tentacles): |
| | 432 | tentacles[rXn_refAsInt] = [] |
| | 433 | tentacles[rXn_refAsInt].append(tentacledescription) |
| | 434 | else: |
| | 435 | # no role on way means this is the actual start of our route |
| | 436 | # so, all that went into allWaysgoingFromLowerToHigher etc has to go to the last tentacle |
| | 437 | routeHasStarted = True |
| | 438 | if allWaysgoingFromLowerToHigher or allWaysgoingFromHigherToLower: |
| | 439 | tentacle +=1 |
| | 440 | if allWaysgoingFromHigherToLower: |
| | 441 | allWaysgoingFromLowerToHigher # .append(allWaysgoingFromHigherToLower) |
| | 442 | tentacledescription = [tentacle, allWaysgoingFromLowerToHigher, 0] |
| | 443 | # allWaysgoingFromHigherToLower was assigned the start of the route in mistake in this case |
| | 444 | # it should have gone to both 'branches', so we create a shallow copy |
| | 445 | allWaysgoingFromLowerToHigher = allWaysgoingFromHigherToLower[:]; branch = None |
| | 446 | if not(rXn_refAsInt in tentacles): |
| | 447 | tentacles[rXn_refAsInt] = [] |
| | 448 | tentacles[rXn_refAsInt].append(tentacledescription) |
| | 449 | if high_rXn_refEncountered > 1: |
| | 450 | # We're past the first high rXn_ref, time to disover more tentacles |
| | 451 | if role: |
| | 452 | if role in ['forward']: |
| | 453 | lastNode=wayNodes[-1] |
| | 454 | else: |
| | 455 | lastNode=wayNodes[0] |
| | 456 | if lastNode.get(networklevel + '_ref'): |
| | 457 | print 'rXn_ref', lastNode.get(networklevel + '_ref'), 'found in ', lastNode.getUniqueId() |
| | 458 | tentacle +=1; reference = 0; interestingNodeId = None; tentacledescription = [] |
| | 459 | if interestingNodeId and lastNode.getUniqueId() == interestingNodeId: |
| | 460 | reference = tentacle+1 |
| | 461 | if allWaysgoingFromLowerToHigher: |
| | 462 | tentacledescription = [tentacle, allWaysgoingFromLowerToHigherBeyondEndOfRoute, reference] |
| | 463 | elif allWaysgoingFromHigherToLower: |
| | 464 | tentacledescription = [tentacle, allWaysgoingFromHigherToLowerBeyondEndOfRoute, reference] |
| | 465 | allWaysgoingFromLowerToHigherBeyondEndOfRoute = []; allWaysgoingFromHigherToLowerBeyondEndOfRoute = []; branch = None |
| | 466 | if tentacledescription: |
| | 467 | if rXn_refAsInt and not(rXn_refAsInt in tentacles): |
| | 468 | tentacles[rXn_refAsInt] = [] |
| | 469 | tentacles[rXn_refAsInt].append(tentacledescription) |
| | 470 | if logVerbosity > 49: print tentacle, repr(tentacles) |
| | 471 | |
| 224 | | lastNodesBeforeSplit = [wayNodes[-1]] |
| 225 | | print 'wayNodes', wayNodes |
| 226 | | print 'lastNodesBeforeSplit', lastNodesBeforeSplit |
| 227 | | print way.getNodesCount(), 'startnode', wayNodes[0], 'endnode', wayNodes[-1] |
| 228 | | print 'roundabout', roundabout |
| 229 | | |
| | 483 | return '', True, '|align="right" | way has no nodes||align="right" | {{BrowseRoute|' + str(route.getId()) + '}}||align="right" needs to be downloaded first\n' |
| | 484 | if logVerbosity > 49: print waynodes |
| | 485 | if logVerbosity > 29: |
| | 486 | print 'lastNodesBeforeSplit', lastNodesBeforeSplit |
| | 487 | print way.getNodesCount(), 'startnode', wayNodes[0], 'endnode', wayNodes[-1] |
| | 488 | print 'roundabout', roundabout |
| | 489 | print wayNodes[-1].get(networklevel + '_ref'),not(member.getUniqueId() == routeMembers[-1].getUniqueId()) |
| 257 | | #if not(continuous_forward) and not(fixme): |
| 258 | | #sortedRelation = sortRouteRelation(route, nodesForSorting, beginAndEndNodes) |
| 259 | | |
| 260 | | #print route |
| 261 | | #print sortedRelation |
| 262 | | #commandsList.append(Command.ChangeCommand(route, sortedRelation)) |
| 263 | | #Main.main.undoRedo.add(Command.SequenceCommand("Sorted route relation", commandsList)) |
| 264 | | #allWaysgoingFromLowerToHigher = []; allWaysgoingFromHigherToLower = [] |
| 265 | | #for member in route.getMembers(): |
| 266 | | #if member.isWay(): |
| 267 | | #role = member.getRole() |
| 268 | | #way = member.getWay() |
| 269 | | #if role=='forward': |
| 270 | | #allWaysgoingFromLowerToHigher.append(member) |
| 271 | | #elif role=='backward': |
| 272 | | #allWaysgoingFromHigherToLower.append(member) |
| 273 | | #else: |
| 274 | | #allWaysgoingFromLowerToHigher.append(member) |
| 275 | | #allWaysgoingFromHigherToLower.append(member) |
| 276 | | #print allWaysgoingFromLowerToHigher |
| 277 | | #continuous_forward = checkForContinuity(allWaysgoingFromLowerToHigher) |
| 278 | | #else: |
| | 559 | if 'sortRouteRelations' in sideEffects and not(continuous_forward) and not(fixme): |
| | 560 | sortedRelation = sortRouteRelation(route, nodesForSorting, beginAndEndNodes) |
| | 561 | |
| | 562 | if logVerbosity>49: |
| | 563 | print route |
| | 564 | print sortedRelation |
| | 565 | |
| | 566 | allWaysgoingFromLowerToHigher = []; allWaysgoingFromHigherToLower = [] |
| | 567 | routeMembers = sortedRelation.getMembers(); i=0 |
| | 568 | for member in routeMembers: |
| | 569 | if member.isWay(): |
| | 570 | role = member.getRole() |
| | 571 | if i==0: |
| | 572 | lastNodesBeforeSplit = [wayNodes] # why nodes in plural? situations occur where the branch starts on a roundabout |
| | 573 | if role and role in ['forward', 'backward']: |
| | 574 | if not(branch): |
| | 575 | if role in ['forward']: |
| | 576 | lastNodesBeforeSplit = [wayNodes[0]] |
| | 577 | else: |
| | 578 | lastNodesBeforeSplit = [wayNodes[-1]] |
| | 579 | if logVerbosity > 29: |
| | 580 | print 'wayNodes', wayNodes |
| | 581 | print 'lastNodesBeforeSplit', lastNodesBeforeSplit |
| | 582 | print way.getNodesCount(), 'startnode', wayNodes[0], 'endnode', wayNodes[-1] |
| | 583 | print 'roundabout', roundabout |
| | 584 | |
| | 585 | if role in ['forward'] and (wayNodes[-1] in lastNodesBeforeSplit or wayNodes[-1] in roundabout): |
| | 586 | branch = 'HigherToLower' |
| | 587 | elif role in ['backward'] and wayNodes[0] in lastNodesBeforeSplit: |
| | 588 | branch = 'HigherToLower' |
| | 589 | elif wayNodes[-1].get(networklevel + '_ref') and not(member.getUniqueId() == routeMembers[-1].getUniqueId()): # not(allWaysgoingFromHigherToLower) and ## this last part is probably not necessary anymore |
| | 590 | # This is for when the route starts forked from a different rXn node (split node situation), we don't want it to kick in for the last member of the route |
| | 591 | branch = 'HigherToLower' |
| | 592 | elif not(branch == 'HigherToLower'): |
| | 593 | branch = 'LowerToHigher' |
| | 594 | print branch |
| | 595 | if branch == 'LowerToHigher': |
| | 596 | allWaysgoingFromLowerToHigher.append(member) |
| | 597 | elif branch == 'HigherToLower': |
| | 598 | allWaysgoingFromHigherToLower.append(member) |
| | 599 | else: |
| | 600 | branch = None; roundabout = [] |
| | 601 | allWaysgoingFromLowerToHigher.append(member) |
| | 602 | allWaysgoingFromHigherToLower.append(member) |
| | 603 | if way.get('junction') == 'roundabout': |
| | 604 | roundabout = way.getNodes() |
| | 605 | i+=1 |
| | 606 | continuous_forward = checkForContinuity(allWaysgoingFromLowerToHigher) |
| | 607 | if continuous_forward: |
| | 608 | # we only want to store the sorted relation, when sorting actually succeeded in getting it continuous |
| | 609 | commandsList.append(Command.ChangeCommand(route, sortedRelation)) |
| | 610 | Main.main.undoRedo.add(Command.SequenceCommand("Sorted route relation", commandsList)) |
| 306 | | newNote = str(rcn_refs[0]).zfill(2) + '-' + str(rcn_refs[1]).zfill(2) |
| 307 | | #print note, newNote |
| 308 | | if not(note) or note != newNote: |
| 309 | | if not(note): note = 'nothing' |
| 310 | | newRelation.put('note', newNote) |
| | 645 | if not(-1 in rXn_refs): |
| | 646 | rXn_refs.sort() |
| | 647 | newNote = str(rXn_refs[0]).zfill(2) + '-' + str(rXn_refs[-1]).zfill(2) |
| | 648 | else: |
| | 649 | newNote = '' |
| | 650 | for ref in actual_rXn_refs: |
| | 651 | newNote+=ref + '-' |
| | 652 | newNote = newNote[:-1] |
| | 653 | if logVerbosity > 49: print note, newNote |
| | 654 | if 'modifyNoteTo_xx-yy' in sideEffects: |
| | 655 | if (not(note) or note != newNote) and rXn_refs[0] != rXn_refs[-1]: |
| | 656 | newRelation = Relation(route) |
| | 657 | #print newRelation.getUniqueId() |
| | 658 | #print route.getUniqueId() |
| | 659 | if not(note): note = 'nothing' |
| | 660 | newRelation.put('note', newNote) |
| | 661 | relationChanged = True |
| | 662 | commandsList.append(Command.ChangeCommand(route, newRelation)) |
| | 663 | |
| | 664 | Main.main.undoRedo.add(Command.SequenceCommand("Changing note from " + note + ' to ' + newNote, commandsList)) |
| | 665 | commandsList = [] |
| | 666 | |
| | 667 | if len(route_relation_names) > 1 and route_relation_names[0] != route_relation_names[1]: |
| | 668 | # print 'This is probably a CONNECTION to another network' |
| | 669 | if logVerbosity > 9: print newNote, route_relation_names |
| | 670 | roleInNetwork = 'connection' |
| | 671 | wikiEN = '' |
| | 672 | else: |
| | 673 | if logVerbosity > 9: print 'less than 2 end nodes with '+networklevel+'_ref found for route', newNote |
| | 674 | wikiEN = 'style="color:red" | ' + repr(rXn_refs) + ' - ?' |
| | 675 | if 'addFixmeTODOtags' in sideEffects and not(route.get(networklevel+':external_connection')) and not(route.get('roundtrip')): |
| | 676 | newRelation = Relation(route) |
| | 677 | #print newRelation.getUniqueId() |
| | 678 | #print route.getUniqueId() |
| | 679 | fixmetodo = 'less than 2 end nodes with '+networklevel+'_ref found for route' + newNote + ' ' + repr(rXn_refs) + ' ' + note |
| | 680 | newRelation.put('fixmetodo', fixmetodo) |
| 330 | | print 'route ',newNote,' is NOT CONTINUOUS in the forward direction' |
| 331 | | #print allWaysgoingFromLowerToHigher |
| | 693 | if logVerbosity > 9: print 'route ',newNote,' is NOT CONTINUOUS going from xx to yy; xx<yy' |
| | 694 | if logVerbosity > 49: print 'L2H:', allWaysgoingFromLowerToHigher |
| | 695 | if not(fixme) and 'addFixmeTODOtags' in sideEffects: |
| | 696 | newRelation = Relation(route) |
| | 697 | #print newRelation.getUniqueId() |
| | 698 | #print route.getUniqueId() |
| | 699 | fixmetodo += ' ' + newNote + 'is not continuous going from xx to yy; xx<yy' |
| | 700 | newRelation.put('fixmetodo', fixmetodo) |
| | 701 | relationChanged = True |
| | 702 | commandsList.append(Command.ChangeCommand(route, newRelation)) |
| | 703 | if not(note): note = 'UNKNOWN' |
| | 704 | |
| | 705 | Main.main.undoRedo.add(Command.SequenceCommand("report that " + note + ' is not continuous going from xx to yy; xx<yy' , commandsList)) |
| | 706 | commandsList = [] |
| 347 | | problem = False |
| 348 | | return roleInNetwork, problem, '|align="right" | ' + note + '||align="right" | {{BrowseRoute|' + str(route.getId()) + '}}||align="right" ' + wikiFM + ' ||' + wikiCF + ' ||' + wikiCB + '\n' |
| 349 | | |
| 350 | | def checkNetwork(network): |
| | 733 | problem = '' |
| | 734 | |
| | 735 | print 'PROBLEM:', problem |
| | 736 | return str(roleInNetwork), problem, '|align="right" | ' + str(note) + '||align="right" | {{BrowseRoute|' + str(route.getId()) + '}}||align="right" ' + str(wikiFM) + ' ||' + str(wikiCF) + ' ||' + str(wikiCB) + ' ||' + str(wikiEN) + '\n' |
| | 737 | |
| | 738 | def sortNetwork(network): |
| | 739 | # While making a list of all the nodes in the relation with an rXn_ref, find the node with the lowest rXn_ref in the network, not necessarily 01 and bring it to the first position |
| | 740 | # Look at the ways connecting to this node and their parent route relations with network=rXn |
| | 741 | # For all these relations, make a list of all the rXn_ref numbers, they lead to and remember the UIDs of these nodes and keep a ref to the relations |
| | 742 | # Split this list in two, one for internal routes, another for route relations connecting to a foreign network (so the ones with a connection role) |
| | 743 | # Sort both lists and bring the relations in positions following the first node |
| | 744 | # Do the same for all the relations in the second list |
| | 745 | # Then add the lowest rXn_ref number and remove it from the general todo list of rXn_ref nodes that were encountered in internal route relations |
| 352 | | print '********************************************' |
| 353 | | print name |
| 354 | | print '********************************************' |
| 355 | | #'===' + name + '===\n' + |
| 356 | | wikiReportOnNodes = ('{| class="wikitable" align="left" style="margin:0 0 2em 2em;"\n|-\n|+' + name + |
| 357 | | '\n|-\n!style="width:2.5em" | Node\n!Link\n! # Roads\n! # Relations\n|-\n') |
| 358 | | |
| 359 | | wikiReportOnRelations = ('{| class="wikitable" align="left" style="margin:0 0 2em 2em;"\n|-\n|+' + name + |
| 360 | | '\n|-\n!style="width:2.5em" | note\n!link\n!fixme\n! forward\n! backward\n|-\n') |
| | 747 | if logVerbosity>19: |
| | 748 | print '********************************************' |
| | 749 | print name |
| | 750 | print '********************************************' |
| | 751 | lowestrXn_refInNetwork=9999; listOfNodeMembersSeen = [] |
| | 752 | dictionaryWithAllNodesBelongingToThisNetwork = {}; dictionaryWithAllNodesBelongingToNeighbouringNetworks = {} |
| | 753 | ListOfInternalRoutesSeen = []; ListOfExternalRoutesSeen = []; dictionaryLinkingRoutesToNotes = {} |
| | 754 | members = network.getMembers() |
| | 755 | # Find a member node with the lowestrXn_refInNetwork and bring it to the front if such node is not there yet |
| | 756 | firstMember = members[0] |
| | 757 | if firstMember.isRelation() or firstMember.isNode() and int(firstMember.getNode().get(networklevel + '_ref')) != lowestrXn_refInNetwork: |
| | 758 | memberNode = None |
| | 759 | for networkMember in members: |
| | 760 | if networkMember.isNode(): |
| | 761 | memberNode = networkMember.getNode() |
| | 762 | if int(memberNode.get(networklevel + '_ref')) == 1: break |
| | 763 | if memberNode: |
| | 764 | network.removeMembersFor(memberNode) |
| | 765 | network.addMember(0, networkMember) |
| | 766 | |
| | 767 | for networkMember in network.getMembers(): |
| | 768 | if networkMember.isNode(): |
| | 769 | node = networkMember.getNode() |
| | 770 | rXn_ref = node.get(networklevel + '_ref') |
| | 771 | if int(rXn_ref) == 1: |
| | 772 | referrersForNode = node.getReferrers() |
| | 773 | for referrer in referrersForNode: |
| | 774 | if referrer.getType() is dummy_way.getType(): |
| | 775 | referrersForWay = referrer.getReferrers() |
| | 776 | for wayReferrer in referrersForWay: |
| | 777 | if wayReferrer.getType() is dummy_relation.getType(): |
| | 778 | aRelation = wayReferrer |
| | 779 | if aRelation.get('type') == 'route' and aRelation.get('network') ==networklevel and not(aRelation.get('ref')): |
| | 780 | rXnNetworkCountForNode+=1 |
| | 781 | if aRelation.hasIncompleteMembers(): |
| | 782 | name = aRelation.get('name') |
| | 783 | if not(name): name = '' |
| | 784 | note = aRelation.get('note') |
| | 785 | if not(note): note = '' |
| | 786 | networkname = aRelation.get('network') |
| | 787 | if not(networkname): networkname = '' |
| | 788 | if 'downloadIncompleteMembers' in sideEffects: |
| | 789 | aDownloadWasNeeded = True |
| | 790 | print 'Downloading incomplete members for', note |
| | 791 | DownloadRelationMemberTask.run(DownloadRelationMemberTask(aRelation, aRelation.getIncompleteMembers(), mv.editLayer )) |
| | 792 | time.sleep(1) |
| | 793 | continue |
| | 794 | else: |
| | 795 | JOptionPane.showMessageDialog(Main.parent, 'Please download all incomplete members of the route relations first: ' + networkname + ' ' + note + ' ' + name) |
| | 796 | break |
| | 797 | networkMembersList = [] |
| | 798 | for subMember in network.getMembers(): |
| | 799 | if subMember.isRelation(): |
| | 800 | routeRelation = subMember.getRelation() |
| | 801 | networkMembersList.append(routeRelation.getUniqueId()) |
| | 802 | routeId = aRelation.getUniqueId() |
| | 803 | if rXnRelationWeWantToProcess and not(routeId in networkMembersList): |
| | 804 | roleFromRouteCheck, problemReported, wikiReport = checkRCNroute(aRelation, aDownloadWasNeeded) |
| | 805 | if problemReported and 'createWikiReport' in sideEffects: |
| | 806 | wikiReportOnRelations += wikiReport + '\n|-\n' |
| | 807 | if 'addRouteToNetwork' in sideEffects and not(aDownloadWasNeeded): |
| | 808 | newRelation = Relation(network) |
| | 809 | newmember = RelationMember(roleFromRouteCheck, aRelation) |
| | 810 | if logVerbosity > 9: print newRelation.getMembersCount(), ' ',i, ' ', newmember |
| | 811 | newRelation.addMember( i, newmember) |
| | 812 | commandsList = [] |
| | 813 | commandsList.append(Command.ChangeCommand(network, newRelation)) |
| | 814 | note = aRelation.get('note') |
| | 815 | if not(note): |
| | 816 | note = '' |
| | 817 | Main.main.undoRedo.add(Command.SequenceCommand("Adding " + note + " to network", commandsList)) |
| | 818 | commandsList = [] |
| | 819 | if logVerbosity > 9: print 'Added newly found RCN route relation to network: ', note |
| | 820 | i+=1 |
| | 821 | |
| | 822 | def checkNetwork(network, networklevel, aDownloadWasNeeded): |
| | 823 | name = ''; name = network.get('name') |
| | 824 | if logVerbosity>19: |
| | 825 | print '********************************************' |
| | 826 | print name |
| | 827 | print '********************************************' |
| | 828 | if 'createWikiReport' in sideEffects: |
| | 829 | wikiReportOnNodes = ('\n==' + name + '==\n{| class="wikitable" align="left" style="margin:0 0 2em 2em;"\n|-\n|+' + name + |
| | 830 | '\n|-\n!style="width:2.5em" | Node\n!Link\n! # Roads\n! # Relations\n|-\n') |
| | 831 | wikiReportOnRelations = ('{| class="wikitable" align="left" style="margin:0 0 2em 2em;"\n|-\n|+' + name + |
| | 832 | '\n|-\n!style="width:2.5em" | note\n!link\n!fixme\n! forward\n! backward\n! end nodes\n|-\n') |
| 362 | | for networkmember in network.getMembers(): |
| 363 | | if networkmember.isRelation(): |
| 364 | | subrelation = networkmember.getRelation() |
| 365 | | if subrelation.hasIncompleteMembers(): |
| 366 | | #JOptionPane.showMessageDialog(Main.parent, 'Please download all incomplete member of the route relations first') |
| 367 | | DownloadRelationMemberTask.run(DownloadRelationMemberTask(subrelation, subrelation.getIncompleteMembers(), mv.editLayer )) |
| 368 | | break |
| 369 | | roleFromRouteCheck, problemReported, wikiReport = checkRCNroute(subrelation) |
| 370 | | if problemReported: |
| 371 | | wikiReportOnRelations += wikiReport + '\n|-\n' |
| 372 | | #if roleFromRouteCheck: |
| 373 | | role = networkmember.getRole() |
| 374 | | if role != roleFromRouteCheck: |
| 375 | | print |
| 376 | | print 'Role in network is ', role |
| 377 | | print 'Maybe this should be: ', roleFromRouteCheck |
| 378 | | if networkmember.isNode(): |
| 379 | | node = networkmember.getNode() |
| 380 | | rcn_ref = node.get('rcn_ref') |
| 381 | | expected_rcn_route_relations = node.get('expected_rcn_route_relations') |
| 382 | | if expected_rcn_route_relations: |
| 383 | | expected_rcn_route_relations = int(expected_rcn_route_relations) |
| | 834 | for networkMember in network.getMembers(): |
| | 835 | if networkMember.isRelation(): |
| | 836 | routeRelation = networkMember.getRelation() |
| | 837 | if routeRelation.get('network') ==networklevel: |
| | 838 | if routeRelation.hasIncompleteMembers(): |
| | 839 | name = routeRelation.get('name') |
| | 840 | if not(name): name = '' |
| | 841 | note = routeRelation.get('note') |
| | 842 | if not(note): note = '' |
| | 843 | kindOfNetwork = routeRelation.get('network') |
| | 844 | if not(kindOfNetwork): kindOfNetwork = '' |
| | 845 | if 'downloadIncompleteMembers' in sideEffects: |
| | 846 | aDownloadWasNeeded = True |
| | 847 | print 'Downloading incomplete members for', note |
| | 848 | DownloadRelationMemberTask.run(DownloadRelationMemberTask(routeRelation, routeRelation.getIncompleteMembers(), mv.editLayer )) |
| | 849 | time.sleep(1) |
| | 850 | continue |
| | 851 | else: |
| | 852 | JOptionPane.showMessageDialog(Main.parent, 'Please download all incomplete members of the route relations first: ' + kindOfNetwork + ' ' + note + ' ' + name) |
| | 853 | break |
| | 854 | roleFromRouteCheck, problemReported, wikiReport = checkRxNroute(routeRelation, networklevel, aDownloadWasNeeded) |
| | 855 | if problemReported and 'createWikiReport' in sideEffects: |
| | 856 | wikiReportOnRelations += wikiReport + '\n|-\n' |
| | 857 | role = networkMember.getRole() |
| | 858 | if logVerbosity > 29 and role != roleFromRouteCheck: |
| | 859 | print |
| | 860 | print 'Role in network is ', role |
| | 861 | print 'Maybe this should be: ', roleFromRouteCheck |
| | 862 | if networkMember.isNode(): |
| | 863 | node = networkMember.getNode() |
| | 864 | rXn_ref = node.get(networklevel + '_ref') |
| | 865 | expected_rXn_route_relations = node.get('expected_' + networklevel + '_route_relations') |
| | 866 | if expected_rXn_route_relations: |
| | 867 | expected_rXn_route_relations = int(expected_rXn_route_relations) |
| 407 | | if len(referrersForWay) < 1: |
| 408 | | Main.main.getCurrentDataSet().setSelected(referrer) |
| 409 | | AutoScaleAction.zoomToSelection() |
| 410 | | ##selectedWay = mv.editLayer.data.getSelected() |
| 411 | | #DownloadReferrersAction.downloadReferrers(mv.editLayer, referrersForNode) |
| 412 | | referrersForWay = referrer.getReferrers() |
| 413 | | for wayreferrer in referrersForWay: |
| 414 | | if wayreferrer.getType() is dummy_relation.getType(): |
| 415 | | memberslist = [] |
| 416 | | if wayreferrer.get('type') == 'route' and wayreferrer.get('network') == 'rcn': |
| 417 | | rcnNetworkCountForNode+=1 |
| 418 | | for submember in network.getMembers(): |
| 419 | | if submember.isRelation(): |
| 420 | | subrelation = submember.getRelation() |
| 421 | | memberslist.append(subrelation.getId()) |
| 422 | | if not(wayreferrer.getId()): |
| 423 | | print dir(wayreferrer) |
| 424 | | break |
| 425 | | routeId = wayreferrer.getId() |
| 426 | | if not(routeId) or not(routeId in memberslist): |
| 427 | | if wayreferrer.get('network') == 'rcn': |
| 428 | | roleFromRouteCheck, problemReported, wikiReport = checkRCNroute(wayreferrer) |
| 429 | | print wikiReport |
| 430 | | if problemReported: |
| 431 | | wikiReportOnRelations += wikiReport + '\n|-\n' |
| | 892 | if len(referrersForWay) < 1 and 'downloadReferrersForWays' in sideEffects: |
| | 893 | aDownloadWasNeeded = True |
| | 894 | if 'selectObjects' in sideEffects: Main.main.getCurrentDataSet().setSelected(referrer) |
| | 895 | if 'zoomToSelection' in sideEffects: AutoScaleAction.zoomToSelection() |
| | 896 | print 'Downloading referrers for ', referrer.get('name') , ' ', rXn_ref |
| | 897 | DownloadReferrersAction.downloadReferrers(mv.editLayer, referrer) |
| | 898 | |
| | 899 | for wayReferrer in referrersForWay: |
| | 900 | if wayReferrer.getType() is dummy_relation.getType(): |
| | 901 | aRelation = wayReferrer |
| | 902 | rXnRelationWeWantToProcess = False # We need this again further on, when deciding whether or not to add this relation to the network |
| | 903 | if aRelation.get('type') == 'route' and aRelation.get('network') ==networklevel and not(aRelation.get('ref')): # in ['RUR','NRR','NRW','2LR','3LR','KAI','EHR','DFR','WBR','Nk']): |
| | 904 | # The check on the ref is for Germany, where many rXn networks run crisscross through another. |
| | 905 | # We wouldn't want to get entangled in that mess. |
| | 906 | # The list is continuously getting longer, of course. But it's the best we can do here |
| | 907 | rXnRelationWeWantToProcess = True |
| | 908 | rXnNetworkCountForNode+=1 |
| | 909 | if aRelation.hasIncompleteMembers(): |
| | 910 | name = aRelation.get('name') |
| | 911 | if not(name): name = '' |
| | 912 | note = aRelation.get('note') |
| | 913 | if not(note): note = '' |
| | 914 | kindOfNetwork = aRelation.get('network') |
| | 915 | if not(kindOfNetwork): kindOfNetwork = '' |
| | 916 | if 'downloadIncompleteMembers' in sideEffects: |
| | 917 | aDownloadWasNeeded = True |
| | 918 | print 'Downloading incomplete members for', note |
| | 919 | DownloadRelationMemberTask.run(DownloadRelationMemberTask(aRelation, aRelation.getIncompleteMembers(), mv.editLayer )) |
| | 920 | time.sleep(1) |
| | 921 | continue |
| | 922 | else: |
| | 923 | JOptionPane.showMessageDialog(Main.parent, 'Please download all incomplete members of the route relations first: ' + kindOfNetwork + ' ' + note + ' ' + name) |
| | 924 | break |
| | 925 | networkMembersList = [] |
| | 926 | # print network |
| | 927 | for subMember in network.getMembers(): |
| | 928 | if subMember.isRelation(): |
| | 929 | routeRelation = subMember.getRelation() |
| | 930 | networkMembersList.append(routeRelation.getUniqueId()) |
| | 931 | routeId = aRelation.getUniqueId() |
| | 932 | if rXnRelationWeWantToProcess and not(routeId in networkMembersList): |
| | 933 | roleFromRouteCheck, problemReported, wikiReport = checkRxNroute(aRelation, networklevel, aDownloadWasNeeded) |
| | 934 | if problemReported and 'createWikiReport' in sideEffects: |
| | 935 | wikiReportOnRelations += wikiReport + '\n|-\n' |
| | 936 | if 'addRouteToNetwork' in sideEffects and not(aDownloadWasNeeded): |
| 451 | | print |
| 452 | | wikiReportOnNodes += ('|-\n|}\n') |
| 453 | | wikiReportOnRelations += ('|-\n|}\n<br style="clear:left;" />\n') |
| 454 | | fh = open('C:/wikiReport.txt', 'a') |
| 455 | | fh.write(wikiReportOnNodes) |
| 456 | | fh.write(wikiReportOnRelations) |
| 457 | | fh.close() |
| 458 | | |
| | 955 | if logVerbosity > 19: print |
| | 956 | if 'createWikiReport' in sideEffects: |
| | 957 | fh = codecs.open(wikiReportFN, 'a', encoding="UTF-8") |
| | 958 | wikiReportOnNodes += ('|-\n|}\n') |
| | 959 | wikiReportOnRelations += ('|-\n|}\n<br style="clear:left;" />\n') |
| | 960 | fh.write(wikiReportOnNodes) |
| | 961 | fh.write(wikiReportOnRelations) |
| | 962 | fh.close() |
| | 963 | |
| | 964 | def checkAssociatedStreet(street): |
| | 965 | streetnameOfRelation = street.get('name') |
| | 966 | streetname = []; housenumber = [] |
| | 967 | for member in street.getMembers(): |
| | 968 | role = member.getRole() |
| | 969 | if role =='street': |
| | 970 | if member.isWay(): |
| | 971 | m = member.getWay() |
| | 972 | elif member.isRelation(): |
| | 973 | m = member.getRelation() |
| | 974 | sname = m.get('name') |
| | 975 | if sname and not(sname in streetname): |
| | 976 | streetname.append(sname) |
| | 977 | elif role =='house': |
| | 978 | if member.isNode(): |
| | 979 | element = member.getNode() |
| | 980 | elif member.isWay(): |
| | 981 | element = member.getWay() |
| | 982 | housenumber=element.get('addr:housenumber') |
| | 983 | sname = element.get('addr:street') |
| | 984 | if sname and not(sname in streetname): |
| | 985 | streetname.append(sname) |
| | 986 | #print streetnameOfRelation, streetname, housenumber |
| | 987 | if len(streetname) != 1 or streetnameOfRelation!=streetname[0]: |
| | 988 | print streetnameOfRelation, len(streetname), streetname |
| | 989 | |
| | 990 | aDownloadWasNeeded = False |
| | 991 | ''' |
| | 992 | Since Downloading referrers or missing members happens asynchronously in a separate worker thread |
| | 993 | the script can run in three modes |
| | 994 | |
| | 995 | 1. No downloads allowed/offline run; output mentions that data was incomplete in its reports. |
| | 996 | 2. Download run; When incomplete items are encountered, they are scheduled to be downloaded. From then on, no more quality checks are performed on the data. |
| | 997 | All hierarchies are still checked, looking for more incomplete data for which more downloads need to be scheduled. |
| | 998 | 3. Normal run; All data is available and proper reporting can be performed. |
| | 999 | ''' |
| 477 | | #JOptionPane.showMessageDialog(Main.parent, 'Please download all incomplete member of the relations first') |
| 478 | | DownloadRelationMemberTask.run(DownloadRelationMemberTask(relation, relation.getIncompleteMembers(), mv.editLayer )) |
| 479 | | break |
| 480 | | if relation.get('type') == 'route' and relation.get('network') == 'rcn': |
| 481 | | checkRCNroute(relation) |
| 482 | | if relation.get('type') == 'network' and relation.get('network') == 'rcn': |
| 483 | | checkNetwork(relation) |
| 484 | | if relation.get('type') == 'collection' and relation.get('network') == 'rcn': |
| 485 | | for networkmember in relation.getMembers(): |
| 486 | | if networkmember.isRelation(): |
| 487 | | subrelation = networkmember.getRelation() |
| 488 | | if subrelation.hasIncompleteMembers(): |
| 489 | | #JOptionPane.showMessageDialog(Main.parent, 'Please download all incomplete member of the network relations first') |
| 490 | | DownloadRelationMemberTask.run(DownloadRelationMemberTask(subrelation, subrelation.getIncompleteMembers(), mv.editLayer )) |
| 491 | | #break |
| 492 | | checkNetwork(subrelation) |
| 493 | | |
| | 1017 | if 'downloadIncompleteMembers' in sideEffects: |
| | 1018 | aDownloadWasNeeded = True |
| | 1019 | print 'Downloading referrers for ', str(relation.get('name')), ' ', str(relation.get('note')) |
| | 1020 | DownloadRelationMemberTask.run(DownloadRelationMemberTask(relation, relation.getIncompleteMembers(), mv.editLayer )) |
| | 1021 | continue |
| | 1022 | else: |
| | 1023 | JOptionPane.showMessageDialog(Main.parent, 'Please download all incomplete member of the relations first') |
| | 1024 | exit() |
| | 1025 | networklevel = relation.get('network') |
| | 1026 | relationType = relation.get('type') |
| | 1027 | |
| | 1028 | if networklevel in ('rcn','rwn','rhn'): |
| | 1029 | if relationType == 'route': |
| | 1030 | checkRxNroute(relation, networklevel, aDownloadWasNeeded) |
| | 1031 | elif relationType == 'network': |
| | 1032 | checkNetwork(relation, networklevel, aDownloadWasNeeded) |
| | 1033 | elif relationType == 'collection': |
| | 1034 | for collectionMember in relation.getMembers(): |
| | 1035 | if collectionMember.isRelation(): |
| | 1036 | networkRelation = collectionMember.getRelation() |
| | 1037 | if networkRelation.hasIncompleteMembers(): |
| | 1038 | name = networkRelation.get('name') |
| | 1039 | if not(name): name = '' |
| | 1040 | networkname = networkRelation.get('network') |
| | 1041 | if not(networkname): networkname = '' |
| | 1042 | if 'downloadIncompleteMembers' in sideEffects: |
| | 1043 | aDownloadWasNeeded = True |
| | 1044 | print 'Downloading referrers for ', name |
| | 1045 | DownloadRelationMemberTask.run(DownloadRelationMemberTask(networkRelation, networkRelation.getIncompleteMembers(), mv.editLayer )) |
| | 1046 | continue |
| | 1047 | else: |
| | 1048 | JOptionPane.showMessageDialog(Main.parent, 'Please download all incomplete members of the network relations first:' + networkname + ' ' + name) |
| | 1049 | break |
| | 1050 | checkNetwork(networkRelation, networklevel, aDownloadWasNeeded) |
| | 1051 | elif relationType == 'associatedStreet': |
| | 1052 | checkAssociatedStreet(relation) |
| | 1053 | elif relationType == "route_master": |
| | 1054 | pass |
| | 1055 | elif relationType == "route" and relation.get('route') in ['bus','tram']: |
| | 1056 | checkPTroute(relation, aDownloadWasNeeded) |
| | 1057 | |
| | 1058 | if aDownloadWasNeeded: |
| | 1059 | JOptionPane.showMessageDialog(Main.parent, 'There was incomplete data and downloading mode was initiated,\nNo further quality checks were performed.\nPlease run the script again when all downloads have completed') |
