Scripts para Gerenciar Planos de Controle em Revisões¶

Esses scripts são usados no gerenciamento de um plano de controle quando ele deve ser modificado por meio da divisão em múltiplos planos de controle específicos por área, a serem editados em diferentes revisões e, depois que as revisões forem consolidadas de volta no modelo mestre, para mesclar os planos individuais de volta em um único plano de controle.

Script para Dividir um Plano de Controle¶

#####################################################################################
#####################################################################################
# Disclaimer of Warranty: TO THE EXTENT PERMITTED BY APPLICABLE LAW THE AIMSUN
# SCRIPTS, INCLUDING BUT NOT LIMITED TO ALL DATA, TOOLS AND CALCULATIONS THEREIN
# ARE PROVIDED "AS IS" AND WITHOUT EXPRESS OR IMPLIED WARRANTY OF ANY KIND BY
# EITHER AIMSUN OR ANYONE ELSE WHO HAS BEEN INVOLVED IN THE CREATION, PRODUCTION OR
# DELIVERY OF THE AIMSUN SCRIPTS, INCLUDING BUT NOT LIMITED TO ANY EXPRESS OR
# IMPLIED WARRANTY OF MERCHANTABILITY, ACCURACY, QUIET ENJOYMENT,
# NONINFRINGEMENT OR FITNESS FOR A PARTICULAR PURPOSE. NO COVENANTS, WARRANTIES
# OR INDEMNITIES OF ANY KIND ARE GRANTED BY AIMSUN TO YOU THE USER. SHOULD THE
# PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
# REPAIR OR CORRECTION.
#####################################################################################
#####################################################################################

################################################################################### 
###                       
###     Start main body -
###                                
###################################################################################


def main():

    sourceControlPlans = []

    # Check this is being run from  the right type of object
    if target==None or target.isA(model.getType("GKControlPlan"))==False:
        print "must be run from a control plan or plans"

    # Assemble a list of selected control plans
    for item in selection:
        if item.isA(model.getType("GKControlPlan")):
            sourceControlPlans.append(item)

    # get the relevant objects
    problemNet = returnProblemNetFromDialog("Retrieve problem net")
    nodeIdsInProblemNet = returnDictNodesInPolygon(problemNet).keys()
    polygonLayer = returnPolygonLayerFromDialog("Retrieve polygon layer")
    polygons = returnPolygonsForLayer(polygonLayer)
    dictPolygonNameNodeIds = {}
    listNodeIdsInPolygons = []

    #Split into new plans using polygons
    for polygon in polygons:
        #Try to find the polygon name
        polygonName = str(polygon.getName())
        if polygonName == "":
            polygonName = str(polygon.getExternalId())
        if polygonName == "":
            polygonName = str(polygon.getId())
        if polygonName in dictPolygonNameNodeIds:
            print "repeated polygon name - Error"
            return

        listNodeIdsInPolygon = returnDictNodesInPolygon(polygon).keys()

        #Get the nodes in the polygon
        dictPolygonNameNodeIds[polygonName] = []
        for nodeId in listNodeIdsInPolygon:
            if nodeId not in listNodeIdsInPolygons:
                dictPolygonNameNodeIds[polygonName].append(nodeId)
                listNodeIdsInPolygons.append(nodeId)

    polygonName = "OUTSIDE"
    for nodeId in nodeIdsInProblemNet:
        if nodeId not in listNodeIdsInPolygons:
            if polygonName not in dictPolygonNameNodeIds:
                dictPolygonNameNodeIds[polygonName]=[]
            dictPolygonNameNodeIds[polygonName].append(nodeId)
            print "nodeId outside" + str(nodeId)

    # Copy the nodes to the polygons
    for sourceControlPlan in sourceControlPlans:
        sourceControlPlanName = str(sourceControlPlan.getName())
        for polygonName in sorted(dictPolygonNameNodeIds.keys()):
            listNodesIds = dictPolygonNameNodeIds[polygonName]
            targetControlPlanName = sourceControlPlanName + "_" + polygonName
            targetControlPlan = getControlPlan( model, targetControlPlanName )
            targetControlPlan.setDataValue(parentControlPlanIdCol, QVariant(sourceControlPlan.getId()))

            copyControlJunctionsFromSourceControlPlanToTargetControlPlan(sourceControlPlan, targetControlPlan, listNodesIds)
    return



## Entry Point
## Call the main function for this script
main()

print "Done"

Script para Recombinar Planos de Controle¶

##################################################################################  
###                       
###     Start main body -
###                               
##################################################################################

