Inserir o nome do ambiente em revestimentos automático

Introdução

Olá, pessoal! Hoje vamos mergulhar em um assunto super interessante e útil para quem trabalha com o Revit: como inserir automaticamente o nome do ambiente nos elementos de revestimento. Esse script em Python para o pyRevit/ Python Script no Dynamo é uma ferramenta poderosa que vai economizar um tempão no seu fluxo de trabalho.

O que esse código faz? Bem, ele vasculha o seu modelo Revit, encontra todos os ambientes, descobre os limites desses ambientes e, como mágica, insere o nome do ambiente nos elementos que formam esses limites. Legal, né? Vamos destrinchar isso passo a passo e entender como essa automação funciona nos bastidores.

Coleta de Ambientes

Antes de mais nada, precisamos encontrar todos os ambientes no nosso modelo Revit. É como se estivéssemos fazendo uma varredura no projeto, procurando por todos os espaços definidos. Para isso, usamos uma ferramenta super poderosa chamada FilteredElementCollector. Pense nela como um scanner super eficiente que vasculha todo o documento do Revit.

Vamos dar uma olhada no código que faz essa mágica acontecer:

rooms = FilteredElementCollector(doc).OfCategory(BuiltInCategory.OST_Rooms).WhereElementIsNotElementType().ToElements()

Parece complicado? Vamos quebrar isso em partes menores:

– FilteredElementCollector(doc): Isso cria nosso “scanner” que vai vasculhar o documento Revit atual.
– .OfCategory(BuiltInCategory.OST_Rooms): Aqui estamos dizendo “ei, só me interessa encontrar ambientes!”.
– .WhereElementIsNotElementType(): Essa parte é crucial. Estamos pedindo apenas os ambientes reais, não os tipos de ambiente.
– .ToElements(): Por fim, transformamos tudo isso em uma lista que podemos manipular facilmente.

Essa etapa é fundamental porque nos dá acesso a todos os ambientes do projeto. É como se tivéssemos uma lista mágica com todos os espaços do nosso modelo!

Configuração das Opções de Limite

Agora que temos nossa lista de ambientes, precisamos entender onde exatamente esses ambientes começam e terminam. É como traçar o contorno de cada cômodo no projeto. Para isso, usamos algo chamado SpatialElementBoundaryOptions. Parece um nome complicado, mas é basicamente uma ferramenta que nos ajuda a definir como queremos que os limites dos ambientes sejam considerados.

Veja como configuramos isso no código:

opt = SpatialElementBoundaryOptions()
opt.SpatialElementBoundaryLocation = SpatialElementBoundaryLocation.Finish

O que está acontecendo aqui?

– Primeiro, criamos um objeto SpatialElementBoundaryOptions.
– Depois, configuramos a propriedade SpatialElementBoundaryLocation para “Finish”. Isso significa que queremos considerar o limite do ambiente onde o acabamento termina, não onde a parede começa.

Essa configuração é super importante porque nos garante que estamos pegando os limites exatos dos ambientes, considerando os acabamentos. Assim, quando inserirmos o nome do ambiente nos elementos, ele estará no lugar certo!

Início e Compromisso da Transação

Antes de começarmos a fazer alterações no nosso modelo Revit, precisamos avisar o programa que vamos mexer nas coisas. É como se estivéssemos dizendo “Ei, Revit, presta atenção, vou fazer algumas mudanças aqui!”. Para isso, usamos algo chamado Transaction.

Veja como isso é feito no código:

t = Transaction(doc, 'Insert room name in finishes')
t.Start()
# ... (aqui vão todas as nossas operações)
t.Commit()

Vamos entender o que está acontecendo:

– Criamos uma nova Transaction, dando a ela um nome descritivo (“Insert room name in finishes”).
– Usamos t.Start() para iniciar a transação. É como dar o sinal verde para começar as alterações.
– Depois de fazer todas as alterações que precisamos, usamos t.Commit() para confirmar tudo. É como dizer “pronto, Revit, pode salvar todas essas mudanças!”.

Usar transações é super importante porque garante que todas as nossas alterações sejam feitas de uma vez só, de forma organizada. Se algo der errado no meio do caminho, o Revit pode facilmente desfazer tudo, mantendo a integridade do nosso modelo.

