Guide d’automatisation Revit et de programmation API

Introduction à l’automatisation Revit

L’automatisation de Revit via l’API (Application Programming Interface) permet aux professionnels AEC de simplifier les tâches répétitives, d’appliquer les standards et de créer des workflows personnalisés qui étendent les fonctions natives de Revit. Ce guide propose une introduction complète à la programmation de l’API Revit avec des exemples pratiques en C# et en Python.

Premiers pas avec l’API Revit

Avant d’aborder des exemples d’automatisation précis, il est important de comprendre la structure et les possibilités de l’API Revit :

• Documentation de l’API : accéder à la documentation et y rechercher les informations utiles
• Environnement de développement : configurer Visual Studio et les environnements Python
• Concepts de base : comprendre le modèle objet, les transactions et les événements de l’API Revit
• Développement d’add-ins : créer des commandes externes et des applications

Exemples C# pour automatiser Revit

C# est le principal langage de développement de l’API Revit. Ce guide couvre les exemples essentiels suivants :

1. Sélection et filtrage des éléments

                                        
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. Gestion des paramètres

                                        
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. Création de géométrie

                                        
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();
}

                                      

Exemples Python pour automatiser Revit

Python offre un point d’entrée plus accessible à de nombreux utilisateurs. Le guide présente les scripts Python avec pyRevit et RevitPythonShell :

1. Sélection d’éléments avec 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. Gestion des paramètres avec 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()

                                      

Techniques avancées d’automatisation

Au-delà de l’utilisation de base de l’API, ce guide couvre des techniques avancées :

• Intégration Dynamo : combiner programmation visuelle et scripts API
• Traitement par lots : traiter plusieurs fichiers et éléments
• Intégration de bases de données : connecter Revit à des bases externes
• Développement d’interfaces : créer des interfaces personnalisées pour les outils
• Déploiement : distribuer les outils aux membres de l’équipe

Workflows pratiques d’automatisation

Le guide contient des workflows complets pour des scénarios d’automatisation fréquents :

• Configuration des feuilles : automatiser la création des feuilles et des vues
• Audit des modèles : contrôler les modèles par rapport aux standards et générer des rapports
• Échange de données : exporter et importer des données entre Revit et d’autres plateformes
• Documentation : automatiser les annotations et les cotations
• Automatisation de la conception : générer des variantes à partir de paramètres

Bonnes pratiques et optimisation des performances

Une automatisation Revit fiable exige une attention particulière aux performances et à la robustesse :

• Gestion des transactions : optimiser l’utilisation des transactions
• Gestion des erreurs : mettre en œuvre une gestion des erreurs et une journalisation robustes
• Techniques de performance : améliorer la vitesse d’exécution
• Compatibilité des versions : assurer le fonctionnement des add-ins sur plusieurs versions de Revit
• Stratégies de test : tester méthodiquement les outils d’automatisation