Pular para o conteúdo

Exemplo de Script: Atributos e Estilos

Este exemplo demonstra como plotar informações na vista 2D quando as informações não estão imediatamente disponíveis e vinculadas aos objetos que serão usados para exibi-las.

O sistema de desenho do Aimsun Next é baseado em Modos (GKViewMode) e Estilos (GKViewStyle) que plotará objetos em uma visualização 2D, renderizando-os de acordo com atributos do objeto. Por exemplo, uma seção viária pode ser desenhada em diferentes cores dependendo do fluxo de tráfego nela.

Se, no entanto, a tarefa for desenhar as seções viárias em cores diferentes com base nas linhas de transporte público que as utilizam, então a informação sobre o uso da seção está na linha de transporte público (GKPublicLine, herdada de GKRoute), não na seção e, portanto, não está disponível para ser renderizada em um estilo de visualização. A solução é colocar essa informação na seção usando um script e, em seguida, criar um estilo para alterar a cor com base nesses dados.

Atributos do Objeto

Todos os objetos do Aimsun têm atributos para armazenar dados. O atributo (coluna, nos termos do Aimsun Next) é definido no nível da classe (tipo, nos termos do Aimsun Next), enquanto o conteúdo dos dados é atribuído ao atributo no nível da instância (objeto, nos termos do Aimsun Next). Na prática, cada tipo tem um conjunto de colunas definido para ele, que permite que um objeto desse tipo armazene seus dados.

O Aimsun Next tem dois métodos para obter e definir dados em qualquer objeto:

GKObject::getDataValue 
 GKObject::setDataValue

O Aimsun Next também tem métodos para descobrir o tipo de dados e as colunas disponíveis:

GKModel::getType
GKModel::getColumn 
GKType::GetColumn -to get columns for a particular type.

Ele também pode criar novas colunas usando o método add column:

GKType::addExternalColumn

Portanto, as tarefas necessárias para implementar nosso novo script são:

  1. Adicione uma nova coluna para armazenar o identificador da linha pública.
  2. Preencha o atributo em cada seção com o valor correto.

A primeira tarefa é concluída com o seguinte código:

type = model.getType( "GKSection" )
attr = type.addExternalColumn( "GKSection::ptline", "PT Line", GKColumn.Int )

A primeira linha obtém o tipo ao qual queremos adicionar a coluna. A segunda linha adiciona a nova coluna. Esta coluna tem:

  • Um nome interno e único: GKSection::ptline.
  • Um nome externo que será apresentado ao usuário: "Linha de TP".
  • O tipo dos dados em que armazenaremos, neste caso um número inteiro: GKColumn.Int.

Várias novas colunas podem ser criadas com diferentes tipos de dados. Para mais detalhes, consulte GKType e GKColumn classes na documentação HTML.

Os atributos são adicionados com o seguinte código:

ptType = model.getType( "GKPublicLine" )
for types in model.getCatalog().getUsedSubTypesFromType( ptType ):
    for ptline in types.values():
        for section in ptline.getRoute():
            section.setDataValue(attr, QVariant(ptline.getId()))

O laço externo percorre todas as linhas públicas no modelo; o laço interno percorre cada seção na linha atual. Observe, contudo, que a implementação atual manterá apenas o identificador da última linha processada para seções usadas por mais de uma linha pública. Isso pode ser resolvido de várias maneiras, dependendo do escopo do script, mas aqui, por simplicidade, apenas o último valor é usado.

Modos e Estilos

A próxima etapa é adicionar um novo modo e um novo estilo para alterar a cor da seção. Isso pode ser feito usando a GUI ou com algum trabalho adicional no script.

O código para criar o modo e o estilo deve verificar se ele não cria modos que já existem. Como o mesmo script será usado para classificar as seções e para definir o modo e o estilo corretos, executá-lo duas vezes poderia criar dois modos e estilos diferentes. Portanto, antes de criar um modo, o script primeiro verifica se ele ainda não existe.

Como o script ficará bastante longo, para melhorar a legibilidade e reduzir erros, é uma boa prática dividi-lo em funções menores que realizem operações simples. Portanto, escreveremos:

  1. uma função que cria um novo estilo de vista baseado em um atributo.
  2. uma função que cria automaticamente as faixas de cores apropriadas para o novo estilo de visualização, usada pela função acima.
  3. uma função que cria um novo modo de visualização que usa o estilo de visualização criado com as funções acima.
  4. uma função que ativa o novo modo de vista.

A função a seguir cria o novo estilo de visualização (se ele ainda não existir) e o inicializa. Ela também remove quaisquer intervalos anteriores, pois o número de rotas pode ter mudado desde a última execução, e chama uma função que codificaremos posteriormente para criar automaticamente os novos intervalos:

def createStyle( model, type, attr ):
    style = model.getGeoModel().findStyle("GKSection::ptline style")
    if style == None:
        cmd = GKViewModeStyleNewCmd()
        model.getCommander().addCommand( cmd )
        style = cmd.createdObject()
        style.setInternalName( "GKSection::ptline style" )
        style.setName( "PTLines Style" )
    if style != None:
        style.setStyleType( GKViewModeStyle.eColor )
        style.setVariableType( GKViewModeStyle.eDiscrete )
        style.setColumn( type, attr )
        style.removeAllRanges()
        createRanges( model, style )
    return style

A função a seguir cria uma faixa para cada linha pública. Em seguida, atribui uma cor diferente a cada faixa e define seu nome igual ao nome da linha pública:

def createRanges( model, style ):
    ramp = GKColorRamp.getRamp( "MARK_COLORS" );
    i = 0
    ptType = model.getType( "GKPublicLine" )
    for types in model.getCatalog().getUsedSubTypesFromType(ptType):
        for ptline in types.values():
            range = style.addRange( ptline.getId() )
            if range != None :
                range.label = ptline.getName()
                range.color = ramp.getColor( i, len(types) )
                i = i + 1

A função a seguir cria o novo modo de vista (se ele ainda não existir) e o configura. Ela chama a primeira função para criar o estilo:

def createMode( model, type, attr ):
    mode = model.getGeoModel().findMode( "GKSection::ptline mode" )
    if mode == None :
        cmd = GKViewModeNewCmd()
        model.getCommander().addCommand( cmd )
        mode = cmd.createdObject()
        mode.setInternalName( "GKSection::ptline mode" )
        mode.setName( "PTLines Mode" )
    if mode != None:
        mode.removeAllStyles()
        style = createStyle( model, type, attr )
        mode.addStyle( style )
    return mode

A última função a escrever é aquela que ativa o modo:

def setMode( mode ):
    gui = GKGUISystem.getGUISystem().getActiveGui()
    if gui != None:
        activeWindow = gui.getActiveViewWindow()
        if activeWindow != None:
            activeWindow.setMode( mode )

Para chamar todas essas funções, adicione a seguinte linha no final do script:

setMode( createMode( model, type, attr ) )