Exemplo de Script: Atributos e Estilos

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

O sistema de desenho Aimsun Next é baseado em Modos (GKViewMode) e Estilos (GKViewStyle) que plotarão objetos em uma visualização 2D, renderizando-os de acordo com os atributos do objeto. Por exemplo, um trecho de via pode ser desenhado em cores diferentes dependendo do fluxo de trânsito nele.

No entanto, se a tarefa é desenhar os trechos de via em cores diferentes com base nas linhas de transporte público que os utilizam, então a informação sobre o uso do trecho está na linha de transporte público (GKPublicLine, herdada de GKRoute), não no trecho e, portanto, não está disponível para ser renderizada em um estilo de visualização. A solução é colocar essa informação no trecho usando um script, e então criar um estilo para mudar a cor com base nesses dados.

Atributos do Objeto

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

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

GKObject::getDataValue 
 GKObject::setDataValue

Aimsun Next também possui métodos para descobrir o tipo de dado e as colunas disponíveis:

GKModel::getType
GKModel::getColumn 
GKType::GetColumn -para obter colunas para um tipo particular.

Também é possível criar novas colunas usando o método adicionar coluna:

GKType::addExternalColumn

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

1. Adicionar uma nova coluna para armazenar o identificador da linha de transporte público.
2. Preencher o atributo em cada trecho com o valor correto.

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

type = model.getType( "GKSection" )
attr = type.addExternalColumn( "GKSection::ptline", "Linha de TP", 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 que armazenaremos, neste caso um número inteiro: GKColumn.Int.

Múltiplas novas colunas podem ser criadas com diferentes tipos de dados. Para mais detalhes, veja as classes GKType e GKColumn 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 loop externo é para todas as linhas de transporte público no modelo, o loop interno é para cada trecho na linha atual. Note, porém, que a implementação atual só manterá o identificador da última linha processada para trechos utilizados por mais de uma linha de transporte público. Isso pode ser resolvido de várias maneiras, dependendo do escopo do script, mas aqui, para simplicidade, apenas o último valor é usado.

Modos e Estilos

A próxima etapa é adicionar um novo modo e um novo estilo para mudar a cor do trecho. Isso pode ser feito usando a interface gráfica ou com um trabalho extra no script.

O código para criar o modo e o estilo deve verificar se não cria modos que já existem. Como o mesmo script será usado para classificar os trechos e para definir o modo e 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 já não existe.

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

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

A função a seguir cria o novo estilo de visualização (se não existir) e o inicializa. Ela também remove qualquer faixa anterior, pois o número de rotas pode ter mudado desde a última execução, e chama uma função que codificaremos mais tarde para criar automaticamente as novas faixas:

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( "Estilo de Linhas de TP" )
    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 seguinte cria uma faixa para cada linha de transporte público. Em seguida, atribui uma cor diferente a cada faixa e define seu nome igual ao nome da linha de transporte público:

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 próxima função cria o novo modo de visualização (se 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( "Modo de Linhas de TP" )
    if mode != None:
        mode.removeAllStyles()
        style = createStyle( model, type, attr )
        mode.addStyle( style )
    return mode

A última função a ser escrita é a 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 ) )