VoltaDynaBim

[Dynamo += Python] WPF + WebView2

2026-10-25T16:22:54.240+01:00

Comment utiliser WebView2 dans une interface WPF avec PythonNet3

#DynamoBIM #Revit #Python #RevitAPI #WPF #WebView2 #Pandas #AutodeskExpertElite #AutodeskCommunity

if this article is not in your language, use the Google Translate widget ⬈ (bottom of page for Mobile version ⬇)

Savez-vous que l'assembly Microsoft.Web.WebView2.Core est disponible dans le contexte Dynamo ? , ce qui permet en conséquence d'utiliser WebView2 dans vos interfaces WPF.

Explication

Par rapport à WebBrowser (obsolète), WebView2 peut sembler plus complexe à programmer, mais il offre la puissance, la sécurité et la compatibilité totale d'un moteur Web moderne (Chromium).

La mise en œuvre de WebView2 nécessite de gérer plusieurs étapes.

Créer ou récupérer un CoreWebView2Environment.
Initialiser le contrôle de façon asynchrone.
Attendre que le moteur soit chargé via CoreWebView2InitializationCompleted.
Charger le HTML.
Déclarer / Gérer les événements JavaScript/.NET
(création d'un pont via CoreWebView2.WebMessageReceived).

Avec WebView2, nous devons attendre que CoreWebView2 soit prêt. Ce surcoût de code vient du cycle de vie plus explicite du navigateur.

En revanche, une fois le pont configuré, nous disposons d'une interface plus moderne et plus flexible.

L'événement JavaScript chrome.webview.postMessage(...) envoie un "message" à Python/.NET. En retour, .NET peut exécuter du JavaScript ou envoyer un message à la page. Cela facilite la création d'une interface web pilotée par Revit.

Exemple

Voici un exemple avec un DataFrame Pandas et la bibliothèque open-source de visualisation de données Plotly.

Nous passons ici par une classe d'extension Pandas pour créer des propriétés dynamiques d'un DataFrame, puis les afficher dans une fenêtre WPF.

vidéo


import clr
import sys
import System
#import net library
from System import Array
from System.Collections.Generic import List, IList, Dictionary

from System import Environment
from System.IO import Path, Directory
from System import Action
from System.Threading.Tasks import Task
#import Revit API
clr.AddReference('RevitAPI')
import Autodesk
from Autodesk.Revit.DB import *
import Autodesk.Revit.DB as DB
#import specify namespace
from Autodesk.Revit.DB.Electrical import *

clr.AddReference('RevitAPIUI')
import Autodesk.Revit.UI as RUI
from Autodesk.Revit.UI import *


#import transactionManager and DocumentManager (RevitServices is specific to Dynamo)
clr.AddReference('RevitServices')
import RevitServices
from RevitServices.Persistence import DocumentManager
from RevitServices.Transactions import TransactionManager
doc = DocumentManager.Instance.CurrentDBDocument
uiapp = DocumentManager.Instance.CurrentUIApplication
uidoc = uiapp.ActiveUIDocument

clr.AddReference("System.Core")
clr.ImportExtensions(System.Linq)

clr.AddReference("System.Reflection")
from System.Reflection import BindingFlags

clr.AddReference("System.Xml")
clr.AddReference("PresentationFramework")
clr.AddReference("System.Xml")
clr.AddReference("PresentationCore")
clr.AddReference("System.Windows")
import System.Windows.Controls 
from System.Windows.Controls import *
import System.Windows.Controls.Primitives 
from System.Collections.Generic import List
from System.IO import StringReader
from System.Xml import XmlReader
from System.Windows import LogicalTreeHelper 
from System.Windows.Markup import XamlReader, XamlWriter
from System.Windows import Window, Application
from System.Windows.Media.Imaging import BitmapCacheOption, BitmapCreateOptions, TransformedBitmap
from System.Windows.Media import ScaleTransform
from System.Windows import Application, WindowState

clr.AddReference("Microsoft.Web.WebView2.Core")
from Microsoft.Web.WebView2.Core import CoreWebView2Environment

import os
import tempfile
import time
import json
import traceback
import pandas as pd
import re
import plotly.express as px
import plotly.graph_objects as go


APPDATADIR = Environment.GetFolderPath( Environment.SpecialFolder.LocalApplicationData)


class MainForm(Window):
    __namespace__ = "Dynamo.PandasViewer_WxeZ74"
    #
    init_htmlDf = """\
        <html>
        <head>
        <meta http-equiv="X-UA-Compatible" content="IE=9">
        <style> 
          table, th, td {font-size:10pt; border:1px solid black; border-collapse:collapse; text-align:left;}
          th, td {padding: 5px;}
          tr:nth-child(even) {background: #E0E0E0;}
          tr:hover {background: silver; cursor: pointer;}
        </style>
        </head>
          <body>
          </body>
        </html>
        """
    string_xaml = '''
    <Window
        x:Name="PandasViewerForm"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:wv2="clr-namespace:Microsoft.Web.WebView2.Wpf;assembly=Microsoft.Web.WebView2.Wpf"
        Title="PandasViewer"
        Width="600"
        Height="540"
        MinWidth="300"
        MinHeight="200"
        WindowStartupLocation="CenterScreen"
        ResizeMode="CanResizeWithGrip">
    
        <Grid>
            <wv2:WebView2
                x:Name="webBrowser1"
                HorizontalAlignment="Stretch"
                VerticalAlignment="Stretch"/>
        </Grid>
    </Window>'''
  
    def __init__(self):
        super().__init__()
        self.htmlDf = self.init_htmlDf
        self._core = None
        self._pending_html = None
        self._initialized = False
        self.start_time = time.time()
        # Solution with PythonNetFixer module
        xr = XmlReader.Create(StringReader(MainForm.string_xaml))
        self.root = XamlReader.Load(xr) 
        # copy attributes from the root window to self (NOT NECESSARY if you used WPF_Utils.LoadComponent(self, string_xaml))
        for prop_info in self.root.GetType().GetProperties():
            if prop_info.CanWrite:
                try:
                    setattr(self, prop_info.Name, prop_info.GetValue(self.root)) 
                except Exception as ex:
                    print(ex, f"{prop_info.Name=}")
        self.InitializeComponent()
        
    def InitializeComponent(self):
        reader = XmlReader.Create(StringReader(MainForm.string_xaml))
        while reader.Read():
            # Check if it's an element node
            if reader.NodeType == System.Xml.XmlNodeType.Element:
                # Check for x:Name attribute
                name = next((reader.GetAttribute(x) for x in ["x:Name", "Name"] if reader.GetAttribute(x) is not None ), None)
                if name:
                    uiElement = LogicalTreeHelper.FindLogicalNode(self.root, name)
                    if uiElement:
                        setattr(self, name, uiElement)
        #
        self.ContentRendered  += self.WindowRendered

        self.Loaded += self.On_loaded
        self.webBrowser1.CoreWebView2InitializationCompleted += self.On_Initialized

            
    def WindowRendered(self, sender, e):
        print(f"UI show in {time.time() - self.start_time} seconds")
        
    def On_loaded(self, sender, e):
        if getattr(self, "_webview_started", False):
            return
        self._webview_started = True
    
        try:
            folder = Path.Combine(APPDATADIR, "DynamoPandasViewer", "WebView2")
            Directory.CreateDirectory(folder)
    
            task = CoreWebView2Environment.CreateAsync(None, folder, None)
    
            def completed(t):
                def apply():
                    if t.IsFaulted:
                        print("WebView2 error:", t.Exception)
                    else:
                        self.webBrowser1.EnsureCoreWebView2Async(t.Result)
    
                self.Dispatcher.BeginInvoke(Action(apply))
    
            self._environment_continuation = task.ContinueWith(
                Action[Task](completed)
            )
        except Exception:
            print(traceback.format_exc())
    
    
    def On_Initialized(self, sender, e):
        if not e.IsSuccess:
            print("WebView2 initialization failed:", e.InitializationException)
            return
    
        self._core = self.webBrowser1.CoreWebView2
        self._core.WebMessageReceived += self.On_web_message
        self.Navigate_to_html(getattr(self, "_pending_html", None) or self.htmlDf)
    
    
    def Navigate_to_html(self, html):
        if self._core is None:
            self._pending_html = html
            return
        #
        path = os.path.join(tempfile.gettempdir(), f"dynamo_plotly_viewer.html")
        #
        with open(path, "w", encoding="utf-8") as f:
            f.write(str(html))
    
        self._core.Navigate("file:///" + path.replace("\\", "/"))
    
    
    def On_web_message(self, sender, e):
        try:
            message = json.loads(e.TryGetWebMessageAsString())
            if message.get("type") != "selectElement":
                return
    
            value = str(message.get("elementId", ""))
            if value.isdigit():
                elemId = ElementId(int(value))
                uidoc.Selection.SetElementIds(List[ElementId]([elemId]))
                uidoc.ShowElements(List[ElementId]([elemId]))
        except Exception:
            print(traceback.format_exc())
        
    #@property
    def get_HtmlText(self):
        return self.htmlDf
        
    def set_HtmlText(self, value):
        self.htmlDf = value
        if self._core is None:
            self._pending_html = value
        else:
            self.Navigate_to_html(self.htmlDf)
    
    HtmlText = clr.clrproperty(str, get_HtmlText, set_HtmlText)
        

    def ResetHtml(self):
        self.HtmlText = self.init_htmlDf
    
    
@pd.api.extensions.register_dataframe_accessor("viewer")
class HtmlAccessor:

    def __init__(self, df_obj):
        self._obj = df_obj

    def _get_base_html(self):
        html_content = getattr(viewerForm, "htmlDf", "")
        if not html_content or "</body>" not in html_content:
            return "<html><body></body></html>"
        return html_content

    def Show(self, n=0, label=""):
        html_df = self._get_base_html()

        df_to_show = self._obj if n == 0 else self._obj.head(n)
        html_to_add = df_to_show.to_html()

        if label:
            html_to_add = f"<p><b>{label}</b></p>" + html_to_add

        updated_html = re.sub(
                r"</body>", html_to_add + r"<br><hr><br></body>", html_df, flags=re.I
        )

        viewerForm.HtmlText = updated_html
        viewerForm.htmlDf = updated_html
        
    def Plot3D(self, contours_points=None):
        
        post_script = """
            document.getElementById('{plot_id}').on('plotly_click', e => {
                const id = e.points[0].customdata?.[0];
                if (id != null && window.chrome?.webview)
                    window.chrome.webview.postMessage(JSON.stringify({
                        type: 'selectElement', elementId: String(id)
                    }));
            });
        """
        df = self._obj
        cfg = df.attrs.get("plot3d", {})
    
        fig = px.scatter_3d(
            df,
            x=cfg.get("x", "X"),
            y=cfg.get("y", "Y"),
            z=cfg.get("z", "Z"),
            color=cfg.get("color", "Name"),
            size=cfg.get("size", "Power"),
            size_max=100,
            hover_data=cfg.get("hover_data", ["ElementId", "Name", "Power"]),
            custom_data=["ElementId"]
        )
    
        for i, pts in enumerate(contours_points or []):
            x, y, z = zip(*[(p.X, p.Y, p.Z) for p in pts])
            fig.add_trace(go.Scatter3d(
                x=x, y=y, z=z, 
                mode="lines",
                name=f"Contour sol {i + 1}",
                line=dict(color="gray", width=1),
                hoverinfo="skip"
            ))
    
        html = fig.to_html(full_html=True, include_plotlyjs=True, post_script=post_script)
    
        html = re.sub(
            r"</body>", lambda m: html + m[0],
            self._get_base_html(), count=1, flags=re.I
        )
    
        viewerForm.HtmlText = viewerForm.htmlDf = html
        

def find_viewer():
    app = Application.Current

    if app is None:
        return None, None

    for window in app.Windows:
        print(window.Title)
        try:
            if window.Title != "PandasViewer":
                continue
            # The WebView2 control is declared in the XAML.
            web = window.FindName("webBrowser1")

            if web is None:
                _web = getattr(window, "webBrowser1", None)
                _htmlText = getattr(window, "HtmlText", None)
            #
            if _web is not None and _htmlText is not None:
                return window, _web

        except Exception:
            continue
    return None, None


viewerForm, webView = find_viewer()

if viewerForm is None :
    viewerForm = MainForm()
    viewerForm.Title = "PandasViewer"
    viewerForm.Show()

else:
    viewerForm.ResetHtml()
    
    if not viewerForm.IsVisible:
        viewerForm.Show()

    if viewerForm.WindowState == WindowState.Minimized:
        viewerForm.WindowState = WindowState.Normal

    viewerForm.Activate()
     
    
def get_floor_contours(xdoc):
    return [
        points
            for f in FilteredElementCollector(xdoc).OfClass(Floor).WhereElementIsNotElementType()
                for r in HostObjectUtils.GetTopFaces(f)
                    for face in [f.GetGeometryObjectFromReference(r)]
                        if face.Area > 50
                            for points in [[p for loop in face.GetEdgesAsCurveLoops() for c in loop for p in c.Tessellate()]]
                                if len(points) >= 3
    ]

lnkinstance = UnwrapElement(IN[0])
doc_lnk = lnkinstance.GetLinkDocument()

all_panels = (FilteredElementCollector(doc).OfCategory(BuiltInCategory.OST_ElectricalEquipment).WhereElementIsNotElementType()
            .Where(System.Func[DB.Element, System.Boolean](lambda e : e.Symbol.Family.get_Parameter(BuiltInParameter.FAMILY_CONTENT_PART_TYPE).AsInteger() == 14))\
            .ToList()

)

df = pd.DataFrame([], columns=["ElementId", "X", "Y", "Z", "Power", "Name"])


for panel in all_panels:
    loc = panel.Location.Point
    power_str = panel.get_Parameter(BuiltInParameter.RBS_ELEC_PANEL_TOTALLOAD_PARAM).AsValueString()
    print(power_str)
    power = float(re.search(r"([0-9]+(?:\.[0-9]+)?)\s*", power_str).group(1))
    df.loc[len(df) + 1] = [panel.Id.Value, loc.X, loc.Y, loc.Z, power, panel.Name]
    
df.viewer.Show(label="list of Electrical Panel")   
contours = get_floor_contours(doc_lnk)    
df.viewer.Plot3D(contours)

OUT = repr(df)

Comparaison avec WebBrowser

Fonctionnalité	WebBrowser classique	WebView2
Afficher HTML / CSS	Oui	Oui
Afficher Plotly 3D	Possible, mais moteur ancien	Oui, Chromium moderne
Rotation et zoom 3D	Dépend de la version d'IE	Oui
Clic sur une sphère (`plotly_click`)	Dépend de la compatibilité JavaScript	Oui
JavaScript → Python/.NET	`ObjectForScripting`	`WebMessageReceived`
Python/.NET → JavaScript	`InvokeScript()`	`ExecuteScriptAsync()`
Initialisation asynchrone du moteur	Non, généralement plus simple	Oui
Compatibilité avec les bibliothèques JS modernes	Limitée	Excellente

« C’est le temps que tu as perdu pour ta rose qui fait ta rose si importante. »
Le Petit Prince (chapitre 21) Antoine de Saint-Exupéry,

[Dynamo + Python] Revit 2027 : HVAC Zone → GenericZone (Migration API)

2026-09-30T12:33:33.776+02:00

Comment retrouver les zones systèmes (ex CVC) qui sont attachées aux espaces avec Revit 2027

#DynamoBIM #Revit #Python #RevitAPI #GenericZone #Revit API 2027 #AutodeskExpertElite #AutodeskCommunity

if this article is not in your language, use the Google Translate widget ⬈ (bottom of page for Mobile version ⬇)

Les Zones Système (GenericZones) viennent remplacer les Zones HVAC .

Sur des projets existants, elles sont désormais automatiquement converties lors de l’ouverture des projets Revit 2027.

Parmi les changements notables :

les HVAC Zones deviennent obsolètes
Les espaces MEP peuvent être situés dans plusieurs zones.
Les zones dépendent d'un seul niveau (impossibilité de créer une zone sur plusieurs niveaux).
Les zones peuvent être :

soit attaché aux espaces
soit basées sur une esquisse

Les Zones Système (GenericZones) sont des zones analytiques.

Il en résulte plusieurs modifications dans l'API

Migration / Item	Details
Propriété et BIC dépréciés	`Autodesk.Revit.DB.Mechanical.Space.Zone`, `BuiltInCategory:OST_HVAC_Zones`
a utilisé en remplacement	`GenericZone` + `GetSpaceIds()`

Voici un exemple qui combine deux méthodes pour retrouver les espaces, tout en stockant le tout dans une Datatable pour faire une recherche rapide par ElementId via Select()

1. Zones basées sur des espaces

La méthode la plus rapide consiste à utiliser :

spaceIds = genericZone.GetSpaceIds()

Chaque ElementId correspond à un espace associé à la zone.

2. Zones basées sur une esquisse

Les zones créées à partir d'un contour ne possèdent pas d'association directe avec les espaces.

L'alternative consiste à :

récupérer le polygone de la zone

récupérer le point de calcul de chaque espace et vérifier si ce dernier est dans le polygone (avec l'API Dynamo Polygon.ContainmentTest() )


import clr
import System
from System.Collections.Generic import List
from System.Linq import Enumerable
from System.Collections.Generic import IEnumerable

clr.AddReference('ProtoGeometry')
from Autodesk.DesignScript.Geometry import *
import Autodesk.DesignScript.Geometry as DS

clr.AddReference('RevitAPI')
import Autodesk
import Autodesk.Revit.DB as DB
from Autodesk.Revit.DB import *
from Autodesk.Revit.DB.Analysis import *

clr.AddReference('RevitServices')
import RevitServices
from RevitServices.Persistence import DocumentManager
doc = DocumentManager.Instance.CurrentDBDocument
uiapp = DocumentManager.Instance.CurrentUIApplication
uidoc = uiapp.ActiveUIDocument
app = uiapp.Application
sdkNumber = int(app.VersionNumber)

clr.AddReference('RevitNodes')
import Revit
clr.ImportExtensions(Revit.Elements)
clr.ImportExtensions(Revit.GeometryConversion)
clr.ImportExtensions(Revit.GeometryReferences)

clr.AddReference('System.Data')
from System.Data import *

clr.AddReference("System.Core")
clr.ImportExtensions(System.Linq)


import traceback
input_space = UnwrapElement(IN[0])

fecSpace = FilteredElementCollector(doc).OfCategory(BuiltInCategory.OST_MEPSpaces).WhereElementIsNotElementType().ToElements()

def get_ZoneGetSpaceIds(zone):
    try:
        if zone.GeometricDefinition == ZoneGeometricDefinition.Spaces:
            return zone.GetSpaceIds()
        else:
            zone_sketch = doc.GetElement(zone.GetSketchId())
            profile : DB.CurveArrArray = zone_sketch.Profile
            zone_polygon = DS.Polygon.ByPoints([c.GetEndPoint(0).ToPoint() for c in profile[0]])
            level1Filter = ElementLevelFilter(zone.LevelId)
            fecLvlSpaceId = (
                FilteredElementCollector(doc).OfCategory(BuiltInCategory.OST_MEPSpaces).WhereElementIsNotElementType().WherePasses(level1Filter)
                .Where(System.Func[System.Object, System.Boolean](lambda space: space.Area > 0 and isinstance(space.Location, DB.LocationPoint)) )
                .Where(System.Func[System.Object, System.Boolean](lambda space: zone_polygon.ContainmentTest(space.Location.Point.ToPoint() ) ))
                .Select[System.Object, DB.ElementId](System.Func[System.Object, DB.ElementId](lambda x: x.Id))
                .ToList()
            )
            return fecLvlSpaceId
    except Exception as ex:
        print(traceback.format_exc())
        return List[ElementId]()

if sdkNumber < 2027:
    OUT = [[s.Name , s.Zone.Name ] for s in fecSpace]
else:
    # Global variable DataTable                                
    dt_zone = DataTable("GZone")
    dt_zone.Columns.Add('SpaceId', DB.ElementId)
    dt_zone.Columns.Add('SpaceIdValue', System.Int64)
    dt_zone.Columns.Add('Zone', DB.Analysis.GenericZone)     
    dt_zone.Columns.Add('ZoneName', System.String)  
    #
    dt_zone.BeginLoadData()
    lst_zones = (
                FilteredElementCollector(doc).OfClass(GenericZone)
                .SelectMany[DB.Element, DB.ElementId, DataRow](
                                                System.Func[DB.Element, IEnumerable[DB.ElementId]](lambda z : get_ZoneGetSpaceIds(z) ),
                                                System.Func[DB.Element, DB.ElementId, DataRow](lambda z, space_id : dt_zone.Rows.Add(space_id, space_id.Value, z, z.Name)
                                                ))
                .ToList()
    )
    
    dt_zone.EndLoadData()
    #
    #OUT = [[s.Name , dt_zone.Select(f"[SpaceIdValue] = '{s.Id.Value}'").Cast[DataRow]().FirstOrDefault() ] for s in fecSpace]
    # 
    out = []
    for s in fecSpace:
        dataRow_spaces = dt_zone.Select(f"[SpaceIdValue] = '{s.Id.Value}'").Cast[DataRow]()#.FirstOrDefault() 
        if dataRow_spaces is not None:
            out.append([s.Name, [r['ZoneName'] for r in dataRow_spaces] ])
            
    if input_space is not None:
        dataRow_spaces = dt_zone.Select(f"[SpaceIdValue] = '{input_space.Id.Value}'").Cast[DataRow]()
        print(len(list(dataRow_spaces)))
        dataRow_ZDM = dt_zone.Select(f"[SpaceIdValue] = '{input_space.Id.Value}' AND [ZoneName] Like '%ZDM%'").Cast[DataRow]().FirstOrDefault() 
        dataRow_ZDA = dt_zone.Select(f"[SpaceIdValue] = '{input_space.Id.Value}' AND [ZoneName] Like '%ZDA%'").Cast[DataRow]().FirstOrDefault() 
        if dataRow_spaces is not None:
            out.insert(0, [
                            input_space.Name, 
                            [r['ZoneName'] for r in dataRow_spaces], 
                            dataRow_ZDM['ZoneName'] if dataRow_ZDM is not None else None,
                            dataRow_ZDA['ZoneName'] if dataRow_ZDA is not None else None
                        ])
    OUT = out

. .

« Ce n’est pas que nous ayons peu de temps, c’est que nous en perdons beaucoup. »
Sénèque

...

[Dynamo += Python] Export IFC : configurations Utilisateur (MAJ 05/09/2026)

2026-09-04T23:50:00.000+02:00

Une astuce pour obtenir les données des configurations d'Export IFC

#DynamoBIM #Revit #Python #RevitAPI #IFC #ConfigurationIFC #AutodeskExpertElite #AutodeskCommunity

if this article is not in your language, use the Google Translate widget ⬈ (bottom of page for Mobile version ⬇)

MAJ 05/09/2026 : Mise à jour pour Revit 2027

Dans le présent article, depuis Revit, nous cherchons à récupérer les données des configurations utilisateur d'export IFC.

Le but étant de permettre un export IFC depuis Dynamo suivant une configuration précise sans avoir à faire un export-import de celle-ci (au format json)

Le code Python



import clr
import sys
import System

# Import RevitAPI
clr.AddReference("RevitAPI")
import Autodesk
from Autodesk.Revit.DB import *
import Autodesk.Revit.DB as DB
from Autodesk.Revit.Attributes import *
from Autodesk.Revit.DB.IFC import *


clr.AddReference("RevitServices")
import RevitServices
from RevitServices.Persistence import DocumentManager
from RevitServices.Transactions import TransactionManager
doc = DocumentManager.Instance.CurrentDBDocument
uiapp = DocumentManager.Instance.CurrentUIApplication
uidoc = uiapp.ActiveUIDocument
app = uiapp.Application
sdkNumber = int(app.VersionNumber)


IFCExportConfiguration = None
IFCExportConfigurationsMap = None
pf_path = System.Environment.GetFolderPath(System.Environment.SpecialFolder.ProgramFilesX86)
pf_data_path = System.Environment.GetFolderPath(System.Environment.SpecialFolder.CommonApplicationData)
ifc_bundle_path = "{0}\\Autodesk\\ApplicationPlugins\\IFC {1}.bundle\\Contents\\{1}".format(pf_data_path, sdkNumber)
if System.IO.Directory.Exists(ifc_bundle_path):
    print("pass1")
    sys.path.append(ifc_bundle_path)
    if sdkNumber < 2027:
        clr.AddReference("IFCExporterUIOverride")
        from BIM.IFC.Export.UI import IFCExportConfigurationsMap, IFCExportConfiguration, IFCCommandOverrideApplication
    else:
        clr.AddReference("Revit.IFC.Export")
        from Revit.IFC.Export.Utility import IFCExportConfigurationsMap, IFCExportConfiguration
        clr.AddReference("IFCExporterUIOverride")
        from BIM.IFC.Export.UI import IFCCommandOverrideApplication
else:
    ifc_addin_path = "{}\\Autodesk\\Revit {}\\AddIns\IFCExporterUI".format(pf_path, sdkNumber)
    if System.IO.Directory.Exists(ifc_addin_path):
        print("pass2")
        sys.path.append(ifc_addin_path)
        clr.AddReference("Autodesk.IFC.Export.UI")
        from BIM.IFC.Export.UI import IFCExportConfigurationsMap, IFCExportConfiguration, IFCCommandOverrideApplication

import json

ifc_dict_config = {}
if IFCExportConfigurationsMap is not None:
    idfdocA = IFCCommandOverrideApplication.TheDocument
    if idfdocA is None:
        propinfo = clr.GetClrType(IFCCommandOverrideApplication).GetProperty('TheDocument')
        propinfo.SetValue(None, doc)
    configurationsMap = IFCExportConfigurationsMap(doc)
    configurationsMap.AddBuiltInConfigurations()
    configurationsMap.AddSavedConfigurations({})
    
    for config in configurationsMap.Values:
        dict_ifc_version_str = {"IFC_Version_str": config.IFCVersion.ToString() }
        dict_config = json.loads(config.SerializeConfigToJson())
        # merge dictionaries
        merge_dict_3 = dict(dict_ifc_version_str,**dict_config)
        ifc_dict_config[config.Name] = merge_dict_3
  
OUT = ifc_dict_config

Note 1

il existe 2 addin export IFC, celui de base (qui est livré d'origine avec Revit) et celui que l'on met à jour manuellement par la suite via le Repo Github d'Autodesk, ce dernier vient remplacer le 1er, mais ne partage pas le même dossier.

Il faut donc veiller à charger la bonne assembly (voir code ci dessus)

Note 2

Une petite explication concernant ces lignes


idfdocA = IFCCommandOverrideApplication.TheDocument
if idfdocA is None:
	propinfo = clr.GetClrType(IFCCommandOverrideApplication).GetProperty('TheDocument')
	propinfo.SetValue(None, doc)

Ces lignes de code effectuent une opération de réflexion (.NET Reflection) pour modifier dynamiquement la propriété TheDocument d'une instance de la classe IFCCommandOverrideApplication.

Le but de ces lignes est de s'assurer que l'application d'exportation IFC IFCCommandOverrideApplication est configurée pour utiliser le document Revit actuel (doc) comme contexte pour l'exportation. Cela peut être nécessaire si l'application d'exportation IFC n'est pas automatiquement configurée pour utiliser le bon document Revit ou si vous devez réaffecter explicitement le document cible pour l'exportation dans des scénarios spécifiques.

Résultat

Export IFC à partir des valeurs d'une configuration

Vous pouvez ensuite compléter le script dynamo en rajoutant par exemple le nœud Export IFC du package GeniusLoci

Export IFC direct à partir d'un IFCExportConfiguration

Une autre solution consiste de transférer les valeurs une instance d'un IFCExportConfiguration vers une instance IFCExportOptions avec la méthode

Void UpdateOptions(Autodesk.Revit.DB.IFCExportOptions, Autodesk.Revit.DB.ElementId)

CODE 1 (extraction des configurations)


import clr
import sys
import System

# Import RevitAPI
clr.AddReference("RevitAPI")
import Autodesk
from Autodesk.Revit.DB import *
import Autodesk.Revit.DB as DB
from Autodesk.Revit.Attributes import *
from Autodesk.Revit.DB.IFC import *


clr.AddReference("RevitServices")
import RevitServices
from RevitServices.Persistence import DocumentManager
from RevitServices.Transactions import TransactionManager
doc = DocumentManager.Instance.CurrentDBDocument
uiapp = DocumentManager.Instance.CurrentUIApplication
uidoc = uiapp.ActiveUIDocument
app = uiapp.Application
sdkNumber = int(app.VersionNumber)


IFCExportConfiguration = None
IFCExportConfigurationsMap = None
pf_path = System.Environment.GetFolderPath(System.Environment.SpecialFolder.ProgramFilesX86)
pf_data_path = System.Environment.GetFolderPath(System.Environment.SpecialFolder.CommonApplicationData)
ifc_bundle_path = "{0}\\Autodesk\\ApplicationPlugins\\IFC {1}.bundle\\Contents\\{1}".format(pf_data_path, sdkNumber)
if System.IO.Directory.Exists(ifc_bundle_path):
    print("pass1")
    sys.path.append(ifc_bundle_path)
    if sdkNumber < 2027:
        clr.AddReference("IFCExporterUIOverride")
        from BIM.IFC.Export.UI import IFCExportConfigurationsMap, IFCExportConfiguration, IFCCommandOverrideApplication
    else:
        clr.AddReference("Revit.IFC.Export")
        from Revit.IFC.Export.Utility import IFCExportConfigurationsMap, IFCExportConfiguration
        clr.AddReference("IFCExporterUIOverride")
        from BIM.IFC.Export.UI import IFCCommandOverrideApplication
else:
    ifc_addin_path = "{}\\Autodesk\\Revit {}\\AddIns\IFCExporterUI".format(pf_path, sdkNumber)
    if System.IO.Directory.Exists(ifc_addin_path):
        print("pass2")
        sys.path.append(ifc_addin_path)
        clr.AddReference("Autodesk.IFC.Export.UI")
        from BIM.IFC.Export.UI import IFCExportConfigurationsMap, IFCExportConfiguration, IFCCommandOverrideApplication

import json

ifc_dict_config = {}
if IFCExportConfigurationsMap is not None:
    idfdocA = IFCCommandOverrideApplication.TheDocument
    if idfdocA is None:
        propinfo = clr.GetClrType(IFCCommandOverrideApplication).GetProperty('TheDocument')
        propinfo.SetValue(None, doc)
    configurationsMap = IFCExportConfigurationsMap(doc)
    configurationsMap.AddBuiltInConfigurations()
    configurationsMap.AddSavedConfigurations({})
    
    for config in configurationsMap.Values:
        dict_ifc_version_str = {"IFC_Version_str": config.IFCVersion.ToString() }
        dict_config = json.loads(config.SerializeConfigToJson())
        # merge dictionaries
        merge_dict_3 = dict(dict_ifc_version_str,**dict_config)
        ifc_dict_config[config.Name] = merge_dict_3
  
OUT = ifc_dict_config

CODE 2 (Export IFC)

Actuellement (sous Pythonnet3 + Revit 2027.1 ) une erreur se produit avec Document.Export(String, String, IFCExportOptions) , une solution de contournement consiste à utiliser la Reflection.


import clr
import sys
import System
from System.Collections.Generic import *

clr.AddReference('ProtoGeometry')
from Autodesk.DesignScript.Geometry import *


clr.AddReference("System.Reflection")
from System.Reflection import BindingFlags

clr.AddReference("System.Core")
clr.ImportExtensions(System.Linq)

# Import RevitAPI
clr.AddReference("RevitAPI")
import Autodesk
from Autodesk.Revit.DB import *
import Autodesk.Revit.DB as DB
from Autodesk.Revit.Attributes import*
from Autodesk.Revit.DB.IFC import*

# Import DocumentManager and TransactionManager
clr.AddReference("RevitServices")
import RevitServices
from RevitServices.Persistence import DocumentManager
from RevitServices.Transactions import TransactionManager
doc = DocumentManager.Instance.CurrentDBDocument
uiapp = DocumentManager.Instance.CurrentUIApplication
app = uiapp.Application
uidoc = DocumentManager.Instance.CurrentUIApplication.ActiveUIDocument
sdkNumber = int(app.VersionNumber)

IFCExportConfiguration = None
IFCExportConfigurationsMap = None
pf_path = System.Environment.GetFolderPath(System.Environment.SpecialFolder.ProgramFilesX86)
pf_data_path = System.Environment.GetFolderPath(System.Environment.SpecialFolder.CommonApplicationData)
ifc_bundle_path = "{0}\\Autodesk\\ApplicationPlugins\\IFC {1}.bundle\\Contents\\{1}".format(pf_data_path, sdkNumber)
if System.IO.Directory.Exists(ifc_bundle_path):
    sys.path.append(ifc_bundle_path)
    if sdkNumber < 2027:
        clr.AddReference("IFCExporterUIOverride")
        from BIM.IFC.Export.UI import IFCExportConfigurationsMap, IFCExportConfiguration, IFCCommandOverrideApplication
    else:
        clr.AddReference("Revit.IFC.Export")
        from Revit.IFC.Export.Utility import IFCExportConfigurationsMap, IFCExportConfiguration
        clr.AddReference("Revit.IFC.Common")
        from Revit.IFC.Common.Extensions import IFCClassificationMgr
        clr.AddReference("IFCExporterUIOverride")
        from BIM.IFC.Export.UI import IFCCommandOverrideApplication
else:
    ifc_addin_path = "{}\\Autodesk\\Revit {}\\AddIns\IFCExporterUI".format(pf_path, sdkNumber)
    if System.IO.Directory.Exists(ifc_addin_path):
        print("pass2")
        sys.path.append(ifc_addin_path)
        clr.AddReference("Autodesk.IFC.Export.UI")
        from BIM.IFC.Export.UI import IFCExportConfigurationsMap, IFCExportConfiguration, IFCCommandOverrideApplication
        
        
def exportIfc(current_doc, pathfolder, name, ifcExportConfig, view3DId=ElementId.InvalidElementId):
    global error
    #
    if name.endswith(".rvt"):
        name = name.replace(".rvt", ".ifc")
    #
    #When using transactions with documents other than the primary document,better luck creating transactions from scratch.
    TransactionManager.Instance.ForceCloseTransaction()
    # define options
    options = IFCExportOptions()
    if ifcExportConfig is not None :
        #Define the of a 3d view to export
        
        # copy settings of the myIFCExportConfiguration to the IFCExportOptions
        if sdkNumber < 2027:
            exportViewId = ElementId.InvalidElementId # or None -> add view in options
            ifcExportConfig.UpdateOptions(options, exportViewId)
        else:
            # Revit 2027 and above
            if view3DId == ElementId.InvalidElementId:
                ifcExportConfig.UseActiveViewGeometry = False
                ifcExportConfig.VisibleElementsOfCurrentView = False
            else:
                ifcExportConfig.VisibleElementsOfCurrentView = True
                ifcExportConfig.ActiveViewId = view3DId
            #
            if ifcExportConfig.ExportUserDefinedPsets:
                userDefinedPsetsFileName = System.IO.Path.GetFileName(ifcExportConfig.ExportUserDefinedPsetsFileName)
                ifcExportConfig.ExportUserDefinedPsetsFileName = System.IO.Path.Combine(pathfolder, userDefinedPsetsFileName)
            #
            if ifcExportConfig.ExportUserDefinedPsets:
                userDefinedParameterMappingFileName = System.IO.Path.GetFileName(ifcExportConfig.ExportUserDefinedParameterMappingFileName)
                ifcExportConfig.ExportUserDefinedParameterMappingFileName = System.IO.Path.Combine(pathfolder, userDefinedParameterMappingFileName)
                
            ifcExportConfig.UpdateOptions(current_doc, options, view3DId, False)
            # call this before the Export IFC transaction starts, as it has its own transaction.
            IFCClassificationMgr.DeleteObsoleteSchemas(current_doc)
    
    #
    t = Transaction(current_doc, 'Export IFC')
    t.Start()
    failureOptions = t.GetFailureHandlingOptions()
    failureOptions.SetClearAfterRollback(False)
    t.SetFailureHandlingOptions(failureOptions)
    #
    try:
        #
        current_doc.Regenerate()
        result = current_doc.GetType().InvokeMember("Export", BindingFlags.InvokeMethod , None, current_doc, (pathfolder, name, options) )
    except Exception as ex:
        print(ex)
        t.RollBack()
        t.Dispose()
        return 0
    else:
        t.RollBack() # instead of t.Dispose()
        t.Dispose()
        return pathfolder + '\\' + name
        
        
ifc_config_map = IN[0]
pathfolder = IN[1]
name = IN[2]
ifc_config_name = IN[3]

ifcExportConfig = ifc_config_map[ifc_config_name]

exportIfc(doc, pathfolder, name, ifcExportConfig)

Le monde se divise en deux catégories......
NWC VS IFC
Close VS Open
sans hôte VS hôte par face
Modèle Générique VS Site
Etc...

La meilleure, c'est celle qui fait avancer le projet…