| 45 | | import codecs |
| 46 | | |
| 47 | | |
| 48 | | # the file name where the report for the wiki goes, needs to be configurable |
| 49 | | wikiReportFN = 'C:/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, # not implemented yet |
| 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, # not implemented yet |
| 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 = 20 |
| 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 | | ''' |
| 373 | | else: |
| 374 | | if not(routeHasStarted): |
| 375 | | if role: |
| 376 | | if role in ['forward']: |
| 377 | | firstNode=wayNodes[0] |
| 378 | | else: |
| 379 | | firstNode=wayNodes[-1] |
| 380 | | firstNodeUid = firstNode.getUniqueId() |
| 381 | | print firstNodeUid, firstNodeUid in likelyCandidateNodesForActualStartOfRoute |
| 382 | | if firstNodeUid in likelyCandidateNodesForActualStartOfRoute: print likelyCandidateNodesForActualStartOfRoute[firstNodeUid] |
| 383 | | print likelyCandidateNodesForActualStartOfRoute |
| 384 | | if firstNodeUid in likelyCandidateNodesForActualStartOfRoute and likelyCandidateNodesForActualStartOfRoute[firstNodeUid]>1: |
| 385 | | routeHasStarted = True |
| 386 | | if firstNode.get(networklevel + '_ref'): |
| 387 | | if logVerbosity > 49: print 'rXn_ref', firstNode.get(networklevel + '_ref'), 'found in ', firstNode.getUniqueId() |
| 388 | | # This is not the first member anymore and the first node has an rXn_ref and the member has a role, |
| 389 | | # so we have to assign what we thought was the start of the route to one of our tentacles |
| 390 | | tentacle +=1; reference = 0; interestingNodeId = None; tentacledescription = [] |
| 391 | | if allWaysgoingFromLowerToHigher: |
| 392 | | prevRole = allWaysgoingFromLowerToHigher[-1].getRole() |
| 393 | | if logVerbosity > 49: print 'prevRoleL2H', prevRole |
| 394 | | if prevRole in ['forward']: |
| 395 | | interestingNodeId = allWaysgoingFromLowerToHigher[-1].getWay().getNodes()[-1].getUniqueId() |
| 396 | | elif prevRole in ['backward']: |
| 397 | | interestingNodeId = allWaysgoingFromLowerToHigher[-1].getWay().getNodes()[0].getUniqueId() |
| 398 | | elif allWaysgoingFromHigherToLower: |
| 399 | | prevRole = allWaysgoingFromHigherToLower[-1].getRole() |
| 400 | | if logVerbosity > 49: print 'prevRoleH2L', prevRole |
| 401 | | if prevRole in ['forward']: |
| 402 | | interestingNodeId = allWaysgoingFromHigherToLower[-1].getWay().getNodes()[0].getUniqueId() |
| 403 | | elif prevRole in ['backward']: |
| 404 | | interestingNodeId = allWaysgoingFromHigherToLower[-1].getWay().getNodes()[-1].getUniqueId() |
| 405 | | if interestingNodeId and firstNode.getUniqueId() == interestingNodeId: |
| 406 | | reference = tentacle+1 |
| 407 | | if allWaysgoingFromLowerToHigher: |
| 408 | | tentacledescription = [tentacle, allWaysgoingFromLowerToHigher, reference] |
| 409 | | elif allWaysgoingFromHigherToLower: |
| 410 | | tentacledescription = [tentacle, allWaysgoingFromHigherToLower, reference] |
| 411 | | allWaysgoingFromLowerToHigher = []; allWaysgoingFromHigherToLower = []; branch = None |
| 412 | | if tentacledescription: |
| 413 | | if rXn_refAsInt and not(rXn_refAsInt in tentacles): |
| 414 | | tentacles[rXn_refAsInt] = [] |
| 415 | | tentacles[rXn_refAsInt].append(tentacledescription) |
| | 219 | if role and role in ['forward', 'backward']: |
| | 220 | if not(branch): |
| | 221 | if role in ['forward']: |
| | 222 | lastNodesBeforeSplit = [wayNodes[0]] |
| 417 | | # no role on way means this is the actual start of our route |
| 418 | | # so, all that went into allWaysgoingFromLowerToHigher etc has to go to the last tentacle |
| 419 | | routeHasStarted = True |
| 420 | | if allWaysgoingFromLowerToHigher or allWaysgoingFromHigherToLower: |
| 421 | | tentacle +=1 |
| 422 | | if allWaysgoingFromHigherToLower: |
| 423 | | allWaysgoingFromLowerToHigher # .append(allWaysgoingFromHigherToLower) |
| 424 | | tentacledescription = [tentacle, allWaysgoingFromLowerToHigher, 0] |
| 425 | | # allWaysgoingFromHigherToLower was assigned the start of the route in mistake in this case |
| 426 | | # it should have gone to both 'branches', so we create a shallow copy |
| 427 | | allWaysgoingFromLowerToHigher = allWaysgoingFromHigherToLower[:]; branch = None |
| 428 | | if not(rXn_refAsInt in tentacles): |
| 429 | | tentacles[rXn_refAsInt] = [] |
| 430 | | tentacles[rXn_refAsInt].append(tentacledescription) |
| 431 | | if high_rXn_refEncountered > 1: |
| 432 | | # We're past the first high rXn_ref, time to disover more tentacles |
| 433 | | if role: |
| 434 | | if role in ['forward']: |
| 435 | | lastNode=wayNodes[-1] |
| 436 | | else: |
| 437 | | lastNode=wayNodes[0] |
| 438 | | if lastNode.get(networklevel + '_ref'): |
| 439 | | print 'rXn_ref', lastNode.get(networklevel + '_ref'), 'found in ', lastNode.getUniqueId() |
| 440 | | tentacle +=1; reference = 0; interestingNodeId = None; tentacledescription = [] |
| 441 | | if interestingNodeId and lastNode.getUniqueId() == interestingNodeId: |
| 442 | | reference = tentacle+1 |
| 443 | | if allWaysgoingFromLowerToHigher: |
| 444 | | tentacledescription = [tentacle, allWaysgoingFromLowerToHigherBeyondEndOfRoute, reference] |
| 445 | | elif allWaysgoingFromHigherToLower: |
| 446 | | tentacledescription = [tentacle, allWaysgoingFromHigherToLowerBeyondEndOfRoute, reference] |
| 447 | | allWaysgoingFromLowerToHigherBeyondEndOfRoute = []; allWaysgoingFromHigherToLowerBeyondEndOfRoute = []; branch = None |
| 448 | | if tentacledescription: |
| 449 | | if rXn_refAsInt and not(rXn_refAsInt in tentacles): |
| 450 | | tentacles[rXn_refAsInt] = [] |
| 451 | | tentacles[rXn_refAsInt].append(tentacledescription) |
| 452 | | if logVerbosity > 49: print tentacle, repr(tentacles) |
| 453 | | |
| 454 | | if role and role in ['forward', 'backward']: |
| 455 | | # if there is a role, it might be part of the route proper when it starts or ends in a fork |
| 456 | | # this is what we suppose, if we encounter another node with a low rXn_ref, we add what we already had |
| 457 | | # to the tentacles structure and clear fromLowToHigh |
| 458 | | if not(branch): |
| 459 | | if wayNodes: |
| 460 | | if role in ['forward']: |
| 461 | | lastNodesBeforeSplit = [wayNodes[0]] |
| 462 | | else: |
| 463 | | lastNodesBeforeSplit = [wayNodes[-1]] |
| 464 | | else: |
| 465 | | return '', True, '|align="right" | way has no nodes||align="right" | {{BrowseRoute|' + str(route.getId()) + '}}||align="right" needs to be downloaded first\n' |
| 466 | | if logVerbosity > 49: print waynodes |
| 467 | | if logVerbosity > 29: |
| 468 | | print 'lastNodesBeforeSplit', lastNodesBeforeSplit |
| 469 | | print way.getNodesCount(), 'startnode', wayNodes[0], 'endnode', wayNodes[-1] |
| 470 | | print 'roundabout', roundabout |
| 471 | | print wayNodes[-1].get(networklevel + '_ref'),not(member.getUniqueId() == routeMembers[-1].getUniqueId()) |
| | 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 | |
| 541 | | if 'sortRouteRelations' in sideEffects and not(continuous_forward) and not(fixme): |
| 542 | | sortedRelation = sortRouteRelation(route, nodesForSorting, beginAndEndNodes) |
| 543 | | |
| 544 | | if logVerbosity>49: |
| 545 | | print route |
| 546 | | print sortedRelation |
| 547 | | |
| 548 | | allWaysgoingFromLowerToHigher = []; allWaysgoingFromHigherToLower = [] |
| 549 | | routeMembers = sortedRelation.getMembers(); i=0 |
| 550 | | for member in routeMembers: |
| 551 | | if member.isWay(): |
| 552 | | role = member.getRole() |
| 553 | | if i==0: |
| 554 | | lastNodesBeforeSplit = [wayNodes] # why nodes in plural? situations occur where the branch starts on a roundabout |
| 555 | | if role and role in ['forward', 'backward']: |
| 556 | | if not(branch): |
| 557 | | if role in ['forward']: |
| 558 | | lastNodesBeforeSplit = [wayNodes[0]] |
| 559 | | else: |
| 560 | | lastNodesBeforeSplit = [wayNodes[-1]] |
| 561 | | if logVerbosity > 29: |
| 562 | | print 'wayNodes', wayNodes |
| 563 | | print 'lastNodesBeforeSplit', lastNodesBeforeSplit |
| 564 | | print way.getNodesCount(), 'startnode', wayNodes[0], 'endnode', wayNodes[-1] |
| 565 | | print 'roundabout', roundabout |
| 566 | | |
| 567 | | if role in ['forward'] and (wayNodes[-1] in lastNodesBeforeSplit or wayNodes[-1] in roundabout): |
| 568 | | branch = 'HigherToLower' |
| 569 | | elif role in ['backward'] and wayNodes[0] in lastNodesBeforeSplit: |
| 570 | | branch = 'HigherToLower' |
| 571 | | elif wayNodes[-1].get(networklevel + '_ref') and not(member.getUniqueId() == routeMembers[-1].getUniqueId()): # not(allWaysgoingFromHigherToLower) and ## this last part is probably not necessary anymore |
| 572 | | # 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 |
| 573 | | branch = 'HigherToLower' |
| 574 | | elif not(branch == 'HigherToLower'): |
| 575 | | branch = 'LowerToHigher' |
| 576 | | print branch |
| 577 | | if branch == 'LowerToHigher': |
| 578 | | allWaysgoingFromLowerToHigher.append(member) |
| 579 | | elif branch == 'HigherToLower': |
| 580 | | allWaysgoingFromHigherToLower.append(member) |
| 581 | | else: |
| 582 | | branch = None; roundabout = [] |
| 583 | | allWaysgoingFromLowerToHigher.append(member) |
| 584 | | allWaysgoingFromHigherToLower.append(member) |
| 585 | | if way.get('junction') == 'roundabout': |
| 586 | | roundabout = way.getNodes() |
| 587 | | i+=1 |
| 588 | | continuous_forward = checkForContinuity(allWaysgoingFromLowerToHigher) |
| 589 | | if continuous_forward: |
| 590 | | # we only want to store the sorted relation, when sorting actually succeeded in getting it continuous |
| 591 | | commandsList.append(Command.ChangeCommand(route, sortedRelation)) |
| 592 | | Main.main.undoRedo.add(Command.SequenceCommand("Sorted route relation", commandsList)) |
| 593 | | else: |
| 594 | | # a route relation with only one way member |
| | 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: |
| | 279 | else: |
| 627 | | if not(-1 in rXn_refs): |
| 628 | | rXn_refs.sort() |
| 629 | | newNote = str(rXn_refs[0]).zfill(2) + '-' + str(rXn_refs[-1]).zfill(2) |
| 630 | | else: |
| 631 | | newNote = '' |
| 632 | | for ref in actual_rXn_refs: |
| 633 | | newNote+=ref + '-' |
| 634 | | newNote = newNote[:-1] |
| 635 | | if logVerbosity > 49: print note, newNote |
| 636 | | if 'modifyNoteTo_xx-yy' in sideEffects: |
| 637 | | if (not(note) or note != newNote) and rXn_refs[0] != rXn_refs[-1]: |
| 638 | | newRelation = Relation(route) |
| 639 | | #print newRelation.getUniqueId() |
| 640 | | #print route.getUniqueId() |
| 641 | | if not(note): note = 'nothing' |
| 642 | | newRelation.put('note', newNote) |
| 643 | | relationChanged = True |
| 644 | | commandsList.append(Command.ChangeCommand(route, newRelation)) |
| 645 | | |
| 646 | | Main.main.undoRedo.add(Command.SequenceCommand("Changing note from " + note + ' to ' + newNote, commandsList)) |
| 647 | | commandsList = [] |
| 648 | | |
| 649 | | if len(route_relation_names) > 1 and route_relation_names[0] != route_relation_names[1]: |
| 650 | | # print 'This is probably a CONNECTION to another network' |
| 651 | | if logVerbosity > 9: print newNote, route_relation_names |
| 652 | | roleInNetwork = 'connection' |
| 653 | | wikiEN = '' |
| 654 | | else: |
| 655 | | if logVerbosity > 9: print 'less than 2 end nodes with '+networklevel+'_ref found for route', newNote |
| 656 | | wikiEN = 'style="color:red" | ' + repr(rXn_refs) + ' - ?' |
| 657 | | if 'addFixmeTODOtags' in sideEffects and not(route.get(networklevel+':external_connection')) and not(route.get('roundtrip')): |
| 658 | | newRelation = Relation(route) |
| 659 | | #print newRelation.getUniqueId() |
| 660 | | #print route.getUniqueId() |
| 661 | | fixmetodo = 'less than 2 end nodes with '+networklevel+'_ref found for route' + newNote + ' ' + repr(rXn_refs) + ' ' + note |
| 662 | | newRelation.put('fixmetodo', fixmetodo) |
| | 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) |
| 727 | | if logVerbosity>19: |
| 728 | | print '********************************************' |
| 729 | | print name |
| 730 | | print '********************************************' |
| 731 | | lowestrXn_refInNetwork=9999; listOfNodeMembersSeen = [] |
| 732 | | dictionaryWithAllNodesBelongingToThisNetwork = {}; dictionaryWithAllNodesBelongingToNeighbouringNetworks = {} |
| 733 | | ListOfInternalRoutesSeen = []; ListOfExternalRoutesSeen = []; dictionaryLinkingRoutesToNotes = {} |
| 734 | | members = network.getMembers() |
| 735 | | # Find a member node with the lowestrXn_refInNetwork and bring it to the front if such node is not there yet |
| 736 | | firstMember = members[0] |
| 737 | | if firstMember.isRelation() or firstMember.isNode() and int(firstMember.getNode().get(networklevel + '_ref')) != lowestrXn_refInNetwork: |
| 738 | | memberNode = None |
| 739 | | for networkMember in members: |
| 740 | | if networkMember.isNode(): |
| 741 | | memberNode = networkMember.getNode() |
| 742 | | if int(memberNode.get(networklevel + '_ref')) == 1: break |
| 743 | | if memberNode: |
| 744 | | network.removeMembersFor(memberNode) |
| 745 | | network.addMember(0, networkMember) |
| 746 | | |
| 747 | | for networkMember in network.getMembers(): |
| 748 | | if networkMember.isNode(): |
| 749 | | node = networkMember.getNode() |
| 750 | | rXn_ref = node.get(networklevel + '_ref') |
| 751 | | if int(rXn_ref) == 1: |
| | 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') |
| | 361 | i=1 |
| | 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) |
| | 384 | else: |
| | 385 | expected_rcn_route_relations = 3 |
| | 386 | if rcn_ref: |
| | 387 | #print rcn_ref |
| 756 | | for wayReferrer in referrersForWay: |
| 757 | | if wayReferrer.getType() is dummy_relation.getType(): |
| 758 | | aRelation = wayReferrer |
| 759 | | if aRelation.get('type') == 'route' and aRelation.get('network') ==networklevel and not(aRelation.get('ref')): |
| 760 | | rXnNetworkCountForNode+=1 |
| 761 | | if aRelation.hasIncompleteMembers(): |
| 762 | | name = aRelation.get('name') |
| 763 | | if not(name): name = '' |
| 764 | | note = aRelation.get('note') |
| 765 | | if not(note): note = '' |
| 766 | | networkname = aRelation.get('network') |
| 767 | | if not(networkname): networkname = '' |
| 768 | | if 'downloadIncompleteMembers' in sideEffects: |
| 769 | | aDownloadWasNeeded = True |
| 770 | | print 'Downloading incomplete members for', note |
| 771 | | DownloadRelationMemberTask.run(DownloadRelationMemberTask(aRelation, aRelation.getIncompleteMembers(), mv.editLayer )) |
| 772 | | time.sleep(1) |
| 773 | | continue |
| 774 | | else: |
| 775 | | JOptionPane.showMessageDialog(Main.parent, 'Please download all incomplete members of the route relations first: ' + networkname + ' ' + note + ' ' + name) |
| 776 | | break |
| 777 | | networkMembersList = [] |
| 778 | | for subMember in network.getMembers(): |
| 779 | | if subMember.isRelation(): |
| 780 | | routeRelation = subMember.getRelation() |
| 781 | | networkMembersList.append(routeRelation.getUniqueId()) |
| 782 | | routeId = aRelation.getUniqueId() |
| 783 | | if rXnRelationWeWantToProcess and not(routeId in networkMembersList): |
| 784 | | roleFromRouteCheck, problemReported, wikiReport = checkRCNroute(aRelation, aDownloadWasNeeded) |
| 785 | | if problemReported and 'createWikiReport' in sideEffects: |
| 786 | | wikiReportOnRelations += wikiReport + '\n|-\n' |
| 787 | | if 'addRouteToNetwork' in sideEffects and not(aDownloadWasNeeded): |
| | 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' |
| 801 | | |
| 802 | | |
| 803 | | def checkNetwork(network, networklevel, aDownloadWasNeeded): |
| 804 | | name = network.get('name') |
| 805 | | if logVerbosity>19: |
| 806 | | print '********************************************' |
| 807 | | print name |
| 808 | | print '********************************************' |
| 809 | | if 'createWikiReport' in sideEffects: |
| 810 | | wikiReportOnNodes = ('\n==' + name + '==\n{| class="wikitable" align="left" style="margin:0 0 2em 2em;"\n|-\n|+' + name + |
| 811 | | '\n|-\n!style="width:2.5em" | Node\n!Link\n! # Roads\n! # Relations\n|-\n') |
| 812 | | wikiReportOnRelations = ('{| class="wikitable" align="left" style="margin:0 0 2em 2em;"\n|-\n|+' + name + |
| 813 | | '\n|-\n!style="width:2.5em" | note\n!link\n!fixme\n! forward\n! backward\n! end nodes\n|-\n') |
| 814 | | i=1 |
| 815 | | for networkMember in network.getMembers(): |
| 816 | | if networkMember.isRelation(): |
| 817 | | routeRelation = networkMember.getRelation() |
| 818 | | if routeRelation.get('network') ==networklevel: |
| 819 | | if routeRelation.hasIncompleteMembers(): |
| 820 | | name = routeRelation.get('name') |
| 821 | | if not(name): name = '' |
| 822 | | note = routeRelation.get('note') |
| 823 | | if not(note): note = '' |
| 824 | | kindOfNetwork = routeRelation.get('network') |
| 825 | | if not(kindOfNetwork): kindOfNetwork = '' |
| 826 | | if 'downloadIncompleteMembers' in sideEffects: |
| 827 | | aDownloadWasNeeded = True |
| 828 | | print 'Downloading incomplete members for', note |
| 829 | | DownloadRelationMemberTask.run(DownloadRelationMemberTask(routeRelation, routeRelation.getIncompleteMembers(), mv.editLayer )) |
| 830 | | time.sleep(1) |
| 831 | | continue |
| 832 | | else: |
| 833 | | JOptionPane.showMessageDialog(Main.parent, 'Please download all incomplete members of the route relations first: ' + kindOfNetwork + ' ' + note + ' ' + name) |
| 834 | | break |
| 835 | | roleFromRouteCheck, problemReported, wikiReport = checkRxNroute(routeRelation, networklevel, aDownloadWasNeeded) |
| 836 | | if problemReported and 'createWikiReport' in sideEffects: |
| 837 | | wikiReportOnRelations += wikiReport + '\n|-\n' |
| 838 | | role = networkMember.getRole() |
| 839 | | if logVerbosity > 29 and role != roleFromRouteCheck: |
| 840 | | print |
| 841 | | print 'Role in network is ', role |
| 842 | | print 'Maybe this should be: ', roleFromRouteCheck |
| 843 | | if networkMember.isNode(): |
| 844 | | node = networkMember.getNode() |
| 845 | | rXn_ref = node.get(networklevel + '_ref') |
| 846 | | expected_rXn_route_relations = node.get('expected_' + networklevel + '_route_relations') |
| 847 | | if expected_rXn_route_relations: |
| 848 | | expected_rXn_route_relations = int(expected_rXn_route_relations) |
| 849 | | else: |
| 850 | | expected_rXn_route_relations = 3 |
| 851 | | if rXn_ref: |
| 852 | | if logVerbosity > 39: print rXn_ref |
| 853 | | referrersForNode = node.getReferrers() |
| 854 | | networkNotFoundForNode = True |
| 855 | | for referrer in referrersForNode: |
| 856 | | if referrer.getType() is dummy_relation.getType(): |
| 857 | | if referrer.get('type') in ['network'] and referrer.get('network') in ['rcn','rwn','rhn']: |
| 858 | | networkNotFoundForNode = False |
| 859 | | break |
| 860 | | if networkNotFoundForNode and 'downloadReferrersNodes' in sideEffects: |
| 861 | | aDownloadWasNeeded = True |
| 862 | | if 'selectObjects' in sideEffects: Main.main.getCurrentDataSet().setSelected(node) |
| 863 | | if 'zoomToSelection' in sideEffects: AutoScaleAction.zoomToSelection() |
| 864 | | #selectedNode = mv.editLayer.data.getSelected() |
| 865 | | print 'Downloading referrers for ', node.get(networklevel + '_ref') |
| 866 | | DownloadReferrersAction.downloadReferrers(mv.editLayer, node) |
| 867 | | |
| 868 | | rXnNetworkCountForNode = roads = 0 |
| 869 | | for referrer in referrersForNode: |
| 870 | | if referrer.getType() is dummy_way.getType(): |
| 871 | | if referrer.get('highway'): roads += 1 |
| 872 | | referrersForWay = referrer.getReferrers() |
| 873 | | if len(referrersForWay) < 1 and 'downloadReferrersForWays' in sideEffects: |
| 874 | | aDownloadWasNeeded = True |
| 875 | | if 'selectObjects' in sideEffects: Main.main.getCurrentDataSet().setSelected(referrer) |
| 876 | | if 'zoomToSelection' in sideEffects: AutoScaleAction.zoomToSelection() |
| 877 | | print 'Downloading referrers for ', referrer.get('name') , ' ', rXn_ref |
| 878 | | DownloadReferrersAction.downloadReferrers(mv.editLayer, referrer) |
| 879 | | |
| 880 | | for wayReferrer in referrersForWay: |
| 881 | | if wayReferrer.getType() is dummy_relation.getType(): |
| 882 | | aRelation = wayReferrer |
| 883 | | rXnRelationWeWantToProcess = False # We need this again further on, when deciding whether or not to add this relation to the network |
| 884 | | 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']): |
| 885 | | # The check on the ref is for Germany, where many rXn networks run crisscross through another. |
| 886 | | # We wouldn't want to get entangled in that mess. |
| 887 | | # The list is continuously getting longer, of course. But it's the best we can do here |
| 888 | | rXnRelationWeWantToProcess = True |
| 889 | | rXnNetworkCountForNode+=1 |
| 890 | | if aRelation.hasIncompleteMembers(): |
| 891 | | name = aRelation.get('name') |
| 892 | | if not(name): name = '' |
| 893 | | note = aRelation.get('note') |
| 894 | | if not(note): note = '' |
| 895 | | kindOfNetwork = aRelation.get('network') |
| 896 | | if not(kindOfNetwork): kindOfNetwork = '' |
| 897 | | if 'downloadIncompleteMembers' in sideEffects: |
| 898 | | aDownloadWasNeeded = True |
| 899 | | print 'Downloading incomplete members for', note |
| 900 | | DownloadRelationMemberTask.run(DownloadRelationMemberTask(aRelation, aRelation.getIncompleteMembers(), mv.editLayer )) |
| 901 | | time.sleep(1) |
| 902 | | continue |
| 903 | | else: |
| 904 | | JOptionPane.showMessageDialog(Main.parent, 'Please download all incomplete members of the route relations first: ' + kindOfNetwork + ' ' + note + ' ' + name) |
| 905 | | break |
| 906 | | networkMembersList = [] |
| 907 | | # print network |
| 908 | | for subMember in network.getMembers(): |
| 909 | | if subMember.isRelation(): |
| 910 | | routeRelation = subMember.getRelation() |
| 911 | | networkMembersList.append(routeRelation.getUniqueId()) |
| 912 | | routeId = aRelation.getUniqueId() |
| 913 | | if rXnRelationWeWantToProcess and not(routeId in networkMembersList): |
| 914 | | roleFromRouteCheck, problemReported, wikiReport = checkRxNroute(aRelation, networklevel, aDownloadWasNeeded) |
| 915 | | if problemReported and 'createWikiReport' in sideEffects: |
| 916 | | wikiReportOnRelations += wikiReport + '\n|-\n' |
| 917 | | if 'addRouteToNetwork' in sideEffects and not(aDownloadWasNeeded): |
| 918 | | newRelation = Relation(network) |
| 919 | | newmember = RelationMember(roleFromRouteCheck, aRelation) |
| 920 | | if logVerbosity > 9: print newRelation.getMembersCount(), ' ',i, ' ', newmember |
| 921 | | newRelation.addMember( i, newmember) |
| 922 | | commandsList = [] |
| 923 | | commandsList.append(Command.ChangeCommand(network, newRelation)) |
| 924 | | note = aRelation.get('note') |
| 925 | | if not(note): |
| 926 | | note = '' |
| 927 | | Main.main.undoRedo.add(Command.SequenceCommand("Adding " + note + " to network", commandsList)) |
| 928 | | commandsList = [] |
| 929 | | if logVerbosity > 9: print 'Added newly found RCN route relation to network: ', note |
| 930 | | i+=1 |
| 931 | | if rXnNetworkCountForNode < expected_rXn_route_relations: |
| 932 | | if logVerbosity > 9: print 'Node ', rXn_ref, ' only has ', rXnNetworkCountForNode, ' rXn routes connected to it' |
| 933 | | if 'createWikiReport' in sideEffects: wikiReportOnNodes += '|align="right" | ' + rXn_ref + '||align="right" | {{Node|' + str(node.getId()) + '}}||align="right" |' + str(roads) + ' ||align="right" style="color:red" | ' + str(rXnNetworkCountForNode) + '\n|-\n' |
| | 446 | if rcnNetworkCountForNode < expected_rcn_route_relations: |
| | 447 | print 'Node ', rcn_ref, ' only has ', rcnNetworkCountForNode, ' rcn routes connected to it' |
| | 448 | wikiReportOnNodes += '|align="right" | ' + rcn_ref + '||align="right" | {{Node|' + str(node.getId()) + '}}||align="right" |' + str(roads) + ' ||align="right" style="color:red" | ' + str(rcnNetworkCountForNode) + '\n|-\n' |
| 973 | | if 'downloadIncompleteMembers' in sideEffects: |
| 974 | | aDownloadWasNeeded = True |
| 975 | | print 'Downloading referrers for ', str(relation.get('name')), ' ', str(relation.get('note')) |
| 976 | | DownloadRelationMemberTask.run(DownloadRelationMemberTask(relation, relation.getIncompleteMembers(), mv.editLayer )) |
| 977 | | continue |
| 978 | | else: |
| 979 | | JOptionPane.showMessageDialog(Main.parent, 'Please download all incomplete member of the relations first') |
| 980 | | exit() |
| 981 | | networklevel=relation.get('network') |
| 982 | | if networklevel in ('rcn','rwn','rhn'): |
| 983 | | relationType = relation.get('type') |
| 984 | | if relationType == 'route': |
| 985 | | checkRxNroute(relation, networklevel, aDownloadWasNeeded) |
| 986 | | elif relationType == 'network': |
| 987 | | checkNetwork(relation, networklevel, aDownloadWasNeeded) |
| 988 | | elif relationType == 'collection': |
| 989 | | for collectionMember in relation.getMembers(): |
| 990 | | if collectionMember.isRelation(): |
| 991 | | networkRelation = collectionMember.getRelation() |
| 992 | | if networkRelation.hasIncompleteMembers(): |
| 993 | | name = networkRelation.get('name') |
| 994 | | if not(name): name = '' |
| 995 | | networkname = networkRelation.get('network') |
| 996 | | if not(networkname): networkname = '' |
| 997 | | if 'downloadIncompleteMembers' in sideEffects: |
| 998 | | aDownloadWasNeeded = True |
| 999 | | print 'Downloading referrers for ', name |
| 1000 | | DownloadRelationMemberTask.run(DownloadRelationMemberTask(networkRelation, networkRelation.getIncompleteMembers(), mv.editLayer )) |
| 1001 | | continue |
| 1002 | | else: |
| 1003 | | JOptionPane.showMessageDialog(Main.parent, 'Please download all incomplete members of the network relations first:' + networkname + ' ' + name) |
| 1004 | | break |
| 1005 | | checkNetwork(networkRelation, networklevel, aDownloadWasNeeded) |
| 1006 | | if aDownloadWasNeeded: |
| 1007 | | 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') |
| | 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) |