def main():

    # Check this is being run from  the right type of object
    if parentControlPlanIdCol==None:
        print "not found column GKControlPlan::ParentControlPlanId"
        return
    dictOriginalControlPlanIdListSplitControlPlans = {}
    if target==None or target.isA(model.getType("GKControlPlan"))==False:
        print "must be run from a control plan or plans"

    # Assemble a list of control plans
    for item in selection:
        if item.isA(model.getType("GKControlPlan")):
            originalControlPlanId = item.getDataValueInt(parentControlPlanIdCol)
            if originalControlPlanId > 0:
                if originalControlPlanId not in dictOriginalControlPlanIdListSplitControlPlans:
                    dictOriginalControlPlanIdListSplitControlPlans[originalControlPlanId]=[]
                dictOriginalControlPlanIdListSplitControlPlans[originalControlPlanId].append(item)

    for originalControlPlanId in dictOriginalControlPlanIdListSplitControlPlans.keys():
        originalControlPlanName = str(originalControlPlanId)
        originalControlPlan = model.getCatalog().find(originalControlPlanId)
        if originalControlPlan!=None:
            originalControlPlanName = str(originalControlPlan.getName())
        if originalControlPlan==None or CREATE_NEW_CONTROL_PLAN:
            originalControlPlanName = originalControlPlanName + "_COMBINED"
            originalControlPlan = getControlPlan( model, originalControlPlanName

        # Copy the junction controls
        for splitControlPlan in dictOriginalControlPlanIdListSplitControlPlans[originalControlPlanId]:
            nodeIdsWithControl = splitControlPlan.getControlJunctions().keys()
            copyControlJunctionsFromSourceControlPlanToTargetControlPlan(splitControlPlan, originalControlPlan, nodeIdsWithControl)

    return


# Entry Point
## Call the main function for this script
main()

print "Done"

Funções Utilitárias ¶

As funções utilitárias são usadas pelos scripts de cópia de plano de controle.

#################################################################################
###                         
###     Define Utility Functions
###                                
#################################################################################

def getControlPlan( model, name ):
    #find control plan in model
    controlPlanType = model.getType( "GKControlPlan" )
    controlPlan = model.getCatalog().findByName(str(name), controlPlanType)
    if controlPlan!=None:
        return controlPlan
    else:
        cmd = GKControlPlanNewCmd()
        model.getCommander().addCommand(cmd)
        controlPlan = cmd.createdObject()
        controlPlan.setName( name )
        controlPlan.setExternalId( name )
        return controlPlan

def returnProblemNetFromDialog(windowTitle):

    print "Select " + windowTitle + " problemNet"

    dialog = GAnyObjectChooserEditor()
    dialog.setWindowTitle("Select " + windowTitle + " problemNet")
    #dialog.setName("Select " + windowTitle + " Centroids")
    chooser = dialog.getChooser()
    chooser.setWindowTitle("Select " + windowTitle + " problemNet")
    #chooser.setName("Select " + windowTitle + " Centroids")
    chooser.setType(model, model.getType("GKProblemNet"), GAnyObjectChooser.ChooserMode.eOneObject)
    acceptedRejected = dialog.execDialog()
    if acceptedRejected == 1:
        layer = chooser.getObject()
        if layer!=None:
            print "returning problem net by chooser"
            return layer

    print "no problem net"
    return None

def returnPolygonLayerFromDialog(windowTitle):

    print "Select " + windowTitle + " polygon layer"

    dialog = GAnyObjectChooserEditor()
    dialog.setWindowTitle("Select " + windowTitle + " polygon layer")
    #dialog.setName("Select " + windowTitle + " Centroids")
    chooser = dialog.getChooser()
    chooser.setWindowTitle("Select " + windowTitle + " polygon layer")
    #chooser.setName("Select " + windowTitle + " Centroids")
    chooser.setType(model, model.getType("GKLayer"), GAnyObjectChooser.ChooserMode.eOneObject)
    acceptedRejected = dialog.execDialog()
    if acceptedRejected == 1:
        layer = chooser.getObject()
        if layer!=None:
            print "returning problem net by chooser"
            return layer

    print "no problem net"
    return None

def copyControlJunctionsFromSourceControlPlanToTargetControlPlan(sourceControlPlan, targetControlPlan, listNodesIds):

    nodeIdsWithControl = targetControlPlan.getControlJunctions().keys()
    for nodeId in nodeIdsWithControl:
        targetControlPlan.removeControlJunction(nodeId)

    for nodeId in listNodesIds:

        sourceControlJunction = sourceControlPlan.getControlJunction(nodeId)

        targetControlPlan.removeControlJunction(nodeId)

        if sourceControlJunction!=None:
            targetControlPlan.addControlJunction(nodeId, sourceControlJunction.clone())

    return

def returnPolygonsForLayer(layer):

    listPolygons = []

    for geoObject in layer.getObjects():
        if geoObject.isA(model.getType("GKPolygon")):
            listPolygons.append(geoObject)

    return listPolygons

def returnDictNodesInPolygon(polygon):

    dictNodeIdNodes = {}

    if polygon==None:
        for node in model.getCatalog().getObjectsByType(model.getType("GKNode")).values():
            dictNodeIdNodes[node.getId()]=node
        return dictNodeIdNodes

    for nodeOrSection in polygon.classifyObjects(polygon.eOnlyNodesAndSections):
        if nodeOrSection.isA(model.getType("GKNode")):
            dictNodeIdNodes[nodeOrSection.getId()]=nodeOrSection

    return dictNodeIdNodes