Iteração sobre Ambiente e Limites

Agora vem a parte mais legal: vamos passar por cada ambiente que encontramos e fazer a mágica acontecer! É aqui que realmente inserimos o nome do ambiente nos elementos de revestimento.

Vamos olhar o código e depois explicar cada parte:

for room in rooms:
    boundary_segments = room.GetBoundarySegments(opt)
    room_name = room.get_Parameter(BuiltInParameter.ROOM_NAME).AsString()
    
    for boundary_segment_list in boundary_segments:
        for boundary_segment in boundary_segment_list:
            element = doc.GetElement(boundary_segment.ElementId)
            if element and element.LookupParameter('Comments'):
                element.LookupParameter('Comments').Set(room_name)

Uau, tem muita coisa acontecendo aqui! Vamos desvendar isso juntos:

– Primeiro, usamos um loop for para passar por cada ambiente (room) na nossa lista de ambientes.
– Para cada ambiente, obtemos seus segmentos de limite usando room.GetBoundarySegments(opt). Lembra das opções que configuramos antes? Elas entram em ação aqui!
– Pegamos o nome do ambiente com room.get_Parameter(BuiltInParameter.ROOM_NAME).AsString(). Isso nos dá o nome do ambiente como uma string que podemos usar.
– Depois, entramos em dois loops aninhados para passar por cada segmento de limite do ambiente.
– Para cada segmento, pegamos o elemento associado usando doc.GetElement(boundary_segment.ElementId).
– Verificamos se o elemento existe e se tem um parâmetro chamado ‘Comments’.
– Se tudo isso for verdade, finalmente inserimos o nome do ambiente no parâmetro ‘Comments’ do elemento usando element.LookupParameter(‘Comments’).Set(room_name).

Essa parte do código é o coração da nossa automação. É aqui que realmente pegamos o nome do ambiente e o colocamos nos elementos de revestimento. É como se estivéssemos etiquetando cada parede, piso ou teto com o nome do ambiente a que pertencem!

Conclusão

E aí está, pessoal! Acabamos de dar um passeio completo por um script super poderoso que automatiza a inserção dos nomes dos ambientes nos elementos de revestimento no Revit. Isso pode parecer uma tarefa simples, mas imaginem fazer isso manualmente em um projeto grande… Seria um pesadelo, não é?

Com essa automação, você economiza horas de trabalho tedioso e reduz drasticamente a chance de erros humanos. É uma ferramenta incrível para manter seu modelo Revit organizado e informativo.

Lembrem-se, a automação em BIM não é só sobre economizar tempo. É sobre melhorar a qualidade do nosso trabalho, reduzir erros e nos permitir focar nas partes criativas e estratégicas do projeto. Este script é apenas um exemplo do poder do pyRevit e do Python no Revit.

Espero que este artigo tenha sido útil e que você se sinta inspirado a explorar mais o mundo das automações no Revit! Tem alguma dúvida ou quer compartilhar como você usou esse script no seu trabalho? Deixe um comentário abaixo! E não se esqueça de conferir nossos outros artigos. Até a próxima!

Código completo

# Coletar todos os ambientes no modelo
rooms = FilteredElementCollector(doc).OfCategory(BuiltInCategory.OST_Rooms).WhereElementIsNotElementType().ToElements()

# Opções para obter os Boundaries
options = SpatialElementBoundaryOptions()
options.SpatialElementBoundaryLocation = SpatialElementBoundaryLocation.Finish

# Iniciar a transação
t = Transaction(doc,__title__)
t.Start()

# Iterar sobre cada ambiente
for room in rooms:
    room_name = room.get_Parameter(BuiltInParameter.ROOM_NAME).AsString()
    
    # Obter os segmentos do perímetro do ambiente
    boundaries = room.GetBoundarySegments(options)
    
    # Cada sala pode ter múltiplos loops (ex.: ilhas dentro da sala)
    for loop in boundaries:
        for segment in loop:
            element_id = segment.ElementId  # Pega o ID do elemento
            if element_id.IntegerValue > 0:  # Ignorar ID -1 que representa um limite sem elemento
                element = doc.GetElement(element_id)

                # Inserir o nome do ambiente no Revestimento
                element.LookupParameter("Ambiente").Set(room_name)
                

t.Commit()