Revit-Automatisierung und API-Programmierung

Einführung in die Revit-Automatisierung

Die Automatisierung von Revit über die API (Application Programming Interface) ermöglicht AEC-Fachleuten, wiederkehrende Aufgaben zu vereinfachen, Standards durchzusetzen und individuelle Workflows zu entwickeln, die die nativen Funktionen von Revit erweitern. Dieser Leitfaden bietet eine umfassende Einführung in die Revit-API-Programmierung mit praktischen Beispielen in C# und Python.

Erste Schritte mit der Revit API

Bevor konkrete Automatisierungsbeispiele behandelt werden, ist es wichtig, Struktur und Möglichkeiten der Revit API zu verstehen:

• API-Dokumentation: Revit-API-Dokumentation aufrufen und gezielt durchsuchen
• Entwicklungsumgebung: Visual Studio und Python-Umgebungen konfigurieren
• Grundkonzepte: Objektmodell, Transaktionen und Ereignisbehandlung der Revit API verstehen
• Add-in-Entwicklung: Externe Befehle und Anwendungen erstellen

C#-Beispiele für die Revit-Automatisierung

C# ist die wichtigste Sprache für die Entwicklung mit der Revit API. Dieser Leitfaden behandelt folgende zentrale Beispiele:

1. Elementauswahl und Filterung

                                        
1
2
3
4
5
6
7
8
9
10
11
12
                                        // Get all walls in the current document
FilteredElementCollector collector = new FilteredElementCollector(doc);
ICollection<Element> walls = collector.OfClass(typeof(Wall)).ToElements();

// Filter walls by parameter value
List<Element> filteredWalls = new List<Element>();
foreach (Element wall in walls)
{
    Parameter param = wall.LookupParameter("Comments");
    if (param != null && param.AsString() == "Exterior")
    {
        filteredWalls.Add(wall);
    }
}

                                      

2. Parameterverwaltung

                                        
1
2
3
4
5
6
7
8
9
10
11
12
                                        // Set parameter value for multiple elements
using (Transaction tx = new Transaction(doc, "Set Parameters"))
{
    tx.Start();
    foreach (Element element in elements)
    {
        Parameter param = element.LookupParameter("Mark");
        if (param != null && !param.IsReadOnly)
        {
            param.Set("New Value");
        }
    }
    tx.Commit();
}

                                      

3. Geometrieerstellung

                                        
1
2
3
4
5
6
7
8
9
10
11
12
                                        // Create a wall by curve
using (Transaction tx = new Transaction(doc, "Create Wall"))
{
    tx.Start();
    XYZ start = new XYZ(0, 0, 0);
    XYZ end = new XYZ(20, 0, 0);
    Line line = Line.CreateBound(start, end);
    WallType wallType = new FilteredElementCollector(doc)
        .OfClass(typeof(WallType)).FirstElement() as WallType;
    Level level = new FilteredElementCollector(doc)
        .OfClass(typeof(Level)).FirstElement() as Level;
    Wall.Create(doc, line, wallType.Id, level.Id, 10, 0, false, false);
    tx.Commit();
}

                                      

Python-Beispiele für die Revit-Automatisierung

Python bietet vielen Anwendern einen leichteren Einstieg. Der Leitfaden behandelt Python-Skripting mit pyRevit und RevitPythonShell:

1. Elementauswahl mit Python

                                        
1
2
3
4
5
6
7
8
9
10
11
12
                                        # Get all doors in the current document
from Autodesk.Revit.DB import FilteredElementCollector, FamilyInstance, BuiltInCategory
from Autodesk.Revit.UI import TaskDialog

doc = __revit__.ActiveUIDocument.Document
doors = FilteredElementCollector(doc).OfCategory(BuiltInCategory.OST_Doors).WhereElementIsNotElementType().ToElements()
TaskDialog.Show("Door Count", "Number of doors: {}".format(len(doors)))

                                      

2. Parameterbearbeitung mit Python

                                        
1
2
3
4
5
6
7
8
9
10
11
12
                                        # Get and modify parameters
from Autodesk.Revit.DB import Transaction

doc = __revit__.ActiveUIDocument.Document
uidoc = __revit__.ActiveUIDocument
t = Transaction(doc, "Modify Parameters")
t.Start()
selection = [doc.GetElement(id) for id in uidoc.Selection.GetElementIds()]
for element in selection:
    param = element.LookupParameter("Comments")
    if param and not param.IsReadOnly:
        param.Set("Modified by Python script")
t.Commit()

                                      

Fortgeschrittene Automatisierungstechniken

Über die grundlegende API-Nutzung hinaus behandelt dieser Leitfaden fortgeschrittene Techniken:

• Dynamo-Integration: Visuelle Programmierung mit API-Skripten kombinieren
• Stapelverarbeitung: Mehrere Dateien und Elemente verarbeiten
• Datenbankintegration: Revit mit externen Datenbanken verbinden
• UI-Entwicklung: Eigene Benutzeroberflächen für Werkzeuge erstellen
• Bereitstellung: Werkzeuge an Teammitglieder verteilen

Praktische Automatisierungsworkflows

Der Leitfaden enthält vollständige Workflows für häufige Automatisierungsszenarien:

• Planerstellung: Zeichnungspläne und Ansichten automatisiert anlegen
• Modellprüfung: Modelle gegen Standards prüfen und Berichte erzeugen
• Datenaustausch: Daten zwischen Revit und anderen Plattformen exportieren und importieren
• Dokumentation: Beschriftung und Bemaßung automatisieren
• Entwurfsautomatisierung: Entwurfsvarianten aus Parametern erzeugen

Best Practices und Leistungsoptimierung

Erfolgreiche Revit-Automatisierung erfordert besondere Aufmerksamkeit für Leistung und Zuverlässigkeit:

• Transaktionsmanagement: Transaktionen für eine bessere Leistung optimieren
• Fehlerbehandlung: Robuste Fehlerbehandlung und Protokollierung umsetzen
• Leistungstechniken: Ausführungsgeschwindigkeit gezielt verbessern
• Versionskompatibilität: Add-ins über mehrere Revit-Versionen hinweg unterstützen
• Teststrategien: Automatisierungswerkzeuge systematisch prüfen