Numerical Attribute validation callback (#2562)

* Numerical attributes can now be clamped

* #2545 : IfcMaterialLayer Priority is now clamped between 0 and 100

* Run black

.github/workflows/ci-blenderbim-choco.yml

@@ -0,0 +1,92 @@
+name: Publish-blenderbim-chocolatey package
+
+on:
+  schedule:
+    #         ┌───────────── minute (0 - 59)
+    #         │  ┌───────────── hour (0 - 23)
+    #         │  │ ┌───────────── day of the month (1 - 31)
+    #         │  │ │ ┌───────────── month (1 - 12 or JAN-DEC)
+    #         │  │ │ │ ┌───────────── day of the week (0 - 6 or SUN-SAT)
+    #         *  * * * *
+    - cron:  "30 0 * * *" # 30min past utc midnight
+
+env:
+  major: 0
+  minor: 0
+  name: blenderbim
+  choco_version: 1.1.0
+  CHOCO_TOKEN:   ${{ secrets.CHOCO_TOKEN }}
+
+jobs:
+  activate:
+    runs-on: ubuntu-latest
+    if: |
+      github.repository == 'IfcOpenShell/IfcOpenShell'
+    steps:
+    - name: Set env
+      run: echo ok go
+
+  build:
+    needs: activate
+    name: ${{ matrix.config.name }}-${{ matrix.pyver }}
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        pyver: [py310]
+        config:
+          - {
+            name: "Windows Build",
+            short_name: win,
+          }
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/setup-python@v2 # https://github.com/actions/setup-python
+        with:
+          python-version: '3.7.7' # Version range or exact version of a Python version to use, using SemVer's version range syntax
+          architecture: 'x64' # optional x64 or x86. Defaults to x64 if not specified
+      - run: echo ${{ env.DATE }}
+
+      - name: Check in published releases if we should do a choco release
+        id: do_choco
+        run: |
+          echo "::set-output name=choco_release::$(python3 /home/runner/work/IfcOpenShell/IfcOpenShell/choco/blenderbim/check_repo_infos.py --do_choco_release?)"
+
+      - name: Fill chocolatey scripts on win with latest blender python
+        if: ${{steps.do_choco.outputs.choco_release}} == 'do_choco_release'
+        run: |
+          yesterday_non_iso="$(date  --date='yesterday' +'%y%m%d' | tr -d '\n')" &&
+          target_os=${{ matrix.config.short_name }} &&
+          latest_blender_python_version_maj_min=$(python3 /home/runner/work/IfcOpenShell/IfcOpenShell/choco/blenderbim/check_repo_infos.py --latest_blender_python_version_maj_min?) &&
+          echo "latest_blender_python_version_maj_min?: $latest_blender_python_version_maj_min" &&
+          pyver=$(python3 /home/runner/work/IfcOpenShell/IfcOpenShell/choco/blenderbim/check_repo_infos.py --pyver?) &&
+          export latest_blender_version_maj_min=$(python3 /home/runner/work/IfcOpenShell/IfcOpenShell/choco/blenderbim/check_repo_infos.py --latest_blender_release_maj_min?) &&
+          export latest_blender_version_maj_min_pat=$(python3 /home/runner/work/IfcOpenShell/IfcOpenShell/choco/blenderbim/check_repo_infos.py --latest_blender_release_maj_min_pat?) &&
+          echo   latest_blender_version_maj_min_pat?: $latest_blender_version_maj_min_pat &&
+          export blenderbim_build_version="${{ env.major }}.${{ env.minor }}.$yesterday_non_iso" &&
+          export url_blenderbim_py310_win_zip="https://github.com/IfcOpenShell/IfcOpenShell/releases/download/blenderbim-$yesterday_non_iso/blenderbim-$yesterday_non_iso-$pyver-$target_os.zip" &&
+          wget $url_blenderbim_py310_win_zip --no-verbose &&
+          export sha256sum_blenderbim_py310_win_zip=$( sha256sum blenderbim-$yesterday_non_iso-$pyver-$target_os.zip  --tag | cut -d ' ' -f 4  | tr -d '\n') &&
+          echo   sha256sum_blenderbim_py310_win_zip: $sha256sum_blenderbim_py310_win_zip &&
+          python3 choco/blenderbim/fill_dynamic_parameters.py &&
+          echo __build choco with mono &&
+          wget "https://github.com/chocolatey/choco/archive/refs/tags/$choco_version.tar.gz" --quiet &&
+          tar -xzf "$choco_version.tar.gz" &&
+          cd choco-$choco_version &&
+          chmod +x build.sh zip.sh &&
+          ./build.sh &&
+          cp -r build_output/chocolatey /opt/chocolatey &&
+          cd /home/runner/work/IfcOpenShell/IfcOpenShell/choco/blenderbim/ &&
+          echo __choco pack &&
+          mono /opt/chocolatey/choco.exe --version &&
+          mono /opt/chocolatey/choco.exe pack --allow-unofficial &&
+          echo __choco set apiKey &&
+          mono /opt/chocolatey/choco.exe setapikey --key="$CHOCO_TOKEN" --source="https://push.chocolatey.org/" --allow-unofficial # &&
+          echo __choco push &&
+          mono /opt/chocolatey/choco.exe push --source="https://push.chocolatey.org/" --key="$CHOCO_TOKEN" --allow-unofficial --verbose
+
+      - name: Inform user about not packaging
+        if: ${{steps.do_choco.outputs.choco_release}} != 'do_choco_release'
+        run: |
+          echo "no releases found today ${{ env.DATE }}, therefore choco packaging is skipped."
+

.github/workflows/ci-blenderbim-matrix.yml

@@ -3,8 +3,18 @@ name: Publish-blenderbim-multiplatform
 on:
   push:
     paths:
-      - 'src/blenderbim/**'
       - '.github/workflows/ci-blenderbim-matrix.yml'
+      - 'src/blenderbim/**'
+      - 'src/ifcopenshell-python/ifcopenshell/**'
+      - 'src/bcf/src/bcf/**'
+      - 'src/ifcclash/ifcclash/**'
+      - 'src/ifccobie/**'
+      - 'src/ifcdiff/**'
+      - 'src/ifccsv/**'
+      - 'src/ifcpatch/ifcpatch/**'
+      - 'src/ifc4d/ifc4d/**'
+      - 'src/ifc5d/ifc5d/**'
+      - 'src/ifccityjson/**'
     branches:
       - v0.7.0
 
@@ -43,6 +53,10 @@ jobs:
             name: "MacOS Build",
             short_name: macos
           }
+          - {
+            name: "MacOS ARM Build",
+            short_name: macosm1
+          }
     steps:
       - uses: actions/checkout@v2
       - uses: actions/setup-python@v2 # https://github.com/actions/setup-python

.github/workflows/ci-ifcopenshell-conda-daily.yml

@@ -0,0 +1,65 @@
+name: ci-ifcopenshell-conda-daily
+
+on:
+  workflow_run:
+    workflows: ["ci"]
+    types:
+      - completed
+
+jobs:
+  activate:
+    runs-on: ubuntu-latest
+    if: |
+      github.repository == 'IfcOpenShell/IfcOpenShell'
+    steps:
+      - name: Set env
+        run: echo ok go
+
+  test:
+    name: ${{ matrix.platform.distver }}-${{ matrix.pyver.name }}
+    needs: activate
+    runs-on: ${{ matrix.platform.distver }}
+    defaults:
+      run:
+        shell: bash -l {0}
+    strategy:
+      fail-fast: false
+      matrix:
+        pyver: [
+          # { name: py39, distver: '3.9' },
+          { name: py310, distver: '3.10'},
+          { name: py311, distver: '3.11'}
+        ]
+        platform: [
+          { name: Windows, distver: windows-2022, upload: 'false' },
+          { name: Windows, distver: windows-2019, upload: 'true' },
+          { name: Linux, distver: ubuntu-20.04,  upload: 'true' },
+          { name: Linux, distver: ubuntu-22.04,  upload: 'false' },
+          { name: macOS, distver: macos-11, upload: 'true' },
+          { name: macOS, distver: macos-12, upload: 'false' }
+        ]
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          submodules: recursive
+      - name: Download MacOSX SDK
+        if: ${{ matrix.platform.name == 'macOS' }}
+        run: |
+          curl -o MacOSX10.13.sdk.tar.xz -L https://github.com/phracker/MacOSX-SDKs/releases/download/11.3/MacOSX10.13.sdk.tar.xz && \
+          tar xf MacOSX10.13.sdk.tar.xz && \
+          sudo mv -v MacOSX10.13.sdk /opt/ && \
+          ls /opt/
+      - uses: seanmiddleditch/gha-setup-ninja@master
+      - uses: conda-incubator/setup-miniconda@v2  # https://github.com/conda-incubator/setup-miniconda
+        with:
+          activate-environment: conda-build
+          python-version: ${{ matrix.pyver.distver }}
+          environment-file: conda/environment.yml
+      - name: build, test and upload ifcopenshell
+        if: ${{ matrix.platform.upload == 'true' }}
+        run: |
+          conda-build . --python ${{ matrix.pyver.distver }} -c conda-forge --token ${{ secrets.ANACONDA_TOKEN }} --user ifcopenshell --no-remove-work-dir
+      - name: build & test ifcopenshell
+        if: ${{ matrix.platform.upload == 'false' }}
+        run: |
+          conda-build . --python ${{ matrix.pyver.distver }} -c conda-forge --no-remove-work-dir

.github/workflows/ci-ifcopenshell-pypi.yml

@@ -0,0 +1,73 @@
+name: ci-ifcopenshell-pypi
+
+on:
+  schedule:
+    #         ┌───────────── minute (0 - 59)
+    #         │  ┌───────────── hour (0 - 23)
+    #         │  │ ┌───────────── day of the month (1 - 31)
+    #         │  │ │ ┌───────────── month (1 - 12 or JAN-DEC)
+    #         │  │ │ │ ┌───────────── day of the week (0 - 6 or SUN-SAT)
+    #         *  * * * *
+    - cron: "49 23 1 * *" # 11min before utc midnight
+
+env:
+  major: 0
+  minor: 0
+  name: ifcopenshell
+
+jobs:
+  activate:
+    runs-on: ubuntu-latest
+    if: |
+      github.repository == 'IfcOpenShell/IfcOpenShell'
+    steps:
+    - name: Set env
+      run: echo ok go
+
+  build:
+    needs: activate
+    name: ${{ matrix.config.name }}-${{ matrix.pyver }}
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        pyver: [py36, py37, py38, py39, py310]
+        config:
+          - {
+            name: "Windows Build",
+            short_name: win,
+          }
+          - {
+            name: "Linux Build",
+            short_name: linux
+          }
+          - {
+            name: "MacOS Build",
+            short_name: macos
+          }
+          - {
+            name: "MacOS ARM Build",
+            short_name: macosm1
+          }
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/setup-python@v2 # https://github.com/actions/setup-python
+        with:
+          python-version: '3.7.7' # Version range or exact version of a Python version to use, using SemVer's version range syntax
+          architecture: 'x64' # optional x64 or x86. Defaults to x64 if not specified
+      - run: echo ${{ env.DATE }}
+      - name: Get current date
+        id: date
+        run: echo "::set-output name=date::$(date +'%y%m%d')"
+      - name: Compile
+        run: |
+          pip install build
+          cp -r src/ifcopenshell-python src/ifcopenshell_${{ matrix.config.short_name }}_${{ matrix.pyver }} &&
+          cd src/ifcopenshell_${{ matrix.config.short_name }}_${{ matrix.pyver }} &&
+          make dist PLATFORM=${{ matrix.config.short_name }} PYVERSION=${{ matrix.pyver }}
+      - name: Publish a Python distribution to PyPI
+        uses: ortega2247/pypi-upload-action@master
+        with:
+          user: __token__
+          password: ${{ secrets.PYPI_API_TOKEN }}
+          packages_dir: src/ifcopenshell_${{ matrix.config.short_name }}_${{ matrix.pyver }}/dist

.github/workflows/ci-py-only.yml

@@ -0,0 +1,95 @@
+name: ci_py_only
+
+on:
+  push:
+    paths:
+      - 'src/**'
+      - 'test/**'
+      - 'conda/**'
+      - 'cmake/**'
+      - '.github/workflows/ci_py_only.yml'
+  pull_request:
+
+jobs:
+  activate:
+    runs-on: ubuntu-latest
+    if: |
+      github.repository == 'IfcOpenShell/IfcOpenShell' &&
+      !contains(github.event.head_commit.message, 'skip ci')
+    steps:
+      - run: echo ok go
+
+  build:
+    runs-on: ubuntu-20.04
+    needs: activate
+    steps:
+      - uses: actions/checkout@v2
+        with:
+            submodules: recursive
+      - name: Install C++ dependencies
+        run: |
+          sudo apt update
+          sudo apt-get install --no-install-recommends \
+          git cmake gcc g++ \
+          libboost-date-time-dev \
+          libboost-filesystem-dev \
+          libboost-iostreams-dev \
+          libboost-program-options-dev \
+          libboost-regex-dev \
+          libboost-system-dev \
+          libboost-thread-dev \
+          python3-all-dev python3-pip \
+          swig libpcre3-dev libxml2-dev \
+          libtbb-dev nlohmann-json3-dev \
+          libocct-foundation-dev libocct-modeling-algorithms-dev libocct-modeling-data-dev libocct-ocaf-dev libocct-visualization-dev libocct-data-exchange-dev \
+          libhdf5-dev libcgal-dev
+          
+      - name: ccache
+        uses: hendrikmuhs/ccache-action@v1
+
+      - name: Build ifcopenshell
+        run: |
+          mkdir build && cd build
+          cmake \
+               -DCMAKE_C_COMPILER_LAUNCHER=ccache \
+               -DCMAKE_CXX_COMPILER_LAUNCHER=ccache \
+               -DCMAKE_BUILD_TYPE=Release \
+               -DCMAKE_PREFIX_PATH=/usr \
+               -DCMAKE_SYSTEM_PREFIX_PATH=/usr \
+               -DOCC_INCLUDE_DIR=/usr/include/opencascade \
+               -DOCC_LIBRARY_DIR=/usr/lib/x86_64-linux-gnu \
+               -DPYTHON_EXECUTABLE:FILEPATH=/usr/bin/python3 \
+               -DPYTHON_INCLUDE_DIR:PATH=/usr/include/python3.8 \
+               -DPYTHON_LIBRARY:FILEPATH=/usr/lib/x86_64-linux-gnu/libpython3.8.so \
+               -DCOLLADA_SUPPORT=Off \
+               "-DSCHEMA_VERSIONS=2x3;4" \
+               -DBUILD_CONVERT=Off \
+               -DGLTF_SUPPORT=On \
+               -DJSON_INCLUDE_DIR=/usr/include \
+               -DCGAL_INCLUDE_DIR=/usr/include \
+               -DGMP_INCLUDE_DIR=/usr/include \
+               -DMPFR_INCLUDE_DIR=/usr/include \
+               -DGMP_LIBRARY_DIR=/usr/lib/x86_64-linux-gnu \
+               -DMPFR_LIBRARY_DIR=/usr/lib/x86_64-linux-gnu \
+               -DHDF5_INCLUDE_DIR=/usr/include/hdf5/serial \
+             ../cmake
+          sudo make -j $(nproc)
+          sudo make install
+
+      - name: Install Python dependencies
+        run: |
+          sudo /usr/bin/python -m pip install -U pip
+          sudo /usr/bin/python -m pip install xmlschema numpy lxml
+          sudo /usr/bin/python -m pip install src/bcf
+          sudo /usr/bin/python -m pip install pytest
+          sudo /usr/bin/python -m pip install isodate
+          sudo /usr/bin/python -m pip install lark
+          sudo /usr/bin/python -m pip install networkx
+
+      - name: Test
+        run: |
+          cd test
+          sudo /usr/bin/python tests.py
+          cd ../src/ifcopenshell-python
+          mv ifcopenshell ifcopenshell-local # Force testing on installed module
+          make test

.github/workflows/ci.yml

@@ -3,8 +3,19 @@ name: ci
 on:
   push:
     paths:
-      - 'src/**'
-      - 'test/**'
+      - 'src/ifcblender/**'
+      - 'src/ifcconvert/**'
+      - 'src/ifcgeom/**'
+      - 'src/ifcgeom_schema_agnostic/**'
+      - 'src/ifcgeomserver/**'
+      - 'src/ifcjni/**'
+      - 'src/ifcmax/**'
+      - 'src/ifcopenshell-python/**'
+      - '!src/ifcopenshell-python/docs/**'
+      - 'src/ifcparse/**'
+      - 'src/ifcwrap/**'
+      - 'src/qtviewer/**'
+      - 'src/serializers/**'
       - 'conda/**'
       - 'cmake/**'
       - '.github/workflows/ci.yml'
@@ -62,7 +73,7 @@ jobs:
                -DPYTHON_INCLUDE_DIR:PATH=/usr/include/python3.8 \
                -DPYTHON_LIBRARY:FILEPATH=/usr/lib/x86_64-linux-gnu/libpython3.8.so \
                -DCOLLADA_SUPPORT=Off \
-               "-DSCHEMA_VERSIONS=2x3;4" \
+               "-DSCHEMA_VERSIONS=2x3;4;4x3" \
                -DGLTF_SUPPORT=On \
                -DJSON_INCLUDE_DIR=/usr/include \
                -DCGAL_INCLUDE_DIR=/usr/include \

.github/workflows/release.yml

@@ -19,13 +19,23 @@ jobs:
         uses: actions/checkout@v2
         with:
           submodules: recursive
-      - 
-        name: Update ubuntu
+      - name: Install C++ dependencies
         run: |
           sudo apt update
-          sudo apt-get install git cmake gcc g++ libboost1.67-all-dev python3-all-dev swig libpcre3-dev libxml2-dev
-          sudo apt-get install libocct-foundation-dev libocct-modeling-algorithms-dev libocct-modeling-data-dev libocct-ocaf-dev libocct-visualization-dev libocct-data-exchange-dev \
-          libhdf5-dev libcgal-dev
+          sudo apt-get install --no-install-recommends \
+          git cmake gcc g++ \
+          libboost-date-time-dev \
+          libboost-filesystem-dev \
+          libboost-iostreams-dev \
+          libboost-program-options-dev \
+          libboost-regex-dev \
+          libboost-system-dev \
+          libboost-thread-dev \
+          python3-all-dev python3-pip \
+          swig libpcre3-dev libxml2-dev \
+          libtbb-dev nlohmann-json3-dev \
+          libocct-foundation-dev libocct-modeling-algorithms-dev libocct-modeling-data-dev libocct-ocaf-dev libocct-visualization-dev libocct-data-exchange-dev \
+          libhdf5-dev libcgal-dev opencollada-dev
           
       - name: Build
         env:
@@ -44,10 +54,18 @@ jobs:
            -DPYTHON_EXECUTABLE:FILEPATH=/usr/bin/python3 \
            -DPYTHON_INCLUDE_DIR:PATH=/usr/include/python3.8 \
            -DPYTHON_LIBRARY:FILEPATH=/usr/lib/x86_64-linux-gnu/libpython3.8.so \
-           -DCOLLADA_SUPPORT=Off \
            -DLIBXML2_INCLUDE_DIR=/usr/include/libxml2 \
            -DLIBXML2_LIBRARIES=/usr/lib/x86_64-linux-gnu/libxml2.so \
+           -DGLTF_SUPPORT=On \
+           -DJSON_INCLUDE_DIR=/usr/include \
+           -DCGAL_INCLUDE_DIR=/usr/include \
+           -DGMP_INCLUDE_DIR=/usr/include \
+           -DMPFR_INCLUDE_DIR=/usr/include \
+           -DGMP_LIBRARY_DIR=/usr/lib/x86_64-linux-gnu \
+           -DMPFR_LIBRARY_DIR=/usr/lib/x86_64-linux-gnu \
            -DHDF5_INCLUDE_DIR=/usr/include/hdf5/serial \
+           -DOPENCOLLADA_INCLUDE_DIR=/usr/include/opencollada \
+           -DOPENCOLLADA_LIBRARY_DIR=/usr/lib/opencollada/ \
            ../cmake
           make -j $(nproc)
           make install

.gitignore

@@ -67,3 +67,9 @@ htmlcov
 
 # Blender
 *.blend1
+
+# Sphinx
+_build/
+
+# IDS Docs
+src/ifcopenshell-python/test/build

.gitmodules

@@ -8,9 +8,6 @@
 [submodule "src/svgfill"]
 	path = src/svgfill
 	url = https://github.com/IfcOpenShell/svgfill
-[submodule "src/ifcopenshell-python/ifcopenshell/Sample-BIM-Files"]
-	path = src/ifcopenshell-python/ifcopenshell/Sample-BIM-Files
-	url = https://github.com/atomczak/Sample-BIM-Files
 [submodule "src/ifcopenshell-python/test/Sample-BIM-Files"]
 	path = src/ifcopenshell-python/test/Sample-BIM-Files
-	url = https://github.com/atomczak/Sample-BIM-Files
+	url = https://github.com/IfcOpenShell/ids-test-files

Dockerfile

@@ -23,9 +23,11 @@ RUN echo "deb http://archive.ubuntu.com/ubuntu focal-proposed main restricted" |
     echo "deb http://archive.ubuntu.com/ubuntu focal-proposed multiverse" |  tee -a /etc/apt/sources.list; \
     apt-get -qq update; \
     apt-get -y install tzdata dos2unix rsync; \
-    apt-get -y install python3 libxml2 liboce-foundation11 liboce-modeling11 liboce-ocaf11 liboce-visualization11 \
-                     liboce-ocaf-lite11 libpython3.8 libboost-system1.67.0 libboost-program-options1.67.0 \
-                    libboost-regex1.67.0 libboost-thread1.67.0 libboost-date-time1.67.0; \
+    apt-get -y install python3 libxml2 libpython3.8 \
+                    libboost-all-dev \
+                    libocct-foundation-dev libocct-modeling-algorithms-dev libocct-modeling-data-dev \
+                    libocct-ocaf-dev libocct-visualization-dev libocct-data-exchange-dev \
+                    libhdf5-serial-dev ; \
     rm -rf /var/lib/apt/lists/* ; 
 
 COPY . /home/IfcOpenShell/

README.md

@@ -1,305 +1,73 @@
+
 IfcOpenShell 
 ============
-IfcOpenShell is an open source ([LGPL]) software library for working with the Industry Foundation Classes ([IFC]) 
-file format. Extensive geometric support is implemented for the IFC releases [IFC2x3 TC1] and [IFC4 Add2 TC1].
-Support for parsing is provided for IFC4x1, IFC4x2, and the IFC4x3 release candidates. Extending with support for
-arbitrary IFC schemas is possible at compile-time when using C++ and at run-time when using Python.
 
-For more information, see
-* [http://ifcopenshell.org](http://ifcopenshell.org)  
-* [http://academy.ifcopenshell.org](http://academy.ifcopenshell.org)
+IfcOpenShell is an open source ([LGPL]) software library for working with Industry Foundation Classes ([IFC]). Complete
+parsing support is provided for [IFC2x3 TC1], [IFC4 Add2 TC1], IFC4x1, IFC4x3, and IFC4x3. Extensive geometric support
+is implemented for the IFC releases [IFC2x3 TC1] and [IFC4 Add2 TC1]. Extending with support for arbitrary IFC schemas
+is possible at compile-time when using C++ and at run-time when using Python.
 
-[![Build Status](https://travis-ci.org/IfcOpenShell/IfcOpenShell.svg?branch=v0.6.0)](https://travis-ci.org/IfcOpenShell/IfcOpenShell)
+In addition to a C++ and Python API, IfcOpenShell comes with an ecosystem of tools, notably including IfcConvert (an application to convert IFC models to
+other formats), the BlenderBIM Add-on (an add-on to Blender providing a graphical IFC authoring platform), and many
+other libraries, CLI apps, and more. Support is also provided for auxiliary standards such as BCF and IDS.
 
-Prerequisites
--------------
-* Git
-* CMake (2.6 or newer)
-* Windows: [Visual Studio] 2008 to 2019 (2022 not yet supported by dependency CMake) with C++ toolset (or [Visual C++ Build Tools]) or [MSYS2] + MinGW
-* *nix: GCC 4.7 or newer, or Clang (any version)
+For more information, see:
 
-Dependencies
--------------
-* [Boost](http://www.boost.org/)
-* [Open Cascade](https://dev.opencascade.org/) - *optional*, but required for building IfcGeom
-  ([official](https://dev.opencascade.org/release), "OCCT", or [community edition](https://github.com/tpaviot/oce), "OCE")  
-  For converting IFC representation items into BRep solids and tesselated meshes
-* [OpenCOLLADA](https://github.com/khronosGroup/OpenCOLLADA/) - *optional*  
-  For IfcConvert to be able to write tessellated Collada (.dae) files
-* [SWIG](http://www.swig.org/) and [Python](https://www.python.org/) - *optional*  
-  For building the IfcOpenShell Python interface and the Blender add-on
-* [3ds Max SDK](http://www.autodesk.com/products/3ds-max/free-trial) - *optional*  
-  For building the 3ds Max plug-in.
-  All recent versions of 3ds Max (2014 and newer) are 64-bit only, so a 64-bit installation is assumed.
+* [IfcOpenShell Website](http://ifcopenshell.org)
+* [IfcOpenShell Documentation](http://blenderbim.org/docs-python)
+  * [IfcOpenShell C++ Installation](https://blenderbim.org/docs-python/ifcopenshell/installation.html)
+  * [IfcOpenShell Python Installation](https://blenderbim.org/docs-python/ifcopenshell-python/installation.html)
+  * [IfcOpenShell Python Hello World Tutorial](https://blenderbim.org/docs-python/ifcopenshell-python/hello_world.html)
+* [BlenderBIM Add-on Website](https://blenderbim.org)
+* [BlenderBIM Add-on Documentation](http://blenderbim.org/docs)
+  * [Add-on Installation](https://blenderbim.org/docs/users/installation.html)
+  * [Exploring an IFC model](https://blenderbim.org/docs/users/exploring_an_ifc_model.html)
 
-Building IfcOpenShell
----------------------
+| Service                                         | Status                                                                                                                                       |
+| ----------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------- |
+| Anaconda Daily Build                            | [![Anaconda-Server Badge](https://img.shields.io/conda/vn/ifcopenshell/ifcopenshell)](https://anaconda.org/ifcopenshell/ifcopenshell)        |
+| Anaconda v0.7.0 Stable                          | [![Anaconda-Server Badge](https://img.shields.io/conda/vn/conda-forge/ifcopenshell)](https://anaconda.org/conda-forge/ifcopenshell)          |
+| PyPi Daily Build                                | [![PyPi Badge](https://img.shields.io/pypi/v/ifcopenshell)](https://pypi.org/project/ifcopenshell/)                                          |
+| ArchLinux AUR Package                           | [![AUR Badge](https://img.shields.io/aur/version/ifcopenshell-git)](https://aur.archlinux.org/packages/ifcopenshell-git)                     |
+| BlenderBIM Add-on Chocolatey (under moderation) | [![Chocolatey Badge](https://img.shields.io/chocolatey/v/blenderbim-nightly)](https://community.chocolatey.org/packages/blenderbim-nightly/) |
+| Sponsor development on OpenCollective           | [![Financial Contributors](https://opencollective.com/opensourcebim/tiers/badge.svg)](https://opencollective.com/opensourcebim/)             |
+| Docker hub                                      | [![Docker Pulls](https://img.shields.io/docker/pulls/aecgeeks/ifcopenshell)](https://hub.docker.com/r/aecgeeks/ifcopenshell)                 |
 
-Note 1: The path where the source code is cloned to can contain spaces but non-ASCII characters are very likely to cause problems with the build.
-
-Note 2: If you had not used `git clone --recursive https://github.com/IfcOpenShell/IfcOpenshell.git`, update the submodules by running `git submodule init & git submodule update`.
-
-Note 3: Be careful with special characters is the path when using the nix or win build scripts, because the OpenCASCADE build will fail on paths containing ++ and likely other situations.
-
-### Compiling on Windows
-The preferred way to fetch and build this project's dependencies is to use the build scripts
-in win/ folder. **See [win/readme.md] for more information**.
-
-#### Using Visual Studio
-Instructions in a nutshell (**assuming Visual Studio 2015 x64 environment variables set**):
-
-    > cd IfcOpenShell\win
-    > build-deps.cmd
-    > run-cmake.bat
-
-NB: `build-deps.cmd` need to be ran from the directory containing it, i.e. the `./win` folder.
-
-You can now open and build the solution file in Visual Studio:
-
-    > ..\build-vs2015-x64\IfcOpenShell.sln
-
-As the scripts default to using the `RelWithDebInfo` configuration, and a freshly created solution by CMake defaults
-to `Debug`, make sure to switch the used build configuration. Build the `INSTALL` project (right-click -> Project
-Only) to deploy the headers and binaries into a single location if wanted/needed.
-
-Alternatively, one can use the utility batch file(s) to build and install the project easily from the command-line
-(installing a project will build it also, if required):
-
-    > install-ifcopenshell.bat
-
-#### Using MSYS2 + MinGW
-
-Start the MSYS2 Shell and then:
-
-    $ cd IfcOpenShell/win
-    $ ./build-deps.sh
-    $ ./run-cmake.sh
-    $ ./install-ifcopenshell.sh
-
-#### Using Bash on Ubuntu on Windows
-
-Start Bash on Ubuntu on Windows and follow the instructions below. Compiling on Ubuntu 14.04.4 LTS using GCC 4.8.4
-or Clang 3.5 has been confirmed to work.
-
-### Compiling on *nix
-
-The following instructions are for Ubuntu, modify as required for other operating systems. [nix/build-all.py] script
-can be experimented with and studied for pointers for other operating systems, but note that this script is not currently
-meant to be used for a typical IfcOpenShell workspace setup.
-
-Note 1: It is recommeded to use OCCT for IfcOpenShell. You could use OCE as well, but sometimes it may lag behind OCCT and 
-therefore not compile with the latest IfcOpenShell.
-
-Note 2: where `make -j` is written, add a number roughly equal to the amount of CPU cores + 1.
-
-**1)** Install most of the prerequisites and dependencies:
-
-    $ sudo apt-get install git cmake gcc g++ libboost-all-dev libcgal-dev
-
-**2a)** Either use an OCCT package from your operating system's software repository
-
-    $ sudo apt-get install libocct-data-exchange-dev libocct-draw-dev libocct-foundation-dev libocct-modeling-algorithms-dev libocct-modeling-data-dev libocct-ocaf-dev libocct-visualization-dev
-
-**2b)** or, if OCCT is not available or the latest code is wanted, obtain and compile OCCT from https://dev.opencascade.org/release
-
-**2c)** or, if you'd like to try using OCE, use the package from your operating system's software repository
-
-    $ sudo apt-get install liboce-foundation-dev liboce-modeling-dev liboce-ocaf-dev liboce-visualization-dev liboce-ocaf-lite-dev
-
-**2d)** or if OCE is not available, or the latest code is wanted, compile OCE yourself (note that the build takes a long time)
-
-    $ sudo apt-get install libftgl-dev libtbb2 libtbb-dev libgl1-mesa-dev libfreetype6-dev
-    $ git clone https://github.com/tpaviot/oce.git
-    $ cd oce
-    $ mkdir build && cd build
-    $ cmake ..
-    $ make -j
-    $ sudo make install
-
-**3)** For building IfcConvert with COLLADA (.dae) support (on by default), OpenCOLLADA is needed:
-
-    $ sudo apt-get install libpcre3-dev libxml2-dev
-    $ git clone https://github.com/KhronosGroup/OpenCOLLADA.git
-    $ cd OpenCOLLADA
-    Using a known good revision, but HEAD should work too:
-    $ git checkout 064a60b65c2c31b94f013820856bc84fb1937cc6
-    $ mkdir build && cd build
-    $ cmake ..
-    $ make -j
-    $ sudo make install
-
-**4)** For building the IfcPython wrapper (on by default), SWIG and Python development are needed, if not already available:
-
-    $ sudo apt-get install python-all-dev swig
-
-**5)** To build IfcOpenShell please take the following steps. Alternatively use environment variables for setting the
-dependencies' paths. `OCC_INCLUDE_DIR` might be needed to set also. `OPENCOLLADA_INCLUDE_DIR` and `OPENCOLLADA_LIBRARY_DIR`
-(and potentially `PCRE_LIBRARY_DIR`) are needed if building with COLLADA support. (`-DCOLLADA_SUPPORT=0` disables it).
-
-    $ cd /path/to/IfcOpenShell
-    $ mkdir build && cd build
-    $ cmake ../cmake -DOCC_LIBRARY_DIR=/usr/lib/x86_64-linux-gnu/ \
-          -DOPENCOLLADA_INCLUDE_DIR="/usr/local/include/opencollada" \
-          -DOPENCOLLADA_LIBRARY_DIR="/usr/local/lib/opencollada"  \
-          -DPCRE_LIBRARY_DIR=/usr/lib/x86_64-linux-gnu/ \
-          -DCGAL_INCLUDE_DIR=/usr/include \
-          -DGMP_INCLUDE_DIR=/usr/include \
-          -DMPFR_INCLUDE_DIR=/usr/include \
-          -DGMP_LIBRARY_DIR=/usr/lib/x86_64-linux-gnu \
-          -DMPFR_LIBRARY_DIR=/usr/lib/x86_64-linux-gnu \
-          -DHDF5_SUPPORT=Off
-    $ make -j
-
-If all worked out correctly you can now use IfcOpenShell. See the examples below.
-
-**6)** Install the project if wanted:
-
-    $ sudo make install
-    
-### Installing on MacOS Using Homebrew
-
-**1)** Install all dependencies using [Homebrew](https://brew.sh/)
-
-```{shell}
-$ brew install boost swig cmake ftgl cgal gmp libaec opencascade
-```
-
-**2)** Clone the git repo and its submodules
-```{shell}
-$ git clone --recurse-submodules https://github.com/IfcOpenShell/IfcOpenShell.git 
-```
-**3)** Build IfcOpenShell with flags for Homebrew dependencies (```/usr/local/```)
-```{shell}
-$ cd /path/to/IfcOpenShell
-$ mkdir build && cd build
-$ cmake ../cmake -DOCC_LIBRARY_DIR=/usr/local/lib/ \
-      -DOCC_INCLUDE_DIR=/usr/local/include/opencascade/ \
-      -DCOLLADA_SUPPORT=0 \
-      -DCGAL_INCLUDE_DIR=/usr/local/include/ \
-      -DGMP_LIBRARY_DIR=/usr/local/lib/ \
-      -DMPFR_LIBRARY_DIR=/usr/local/lib/
-      
-$ make -j -lboost_options
-```
-
-Note: Make sure to compile using XCode, rather than a ```brew``` installed C/C++ compiler.
-
-Installing IfcOpenShell with Conda
-----------------------------------
-Another option for building and installing IfcOpenShell is to use the popular
-[Anaconda Python Distribution](https://www.anaconda.com/download).
-The requirements are spread across a number of channels.
-You can add these channels to your configuration, or specify them all on the command line:
-
-    $ conda install -c conda-forge -c oce -c dlr-sc -c ifcopenshell ifcopenshell
-
-Usage examples
---------------
-
-**Invoking IfcConvert from the command line**
-
-    $ wget -O duplex.zip https://portal.nibs.org/files/wl/\?id=4DsTgHFQAcOXzFetxbpRCECPbbfUqpgo
-    $ unzip duplex.zip
-    $ ./IfcConvert Duplex_A_20110907_optimized.ifc
-    $ less Duplex_A_20110907_optimized.obj
-
-**Using the IfcOpenShell Python interface**
-
-    $ wget -O duplex.zip https://portal.nibs.org/files/wl/\?id=4DsTgHFQAcOXzFetxbpRCECPbbfUqpgo
-    $ unzip duplex.zip
-    $ python
-    >>> import ifcopenshell
-    >>> f = ifcopenshell.open("Duplex_A_20110907_optimized.ifc")
-    >>>
-    >>> # Accessing entity instances by type:
-    >>> f.by_type("ifcwall")[:2]
-    [#91=IfcWallStandardCase('2O2Fr$t4X7Zf8NOew3FL9r',#1,'Basic Wall:Interior - Partition (92mm Stud):144586',$,'Basic Wall:Interior - Partition (92mm Stud):128360',#5198,#18806,'144586'), #92=IfcWallStandardCase('2O2Fr$t4X7Zf8NOew3FLIE',#1,'Basic Wall:Interior - Partition (92mm Stud):143921',$,'Basic Wall:Interior - Partition (92mm Stud):128360',#5206,#18805,'143921')]
-    >>> wall = _[0]
-    >>> len(wall) # number of EXPRESS attributes
-    8
-    >>>
-    >>> # Accessing EXPRESS attributes by name:
-    >>> wall.GlobalId 
-    '2O2Fr$t4X7Zf8NOew3FL9r'
-    >>> wall.Name = "My wall"
-    >>> wall.NonExistingAttr
-    Traceback (most recent call last):
-      File "<stdin>", line 1, in <module>
-      File ".\ifcopenshell.py", line 14, in __getattr__
-        except: raise AttributeError("entity instance of type '%s' has no attribute'%s'"%(self.wrapped_data.is_a(), name)) from None
-    AttributeError: entity instance of type 'IfcWallStandardCase' has no attribute 'NonExistingAttr'
-    >>> wall.GlobalId = 3
-    Traceback (most recent call last):
-      File "<stdin>", line 1, in <module>
-      File ".\ifcopenshell.py", line 26, in __setattr__
-        self[self.wrapped_data.get_argument_index(key)] = value
-      File ".\ifcopenshell.py", line 30, in __setitem__
-        self.wrapped_data.set_argument(idx, entity_instance.map_value(value))
-      File ".\ifc_wrapper.py", line 118, in <lambda>
-        set_argument = lambda self,x,y: self._set_argument(x) if y is None else self
-    ._set_argument(x,y)
-      File ".\ifc_wrapper.py", line 114, in _set_argument
-        def _set_argument(self, *args): return _ifc_wrapper.entity_instance__set_argument(self, *args)
-    RuntimeError: INT is not a valid type for 'GlobalId'
-    >>> # Creating new entity instances
-    >>> f.createIfcCartesianPoint(Coordinates=(1.0,1.5,2.0))
-    #27530=IfcCartesianPoint((1.,1.5,2.))
-    >>> 
-    >>> # Working with GlobalId attributes:
-    >>> import uuid
-    >>> ifcopenshell.guid.compress(uuid.uuid1().hex)
-    '3x4C8Q_6qHuv$P$FYkANRX'
-    >>> new_guid = _
-    >>> owner_hist = f.by_type("IfcOwnerHistory")[0]
-    >>> new_wall = f.createIfcWallStandardCase(new_guid, owner_hist, None, None, Tag='my_tag')
-    >>> new_wall.ObjectType = ''
-    >>> new_wall.ObjectPlacement = new_wall.Representation = None
-    >>>
-    >>> # Accessing entity instances by instance id or GlobalId:
-    >>> f[92]
-    #92=IfcWallStandardCase('2O2Fr$t4X7Zf8NOew3FLIE',#1,'Basic Wall:Interior - Partition (92mm Stud):143921',$,'Basic Wall:Interior - Partition (92mm Stud):128360',#5206,#18805,'143921')
-    >>> f['2O2Fr$t4X7Zf8NOew3FLIE']
-    #92=IfcWallStandardCase('2O2Fr$t4X7Zf8NOew3FLIE',#1,'Basic Wall:Interior - Partition (92mm Stud):143921',$,'Basic Wall:Interior - Partition (92mm Stud):128360',#5206,#18805,'143921')
-    >>>
-    >>> # Writing IFC-SPF files to disk:
-    >>> f.write("out.ifc")
-
-Extra tools
------------
-
-Also available are a series of utilities that are based on or related to IfcOpenShell.
+Contents
+--------
 
 Those marked with an asterisk are part of IfcOpenShell.
 
-Name | License
---- | ---
-bcf | LGPL-3.0-or-later
-blenderbim | GPL-3.0-or-later
-bsdd | LGPL-3.0-or-later
-ifc2ca | LGPL-3.0-or-later
-ifc4d | LGPL-3.0-or-later
-ifc5d | LGPL-3.0-or-later
-ifcbimtester | LGPL-3.0-or-later
-ifcblender | LGPL-3.0-or-later\*
-ifccityjson | LGPL-3.0-or-later
-ifcclash | LGPL-3.0-or-later
-ifccobie | LGPL-3.0-or-later
-ifcconvert | LGPL-3.0-or-later\*
-ifccsv | LGPL-3.0-or-later
-ifcdiff | LGPL-3.0-or-later
-ifcfm | LGPL-3.0-or-later
-ifcgeom | LGPL-3.0-or-later\*
-ifcgeom\_schema\_agnostic | LGPL-3.0-or-later\*
-ifcgeomserver | LGPL-3.0-or-later\*
-ifcjni | LGPL-3.0-or-later\*
-ifcmax | LGPL-3.0-or-later\*
-ifcopenshell-python | LGPL-3.0-or-later\*
-ifcparse | LGPL-3.0-or-later\*
-ifcpatch | LGPL-3.0-or-later
-ifcsverchok | GPL-3.0-or-later
-ifcwrap | LGPL-3.0-or-later\*
-qtviewer | LGPL-3.0-or-later\*
-serializers | LGPL-3.0-or-later\*
+| Name                      | Description                                                           | License             |
+| ------------------------- | ----------------------------------------------------------------------| ------------------- |
+| bcf                       | Library to read and write BCF-XML and query OpenCDE BCF-API modules   | LGPL-3.0-or-later   |
+| blenderbim                | Add-on to Blender providing a graphical native IFC authoring platform | GPL-3.0-or-later    |
+| bsdd                      | Library to query the bSDD API                                         | LGPL-3.0-or-later   |
+| ifc2ca                    | Utility to convert IFC structural analysis models to Code_Aster       | LGPL-3.0-or-later   |
+| ifc4d                     | Convert to and from IFC and project management software               | LGPL-3.0-or-later   |
+| ifc5d                     | Report and optimise cost information from IFC                         | LGPL-3.0-or-later   |
+| ifcbimtester              | Wrapper for Gherkin based unit testing for IFC models                 | LGPL-3.0-or-later   |
+| ifcblender                | Historic Blender IFC import add-on                                    | LGPL-3.0-or-later\* |
+| ifccityjson               | Convert CityJSON to IFC                                               | LGPL-3.0-or-later   |
+| ifcclash                  | Clash detection library and CLI app                                   | LGPL-3.0-or-later   |
+| ifccobie                  | Extract IFC data for COBie handover requirements                      | LGPL-3.0-or-later   |
+| ifcconvert                | CLI app to convert IFC to many other formats                          | LGPL-3.0-or-later\* |
+| ifccsv                    | Library and CLI app to export and import schedules from IFC           | LGPL-3.0-or-later   |
+| ifcdiff                   | Compare changes between IFC models                                    | LGPL-3.0-or-later   |
+| ifcfm                     | Extract IFC data for FM handover requirements                         | LGPL-3.0-or-later   |
+| ifcgeom                   | Internal library for IfcOpenShell                                     | LGPL-3.0-or-later\* |
+| ifcgeom\_schema\_agnostic | Internal library for IfcOpenShell                                     | LGPL-3.0-or-later\* |
+| ifcgeomserver             | Internal library for IfcOpenShell                                     | LGPL-3.0-or-later\* |
+| ifcjni                    | Internal library for IfcOpenShell                                     | LGPL-3.0-or-later\* |
+| ifcmax                    | Historic extension for IFC support in 3DS Max                         | LGPL-3.0-or-later\* |
+| ifcopenshell-python       | Python library for IFC manipulation                                   | LGPL-3.0-or-later\* |
+| ifcparse                  | Internal library for IfcOpenShell                                     | LGPL-3.0-or-later\* |
+| ifcpatch                  | Utility to run pre-packaged scripts to manipulate IFCs                | LGPL-3.0-or-later   |
+| ifcsverchok               | Blender Add-on for visual node programming with IFC                   | GPL-3.0-or-later    |
+| ifctester                 | Library, CLI and webapp for IDS model auditing                        | LGPL-3.0-or-later   |
+| ifcwrap                   | Internal library for IfcOpenShell                                     | LGPL-3.0-or-later\* |
+| qtviewer                  | Internal library for IfcOpenShell                                     | LGPL-3.0-or-later\* |
+| serializers               | Internal library for IfcOpenShell                                     | LGPL-3.0-or-later\* |
 
 [LGPL]: https://github.com/IfcOpenShell/IfcOpenShell/tree/master/COPYING.LESSER "LGPL-3.0-or-later"
 [IFC]: https://technical.buildingsmart.org/standards/ifc/ "IFC"

choco/blenderbim/blenderbim.nuspec

@@ -0,0 +1,34 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Do not remove this test for UTF-8: if “Ω” doesn’t appear as greek uppercase omega letter enclosed in quotation marks, you should use an editor that supports UTF-8, not this one. -->
+<package xmlns="http://schemas.microsoft.com/packaging/2015/06/nuspec.xsd">
+  <metadata>
+    <id>blenderbim-nightly</id>
+    <version>blenderbim_build_version-alpha</version>
+    <packageSourceUrl>https://github.com/IfcOpenShell/IfcOpenShell</packageSourceUrl>
+    <owners>fbpyr</owners>
+    <!-- == SOFTWARE SPECIFIC SECTION == -->
+    <title>BlenderBIM install nightly</title>
+    <authors>Dion Moult and many more, see: https://github.com/IfcOpenShell/IfcOpenShell/graphs/contributors</authors>
+    <projectUrl>https://github.com/IfcOpenShell/IfcOpenShell</projectUrl>
+    <iconUrl>https://rawcdn.githack.com/IfcOpenShell/IfcOpenShell/c6ee1d1679d1298de0d7447ff108c22709c68e54/choco/blenderbim/blenderbim.png</iconUrl>
+    <!-- <copyright>Year Software Vendor</copyright> -->
+    <licenseUrl>https://github.com/IfcOpenShell/IfcOpenShell/blob/v0.7.0/COPYING</licenseUrl>
+    <requireLicenseAcceptance>true</requireLicenseAcceptance>
+    <projectSourceUrl>https://github.com/IfcOpenShell/IfcOpenShell</projectSourceUrl>
+    <docsUrl>https://blenderbim.org/docs/</docsUrl>
+    <!--<mailingListUrl></mailingListUrl>-->
+    <bugTrackerUrl>https://github.com/IfcOpenShell/IfcOpenShell/issues</bugTrackerUrl>
+    <tags>blender bim blenderbim ifc python opensource foss</tags>
+    <summary>opensource bim</summary>
+    <description>opensource bim addon for blender - source code at: https://github.com/IfcOpenShell/IfcOpenShell</description>
+    <!-- <releaseNotes>__REPLACE_OR_REMOVE__MarkDown_Okay</releaseNotes> -->
+
+    <dependencies>
+      <dependency id="blender" version="latest_blender_version_maj_min_pat" />
+      <dependency id="7zip"    version="22.1"/>
+    </dependencies>
+  </metadata>
+  <files>
+    <file src="tools\**" target="tools" />
+  </files>
+</package>

choco/blenderbim/check_repo_infos.py

@@ -0,0 +1,80 @@
+import datetime
+import re
+import sys
+from urllib import request
+
+
+def request_repo_info(url: str):
+    req  = request.Request(url)
+    resp = request.urlopen(req)
+    if not resp.status == 200:
+        print(f"[ERROR] could not contact server: {url}")
+        quit(1)
+    return resp
+
+
+if sys.argv[1] == "--do_choco_release?":
+    now = datetime.datetime.now()
+    blenderbim_date = (now - datetime.timedelta(days=1)).strftime("%y%m%d")
+    url = "https://github.com/IfcOpenShell/IfcOpenShell/releases"
+    resp = request_repo_info(url)
+    text = str(resp.read())
+    if blenderbim_date in text:
+        print("do_choco_release", end="")
+
+
+elif sys.argv[1] == "--latest_blender_release_maj_min_pat?":
+    re_blender_version_min_maj_pat = r"Latest Version.+<span>Blender (\d+\.\d+\.\d+)</span>"
+    url = "https://community.chocolatey.org/packages/blender"
+    resp = request_repo_info(url)
+    html_txt = str(resp.read())
+    found = re.findall(re_blender_version_min_maj_pat, html_txt)
+    if found:
+        print(found[0], end="")
+
+
+elif sys.argv[1] == "--latest_blender_release_maj_min?":
+    re_blender_version_min_maj = r"Latest Version.+<span>Blender (\d+\.\d+)\..+</span>"
+    url = "https://community.chocolatey.org/packages/blender"
+    resp = request_repo_info(url)
+    html_txt = str(resp.read())
+    found = re.findall(re_blender_version_min_maj, html_txt)
+    if found:
+        print(found[0], end="")
+
+
+elif sys.argv[1] == "--latest_blender_python_version_maj_min?":
+    # get latest blender version first
+    re_blender_version_min_maj_pat = r"Latest Version.+<span>Blender (\d+\.\d+\.\d+)</span>"
+    url = "https://community.chocolatey.org/packages/blender"
+    resp = request_repo_info(url)
+    html_txt = str(resp.read())
+    found = re.findall(re_blender_version_min_maj_pat, html_txt)
+    if found:
+        latest_blender_version_tag = f"v{found[0]}"
+        re_blender_python_version_maj_min = r"SET\(PYTHON_VERSION (\d+.\d+) "
+        url = f"https://raw.githubusercontent.com/blender/blender/{latest_blender_version_tag}/build_files/cmake/Modules/FindPythonLibsUnix.cmake"
+        resp = request_repo_info(url)
+        html_txt = str(resp.read())
+        found = re.findall(re_blender_python_version_maj_min, html_txt)
+        if found:
+            print(found[0], end="")
+
+
+elif sys.argv[1] == "--pyver?":
+    # get latest blender version first
+    re_blender_version_min_maj_pat = r"Latest Version.+<span>Blender (\d+\.\d+\.\d+)</span>"
+    url = "https://community.chocolatey.org/packages/blender"
+    resp = request_repo_info(url)
+    html_txt = str(resp.read())
+    found = re.findall(re_blender_version_min_maj_pat, html_txt)
+    if found:
+        latest_blender_version_tag = f"v{found[0]}"
+        re_blender_python_version_maj_min = r"SET\(PYTHON_VERSION (\d+.\d+) "
+        url = f"https://raw.githubusercontent.com/blender/blender/{latest_blender_version_tag}/build_files/cmake/Modules/FindPythonLibsUnix.cmake"
+        resp = request_repo_info(url)
+        html_txt = str(resp.read())
+        found = re.findall(re_blender_python_version_maj_min, html_txt)
+        if found:
+            print(f"py{found[0].replace('.', '')}", end="")
+

choco/blenderbim/fill_dynamic_parameters.py

@@ -0,0 +1,49 @@
+import os
+from pathlib import Path
+
+
+print("[INFO] inserting dynamic chocolatey package parameters")
+HERE_DIR = Path(__file__).parent.absolute()
+# print(f"[INFO] HERE_DIR: {HERE_DIR}")
+
+topics = {
+    "spec": {
+        "path": HERE_DIR / "blenderbim.nuspec",
+        "env_vars": {
+            "latest_blender_version_maj_min_pat",
+            "blenderbim_build_version",
+        },
+    },
+    "install": {
+        "path": HERE_DIR / "tools" / "chocolateyinstall.ps1",
+        "env_vars": {
+            "url_blenderbim_py310_win_zip",
+            "sha256sum_blenderbim_py310_win_zip",
+            "latest_blender_version_maj_min",
+        },
+    },
+    "uninstall": {
+        "path": HERE_DIR / "tools" / "chocolateyuninstall.ps1",
+        "env_vars": {
+            "latest_blender_version_maj_min",
+        },
+    },
+}
+
+for topic, info in topics.items():
+    print(f"[INFO] {topic}:")
+    for env_var_name in info["env_vars"]:
+        print(f"[INFO] {env_var_name} exists?: {os.environ[env_var_name]}")
+
+    with open(info["path"], encoding="utf-8") as txt:
+        content = txt.read()
+
+    for env_var_name in info["env_vars"]:
+        # print(f"[INFO] replace: {env_var_name}")
+        content = content.replace(env_var_name, os.environ[env_var_name])
+
+    with open(info["path"], "w", encoding="utf-8") as txt:
+        txt.write(content)
+        print(f"[INFO] written: {info['path']}")
+
+print("[INFO] inserting dynamic chocolatey package parameters successful")

choco/blenderbim/tools/chocolateybeforemodify.ps1

@@ -0,0 +1,11 @@
+$processName      = "blender"
+$blenderIsRunning = Get-Process -Name $processName -ErrorAction SilentlyContinue
+
+if($blenderIsRunning -eq $null) {
+    echo "Blender is not running ready for next action."
+}
+else {
+    Write-Warning "$processName is still running - installer cannot safely proceed to next action."
+    Write-Warning "Please retry after closing all running blender applications."
+    exit 1
+}

choco/blenderbim/tools/chocolateyinstall.ps1

@@ -0,0 +1,29 @@
+$ErrorActionPreference = 'Stop'
+
+$url64          = 'url_blenderbim_py310_win_zip'
+$checksum64     = 'sha256sum_blenderbim_py310_win_zip'
+$checksumType64 = 'sha256'
+
+$appDataUserDir  = [System.Environment]::GetEnvironmentVariable('appdata')
+$unzipTargetDir  = "$appDataUserDir\Blender Foundation\Blender\latest_blender_version_maj_min\scripts\addons"
+
+$chocoBaseDir    = [System.Environment]::GetEnvironmentVariable('ChocolateyInstall')
+$addonEnable     = "$chocoBaseDir\lib\blenderbim-nightly\tools\enable_blenderbim_addon.py"
+
+$programFilesDir = [System.Environment]::GetEnvironmentVariable('ProgramFiles')
+$blenderExePath  = "$env:ProgramFiles\Blender Foundation\Blender latest_blender_version_maj_min\blender.exe"
+
+$processName      = "blender"
+$blenderIsRunning = Get-Process -Name $processName -ErrorAction SilentlyContinue
+
+
+if($blenderIsRunning -eq $null) {
+    echo "attempting to install blenderbim."
+    Install-ChocolateyZipPackage -PackageName $env:ChocolateyPackageName -Url64 $url64 -Checksum64 $checksum64 -checksumType $checksumType64 -UnzipLocation $unzipTargetDir
+    Start-Process -FilePath  $blenderExePath -ArgumentList "-b", "-y", "--python", "$addonEnable"
+}
+else {
+    Write-Warning "$processName is still running - blenderbim cannot be safely installed."
+    Write-Warning "Please retry after closing all running blender applications."
+    exit 1
+}

choco/blenderbim/tools/chocolateyuninstall.ps1

@@ -0,0 +1,22 @@
+$appDataUserDir = [System.Environment]::GetEnvironmentVariable('appdata')
+$unzippedDir = "$appDataUserDir\Blender Foundation\Blender\latest_blender_version_maj_min\scripts\addons\blenderbim"
+
+$chocoBaseDir    = [System.Environment]::GetEnvironmentVariable('ChocolateyInstall')
+$addonDisable     = "$chocoBaseDir\lib\blenderbim-nightly\tools\disable_blenderbim_addon.py"
+
+$programFilesDir = [System.Environment]::GetEnvironmentVariable('ProgramFiles')
+$blenderExePath  = "$env:ProgramFiles\Blender Foundation\Blender latest_blender_version_maj_min\blender.exe"
+
+$processName      = "blender"
+$blenderIsRunning = Get-Process -Name $processName -ErrorAction SilentlyContinue
+
+if($blenderIsRunning -eq $null) {
+    echo "attempting to uninstall blenderbim."
+    Start-Process -FilePath $blenderExePath -ArgumentList "-b", "-y", "--python", "$addonDisable"
+    Remove-Item -LiteralPath $unzippedDir -Force -Recurse
+}
+else {
+    Write-Warning "$processName is still running - blenderbim cannot be safely uninstalled."
+    Write-Warning "Please retry after closing all running blender applications."
+    exit 1
+}

choco/blenderbim/tools/disable_blenderbim_addon.py

@@ -0,0 +1,8 @@
+import bpy
+
+
+bpy.ops.preferences.addon_disable(module='blenderbim')
+bpy.ops.wm.save_userpref()
+
+print("disabled blenderbim addon successfully.")
+

choco/blenderbim/tools/enable_blenderbim_addon.py

@@ -0,0 +1,8 @@
+import bpy
+
+
+bpy.ops.preferences.addon_enable(module='blenderbim')
+bpy.ops.wm.save_userpref()
+
+print("enabled blenderbim addon successfully.")
+

cmake/CMakeLists.txt

@@ -38,7 +38,7 @@ MESSAGE(STATUS "Autodesk 3ds Max SDK found at ${max_sdk}")
 set(HAS_MAX TRUE)
 endif()
 endforeach()
-
+OPTION(MINIMAL_BUILD "The build is to make a minimal version of IFC converter from OCCT into IFC." OFF)
 OPTION(COLLADA_SUPPORT "Build IfcConvert with COLLADA support (requires OpenCOLLADA)." ON)
 OPTION(IFCXML_SUPPORT "Build IfcParse with ifcXML support (requires libxml2)." ON)
 OPTION(ENABLE_BUILD_OPTIMIZATIONS "Enable certain compiler and linker optimizations on RelWithDebInfo and Release builds." OFF)
@@ -53,6 +53,7 @@ OPTION(HDF5_SUPPORT "Enable HDF5 support (requires HDF5, zlib)" ON)
 OPTION(USE_VLD "Use Visual Leak Detector for debugging memory leaks, MSVC-only." OFF)
 OPTION(USE_MMAP "Adds a command line options to parse IFC files from memory mapped files using Boost.Iostreams" OFF)
 OPTION(BUILD_SHARED_LIBS "Build IfcParse and IfcGeom as shared libs (SO/DLL)." OFF)
+OPTION(MSVC_PARALLEL_BUILD "Multi-threaded compilation in Microsoft Visual Studio (/MP)" OFF)
 if (${HAS_MAX})
 OPTION(BUILD_IFCMAX "Build IfcMax, a 3ds Max plug-in, Windows-only." OFF)
 endif()
@@ -66,6 +67,10 @@ IF(NOT CMAKE_BUILD_TYPE)
 	SET(CMAKE_BUILD_TYPE "Release")
 ENDIF()
 
+if(MSVC AND MSVC_PARALLEL_BUILD)
+	add_definitions("/MP")
+endif()
+
 # QtViewer requires Qt5
 OPTION(BUILD_QTVIEWER "Build IfcOpenShell Qt GUI Viewer" OFF)
 include(GNUInstallDirs)
@@ -121,6 +126,7 @@ ENDMACRO()
 
 UNIFY_ENVVARS_AND_CACHE(OCC_INCLUDE_DIR)
 UNIFY_ENVVARS_AND_CACHE(OCC_LIBRARY_DIR)
+if (NOT MINIMAL_BUILD)
 UNIFY_ENVVARS_AND_CACHE(OPENCOLLADA_INCLUDE_DIR)
 UNIFY_ENVVARS_AND_CACHE(OPENCOLLADA_LIBRARY_DIR)
 UNIFY_ENVVARS_AND_CACHE(LIBXML2_INCLUDE_DIR)
@@ -130,17 +136,20 @@ UNIFY_ENVVARS_AND_CACHE(PYTHON_EXECUTABLE)
 UNIFY_ENVVARS_AND_CACHE(HDF5_INCLUDE_DIR)
 UNIFY_ENVVARS_AND_CACHE(HDF5_LIBRARY_DIR)
 UNIFY_ENVVARS_AND_CACHE(HDF5_LIBRARIES)
+endif()
 UNIFY_ENVVARS_AND_CACHE(BOOST_ROOT)
 UNIFY_ENVVARS_AND_CACHE(BOOST_LIBRARYDIR)
 
+if (NOT MINIMAL_BUILD)
 UNIFY_ENVVARS_AND_CACHE(CGAL_INCLUDE_DIR)
 UNIFY_ENVVARS_AND_CACHE(CGAL_LIBRARY_DIR)
 UNIFY_ENVVARS_AND_CACHE(GMP_INCLUDE_DIR)
 UNIFY_ENVVARS_AND_CACHE(GMP_LIBRARY_DIR)
 UNIFY_ENVVARS_AND_CACHE(MPFR_INCLUDE_DIR)
 UNIFY_ENVVARS_AND_CACHE(MPFR_LIBRARY_DIR)
+endif()
 
-if (GLTF_SUPPORT AND BUILD_CONVERT)
+if (NOT MINIMAL_BUILD AND GLTF_SUPPORT AND BUILD_CONVERT)
 UNIFY_ENVVARS_AND_CACHE(JSON_INCLUDE_DIR)
 FIND_FILE(json_hpp "json.hpp" ${JSON_INCLUDE_DIR}/nlohmann)
 IF(json_hpp)
@@ -201,10 +210,12 @@ if(USE_MMAP)
     add_definitions(-DUSE_MMAP)
 endif()
 
+if (NOT MINIMAL_BUILD)
 # libxml2 is required for IFCXML (optional) and SVGFILL (mandatory)
-find_package(LibXml2 REQUIRED)
+  find_package(LibXml2 REQUIRED)
+endif()
 
-if (IFCXML_SUPPORT)
+if (NOT MINIMAL_BUILD AND IFCXML_SUPPORT)
     add_definitions(-DWITH_IFCXML)
 	set(SWIG_DEFINES ${SWIG_DEFINES} -DWITH_IFCXML)
 endif()
@@ -346,7 +357,7 @@ endif()
 
 endif(BUILD_IFCGEOM)
 
-IF(COLLADA_SUPPORT)
+IF(NOT MINIMAL_BUILD AND COLLADA_SUPPORT)
 	# Find OpenCOLLADA
 	IF("${OPENCOLLADA_INCLUDE_DIR}" STREQUAL "")
 		MESSAGE(STATUS "No OpenCOLLADA include directory specified")
@@ -426,7 +437,7 @@ IF(COLLADA_SUPPORT)
 	ENDIF()
 ENDIF()
 
-if(HDF5_SUPPORT)
+if(NOT MINIMAL_BUILD AND HDF5_SUPPORT)
     IF("${HDF5_INCLUDE_DIR}" STREQUAL "")
 		MESSAGE(STATUS "No HDF5 include directory specified")
 	ElSE()
@@ -441,30 +452,60 @@ if(HDF5_SUPPORT)
 
     if (HDF5_LIBRARY_DIR)
     	# result of the HDF5 ctest package
-    	
-        if (WIN32)
-        	set(zlib_post lib)
-        	set(lib_ext lib)
-        else()
-        	set(lib_ext a)
+        # Find zlib using cmake find_library. How should this be implemented?
+        # FIND_LIBRARY(NAMES z libz libz_debug PATHS ... NO_DEFAULT_PATH)
+
+
+        if ("$ENV{CONDA_BUILD}" STREQUAL "")
+            # result of the HDF5 ctest package
+
+            if (WIN32)
+                set(zlib_post lib)
+                set(lib_ext lib)
+            else()
+                set(lib_ext a)
+            endif()
+
+            if ("${CMAKE_BUILD_TYPE}" STREQUAL "Debug")
+                set(debug_postfix "_debug")
+            endif()
+
+            SET(HDF5_LIBRARIES
+                    "${HDF5_LIBRARY_DIR}/libhdf5_cpp${debug_postfix}.${lib_ext}"
+                    "${HDF5_LIBRARY_DIR}/libhdf5${debug_postfix}.${lib_ext}"
+                    "${HDF5_LIBRARY_DIR}/libz${zlib_post}${debug_postfix}.${lib_ext}"
+                    "${HDF5_LIBRARY_DIR}/libsz${debug_postfix}.${lib_ext}"
+                    "${HDF5_LIBRARY_DIR}/libaec${debug_postfix}.${lib_ext}"
+                    )
+
+        ELSE()
+            MESSAGE(STATUS "Packaging hdf5 and zlib for conda distribution")
+            if (WIN32)
+                # Windows
+                set(zlib_post zlib)
+                set(lib_ext lib)
+            elseif(${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
+                # macOS
+                set(zlib_post libz)
+                set(lib_ext dylib)
+            else()
+                # linux
+                set(zlib_post libz)
+                set(lib_ext so)
+            endif()
+
+            SET(HDF5_LIBRARIES
+                    "${HDF5_LIBRARY_DIR}/libhdf5_cpp.${lib_ext}"
+                    "${HDF5_LIBRARY_DIR}/libhdf5.${lib_ext}"
+                    "${HDF5_LIBRARY_DIR}/${zlib_post}.${lib_ext}"
+                    )
         endif()
 
-	if ("${CMAKE_BUILD_TYPE}" STREQUAL "Debug")
-		set(debug_postfix "_debug")
-	endif() 
-        
-        SET(HDF5_LIBRARIES 
-            "${HDF5_LIBRARY_DIR}/libhdf5_cpp${debug_postfix}.${lib_ext}"
-            "${HDF5_LIBRARY_DIR}/libhdf5${debug_postfix}.${lib_ext}"
-            "${HDF5_LIBRARY_DIR}/libz${zlib_post}${debug_postfix}.${lib_ext}"
-            "${HDF5_LIBRARY_DIR}/libsz${debug_postfix}.${lib_ext}"
-            "${HDF5_LIBRARY_DIR}/libaec${debug_postfix}.${lib_ext}"
-        )
     endif()
-    
+
     if (NOT HDF5_LIBRARIES)
     	# debian default
-    	
+
         SET(HDF5_LIBRARIES
             /usr/lib/x86_64-linux-gnu/hdf5/serial/libhdf5_cpp.so
             /usr/lib/x86_64-linux-gnu/hdf5/serial/libhdf5.so
@@ -579,13 +620,16 @@ function(files_for_ifc_version IFC_VERSION RESULT_NAME)
 endfunction()
 
 if(NOT SCHEMA_VERSIONS)
-    set(SCHEMA_VERSIONS "2x3" "4" "4x1" "4x2" "4x3_rc1" "4x3_rc2" "4x3_rc3" "4x3_rc4")
+    set(SCHEMA_VERSIONS "2x3" "4" "4x1" "4x2" "4x3_rc1" "4x3_rc2" "4x3_rc3" "4x3_rc4" "4x3")
 endif()
 
 foreach(s ${SCHEMA_VERSIONS})
 	add_definitions(-DHAS_SCHEMA_${s})
 endforeach()
 
+string(REPLACE ";" ")(" schema_version_seq "(${SCHEMA_VERSIONS})")
+ADD_DEFINITIONS(-DSCHEMA_SEQ=${schema_version_seq})
+
 if(COMPILE_SCHEMA)
 	# @todo, this appears to be untested at the moment
 
@@ -655,7 +699,7 @@ if (BUILD_IFCGEOM)
 	endforeach()
 	set(IFCOPENSHELL_LIBRARIES ${IFCOPENSHELL_LIBRARIES} IfcGeom ${IFCGEOM_SCHEMA_LIBRARIES} IfcGeom ${IFCGEOM_SCHEMA_LIBRARIES})
 endif()
-if (BUILD_CONVERT)
+if (BUILD_CONVERT OR BUILD_IFCPYTHON)
 	foreach(s ${SCHEMA_VERSIONS})
 		set(SERIALIZER_SCHEMA_LIBRARIES ${SERIALIZER_SCHEMA_LIBRARIES} Serializers_ifc${s})
 	endforeach()
@@ -728,7 +772,7 @@ TARGET_LINK_LIBRARIES(IfcGeom IfcParse ${IFCGEOM_SCHEMA_LIBRARIES} ${CMAKE_THREA
 
 endif(BUILD_IFCGEOM)
 
-if (BUILD_CONVERT)
+if (BUILD_CONVERT OR BUILD_IFCPYTHON)
 
 # Serializers
 file(GLOB SERIALIZERS_H_FILES ../src/serializers/*.h)
@@ -749,6 +793,10 @@ set_target_properties(Serializers PROPERTIES COMPILE_FLAGS "-DIFC_GEOM_EXPORTS $
 
 TARGET_LINK_LIBRARIES(Serializers ${SERIALIZER_SCHEMA_LIBRARIES} ${OPENCOLLADA_LIBRARIES})
 
+endif(BUILD_CONVERT or BUILD_IFCPYTHON)
+
+if (BUILD_CONVERT)
+
 # IfcConvert
 file(GLOB IFCCONVERT_CPP_FILES ../src/ifcconvert/*.cpp)
 file(GLOB IFCCONVERT_H_FILES ../src/ifcconvert/*.h)
@@ -774,7 +822,7 @@ INSTALL(TARGETS IfcConvert
 endif(BUILD_CONVERT)
 
 # IfcGeomServer
-if(BUILD_GEOMSERVER)
+if(NOT MINIMAL_BUILD AND BUILD_GEOMSERVER)
 
 file(GLOB CPP_FILES ../src/ifcgeomserver/*.cpp)
 file(GLOB H_FILES ../src/ifcgeomserver/*.h)
@@ -805,7 +853,8 @@ if (GIT_FOUND)
 	)
 	string(REPLACE "\n" ";" git_branch_list "${git_branches}")
 	foreach(git_branch_candidate IN ITEMS ${git_branch_list})
-		string(STRIP "${git_branch_candidate}" git_branch_candidate_2)
+		string(REPLACE "*" "" git_branch_candidate_temp "${git_branch_candidate}")
+		string(STRIP "${git_branch_candidate_temp}" git_branch_candidate_2)
 		if (NOT git_branch_candidate_2 MATCHES "^HEAD$")
 			set(git_branch ${git_branch_candidate_2})
 		endif()
@@ -828,7 +877,7 @@ IF(BUILD_DOCUMENTATION)
 	ADD_SUBDIRECTORY(../docs docs)
 ENDIF()
 
-IF(BUILD_IFCPYTHON)
+IF(NOT MINIMAL_BUILD AND BUILD_IFCPYTHON)
 	ADD_SUBDIRECTORY(../src/ifcwrap ifcwrap)
 ENDIF()
 
@@ -836,11 +885,12 @@ IF(BUILD_EXAMPLES)
 	ADD_SUBDIRECTORY(../src/examples examples)
 ENDIF()
 
-IF(BUILD_IFCMAX)
+IF(NOT MINIMAL_BUILD AND BUILD_IFCMAX)
 	ADD_SUBDIRECTORY(../src/ifcmax ifcmax)
 ENDIF()
-
+if (NOT MINIMAL_BUILD)
 ADD_SUBDIRECTORY(../src/svgfill svgfill)
+endif()
 
 # CMake installation targets
 INSTALL(FILES ${IFCPARSE_H_FILES}
@@ -912,12 +962,12 @@ set(CPACK_SOURCE_GENERATOR "TGZ")
 
 FOREACH(COMPONENT IN ITEMS ${BOOST_COMPONENTS})
     string(REPLACE "_" "-" COMP ${COMPONENT})
-    set(BOOST_DEPS "${BOOST_DEPS}, libboost-${COMP}1.67.0")
+    set(BOOST_DEPS "${BOOST_DEPS}, libboost-${COMP}-dev")
 endforeach(COMPONENT)
 
 set(CPACK_DEBIAN_PACKAGE_NAME "${PROJECT_NAME}")
 set(CPACK_DEBIAN_PACKAGE_MAINTAINER "${CPACK_PACKAGE_CONTACT}")
-set(CPACK_DEBIAN_PACKAGE_DEPENDS "python3, libxml2, liboce-foundation11, liboce-modeling11, liboce-ocaf11, liboce-visualization11, liboce-ocaf-lite11, libpython3.8 ${BOOST_DEPS}")
+set(CPACK_DEBIAN_PACKAGE_DEPENDS "python3, libxml2, libocct-foundation-dev, libocct-modeling-algorithms-dev, libocct-modeling-data-dev, libocct-ocaf-dev, libocct-visualization-dev, libocct-data-exchange-dev, libhdf5-serial-dev, libpython3.8 ${BOOST_DEPS}")
 set(CPACK_DEBIAN_PACKAGE_DESCRIPTION_SUMMARY "${CPACK_PACKAGE_DESCRIPTION_SUMMARY}")
 set(CPACK_DEBIAN_PACKAGE_DESCRIPTION "${CPACK_PACKAGE_DESCRIPTION}")
 set(CPACK_DEBIAN_PACKAGE_PRIORITY "optional")

conda/Makefile

@@ -0,0 +1,8 @@
+compile:
+	conda activate conda-build && conda-build -c conda-forge . --keep-old-work --python 3.10.5
+
+debug:
+	conda activate conda-build && conda-debug -c conda-forge . --python 3.10.4
+
+env:
+	conda env update --f environment.yml --prune

conda/bld.bat

@@ -1,29 +1,44 @@
 mkdir build && cd build
 
-REM Remove dot from PY_VER for use in library name
-REM From https://github.com/tpaviot/pythonocc-core/blob/master/ci/conda/bld.bat
 set MY_PY_VER=%PY_VER:.=%
+set LIBXML2="%LIBRARY_PREFIX%/lib/libxml2.lib"
 
-cmake -G "NMake Makefiles" ^
- -DCMAKE_INSTALL_PREFIX="%LIBRARY_PREFIX%" ^
- -DCMAKE_BUILD_TYPE=Release ^
- -DCMAKE_PREFIX_PATH="%LIBRARY_PREFIX%" ^
- -DCMAKE_SYSTEM_PREFIX_PATH="%LIBRARY_PREFIX%" ^
- -DPYTHON_EXECUTABLE="%PYTHON%" ^
- -DPYTHON_INCLUDE_DIR="%PREFIX%"/include ^
- -DPYTHON_LIBRARY="%PREFIX%"/libs/python%MY_PY_VER%.lib ^
- -DBOOST_LIBRARYDIR="%LIBRARY_PREFIX%\lib" ^
- -DBOOST_INCLUDEDIR="%LIBRARY_PREFIX%\include" ^
- -DOCC_INCLUDE_DIR="%LIBRARY_PREFIX%\include\oce" ^
- -DOCC_LIBRARY_DIR="%LIBRARY_PREFIX%\lib" ^
- -DCOLLADA_SUPPORT=Off ^
- -DBUILD_EXAMPLES=Off ^
- -DBUILD_GEOMSERVER=Off ^
- -DBUILD_CONVERT=Off ^
- ../cmake
- 
-if errorlevel 1 exit 1
-
-cmake --build . --target INSTALL --config Release
+cmake -G "Ninja" ^
+ -D CMAKE_BUILD_TYPE:STRING=Release ^
+ -D CMAKE_INSTALL_PREFIX:FILEPATH="%LIBRARY_PREFIX%" ^
+ -D CMAKE_PREFIX_PATH:FILEPATH="%LIBRARY_PREFIX%" ^
+ -D CMAKE_SYSTEM_PREFIX_PATH:FILEPATH="%LIBRARY_PREFIX%" ^
+ -D OCC_INCLUDE_DIR:FILEPATH="%LIBRARY_PREFIX%\include\opencascade" ^
+ -D OCC_LIBRARY_DIR:FILEPATH="%LIBRARY_PREFIX%\lib" ^
+ -D CGAL_INCLUDE_DIR:FILEPATH="%LIBRARY_PREFIX%\include" ^
+ -D GMP_INCLUDE_DIR:FILEPATH="%LIBRARY_PREFIX%\include" ^
+ -D GMP_LIBRARY_DIR:FILEPATH="%LIBRARY_PREFIX%\lib" ^
+ -D MPFR_LIBRARY_DIR:FILEPATH="%LIBRARY_PREFIX%\lib" ^
+ -D COLLADA_SUPPORT=OFF ^
+ -D HDF5_SUPPORT=ON ^
+ -D HDF5_INCLUDE_DIR="%LIBRARY_PREFIX%\include" ^
+ -D HDF5_LIBRARY_DIR="%LIBRARY_PREFIX%\lib" ^
+ -D JSON_INCLUDE_DIR="%LIBRARY_PREFIX%\include" ^
+ -D PYTHON_INCLUDE_DIR=%PREFIX%\include ^
+ -D PYTHON_EXECUTABLE:FILEPATH=%PREFIX%\python.exe ^
+ -D PYTHON_LIBRARY:FILEPATH="%PREFIX%"\libs/python%MY_PY_VER%.lib ^
+ -D BUILD_IFCPYTHON=ON ^
+ -D BUILD_IFCGEOM=ON ^
+ -D COLLADA_SUPPORT:BOOL=OFF ^
+ -D BUILD_EXAMPLES:BOOL=OFF ^
+ -D BUILD_GEOMSERVER:BOOL=OFF ^
+ -D GLTF_SUPPORT:BOOL=ON ^
+ -D BUILD_CONVERT:BOOL=ON ^
+ -D BUILD_IFCMAX:BOOL=OFF ^
+ -D IFCXML_SUPPORT:BOOL=ON ^
+ -D Boost_LIBRARYDIR:FILEPATH="%LIBRARY_PREFIX%\lib" ^
+ -D Boost_INCLUDEDIR:FILEPATH="%LIBRARY_PREFIX%\include" ^
+ -D Boost_USE_STATIC_LIBS:BOOL=OFF ^
+ %SRC_DIR%/cmake
+
+if errorlevel 1 exit 1
+
+:: Build and install
+cmake --build . -- install
 
 if errorlevel 1 exit 1

conda/build.sh

@@ -1,34 +1,44 @@
-# From https://github.com/tpaviot/pythonocc-core/blob/master/ci/conda/build.sh
-if [ "$PY3K" == "1" ]; then
-    MY_PY_VER="${PY_VER}m"
-else
-    MY_PY_VER="${PY_VER}"
+#!/bin/bash
+
+declare -a CMAKE_PLATFORM_FLAGS
+
+if [[ ${HOST} =~ .*linux.* ]]; then
+    CMAKE_PLATFORM_FLAGS+=(-DCMAKE_TOOLCHAIN_FILE=$RECIPE_DIR/cross-linux.cmake)
 fi
 
 if [ `uname` == Darwin ]; then
-    PY_LIB="libpython${MY_PY_VER}.dylib"
-    export   CFLAGS="$CFLAGS   -Wl,-flat_namespace,-undefined,suppress"
-    export CXXFLAGS="$CXXFLAGS -Wl,-flat_namespace,-undefined,suppress"
-    export  LDFLAGS="$LDFLAGS  -Wl,-flat_namespace,-undefined,suppress"
-else
-    PY_LIB="libpython${MY_PY_VER}.so"
+  export CFLAGS="$CFLAGS   -Wl,-flat_namespace,-undefined,suppress"
+  export CXXFLAGS="$CXXFLAGS -Wl,-flat_namespace,-undefined,suppress"
+  export LDFLAGS="$LDFLAGS  -Wl,-flat_namespace,-undefined,suppress"
 fi
 
-mkdir build && cd build
-
-cmake \
- -DCMAKE_INSTALL_PREFIX=$PREFIX \
+cmake -G Ninja \
  -DCMAKE_BUILD_TYPE=Release \
+ -DCMAKE_INSTALL_PREFIX=$PREFIX \
+  ${CMAKE_PLATFORM_FLAGS[@]} \
  -DCMAKE_PREFIX_PATH=$PREFIX \
  -DCMAKE_SYSTEM_PREFIX_PATH=$PREFIX \
- -DOCC_INCLUDE_DIR=$PREFIX/include/oce \
- -DOCC_LIBRARY_DIR=$PREFIX/lib \
  -DPYTHON_EXECUTABLE:FILEPATH=$PYTHON \
- -DPYTHON_INCLUDE_DIR:PATH=$PREFIX/include/python$MY_PY_VER \
- -DPYTHON_LIBRARY:FILEPATH=$PREFIX/lib/${PY_LIB} \
- -DCOLLADA_SUPPORT=Off \
- ../cmake
+ -DGMP_LIBRARY_DIR=$PREFIX/lib \
+ -DMPFR_LIBRARY_DIR=$PREFIX/lib \
+ -DOCC_INCLUDE_DIR=$PREFIX/include/opencascade \
+ -DOCC_LIBRARY_DIR=$PREFIX/lib \
+ -DHDF5_SUPPORT:BOOL=ON \
+ -DHDF5_INCLUDE_DIR=$PREFIX/include \
+ -DHDF5_LIBRARY_DIR=$PREFIX/lib \
+ -DJSON_INCLUDE_DIR=$PREFIX/include \
+ -DCGAL_INCLUDE_DIR=$PREFIX/include \
+ -DCOLLADA_SUPPORT=0 \
+ -DBUILD_EXAMPLES:BOOL=OFF \
+ -DIFCXML_SUPPORT:BOOL=ON \
+ -DGLTF_SUPPORT:BOOL=ON \
+ -DBUILD_CONVERT:BOOL=ON \
+ -DBUILD_IFCPYTHON:BOOL=ON \
+ -DBUILD_IFCGEOM:BOOL=ON \
+ -DBUILD_GEOMSERVER:BOOL=OFF \
+ -DBOOST_USE_STATIC_LIBS:BOOL=OFF \
+ ./cmake
 
-make -j$CPU_COUNT _ifcopenshell_wrapper
-cd ifcwrap
-make install/local
+ninja
+
+ninja install

conda/conda_build_config.yaml

@@ -0,0 +1,2 @@
+CONDA_BUILD_SYSROOT:
+  - /opt/MacOSX10.13.sdk       # [osx]

conda/cross-linux.cmake

@@ -0,0 +1,16 @@
+# this one is important
+set(CMAKE_SYSTEM_NAME Linux)
+set(CMAKE_PLATFORM Linux)
+
+# specify the cross compiler
+set(CMAKE_C_COMPILER $ENV{CC})
+set(CMAKE_CXX_COMPILER $ENV{CXX})
+
+# where is the target environment
+set(CMAKE_FIND_ROOT_PATH $ENV{PREFIX} $ENV{BUILD_PREFIX}/$ENV{HOST}/sysroot)
+
+# search for programs in the build host directories
+set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
+# for libraries and headers in the target directories
+set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
+set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)

conda/environment.yml

@@ -0,0 +1,14 @@
+name: conda-build
+channels:
+  - conda-forge
+dependencies:
+  - conda-build
+  - conda-verify
+  - anaconda-client
+  - ninja
+  - doxygen
+  - ripgrep
+  - pip
+  - pip:
+      - --extra-index-url https://lief.s3-website.fr-par.scw.cloud/latest
+      - lief==0.13.0.dev0

conda/meta.yaml

@@ -1,42 +1,62 @@
+{% set name = "ifcopenshell" %}
+{% set version = "0.7.0" %}
+{% set occt_version = "7.6.2" %}
+{% set cgal_cpp_version = "5.3" %}
+{% set hdf5_version = "1.12.1" %}
+
 package:
-  name: ifcopenshell
-  version: "0.6.0a1"
+  name: {{ name }}
+  version: {{ version }}
 
 source:
-  git_rev: "v0.6.0a1"
-  git_url: https://github.com/IfcOpenShell/IfcOpenShell
+  path: ..
 
 build:
-  number: 0
-  features:
-    - vc9     # [win and py27]
-    - vc10    # [win and py34]
-    - vc14    # [win and py35]
-    - vc14    # [win and py36]
+  binary_relocation: false [osx]
 
 requirements:
   build:
-    - gcc     # [osx]
-    - make
-    - python
-    - oce ==0.18.3
+    - {{ compiler('c') }}
+    - {{ compiler('cxx') }}
+    - ninja >=1.10.2
     - cmake
-    - swig >=3.0.9
-    - libboost
-    - icu
-    - xmlschema
-    - lxml
-    - numpy
-  run:
-    - libgcc  # [osx]
+    - swig >=4.0.2
+
+  host:
     - python
-    - oce ==0.18.3
-    - libboost
-    - icu
-    - xmlschema
-    - lxml
-    - numpy
-    
+    - boost-cpp
+    - occt
+    - libxml2
+    - cgal-cpp
+    - hdf5
+    - mpfr
+    - gmp  # [unix]
+    - mpir  # [win]
+    - nlohmann_json
+
+  run:
+    - python
+    - boost-cpp
+    - occt
+    - libxml2
+    - cgal-cpp
+    - hdf5
+    - mpfr
+    - gmp  # [unix]
+    - mpir  # [win]
+    - nlohmann_json
+
+test:
+  imports:
+    - ifcopenshell
+
 about:
   home: http://ifcopenshell.org
-  license: LGPL
+  license: LGPL-3.0-or-later
+  license_file: COPYING
+  summary: 'IfcOpenShell is a library to support the IFC file format'
+  description: |
+    IfcOpenShell is an open source (LGPL) software library for 
+    working with the Industry Foundation Classes (IFC) file format.
+  doc_url: http://ifcopenshell.org/
+  dev_url: https://github.com/IfcOpenShell/IfcOpenShell

nix/build-all.py

@@ -23,7 +23,7 @@
 # This script builds IfcOpenShell and its dependencies                        #
 #                                                                             #
 # Prerequisites for this script to function correctly:                        #
-#     * cmake * git * bzip2 * tar * c(++) compilers * yacc * autoconf         #
+#     * cmake * git * bzip2 * tar * c(++) compilers * autoconf                #
 #                                                                             #
 #   if building with USE_OCCT additionally:                                   #
 #     * freetype * glx.h                                                      #
@@ -72,7 +72,7 @@ PROJECT_NAME = "IfcOpenShell"
 USE_CURRENT_PYTHON_VERSION = os.getenv("USE_CURRENT_PYTHON_VERSION")
 ADD_COMMIT_SHA = os.getenv("ADD_COMMIT_SHA")
 
-PYTHON_VERSIONS = ["3.6.14", "3.7.12", "3.8.12", "3.9.7", "3.10.0"]
+PYTHON_VERSIONS = ["3.6.14", "3.7.13", "3.8.13", "3.9.11", "3.10.3", "3.11.0"]
 JSON_VERSION = "v3.6.1"
 OCE_VERSION = "0.18.3"
 OCCT_VERSION = "7.5.3"
@@ -83,8 +83,8 @@ SWIG_VERSION = "4.0.2"
 OPENCOLLADA_VERSION = "v1.6.68"
 HDF5_VERSION = "1.12.1"
 
-GMP_VERSION = "6.1.2"
-MPFR_VERSION = "3.1.5" # latest is 4.1.0
+GMP_VERSION = "6.2.1"
+MPFR_VERSION = "3.1.6" # latest is 4.1.0
 CGAL_VERSION = "5.3"
 
 # binaries
@@ -97,7 +97,6 @@ cc = "cc"
 cplusplus = "c++"
 autoconf = "autoconf"
 automake = "automake"
-yacc = "yacc"
 make = "make"
 date = "date"
 curl = "curl"
@@ -220,7 +219,7 @@ print("Building:", *sorted(targets, key=lambda t: len(list(v(t)))))
 
 # Check that required tools are in PATH
 
-for cmd in [git, bunzip2, tar, cc, cplusplus, autoconf, automake, yacc, make, "patch", "cmake"]:
+for cmd in [git, bunzip2, tar, cc, cplusplus, autoconf, automake, make, "patch", "cmake"]:
     if which(cmd) is None:
         raise ValueError(f"Required tool '{cmd}' not installed or not added to PATH")
 
@@ -263,6 +262,11 @@ def run(cmds, cwd=None):
 
     return stdout.strip()
 
+if platform.system() == "Darwin":
+    if run(["sw_vers", "-productVersion"]) >= "11.":
+        # Apparently not supported
+        PYTHON_VERSIONS = [pv for pv in PYTHON_VERSIONS if tuple(map(int, pv.split("."))) >= (3, 7)]
+
 BOOST_VERSION_UNDERSCORE = BOOST_VERSION.replace(".", "_")
 
 OCE_LOCATION = f"https://github.com/tpaviot/oce/archive/OCE-{OCE_VERSION}.tar.gz"
@@ -508,7 +512,7 @@ if USE_OCCT and "occ" in targets:
             "-DBUILD_MODULE_Draw=0",
             "-DBUILD_RELEASE_DISABLE_EXCEPTIONS=Off"
         ],
-        download_url = "https://git.dev.opencascade.org/repos/occt.git",
+        download_url = "https://github.com/Open-Cascade-SAS/OCCT",
         download_name = "occt",
         download_tool=download_tool_git,
         patch=None if OCCT_VERSION >= "7.4" else "./patches/occt/enable-exception-handling.patch",
@@ -577,7 +581,7 @@ if "python" in targets and not USE_CURRENT_PYTHON_VERSION:
     # with the system python because of some threading initialization
     PYTHON_CONFIGURE_ARGS = []
     if platform.system() == "Darwin":
-        PYTHON_CONFIGURE_ARGS = ["--disable-static", "--enable-shared"]
+        PYTHON_CONFIGURE_ARGS = ["--enable-shared"]
 
     for PYTHON_VERSION in PYTHON_VERSIONS:
         try:
@@ -630,7 +634,7 @@ if "cgal" in targets:
     build_dependency(
         name=f"gmp-{GMP_VERSION}",
         mode="autoconf",
-        build_tool_args=["--disable-shared", "--with-pic"],
+        build_tool_args=[ENABLE_FLAG, DISABLE_FLAG, "--with-pic"],
         download_url="https://ftp.gnu.org/gnu/gmp/",
         download_name=f"gmp-{GMP_VERSION}.tar.bz2"
     )
@@ -638,7 +642,7 @@ if "cgal" in targets:
     build_dependency(
         name=f"mpfr-{MPFR_VERSION}",
         mode="autoconf",
-        build_tool_args=["--disable-shared", f"--with-gmp={DEPS_DIR}/install/gmp-{GMP_VERSION}"],
+        build_tool_args=[ENABLE_FLAG, DISABLE_FLAG, f"--with-gmp={DEPS_DIR}/install/gmp-{GMP_VERSION}"],
         download_url=f"http://www.mpfr.org/mpfr-{MPFR_VERSION}/",
         download_name=f"mpfr-{MPFR_VERSION}.tar.bz2"
     )
@@ -647,9 +651,9 @@ if "cgal" in targets:
         name=f"cgal-{CGAL_VERSION}",
         mode="cmake",
         build_tool_args=[
-            f"-DGMP_LIBRARIES={DEPS_DIR}/install/gmp-{GMP_VERSION}/lib/libgmp.a",
+            f"-DGMP_LIBRARIES={DEPS_DIR}/install/gmp-{GMP_VERSION}/lib/libgmp.{LIBRARY_EXT}",
             f"-DGMP_INCLUDE_DIR={DEPS_DIR}/install/gmp-{GMP_VERSION}/include",
-            f"-DMPFR_LIBRARIES={DEPS_DIR}/install/mpfr-{MPFR_VERSION}/lib/libmpfr.a" ,
+            f"-DMPFR_LIBRARIES={DEPS_DIR}/install/mpfr-{MPFR_VERSION}/lib/libmpfr.{LIBRARY_EXT}" ,
             f"-DMPFR_INCLUDE_DIR={DEPS_DIR}/install/mpfr-{MPFR_VERSION}/include",
             f"-DBoost_INCLUDE_DIR={DEPS_DIR}/install/boost-{BOOST_VERSION}",
             f"-DCMAKE_INSTALL_PREFIX={DEPS_DIR}/install/cgal-{CGAL_VERSION}/",

src/bcf/src/bcf/v2/bcfxml.py

@@ -223,10 +223,10 @@ class BcfXml:
 
     def edit_topic(self, topic):
         if not topic.creation_date:
-            topic.creation_date = datetime.utcnow().isoformat()
+            topic.creation_date = datetime.utcnow().replace(microsecond=0).isoformat()
             topic.creation_author = self.author
         else:
-            topic.modified_date = datetime.utcnow().isoformat()
+            topic.modified_date = datetime.utcnow().replace(microsecond=0).isoformat()
             topic.modified_author = self.author
 
         self.document = minidom.Document()
@@ -345,10 +345,10 @@ class BcfXml:
 
     def edit_comment(self, comment, topic):
         if not comment.date:
-            comment.date = datetime.utcnow().isoformat()
+            comment.date = datetime.utcnow().replace(microsecond=0).isoformat()
             comment.author = self.author
         else:
-            comment.modified_date = datetime.utcnow().isoformat()
+            comment.modified_date = datetime.utcnow().replace(microsecond=0).isoformat()
             comment.modified_author = self.author
         self.edit_topic(topic)
 
@@ -595,7 +595,7 @@ class BcfXml:
             copyfile(header_file.reference, os.path.join(topic_filepath, header_file.filename))
             header_file.reference = header_file.filename
             header_file.is_external = False
-        header_file.date = datetime.utcnow().isoformat()
+        header_file.date = datetime.utcnow().replace(microsecond=0).isoformat()
         if not topic.header:
             topic.header = bcf.v2.data.Header()
         topic.header.files.append(header_file)

src/bcf/src/bcf/v3/bcfxml.py

@@ -646,7 +646,7 @@ class BcfXml:
     def get_comments(self, guid):
         comments = {}
         data = self._read_xml(os.path.join(guid, "markup.bcf"), "markup.xsd")
-        if "Comments" not in data["Topics"]:
+        if "Comments" not in data["Topic"]:
             return comments
 
         for item in data["Topic"]["Comments"].get("Comment", []):

src/blenderbim/Makefile

@@ -16,6 +16,24 @@
 # You should have received a copy of the GNU General Public License
 # along with BlenderBIM Add-on.  If not, see <http://www.gnu.org/licenses/>.
 
+PYTHON:=python
+PATCH:=patch
+SED:=sed -i
+ifeq ($(OS),Windows_NT)
+HOSTOS:=win
+else
+UNAME_S:=$(shell uname -s)
+ifeq ($(UNAME_S),Linux)
+HOSTOS:=linux
+endif
+ifeq ($(UNAME_S),Darwin)
+HOSTOS:=macos
+PYTHON:=python3
+PATCH:=patch -d
+SED:=sed -i '' -e
+endif
+endif
+
 VERSION:=`date '+%y%m%d'`
 PYVERSION:=py37
 
@@ -38,18 +56,24 @@ HPPFCL_URL:=https://anaconda.org/conda-forge/hpp-fcl/1.7.5/download/linux-64/hpp
 EIGENPY_URL:=https://anaconda.org/conda-forge/eigenpy/2.6.5/download/linux-64/eigenpy-2.6.5-py37h95e2c48_0.tar.bz2
 BOOST_URL:=https://anaconda.org/conda-forge/boost/1.74.0/download/linux-64/boost-1.74.0-py37h0379df6_3.tar.bz2
 LXML_URL:=https://files.pythonhosted.org/packages/30/c0/d0526314971fc661b083ab135747dc68446a3022686da8c16d25fcf6ef07/lxml-4.6.3-cp37-cp37m-manylinux2014_x86_64.whl
+SHAPELY_URL:=https://files.pythonhosted.org/packages/a2/73/07f507b539527579c026ed5f411c35e287685ce794c4dfb7edf6675cdc24/Shapely-1.8.4-cp37-cp37m-manylinux_2_12_x86_64.manylinux2010_x86_64.whl
+PILLOW_URL:=https://files.pythonhosted.org/packages/ed/d5/c2e84e1e36ab8ebea033921d5886a056c77e18bab5ab1051fcc22de2e8a2/Pillow-9.2.0-cp37-cp37m-manylinux_2_28_x86_64.whl
 endif
 ifeq ($(PYVERSION), py39)
 HPPFCL_URL:=https://anaconda.org/conda-forge/hpp-fcl/1.7.5/download/linux-64/hpp-fcl-1.7.5-py39hbcdfc36_0.tar.bz2
 EIGENPY_URL:=https://anaconda.org/conda-forge/eigenpy/2.6.5/download/linux-64/eigenpy-2.6.5-py39h5aed9d1_0.tar.bz2
 BOOST_URL:=https://anaconda.org/conda-forge/boost/1.74.0/download/linux-64/boost-1.74.0-py39h5472131_3.tar.bz2
 LXML_URL:=https://files.pythonhosted.org/packages/19/d9/a69c6aff5673554df48120565a14a50eaa41d29ae03b02faa0b023666318/lxml-4.6.3-cp39-cp39-manylinux2014_x86_64.whl
+SHAPELY_URL:=https://files.pythonhosted.org/packages/08/12/5af915b2bc0470f4a652ef9978557a0fa8b705b122ccaec6626029e1674c/Shapely-1.8.4-cp39-cp39-manylinux_2_12_x86_64.manylinux2010_x86_64.whl
+PILLOW_URL:=https://files.pythonhosted.org/packages/01/61/3ff85fb4bb596ce3d223c8fcf93c8df5c12bc8899dfb4fb3cb1c5b20dd5f/Pillow-9.2.0-cp39-cp39-manylinux_2_28_x86_64.whl
 endif
 ifeq ($(PYVERSION), py310)
 HPPFCL_URL:=https://anaconda.org/conda-forge/hpp-fcl/1.8.0/download/linux-64/hpp-fcl-1.8.0-py310hdaf7e41_1.tar.bz2
 EIGENPY_URL:=https://anaconda.org/conda-forge/eigenpy/2.6.11/download/linux-64/eigenpy-2.6.11-py310hf3e5c9c_0.tar.bz2
 BOOST_URL:=https://anaconda.org/conda-forge/boost/1.74.0/download/linux-64/boost-1.74.0-py310h7c3ba0c_5.tar.bz2
 LXML_URL:=https://files.pythonhosted.org/packages/25/1e/19b46d8e8881fe0df2e20945d51919eeb1817836d62a90efa8506530e45c/lxml-4.8.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_24_x86_64.whl
+SHAPELY_URL:=https://files.pythonhosted.org/packages/60/20/c6321e3da92a4ad9495727c9aa8c423e47295572ccd35ece82d1ac013e28/Shapely-1.8.4-cp310-cp310-manylinux_2_12_x86_64.manylinux2010_x86_64.whl
+PILLOW_URL:=https://files.pythonhosted.org/packages/f6/51/320986ebd6d46a0e95c2240468ced73153b691ce07617078bcdf30c609ec/Pillow-9.2.0-cp310-cp310-manylinux_2_28_x86_64.whl
 endif
 ASSIMP_URL:=https://anaconda.org/conda-forge/assimp/5.0.1/download/linux-64/assimp-5.0.1-hedfc422_6.tar.bz2
 OCTOMAP_URL:=https://anaconda.org/conda-forge/octomap/1.9.7/download/linux-64/octomap-1.9.7-h4bd325d_0.tar.bz2
@@ -62,42 +86,85 @@ HPPFCL_URL:=https://anaconda.org/conda-forge/hpp-fcl/1.7.5/download/osx-64/hpp-f
 EIGENPY_URL:=https://anaconda.org/conda-forge/eigenpy/2.6.5/download/osx-64/eigenpy-2.6.5-py37h0695097_0.tar.bz2
 BOOST_URL:=https://anaconda.org/conda-forge/boost/1.74.0/download/osx-64/boost-1.74.0-py37hd79e0ac_3.tar.bz2
 LXML_URL:=https://files.pythonhosted.org/packages/1e/3e/f0abc15d5dac50939bccc589aae336d5ead4c72e7ad1039a2e0f3630ea92/lxml-4.6.3-cp37-cp37m-macosx_10_9_x86_64.whl
+SHAPELY_URL:=https://files.pythonhosted.org/packages/47/a9/7c644e71638bff2bbaa87f05ee62fdf6b4552a55e74bbf731d6210b6d436/Shapely-1.8.4-cp37-cp37m-macosx_10_9_x86_64.whl
+PILLOW_URL:=https://files.pythonhosted.org/packages/88/49/c26fc3b5b0e82bdc9d8751d6b939da29327b0d98f7c3b95a575cbfed2743/Pillow-9.2.0-cp37-cp37m-macosx_10_10_x86_64.whl
 endif
 ifeq ($(PYVERSION), py39)
 HPPFCL_URL:=https://anaconda.org/conda-forge/hpp-fcl/1.7.5/download/osx-64/hpp-fcl-1.7.5-py39h1e32b98_0.tar.bz2
 EIGENPY_URL:=https://anaconda.org/conda-forge/eigenpy/2.6.5/download/osx-64/eigenpy-2.6.5-py39h5405915_0.tar.bz2
 BOOST_URL:=https://anaconda.org/conda-forge/boost/1.74.0/download/osx-64/boost-1.74.0-py39ha641261_3.tar.bz2
 LXML_URL:=https://files.pythonhosted.org/packages/b8/74/a71f7ad72e8db54ce899efab84507b801660750cbbfa6a39e6717557d36a/lxml-4.6.3-cp39-cp39-macosx_10_9_x86_64.whl
+SHAPELY_URL:=https://files.pythonhosted.org/packages/f5/f9/bf6cc34b02b3c7d3777c5e47fa57d2f69387613bbd8decdf3577a9d83a83/Shapely-1.8.4-cp39-cp39-macosx_10_9_x86_64.whl
+PILLOW_URL:=https://files.pythonhosted.org/packages/88/7a/ddfe28b485b623361457d4783007c1f9ba83a87f93e7fec32f64793efb6c/Pillow-9.2.0-cp39-cp39-macosx_10_10_x86_64.whl
 endif
 ifeq ($(PYVERSION), py310)
 HPPFCL_URL:=https://anaconda.org/conda-forge/hpp-fcl/1.8.0/download/osx-64/hpp-fcl-1.8.0-py310h651ac30_1.tar.bz2
 EIGENPY_URL:=https://anaconda.org/conda-forge/eigenpy/2.6.11/download/osx-64/eigenpy-2.6.11-py310hc03097c_0.tar.bz2
 BOOST_URL:=https://anaconda.org/conda-forge/boost/1.74.0/download/osx-64/boost-1.74.0-py310h509978a_5.tar.bz2
 LXML_URL:=https://files.pythonhosted.org/packages/a1/44/17b7dac7a18807d30e2fe10c3328c152808f5464565e230bfd0e77f178c6/lxml-4.8.0-cp310-cp310-macosx_10_15_x86_64.whl
+SHAPELY_URL:=https://files.pythonhosted.org/packages/f5/a8/02347c450b5507b9a7a2c15ad6a029613149468fc55ac2100ab215666159/Shapely-1.8.4-cp310-cp310-macosx_10_9_x86_64.whl
+PILLOW_URL:=https://files.pythonhosted.org/packages/d8/60/b13c00d403f34110e96c1b5c0afa73ce461efe3fe960c3a7e3e7fe190d82/Pillow-9.2.0-cp310-cp310-macosx_10_10_x86_64.whl
 endif
 ASSIMP_URL:=https://anaconda.org/conda-forge/assimp/5.0.1/download/osx-64/assimp-5.0.1-h1224e73_6.tar.bz2
 OCTOMAP_URL:=https://anaconda.org/conda-forge/octomap/1.9.7/download/osx-64/octomap-1.9.7-h940c156_0.tar.bz2
 ZLIB_URL:=https://anaconda.org/conda-forge/zlib/1.2.11/download/osx-64/zlib-1.2.11-h7795811_1010.tar.bz2
 endif
 
+ifeq ($(PLATFORM), macosm1)
+ifeq ($(PYVERSION), py37)
+# Warning: py37 not supported on Apple M1
+HPPFCL_URL:=https://anaconda.org/conda-forge/hpp-fcl/1.7.5/download/osx-64/hpp-fcl-1.7.5-py37h2d7f23a_0.tar.bz2
+EIGENPY_URL:=https://anaconda.org/conda-forge/eigenpy/2.6.5/download/osx-64/eigenpy-2.6.5-py37h0695097_0.tar.bz2
+BOOST_URL:=https://anaconda.org/conda-forge/boost/1.74.0/download/osx-64/boost-1.74.0-py37hd79e0ac_3.tar.bz2
+LXML_URL:=https://anaconda.org/conda-forge/lxml/4.9.1/download/osx-64/lxml-4.9.1-py37h994c40b_0.tar.bz2
+SHAPELY_URL:=https://files.pythonhosted.org/packages/47/a9/7c644e71638bff2bbaa87f05ee62fdf6b4552a55e74bbf731d6210b6d436/Shapely-1.8.4-cp37-cp37m-macosx_10_9_x86_64.whl
+PILLOW_URL:=https://files.pythonhosted.org/packages/aa/bc/21097cd891dd2fa02f2b3d767e02e883e026482e59d29975d1bc30024aa3/Pillow-9.2.0-cp39-cp39-macosx_11_0_arm64.whl
+endif
+ifeq ($(PYVERSION), py39)
+HPPFCL_URL:=https://anaconda.org/conda-forge/hpp-fcl/1.7.5/download/osx-arm64/hpp-fcl-1.7.5-py39ha69f3c1_2.tar.bz2
+EIGENPY_URL:=https://anaconda.org/conda-forge/eigenpy/2.6.7/download/osx-arm64/eigenpy-2.6.7-py39ha69f3c1_0.tar.bz2
+BOOST_URL:=https://anaconda.org/conda-forge/boost/1.78.0/download/osx-arm64/boost-1.78.0-py39h2550fe3_0.tar.bz2
+LXML_URL:=https://anaconda.org/conda-forge/lxml/4.9.1/download/osx-arm64/lxml-4.9.1-py39h9eb174b_0.tar.bz2
+SHAPELY_URL:=https://files.pythonhosted.org/packages/8e/60/8186995a96c5a27c9b79c015bbdd89c6d9a6df9988f86f3f1027ecd4a56a/Shapely-1.8.4-cp39-cp39-macosx_11_0_arm64.whl
+PILLOW_URL:=https://files.pythonhosted.org/packages/aa/bc/21097cd891dd2fa02f2b3d767e02e883e026482e59d29975d1bc30024aa3/Pillow-9.2.0-cp39-cp39-macosx_11_0_arm64.whl
+endif
+ifeq ($(PYVERSION), py310)
+HPPFCL_URL:=https://anaconda.org/conda-forge/hpp-fcl/1.8.0/download/osx-arm64/hpp-fcl-1.8.0-py310h5699539_2.tar.bz2
+EIGENPY_URL:=https://anaconda.org/conda-forge/eigenpy/2.6.9/download/osx-arm64/eigenpy-2.6.9-py310habfc766_1.tar.bz2
+BOOST_URL:=https://anaconda.org/conda-forge/boost/1.78.0/download/osx-arm64/boost-1.78.0-py310h4566fd1_0.tar.bz2
+LXML_URL:=https://anaconda.org/conda-forge/lxml/4.9.1/download/osx-arm64/lxml-4.9.1-py310h02f21da_0.tar.bz2
+SHAPELY_URL:=https://files.pythonhosted.org/packages/ba/d0/75cd36c81a1aa26dd6d37cf7ae1c79b0bc2d379e0f32c359bcb00b14e5c3/Shapely-1.8.4-cp310-cp310-macosx_11_0_arm64.whl
+PILLOW_URL:=https://files.pythonhosted.org/packages/0c/5f/117b653cad585f3aedfe0de996c292e67d4b020ed77f652e5a6c8c24f908/Pillow-9.2.0-cp310-cp310-macosx_11_0_arm64.whl
+endif
+ASSIMP_URL:=https://anaconda.org/conda-forge/assimp/5.0.1/download/osx-arm64/assimp-5.0.1-h0f81e16_7.tar.bz2
+OCTOMAP_URL:=https://anaconda.org/conda-forge/octomap/1.9.7/download/osx-arm64/octomap-1.9.7-hc021e02_0.tar.bz2
+ZLIB_URL:=https://anaconda.org/conda-forge/zlib/1.2.11/download/osx-arm64/zlib-1.2.11-h90dfc92_1014.tar.bz2
+endif
+
 ifeq ($(PLATFORM), win)
 ifeq ($(PYVERSION), py37)
 HPPFCL_URL:=https://anaconda.org/conda-forge/hpp-fcl/1.7.5/download/win-64/hpp-fcl-1.7.5-py37h839d6b1_0.tar.bz2
 EIGENPY_URL:=https://anaconda.org/conda-forge/eigenpy/2.6.5/download/win-64/eigenpy-2.6.5-py37h2c32e34_0.tar.bz2
 BOOST_URL:=https://anaconda.org/conda-forge/boost/1.74.0/download/win-64/boost-1.74.0-py37h3b38789_3.tar.bz2
 LXML_URL:=https://files.pythonhosted.org/packages/9e/5e/171ee9d40a600f565fe691ec5bf7596247ec62cfb2edc00c91afe8ea837b/lxml-4.6.3-cp37-cp37m-win_amd64.whl
+SHAPELY_URL:=https://files.pythonhosted.org/packages/ca/4d/85b912d7947261e6b3218b01946bcd7c2efb2bbafaf517c6fe1dc3bb8399/Shapely-1.8.4-cp37-cp37m-win_amd64.whl
+PILLOW_URL:=https://files.pythonhosted.org/packages/69/f5/9e802159d78b2eaf26bf1f8b94648605993f5ca7247ac8870f065063fc40/Pillow-9.2.0-cp37-cp37m-win_amd64.whl
 endif
 ifeq ($(PYVERSION), py39)
 HPPFCL_URL:=https://anaconda.org/conda-forge/hpp-fcl/1.7.5/download/win-64/hpp-fcl-1.7.5-py39h2e7c763_0.tar.bz2
 EIGENPY_URL:=https://anaconda.org/conda-forge/eigenpy/2.6.5/download/win-64/eigenpy-2.6.5-py39h3ce40e6_0.tar.bz2
 BOOST_URL:=https://anaconda.org/conda-forge/boost/1.74.0/download/win-64/boost-1.74.0-py39hefe7e4c_3.tar.bz2
 LXML_URL:=https://files.pythonhosted.org/packages/72/d4/426ecb8849c47c3e370c87aa0ac05d85768df917ffea27fcd6686a5e6495/lxml-4.6.3-cp39-cp39-win_amd64.whl
+SHAPELY_URL:=https://files.pythonhosted.org/packages/72/c3/0d52812db25ca71203f6203891277e6ee4f0244b21a36c062123ece15f36/Shapely-1.8.4-cp39-cp39-win_amd64.whl
+PILLOW_URL:=https://files.pythonhosted.org/packages/19/3f/b4d4bcf05dbcbe07f2e9613a8f4180c297395e73a91d8ad22c32c6624f8c/Pillow-9.2.0-cp39-cp39-win_amd64.whl
 endif
 ifeq ($(PYVERSION), py310)
 HPPFCL_URL:=https://anaconda.org/conda-forge/hpp-fcl/1.8.0/download/win-64/hpp-fcl-1.8.0-py310hc5a3c62_1.tar.bz2
 EIGENPY_URL:=https://anaconda.org/conda-forge/eigenpy/2.6.11/download/win-64/eigenpy-2.6.11-py310hbd43d28_0.tar.bz2
 BOOST_URL:=https://anaconda.org/conda-forge/boost/1.74.0/download/win-64/boost-1.74.0-py310hc781a3c_5.tar.bz2
 LXML_URL:=https://files.pythonhosted.org/packages/f6/71/65c80a4caa1617a4c6e8fe1500cebb179db96232e2f623bfe6a1f4294e39/lxml-4.8.0-cp310-cp310-win_amd64.whl
+SHAPELY_URL:=https://files.pythonhosted.org/packages/24/b5/46d13799804b5fe9ede2eca8b19023410e29b78baca0bff727671a1df8c1/Shapely-1.8.4-cp310-cp310-win_amd64.whl
+PILLOW_URL:=https://files.pythonhosted.org/packages/02/55/67a3c17b9e7d972ed8c246f104da99ca4f3ea42fba566697e479011b84b6/Pillow-9.2.0-cp310-cp310-win_amd64.whl
 endif
 ASSIMP_URL:=https://anaconda.org/conda-forge/assimp/5.0.1/download/win-64/assimp-5.0.1-hc2aa0de_6.tar.bz2
 OCTOMAP_URL:=https://anaconda.org/conda-forge/octomap/1.9.7/download/win-64/octomap-1.9.7-h5362a0b_0.tar.bz2
@@ -115,7 +182,7 @@ endif
 	cp -r blenderbim/* dist/blenderbim/
 
 	# Provides IfcOpenShell Python functionality
-	cd dist/working && wget https://s3.amazonaws.com/ifcopenshell-builds/ifcopenshell-python-$(PYNUMBER)-v0.7.0-2985bba-$(PLATFORM)64.zip
+	cd dist/working && wget https://s3.amazonaws.com/ifcopenshell-builds/ifcopenshell-python-$(PYNUMBER)-v0.7.0-cdde536-$(PLATFORM)64.zip
 	cd dist/working && unzip ifcopenshell-python*
 	cp -r dist/working/ifcopenshell dist/blenderbim/libs/site/packages/
 
@@ -138,11 +205,13 @@ endif
 	# Provides IFCClash functionality
 	cp -r dist/working/IfcOpenShell-0.7.0/src/ifcclash/ifcclash dist/blenderbim/libs/site/packages/
 	# Provides BIMTester functionality
-	cd dist/working && python -m venv env
+	cd dist/working && $(PYTHON) -m venv env
 	cd dist/working && . env/bin/activate && pip install pybabel
 	cd dist/working && . env/bin/activate && pip install babel
 	cd dist/working && . env/bin/activate && ./env/bin/pybabel compile -d ./IfcOpenShell-0.7.0/src/ifcbimtester/bimtester/locale/
 	cp -r dist/working/IfcOpenShell-0.7.0/src/ifcbimtester/bimtester dist/blenderbim/libs/site/packages/
+	# Provides IFCTester functionality
+	cp -r dist/working/IfcOpenShell-0.7.0/src/ifctester/ifctester dist/blenderbim/libs/site/packages/
 	# Provides IFCCOBie functionality
 	cp -r dist/working/IfcOpenShell-0.7.0/src/ifccobie/* dist/blenderbim/libs/site/packages/
 	# Provides IFCDiff functionality
@@ -161,9 +230,9 @@ endif
 
 	# Provides Mustache templating in construction documentation
 	mkdir dist/working
-	cd dist/working && wget https://files.pythonhosted.org/packages/d6/fd/eb8c212053addd941cc90baac307c00ac246ac3fce7166b86434c6eae963/pystache-0.5.4.tar.gz
+	cd dist/working && wget https://files.pythonhosted.org/packages/3f/e7/8750ba6c6101d6aa5ceeb20c013adf2c6f3554a12c71d75654b468404bfa/pystache-0.6.0.tar.gz
 	cd dist/working && tar -xzvf pystache*
-	cd dist/working/pystache-0.5.4/ && python setup.py build && cp -r build/lib/pystache ../../blenderbim/libs/site/packages/
+	cd dist/working/pystache-0.6.0/ && $(PYTHON) setup.py build && cp -r build/lib/pystache ../../blenderbim/libs/site/packages/
 	rm -rf dist/working
 
 	# Provides SVG export in construction documentation
@@ -210,9 +279,9 @@ endif
 
 	# Required by IFCDiff
 	mkdir dist/working
-	cd dist/working && wget https://github.com/Moult/deepdiff/archive/master.zip
-	cd dist/working && unzip master.zip
-	cp -r dist/working/deepdiff-master/deepdiff dist/blenderbim/libs/site/packages/
+	cd dist/working && wget https://files.pythonhosted.org/packages/0f/ca/caead2949fbb824c7142e3774fa841aa853bb4d4331b440da8c8514dfc6f/deepdiff-5.8.1.tar.gz
+	cd dist/working && tar -xzvf deepdiff*
+	cp -r dist/working/deepdiff-5.8.1/deepdiff dist/blenderbim/libs/site/packages/
 	rm -rf dist/working
 
 	# Required by deepdiff
@@ -238,16 +307,16 @@ endif
 
 	# Required by bcf
 	mkdir dist/working
-	cd dist/working && wget https://files.pythonhosted.org/packages/bb/41/ad9ce53bb978b68af8ae415293cafc89b165b8ad55a593725299dca76729/xmlschema-1.1.1.tar.gz
+	cd dist/working && wget https://files.pythonhosted.org/packages/5b/ef/f97c3e1a7efa00e989a793fe15297214fc95ad7d9e3810586bd08ce9f0f3/xmlschema-2.0.2.tar.gz
 	cd dist/working && tar -xzvf xmlschema*
-	cp -r dist/working/xmlschema-1.1.1/xmlschema dist/blenderbim/libs/site/packages/
+	cp -r dist/working/xmlschema-2.0.2/xmlschema dist/blenderbim/libs/site/packages/
 	rm -rf dist/working
 
 	# Required by bcf
 	mkdir dist/working
-	cd dist/working && wget https://files.pythonhosted.org/packages/12/f9/f9960222d5274944b01391749e55e4dcdf28d8f0c108b64ac931ceff6fdb/elementpath-1.4.3.tar.gz
+	cd dist/working && wget https://files.pythonhosted.org/packages/11/bc/5afb61dd5d863e5cf77cd952445c50c17e65953405986f19e97e4389692a/elementpath-3.0.2.tar.gz
 	cd dist/working && tar -xzvf elementpath*
-	cp -r dist/working/elementpath-1.4.3/elementpath dist/blenderbim/libs/site/packages/
+	cp -r dist/working/elementpath-3.0.2/elementpath dist/blenderbim/libs/site/packages/
 	rm -rf dist/working
 
 	# Required by bcf
@@ -271,6 +340,29 @@ endif
 	cp -r dist/working/PyP6Xer-1.13.0/xerparser dist/blenderbim/libs/site/packages/
 	rm -rf dist/working
 
+	# Required by QTOCalculator
+	mkdir dist/working
+	cd dist/working && wget $(SHAPELY_URL)
+	cd dist/working && cp *.whl shapely.zip && unzip shapely.zip
+	cp -r dist/working/shapely dist/blenderbim/libs/site/packages/
+ifeq ($(PLATFORM), win)
+	cp -r dist/working/Shapely.libs dist/blenderbim/libs/site/packages/
+endif
+ifeq ($(PLATFORM), linux)
+	cp -r dist/working/Shapely.libs dist/blenderbim/libs/site/packages/
+endif
+	rm -rf dist/working
+
+	# Required by the BIM tool thumbnail generator
+	mkdir dist/working
+	cd dist/working && wget $(PILLOW_URL)
+	cd dist/working && cp *.whl pillow.zip && unzip pillow.zip
+	cp -r dist/working/PIL dist/blenderbim/libs/site/packages/
+ifeq ($(PLATFORM), linux)
+	cp -r dist/working/Pillow.libs dist/blenderbim/libs/site/packages/
+endif
+	rm -rf dist/working
+
 	# Required by xerparser and IFC4D
 	# TODO: remove this dependency. It's only used to show a progress bar.
 	mkdir dist/working
@@ -281,7 +373,7 @@ endif
 
 	# Required by IFCCityJSON
 	mkdir dist/working
-	cd dist/working && python -m venv env
+	cd dist/working && $(PYTHON) -m venv env
 	cd dist/working && mkdir site-packages
 	cd dist/working && . env/bin/activate && pip install cjio --target=./site-packages
 	cd dist/working/site-packages/ && rm -r *dist-info*
@@ -389,16 +481,30 @@ endif
 	# See bug #1294
 	cd dist/working/ && wget https://raw.githubusercontent.com/IfcOpenShell/IfcOpenShell/v0.7.0/src/ifcbimtester/patch/model_core.patch
 	cd dist/working/ && wget https://raw.githubusercontent.com/IfcOpenShell/IfcOpenShell/v0.7.0/src/ifcbimtester/patch/runner_util.patch
-	cd dist/working/ && patch ../blenderbim/libs/site/packages/behave/model_core.py < model_core.patch
-	cd dist/working/ && patch ../blenderbim/libs/site/packages/behave/runner_util.py < runner_util.patch
+	cd dist/working/ && $(PATCH) ../blenderbim/libs/site/packages/behave/model_core.py < model_core.patch
+	cd dist/working/ && $(PATCH) ../blenderbim/libs/site/packages/behave/runner_util.py < runner_util.patch
+	# See bug #2159
+	cd dist/working/ && wget https://raw.githubusercontent.com/IfcOpenShell/IfcOpenShell/v0.7.0/src/ifcbimtester/patch/junit.patch
+	cd dist/working/ && $(PATCH) ../blenderbim/libs/site/packages/behave/reporter/junit.py < junit.patch
 	rm -rf dist/working
 
 	# Required by ids - uh, not any more, but I'm trying it out in the drawing module
+ifeq ($(PLATFORM), macosm1)
+	# No wheels available for MacOS M1, but turns out this Anaconda build works
+	mkdir dist/working
+	cd dist/working && wget $(LXML_URL)
+	cd dist/working && tar -xf lxml*
+	cp -r dist/working/lib/$(PYLIBDIR)/site-packages/lxml dist/blenderbim/libs/site/packages/
+	rm -rf dist/working
+else
+	# Wheels are preferred for other OSes. A first attempt at using Anaconda
+	# builds for everything shows it breaks on windows. See #2422.
 	mkdir dist/working
 	cd dist/working && wget $(LXML_URL)
 	cd dist/working && cp *.whl lxml.zip && unzip lxml.zip
 	cp -r dist/working/lxml dist/blenderbim/libs/site/packages/
 	rm -rf dist/working
+endif
 
 	# Required by behave
 	mkdir dist/working
@@ -470,14 +576,14 @@ endif
 	cp -r dist/working/IFC2JSON_python-master/file_converters/ifcjson dist/blenderbim/libs/site/packages/
 	rm -rf dist/working
 
-	# Provides OpenLCA fucntionality
+	# Provides OpenLCA functionality
 	mkdir dist/working
 	cd dist/working && wget https://files.pythonhosted.org/packages/85/33/f91b96e9e8608ff65a003b692e8a9cdd60f2178f60617e5b1d21334c009c/olca-ipc-0.0.10.tar.gz
 	cd dist/working && tar -xzvf olca-ipc*
 	cd dist/working/olca-ipc-0.0.10/ && cp -r olca ../../blenderbim/libs/site/packages/
 	rm -rf dist/working
 
-	# Provides Brickschema fucntionality
+	# Provides Brickschema functionality
 	mkdir dist/working
 	cd dist/working && wget https://files.pythonhosted.org/packages/ca/37/8309da9a72407d2f5eb5489c197ac3cfe96ee3ccba1902d2a0ecc7843f92/brickschema-0.5.1.tar.gz
 	cd dist/working && tar -xzvf brickschema*
@@ -518,7 +624,7 @@ endif
 	cd dist/working/ && cp -r pkg_resources ../blenderbim/libs/site/packages/
 	rm -rf dist/working
 
-	cd dist/blenderbim && sed -i "s/999999/$(VERSION)/" __init__.py
+	cd dist/blenderbim && $(SED) "s/999999/$(VERSION)/" __init__.py
 	cd dist && zip -r blenderbim-$(VERSION)-$(PYVERSION)-$(PLATFORM).zip ./*
 	rm -rf dist/blenderbim
 
@@ -534,11 +640,19 @@ test-core:
 
 .PHONY: test-bim
 test-bim:
+ifndef MODULE
 	pytest test/bim
+else
+	pytest test/bim -m "$(MODULE)" ./ --maxfail=1
+endif
 
 .PHONY: test-tool
 test-tool:
+ifndef MODULE
 	pytest test/tool
+else
+	pytest test/tool/test_$(MODULE).py
+endif
 
 .PHONY: qa
 qa:

src/blenderbim/blenderbim/bim/__init__.py

@@ -27,6 +27,7 @@ modules = {
     "root": None,
     "unit": None,
     "model": None,
+    "cad": None,
     "georeference": None,
     "context": None,
     "drawing": None,
@@ -61,6 +62,7 @@ modules = {
     "clash": None,
     "lca": None,
     "csv": None,
+    "tester": None,
     "bimtester": None,
     "diff": None,
     "patch": None,
@@ -91,7 +93,11 @@ classes = [
     operator.SelectIfcFile,
     operator.SelectSchemaDir,
     operator.SelectURIAttribute,
+    operator.EditBlenderCollection,
+    operator.BIM_OT_open_webbrowser,
+    operator.BIM_OT_show_description,
     prop.StrProperty,
+    operator.BIM_OT_enum_property_search,  # /!\ Register AFTER prop.StrProperty
     prop.ObjProperty,
     prop.Attribute,
     prop.ModuleVisibility,
@@ -130,7 +136,8 @@ for mod in modules.values():
 
 def on_register(scene):
     handler.setDefaultProperties(scene)
-    bpy.app.handlers.depsgraph_update_post.remove(on_register)
+    if not bpy.app.background:
+        bpy.app.handlers.depsgraph_update_post.remove(on_register)
 
 
 def register():
@@ -153,6 +160,8 @@ def register():
     bpy.types.Camera.BIMMeshProperties = bpy.props.PointerProperty(type=prop.BIMMeshProperties)
     bpy.types.PointLight.BIMMeshProperties = bpy.props.PointerProperty(type=prop.BIMMeshProperties)
     bpy.types.SCENE_PT_unit.append(ui.ifc_units)
+    if hasattr(bpy.types, "UI_MT_button_context_menu"):
+        bpy.types.UI_MT_button_context_menu.append(ui.draw_custom_context_menu)
 
     for mod in modules.values():
         mod.register()
@@ -173,6 +182,8 @@ def unregister():
     del bpy.types.Camera.BIMMeshProperties
     del bpy.types.PointLight.BIMMeshProperties
     bpy.types.SCENE_PT_unit.remove(ui.ifc_units)
+    if hasattr(bpy.types, "UI_MT_button_context_menu"):
+        bpy.types.UI_MT_button_context_menu.remove(ui.draw_custom_context_menu)
 
     for mod in reversed(list(modules.values())):
         mod.unregister()

src/blenderbim/blenderbim/bim/data/libraries/IFC4 Demo Library.ifc

@@ -1,13 +1,13 @@
 ISO-10303-21;
 HEADER;
 FILE_DESCRIPTION(('ViewDefinition[DesignTransferView]'),'2;1');
-FILE_NAME('/dev/null','2021-11-08T10:06:41+11:00',(),(),'IfcOpenShell v0.7.0-ab506098','IfcOpenShell v0.7.0-ab506098','Nobody');
+FILE_NAME('/dev/null','2022-10-14T18:00:26+11:00',(),(),'IfcOpenShell v0.7.0-dc67287d','IfcOpenShell v0.7.0-dc67287d','Nobody');
 FILE_SCHEMA(('IFC4'));
 ENDSEC;
 DATA;
-#1=IFCPROJECT('1oJZZVd$b1PA6ggg_hh4cE',$,'BlenderBIM Demo',$,$,$,$,(#12,#16),#7);
-#2=IFCPROJECTLIBRARY('3jWhYPJYL2eOMZ9UZerKqx',$,'BlenderBIM Demo Library',$,$,$,$,$,$);
-#3=IFCRELDECLARES('1Wjv8iy5XBshHpEwChjCFa',$,$,$,#1,(#2));
+#1=IFCPROJECT('0yOx2IKFL4HAbf$IjzE0Kp',$,'BlenderBIM Demo',$,$,$,$,(#12,#16),#7);
+#2=IFCPROJECTLIBRARY('2jUXWJsnH2pxWl9Bl3Ljhd',$,'BlenderBIM Demo Library',$,$,$,$,$,$);
+#3=IFCRELDECLARES('0Rn4fWoen7xB9hskGGEfEy',$,$,$,#1,(#2));
 #4=IFCSIUNIT(*,.LENGTHUNIT.,$,.METRE.);
 #5=IFCSIUNIT(*,.AREAUNIT.,$,.SQUARE_METRE.);
 #6=IFCSIUNIT(*,.VOLUMEUNIT.,$,.CUBIC_METRE.);
@@ -24,82 +24,82 @@ DATA;
 #17=IFCGEOMETRICREPRESENTATIONSUBCONTEXT('Body','Model',*,*,*,*,#12,$,.MODEL_VIEW.,$);
 #18=IFCGEOMETRICREPRESENTATIONSUBCONTEXT('Annotation','Plan',*,*,*,*,#16,$,.PLAN_VIEW.,$);
 #19=IFCMATERIAL('Unknown',$,$);
-#20=IFCWALLTYPE('24Js5pn1PCeA_DXGWh67_f',$,'DEMO50',$,$,$,$,$,$,$);
+#20=IFCWALLTYPE('0D2QFqmA18fvA6TUteIRXc',$,'WAL50',$,$,$,$,$,$,.NOTDEFINED.);
 #21=IFCMATERIALLAYERSET((#23),$,$);
-#22=IFCRELASSOCIATESMATERIAL('3gPuTuaVf1AAgeln9$alDb',$,$,$,(#20),#21);
+#22=IFCRELASSOCIATESMATERIAL('0WbN7alqv8ix3w4MOdyl8F',$,$,$,(#20),#21);
 #23=IFCMATERIALLAYER(#19,0.05,$,$,$,$,$);
-#24=IFCRELDECLARES('3AJpFBgAf4OQzrklK7UbEn',$,$,$,#2,(#37,#41,#76,#47,#58,#91,#25,#225,#71,#159,#29,#62,#95,#20,#53,#86,#33,#66,#81));
-#25=IFCWALLTYPE('1HCqnc9S51NhU$e0Xceg6o',$,'DEMO100',$,$,$,$,$,$,$);
+#24=IFCRELDECLARES('13kodoVGr08Bn7WfGWndV_',$,$,$,#2,(#37,#41,#76,#47,#58,#91,#25,#225,#71,#159,#29,#62,#95,#20,#53,#86,#33,#66,#81));
+#25=IFCWALLTYPE('0qRxb2OqjDEfFI9i7b6qAw',$,'WAL100',$,$,$,$,$,$,.NOTDEFINED.);
 #26=IFCMATERIALLAYERSET((#28),$,$);
-#27=IFCRELASSOCIATESMATERIAL('2Ikoi$G2PCXvk61V36wh3N',$,$,$,(#25),#26);
+#27=IFCRELASSOCIATESMATERIAL('3BDm6HH553QhwCW7FPmjrR',$,$,$,(#25),#26);
 #28=IFCMATERIALLAYER(#19,0.1,$,$,$,$,$);
-#29=IFCWALLTYPE('3UPlZcHuTCi8CevFkzQjZ_',$,'DEMO200',$,$,$,$,$,$,$);
+#29=IFCWALLTYPE('1KMENjmzj7cf_am9SYEaXW',$,'WAL200',$,$,$,$,$,$,.NOTDEFINED.);
 #30=IFCMATERIALLAYERSET((#32),$,$);
-#31=IFCRELASSOCIATESMATERIAL('3uAo69i4j4nwMM7VRW3TQn',$,$,$,(#29),#30);
+#31=IFCRELASSOCIATESMATERIAL('1$36L06DrDYx1sZ9tBQ_WE',$,$,$,(#29),#30);
 #32=IFCMATERIALLAYER(#19,0.2,$,$,$,$,$);
-#33=IFCWALLTYPE('1y03E8PfTAJPit3967Y5Uf',$,'DEMO300',$,$,$,$,$,$,$);
+#33=IFCWALLTYPE('2y5Y19etz3rhrt8P45fuGA',$,'WAL300',$,$,$,$,$,$,.NOTDEFINED.);
 #34=IFCMATERIALLAYERSET((#36),$,$);
-#35=IFCRELASSOCIATESMATERIAL('2pvy9lWJL62BoA9QC5KCOG',$,$,$,(#33),#34);
+#35=IFCRELASSOCIATESMATERIAL('1WSONmheTD9xhiluqtfktr',$,$,$,(#33),#34);
 #36=IFCMATERIALLAYER(#19,0.3,$,$,$,$,$);
-#37=IFCCOVERINGTYPE('3ppA8IYrP2nffVvxie6ghZ',$,'DEMO10',$,$,$,$,$,$,$);
+#37=IFCCOVERINGTYPE('1pAuiYopL5hxCATiIPV8QG',$,'COV10',$,$,$,$,$,$,.NOTDEFINED.);
 #38=IFCMATERIALLAYERSET((#40),$,$);
-#39=IFCRELASSOCIATESMATERIAL('2Lg3S9QRH4kPgHpYrtokt6',$,$,$,(#37),#38);
+#39=IFCRELASSOCIATESMATERIAL('0ysRf97LT8fw28mDwt2vop',$,$,$,(#37),#38);
 #40=IFCMATERIALLAYER(#19,0.01,$,$,$,$,$);
-#41=IFCCOVERINGTYPE('3KuCqMbY16DRUygYOrLyYE',$,'DEMO20',$,$,(#45),$,$,$,$);
+#41=IFCCOVERINGTYPE('00LbT8PQf3XwImYkj_i_$4',$,'COV20',$,$,(#45),$,$,$,.NOTDEFINED.);
 #42=IFCMATERIALLAYERSET((#44),$,$);
-#43=IFCRELASSOCIATESMATERIAL('27BA_9uQT6OfxSGgEbsKY4',$,$,$,(#41),#42);
+#43=IFCRELASSOCIATESMATERIAL('0Kvr3quG19xw6$528t4NQi',$,$,$,(#41),#42);
 #44=IFCMATERIALLAYER(#19,0.02,$,$,$,$,$);
-#45=IFCPROPERTYSET('11$WHz$79EMw60BdaUh77w',$,'EPset_Parametric',$,(#46));
+#45=IFCPROPERTYSET('1IZqsXecj8NQZcNAIAY48P',$,'EPset_Parametric',$,(#46));
 #46=IFCPROPERTYSINGLEVALUE('LayerSetDirection',$,IFCLABEL('AXIS2'),$);
-#47=IFCCOVERINGTYPE('2cYyQpe9f1vBW8C4D58QZS',$,'DEMO30',$,$,(#51),$,$,$,$);
+#47=IFCCOVERINGTYPE('10YNsLMi9409CbEVFmDkJt',$,'COV30',$,$,(#51),$,$,$,.NOTDEFINED.);
 #48=IFCMATERIALLAYERSET((#50),$,$);
-#49=IFCRELASSOCIATESMATERIAL('1ir_2IiXX4Ax4VH5lcXGEu',$,$,$,(#47),#48);
+#49=IFCRELASSOCIATESMATERIAL('2jZVWXllT9ugYrdBaIBAnt',$,$,$,(#47),#48);
 #50=IFCMATERIALLAYER(#19,0.03,$,$,$,$,$);
-#51=IFCPROPERTYSET('2IalIx1bj02AXv21tZC0Sz',$,'EPset_Parametric',$,(#52));
+#51=IFCPROPERTYSET('2M2_M1eSXFYR8vFE96Ecy1',$,'EPset_Parametric',$,(#52));
 #52=IFCPROPERTYSINGLEVALUE('LayerSetDirection',$,IFCLABEL('AXIS3'),$);
-#53=IFCRAMPTYPE('23wMhiydD6yw5XpaFs6XCA',$,'DEMO200',$,$,$,$,$,$,$);
+#53=IFCRAMPTYPE('09P6PVRiT44vIjup23Olfq',$,'RAM200',$,$,$,$,$,$,.NOTDEFINED.);
 #54=IFCMATERIALLAYERSET((#56),$,$);
-#55=IFCRELASSOCIATESMATERIAL('2SLXH7fU1D6OIOdV8Gq6T_',$,$,$,(#53),#54);
+#55=IFCRELASSOCIATESMATERIAL('2Ghy1OMS1FLAOmdzrFp4rp',$,$,$,(#53),#54);
 #56=IFCMATERIALLAYER(#19,0.2,$,$,$,$,$);
 #57=IFCCIRCLEPROFILEDEF(.AREA.,$,$,0.3);
-#58=IFCPILETYPE('3J5r90lrL3kv3b8uqOGsY1',$,'DEMO1',$,$,$,$,$,$,$);
+#58=IFCPILETYPE('0X0OrCsUnDUPVeAu90N_K$',$,'P1',$,$,$,$,$,$,.NOTDEFINED.);
 #59=IFCMATERIALPROFILESET($,$,(#61),$);
-#60=IFCRELASSOCIATESMATERIAL('2vYxThgzHDSOHXKehbpw4S',$,$,$,(#58),#59);
+#60=IFCRELASSOCIATESMATERIAL('1FiRvXL$nBkuT8B3FfiGT9',$,$,$,(#58),#59);
 #61=IFCMATERIALPROFILE($,$,#19,#57,$,$);
-#62=IFCSLABTYPE('0OWxf_nd97uvH$Sr4QbAVW',$,'DEMO150',$,$,$,$,$,$,$);
+#62=IFCSLABTYPE('1helZ086v1o8JD3Ow1eWAy',$,'FLR150',$,$,$,$,$,$,.NOTDEFINED.);
 #63=IFCMATERIALLAYERSET((#65),$,$);
-#64=IFCRELASSOCIATESMATERIAL('3WSlLxuwH3Sfsul8DwR0LU',$,$,$,(#62),#63);
+#64=IFCRELASSOCIATESMATERIAL('3BbM02xKH6h97dBaMJp$Rr',$,$,$,(#62),#63);
 #65=IFCMATERIALLAYER(#19,0.2,$,$,$,$,$);
-#66=IFCSLABTYPE('0wVKQLFFb2oAHccogmWWWy',$,'DEMO250',$,$,$,$,$,$,$);
+#66=IFCSLABTYPE('1YAagoi$9D_hPiWtssbkcG',$,'FLR250',$,$,$,$,$,$,.NOTDEFINED.);
 #67=IFCMATERIALLAYERSET((#69),$,$);
-#68=IFCRELASSOCIATESMATERIAL('01R$pwjx14qOlDDfB34EBC',$,$,$,(#66),#67);
+#68=IFCRELASSOCIATESMATERIAL('0m1oulHjT1u889pxJG$XG_',$,$,$,(#66),#67);
 #69=IFCMATERIALLAYER(#19,0.3,$,$,$,$,$);
 #70=IFCRECTANGLEPROFILEDEF(.AREA.,$,$,0.5,0.6);
-#71=IFCCOLUMNTYPE('2OGUvw6Tj9deH3dTY4Hk3T',$,'DEMO1',$,$,$,$,$,$,$);
+#71=IFCCOLUMNTYPE('1lzPzyyFfFYRgjqMHnKZLx',$,'C1',$,$,$,$,$,$,.NOTDEFINED.);
 #72=IFCMATERIALPROFILESET($,$,(#74),$);
-#73=IFCRELASSOCIATESMATERIAL('1f717ijc53DgmnoMRFBZ62',$,$,$,(#71),#72);
+#73=IFCRELASSOCIATESMATERIAL('26fuP2VpfEnhlUsk0K1i4y',$,$,$,(#71),#72);
 #74=IFCMATERIALPROFILE($,$,#19,#70,$,$);
 #75=IFCCIRCLEHOLLOWPROFILEDEF(.AREA.,$,$,0.25,0.005);
-#76=IFCCOLUMNTYPE('3_jg43QeDAWvPCl1D0Lw_q',$,'DEMO2',$,$,$,$,$,$,$);
+#76=IFCCOLUMNTYPE('1qqu_K2Az3yvZSOapZmUrZ',$,'C2',$,$,$,$,$,$,.NOTDEFINED.);
 #77=IFCMATERIALPROFILESET($,$,(#79),$);
-#78=IFCRELASSOCIATESMATERIAL('3mX_vYbF92vxfOrjZFAuYk',$,$,$,(#76),#77);
+#78=IFCRELASSOCIATESMATERIAL('2YQz9JCGXAogjkmN3RZeKI',$,$,$,(#76),#77);
 #79=IFCMATERIALPROFILE($,$,#19,#75,$,$);
 #80=IFCRECTANGLEHOLLOWPROFILEDEF(.AREA.,$,$,0.075,0.15,0.005,0.005,0.005);
-#81=IFCCOLUMNTYPE('2ZJTQa2Db0MAv2N5bjUuXK',$,'DEMO3',$,$,$,$,$,$,$);
+#81=IFCCOLUMNTYPE('1rnXRgQ3X6pfk5O9j4HCLm',$,'C3',$,$,$,$,$,$,.NOTDEFINED.);
 #82=IFCMATERIALPROFILESET($,$,(#84),$);
-#83=IFCRELASSOCIATESMATERIAL('0Yslq2hlz9Qe3PO16oqESz',$,$,$,(#81),#82);
+#83=IFCRELASSOCIATESMATERIAL('2CQLZ1qlzA9uN2eRrpg99c',$,$,$,(#81),#82);
 #84=IFCMATERIALPROFILE($,$,#19,#80,$,$);
 #85=IFCISHAPEPROFILEDEF(.AREA.,'DEMO-I',$,0.1,0.2,0.005,0.01,0.005,$,$);
-#86=IFCBEAMTYPE('2bUnl1uHnB$QSMF_fVajUw',$,'DEMO1',$,$,$,$,$,$,$);
+#86=IFCBEAMTYPE('1xjrF860f2H9zb04Ui98Rt',$,'B1',$,$,$,$,$,$,.NOTDEFINED.);
 #87=IFCMATERIALPROFILESET($,$,(#89),$);
-#88=IFCRELASSOCIATESMATERIAL('08d9DxbyHAyRgRPc6W4Qsn',$,$,$,(#86),#87);
+#88=IFCRELASSOCIATESMATERIAL('03i9c81690fx2ZTBBXcqkL',$,$,$,(#86),#87);
 #89=IFCMATERIALPROFILE($,$,#19,#85,$,$);
 #90=IFCCSHAPEPROFILEDEF(.AREA.,'DEMO-C',$,0.2,0.1,0.0015,0.03,0.005);
-#91=IFCBEAMTYPE('0f1mNiwDTAiuSgrvotHh5$',$,'DEMO2',$,$,$,$,$,$,$);
+#91=IFCBEAMTYPE('3mAc_7AGP06w4CzYOlYVL2',$,'B2',$,$,$,$,$,$,.NOTDEFINED.);
 #92=IFCMATERIALPROFILESET($,$,(#94),$);
-#93=IFCRELASSOCIATESMATERIAL('2cO0XhlFf8MxIg_eNDWX_X',$,$,$,(#91),#92);
+#93=IFCRELASSOCIATESMATERIAL('2xvXgaSvL7KPR25fXz0fSE',$,$,$,(#91),#92);
 #94=IFCMATERIALPROFILE($,$,#19,#90,$,$);
-#95=IFCWINDOWTYPE('0ihTx2Iw1E2gRAq1N4pWVg',$,'DEMO1',$,$,$,(#136,#158),$,$,$,$,$,$);
+#95=IFCWINDOWTYPE('1kxjrhA4P2dwwueZ0_nSuu',$,'WT01',$,$,$,(#136,#158),$,$,.NOTDEFINED.,.NOTDEFINED.,$,$);
 #96=IFCINDEXEDPOLYGONALFACE((13,17,18,14));
 #97=IFCINDEXEDPOLYGONALFACE((5,6,3,4));
 #98=IFCINDEXEDPOLYGONALFACE((7,8,2,1));
@@ -126,14 +126,14 @@ DATA;
 #119=IFCPOLYGONALFACESET(#118,$,(#96,#97,#98,#99,#100,#102,#103,#104,#105,#106,#107,#108,#109,#110,#111,#112),$);
 #120=IFCPOLYGONALFACESET(#118,$,(#101,#113,#114,#115,#116,#117),$);
 #121=IFCSHAPEREPRESENTATION(#17,'Body','Tessellation',(#119,#120));
-#122=IFCSURFACESTYLE('Frame',.BOTH.,(#125));
-#123=IFCCOLOURRGB($,0.0429765619337559,0.0429765619337559,0.0429765619337559);
+#122=IFCSURFACESTYLE('Frame',.BOTH.,(#123));
+#123=IFCSURFACESTYLERENDERING(#124,0.,#125,$,$,$,IFCNORMALISEDRATIOMEASURE(0.),IFCSPECULARROUGHNESS(0.4),.NOTDEFINED.);
 #124=IFCCOLOURRGB($,0.0429765619337559,0.0429765619337559,0.0429765619337559);
-#125=IFCSURFACESTYLERENDERING(#123,0.,#124,$,$,$,$,$,$);
-#126=IFCSURFACESTYLE('Glass',.BOTH.,(#129));
-#127=IFCCOLOURRGB($,0.800000011920929,1.,1.);
+#125=IFCCOLOURRGB($,0.800000011920929,0.800000011920929,0.800000011920929);
+#126=IFCSURFACESTYLE('Glass',.BOTH.,(#127));
+#127=IFCSURFACESTYLERENDERING(#128,0.,#129,$,$,$,IFCNORMALISEDRATIOMEASURE(0.),IFCSPECULARROUGHNESS(0.5),.NOTDEFINED.);
 #128=IFCCOLOURRGB($,0.800000011920929,1.,1.);
-#129=IFCSURFACESTYLERENDERING(#127,0.799999997019768,#128,$,$,$,$,$,$);
+#129=IFCCOLOURRGB($,0.800000011920929,0.800000011920929,0.800000011920929);
 #130=IFCSTYLEDITEM(#119,(#122),'Frame');
 #131=IFCSTYLEDITEM(#120,(#126),'Glass');
 #132=IFCCARTESIANPOINT((0.,0.,0.));
@@ -163,7 +163,7 @@ DATA;
 #156=IFCDIRECTION((0.,0.,1.));
 #157=IFCAXIS2PLACEMENT3D(#154,#156,#155);
 #158=IFCREPRESENTATIONMAP(#157,#153);
-#159=IFCDOORTYPE('0HLh8Cp3f58hay4OhB7SHy',$,'DEMO1',$,$,$,(#204,#224),$,$,$,$,$,$);
+#159=IFCDOORTYPE('0s370BWH51r8Xg03pJ5OBE',$,'DT01',$,$,$,(#204,#224),$,$,.NOTDEFINED.,.NOTDEFINED.,$,$);
 #160=IFCINDEXEDPOLYGONALFACE((17,16,15,14));
 #161=IFCINDEXEDPOLYGONALFACE((2,3,29,28));
 #162=IFCINDEXEDPOLYGONALFACE((27,28,29,30,32,31));
@@ -194,14 +194,14 @@ DATA;
 #187=IFCPOLYGONALFACESET(#186,$,(#161,#162,#163,#164,#165,#166,#169,#170,#171,#172,#173,#174,#175,#176,#179,#180,#182,#183,#184,#185),$);
 #188=IFCPOLYGONALFACESET(#186,$,(#160,#167,#168,#177,#178,#181),$);
 #189=IFCSHAPEREPRESENTATION(#17,'Body','Tessellation',(#187,#188));
-#190=IFCSURFACESTYLE('Frame',.BOTH.,(#193));
-#191=IFCCOLOURRGB($,0.0429765619337559,0.0429765619337559,0.0429765619337559);
+#190=IFCSURFACESTYLE('Frame',.BOTH.,(#191));
+#191=IFCSURFACESTYLERENDERING(#192,0.,#193,$,$,$,IFCNORMALISEDRATIOMEASURE(0.),IFCSPECULARROUGHNESS(0.4),.NOTDEFINED.);
 #192=IFCCOLOURRGB($,0.0429765619337559,0.0429765619337559,0.0429765619337559);
-#193=IFCSURFACESTYLERENDERING(#191,0.,#192,$,$,$,$,$,$);
-#194=IFCSURFACESTYLE('Panel',.BOTH.,(#197));
-#195=IFCCOLOURRGB($,0.184475064277649,0.184475019574165,0.184475019574165);
+#193=IFCCOLOURRGB($,0.800000011920929,0.800000011920929,0.800000011920929);
+#194=IFCSURFACESTYLE('Panel',.BOTH.,(#195));
+#195=IFCSURFACESTYLERENDERING(#196,0.,#197,$,$,$,IFCNORMALISEDRATIOMEASURE(0.),IFCSPECULARROUGHNESS(0.5),.NOTDEFINED.);
 #196=IFCCOLOURRGB($,0.184475064277649,0.184475019574165,0.184475019574165);
-#197=IFCSURFACESTYLERENDERING(#195,0.,#196,$,$,$,$,$,$);
+#197=IFCCOLOURRGB($,0.800000011920929,0.800000011920929,0.800000011920929);
 #198=IFCSTYLEDITEM(#187,(#190),'Frame');
 #199=IFCSTYLEDITEM(#188,(#194),'Panel');
 #200=IFCCARTESIANPOINT((0.,0.,0.));
@@ -229,7 +229,7 @@ DATA;
 #222=IFCDIRECTION((0.,0.,1.));
 #223=IFCAXIS2PLACEMENT3D(#220,#222,#221);
 #224=IFCREPRESENTATIONMAP(#223,#219);
-#225=IFCFURNITURETYPE('1wgo6Pw4jDJO4F1GA9Qlmx',$,'BUNNY',$,$,$,(#946,#988),$,$,$,$);
+#225=IFCFURNITURETYPE('227RrM$yD30RGzlTgbBH3c',$,'BUN01',$,$,$,(#946,#988),$,$,.NOTDEFINED.,.NOTDEFINED.);
 #226=IFCINDEXEDPOLYGONALFACE((187,278,44));
 #227=IFCINDEXEDPOLYGONALFACE((21,52,60));
 #228=IFCINDEXEDPOLYGONALFACE((91,100,31));

src/blenderbim/blenderbim/bim/data/pset/EPset_Drawing.ifc

@@ -5,7 +5,7 @@ FILE_NAME('EPset_Drawing.ifc','2020-01-01T00:00:00',(),(),'EPset_Drawing','EPset
 FILE_SCHEMA(('IFC4'));
 ENDSEC;
 DATA;
-#1=IFCPROPERTYSETTEMPLATE('2JhNIvqZrFnAgxfhK0XVQX',$,'EPset_Drawing','',.PSET_OCCURRENCEDRIVEN.,'IfcAnnotation',(#2,#3,#4,#5,#6,#7,#8,#9,#10,#11));
+#1=IFCPROPERTYSETTEMPLATE('2JhNIvqZrFnAgxfhK0XVQX',$,'EPset_Drawing','',.PSET_OCCURRENCEDRIVEN.,'IfcAnnotation',(#2,#3,#4,#5,#6,#7,#8,#9,#10,#11,#12,#13,#14,#15));
 #2=IFCSIMPLEPROPERTYTEMPLATE('23JavTMk98ZxXhrUEnjAcf',$,'TargetView','',.P_SINGLEVALUE.,'IfcLabel',$,$,$,$,$,.READWRITE.);
 #3=IFCSIMPLEPROPERTYTEMPLATE('1yVWUt5H9DAOuu0OaMMLpe',$,'Scale','',.P_SINGLEVALUE.,'IfcLabel',$,$,$,$,$,.READWRITE.);
 #4=IFCSIMPLEPROPERTYTEMPLATE('3gsuPBtU93b8f0gg1pjkq6',$,'HumanScale','',.P_SINGLEVALUE.,'IfcLabel',$,$,$,$,$,.READWRITE.);
@@ -16,5 +16,9 @@ DATA;
 #9=IFCSIMPLEPROPERTYTEMPLATE('10hT_1zrzEbRRKMXYAWvtD',$,'Metadata','',.P_SINGLEVALUE.,'IfcText',$,$,$,$,$,.READWRITE.);
 #10=IFCSIMPLEPROPERTYTEMPLATE('3Z0BXPSG5CWgtI33ioV7aj',$,'Include','',.P_SINGLEVALUE.,'IfcText',$,$,$,$,$,.READWRITE.);
 #11=IFCSIMPLEPROPERTYTEMPLATE('1RVts_g3PAw98PJA2yL3bO',$,'Exclude','',.P_SINGLEVALUE.,'IfcText',$,$,$,$,$,.READWRITE.);
+#12=IFCSIMPLEPROPERTYTEMPLATE('0c1$8NpYDEaBiJrj16jHIo',$,'Stylesheet','',.P_SINGLEVALUE.,'IfcURIReference',$,$,$,$,$,.READWRITE.);
+#13=IFCSIMPLEPROPERTYTEMPLATE('3mRF52q81FQB$h4oTh7M45',$,'Markers','',.P_SINGLEVALUE.,'IfcURIReference',$,$,$,$,$,.READWRITE.);
+#14=IFCSIMPLEPROPERTYTEMPLATE('1rhr_0N3LDtuORcEJP0KXM',$,'Symbols','',.P_SINGLEVALUE.,'IfcURIReference',$,$,$,$,$,.READWRITE.);
+#15=IFCSIMPLEPROPERTYTEMPLATE('2sHDBuW7P4TROy$hL2w7ct',$,'Patterns','',.P_SINGLEVALUE.,'IfcURIReference',$,$,$,$,$,.READWRITE.);
 ENDSEC;
 END-ISO-10303-21;

src/blenderbim/blenderbim/bim/data/styles/default.css

@@ -31,10 +31,11 @@ text { fill: black; stroke: none; }
 .PredefinedType-SECTIONLEVEL { marker-start: url(#section-level-marker); stroke-dasharray: 12.5, 3, 3, 3; }
 .PredefinedType-PLANLEVEL { marker-end: url(#plan-level-marker); }
 .PredefinedType-DIMENSION { marker-start: url(#dimension-marker-start); marker-end: url(#dimension-marker-end); }
+.PredefinedType-ANGLE { marker-start: url(#angle-marker-start); marker-end: url(#angle-marker-end); }
 .PredefinedType-RADIUS { marker-end: url(#radius-marker-end); }
 .PredefinedType-DIAMETER { marker-start: url(#diameter-marker-start); marker-end: url(#diameter-marker-end); }
 .PredefinedType-HIDDENLINE { stroke-dasharray: 3, 2; }
-.PredefinedType-STAIR { marker-start: url(#stair-marker-start); marker-end: url(#stair-marker-end); }
+.PredefinedType-STAIRARROW { marker-start: url(#stair-marker-start); marker-end: url(#stair-marker-end); }
 .PredefinedType-BOUNDARY { fill: none; stroke: red; stroke-width: 1; stroke-dasharray: 12, 4, 3, 4, 3, 4; }
 .PredefinedType-BATTING { marker-start: url(#batting); stroke: none; }
 .PredefinedType-SEALANT { fill: url(#crosshatch1); stroke-width: 0.25; }

src/blenderbim/blenderbim/bim/data/templates/markers.svg

@@ -21,6 +21,18 @@
             <path d="M 0 3.5 L 0 10.5 L 10 7" class="annotation" style="fill:black;" />
         </g>
     </marker>
+    <marker id="angle-marker-start" markerHeight="14" markerWidth="11" orient="auto" refX="1" refY="7">
+        <g>
+            <path d="M 11 3.5 L 11 10.5 L 1 7" class="annotation" style="fill:black;" />
+            <path d="M 1 0 L 1 14" class="annotation" style="stroke-width:1;" />
+        </g>
+    </marker>
+    <marker id="angle-marker-end" markerHeight="14" markerWidth="11" orient="auto" refX="10" refY="7">
+        <g>
+            <path d="M 0 3.5 L 0 10.5 L 10 7" class="annotation" style="fill:black;" />
+            <path d="M 10 0 L 10 14" class="annotation" style="stroke-width:1;" />
+        </g>
+    </marker>
     <marker id="diameter-marker-start" markerHeight="14" markerWidth="11" orient="auto" refX="1" refY="7">
         <g>
             <path d="M 11 3.5 L 11 10.5 L 1 7" class="annotation" style="fill:black;" />

src/blenderbim/blenderbim/bim/export_ifc.py

@@ -97,6 +97,7 @@ class IfcExporter:
             except:
                 continue
             ifcopenshell.api.run("root.remove_product", self.file, **{"product": product})
+        IfcStore.deleted_ids.clear()
         return results
 
     def sync_all_objects(self):
@@ -148,7 +149,7 @@ class IfcExporter:
         return checksum != str([s.id() for s in tool.Geometry.get_styles(obj) if s])
 
     def sync_object_placement(self, obj):
-        if not self.has_object_moved(obj):
+        if not tool.Ifc.is_moved(obj):
             return
         blender_matrix = np.array(obj.matrix_world)
         element = self.file.by_id(obj.BIMObjectProperties.ifc_definition_id)
@@ -162,17 +163,6 @@ class IfcExporter:
         blenderbim.core.geometry.edit_object_placement(tool.Ifc, tool.Geometry, tool.Surveyor, obj=obj)
         return element
 
-    def has_object_moved(self, obj):
-        if not obj.BIMObjectProperties.location_checksum:
-            return True  # Let's be conservative
-        loc_check = np.frombuffer(eval(obj.BIMObjectProperties.location_checksum))
-        rot_check = np.frombuffer(eval(obj.BIMObjectProperties.rotation_checksum))
-        loc_real = np.array(obj.matrix_world.translation).flatten()
-        rot_real = np.array(obj.matrix_world.to_3x3()).flatten()
-        if np.allclose(loc_check, loc_real, atol=1e-4) and np.allclose(rot_check, rot_real, atol=1e-2):
-            return False
-        return True
-
     def sync_grid_axis_object_placement(self, obj, element):
         grid = (element.PartOfU or element.PartOfV or element.PartOfW)[0]
         grid_obj = tool.Ifc.get_object(grid)

src/blenderbim/blenderbim/bim/handler.py

@@ -26,6 +26,7 @@ from blenderbim.bim.module.drawing.prop import RasterStyleProperty
 from bpy.app.handlers import persistent
 from blenderbim.bim.ifc import IfcStore
 from blenderbim.bim.module.owner.prop import get_user_person, get_user_organisation
+from blenderbim.bim.module.model.data import AuthoringData
 from ifcopenshell.api.material.data import Data as MaterialData
 from ifcopenshell.api.type.data import Data as TypeData
 
@@ -301,3 +302,4 @@ def setDefaultProperties(scene):
         drawing_style.name = "Blender Default"
         drawing_style.render_type = "DEFAULT"
         bpy.ops.bim.save_drawing_style(index="2")
+        AuthoringData.type_thumbnails = {}

src/blenderbim/blenderbim/bim/helper.py

@@ -16,14 +16,17 @@
 # You should have received a copy of the GNU General Public License
 # along with BlenderBIM Add-on.  If not, see <http://www.gnu.org/licenses/>.
 
+# from datetime import date
 import bpy
 import json
 import math
 import zipfile
 import ifcopenshell
 import ifcopenshell.util.attribute
+from ifcopenshell.util.doc import get_attribute_doc, get_predefined_type_doc, get_property_doc
 from mathutils import geometry
 from mathutils import Vector
+import blenderbim.tool as tool
 from blenderbim.bim.ifc import IfcStore
 
 
@@ -38,11 +41,19 @@ def draw_attribute(attribute, layout, copy_operator=None):
     if not value_name:
         layout.label(text=attribute.name)
         return
-    layout.prop(
-        attribute,
-        value_name,
-        text=attribute.name,
-    )
+    if value_name == "enum_value":
+        prop_with_search(layout, attribute, "enum_value", text=attribute.name)
+    else:
+        layout.prop(
+            attribute,
+            value_name,
+            text=attribute.name,
+        )
+    if "ScheduleDuration" in attribute.name:
+        layout.prop(bpy.context.scene.BIMDuration, "duration_days", text="D")
+        layout.prop(bpy.context.scene.BIMDuration, "duration_hours", text="H")
+        layout.prop(bpy.context.scene.BIMDuration, "duration_minutes", text="M")
+
     if attribute.is_optional:
         layout.prop(attribute, "is_null", icon="RADIOBUT_OFF" if attribute.is_null else "RADIOBUT_ON", text="")
     if copy_operator:
@@ -74,7 +85,9 @@ def import_attribute(attribute, props, data, callback=None):
     new.is_null = data[attribute.name()] is None
     new.is_optional = attribute.optional()
     new.data_type = data_type if isinstance(data_type, str) else ""
+    new.ifc_class = data["type"]
     is_handled_by_callback = callback(attribute.name(), new, data) if callback else None
+
     if is_handled_by_callback:
         pass  # Our job is done
     elif is_handled_by_callback is False:
@@ -90,9 +103,49 @@ def import_attribute(attribute, props, data, callback=None):
     elif data_type == "float":
         new.float_value = 0.0 if new.is_null else data[attribute.name()]
     elif data_type == "enum":
-        new.enum_items = json.dumps(ifcopenshell.util.attribute.get_enum_items(attribute))
-        if data[attribute.name()]:
-            new.enum_value = data[attribute.name()]
+        enum_items = ifcopenshell.util.attribute.get_enum_items(attribute)
+        new.enum_items = json.dumps(enum_items)
+        add_attribute_enum_items_descriptions(new, enum_items)
+        if data[new.name]:
+            new.enum_value = data[new.name]
+    add_attribute_description(new)
+    add_attribute_min_max(new)
+
+
+ATTRIBUTE_MIN_MAX_CONSTRAINTS = {"IfcMaterialLayer": {"Priority": {"value_min": 0, "value_max": 100}}}
+
+
+def add_attribute_min_max(attribute_blender):
+    if attribute_blender.ifc_class in ATTRIBUTE_MIN_MAX_CONSTRAINTS:
+        constraints = ATTRIBUTE_MIN_MAX_CONSTRAINTS[attribute_blender.ifc_class].get(attribute_blender.name, {})
+        for constraint, value in constraints.items():
+            setattr(attribute_blender, constraint, value)
+
+
+def add_attribute_enum_items_descriptions(attribute_blender, enum_items):
+    attribute_blender.enum_descriptions.clear()
+    if isinstance(enum_items, dict):
+        enum_items = enum_items.keys()
+    version = tool.Ifc.get_schema()
+    for enum_item in enum_items:
+        new_enum_description = attribute_blender.enum_descriptions.add()
+        try:
+            description = get_predefined_type_doc(version, attribute_blender.ifc_class, enum_item)
+        except KeyError:  # TODO this only supports predefined type enums. Add support for other types of enums ?
+            description = ""
+        new_enum_description.name = description
+
+
+def add_attribute_description(attribute_blender):
+    if not attribute_blender.name:
+        return
+    version = tool.Ifc.get_schema()
+    try:
+        description = get_attribute_doc(version, attribute_blender.ifc_class, attribute_blender.name)
+    except RuntimeError:  # It's not an Entity Attribute. Let's try a Property Set attribute.
+        description = get_property_doc(version, attribute_blender.ifc_class, attribute_blender.name).get("description")
+    if description:
+        attribute_blender.description = description
 
 
 def export_attributes(props, callback=None):
@@ -105,6 +158,68 @@ def export_attributes(props, callback=None):
     return attributes
 
 
+def prop_with_search(layout, data, prop_name, **kwargs):
+    # kwargs are layout.prop arguments (text, icon, etc.)
+    row = layout.row(align=True)
+    row.prop(data, prop_name, **kwargs)
+    try:
+        if len(get_enum_items(data, prop_name)) > 10:
+            # Magick courtesy of https://blender.stackexchange.com/a/203443/86891
+            row.context_pointer_set(name="data", data=data)
+            op = row.operator("bim.enum_property_search", text="", icon="VIEWZOOM")
+            op.prop_name = prop_name
+    except TypeError:  # Prop is not iterable
+        pass
+
+
+def get_enum_items(data, prop_name, context=None):
+    # Retrieve items from a dynamic EnumProperty, which is otherwise not supported
+    # Or throws an error in the console when the items callback returns an empty list
+    # See https://blender.stackexchange.com/q/215781/86891
+    prop = data.__annotations__[prop_name]
+    items = prop.keywords.get("items")
+    if items is None:
+        return
+    if not isinstance(items, (list, tuple)):
+        # items are retrieved through a callback, not a static list :
+        items = items(data, context or bpy.context)
+    return items
+
+
+def get_obj_ifc_definition_id(context, obj, obj_type):
+    if obj_type == "Object":
+        return bpy.data.objects.get(obj).BIMObjectProperties.ifc_definition_id
+    elif obj_type == "Material":
+        return bpy.data.materials.get(obj).BIMObjectProperties.ifc_definition_id
+    elif obj_type == "Task":
+        return context.scene.BIMTaskTreeProperties.tasks[
+            context.scene.BIMWorkScheduleProperties.active_task_index
+        ].ifc_definition_id
+    elif obj_type == "Cost":
+        return context.scene.BIMCostProperties.cost_items[
+            context.scene.BIMCostProperties.active_cost_item_index
+        ].ifc_definition_id
+    elif obj_type == "Resource":
+        return context.scene.BIMResourceTreeProperties.resources[
+            context.scene.BIMResourceProperties.active_resource_index
+        ].ifc_definition_id
+    elif obj_type == "Profile":
+        return context.scene.BIMProfileProperties.profiles[
+            context.scene.BIMProfileProperties.active_profile_index
+        ].ifc_definition_id
+    elif obj_type == "WorkSchedule":
+        return context.scene.BIMWorkScheduleProperties.active_work_schedule_id
+
+
+# hack to close popup
+# https://blender.stackexchange.com/a/202576/130742
+def close_operator_panel(event):
+    x, y = event.mouse_x, event.mouse_y
+    bpy.context.window.cursor_warp(10, 10)
+    move_back = lambda: bpy.context.window.cursor_warp(x, y)
+    bpy.app.timers.register(move_back, first_interval=0.01)
+
+
 class IfcHeaderExtractor:
     def __init__(self, filepath: str):
         self.filepath = filepath

src/blenderbim/blenderbim/bim/ifc.py

@@ -39,6 +39,8 @@ class IfcStore:
     edited_objs = set()
     pset_template_path = ""
     pset_template_file = None
+    classification_path = ""
+    classification_file = None
     library_path = ""
     library_file = None
     element_listeners = set()
@@ -48,7 +50,7 @@ class IfcStore:
     last_transaction = ""
     history = []
     future = []
-    schema_identifiers = ["IFC4", "IFC2X3"]
+    schema_identifiers = ["IFC4", "IFC2X3", "IFC4X3"]
 
     @staticmethod
     def purge():
@@ -65,7 +67,10 @@ class IfcStore:
         IfcStore.pset_template_file = None
         IfcStore.library_path = ""
         IfcStore.library_file = None
-        IfcStore.schema_identifiers = ["IFC4", "IFC2X3"]
+        IfcStore.last_transaction = ""
+        IfcStore.history = []
+        IfcStore.future = []
+        IfcStore.schema_identifiers = ["IFC4", "IFC2X3", "IFC4X3"]
 
     @staticmethod
     def get_file():
@@ -220,7 +225,11 @@ class IfcStore:
             try:
                 value.name
             except:
-                obj = bpy.data.objects.get(IfcStore.undo_redo_stack_object_names[key])
+                # TODO not so sure about this obj_name check
+                obj_name = IfcStore.undo_redo_stack_object_names.get(key, None)
+                if not obj_name:
+                    continue
+                obj = bpy.data.objects.get(obj_name)
                 if not obj or not obj.BIMObjectProperties.ifc_definition_id:
                     continue
                 element = file.by_id(obj.BIMObjectProperties.ifc_definition_id)
@@ -229,23 +238,35 @@ class IfcStore:
                     data["guid"] = element.GlobalId
                 IfcStore.commit_link_element(data)
 
-
     @staticmethod
     def relink_all_objects():
-        file = IfcStore.get_file()
-        if not file:
+        if not IfcStore.get_file():
             return
         for obj in bpy.data.objects:
-            if not obj:
-                continue
-            if not obj.BIMObjectProperties.ifc_definition_id:
-                continue
-            element = file.by_id(obj.BIMObjectProperties.ifc_definition_id)
+            IfcStore.relink_object(obj)
+        for obj in bpy.data.materials:
+            IfcStore.relink_object(obj)
+
+    @staticmethod
+    def relink_object(obj):
+        if not obj:
+            return
+        if obj.BIMObjectProperties.ifc_definition_id:
+            try:
+                element = IfcStore.get_file().by_id(obj.BIMObjectProperties.ifc_definition_id)
+            except:
+                return
             data = {"id": element.id(), "obj": obj.name}
             if hasattr(element, "GlobalId"):
                 data["guid"] = element.GlobalId
             IfcStore.commit_link_element(data)
-
+        if hasattr(obj, "BIMMaterialProperties") and obj.BIMMaterialProperties.ifc_style_id:
+            try:
+                element = IfcStore.get_file().by_id(obj.BIMMaterialProperties.ifc_style_id)
+            except:
+                return
+            data = {"id": element.id(), "obj": obj.name}
+            IfcStore.commit_link_element(data)
 
     @staticmethod
     def delete_element(element):
@@ -266,6 +287,15 @@ class IfcStore:
 
     @staticmethod
     def link_element(element, obj):
+        existing_obj = IfcStore.id_map.get(element.id(), None)
+        if existing_obj == obj:
+            return
+        elif existing_obj:
+            try:
+                existing_obj.name
+                IfcStore.unlink_element(obj=existing_obj)
+            except:
+                pass
         IfcStore.id_map[element.id()] = obj
         if hasattr(element, "GlobalId"):
             IfcStore.guid_map[element.GlobalId] = obj
@@ -300,6 +330,8 @@ class IfcStore:
     @staticmethod
     def commit_link_element(data):
         obj = bpy.data.objects.get(data["obj"])
+        if not obj:
+            obj = bpy.data.materials.get(data["obj"])
         IfcStore.id_map[data["id"]] = obj
         if "guid" in data:
             IfcStore.guid_map[data["guid"]] = obj
@@ -310,6 +342,21 @@ class IfcStore:
         # TODO Listeners are not re-registered. Does this cause nasty problems to debug later on?
         # TODO We're handling id_map and guid_map, but what about edited_objs? This might cause big problems.
 
+    @staticmethod
+    def rollback_unlink_element(data):
+        if "id" not in data or "obj" not in data:
+            return
+        obj = bpy.data.objects.get(data["obj"])
+        IfcStore.id_map[data["id"]] = obj
+        if data["guid"]:
+            IfcStore.guid_map[data["guid"]] = obj
+
+    @staticmethod
+    def commit_unlink_element(data):
+        del IfcStore.id_map[data["id"]]
+        if data["guid"]:
+            del IfcStore.guid_map[data["guid"]]
+
     @staticmethod
     def unlink_element(element=None, obj=None):
         if element is None:
@@ -345,6 +392,17 @@ class IfcStore:
         elif obj:
             obj.BIMObjectProperties.ifc_definition_id = 0
 
+        if IfcStore.history:
+            data = {}
+            if element:
+                data["id"] = element.id()
+                data["guid"] = getattr(element, "GlobalId", None)
+            if obj:
+                data["obj"] = obj.name
+            IfcStore.history[-1]["operations"].append(
+                {"rollback": IfcStore.rollback_unlink_element, "commit": IfcStore.commit_unlink_element, "data": data}
+            )
+
     @staticmethod
     def execute_ifc_operator(operator, context):
         is_top_level_operator = not bool(IfcStore.current_transaction)

src/blenderbim/blenderbim/bim/import_ifc.py

@@ -121,7 +121,14 @@ class MaterialCreator:
     def parse_representation_item(self, item):
         if not item.StyledByItem:
             return
-        style_ids = [e.id() for e in self.ifc_importer.file.traverse(item.StyledByItem[0]) if e.is_a("IfcSurfaceStyle")]
+        style_ids = []
+        styles = list(item.StyledByItem[0].Styles)
+        while styles:
+            style = styles.pop()
+            if style.is_a("IfcSurfaceStyle"):
+                style_ids.append(style.id())
+            elif style.is_a("IfcPresentationStyleAssignment"):
+                styles.extend(style.Styles)
         if not style_ids:
             return
         for style_id in style_ids:
@@ -168,12 +175,13 @@ class IfcImporter:
         self.settings_native.set(self.settings_native.INCLUDE_CURVES, True)
         self.settings_2d = ifcopenshell.geom.settings()
         self.settings_2d.set(self.settings_2d.INCLUDE_CURVES, True)
+        self.settings_2d.set(self.settings.STRICT_TOLERANCE, True)
         self.project = None
+        self.has_existing_project = False
         self.collections = {}
         self.elements = set()
         self.type_collection = None
         self.type_products = {}
-        self.openings = {}
         self.meshes = {}
         self.mesh_shapes = {}
         self.time = 0
@@ -181,6 +189,7 @@ class IfcImporter:
         self.added_data = {}
         self.native_elements = set()
         self.native_data = {}
+        self.progress = 0
 
         self.material_creator = MaterialCreator(ifc_import_settings, self)
 
@@ -198,7 +207,6 @@ class IfcImporter:
 
     def execute(self):
         bpy.context.window_manager.progress_begin(0, 100)
-        self.progress = 0
         self.profile_code("Starting import process")
         self.load_file()
         self.profile_code("Loading file")
@@ -216,8 +224,6 @@ class IfcImporter:
         self.profile_code("Process context filter")
         self.create_collections()
         self.profile_code("Create collections")
-        self.create_openings_collection()
-        self.profile_code("Create opening collection")
         self.create_materials()
         self.profile_code("Create materials")
         self.create_styles()
@@ -236,24 +242,19 @@ class IfcImporter:
         self.profile_code("Create spatial elements")
         self.create_structural_items()
         self.profile_code("Create structural items")
-        self.create_type_products()
-        self.profile_code("Create type products")
+        if not self.ifc_import_settings.is_coordinating:
+            self.create_element_types()
+            self.profile_code("Create element types")
         self.place_objects_in_collections()
         self.profile_code("Place objects in collections")
-        if self.ifc_import_settings.should_merge_by_class:
-            self.merge_by_class()
-            self.profile_code("Merging by class")
-        elif self.ifc_import_settings.should_merge_by_material:
-            self.merge_by_material()
-            self.profile_code("Merging by material")
-        if self.ifc_import_settings.should_merge_materials_by_colour or len(self.material_creator.materials) > 300:
-            self.merge_materials_by_colour()
-            self.profile_code("Merging by colour")
         self.add_project_to_scene()
         self.profile_code("Add project to scene")
         if self.ifc_import_settings.should_clean_mesh and len(self.file.by_type("IfcElement")) < 1000:
             self.clean_mesh()
             self.profile_code("Mesh cleaning")
+        if self.ifc_import_settings.should_merge_materials_by_colour or len(self.material_creator.materials) > 300:
+            self.merge_materials_by_colour()
+            self.profile_code("Merging by colour")
         self.set_default_context()
         self.profile_code("Setting default context")
         self.update_progress(100)
@@ -269,7 +270,9 @@ class IfcImporter:
 
     def is_point_far_away(self, point, is_meters=True):
         # Locations greater than 1km are not considered "small sites" according to the georeferencing guide
-        limit = 1000 if is_meters else (1000 / self.unit_scale)
+        # Users can configure this if they have to handle larger sites but beware of surveying precision
+        limit = self.ifc_import_settings.distance_limit
+        limit = limit if is_meters else (limit / self.unit_scale)
         coords = point
         if hasattr(point, "Coordinates"):
             coords = point.Coordinates
@@ -304,14 +307,37 @@ class IfcImporter:
             self.settings_2d.set_context_ids(self.plan_contexts)
 
     def process_element_filter(self):
+        offset = self.ifc_import_settings.element_offset
+        offset_limit = offset + self.ifc_import_settings.element_limit
+
         if self.ifc_import_settings.has_filter:
-            self.elements = set(self.ifc_import_settings.elements)
+            self.elements = self.ifc_import_settings.elements
+            if isinstance(self.elements, set):
+                self.elements = list(self.elements)
             # TODO: enable filtering for annotations
             self.annotations = set(self.file.by_type("IfcAnnotation"))
         else:
-            self.elements = set(self.file.by_type("IfcElement"))
+            self.elements = self.file.by_type("IfcElement")
             self.annotations = set(self.file.by_type("IfcAnnotation"))
 
+        self.elements = [e for e in self.elements if not e.is_a("IfcFeatureElement")]
+        if self.ifc_import_settings.is_coordinating:
+            self.elements = [e for e in self.elements if e.Representation]
+
+        self.elements = set(self.elements[offset:offset_limit])
+
+        if self.ifc_import_settings.has_filter or offset or offset_limit < len(self.elements):
+            self.element_types = set([ifcopenshell.util.element.get_type(e) for e in self.elements])
+        else:
+            if self.file.schema in ("IFC2X3", "IFC4"):
+                self.element_types = set(
+                    self.file.by_type("IfcElementType")
+                    + self.file.by_type("IfcDoorStyle")
+                    + self.file.by_type("IfcWindowStyle")
+                )
+            else:
+                self.element_types = set(self.file.by_type("IfcElementType"))
+
         if self.ifc_import_settings.has_filter and self.ifc_import_settings.should_filter_spatial_elements:
             self.spatial_elements = self.get_spatial_elements_filtered_by_elements(self.elements)
         else:
@@ -354,21 +380,38 @@ class IfcImporter:
                 "type": "IfcSweptDiskSolid",
             }
             return True
+
+        if not self.ifc_import_settings.should_use_native_meshes:
+            return False  # Performance improvements only occur on edge cases currently
+
         # FacetedBreps (without voids) are meshes. See #841.
-        # Commented out as seems currently too slow.
-        # if self.is_native_faceted_brep(representations):
-        #    self.native_data[element.GlobalId] = {
-        #        "representations": representations,
-        #        "representation": self.get_body_representation(element.Representation.Representations),
-        #        "type": "IfcFacetedBrep",
-        #    }
-        #    return True
+        if self.is_native_faceted_brep(representations):
+            self.native_data[element.GlobalId] = {
+                "representations": representations,
+                "representation": self.get_body_representation(element.Representation.Representations),
+                "type": "IfcFacetedBrep",
+            }
+            return True
+
+        if self.is_native_face_based_surface_model(representations):
+            self.native_data[element.GlobalId] = {
+                "representations": representations,
+                "representation": self.get_body_representation(element.Representation.Representations),
+                "type": "IfcFaceBasedSurfaceModel",
+            }
+            return True
 
     def is_native_swept_disk_solid(self, representations):
         for representation in representations:
             items = representation["raw"].Items or []  # Be forgiving of invalid IFCs because Revit :(
             if len(items) == 1 and items[0].is_a("IfcSweptDiskSolid"):
                 return True
+            elif len(items) and ( # See #2508 why we accommodate for invalid IFCs here
+                items[0].is_a("IfcSweptDiskSolid")
+                and len({i.is_a() for i in items}) == 1
+                and len({i.Radius for i in items}) == 1
+            ):
+                return True
         return False
 
     def is_native_faceted_brep(self, representations):
@@ -378,6 +421,13 @@ class IfcImporter:
                     return False
         return True
 
+    def is_native_face_based_surface_model(self, representations):
+        for representation in representations:
+            for i in representation["raw"].Items:
+                if i.is_a() != "IfcFaceBasedSurfaceModel":
+                    return False
+        return True
+
     def get_products_from_shape_representation(self, element):
         products = [pr.ShapeOfProduct[0] for pr in element.OfProductRepresentation]
         for rep_map in element.RepresentationMap:
@@ -391,7 +441,7 @@ class IfcImporter:
         props = bpy.context.scene.BIMGeoreferenceProperties
         if props.has_blender_offset:
             return
-        if self.ifc_import_settings.should_offset_model:
+        if self.ifc_import_settings.false_origin:
             return self.set_manual_blender_offset()
         if self.file.schema == "IFC2X3":
             project = self.file.by_type("IfcProject")[0]
@@ -407,9 +457,9 @@ class IfcImporter:
 
     def set_manual_blender_offset(self):
         props = bpy.context.scene.BIMGeoreferenceProperties
-        props.blender_eastings = str(self.ifc_import_settings.model_offset_coordinates[0])
-        props.blender_northings = str(self.ifc_import_settings.model_offset_coordinates[1])
-        props.blender_orthogonal_height = str(self.ifc_import_settings.model_offset_coordinates[2])
+        props.blender_eastings = str(self.ifc_import_settings.false_origin[0])
+        props.blender_northings = str(self.ifc_import_settings.false_origin[1])
+        props.blender_orthogonal_height = str(self.ifc_import_settings.false_origin[2])
         props.has_blender_offset = True
 
     def guess_georeferencing(self, element):
@@ -518,6 +568,9 @@ class IfcImporter:
             if grid.Representation:
                 shape = ifcopenshell.geom.create_shape(self.settings_2d, grid)
             grid_obj = self.create_product(grid, shape)
+            if bpy.context.preferences.addons["blenderbim"].preferences.lock_grids_on_import:
+                grid_obj.lock_location = (True, True, True)
+                grid_obj.lock_rotation = (True, True, True)
             collection = bpy.data.collections.new(self.get_name(grid))
             u_axes = bpy.data.collections.new("UAxes")
             collection.children.link(u_axes)
@@ -535,23 +588,20 @@ class IfcImporter:
             shape = ifcopenshell.geom.create_shape(self.settings_2d, axis.AxisCurve)
             mesh = self.create_mesh(axis, shape)
             obj = bpy.data.objects.new(f"IfcGridAxis/{axis.AxisTag}", mesh)
+            if bpy.context.preferences.addons["blenderbim"].preferences.lock_grids_on_import:
+                obj.lock_location = (True, True, True)
+                obj.lock_rotation = (True, True, True)
             self.link_element(axis, obj)
             self.set_matrix_world(obj, grid_obj.matrix_world)
             grid_collection.objects.link(obj)
 
-    def create_type_products(self):
-        # TODO allow filtering of spatial elements too
-        if self.ifc_import_settings.has_filter:
-            type_products = set([ifcopenshell.util.element.get_type(e) for e in self.elements])
-        else:
-            type_products = self.file.by_type("IfcTypeProduct")
-
-        for type_product in type_products:
-            if not type_product:
+    def create_element_types(self):
+        for element_type in self.element_types:
+            if not element_type:
                 continue
-            self.create_type_product(type_product)
+            self.create_element_type(element_type)
 
-    def create_type_product(self, element):
+    def create_element_type(self, element):
         self.ifc_import_settings.logger.info("Creating object %s", element)
         representation_map = self.get_type_product_body_representation_map(element)
         mesh = None
@@ -585,13 +635,20 @@ class IfcImporter:
                 return representation_map
 
     def create_native_elements(self):
-        total = 0
+        progress = 0
         checkpoint = time.time()
+        total = len(self.native_elements)
         for element in self.native_elements:
-            total += 1
-            if total % 250 == 0:
-                print("{} elements processed in {:.2f}s ...".format(total, time.time() - checkpoint))
+            progress += 1
+            if progress % 250 == 0:
+                percent = round(progress / total * 100)
+                print(
+                    "{} / {} ({}%) elements processed in {:.2f}s ...".format(
+                        progress, total, percent, time.time() - checkpoint
+                    )
+                )
                 checkpoint = time.time()
+                self.incrementally_merge_objects()
             native_data = self.native_data[element.GlobalId]
             representation = native_data["representation"]
             if not representation:
@@ -604,6 +661,8 @@ class IfcImporter:
                     mesh = self.create_native_swept_disk_solid(element, mesh_name)
                 elif native_data["type"] == "IfcFacetedBrep":
                     mesh = self.create_native_faceted_brep(element, mesh_name)
+                elif native_data["type"] == "IfcFaceBasedSurfaceModel":
+                    mesh = self.create_native_faceted_brep(element, mesh_name)
                 mesh.BIMMeshProperties.ifc_definition_id = representation.id()
                 mesh.name = mesh_name
                 self.meshes[mesh_name] = mesh
@@ -643,34 +702,40 @@ class IfcImporter:
             )
         else:
             iterator = ifcopenshell.geom.iterator(self.settings, self.file, include=products)
-        cache = IfcStore.get_cache()
-        if cache:
-            iterator.set_cache(cache)
+        if self.ifc_import_settings.should_cache:
+            cache = IfcStore.get_cache()
+            if cache:
+                iterator.set_cache(cache)
         valid_file = iterator.initialize()
         if not valid_file:
             return results
         checkpoint = time.time()
-        total = 0
+        progress = 0
+        total = len(products)
         start_progress = self.progress
         progress_range = 85 - start_progress
         while True:
-            total += 1
-            if total % 250 == 0:
+            progress += 1
+            if progress % 250 == 0:
+                percent_created = round(progress / total * 100)
+                percent_preprocessed = iterator.progress()
+                percent_average = (percent_created + percent_preprocessed) / 2
                 print(
-                    "{} ({}%) elements processed in {:.2f}s ...".format(
-                        total, iterator.progress(), time.time() - checkpoint
+                    "{} / {} ({}% created, {}% preprocessed) elements processed in {:.2f}s ...".format(
+                        progress, total, percent_created, percent_preprocessed, time.time() - checkpoint
                     )
                 )
                 checkpoint = time.time()
-                self.update_progress((iterator.progress() / 100 * progress_range) + start_progress)
+                self.update_progress((percent_average / 100 * progress_range) + start_progress)
+                self.incrementally_merge_objects()
             shape = iterator.get()
             if shape:
-                product = self.file.by_id(shape.guid)
+                product = self.file.by_id(shape.id)
                 if self.body_contexts:
                     self.create_product(product, shape)
                     results.add(product)
                 else:
-                    if shape.context not in ["Body", "Facetation"] and IfcStore.get_element(shape.guid):
+                    if shape.context not in ["Body", "Facetation"] and IfcStore.get_element(shape.id):
                         # We only load a single context, and we prioritise the Body context. See #1290.
                         pass
                     else:
@@ -681,6 +746,19 @@ class IfcImporter:
         print("Done creating geometry")
         return results
 
+    def incrementally_merge_objects(self):
+        if not self.ifc_import_settings.is_coordinating:
+            return
+        if self.ifc_import_settings.merge_mode == "IFC_CLASS":
+            self.merge_by_class()
+            self.profile_code("Merging by class")
+        elif self.ifc_import_settings.merge_mode == "IFC_TYPE":
+            self.merge_by_type()
+            self.profile_code("Merging by type")
+        elif self.ifc_import_settings.merge_mode == "MATERIAL":
+            self.merge_by_material()
+            self.profile_code("Merging by material")
+
     def create_structural_items(self):
         # Create structural collections
         self.structural_member_collection = bpy.data.collections.new("Members")
@@ -791,9 +869,10 @@ class IfcImporter:
             )
         else:
             iterator = ifcopenshell.geom.iterator(self.settings_2d, self.file, include=products)
-        cache = IfcStore.get_cache()
-        if cache:
-            iterator.set_cache(cache)
+        if self.ifc_import_settings.should_cache:
+            cache = IfcStore.get_cache()
+            if cache:
+                iterator.set_cache(cache)
         valid_file = iterator.initialize()
         if not valid_file:
             return results
@@ -806,8 +885,8 @@ class IfcImporter:
                 checkpoint = time.time()
             shape = iterator.get()
             if shape:
-                product = self.file.by_id(shape.guid)
-                self.create_product(self.file.by_id(shape.guid), shape)
+                product = self.file.by_id(shape.id)
+                self.create_product(product, shape)
                 results.add(product)
             if not iterator.next():
                 break
@@ -818,6 +897,11 @@ class IfcImporter:
         if element is None:
             return
 
+        if self.has_existing_project:
+            obj = tool.Ifc.get_object(element)
+            if obj:
+                return obj
+
         self.ifc_import_settings.logger.info("Creating object %s", element)
 
         if mesh:
@@ -825,7 +909,7 @@ class IfcImporter:
         elif element.is_a("IfcAnnotation") and element.ObjectType == "DRAWING":
             mesh = self.create_camera(element, shape)
             self.link_mesh(shape, mesh)
-        elif element.is_a("IfcAnnotation") and self.is_curve_annotation(element):
+        elif element.is_a("IfcAnnotation") and self.is_curve_annotation(element) and shape:
             mesh = self.create_curve(element, shape)
             self.link_mesh(shape, mesh)
         elif shape:
@@ -855,17 +939,18 @@ class IfcImporter:
         elif hasattr(element, "ObjectPlacement"):
             self.set_matrix_world(obj, self.apply_blender_offset_to_matrix_world(obj, self.get_element_matrix(element)))
 
-        self.add_opening_relation(element, obj)
-
-        if element.is_a("IfcOpeningElement"):
-            obj.display_type = "WIRE"
         return obj
 
     def get_representation_item_material_name(self, item):
         if not item.StyledByItem:
             return
-        style_ids = [e.id() for e in self.file.traverse(item.StyledByItem[0]) if e.is_a("IfcSurfaceStyle")]
-        return style_ids[0] if style_ids else None
+        styles = list(item.StyledByItem[0].Styles)
+        while styles:
+            style = styles.pop()
+            if style.is_a("IfcSurfaceStyle"):
+                return style.id()
+            elif style.is_a("IfcPresentationStyleAssignment"):
+                styles.extend(style.Styles)
 
     def create_native_faceted_brep(self, element, mesh_name):
         # TODO: georeferencing?
@@ -914,22 +999,32 @@ class IfcImporter:
             self.convert_representation(item.MappingSource.MappedRepresentation)
         elif item.is_a() == "IfcFacetedBrep":
             self.convert_representation_item_faceted_brep(item)
+        elif item.is_a() == "IfcFaceBasedSurfaceModel":
+            self.convert_representation_item_face_based_surface_model(item)
+
+    def convert_representation_item_face_based_surface_model(self, item):
+        mesh = item.get_info_2(recursive=True)
+        for face_set in mesh["FbsmFaces"]:
+            self.convert_representation_item_face_set(item, face_set)
 
     def convert_representation_item_faceted_brep(self, item):
+        mesh = item.get_info_2(recursive=True)
+        return self.convert_representation_item_face_set(item, mesh["Outer"])
+
+    def convert_representation_item_face_set(self, item, mesh):
         # On a few occasions, we flatten a list. This seems to be the most efficient way to do it.
         # https://stackoverflow.com/questions/20112776/how-do-i-flatten-a-list-of-lists-nested-lists
-        mesh = item.get_info_2(recursive=True)
 
         # For huge face sets it might be better to do a "flatmap" instead of sum()
         # bounds = sum((f["Bounds"] for f in mesh["Outer"]["CfsFaces"] if len(f["Bounds"]) == 1), ())
-        bounds = tuple(chain.from_iterable(f["Bounds"] for f in mesh["Outer"]["CfsFaces"] if len(f["Bounds"]) == 1))
+        bounds = tuple(chain.from_iterable(f["Bounds"] for f in mesh["CfsFaces"] if len(f["Bounds"]) == 1))
         # Here are some untested alternatives, are they faster?
         # bounds = tuple((f["Bounds"] for f in mesh["Outer"]["CfsFaces"] if len(f["Bounds"]) == 1))[0]
         # bounds = chain.from_iterable(f["Bounds"] for f in mesh["Outer"]["CfsFaces"] if len(f["Bounds"]) == 1)
 
         polygons = [[(p["id"], p["Coordinates"]) for p in b["Bound"]["Polygon"]] for b in bounds]
 
-        for face in mesh["Outer"]["CfsFaces"]:
+        for face in mesh["CfsFaces"]:
             # Blender cannot handle faces with holes.
             if len(face["Bounds"]) > 1:
                 inner_bounds = []
@@ -1027,6 +1122,7 @@ class IfcImporter:
                     polyline.points[-1].co = representation["matrix"] @ mathutils.Vector(v2)
 
         curve.bevel_depth = self.unit_scale * item.Radius
+        curve.use_fill_caps = True
         return curve
 
     def create_native_annotation(self, element, mesh_name):
@@ -1059,33 +1155,74 @@ class IfcImporter:
 
     def merge_by_class(self):
         merge_set = {}
-        for obj in self.added_data.values():
-            if not isinstance(obj, bpy.types.Object):
+        id_set = {}
+        for ifc_definition_id, obj in self.added_data.items():
+            if not isinstance(obj, bpy.types.Object) or not obj.data:
                 continue
-            if "/" not in obj.name or "IfcRelAggregates" in obj.users_collection[0].name:
+            element = self.file.by_id(ifc_definition_id)
+            if not element.is_a("IfcElement"):
                 continue
-            merge_set.setdefault(obj.name.split("/")[0], []).append(obj)
-        self.merge_objects(merge_set)
+            merge_set.setdefault(element.is_a(), []).append(obj)
+            id_set.setdefault(element.is_a(), []).append(ifc_definition_id)
+        self.merge_objects(merge_set, id_set)
+
+    def merge_by_type(self):
+        merge_set = {}
+        id_set = {}
+        for ifc_definition_id, obj in self.added_data.items():
+            if not isinstance(obj, bpy.types.Object) or not obj.data:
+                continue
+            element = self.file.by_id(ifc_definition_id)
+            if not element.is_a("IfcElement"):
+                continue
+            element_type = ifcopenshell.util.element.get_type(element)
+            if not element_type:
+                continue
+            merge_key = str(element_type.id()) + "-" + element_type.Name or "Unnamed"
+            merge_set.setdefault(merge_key, []).append(obj)
+            id_set.setdefault(merge_key, []).append(ifc_definition_id)
+        self.merge_objects(merge_set, id_set)
 
     def merge_by_material(self):
         merge_set = {}
-        for obj in self.added_data.values():
-            if not isinstance(obj, bpy.types.Object):
+        id_set = {}
+        for ifc_definition_id, obj in self.added_data.items():
+            if not isinstance(obj, bpy.types.Object) or not obj.data:
                 continue
-            if "/" not in obj.name or "IfcRelAggregates" in obj.users_collection[0].name:
+            element = self.file.by_id(ifc_definition_id)
+            if not element.is_a("IfcElement"):
                 continue
-            if not obj.material_slots:
-                merge_set.setdefault("no-material", []).append(obj)
-            else:
-                merge_set.setdefault(obj.material_slots[0].name, []).append(obj)
-        self.merge_objects(merge_set)
+            merge_key = obj.material_slots[0].name if obj.material_slots else "no-material"
+            merge_set.setdefault(merge_key, []).append(obj)
+            id_set.setdefault(merge_key, []).append(ifc_definition_id)
+        self.merge_objects(merge_set, id_set)
 
-    def merge_objects(self, merge_set):
-        for ifc_class, objs in merge_set.items():
-            context_override = {}
-            context_override["object"] = context_override["active_object"] = objs[0]
-            context_override["selected_objects"] = context_override["selected_editable_objects"] = objs
-            bpy.ops.object.join(context_override)
+    def merge_objects(self, merge_set, id_set):
+        total_objs = sum([len(o) for o in merge_set.values()])
+        cumulative_total = 0
+        merge_set = {k: v for k, v in sorted(merge_set.items(), key=lambda i: len(i[1]), reverse=True)}
+        for group_name, objs in merge_set.items():
+            total_group_objs = len(objs)
+            if total_group_objs < 10:
+                continue
+            merge_potential = total_objs - cumulative_total
+            if merge_potential < 250:
+                print("Merge target achieved")
+                return
+            cumulative_total += total_group_objs
+            print(f"Merging {total_group_objs} objects, {merge_potential} potentially remaining -", group_name)
+            try:
+                target = objs[0]
+                target.data = target.data.copy()
+                context_override = {}
+                context_override["object"] = context_override["active_object"] = target
+                context_override["selected_objects"] = context_override["selected_editable_objects"] = objs
+                bpy.ops.object.join(context_override)
+                target.data.name += "-merge"
+                for ifc_definition_id in id_set[group_name][1:]:
+                    del self.added_data[ifc_definition_id]
+            except:
+                print("Merge failed")
 
     def merge_materials_by_colour(self):
         cleaned_materials = {}
@@ -1117,7 +1254,6 @@ class IfcImporter:
             # Occurs when reloading a project
             pass
         project_collection = bpy.context.view_layer.layer_collection.children[self.project["blender"].name]
-        project_collection.children[self.opening_collection.name].hide_viewport = True
         project_collection.children[self.type_collection.name].hide_viewport = True
 
     def clean_mesh(self):
@@ -1140,11 +1276,6 @@ class IfcImporter:
         bpy.ops.object.editmode_toggle(context_override)
         IfcStore.edited_objs.clear()
 
-    def add_opening_relation(self, element, obj):
-        if not element.is_a("IfcOpeningElement"):
-            return
-        self.openings[element.GlobalId] = obj
-
     def load_file(self):
         self.ifc_import_settings.logger.info("loading file %s", self.ifc_import_settings.input_file)
         if not bpy.context.scene.BIMProperties.ifc_file:
@@ -1184,7 +1315,13 @@ class IfcImporter:
                 )
 
     def create_project(self):
-        self.project = {"ifc": self.file.by_type("IfcProject")[0]}
+        project = self.file.by_type("IfcProject")[0]
+        self.project = {"ifc": project}
+        obj = tool.Ifc.get_object(project)
+        if obj:
+            self.project["blender"] = obj.users_collection[0]
+            self.has_existing_project = True
+            return
         self.project["blender"] = bpy.data.collections.new(
             "{}/{}".format(self.project["ifc"].is_a(), self.project["ifc"].Name)
         )
@@ -1237,10 +1374,17 @@ class IfcImporter:
         for element in related_objects:
             if element not in self.spatial_elements:
                 continue
-            global_id = element.GlobalId
-            collection = bpy.data.collections.new(self.get_name(element))
-            self.collections[global_id] = collection
-            parent.children.link(collection)
+            is_existing = False
+            if self.has_existing_project:
+                obj = tool.Ifc.get_object(element)
+                if obj:
+                    is_existing = True
+                    collection = obj.users_collection[0]
+                    self.collections[element.GlobalId] = collection
+            if not is_existing:
+                collection = bpy.data.collections.new(self.get_name(element))
+                self.collections[element.GlobalId] = collection
+                parent.children.link(collection)
             if element.IsDecomposedBy:
                 for rel_aggregate in element.IsDecomposedBy:
                     self.create_spatial_decomposition_collection(collection, rel_aggregate.RelatedObjects)
@@ -1275,10 +1419,6 @@ class IfcImporter:
             if parent:
                 self.collections[parent.GlobalId].children.link(aggregate["collection"])
 
-    def create_openings_collection(self):
-        self.opening_collection = bpy.data.collections.new("IfcOpeningElements")
-        self.project["blender"].children.link(self.opening_collection)
-
     def create_materials(self):
         for material in self.file.by_type("IfcMaterial"):
             self.create_material(material)
@@ -1295,11 +1435,18 @@ class IfcImporter:
 
         for material_definition_representation in self.file.by_type("IfcMaterialDefinitionRepresentation"):
             material = material_definition_representation.RepresentedMaterial
+            blender_material = self.material_creator.materials[material.id()]
             for representation in material_definition_representation.Representations:
-                for style in [e for e in self.file.traverse(representation) if e.is_a("IfcSurfaceStyle")]:
-                    blender_material = self.material_creator.materials[material.id()]
-                    self.create_style(style, blender_material)
-                    parsed_styles.add(style.id())
+                styles = []
+                for styled_item in representation.Items:
+                    styles.extend(styled_item.Styles)
+                while styles:
+                    style = styles.pop()
+                    if style.is_a("IfcSurfaceStyle"):
+                        self.create_style(style, blender_material)
+                        parsed_styles.add(style.id())
+                    elif style.is_a("IfcPresentationStyleAssignment"):
+                        styles.extend(style.Styles)
 
         for style in self.file.by_type("IfcSurfaceStyle"):
             if style.id() in parsed_styles:
@@ -1348,13 +1495,21 @@ class IfcImporter:
         if surface_style.ReflectanceMethod in ["PHYSICAL", "NOTDEFINED"]:
             blender_material.use_nodes = True
             bsdf = blender_material.node_tree.nodes["Principled BSDF"]
-            if surface_style.DiffuseColour and surface_style.DiffuseColour.is_a("IfcColourRgb"):
-                bsdf.inputs["Base Color"].default_value = (
-                    surface_style.DiffuseColour.Red,
-                    surface_style.DiffuseColour.Green,
-                    surface_style.DiffuseColour.Blue,
-                    1,
-                )
+            if surface_style.DiffuseColour:
+                if surface_style.DiffuseColour.is_a("IfcColourRgb"):
+                    bsdf.inputs["Base Color"].default_value = (
+                        surface_style.DiffuseColour.Red,
+                        surface_style.DiffuseColour.Green,
+                        surface_style.DiffuseColour.Blue,
+                        1,
+                    )
+                elif surface_style.DiffuseColour.is_a("IfcNormalisedRatioMeasure"):
+                    bsdf.inputs["Base Color"].default_value = (
+                        surface_style.SurfaceColour.Red * surface_style.DiffuseColour.wrappedValue,
+                        surface_style.SurfaceColour.Green * surface_style.DiffuseColour.wrappedValue,
+                        surface_style.SurfaceColour.Blue * surface_style.DiffuseColour.wrappedValue,
+                        1,
+                    )
             if surface_style.SpecularColour and surface_style.SpecularColour.is_a("IfcNormalisedRatioMeasure"):
                 bsdf.inputs["Metallic"].default_value = surface_style.SpecularColour.wrappedValue
             if surface_style.SpecularHighlight and surface_style.SpecularHighlight.is_a("IfcSpecularRoughness"):
@@ -1516,8 +1671,6 @@ class IfcImporter:
             return self.collections[element.GlobalId].objects.link(obj)
         elif element.is_a("IfcTypeObject"):
             return self.type_collection.objects.link(obj)
-        elif element.is_a("IfcOpeningElement"):
-            return self.opening_collection.objects.link(obj)
         elif element.is_a("IfcStructuralMember"):
             return self.structural_member_collection.objects.link(obj)
         elif element.is_a("IfcStructuralConnection"):
@@ -1828,7 +1981,7 @@ class IfcImporter:
     def set_default_context(self):
         for subcontext in self.file.by_type("IfcGeometricRepresentationSubContext"):
             if subcontext.ContextIdentifier == "Body":
-                bpy.context.scene.BIMProperties.contexts = str(subcontext.id())
+                bpy.context.scene.BIMRootProperties.contexts = str(subcontext.id())
                 break
 
     def link_element(self, element, obj):
@@ -1857,14 +2010,18 @@ class IfcImportSettings:
         self.input_file = None
         self.diff_file = None
         self.should_use_cpu_multiprocessing = True
-        self.should_merge_by_class = False
-        self.should_merge_by_material = False
+        self.merge_mode = None
         self.should_merge_materials_by_colour = False
+        self.should_use_native_meshes = False
         self.should_clean_mesh = True
+        self.should_cache = True
+        self.is_coordinating = True
         self.deflection_tolerance = 0.001
         self.angular_tolerance = 0.5
-        self.should_offset_model = False
-        self.model_offset_coordinates = (0, 0, 0)
+        self.distance_limit = 1000
+        self.false_origin = None
+        self.element_offset = 0
+        self.element_limit = 30000
         self.has_filter = None
         self.should_filter_spatial_elements = True
         self.elements = set()
@@ -1882,16 +2039,18 @@ class IfcImportSettings:
         settings.diff_file = scene_diff.diff_json_file
         settings.collection_mode = props.collection_mode
         settings.should_use_cpu_multiprocessing = props.should_use_cpu_multiprocessing
-        settings.should_merge_by_class = props.should_merge_by_class
-        settings.should_merge_by_material = props.should_merge_by_material
+        settings.merge_mode = props.merge_mode
         settings.should_merge_materials_by_colour = props.should_merge_materials_by_colour
+        settings.should_use_native_meshes = props.should_use_native_meshes
         settings.should_clean_mesh = props.should_clean_mesh
+        settings.should_cache = props.should_cache
+        settings.is_coordinating = props.is_coordinating
         settings.deflection_tolerance = props.deflection_tolerance
         settings.angular_tolerance = props.angular_tolerance
-        settings.should_offset_model = props.should_offset_model
-        settings.model_offset_coordinates = (
-            [float(o) for o in props.model_offset_coordinates.split(",")]
-            if props.model_offset_coordinates
-            else (0, 0, 0)
-        )
+        settings.distance_limit = props.distance_limit
+        settings.false_origin = [float(o) for o in props.false_origin.split(",")] if props.false_origin else None
+        if settings.false_origin == [0, 0, 0]:
+            settings.false_origin = None
+        settings.element_offset = props.element_offset
+        settings.element_limit = props.element_limit
         return settings

src/blenderbim/blenderbim/bim/module/bcf/operator.py

@@ -768,6 +768,8 @@ class ActivateBcfViewpoint(bpy.types.Operator):
         bcfxml = bcfstore.BcfStore.get_bcfxml()
         props = context.scene.BCFProperties
         blender_topic = props.active_topic
+        if blender_topic is None:
+            return False
         topic = bcfxml.topics[blender_topic.name]
         return topic.viewpoints
 
@@ -880,7 +882,7 @@ class ActivateBcfViewpoint(bpy.types.Operator):
         # Operators with context overrides are used because they are
         # significantly faster than looping through all objects
 
-        exception_global_ids = [v.ifc_guid for v in viewpoint.components.visibility.exceptions]
+        exception_global_ids = {v.ifc_guid for v in viewpoint.components.visibility.exceptions}
 
         if viewpoint.components.visibility.default_visibility:
             old = context.area.type

src/blenderbim/blenderbim/bim/module/bcf/prop.py

@@ -95,7 +95,7 @@ def getBcfViewpoints(self, context, force_update=False):
         props = context.scene.BCFProperties
         bcfxml = bcfstore.BcfStore.get_bcfxml()
         topic = props.active_topic
-        viewpoints = bcfxml.get_viewpoints(topic.name)
+        viewpoints = bcfxml.get_viewpoints(topic.name) if topic else {}
         bcfviewpoints_enum.extend([(v, f"Viewpoint {i+1}", "") for i, v in enumerate(viewpoints.keys())])
     return bcfviewpoints_enum
 

src/blenderbim/blenderbim/bim/module/bimtester/prop.py

@@ -62,7 +62,7 @@ def refreshScenarios(self, context):
 
 
 class BimTesterProperties(PropertyGroup):
-    feature: StringProperty(default="", name="Feature / IDS", update=refreshScenarios)
+    feature: StringProperty(default="", name="Feature", update=refreshScenarios)
     steps: StringProperty(default="", name="Custom Steps")
     ifc_file: StringProperty(default="", name="IFC File")
     audit_ifc_class: EnumProperty(items=get_ifc_classes, name="Audit Class")

src/blenderbim/blenderbim/bim/module/boundary/operator.py

@@ -49,7 +49,7 @@ class Loader:
         if not boundary.ConnectionGeometry:
             return None
         surface = boundary.ConnectionGeometry.SurfaceOnRelatingElement
-        # workaround for unvalid geometry provided by Revit. See https://github.com/IfcOpenShell/IfcOpenShell/issues/635#issuecomment-770366838
+        # workaround for invalid geometry provided by Revit. See https://github.com/IfcOpenShell/IfcOpenShell/issues/635#issuecomment-770366838
         if surface.is_a("IfcCurveBoundedPlane") and not getattr(surface, "InnerBoundaries", None):
             surface.InnerBoundaries = ()
         shape = ifcopenshell.geom.create_shape(self.settings, surface)

src/blenderbim/blenderbim/bim/module/boundary/ui.py

@@ -101,7 +101,7 @@ class BIM_PT_Boundary(Panel):
             entity = getattr(boundary, ifc_attribute)
             if entity:
                 row.label(text=f"{entity.is_a()}/{entity.Name}")
-                op = row.operator("bim.select_global_id", text="", icon="TRACKER")
+                op = row.operator("bim.select_global_id", text="", icon="OBJECT_DATA")
                 op.global_id = entity.GlobalId
             else:
                 row.label(text="")

src/blenderbim/blenderbim/bim/module/brick/ui.py

@@ -18,6 +18,7 @@
 
 import blenderbim.tool as tool
 from bpy.types import Panel, UIList
+from blenderbim.bim.helper import prop_with_search
 from blenderbim.bim.module.brick.data import BrickschemaData, BrickschemaReferencesData
 
 
@@ -48,7 +49,8 @@ class BIM_PT_brickschema(Panel):
         row.operator("bim.close_brick_project", text="", icon="CANCEL")
 
         row = self.layout.row(align=True)
-        row.prop(self.props, "namespace", text="")
+        prop_with_search(row, self.props, "namespace", text="")
+        prop_with_search(row, self.props, "brick_equipment_class", text="")
         row.prop(self.props, "brick_equipment_class", text="")
         row.operator("bim.add_brick", text="", icon="ADD")
 
@@ -101,7 +103,7 @@ class BIM_PT_ifc_brickschema_references(Panel):
             return
 
         row = self.layout.row(align=True)
-        row.prop(self.props, "libraries")
+        prop_with_search(row, self.props, "libraries")
         row.operator("bim.convert_brick_project", text="", icon="ADD")
 
         row = self.layout.row(align=True)

src/blenderbim/blenderbim/bim/module/cad/__init__.py

@@ -0,0 +1,47 @@
+# BlenderBIM Add-on - OpenBIM Blender Add-on
+# Copyright (C) 2022 Dion Moult <dion@thinkmoult.com>
+#
+# This file is part of BlenderBIM Add-on.
+#
+# BlenderBIM Add-on is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# BlenderBIM Add-on is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with BlenderBIM Add-on.  If not, see <http://www.gnu.org/licenses/>.
+
+import bpy
+from . import operator, prop, workspace
+
+classes = (
+    operator.AlignViewToProfile,
+    operator.AddIfcArcIndexFillet,
+    operator.AddIfcCircle,
+    operator.AddRectangle,
+    operator.CadArcFrom2Points,
+    operator.CadArcFrom3Points,
+    operator.CadFillet,
+    operator.CadMitre,
+    operator.CadOffset,
+    operator.CadTrimExtend,
+    prop.BIMCadProperties,
+    workspace.CadHotkey,
+)
+
+
+def register():
+    if not bpy.app.background:
+        bpy.utils.register_tool(workspace.CadTool, after={"builtin.transform"}, separator=True, group=True)
+    bpy.types.Scene.BIMCadProperties = bpy.props.PointerProperty(type=prop.BIMCadProperties)
+
+
+def unregister():
+    if not bpy.app.background:
+        bpy.utils.unregister_tool(workspace.CadTool)
+    del bpy.types.Scene.BIMCadProperties

src/blenderbim/blenderbim/bim/module/cad/operator.py

@@ -0,0 +1,813 @@
+# BlenderBIM Add-on - OpenBIM Blender Add-on
+# Copyright (C) 2020, 2021 Dion Moult <dion@thinkmoult.com>
+#
+# This file is part of BlenderBIM Add-on.
+#
+# BlenderBIM Add-on is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# BlenderBIM Add-on is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with BlenderBIM Add-on.  If not, see <http://www.gnu.org/licenses/>.
+
+import bpy
+import math
+import bmesh
+import mathutils
+import bpy_extras
+import blenderbim.tool as tool
+from mathutils import Vector, Matrix
+from math import pi, radians, sin, cos, sqrt
+
+messages = {
+    "SHARED_VERTEX": "Shared Vertex, no intersection possible",
+    "PARALLEL_EDGES": "Edges Parallel, no intersection possible",
+    "NON_PLANAR_EDGES": "Non Planar Edges, no clean intersection point",
+}
+
+
+class CadTrimExtend(bpy.types.Operator):
+    bl_idname = "bim.cad_trim_extend"
+    bl_label = "CAD Trim / Extend"
+
+    @classmethod
+    def poll(cls, context):
+        obj = context.active_object
+        return bool(obj) and obj.type == "MESH"
+
+    def cancel_message(self, msg):
+        self.report({"WARNING"}, msg)
+        return {"CANCELLED"}
+
+    def execute(self, context):
+        # final attempt to enter unfragmented bm/mesh
+        # ghastly, but what can I do? it works with these
+        # fails without.
+        bpy.ops.object.mode_set(mode="OBJECT")
+        bpy.ops.object.mode_set(mode="EDIT")
+
+        obj = context.active_object
+        me = obj.data
+
+        bm = bmesh.from_edit_mesh(me)
+        bm.verts.ensure_lookup_table()
+        bm.edges.ensure_lookup_table()
+
+        edges = [e for e in bm.edges if e.select and not e.hide]
+
+        if len(edges) == 2:
+            message = tool.Cad.do_vtx_if_appropriate(bm, edges, mode="T")
+            if isinstance(message, set):
+                msg = messages.get(message.pop())
+                return self.cancel_message(msg)
+            bm = message
+        else:
+            return self.cancel_message("select two edges!")
+
+        bmesh.ops.remove_doubles(bm, verts=list(set(edges[0].verts) | set(edges[1].verts)), dist=1e-5)
+        bm.verts.index_update()
+        bm.edges.index_update()
+        bmesh.update_edit_mesh(me, loop_triangles=True)
+        return {"FINISHED"}
+
+
+class CadMitre(bpy.types.Operator):
+    bl_idname = "bim.cad_mitre"
+    bl_label = "CAD Mitre"
+
+    @classmethod
+    def poll(cls, context):
+        obj = context.active_object
+        return bool(obj) and obj.type == "MESH"
+
+    def cancel_message(self, msg):
+        self.report({"WARNING"}, msg)
+        return {"CANCELLED"}
+
+    def execute(self, context):
+        # final attempt to enter unfragmented bm/mesh
+        # ghastly, but what can I do? it works with these
+        # fails without.
+        bpy.ops.object.mode_set(mode="OBJECT")
+        bpy.ops.object.mode_set(mode="EDIT")
+
+        obj = context.active_object
+        me = obj.data
+
+        bm = bmesh.from_edit_mesh(me)
+        bm.verts.ensure_lookup_table()
+        bm.edges.ensure_lookup_table()
+
+        edges = [e for e in bm.edges if e.select and not e.hide]
+
+        if len(edges) == 2:
+            message = tool.Cad.do_vtx_if_appropriate(bm, edges, mode="V")
+            if isinstance(message, set):
+                msg = messages.get(message.pop())
+                return self.cancel_message(msg)
+            bm = message
+        else:
+            return self.cancel_message("select two edges!")
+
+        bmesh.ops.remove_doubles(bm, verts=list(set(edges[0].verts) | set(edges[1].verts)), dist=1e-5)
+        bm.verts.index_update()
+        bm.edges.index_update()
+        bmesh.update_edit_mesh(me, loop_triangles=True)
+        return {"FINISHED"}
+
+
+class CadFillet(bpy.types.Operator):
+    bl_idname = "bim.cad_fillet"
+    bl_label = "CAD Fillet"
+    bl_options = {"REGISTER", "UNDO"}
+    resolution: bpy.props.IntProperty(name="Arc Resolution", min=0, default=1)
+    radius: bpy.props.FloatProperty(name="Radius", default=0.1)
+
+    @classmethod
+    def poll(cls, context):
+        obj = context.active_object
+        return obj and obj.type == "MESH" and context.mode == "EDIT_MESH"
+
+    def draw(self, context):
+        layout = self.layout
+        for prop in self.__class__.__annotations__.keys():
+            layout.prop(self, prop)
+
+    def execute(self, context):
+        bpy.ops.object.mode_set(mode="OBJECT")
+        bpy.ops.object.mode_set(mode="EDIT")
+
+        obj = bpy.context.active_object
+        cursor = obj.matrix_world.inverted() @ bpy.context.scene.cursor.location
+        mesh = obj.data
+        bm = bmesh.from_edit_mesh(mesh)
+        selected_edges = [e for e in bm.edges if e.select]
+        if len(selected_edges) != 2:
+            return {"CANCELLED"}
+
+        # Assume the user has selected two edges sharing a vert, but merge verts
+        # just in case the vertex is coincident but not shared.
+        all_verts = list(set(selected_edges[0].verts) | set(selected_edges[1].verts))
+        bmesh.ops.remove_doubles(bm, verts=all_verts, dist=1e-4)
+
+        # Subdivide one of the edges to give us an extra vert to play with
+        # without damaging any faces that already exist.
+        cut = bmesh.ops.bisect_edges(bm, edges=[selected_edges[1]], cuts=1)
+        bm.edges.index_update()
+        bmesh.update_edit_mesh(mesh)
+
+        is_wire = selected_edges[0].is_wire
+
+        # Recover the original intention of the selected edges after our bisect operation
+        cut_edges = cut["geom_split"][1:]
+        selected_edges = [e for e in bm.edges if e.select and e not in cut_edges]
+        if set(selected_edges[0].verts) & set(cut_edges[0].verts):
+            selected_edges.append(cut_edges[0])
+        elif set(selected_edges[0].verts) & set(cut_edges[1].verts):
+            selected_edges.append(cut_edges[1])
+
+        # Calculate the distance to slide each edge to make space for the fillet arc
+        shared_vert = list(set(selected_edges[0].verts) & set(selected_edges[1].verts))[0]
+        v1 = selected_edges[0].other_vert(shared_vert)
+        v2 = selected_edges[1].other_vert(shared_vert)
+        dir1 = (v1.co - shared_vert.co).normalized()
+        dir2 = (v2.co - shared_vert.co).normalized()
+        edge_angle = dir1.angle(dir2)
+        slide_distance = self.radius / math.tan(edge_angle / 2)
+
+        angle = math.pi - edge_angle
+        fillet_v1 = shared_vert.co + (dir1 * slide_distance)
+        fillet_v2 = shared_vert.co + (dir2 * slide_distance)
+
+        normal = mathutils.geometry.normal([v1.co, shared_vert.co, v2.co])
+
+        center = mathutils.geometry.intersect_line_line(
+            fillet_v1, fillet_v1 + normal.cross(dir1), fillet_v2, fillet_v2 + normal.cross(dir2)
+        )[0]
+
+        v = bm.verts.new(fillet_v1)
+        steps = self.resolution * 4 if self.resolution else 1
+        spin = bmesh.ops.spin(bm, geom=[v], axis=normal, cent=center, steps=steps, angle=angle)
+
+        bmesh.ops.pointmerge(bm, verts=[shared_vert, v], merge_co=v.co)
+        bmesh.ops.pointmerge(bm, verts=[v2, spin["geom_last"][0]], merge_co=spin["geom_last"][0].co)
+
+        # If faces are involved, then the chamfer edge protects existing faces from the newly created fillet.
+        # If no faces are involved, we delete the chamfer edge.
+        if is_wire:
+            chamfer_edge = [e for e in bm.edges if shared_vert in e.verts and v2 in e.verts][0]
+            bm.edges.remove(chamfer_edge)
+
+        bm.verts.index_update()
+        bm.edges.index_update()
+        bmesh.update_edit_mesh(mesh)
+        return {"FINISHED"}
+
+
+class CadArcFrom2Points(bpy.types.Operator):
+    bl_idname = "bim.cad_arc_from_2_points"
+    bl_label = "CAD Arc from 2 Points"
+    bl_options = {"REGISTER", "UNDO"}
+    resolution: bpy.props.IntProperty(name="Arc Resolution", min=1, default=1)
+    should_flip: bpy.props.BoolProperty(name="Flip", description="Flip arc", default=False)
+
+    def draw(self, context):
+        layout = self.layout
+        for prop in self.__class__.__annotations__.keys():
+            layout.prop(self, prop)
+
+    def execute(self, context):
+        bpy.ops.object.mode_set(mode="OBJECT")
+        bpy.ops.object.mode_set(mode="EDIT")
+
+        if bpy.context.mode != "EDIT_MESH":
+            return {"CANCELLED"}
+        obj = bpy.context.active_object
+        region = bpy.context.region
+        region_3d = bpy.context.area.spaces.active.region_3d
+        cursor = bpy.context.scene.cursor.location
+        center = bpy_extras.view3d_utils.location_3d_to_region_2d(region, region_3d, cursor)
+        if not center:
+            return {"CANCELLED"}
+        mesh = obj.data
+        mw = obj.matrix_world
+        bm = bmesh.from_edit_mesh(mesh)
+        selected_verts = [v for v in bm.verts if v.select]
+        if len(selected_verts) != 2:
+            return {"CANCELLED"}
+        v1 = bpy_extras.view3d_utils.location_3d_to_region_2d(region, region_3d, mw @ selected_verts[0].co)
+        v2 = bpy_extras.view3d_utils.location_3d_to_region_2d(region, region_3d, mw @ selected_verts[1].co)
+        l1 = v1 - center
+        l2 = v2 - center
+        angle = l1.angle_signed(l2)
+
+        if self.should_flip:
+            if angle > 0:
+                angle = -((math.pi * 2) - angle)
+            else:
+                angle = (math.pi * 2) + angle
+
+        v = selected_verts[0]
+        bm.verts.remove(selected_verts[1])
+        axis = region_3d.view_rotation @ Vector((0, 0, 1))
+        bmesh.ops.spin(
+            bm,
+            geom=[v],
+            axis=mw.inverted().to_quaternion() @ axis,
+            cent=mw.inverted() @ cursor,
+            steps=self.resolution * 4,
+            angle=-angle,
+        )
+        bmesh.update_edit_mesh(mesh)
+        mesh.update()
+        return {"FINISHED"}
+
+
+class CadArcFrom3Points(bpy.types.Operator):
+    bl_idname = "bim.cad_arc_from_3_points"
+    bl_label = "CAD Arc from 3 Points"
+    bl_options = {"REGISTER", "UNDO"}
+    resolution: bpy.props.IntProperty(name="Arc Resolution", min=1, default=1)
+    only_recalculate_center: bpy.props.BoolProperty(name="Only Recalculate Center", default=False)
+
+    @classmethod
+    def poll(cls, context):
+        obj = context.active_object
+        return obj and obj.type == "MESH" and context.mode == "EDIT_MESH"
+
+    def draw(self, context):
+        layout = self.layout
+        for prop in self.__class__.__annotations__.keys():
+            layout.prop(self, prop)
+
+    def execute(self, context):
+        bpy.ops.object.mode_set(mode="OBJECT")
+        bpy.ops.object.mode_set(mode="EDIT")
+
+        if bpy.context.mode != "EDIT_MESH":
+            return {"CANCELLED"}
+
+        obj = bpy.context.edit_object
+        mesh = obj.data
+        bm = bmesh.from_edit_mesh(mesh)
+
+        arc = [v for v in bm.verts if v.select]
+        if len(arc) != 3:
+            return {"CANCELLED"}
+        elif len([e for e in bm.edges if e.select]) != 2:
+            return {"CANCELLED"}
+
+        sorted_arc = [None, None, None]
+        for v1 in arc:
+            connections = 0
+            for link_edge in v1.link_edges:
+                v2 = link_edge.other_vert(v1)
+                if v2 in arc:
+                    connections += 1
+            if connections == 2:  # Midpoint
+                sorted_arc[1] = v1
+            else:
+                sorted_arc[2 if sorted_arc[2] is None else 0] = v1
+
+        points = [tuple(v.co) for v in sorted_arc]
+        verts, _ = tool.Cad.create_arc_segments(points, num_verts=(self.resolution * 4) + 1, make_edges=False)
+
+        bm.verts.index_update()
+        bm.edges.index_update()
+
+        index_offset = len(bm.verts)
+        new_verts = [bm.verts.new(v) for v in verts]
+        new_edges = [bm.edges.new((new_verts[i], new_verts[i + 1])) for i in range(len(new_verts) - 1)]
+
+        bm.verts.remove(sorted_arc[1])
+        bmesh.ops.remove_doubles(bm, verts=new_verts + [sorted_arc[0], sorted_arc[2]], dist=1e-5)
+
+        bmesh.update_edit_mesh(mesh)
+        return {"FINISHED"}
+
+
+class CadOffset(bpy.types.Operator):
+    bl_idname = "bim.cad_offset"
+    bl_label = "CAD Offset"
+    bl_options = {"REGISTER", "UNDO"}
+    distance: bpy.props.FloatProperty(name="Distance", default=0.1)
+
+    @classmethod
+    def poll(self, context):
+        return context.mode == "EDIT_MESH"
+
+    def draw(self, context):
+        layout = self.layout
+        for prop in self.__class__.__annotations__.keys():
+            layout.prop(self, prop)
+
+    def cancel_message(self, msg):
+        self.report({"WARNING"}, msg)
+        return {"CANCELLED"}
+
+    def execute(self, context):
+        # This is not the same as Mesh Tools or Sverchok. Mesh Tools is based on
+        # a 3D "rail" which allows fancy 3D edge offsets, but will get different
+        # results to traditional CAD, which expects offsets to occur on a
+        # defined 2D workplane. This CAD offset does a pure 2D operation, so it
+        # always looks correct from the desired "2D workplane". This also
+        # reduces the settings down to one parameter instead of the huge config
+        # dialog that Mesh Tools has. Sverchok is 2D based, but has a weird side
+        # effect of converting an unclosed loop into a closed loop which is also
+        # not what users expect.
+        bpy.ops.object.mode_set(mode="OBJECT")
+        bpy.ops.object.mode_set(mode="EDIT")
+
+        obj = context.active_object
+        mw = obj.matrix_world
+
+        bm = bmesh.from_edit_mesh(obj.data)
+        bm.verts.ensure_lookup_table()
+        bm.edges.ensure_lookup_table()
+
+        edges = [e for e in bm.edges if e.select and not e.hide]
+
+        if len(edges) < 1:
+            return self.cancel_message("NO_EDGES")
+
+        verts = set()
+        [verts.update(e.verts) for e in edges]
+
+        # Use the viewport angle to determine the offset direction
+        for area in bpy.context.screen.areas:
+            if area.type == "VIEW_3D":
+                # Don't ask me, I don't know.
+                # view_matrix = area.spaces.active.region_3d.view_matrix
+                x = area.spaces.active.region_3d.view_rotation @ Vector((1, 0, 0))
+                y = area.spaces.active.region_3d.view_rotation @ Vector((0, 1, 0))
+                z = area.spaces.active.region_3d.view_rotation @ Vector((0, 0, 1))
+                wp = Matrix([x, y, z, Vector((0, 0, 0))]).to_4x4().transposed()
+                break
+
+        rotation = Matrix.Rotation(pi / 2, 2, "Z")
+        rotation_i = Matrix.Rotation(-pi / 2, 2, "Z")
+
+        # Create loops from edges
+        loop_edges = set(edges)
+        loops = []
+        while loop_edges:
+            edge = loop_edges.pop()
+            loop = [edge]
+            has_found_connected_edge = True
+            while has_found_connected_edge:
+                has_found_connected_edge = False
+                for edge in loop_edges.copy():
+                    edge_verts = set(edge.verts)
+                    if edge_verts & set(loop[0].verts):
+                        loop.insert(0, edge)
+                        loop_edges.remove(edge)
+                        has_found_connected_edge = True
+                    elif edge_verts & set(loop[-1].verts):
+                        loop.append(edge)
+                        loop_edges.remove(edge)
+                        has_found_connected_edge = True
+            loops.append(loop)
+
+        for loop in loops:
+            all_verts = {v.index for e in loop for v in e.verts}
+            possible_v1s = []
+            is_closed = True
+            for edge in loop:
+                # If we have an open loop, start at either end instead
+                v = edge.verts[0]
+                if len(v.link_edges) == 1:
+                    possible_v1s.append(v)
+                    is_closed = False
+                else:
+                    for link_edge in v.link_edges:
+                        if link_edge.other_vert(v).index not in all_verts:
+                            possible_v1s.append(v)
+                            is_closed = False
+                            break
+                v = edge.verts[1]
+                if len(v.link_edges) == 1:
+                    possible_v1s.append(v)
+                    is_closed = False
+                else:
+                    for link_edge in v.link_edges:
+                        if link_edge.other_vert(v).index not in all_verts:
+                            possible_v1s.append(v)
+                            is_closed = False
+                            break
+
+            # Always start at the same vertex, so that when the operator is
+            # refreshed with new parameters the axes don't randomly get flipped.
+            if is_closed:
+                bm.verts.ensure_lookup_table()
+                bm.edges.ensure_lookup_table()
+                start = bm.verts[min(all_verts)]
+            else:
+                start = possible_v1s[0] if possible_v1s[0].index < possible_v1s[1].index else possible_v1s[1]
+
+            v1 = start
+
+            new_verts = []
+            processed_verts = set()
+            # [v0] --> v1 --> v2
+            while v1:
+                if v1.index in processed_verts:
+                    break
+
+                link_verts = []
+                if len(v1.link_edges) == 1:
+                    v = v1.link_edges[0].other_vert(v1)
+                    link_verts.append(v) if v.index in all_verts else None
+                else:
+                    v = v1.link_edges[0].other_vert(v1)
+                    link_verts.append(v) if v.index in all_verts else None
+                    v = v1.link_edges[1].other_vert(v1)
+                    link_verts.append(v) if v.index in all_verts else None
+
+                if len(link_verts) == 1:
+                    v2 = link_verts[0]
+                    v0 = None if v2.index not in processed_verts else v2
+                    v2 = None if v2.index in processed_verts else v2
+                else:
+                    v2 = link_verts[0]
+                    v0 = link_verts[1]
+                    if v2.index in processed_verts:
+                        if is_closed and v0.index in processed_verts:
+                            v3 = start
+                            v0 = v0 if v2 == v3 else v2
+                            v2 = v3
+                        else:
+                            v0, v2 = v2, v0
+
+                normals = []
+                v1co = (wp.inverted() @ mw @ v1.co).to_2d()
+                if v2:
+                    v2co = (wp.inverted() @ mw @ v2.co).to_2d()
+                    direction = (v2co - v1co).normalized()
+                    local_direction = (rotation @ direction).normalized()
+                    normals.append(local_direction)
+
+                if v0:
+                    v0co = (wp.inverted() @ mw @ v0.co).to_2d()
+                    direction = (v0co - v1co).normalized()
+                    local_direction = (rotation_i @ direction).normalized()
+                    normals.append(local_direction)
+
+                if len(normals) == 2:
+                    # https://stackoverflow.com/a/54042831/9627415
+                    new_normal = (normals[0].lerp(normals[1], 0.5)).normalized()
+                    offset_length = self.distance / sqrt((1 + normals[0].dot(normals[1])) / 2)
+                    offset = mw.inverted().to_quaternion() @ (wp.to_quaternion() @ (new_normal * offset_length).to_3d())
+                    new_vert = v1.co + offset
+                    new_verts.append(bm.verts.new(new_vert))
+                else:
+                    normal = (normals[0] * self.distance).to_3d()
+                    offset = mw.inverted().to_quaternion() @ (wp.to_quaternion() @ normal)
+                    new_vert = v1.co + offset
+                    new_verts.append(bm.verts.new(new_vert))
+
+                processed_verts.add(v1.index)
+
+                if v2 in processed_verts:
+                    break
+
+                v1 = v2
+
+            [bm.edges.new((new_verts[i], new_verts[i + 1])) for i in range(len(new_verts) - 1)]
+            if is_closed:
+                bm.edges.new((new_verts[len(new_verts) - 1], new_verts[0]))
+
+        bm.verts.index_update()
+        bm.edges.index_update()
+        bmesh.update_edit_mesh(obj.data)
+        return {"FINISHED"}
+
+
+class AddIfcCircle(bpy.types.Operator):
+    bl_idname = "bim.add_ifccircle"
+    bl_label = "Add IfcCircle"
+    radius: bpy.props.FloatProperty(name="Radius", default=0.1)
+
+    @classmethod
+    def poll(cls, context):
+        obj = context.active_object
+        return bool(obj) and obj.type == "MESH"
+
+    def execute(self, context):
+        if self.has_selected_existing_circle(context):
+            self.change_radius(context)
+        else:
+            self.create_circle(context)
+        return {"FINISHED"}
+
+    def has_selected_existing_circle(self, context):
+        obj = context.active_object
+        bm = bmesh.from_edit_mesh(obj.data)
+        verts = [v for v in bm.verts if v.select and not v.hide]
+        if len(verts) != 2:
+            return False
+        groups = []
+        for i, group in enumerate(obj.vertex_groups):
+            if "IFCCIRCLE" in group.name:
+                groups.append(i)
+        bm.verts.layers.deform.verify()
+        deform_layer = bm.verts.layers.deform.active
+        for group in groups:
+            if group in verts[0][deform_layer] and group in verts[1][deform_layer]:
+                return True
+
+    def change_radius(self, context):
+        obj = context.active_object
+        bm = bmesh.from_edit_mesh(obj.data)
+        verts = [v for v in bm.verts if v.select and not v.hide]
+        center = verts[0].co.lerp(verts[1].co, 0.5)
+        verts[0].co = center + ((verts[0].co - center).normalized() * self.radius)
+        verts[1].co = center + ((verts[1].co - center).normalized() * self.radius)
+        bm.verts.index_update()
+        bm.edges.index_update()
+        bmesh.update_edit_mesh(obj.data)
+
+    def create_circle(self, context):
+        obj = context.active_object
+        bpy.ops.object.mode_set(mode="OBJECT")
+        # The last group may be the result of a prior run of this operator.
+        # I tried looping through all groups but Blender group indices seem to behave unpredictably.
+        if len(obj.vertex_groups):
+            last_group = obj.vertex_groups[-1]
+            verts_in_group = [v for v in obj.data.vertices if last_group.index in [vg.group for vg in v.groups]]
+            if "IFCCIRCLE" in last_group.name and len(verts_in_group) != 2:
+                obj.vertex_groups.remove(last_group)
+        group = obj.vertex_groups.new(name="IFCCIRCLE")
+        bpy.ops.object.mode_set(mode="EDIT")
+
+        bm = bmesh.from_edit_mesh(obj.data)
+
+        bm.verts.layers.deform.verify()
+        deform_layer = bm.verts.layers.deform.active
+
+        center = obj.matrix_world.inverted() @ context.scene.cursor.location
+
+        v1 = bm.verts.new((center[0], center[1] + self.radius, 0.0))
+        v2 = bm.verts.new((center[0], center[1] - self.radius, 0.0))
+        bm.verts.index_update()
+        bm.edges.new((v1, v2))
+
+        for vert in [v1, v2]:
+            vert[deform_layer][group.index] = 1
+
+        bm.verts.index_update()
+        bm.edges.index_update()
+        bmesh.update_edit_mesh(obj.data)
+
+
+class AddIfcArcIndexFillet(bpy.types.Operator):
+    bl_idname = "bim.add_ifcarcindex_fillet"
+    bl_label = "Add Arc Index Fillet"
+    bl_options = {"REGISTER", "UNDO"}
+    radius: bpy.props.FloatProperty(name="Radius", default=0.1)
+
+    @classmethod
+    def poll(cls, context):
+        obj = context.active_object
+        return obj and obj.type == "MESH" and context.mode == "EDIT_MESH"
+
+    def draw(self, context):
+        layout = self.layout
+        for prop in self.__class__.__annotations__.keys():
+            layout.prop(self, prop)
+
+    def execute(self, context):
+        if self.has_selected_existing_arc(context):
+            self.change_radius(context)
+        else:
+            self.create_arc(context)
+        return {"FINISHED"}
+
+    def has_selected_existing_arc(self, context):
+        obj = context.active_object
+        bm = bmesh.from_edit_mesh(obj.data)
+        verts = [v for v in bm.verts if v.select and not v.hide]
+        if len(verts) != 3:
+            return False
+        groups = []
+        for i, group in enumerate(obj.vertex_groups):
+            if "IFCARCINDEX" in group.name:
+                groups.append(i)
+        bm.verts.layers.deform.verify()
+        deform_layer = bm.verts.layers.deform.active
+        for group in groups:
+            try:
+                if group in verts[0][deform_layer] and group in verts[1][deform_layer]:
+                    return True
+            except:
+                pass  # Potentially fail if the vert has been removed in the previous operation
+
+    def change_radius(self, context):
+        obj = context.active_object
+        bm = bmesh.from_edit_mesh(obj.data)
+        edges = [e for e in bm.edges if e.select and not e.hide]
+
+        mid = list(set(edges[0].verts) & set(edges[1].verts))[0]
+        v1 = edges[0].other_vert(mid)
+        v2 = edges[1].other_vert(mid)
+        center = tool.Cad.get_center_of_arc([v1.co, mid.co, v2.co])
+
+        if len(v1.link_edges) != 2 or len(v2.link_edges) != 2:
+            return
+
+        v3 = v1.link_edges[1].other_vert(v1) if mid in v1.link_edges[0].verts else v1.link_edges[0].other_vert(v1)
+        v4 = v2.link_edges[1].other_vert(v2) if mid in v2.link_edges[0].verts else v2.link_edges[0].other_vert(v2)
+        dir1 = (v3.co - v1.co).normalized()
+        dir2 = (v4.co - v2.co).normalized()
+
+        intersect = mathutils.geometry.intersect_line_line(v3.co, v1.co, v4.co, v2.co)[0]
+
+        edge_angle = dir1.angle(dir2)
+        slide_distance = self.radius / math.tan(edge_angle / 2)
+
+        v1.co = intersect + (dir1 * slide_distance)
+        v2.co = intersect + (dir2 * slide_distance)
+
+        normal = mathutils.geometry.normal([v1.co, intersect, v2.co])
+        center = mathutils.geometry.intersect_line_line(
+            v1.co, v1.co + normal.cross(dir1), v2.co, v2.co + normal.cross(dir2)
+        )[0]
+
+        mid.co = center + ((v1.co.lerp(v2.co, 0.5) - center).normalized() * self.radius)
+
+        bm.verts.index_update()
+        bm.edges.index_update()
+        bmesh.update_edit_mesh(obj.data)
+
+    def create_arc(self, context):
+        obj = bpy.context.active_object
+
+        bpy.ops.object.mode_set(mode="OBJECT")
+        # The last group may be the result of a prior run of this operator.
+        # I tried looping through all groups but Blender group indices seem to behave unpredictably.
+        if len(obj.vertex_groups):
+            last_group = obj.vertex_groups[-1]
+            verts_in_group = [v for v in obj.data.vertices if last_group.index in [vg.group for vg in v.groups]]
+            if "IFCARCINDEX" in last_group.name and len(verts_in_group) != 3:
+                obj.vertex_groups.remove(last_group)
+        group = obj.vertex_groups.new(name="IFCARCINDEX")
+        bpy.ops.object.mode_set(mode="EDIT")
+
+        bm = bmesh.from_edit_mesh(obj.data)
+
+        bm.verts.layers.deform.verify()
+        deform_layer = bm.verts.layers.deform.active
+
+        selected_edges = [e for e in bm.edges if e.select]
+        if len(selected_edges) != 2:
+            return {"CANCELLED"}
+
+        # Assume the user has selected two edges sharing a vert, but merge verts
+        # just in case the vertex is coincident but not shared.
+        all_verts = list(set(selected_edges[0].verts) | set(selected_edges[1].verts))
+
+        bmesh.ops.remove_doubles(bm, verts=all_verts, dist=1e-4)
+
+        # Calculate the distance to slide each edge to make space for the fillet arc
+        shared_vert = list(set(selected_edges[0].verts) & set(selected_edges[1].verts))[0]
+        v1 = selected_edges[0].other_vert(shared_vert)
+        v2 = selected_edges[1].other_vert(shared_vert)
+        dir1 = (v1.co - shared_vert.co).normalized()
+        dir2 = (v2.co - shared_vert.co).normalized()
+        edge_angle = dir1.angle(dir2)
+        slide_distance = self.radius / math.tan(edge_angle / 2)
+
+        angle = math.pi - edge_angle
+        fillet_v1co = shared_vert.co + (dir1 * slide_distance)
+        fillet_v2co = shared_vert.co + (dir2 * slide_distance)
+
+        normal = mathutils.geometry.normal([v1.co, shared_vert.co, v2.co])
+
+        center = mathutils.geometry.intersect_line_line(
+            fillet_v1co, fillet_v1co + normal.cross(dir1), fillet_v2co, fillet_v2co + normal.cross(dir2)
+        )[0]
+
+        fillet_v1 = bm.verts.new(fillet_v1co)
+        fillet_v2 = bm.verts.new(fillet_v2co)
+
+        midpointco = center + ((fillet_v1co.lerp(fillet_v2.co, 0.5) - center).normalized() * self.radius)
+        midpoint = bm.verts.new(midpointco)
+
+        bm.edges.new((v1, fillet_v1))
+        bm.edges.new((v2, fillet_v2))
+        bm.edges.new((fillet_v1, midpoint))
+        bm.edges.new((fillet_v2, midpoint))
+
+        bmesh.ops.delete(bm, geom=[shared_vert], context="VERTS")
+
+        for vert in [fillet_v1, midpoint, fillet_v2]:
+            vert[deform_layer][group.index] = 1
+
+        bm.verts.index_update()
+        bm.edges.index_update()
+        bmesh.update_edit_mesh(obj.data)
+
+
+class AlignViewToProfile(bpy.types.Operator):
+    bl_idname = "bim.align_view_to_profile"
+    bl_label = "Align View To Profile"
+    #            __ ___
+    #          .'. -- . '.
+    #         /U)  __   (O|
+    #        /.'  ()()   '.\._
+    #      .',/;,_.--._.;;) . '--..__
+    #     /  ,///|.__.|.\\\  \ '.  '.''---..___
+    #    /'._ '' ||  ||  '' _'\  :   \   '   . '.
+    #   /        ||  ||        '.,    )   )   :  \
+    #  :'-.__ _  ||  ||   _ __.' _\_ .'  '   '   ,)
+    #  (          '  |'        ( __= ___..-._ ( (.\\
+    # ('\      .___ ___.      /'.___=          \.\.\
+    #  \\\-..____________..-'///
+
+    @classmethod
+    def poll(cls, context):
+        obj = context.active_object
+        return bool(obj) and obj.type == "MESH"
+
+    def execute(self, context):
+        bpy.ops.object.mode_set(mode="OBJECT")
+        bpy.ops.view3d.view_axis(type="TOP", align_active=True)
+        region_3d = bpy.context.area.spaces.active.region_3d
+        region_3d.view_perspective = "ORTHO"
+        bpy.ops.object.mode_set(mode="EDIT")
+        return {"FINISHED"}
+
+
+class AddRectangle(bpy.types.Operator):
+    bl_idname = "bim.add_rectangle"
+    bl_label = "Add Rectangle"
+    x: bpy.props.FloatProperty(name="X", default=0.1)
+    y: bpy.props.FloatProperty(name="Y", default=0.1)
+
+    @classmethod
+    def poll(cls, context):
+        obj = context.active_object
+        return bool(obj) and obj.type == "MESH"
+
+    def execute(self, context):
+        obj = context.active_object
+        bm = bmesh.from_edit_mesh(obj.data)
+        cursor = obj.matrix_world.inverted() @ context.scene.cursor.location
+        new_verts = [
+            bm.verts.new((cursor[0], cursor[1], 0.0)),
+            bm.verts.new((cursor[0] + self.x, cursor[1], 0.0)),
+            bm.verts.new((cursor[0] + self.x, cursor[1] + self.y, 0.0)),
+            bm.verts.new((cursor[0], cursor[1] + self.y, 0.0)),
+        ]
+        [bm.edges.new((new_verts[i], new_verts[i + 1])) for i in range(len(new_verts) - 1)]
+        bm.edges.new((new_verts[len(new_verts) - 1], new_verts[0]))
+
+        bm.verts.index_update()
+        bm.edges.index_update()
+        bmesh.update_edit_mesh(obj.data)
+        return {"FINISHED"}

src/blenderbim/blenderbim/bim/module/cad/prop.py

@@ -0,0 +1,30 @@
+# BlenderBIM Add-on - OpenBIM Blender Add-on
+# Copyright (C) 2022 Dion Moult <dion@thinkmoult.com>
+#
+# This file is part of BlenderBIM Add-on.
+#
+# BlenderBIM Add-on is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# BlenderBIM Add-on is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with BlenderBIM Add-on.  If not, see <http://www.gnu.org/licenses/>.
+
+import bpy
+from blenderbim.bim.module.model.data import AuthoringData
+from blenderbim.bim.module.model.root import ConstrTypeEntityNotFound
+from bpy.types import PropertyGroup
+
+
+class BIMCadProperties(PropertyGroup):
+    resolution: bpy.props.IntProperty(name="Arc Resolution", min=1, default=1)
+    radius: bpy.props.FloatProperty(name="Radius", default=0.1)
+    distance: bpy.props.FloatProperty(name="Distance", default=0.1)
+    x: bpy.props.FloatProperty(name="X", default=0.2)
+    y: bpy.props.FloatProperty(name="Y", default=0.1)

src/blenderbim/blenderbim/bim/module/cad/workspace.py

@@ -0,0 +1,213 @@
+# BlenderBIM Add-on - OpenBIM Blender Add-on
+# Copyright (C) 2022 Dion Moult <dion@thinkmoult.com>
+#
+# This file is part of BlenderBIM Add-on.
+#
+# BlenderBIM Add-on is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# BlenderBIM Add-on is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with BlenderBIM Add-on.  If not, see <http://www.gnu.org/licenses/>.
+
+import os
+import bpy
+import blenderbim.tool as tool
+import blenderbim.bim.module.type.prop as type_prop
+from bpy.types import WorkSpaceTool
+from blenderbim.bim.module.model.data import AuthoringData
+
+
+class CadTool(WorkSpaceTool):
+    bl_space_type = "VIEW_3D"
+    bl_context_mode = "EDIT_MESH"
+
+    bl_idname = "bim.cad_tool"
+    bl_label = "CAD Tool"
+    bl_description = "Gives you CAD authoring related superpowers"
+    bl_icon = os.path.join(os.path.dirname(__file__), "ops.authoring.cad")
+    bl_widget = None
+    # https://docs.blender.org/api/current/bpy.types.KeyMapItems.html
+    bl_keymap = (
+        ("bim.cad_hotkey", {"type": "C", "value": "PRESS", "shift": True}, {"properties": [("hotkey", "S_C")]}),
+        ("bim.cad_hotkey", {"type": "E", "value": "PRESS", "shift": True}, {"properties": [("hotkey", "S_E")]}),
+        ("bim.cad_hotkey", {"type": "F", "value": "PRESS", "shift": True}, {"properties": [("hotkey", "S_F")]}),
+        ("bim.cad_hotkey", {"type": "O", "value": "PRESS", "shift": True}, {"properties": [("hotkey", "S_O")]}),
+        ("bim.cad_hotkey", {"type": "Q", "value": "PRESS", "shift": True}, {"properties": [("hotkey", "S_Q")]}),
+        ("bim.cad_hotkey", {"type": "R", "value": "PRESS", "shift": True}, {"properties": [("hotkey", "S_R")]}),
+        ("bim.cad_hotkey", {"type": "T", "value": "PRESS", "shift": True}, {"properties": [("hotkey", "S_T")]}),
+        ("bim.cad_hotkey", {"type": "V", "value": "PRESS", "shift": True}, {"properties": [("hotkey", "S_V")]}),
+        ("bim.cad_hotkey", {"type": "X", "value": "PRESS", "shift": True}, {"properties": [("hotkey", "S_X")]}),
+    )
+
+    def draw_settings(context, layout, tool):
+        obj = context.active_object
+        if obj and obj.data and hasattr(obj.data, "BIMMeshProperties") and obj.data.BIMMeshProperties.is_profile:
+            row = layout.row(align=True)
+            row.label(text="", icon="EVENT_SHIFT")
+            row.label(text="", icon="EVENT_Q")
+            if obj.BIMObjectProperties.ifc_definition_id:
+                row.operator("bim.edit_extrusion_profile", text="Save Profile")
+                row.operator("bim.align_view_to_profile", text="", icon="AXIS_FRONT")
+                row.operator("bim.disable_editing_extrusion_profile", text="", icon="CANCEL")
+            else:
+                row.operator("bim.edit_arbitrary_profile", text="Save Profile")
+                row.operator("bim.align_view_to_profile", text="", icon="AXIS_FRONT")
+                row.operator("bim.disable_editing_arbitrary_profile", text="", icon="CANCEL")
+
+            row = layout.row(align=True)
+            row.label(text="", icon="EVENT_SHIFT")
+            row.label(text="", icon="EVENT_E")
+            row.operator("bim.cad_hotkey", text="Extend").hotkey = "S_E"
+
+            row = layout.row(align=True)
+            row.label(text="", icon="EVENT_SHIFT")
+            row.label(text="", icon="EVENT_T")
+            row.operator("bim.cad_hotkey", text="Mitre").hotkey = "S_T"
+
+            row = layout.row(align=True)
+            row.label(text="", icon="EVENT_SHIFT")
+            row.label(text="", icon="EVENT_F")
+            row.operator("bim.cad_hotkey", text="Fillet").hotkey = "S_F"
+
+            row = layout.row(align=True)
+            row.label(text="", icon="EVENT_SHIFT")
+            row.label(text="", icon="EVENT_O")
+            row.operator("bim.cad_hotkey", text="Offset").hotkey = "S_O"
+
+            row = layout.row(align=True)
+            row.label(text="", icon="EVENT_SHIFT")
+            row.label(text="", icon="EVENT_R")
+            row.operator("bim.add_rectangle", text="Rectangle")
+
+            row = layout.row(align=True)
+            row.label(text="", icon="EVENT_SHIFT")
+            row.label(text="", icon="EVENT_C")
+            row.operator("bim.add_ifccircle", text="Circle")
+
+            row = layout.row(align=True)
+            row.label(text="", icon="EVENT_SHIFT")
+            row.label(text="", icon="EVENT_V")
+            row.operator("bim.set_arc_index", text="3-Point Arc")
+
+            row = layout.row(align=True)
+            row.label(text="", icon="EVENT_SHIFT")
+            row.label(text="", icon="EVENT_X")
+            row.operator("bim.reset_vertex", text="Reset Vertex")
+        else:
+            row = layout.row(align=True)
+            row.label(text="", icon="EVENT_SHIFT")
+            row.label(text="", icon="EVENT_E")
+            row.operator("bim.cad_hotkey", text="Extend").hotkey = "S_E"
+
+            row = layout.row(align=True)
+            row.label(text="", icon="EVENT_SHIFT")
+            row.label(text="", icon="EVENT_T")
+            row.operator("bim.cad_hotkey", text="Mitre").hotkey = "S_T"
+
+            row = layout.row(align=True)
+            row.label(text="", icon="EVENT_SHIFT")
+            row.label(text="", icon="EVENT_F")
+            row.operator("bim.cad_hotkey", text="Fillet").hotkey = "S_F"
+
+            row = layout.row(align=True)
+            row.label(text="", icon="EVENT_SHIFT")
+            row.label(text="", icon="EVENT_O")
+            row.operator("bim.cad_hotkey", text="Offset").hotkey = "S_O"
+
+            row = layout.row(align=True)
+            row.label(text="", icon="EVENT_SHIFT")
+            row.label(text="2-Point Arc", icon="EVENT_C")
+
+            row = layout.row(align=True)
+            row.label(text="", icon="EVENT_SHIFT")
+            row.label(text="", icon="EVENT_V")
+            row.operator("bim.cad_hotkey", text="3-Point Arc").hotkey = "S_V"
+
+
+class CadHotkey(bpy.types.Operator):
+    bl_idname = "bim.cad_hotkey"
+    bl_label = "CAD Hotkey"
+    bl_options = {"REGISTER", "UNDO"}
+    hotkey: bpy.props.StringProperty()
+
+    def execute(self, context):
+        self.props = context.scene.BIMCadProperties
+        getattr(self, f"hotkey_{self.hotkey}")()
+        return {"FINISHED"}
+
+    def draw(self, context):
+        props = context.scene.BIMCadProperties
+        if self.hotkey == "S_C":
+            if self.is_profile():
+                row = self.layout.row()
+                row.prop(props, "radius")
+        elif self.hotkey == "S_F":
+            if not self.is_profile():
+                row = self.layout.row()
+                row.prop(props, "resolution")
+            row = self.layout.row()
+            row.prop(props, "radius")
+        elif self.hotkey == "S_O":
+            row = self.layout.row()
+            row.prop(props, "distance")
+        elif self.hotkey == "S_R":
+            row = self.layout.row()
+            row.prop(props, "x")
+            row = self.layout.row()
+            row.prop(props, "y")
+        elif self.hotkey == "S_V":
+            if not self.is_profile():
+                row = self.layout.row()
+                row.prop(props, "resolution")
+
+    def hotkey_S_C(self):
+        if self.is_profile():
+            bpy.ops.bim.add_ifccircle(radius=self.props.radius)
+        else:
+            bpy.ops.bim.cad_arc_from_2_points()
+
+    def hotkey_S_E(self):
+        bpy.ops.bim.cad_trim_extend()
+
+    def hotkey_S_F(self):
+        if self.is_profile():
+            bpy.ops.bim.add_ifcarcindex_fillet(radius=self.props.radius)
+        else:
+            bpy.ops.bim.cad_fillet(resolution=self.props.resolution, radius=self.props.radius)
+
+    def hotkey_S_O(self):
+        bpy.ops.bim.cad_offset(distance=self.props.distance)
+
+    def hotkey_S_Q(self):
+        if tool.Ifc.get_entity(bpy.context.active_object):
+            bpy.ops.bim.edit_extrusion_profile()
+        else:
+            bpy.ops.bim.edit_arbitrary_profile()
+
+    def hotkey_S_R(self):
+        if self.is_profile():
+            bpy.ops.bim.add_rectangle(x=self.props.x, y=self.props.y)
+
+    def hotkey_S_T(self):
+        bpy.ops.bim.cad_mitre()
+
+    def hotkey_S_V(self):
+        if self.is_profile():
+            bpy.ops.bim.set_arc_index()
+        else:
+            bpy.ops.bim.cad_arc_from_3_points(resolution=self.props.resolution)
+
+    def hotkey_S_X(self):
+        if self.is_profile():
+            bpy.ops.bim.reset_vertex()
+
+    def is_profile(self):
+        obj = bpy.context.active_object
+        return obj and obj.data and hasattr(obj.data, "BIMMeshProperties") and obj.data.BIMMeshProperties.is_profile

src/blenderbim/blenderbim/bim/module/classification/__init__.py

@@ -20,23 +20,26 @@ import bpy
 from . import ui, prop, operator
 
 classes = (
-    operator.LoadClassificationLibrary,
     operator.AddClassification,
-    operator.RemoveClassification,
-    operator.EnableEditingClassification,
-    operator.DisableEditingClassification,
-    operator.EditClassification,
-    operator.RemoveClassificationReference,
-    operator.EnableEditingClassificationReference,
-    operator.DisableEditingClassificationReference,
-    operator.EditClassificationReference,
     operator.AddClassificationReference,
     operator.ChangeClassificationLevel,
+    operator.DisableEditingClassification,
+    operator.DisableEditingClassificationReference,
+    operator.DisableEditingClassificationReferences,
+    operator.EditClassification,
+    operator.EditClassificationReference,
+    operator.EnableEditingClassification,
+    operator.EnableEditingClassificationReference,
+    operator.LoadClassificationLibrary,
+    operator.RemoveClassification,
+    operator.RemoveClassificationReference,
     prop.ClassificationReference,
     prop.BIMClassificationProperties,
     prop.BIMClassificationReferenceProperties,
     ui.BIM_PT_classifications,
     ui.BIM_PT_classification_references,
+    ui.BIM_PT_material_classifications,
+    ui.BIM_PT_cost_classifications,
     ui.BIM_UL_classifications,
 )
 

src/blenderbim/blenderbim/bim/module/classification/data.py

@@ -0,0 +1,143 @@
+# BlenderBIM Add-on - OpenBIM Blender Add-on
+# Copyright (C) 2022 Dion Moult <dion@thinkmoult.com>
+#
+# This file is part of BlenderBIM Add-on.
+#
+# BlenderBIM Add-on is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# BlenderBIM Add-on is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with BlenderBIM Add-on.  If not, see <http://www.gnu.org/licenses/>.
+
+import bpy
+import ifcopenshell
+import ifcopenshell.util.date
+import ifcopenshell.util.classification
+import blenderbim.tool as tool
+from blenderbim.bim.ifc import IfcStore
+
+
+def refresh():
+    ClassificationsData.is_loaded = False
+    ClassificationReferencesData.is_loaded = False
+    MaterialClassificationsData.is_loaded = False
+    CostClassificationsData.is_loaded = False
+
+
+class ClassificationsData:
+    data = {}
+    is_loaded = False
+
+    @classmethod
+    def load(cls):
+        cls.is_loaded = True
+        cls.data["has_classification_file"] = cls.has_classification_file()
+        cls.data["classifications"] = cls.classifications()
+        cls.data["available_classifications"] = cls.available_classifications()
+
+    @classmethod
+    def has_classification_file(cls):
+        return bool(IfcStore.classification_file)
+
+    @classmethod
+    def classifications(cls):
+        results = []
+        for element in tool.Ifc.get().by_type("IfcClassification"):
+            data = element.get_info()
+            if tool.Ifc.get().schema == "IFC2X3" and element.EditionDate:
+                data["EditionDate"] = ifcopenshell.util.date.ifc2datetime(data["EditionDate"])
+            results.append(data)
+        return results
+
+    @classmethod
+    def available_classifications(cls):
+        if not IfcStore.classification_file:
+            return []
+        return [(str(e.id()), e.Name, "") for e in IfcStore.classification_file.by_type("IfcClassification")]
+
+
+class ReferencesData:
+    @classmethod
+    def is_available_classification_added(cls):
+        if not IfcStore.classification_file or not IfcStore.classification_file.by_type("IfcClassification"):
+            return False
+        props = bpy.context.scene.BIMClassificationProperties
+        name = IfcStore.classification_file.by_id(int(props.available_classifications)).Name
+        return name in [e.Name for e in tool.Ifc.get().by_type("IfcClassification")]
+
+
+class ClassificationReferencesData(ReferencesData):
+    data = {}
+    is_loaded = False
+
+    @classmethod
+    def load(cls):
+        cls.is_loaded = True
+        cls.data["references"] = cls.references()
+        cls.data["is_available_classification_added"] = cls.is_available_classification_added()
+
+    @classmethod
+    def references(cls):
+        results = []
+        element = tool.Ifc.get_entity(bpy.context.active_object)
+        if element:
+            for reference in ifcopenshell.util.classification.get_references(element):
+                data = reference.get_info()
+                del data["ReferencedSource"]
+                results.append(data)
+        return results
+
+
+class MaterialClassificationsData(ReferencesData):
+    data = {}
+    is_loaded = False
+
+    @classmethod
+    def load(cls):
+        cls.is_loaded = True
+        cls.data["references"] = cls.references()
+        cls.data["is_available_classification_added"] = cls.is_available_classification_added()
+
+    @classmethod
+    def references(cls):
+        results = []
+        element = tool.Ifc.get_entity(bpy.context.active_object.active_material)
+        if element:
+            for reference in ifcopenshell.util.classification.get_references(element):
+                data = reference.get_info()
+                del data["ReferencedSource"]
+                results.append(data)
+        return results
+
+
+class CostClassificationsData(ReferencesData):
+    data = {}
+    is_loaded = False
+
+    @classmethod
+    def load(cls):
+        cls.is_loaded = True
+        cls.data["references"] = cls.references()
+        cls.data["is_available_classification_added"] = cls.is_available_classification_added()
+
+    @classmethod
+    def references(cls):
+        results = []
+        element = tool.Ifc.get().by_id(
+            bpy.context.scene.BIMCostProperties.cost_items[
+                bpy.context.scene.BIMCostProperties.active_cost_item_index
+            ].ifc_definition_id
+        )
+        if element:
+            for reference in ifcopenshell.util.classification.get_references(element):
+                data = reference.get_info()
+                del data["ReferencedSource"]
+                results.append(data)
+        return results

src/blenderbim/blenderbim/bim/module/classification/operator.py

@@ -1,5 +1,5 @@
 # BlenderBIM Add-on - OpenBIM Blender Add-on
-# Copyright (C) 2020, 2021 Dion Moult <dion@thinkmoult.com>
+# Copyright (C) 2020-2022 Dion Moult <dion@thinkmoult.com>
 #
 # This file is part of BlenderBIM Add-on.
 #
@@ -18,46 +18,40 @@
 
 import bpy
 import json
+import ifcopenshell
 import ifcopenshell.api
+import blenderbim.tool as tool
+import blenderbim.bim.helper
 from blenderbim.bim.ifc import IfcStore
-from ifcopenshell.api.classification.data import Data
-from blenderbim.bim.module.classification.prop import getClassifications, getReferences
 
 
-class LoadClassificationLibrary(bpy.types.Operator):
+class LoadClassificationLibrary(bpy.types.Operator, tool.Ifc.Operator):
     bl_idname = "bim.load_classification_library"
     bl_label = "Load Classification Library"
     filename_ext = ".ifc"
     filter_glob: bpy.props.StringProperty(default="*.ifc;*.ifczip;*.ifcxml", options={"HIDDEN"})
     filepath: bpy.props.StringProperty(subtype="FILE_PATH")
 
-    def execute(self, context):
-        Data.load_library(self.filepath)
-        getClassifications(self, context)
-        return {"FINISHED"}
-
     def invoke(self, context, event):
         context.window_manager.fileselect_add(self)
         return {"RUNNING_MODAL"}
 
+    def _execute(self, context):
+        IfcStore.classification_file = ifcopenshell.open(self.filepath)
 
-class AddClassification(bpy.types.Operator):
+
+class AddClassification(bpy.types.Operator, tool.Ifc.Operator):
     bl_idname = "bim.add_classification"
     bl_label = "Add Classification"
     bl_options = {"REGISTER", "UNDO"}
 
-    def execute(self, context):
-        return IfcStore.execute_ifc_operator(self, context)
-
     def _execute(self, context):
         props = context.scene.BIMClassificationProperties
         ifcopenshell.api.run(
             "classification.add_classification",
-            IfcStore.get_file(),
-            **{"classification": Data.library_file.by_id(int(props.available_classifications))},
+            tool.Ifc.get(),
+            classification=IfcStore.classification_file.by_id(int(props.available_classifications)),
         )
-        Data.load(IfcStore.get_file())
-        return {"FINISHED"}
 
 
 class EnableEditingClassification(bpy.types.Operator):
@@ -67,19 +61,21 @@ class EnableEditingClassification(bpy.types.Operator):
     classification: bpy.props.IntProperty()
 
     def execute(self, context):
+        def callback(name, prop, data):
+            if name == "ReferenceTokens":
+                new = bpy.context.scene.BIMGeoreferenceProperties.projected_crs.add()
+                new.name = name
+                new.data_type = "string"
+                new.is_null = data[name] is None
+                new.is_optional = True
+                new.string_value = "" if new.is_null else json.dumps(data[name])
+                return True
+
         props = context.scene.BIMClassificationProperties
         props.classification_attributes.clear()
-        classification_data = Data.classifications[self.classification]
-        for attribute in IfcStore.get_schema().declaration_by_name("IfcClassification").all_attributes():
-            new = props.classification_attributes.add()
-            new.name = attribute.name()
-            new.is_null = classification_data[attribute.name()] is None
-            new.is_optional = attribute.optional()
-            new.data_type = "string"
-            if attribute.name() == "ReferenceTokens":
-                new.string_value = "" if new.is_null else json.dumps(classification_data[attribute.name()])
-            else:
-                new.string_value = "" if new.is_null else classification_data[attribute.name()]
+        blenderbim.bim.helper.import_attributes2(
+            tool.Ifc.get().by_id(self.classification), props.classification_attributes, callback
+        )
         props.active_classification_id = self.classification
         return {"FINISHED"}
 
@@ -94,34 +90,26 @@ class DisableEditingClassification(bpy.types.Operator):
         return {"FINISHED"}
 
 
-class RemoveClassification(bpy.types.Operator):
+class RemoveClassification(bpy.types.Operator, tool.Ifc.Operator):
     bl_idname = "bim.remove_classification"
     bl_label = "Remove Classification"
     bl_options = {"REGISTER", "UNDO"}
     classification: bpy.props.IntProperty()
 
-    def execute(self, context):
-        return IfcStore.execute_ifc_operator(self, context)
-
     def _execute(self, context):
         self.file = IfcStore.get_file()
         ifcopenshell.api.run(
             "classification.remove_classification",
-            self.file,
-            **{"classification": self.file.by_id(self.classification)},
+            tool.Ifc.get(),
+            classification=self.file.by_id(self.classification),
         )
-        Data.load(IfcStore.get_file())
-        return {"FINISHED"}
 
 
-class EditClassification(bpy.types.Operator):
+class EditClassification(bpy.types.Operator, tool.Ifc.Operator):
     bl_idname = "bim.edit_classification"
     bl_label = "Edit Classification"
     bl_options = {"REGISTER", "UNDO"}
 
-    def execute(self, context):
-        return IfcStore.execute_ifc_operator(self, context)
-
     def _execute(self, context):
         props = context.scene.BIMClassificationProperties
         attributes = {}
@@ -138,9 +126,7 @@ class EditClassification(bpy.types.Operator):
             self.file,
             **{"classification": self.file.by_id(props.active_classification_id), "attributes": attributes},
         )
-        Data.load(IfcStore.get_file())
         bpy.ops.bim.disable_editing_classification()
-        return {"FINISHED"}
 
 
 class EnableEditingClassificationReference(bpy.types.Operator):
@@ -154,16 +140,7 @@ class EnableEditingClassificationReference(bpy.types.Operator):
         obj = bpy.data.objects.get(self.obj) if self.obj else context.active_object
         props = obj.BIMClassificationReferenceProperties
         props.reference_attributes.clear()
-        reference_data = Data.references[self.reference]
-        for attribute in IfcStore.get_schema().declaration_by_name("IfcClassificationReference").all_attributes():
-            if attribute.name() == "ReferencedSource":
-                continue
-            new = props.reference_attributes.add()
-            new.name = attribute.name()
-            new.is_null = reference_data[attribute.name()] is None
-            new.is_optional = attribute.optional()
-            new.data_type = "string"
-            new.string_value = "" if new.is_null else reference_data[attribute.name()]
+        blenderbim.bim.helper.import_attributes2(tool.Ifc.get().by_id(self.reference), props.reference_attributes)
         props.active_reference_id = self.reference
         return {"FINISHED"}
 
@@ -180,41 +157,47 @@ class DisableEditingClassificationReference(bpy.types.Operator):
         return {"FINISHED"}
 
 
-class RemoveClassificationReference(bpy.types.Operator):
+class RemoveClassificationReference(bpy.types.Operator, tool.Ifc.Operator):
     bl_idname = "bim.remove_classification_reference"
     bl_label = "Remove Classification Reference"
     bl_options = {"REGISTER", "UNDO"}
     reference: bpy.props.IntProperty()
     obj: bpy.props.StringProperty()
-
-    def execute(self, context):
-        return IfcStore.execute_ifc_operator(self, context)
+    obj_type: bpy.props.StringProperty()
 
     def _execute(self, context):
         obj = bpy.data.objects.get(self.obj) if self.obj else context.active_object
-        self.file = IfcStore.get_file()
-        ifcopenshell.api.run(
-            "classification.remove_reference",
-            self.file,
-            **{
-                "reference": self.file.by_id(self.reference),
-                "product": self.file.by_id(obj.BIMObjectProperties.ifc_definition_id),
-            },
-        )
-        Data.load(IfcStore.get_file(), obj.BIMObjectProperties.ifc_definition_id)
-        Data.load(IfcStore.get_file())
-        return {"FINISHED"}
+        if self.obj_type == "Object":
+            if context.selected_objects:
+                objects = [o.name for o in context.selected_objects]
+            else:
+                objects = [context.active_object.name]
+        else:
+            objects = [self.obj]
+
+        identification = tool.Ifc.get().by_id(self.reference)[0]
+
+        for obj in objects:
+            ifc_definition_id = blenderbim.bim.helper.get_obj_ifc_definition_id(context, obj, self.obj_type)
+            element = tool.Ifc.get().by_id(ifc_definition_id)
+            references = ifcopenshell.util.classification.get_references(element, should_inherit=False)
+            for reference in references:
+                if reference[0] == identification:
+                    ifcopenshell.api.run(
+                        "classification.remove_reference",
+                        tool.Ifc.get(),
+                        reference=reference,
+                        product=element,
+                    )
+                    break
 
 
-class EditClassificationReference(bpy.types.Operator):
+class EditClassificationReference(bpy.types.Operator, tool.Ifc.Operator):
     bl_idname = "bim.edit_classification_reference"
     bl_label = "Edit Classification Reference"
     bl_options = {"REGISTER", "UNDO"}
     obj: bpy.props.StringProperty()
 
-    def execute(self, context):
-        return IfcStore.execute_ifc_operator(self, context)
-
     def _execute(self, context):
         obj = bpy.data.objects.get(self.obj) if self.obj else context.active_object
         props = obj.BIMClassificationReferenceProperties
@@ -228,48 +211,47 @@ class EditClassificationReference(bpy.types.Operator):
         ifcopenshell.api.run(
             "classification.edit_reference",
             self.file,
-            **{"reference": self.file.by_id(props.active_reference_id), "attributes": attributes},
+            reference=self.file.by_id(props.active_reference_id),
+            attributes=attributes,
         )
-        Data.load(IfcStore.get_file())
         bpy.ops.bim.disable_editing_classification_reference()
-        return {"FINISHED"}
 
 
-class AddClassificationReference(bpy.types.Operator):
+class AddClassificationReference(bpy.types.Operator, tool.Ifc.Operator):
     bl_idname = "bim.add_classification_reference"
     bl_label = "Add Classification Reference"
     bl_options = {"REGISTER", "UNDO"}
     reference: bpy.props.IntProperty()
     obj: bpy.props.StringProperty()
-
-    def execute(self, context):
-        return IfcStore.execute_ifc_operator(self, context)
+    obj_type: bpy.props.StringProperty()
 
     def _execute(self, context):
-        obj = bpy.data.objects.get(self.obj) if self.obj else context.active_object
-        self.file = IfcStore.get_file()
-
-        classification = None
-
+        if self.obj_type == "Object":
+            if context.selected_objects:
+                objects = [o.name for o in context.selected_objects]
+            else:
+                objects = [context.active_object.name]
+        else:
+            objects = [self.obj]
         props = context.scene.BIMClassificationProperties
-        classification_name = Data.library_classifications[int(props.available_classifications)]
-        for classification_id, classification in Data.classifications.items():
-            if classification["Name"] == classification_name:
-                classification = self.file.by_id(classification_id)
+        classification = None
+        classification_name = IfcStore.classification_file.by_id(int(props.available_classifications)).Name
+        for element in tool.Ifc.get().by_type("IfcClassification"):
+            if element.Name == classification_name:
+                classification = element
                 break
 
-        ifcopenshell.api.run(
-            "classification.add_reference",
-            self.file,
-            **{
-                "reference": Data.library_file.by_id(self.reference),
-                "product": self.file.by_id(obj.BIMObjectProperties.ifc_definition_id),
-                "classification": classification,
-            },
-        )
-        Data.load(IfcStore.get_file(), obj.BIMObjectProperties.ifc_definition_id)
-        Data.load(IfcStore.get_file())
-        return {"FINISHED"}
+        for obj in objects:
+            ifc_definition_id = blenderbim.bim.helper.get_obj_ifc_definition_id(context, obj, self.obj_type)
+            if not ifc_definition_id:
+                continue
+            ifcopenshell.api.run(
+                "classification.add_reference",
+                tool.Ifc.get(),
+                reference=IfcStore.classification_file.by_id(self.reference),
+                product=tool.Ifc.get().by_id(ifc_definition_id),
+                classification=classification,
+            )
 
 
 class ChangeClassificationLevel(bpy.types.Operator):
@@ -279,5 +261,28 @@ class ChangeClassificationLevel(bpy.types.Operator):
     parent_id: bpy.props.IntProperty()
 
     def execute(self, context):
-        getReferences(self, context, parent_id=self.parent_id)
+        props = context.scene.BIMClassificationProperties
+        props.available_library_references.clear()
+        for reference in IfcStore.classification_file.by_id(self.parent_id).HasReferences:
+            new = props.available_library_references.add()
+            new.identification = reference.Identification or ""
+            new.name = reference.Name or ""
+            new.ifc_definition_id = reference.id()
+            new.has_references = bool(reference.HasReferences)
+            new.referenced_source
+        if reference.ReferencedSource.is_a("IfcClassificationReference"):
+            props.active_library_referenced_source = reference.ReferencedSource.ReferencedSource.id()
+        else:
+            props.active_library_referenced_source = 0
+        return {"FINISHED"}
+
+
+class DisableEditingClassificationReferences(bpy.types.Operator):
+    bl_idname = "bim.disable_editing_classification_references"
+    bl_label = "Disable Editing Classification References"
+    bl_options = {"REGISTER", "UNDO"}
+
+    def execute(self, context):
+        props = context.scene.BIMClassificationProperties
+        props.available_library_references.clear()
         return {"FINISHED"}

src/blenderbim/blenderbim/bim/module/classification/prop.py

@@ -17,8 +17,9 @@
 # along with BlenderBIM Add-on.  If not, see <http://www.gnu.org/licenses/>.
 
 import bpy
+from blenderbim.bim.ifc import IfcStore
 from blenderbim.bim.prop import StrProperty, Attribute
-from ifcopenshell.api.classification.data import Data
+from blenderbim.bim.module.classification.data import ClassificationsData
 from bpy.types import PropertyGroup
 from bpy.props import (
     PointerProperty,
@@ -31,42 +32,11 @@ from bpy.props import (
     CollectionProperty,
 )
 
-classification_enum = []
 
-
-def purge():
-    global classification_enum
-    classification_enum = []
-
-
-def getClassifications(self, context):
-    global classification_enum
-    if len(classification_enum) < 1:
-        classification_enum.clear()
-        classification_enum.extend([(str(i), n, "") for i, n in Data.library_classifications.items()])
-        if classification_enum:
-            getReferences(self, context, parent_id=int(classification_enum[0][0]))
-    return classification_enum
-
-
-def updateClassification(self, context):
-    getReferences(self, context, parent_id=int(self.available_classifications))
-
-
-def getReferences(self, context, parent_id=None):
-    props = context.scene.BIMClassificationProperties
-    props.available_library_references.clear()
-    for reference in Data.library_file.by_id(parent_id).HasReferences:
-        new = props.available_library_references.add()
-        new.identification = reference.Identification or ""
-        new.name = reference.Name or ""
-        new.ifc_definition_id = reference.id()
-        new.has_references = bool(reference.HasReferences)
-        new.referenced_source
-    if reference.ReferencedSource.is_a("IfcClassificationReference"):
-        props.active_library_referenced_source = reference.ReferencedSource.ReferencedSource.id()
-    else:
-        props.active_library_referenced_source = 0
+def get_available_classifications(self, context):
+    if not ClassificationsData.is_loaded:
+        ClassificationsData.load()
+    return ClassificationsData.data["available_classifications"]
 
 
 class ClassificationReference(PropertyGroup):
@@ -78,9 +48,7 @@ class ClassificationReference(PropertyGroup):
 
 
 class BIMClassificationProperties(PropertyGroup):
-    available_classifications: EnumProperty(
-        items=getClassifications, name="Available Classifications", update=updateClassification
-    )
+    available_classifications: EnumProperty(items=get_available_classifications, name="Available Classifications")
     classification_attributes: CollectionProperty(name="Classification Attributes", type=Attribute)
     active_classification_id: IntProperty(name="Active Classification Id")
     available_library_references: CollectionProperty(name="Available Library References", type=ClassificationReference)

src/blenderbim/blenderbim/bim/module/classification/ui.py

@@ -16,10 +16,17 @@
 # You should have received a copy of the GNU General Public License
 # along with BlenderBIM Add-on.  If not, see <http://www.gnu.org/licenses/>.
 
+import blenderbim.bim.helper
+import blenderbim.tool as tool
 import blenderbim.bim.module.classification.prop as classification_prop
 from bpy.types import Panel, UIList
 from blenderbim.bim.ifc import IfcStore
-from ifcopenshell.api.classification.data import Data
+from blenderbim.bim.module.classification.data import (
+    ClassificationsData,
+    ClassificationReferencesData,
+    MaterialClassificationsData,
+    CostClassificationsData,
+)
 
 
 class BIM_PT_classifications(Panel):
@@ -33,15 +40,15 @@ class BIM_PT_classifications(Panel):
 
     @classmethod
     def poll(cls, context):
-        return IfcStore.get_file()
+        return tool.Ifc.get()
 
     def draw(self, context):
-        if not Data.is_loaded:
-            Data.load(IfcStore.get_file())
+        if not ClassificationsData.is_loaded:
+            ClassificationsData.load()
 
         self.props = context.scene.BIMClassificationProperties
 
-        if Data.library_file:
+        if ClassificationsData.data["has_classification_file"]:
             row = self.layout.row(align=True)
             row.prop(self.props, "available_classifications", text="")
             row.operator("bim.load_classification_library", text="", icon="IMPORT")
@@ -51,36 +58,100 @@ class BIM_PT_classifications(Panel):
             row.label(text="No Active Classification Library")
             row.operator("bim.load_classification_library", text="", icon="IMPORT")
 
-        for classification_id, classification in Data.classifications.items():
-            if self.props.active_classification_id == classification_id:
-                self.draw_editable_ui(classification)
+        for classification in ClassificationsData.data["classifications"]:
+            if self.props.active_classification_id == classification["id"]:
+                self.draw_editable_ui()
             else:
-                self.draw_ui(classification_id, classification)
+                self.draw_ui(classification)
 
-    def draw_editable_ui(self, classification):
+    def draw_editable_ui(self):
         row = self.layout.row(align=True)
-        row.prop(self.props.classification_attributes.get("Name"), "string_value", text="", icon="ASSET_MANAGER")
-        row.operator("bim.edit_classification", text="", icon="CHECKMARK")
+        row.operator("bim.edit_classification", text="Save changes", icon="CHECKMARK")
         row.operator("bim.disable_editing_classification", text="", icon="CANCEL")
+        blenderbim.bim.helper.draw_attributes(self.props.classification_attributes, self.layout)
 
-        for attribute in self.props.classification_attributes:
-            if attribute.name == "Name":
-                continue
-            row = self.layout.row(align=True)
-            row.prop(attribute, "string_value", text=attribute.name)
-            if attribute.is_optional:
-                row.prop(attribute, "is_null", icon="RADIOBUT_OFF" if attribute.is_null else "RADIOBUT_ON", text="")
-
-    def draw_ui(self, classification_id, classification):
+    def draw_ui(self, classification):
         row = self.layout.row(align=True)
         row.label(text=classification["Name"], icon="ASSET_MANAGER")
         if not self.props.active_classification_id:
             op = row.operator("bim.enable_editing_classification", text="", icon="GREASEPENCIL")
-            op.classification = classification_id
-        row.operator("bim.remove_classification", text="", icon="X").classification = classification_id
+            op.classification = classification["id"]
+        row.operator("bim.remove_classification", text="", icon="X").classification = classification["id"]
 
 
-class BIM_PT_classification_references(Panel):
+class ReferenceUI:
+    def draw_ui(self, context):
+        obj = context.active_object
+        self.oprops = obj.BIMObjectProperties
+        self.sprops = context.scene.BIMClassificationProperties
+        self.props = obj.BIMClassificationReferenceProperties
+        self.file = IfcStore.get_file()
+
+        self.draw_add_ui(context)
+
+        if not self.data.data["references"]:
+            row = self.layout.row(align=True)
+            row.label(text="No References")
+
+        for reference in self.data.data["references"]:
+            if self.props.active_reference_id == reference["id"]:
+                self.draw_editable_ui()
+            else:
+                self.draw_reference_ui(reference)
+
+    def draw_add_ui(self, context):
+        if not self.data.data["is_available_classification_added"]:
+            return
+        row = self.layout.row(align=True)
+        row.prop(self.sprops, "available_classifications", text="")
+        if not self.sprops.available_library_references:
+            op = row.operator("bim.change_classification_level", text="", icon="IMPORT")
+            op.parent_id = int(self.sprops.available_classifications)
+            return
+        if self.sprops.active_library_referenced_source:
+            op = row.operator("bim.change_classification_level", text="", icon="FRAME_PREV")
+            op.parent_id = self.sprops.active_library_referenced_source
+        if self.sprops.active_library_reference_index < len(self.sprops.available_library_references):
+            op = row.operator("bim.add_classification_reference", text="", icon="ADD")
+            op.obj = self.obj
+            op.obj_type = self.obj_type
+            op.reference = self.sprops.available_library_references[
+                self.sprops.active_library_reference_index
+            ].ifc_definition_id
+        row.operator("bim.disable_editing_classification_references", text="", icon="CANCEL")
+        self.layout.template_list(
+            "BIM_UL_classifications",
+            "",
+            self.sprops,
+            "available_library_references",
+            self.sprops,
+            "active_library_reference_index",
+        )
+
+    def draw_editable_ui(self):
+        row = self.layout.row(align=True)
+        row.operator("bim.edit_classification_reference", text="Save changes", icon="CHECKMARK")
+        row.operator("bim.disable_editing_classification_reference", text="", icon="CANCEL")
+        blenderbim.bim.helper.draw_attributes(self.props.reference_attributes, self.layout)
+
+    def draw_reference_ui(self, reference):
+        row = self.layout.row(align=True)
+        if self.file.schema == "IFC2X3":
+            name = reference["ItemReference"] or "No Identification"
+        else:
+            name = reference["Identification"] or "No Identification"
+        row.label(text=name, icon="ASSET_MANAGER")
+        row.label(text=reference["Name"] or "")
+        if not self.props.active_reference_id:
+            op = row.operator("bim.enable_editing_classification_reference", text="", icon="GREASEPENCIL")
+            op.reference = reference["id"]
+        op = row.operator("bim.remove_classification_reference", text="", icon="X")
+        op.reference = reference["id"]
+        op.obj = self.obj
+        op.obj_type = self.obj_type
+
+
+class BIM_PT_classification_references(Panel, ReferenceUI):
     bl_label = "IFC Classification References"
     bl_idname = "BIM_PT_classification_references"
     bl_options = {"DEFAULT_CLOSED"}
@@ -93,85 +164,65 @@ class BIM_PT_classification_references(Panel):
     def poll(cls, context):
         if not context.active_object:
             return False
-        if not IfcStore.get_element(context.active_object.BIMObjectProperties.ifc_definition_id):
-            return False
-        return bool(context.active_object.BIMObjectProperties.ifc_definition_id)
+        return bool(tool.Ifc.get_entity(context.active_object))
 
     def draw(self, context):
-        obj = context.active_object
-        self.oprops = obj.BIMObjectProperties
-        self.sprops = context.scene.BIMClassificationProperties
-        self.props = obj.BIMClassificationReferenceProperties
-        self.file = IfcStore.get_file()
-        if not Data.is_loaded:
-            Data.load(IfcStore.get_file())
-        if self.oprops.ifc_definition_id not in Data.products:
-            Data.load(IfcStore.get_file(), self.oprops.ifc_definition_id)
+        if not ClassificationReferencesData.is_loaded:
+            ClassificationReferencesData.load()
+        self.data = ClassificationReferencesData
+        self.obj = context.active_object.name
+        self.obj_type = "Object"
+        self.draw_ui(context)
 
-        self.draw_add_ui(context)
 
-        reference_ids = Data.products[self.oprops.ifc_definition_id]
-        if not reference_ids:
-            row = self.layout.row(align=True)
-            row.label(text="No References")
+class BIM_PT_material_classifications(Panel, ReferenceUI):
+    bl_label = "IFC Material Classifications"
+    bl_idname = "BIM_PT_material_classifications"
+    bl_options = {"DEFAULT_CLOSED"}
+    bl_space_type = "PROPERTIES"
+    bl_region_type = "WINDOW"
+    bl_context = "material"
 
-        for reference_id in reference_ids:
-            reference = Data.references[reference_id]
-            if self.props.active_reference_id == reference_id:
-                self.draw_editable_ui(reference)
-            else:
-                self.draw_ui(reference_id, reference)
+    @classmethod
+    def poll(cls, context):
+        if not tool.Ifc.get():
+            return False
+        try:
+            return bool(context.active_object.active_material.BIMObjectProperties.ifc_definition_id)
+        except:
+            return False
 
-    def draw_add_ui(self, context):
-        if not classification_prop.getClassifications(self.sprops, context):
-            return
+    def draw(self, context):
+        if not MaterialClassificationsData.is_loaded:
+            MaterialClassificationsData.load()
+        self.data = MaterialClassificationsData
+        self.obj = context.active_object.active_material.name
+        self.obj_type = "Material"
+        self.draw_ui(context)
 
-        name = Data.library_classifications[int(self.sprops.available_classifications)]
-        if name in [c["Name"] for c in Data.classifications.values()]:
-            row = self.layout.row(align=True)
-            row.prop(self.sprops, "available_classifications", text="")
-            if self.sprops.active_library_referenced_source:
-                op = row.operator("bim.change_classification_level", text="", icon="FRAME_PREV")
-                op.parent_id = self.sprops.active_library_referenced_source
-            op = row.operator("bim.add_classification_reference", text="", icon="ADD")
-            op.reference = self.sprops.available_library_references[
-                self.sprops.active_library_reference_index
-            ].ifc_definition_id
-            self.layout.template_list(
-                "BIM_UL_classifications",
-                "",
-                self.sprops,
-                "available_library_references",
-                self.sprops,
-                "active_library_reference_index",
-            )
 
-    def draw_editable_ui(self, reference):
-        row = self.layout.row(align=True)
-        row.prop(self.props.reference_attributes.get("Name"), "string_value", text="", icon="ASSET_MANAGER")
-        row.operator("bim.edit_classification_reference", text="", icon="CHECKMARK")
-        row.operator("bim.disable_editing_classification_reference", text="", icon="CANCEL")
+class BIM_PT_cost_classifications(Panel, ReferenceUI):
+    bl_label = "IFC Cost Classifications"
+    bl_idname = "BIM_PT_cost_classifications"
+    bl_options = {"DEFAULT_CLOSED"}
+    bl_space_type = "PROPERTIES"
+    bl_region_type = "WINDOW"
+    bl_context = "scene"
+    bl_parent_id = "BIM_PT_cost_schedules"
 
-        for attribute in self.props.reference_attributes:
-            if attribute.name == "Name":
-                continue
-            row = self.layout.row(align=True)
-            row.prop(attribute, "string_value", text=attribute.name)
-            if attribute.is_optional:
-                row.prop(attribute, "is_null", icon="RADIOBUT_OFF" if attribute.is_null else "RADIOBUT_ON", text="")
+    @classmethod
+    def poll(cls, context):
+        if not tool.Ifc.get():
+            return False
+        return bool(context.scene.BIMCostProperties.cost_items)
 
-    def draw_ui(self, reference_id, reference):
-        row = self.layout.row(align=True)
-        if self.file.schema == "IFC2X3":
-            name = reference["ItemReference"] or "No Identification"
-        else:
-            name = reference["Identification"] or "No Identification"
-        row.label(text=name, icon="ASSET_MANAGER")
-        row.label(text=reference["Name"] or "")
-        if not self.props.active_reference_id:
-            op = row.operator("bim.enable_editing_classification_reference", text="", icon="GREASEPENCIL")
-            op.reference = reference_id
-        row.operator("bim.remove_classification_reference", text="", icon="X").reference = reference_id
+    def draw(self, context):
+        if not CostClassificationsData.is_loaded:
+            CostClassificationsData.load()
+        self.data = CostClassificationsData
+        self.obj = ""
+        self.obj_type = "Cost"
+        self.draw_ui(context)
 
 
 class BIM_UL_classifications(UIList):

src/blenderbim/blenderbim/bim/module/constraint/prop.py

@@ -17,7 +17,9 @@
 # along with BlenderBIM Add-on.  If not, see <http://www.gnu.org/licenses/>.
 
 import bpy
-from blenderbim.bim.prop import StrProperty, Attribute
+from ifcopenshell.util.doc import get_entity_doc
+import blenderbim.tool as tool
+from blenderbim.bim.prop import Attribute
 from bpy.types import PropertyGroup
 from bpy.props import (
     PointerProperty,
@@ -31,6 +33,11 @@ from bpy.props import (
 )
 
 
+def get_available_constraint_types(self, context):
+    version = tool.Ifc.get_schema()
+    return [(c, c, get_entity_doc(version, c).get("description", "")) for c in ["IfcObjective"]]
+
+
 class Constraint(PropertyGroup):
     name: StringProperty(name="Name")
     ifc_definition_id: IntProperty(name="IFC Definition ID")
@@ -46,6 +53,4 @@ class BIMConstraintProperties(PropertyGroup):
 
 class BIMObjectConstraintProperties(PropertyGroup):
     is_adding: StringProperty(name="Is Adding")
-    available_constraint_types: EnumProperty(
-        items=[(c, c, "") for c in ["IfcObjective"]], name="Available Constraint Types"
-    )
+    available_constraint_types: EnumProperty(items=get_available_constraint_types, name="Available Constraint Types")

src/blenderbim/blenderbim/bim/module/context/ui.py

@@ -64,8 +64,8 @@ class BIM_PT_context(bpy.types.Panel):
                 row.operator("bim.remove_context", icon="X", text="").context = ifc_context["id"]
 
             row = box.row(align=True)
-            row.prop(props, "subcontexts", text="")
-            row.prop(props, "target_views", text="")
+            blenderbim.bim.helper.prop_with_search(row, props, "subcontexts", text="")
+            blenderbim.bim.helper.prop_with_search(row, props, "target_views", text="")
             op = row.operator("bim.add_context", icon="ADD", text="")
             op.context_type = ifc_context["context_type"]
             op.context_identifier = props.subcontexts

src/blenderbim/blenderbim/bim/module/cost/operator.py

@@ -27,7 +27,7 @@ from blenderbim.bim.ifc import IfcStore
 from bpy_extras.io_utils import ImportHelper
 from ifcopenshell.api.cost.data import Data
 from ifcopenshell.api.unit.data import Data as UnitData
-from ifcopenshell.api.resource.data import Data as ResourceData
+from blenderbim.bim.module.resource.data import ResourceData
 
 
 class AddCostSchedule(bpy.types.Operator):
@@ -604,7 +604,7 @@ class AddCostValue(bpy.types.Operator):
         value = ifcopenshell.api.run("cost.add_cost_value", self.file, parent=parent)
         ifcopenshell.api.run("cost.edit_cost_value", self.file, cost_value=value, attributes=attributes)
         if parent.is_a("IfcConstructionResource"):
-            ResourceData.load(self.file)
+            ResourceData.load()
         else:
             Data.load(self.file)
         return {"FINISHED"}
@@ -630,7 +630,7 @@ class RemoveCostItemValue(bpy.types.Operator):
             cost_value=self.file.by_id(self.cost_value),
         )
         if parent.is_a("IfcConstructionResource"):
-            ResourceData.load(self.file)
+            ResourceData.load()
         else:
             Data.load(self.file)
         return {"FINISHED"}
@@ -923,24 +923,26 @@ class LoadCostItemQuantities(bpy.types.Operator):
     def execute(self, context):
         self.props = context.scene.BIMCostProperties
         self.file = IfcStore.get_file()
+        Data.load(self.file)
         self.props.cost_item_products.clear()
         self.props.cost_item_processes.clear()
         self.props.cost_item_resources.clear()
-        ifc_definition_id = self.props.cost_items[self.props.active_cost_item_index].ifc_definition_id
-        for control_id, quantity_ids in Data.cost_items[ifc_definition_id]["Controls"].items():
-            related_object = self.file.by_id(control_id)
-            if related_object.is_a("IfcProduct"):
-                new = self.props.cost_item_products.add()
-            elif related_object.is_a("IfcProcess"):
-                new = self.props.cost_item_processes.add()
-            elif related_object.is_a("IfcResource"):
-                new = self.props.cost_item_resources.add()
-            new.ifc_definition_id = control_id
-            new.name = related_object.Name or "Unnamed"
-            total_quantity = 0
-            for quantity_id in quantity_ids:
-                total_quantity += self.file.by_id(quantity_id)[3]
-            new.total_quantity = total_quantity
+        if self.props.active_cost_item_index < len(self.props.cost_items):
+            ifc_definition_id = self.props.cost_items[self.props.active_cost_item_index].ifc_definition_id
+            for control_id, quantity_ids in Data.cost_items[ifc_definition_id]["Controls"].items() or {}:
+                related_object = self.file.by_id(control_id)
+                if related_object.is_a("IfcProduct"):
+                    new = self.props.cost_item_products.add()
+                elif related_object.is_a("IfcProcess"):
+                    new = self.props.cost_item_processes.add()
+                elif related_object.is_a("IfcResource"):
+                    new = self.props.cost_item_resources.add()
+                new.ifc_definition_id = control_id
+                new.name = related_object.Name or "Unnamed"
+                total_quantity = 0
+                for quantity_id in quantity_ids:
+                    total_quantity += self.file.by_id(quantity_id)[3]
+                new.total_quantity = total_quantity
         return {"FINISHED"}
 
 

src/blenderbim/blenderbim/bim/module/cost/prop.py

@@ -19,6 +19,7 @@
 import bpy
 import ifcopenshell.api
 from blenderbim.bim.ifc import IfcStore
+from blenderbim.bim.module.classification.data import CostClassificationsData
 from ifcopenshell.api.cost.data import Data
 from ifcopenshell.api.pset.data import Data as PsetData
 from blenderbim.bim.prop import StrProperty, Attribute
@@ -164,6 +165,7 @@ def update_active_cost_item_index(self, context):
         bpy.ops.bim.load_cost_item_types()
     else:
         bpy.ops.bim.load_cost_item_quantities()
+    CostClassificationsData.load()
 
 
 def update_cost_item_identification(self, context):

src/blenderbim/blenderbim/bim/module/cost/ui.py

@@ -343,6 +343,11 @@ class BIM_PT_cost_item_quantities(Panel):
         return False
 
     def draw(self, context):
+        if not Data.is_loaded:
+            Data.load(IfcStore.get_file())
+
+        if not UnitData.is_loaded:
+            UnitData.load(IfcStore.get_file())
         self.props = context.scene.BIMCostProperties
 
         cost_item = self.props.cost_items[self.props.active_cost_item_index]

src/blenderbim/blenderbim/bim/module/debug/operator.py

@@ -112,6 +112,7 @@ class CreateAllShapes(bpy.types.Operator):
     def execute(self, context):
         self.file = IfcStore.get_file()
         elements = self.file.by_type("IfcElement") + self.file.by_type("IfcSpace")
+
         total = len(elements)
         settings = ifcopenshell.geom.settings()
         failures = []

src/blenderbim/blenderbim/bim/module/debug/ui.py

@@ -94,7 +94,7 @@ class BIM_PT_debug(Panel):
                 op = row.operator("bim.select_global_id", icon="RESTRICT_SELECT_OFF", text="")
                 op.global_id = attribute.string_value
             if attribute.name == "ObjectPlacement":
-                op = row.operator("bim.print_object_placement", icon="TRACKER", text="")
+                op = row.operator("bim.print_object_placement", icon="OBJECT_ORIGIN", text="")
                 op.step_id = attribute.int_value
             if attribute.int_value:
                 row.operator(

src/blenderbim/blenderbim/bim/module/diff/__init__.py

@@ -25,6 +25,7 @@ classes = (
     operator.SelectDiffOldFile,
     operator.SelectDiffNewFile,
     operator.ExecuteIfcDiff,
+    prop.Relationships,
     prop.DiffProperties,
     ui.BIM_PT_diff,
 )

src/blenderbim/blenderbim/bim/module/diff/data.py

@@ -0,0 +1,86 @@
+# BlenderBIM Add-on - OpenBIM Blender Add-on
+# Copyright (C) 2022 Dion Moult <dion@thinkmoult.com>
+#
+# This file is part of BlenderBIM Add-on.
+#
+# BlenderBIM Add-on is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# BlenderBIM Add-on is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with BlenderBIM Add-on.  If not, see <http://www.gnu.org/licenses/>.
+
+import bpy
+import json
+import blenderbim.tool as tool
+
+
+def refresh():
+    DiffData.is_loaded = False
+
+
+class DiffData:
+    data = {}
+    is_loaded = False
+    diff_json_file = None
+    diff = None
+
+    @classmethod
+    def load(cls):
+        cls.data["diff_json"] = cls.diff_json()
+        cls.data["total_added"] = cls.total_added()
+        cls.data["total_deleted"] = cls.total_deleted()
+        cls.data["total_changed"] = cls.total_changed()
+        cls.data["changes"] = cls.changes()
+        cls.is_loaded = True
+
+    @classmethod
+    def diff_json(cls):
+        props = bpy.context.scene.DiffProperties
+        if not props.diff_json_file:
+            cls.diff = None
+            return
+        if props.diff_json_file != cls.diff_json_file:
+            cls.diff_json_file = props.diff_json_file
+            with open(props.diff_json_file, "r") as file:
+                cls.diff = json.load(file)
+        return cls.diff
+
+    @classmethod
+    def total_added(cls):
+        diff = cls.diff_json()
+        if diff:
+            return len(diff["added"])
+
+    @classmethod
+    def total_deleted(cls):
+        diff = cls.diff_json()
+        if diff:
+            return len(diff["deleted"])
+
+    @classmethod
+    def total_changed(cls):
+        diff = cls.diff_json()
+        if diff:
+            return len(diff["changed"].keys())
+
+    @classmethod
+    def changes(cls):
+        diff = cls.diff_json()
+        if not diff:
+            return {}
+        element = tool.Ifc.get_entity(bpy.context.active_object)
+        if not element or not hasattr(element, "GlobalId"):
+            return {}
+        changes = {k.upper().replace("_", " "): str(v) for k, v in diff["changed"].get(element.GlobalId, {}).items()}
+        if element.GlobalId in diff["added"]:
+            changes["Added"] = True
+        elif element.GlobalId in diff["deleted"]:
+            changes["Deleted"] = True
+        return changes

src/blenderbim/blenderbim/bim/module/diff/operator.py

@@ -17,10 +17,11 @@
 # along with BlenderBIM Add-on.  If not, see <http://www.gnu.org/licenses/>.
 
 import bpy
+import json
 import ifccsv
 import ifcopenshell
-import json
-from blenderbim.bim.ifc import IfcStore
+import blenderbim.bim.handler
+import blenderbim.tool as tool
 
 
 class SelectDiffJsonFile(bpy.types.Operator):
@@ -28,6 +29,7 @@ class SelectDiffJsonFile(bpy.types.Operator):
     bl_label = "Select Diff JSON File"
     bl_options = {"REGISTER", "UNDO"}
     filepath: bpy.props.StringProperty(subtype="FILE_PATH")
+    filter_glob: bpy.props.StringProperty(default="*.json", options={"HIDDEN"})
 
     def execute(self, context):
         context.scene.DiffProperties.diff_json_file = self.filepath
@@ -44,21 +46,23 @@ class VisualiseDiff(bpy.types.Operator):
     bl_options = {"REGISTER", "UNDO"}
 
     def execute(self, context):
-        # ifc_file = IfcStore.get_file() # In case we get from Store
-        ifc_file = ifcopenshell.open(context.scene.DiffProperties.diff_new_file)  # for Now refer to the new file
+        ifc_file = tool.Ifc.get()
         with open(context.scene.DiffProperties.diff_json_file, "r") as file:
             diff = json.load(file)
         for obj in context.visible_objects:
-            obj.color = (1.0, 1.0, 1.0, 0.2)
-            global_id = ifc_file.by_id(obj.BIMObjectProperties.ifc_definition_id).GlobalId
+            obj.color = (1.0, 1.0, 1.0, 1.0)
+            element = tool.Ifc.get_entity(obj)
+            if not element:
+                continue
+            global_id = getattr(element, "GlobalId", None)
             if not global_id:
                 continue
             if global_id in diff["deleted"]:
-                obj.color = (1.0, 0.0, 0.0, 0.2)
+                obj.color = (1.0, 0.0, 0.0, 1.0)
             elif global_id in diff["added"]:
-                obj.color = (0.0, 1.0, 0.0, 0.2)
+                obj.color = (0.0, 1.0, 0.0, 1.0)
             elif global_id in diff["changed"]:
-                obj.color = (0.0, 0.0, 1.0, 0.2)
+                obj.color = (0.0, 0.0, 1.0, 1.0)
         area = next(area for area in context.screen.areas if area.type == "VIEW_3D")
         area.spaces[0].shading.color_type = "OBJECT"
         return {"FINISHED"}
@@ -69,9 +73,10 @@ class SelectDiffOldFile(bpy.types.Operator):
     bl_label = "Select Diff Old File"
     bl_options = {"REGISTER", "UNDO"}
     filepath: bpy.props.StringProperty(subtype="FILE_PATH")
+    filter_glob: bpy.props.StringProperty(default="*.ifc", options={"HIDDEN"})
 
     def execute(self, context):
-        context.scene.DiffProperties.diff_old_file = self.filepath
+        context.scene.DiffProperties.old_file = self.filepath
         return {"FINISHED"}
 
     def invoke(self, context, event):
@@ -84,9 +89,10 @@ class SelectDiffNewFile(bpy.types.Operator):
     bl_label = "Select Diff New File"
     bl_options = {"REGISTER", "UNDO"}
     filepath: bpy.props.StringProperty(subtype="FILE_PATH")
+    filter_glob: bpy.props.StringProperty(default="*.ifc", options={"HIDDEN"})
 
     def execute(self, context):
-        context.scene.DiffProperties.diff_new_file = self.filepath
+        context.scene.DiffProperties.new_file = self.filepath
         return {"FINISHED"}
 
     def invoke(self, context, event):
@@ -109,13 +115,14 @@ class ExecuteIfcDiff(bpy.types.Operator):
     def execute(self, context):
         import ifcdiff
 
-        ifc_diff = ifcdiff.IfcDiff(
-            context.scene.DiffProperties.diff_old_file,
-            context.scene.DiffProperties.diff_new_file,
-            self.filepath,
-            context.scene.DiffProperties.diff_relationships.split(),
-        )
+        old = ifcopenshell.open(context.scene.DiffProperties.old_file)
+        new = ifcopenshell.open(context.scene.DiffProperties.new_file)
+        relationships = [r.relationship for r in context.scene.DiffProperties.diff_relationships]
+        query = context.scene.DiffProperties.diff_filter_elements
+
+        ifc_diff = ifcdiff.IfcDiff(old, new, relationships=relationships, filter_elements=query)
         ifc_diff.diff()
-        ifc_diff.export()
+        ifc_diff.export(self.filepath)
         context.scene.DiffProperties.diff_json_file = self.filepath
+        blenderbim.bim.handler.refresh_ui_data()
         return {"FINISHED"}

src/blenderbim/blenderbim/bim/module/diff/prop.py

@@ -18,6 +18,7 @@
 
 import bpy
 from blenderbim.bim.prop import StrProperty
+from blenderbim.bim.module.diff.data import DiffData
 from bpy.types import PropertyGroup
 from bpy.props import (
     PointerProperty,
@@ -31,8 +32,20 @@ from bpy.props import (
 )
 
 
+def update_diff_json_file(self, context):
+    DiffData.data["diff_json"] = DiffData.diff_json()
+
+
+class Relationships(PropertyGroup):
+    relationship: EnumProperty(
+        name="Relationship",
+        items=[(r, r.capitalize(), r) for r in ["type", "property", "container", "aggregate", "classification"]],
+    )
+
+
 class DiffProperties(PropertyGroup):
-    diff_json_file: StringProperty(default="", name="Diff JSON File")
-    diff_old_file: StringProperty(default="", name="Diff Old IFC File")
-    diff_new_file: StringProperty(default="", name="Diff New IFC File")
-    diff_relationships: StringProperty(default="", name="Diff Relationships")
+    diff_json_file: StringProperty(default="", name="JSON Output", update=update_diff_json_file)
+    old_file: StringProperty(default="", name="Old IFC File")
+    new_file: StringProperty(default="", name="New IFC File")
+    diff_relationships: CollectionProperty(type=Relationships, name="Relationships")
+    diff_filter_elements: StringProperty(default="", name="Filter")

src/blenderbim/blenderbim/bim/module/diff/ui.py

@@ -18,6 +18,9 @@
 
 from bpy.types import Panel
 from blenderbim.bim.ifc import IfcStore
+from blenderbim.bim.module.diff.data import DiffData
+import blenderbim.tool as tool
+import json
 
 
 class BIM_PT_diff(Panel):
@@ -30,30 +33,70 @@ class BIM_PT_diff(Panel):
     bl_parent_id = "BIM_PT_quality_control"
 
     def draw(self, context):
+        if not DiffData.is_loaded:
+            DiffData.load()
+
         layout = self.layout
         layout.use_property_split = True
 
         scene = context.scene
-        bim_properties = scene.DiffProperties
+        props = scene.DiffProperties
 
         layout.label(text="IFC Diff Setup:")
 
         row = layout.row(align=True)
-        row.prop(bim_properties, "diff_old_file")
+        row.prop(props, "old_file")
         row.operator("bim.select_diff_old_file", icon="FILE_FOLDER", text="")
 
         row = layout.row(align=True)
-        row.prop(bim_properties, "diff_new_file")
+        row.prop(props, "new_file")
         row.operator("bim.select_diff_new_file", icon="FILE_FOLDER", text="")
 
         row = layout.row(align=True)
-        row.prop(bim_properties, "diff_relationships")
+        row.prop(props, "diff_relationships")
+        row.context_pointer_set("bim_prop_group", props)
+        add = row.operator("bim.edit_blender_collection", icon="ADD", text="")
+        add.option = "add"
+        add.collection = "diff_relationships"
+
+        for index, r in enumerate(props.diff_relationships):
+            row = layout.row(align=True)
+            row.context_pointer_set("bim_prop_group", props)
+            row.prop(r, "relationship", text=" ")
+            remove = row.operator("bim.edit_blender_collection", icon="REMOVE", text="")
+            remove.option = "remove"
+            remove.collection = "diff_relationships"
+            remove.index = index
+
+        row = layout.row(align=True)
+        row.prop(props, "diff_filter_elements")
+        row.operator("bim.ifc_selector", icon="FILTER", text="")
 
         row = layout.row()
         row.operator("bim.execute_ifc_diff")
 
-        # TODO: show if there ifc diff operation is sucessful
         row = layout.row(align=True)
-        row.prop(bim_properties, "diff_json_file")
+        row.prop(props, "diff_json_file")
         row.operator("bim.select_diff_json_file", icon="FILE_FOLDER", text="")
         row.operator("bim.visualise_diff", icon="HIDE_OFF", text="")
+
+        if DiffData.data["diff_json"]:
+            row = layout.row()
+            row.alignment = "CENTER"
+            row.label(text=f"{DiffData.data['total_added']} added")
+            row.label(text=f"{DiffData.data['total_deleted']} deleted")
+            row.label(text=f"{DiffData.data['total_changed']} changed")
+
+        if DiffData.data["changes"]:
+            box = layout.box()
+            row = box.row()
+            row.label(text="Active Object Changes:")
+            for key, value in DiffData.data["changes"].items():
+                row = box.row()
+                if key == "Added":
+                    icon = "ADD"
+                elif key == "Deleted":
+                    icon = "X"
+                else:
+                    icon = "GREASEPENCIL"
+                row.label(text=key, icon=icon)

src/blenderbim/blenderbim/bim/module/document/data.py

@@ -84,21 +84,28 @@ class ObjectDocumentData:
                     continue
 
                 name = rel.RelatingDocument.Name
-                if not name and rel.RelatingDocument.ReferencedDocument:
-                    name = rel.RelatingDocument.ReferencedDocument.Name
 
                 if tool.Ifc.get_schema() == "IFC2X3":
+                    if not name and rel.RelatingDocument.ReferenceToDocument:
+                        name = rel.RelatingDocument.ReferenceToDocument[0].Name
+
                     identification = rel.RelatingDocument.ItemReference
-                    if not identification and rel.RelatingDocument.ReferencedDocument:
-                        identification = rel.RelatingDocument.ReferencedDocument.DocumentId
+                    if not identification and rel.RelatingDocument.ReferenceToDocument:
+                        identification = rel.RelatingDocument.ReferenceToDocument[0].DocumentId
+
+                    location = rel.RelatingDocument.Location
                 else:
+                    if not name and rel.RelatingDocument.ReferencedDocument:
+                        name = rel.RelatingDocument.ReferencedDocument.Name
+
                     identification = rel.RelatingDocument.Identification
                     if not identification and rel.RelatingDocument.ReferencedDocument:
                         identification = rel.RelatingDocument.ReferencedDocument.Identification
 
-                location = rel.RelatingDocument.Location
-                if location is None and rel.RelatingDocument.ReferencedDocument:
-                    location = rel.RelatingDocument.ReferencedDocument.Location
+                    location = rel.RelatingDocument.Location
+                    if location is None and rel.RelatingDocument.ReferencedDocument:
+                        location = rel.RelatingDocument.ReferencedDocument.Location
+
                 if location:
                     if not "://" in location:
                         if not os.path.isabs(location):

src/blenderbim/blenderbim/bim/module/drawing/__init__.py

@@ -34,20 +34,19 @@ classes = (
     operator.BuildSchedule,
     operator.CleanWireframes,
     operator.ContractSheet,
-    operator.ConvertEdgeToArc,
     operator.CopyGrid,
     operator.CreateDrawing,
     operator.CreateSheets,
+    operator.DisableEditingAssignedProduct,
     operator.DisableEditingDrawings,
     operator.DisableEditingSchedules,
     operator.DisableEditingSheets,
     operator.DisableEditingText,
-    operator.DisableEditingTextProduct,
+    operator.EditAssignedProduct,
     operator.EditText,
-    operator.EditTextProduct,
     operator.EditVectorStyle,
+    operator.EnableEditingAssignedProduct,
     operator.EnableEditingText,
-    operator.EnableEditingTextProduct,
     operator.ExpandSheet,
     operator.LoadDrawings,
     operator.LoadSchedules,
@@ -72,12 +71,14 @@ classes = (
     prop.DocProperties,
     prop.BIMCameraProperties,
     prop.BIMTextProperties,
+    prop.BIMAssignedProductProperties,
     ui.BIM_PT_camera,
     ui.BIM_PT_drawing_underlay,
     ui.BIM_PT_annotation_utilities,
     ui.BIM_PT_sheets,
     ui.BIM_PT_drawings,
     ui.BIM_PT_schedules,
+    ui.BIM_PT_product_assignments,
     ui.BIM_PT_text,
     ui.BIM_UL_drawinglist,
     ui.BIM_UL_sheets,
@@ -92,6 +93,7 @@ classes = (
 def register():
     bpy.types.Scene.DocProperties = bpy.props.PointerProperty(type=prop.DocProperties)
     bpy.types.Camera.BIMCameraProperties = bpy.props.PointerProperty(type=prop.BIMCameraProperties)
+    bpy.types.Object.BIMAssignedProductProperties = bpy.props.PointerProperty(type=prop.BIMAssignedProductProperties)
     bpy.types.Object.BIMTextProperties = bpy.props.PointerProperty(type=prop.BIMTextProperties)
     bpy.types.TextCurve.BIMTextProperties = bpy.props.PointerProperty(type=prop.BIMTextProperties)
     bpy.app.handlers.load_post.append(handler.toggleDecorationsOnLoad)
@@ -101,6 +103,8 @@ def register():
 def unregister():
     del bpy.types.Scene.DocProperties
     del bpy.types.Camera.BIMCameraProperties
+    del bpy.types.Object.BIMAssignedProductProperties
+    del bpy.types.Object.BIMTextProperties
     del bpy.types.TextCurve.BIMTextProperties
     bpy.app.handlers.load_post.remove(handler.toggleDecorationsOnLoad)
     bpy.app.handlers.depsgraph_update_pre.remove(handler.depsgraph_update_pre_handler)

src/blenderbim/blenderbim/bim/module/drawing/annotation.py

@@ -151,10 +151,17 @@ class Annotator:
         return obj
 
     @staticmethod
-    def get_annotation_obj(object_type, data_type):
-        collection = bpy.context.scene.camera.users_collection[0]
+    def get_annotation_obj(drawing, object_type, data_type):
+        camera = tool.Ifc.get_object(drawing)
+        co1, _, _, _ = Annotator.get_placeholder_coords(camera)
+        matrix_world = camera.matrix_world.copy()
+        matrix_world[0][3] = co1.x
+        matrix_world[1][3] = co1.y
+        matrix_world[2][3] = co1.z
+        collection = camera.users_collection[0]
         if object_type == "TEXT":
             obj = bpy.data.objects.new(object_type, None)
+            obj.matrix_world = matrix_world
             collection.objects.link(obj)
             return obj
         elif object_type in ("TEXT_LEADER", "SECTION_LEVEL"):
@@ -162,12 +169,14 @@ class Annotator:
             data.dimensions = "3D"
             data.resolution_u = 2
             obj = bpy.data.objects.new(object_type, data)
+            obj.matrix_world = matrix_world
             collection.objects.link(obj)
             return obj
-        for obj in collection.objects:
-            element = tool.Ifc.get_entity(obj)
-            if element and element.ObjectType == object_type:
-                return obj
+        if object_type != "ANGLE":
+            for obj in collection.objects:
+                element = tool.Ifc.get_entity(obj)
+                if element and element.ObjectType == object_type:
+                    return obj
         if data_type == "mesh":
             data = bpy.data.meshes.new(object_type)
         elif data_type == "curve":
@@ -175,12 +184,14 @@ class Annotator:
             data.dimensions = "3D"
             data.resolution_u = 2
         obj = bpy.data.objects.new(object_type, data)
+        obj.matrix_world = matrix_world
         collection.objects.link(obj)
         return obj
 
     @staticmethod
-    def get_placeholder_coords():
-        camera = bpy.context.scene.camera
+    def get_placeholder_coords(camera=None):
+        if not camera:
+            camera = bpy.context.scene.camera
         z_offset = camera.matrix_world.to_quaternion() @ Vector((0, 0, -1))
         if bpy.context.scene.render.resolution_x > bpy.context.scene.render.resolution_y:
             y = (

src/blenderbim/blenderbim/bim/module/drawing/data.py

@@ -22,19 +22,40 @@ import blenderbim.tool as tool
 
 
 def refresh():
+    ProductAssignmentsData.is_loaded = False
     TextData.is_loaded = False
     SheetsData.is_loaded = False
     SchedulesData.is_loaded = False
     DrawingsData.is_loaded = False
 
 
+class ProductAssignmentsData:
+    data = {}
+    is_loaded = False
+
+    @classmethod
+    def load(cls):
+        cls.data = {"relating_product": cls.relating_product()}
+        cls.is_loaded = True
+
+    @classmethod
+    def relating_product(cls):
+        element = tool.Ifc.get_entity(bpy.context.active_object)
+        if not element or not element.is_a("IfcAnnotation"):
+            return
+        for rel in element.HasAssignments:
+            if rel.is_a("IfcRelAssignsToProduct"):
+                name = rel.RelatingProduct.Name or "Unnamed"
+                return f"{rel.RelatingProduct.is_a()}/{name}"
+
+
 class TextData:
     data = {}
     is_loaded = False
 
     @classmethod
     def load(cls):
-        cls.data = {"attributes": cls.attributes(), "relating_product": cls.relating_product()}
+        cls.data = {"attributes": cls.attributes()}
         cls.is_loaded = True
 
     @classmethod
@@ -49,15 +70,6 @@ class TextData:
             {"name": "BoxAlignment", "value": text_literal.BoxAlignment},
         ]
 
-    @classmethod
-    def relating_product(cls):
-        element = tool.Ifc.get_entity(bpy.context.active_object)
-        if not element or not element.is_a("IfcAnnotation") or element.ObjectType not in ["TEXT", "TEXT_LEADER"]:
-            return
-        for rel in element.HasAssignments:
-            if rel.is_a("IfcRelAssignsToProduct"):
-                return rel.RelatingProduct.Name or "Unnamed"
-
 
 class SheetsData:
     data = {}

src/blenderbim/blenderbim/bim/module/drawing/gizmos.py

@@ -317,7 +317,7 @@ class OffsetHandle:
         base = Vector((0, 0, 0))
         axis = Vector((0, 0, 1))
 
-        # projecttion of the arrow to a plane, perpendicular to view ray
+        # projection of the arrow to a plane, perpendicular to view ray
         axis_proj = axis - ray_norm * axis.dot(ray_norm)
 
         # intersection of the axis with the plane through view origin perpendicular to the arrow projection

src/blenderbim/blenderbim/bim/module/drawing/helper.py

@@ -88,17 +88,17 @@ class BoundingBox:
     def intersect(self, bb):
         retVal = False
         if self.vertex != None and bb.vertex != None:
-            # check all the faces of this object for a seperation axis
+            # check all the faces of this object for a separation axis
             for i, f in enumerate(self.face):
                 d = f.normal
                 if self.whichSide(bb.vertex, d, f.vertex[0]) > 0:
-                    return False  # all the vertexes are on the +ve side of the face
+                    return False  # all the vertices are on the +ve side of the face
 
             # now do it again for the other objects faces
             for i, f in enumerate(bb.face):
                 d = f.normal
                 if self.whichSide(self.vertex, d, f.vertex[0]) > 0:
-                    return False  # all the vertexes are on the +ve side of the face
+                    return False  # all the vertices are on the +ve side of the face
 
             # do edge checks
             for e1 in self.edge:
@@ -139,7 +139,7 @@ def format_distance(value, isArea=False, hide_units=True):
 
     value *= scaleFactor
 
-    # Imperial Formating
+    # Imperial Formatting
     if unit_system == "IMPERIAL":
         precision = bpy.context.scene.BIMProperties.imperial_precision
         if precision == "NONE":
@@ -152,7 +152,7 @@ def format_distance(value, isArea=False, hide_units=True):
         base = int(precision)
         decInches = value * toInches
 
-        # Seperate ft and inches
+        # Separate ft and inches
         # Unless Inches are the specified Length Unit
         if unit_length != "INCHES":
             feet = math.floor(decInches / inPerFoot)
@@ -160,7 +160,7 @@ def format_distance(value, isArea=False, hide_units=True):
         else:
             feet = 0
 
-        # Seperate Fractional Inches
+        # Separate Fractional Inches
         inches = math.floor(decInches)
         if inches != 0:
             frac = round(base * (decInches - inches))
@@ -202,7 +202,7 @@ def format_distance(value, isArea=False, hide_units=True):
         else:
             tx_dist = str("%1.3f" % (value * toInches / inPerFoot)) + " sq. ft."
 
-    # METRIC FORMATING
+    # METRIC FORMATTING
     elif unit_system == "METRIC":
         precision = bpy.context.scene.BIMProperties.metric_precision
         if precision != 0:

src/blenderbim/blenderbim/bim/module/drawing/operator.py

@@ -40,7 +40,8 @@ import blenderbim.bim.module.drawing.scheduler as scheduler
 import blenderbim.bim.module.drawing.helper as helper
 import blenderbim.bim.export_ifc
 from lxml import etree
-from mathutils import Vector, Matrix, Euler, geometry
+from mathutils import Vector
+from timeit import default_timer as timer
 from blenderbim.bim.module.drawing.prop import RasterStyleProperty
 from blenderbim.bim.ifc import IfcStore
 from ifcopenshell.api.group.data import Data as GroupData
@@ -49,6 +50,21 @@ from ifcopenshell.api.pset.data import Data as PsetData
 cwd = os.path.dirname(os.path.realpath(__file__))
 
 
+class profile:
+    """
+    A python context manager timing utility
+    """
+
+    def __init__(self, task):
+        self.task = task
+
+    def __enter__(self):
+        self.start = timer()
+
+    def __exit__(self, *args):
+        print(self.task, timer() - self.start)
+
+
 def open_with_user_command(user_command, path):
     if user_command:
         commands = eval(user_command)
@@ -115,53 +131,75 @@ class CreateDrawing(bpy.types.Operator):
         self.camera = context.scene.camera
         self.camera_element = tool.Ifc.get_entity(self.camera)
         self.file = IfcStore.get_file()
-        self.time = None
-        start = time.time()
-        self.profile_code("Start drawing generation process")
-        self.props = context.scene.DocProperties
-        self.cprops = self.camera.data.BIMCameraProperties
-        self.drawing_name = self.file.by_id(self.camera.BIMObjectProperties.ifc_definition_id).Name
-        self.get_scale()
-        if self.cprops.update_representation(self.camera):
-            bpy.ops.bim.update_representation(obj=self.camera.name, ifc_representation_class="")
-        underlay_svg = self.generate_underlay(context)
-        self.profile_code("Generate underlay")
-        linework_svg = self.generate_linework(context)
-        self.profile_code("Generate linework")
-        annotation_svg = self.generate_annotation(context)
-        self.profile_code("Generate annotation")
-        svg_path = self.combine_svgs(context, underlay_svg, linework_svg, annotation_svg)
-        self.profile_code("Combine SVG layers")
+
+        with profile("Drawing generation process"):
+
+            with profile("Initialize drawing generation process"):
+                self.props = context.scene.DocProperties
+                self.cprops = self.camera.data.BIMCameraProperties
+                self.drawing_name = self.file.by_id(self.camera.BIMObjectProperties.ifc_definition_id).Name
+                self.get_scale()
+                if self.cprops.update_representation(self.camera):
+                    bpy.ops.bim.update_representation(obj=self.camera.name, ifc_representation_class="")
+
+                self.svg_writer = svgwriter.SvgWriter()
+                self.svg_writer.human_scale = self.human_scale
+                self.svg_writer.scale = self.scale
+                self.svg_writer.data_dir = context.scene.BIMProperties.data_dir
+                self.svg_writer.camera = self.camera
+                self.svg_writer.camera_width, self.svg_writer.camera_height = self.get_camera_dimensions()
+                self.svg_writer.camera_projection = tuple(self.camera.matrix_world.to_quaternion() @ Vector((0, 0, -1)))
+
+            with profile("Generate underlay"):
+                underlay_svg = self.generate_underlay(context)
+
+            with profile("Generate linework"):
+                linework_svg = self.generate_linework(context)
+
+            with profile("Generate annotation"):
+                annotation_svg = self.generate_annotation(context)
+
+            with profile("Combine SVG layers"):
+                svg_path = self.combine_svgs(context, underlay_svg, linework_svg, annotation_svg)
+
         open_with_user_command(context.preferences.addons["blenderbim"].preferences.svg_command, svg_path)
-        print("Total Time: {:.2f}".format(time.time() - start))
+
         return {"FINISHED"}
 
-    def profile_code(self, message):
-        if not self.time:
-            self.time = time.time()
-        print("{} :: {:.2f}".format(message, time.time() - self.time))
-        self.time = time.time()
+    def get_camera_dimensions(self):
+        render = bpy.context.scene.render
+        if self.is_landscape(render):
+            width = self.camera.data.ortho_scale
+            height = width / render.resolution_x * render.resolution_y
+        else:
+            height = self.camera.data.ortho_scale
+            width = height / render.resolution_y * render.resolution_x
+        return width, height
 
     def combine_svgs(self, context, underlay, linework, annotation):
         # Hacky :)
         svg_path = os.path.join(context.scene.BIMProperties.data_dir, "diagrams", self.drawing_name + ".svg")
         with open(svg_path, "w") as outfile:
-            has_boilerplate = False
+            pset = ifcopenshell.util.element.get_psets(self.camera_element)["EPset_Drawing"]
+            self.svg_writer.create_blank_svg(svg_path).define_boilerplate(
+                pset.get("Stylesheet"), pset.get("Markers"), pset.get("Symbols"), pset.get("Patterns")
+            )
+            boilerplate = self.svg_writer.svg.tostring()
+            outfile.write(boilerplate.replace("</svg>", ""))
             if underlay:
                 with open(underlay) as infile:
-                    for line in infile:
-                        if "<svg " in line:
-                            line = line.replace('">', '" xmlns:ifc="http://www.ifcopenshell.org/ns">')
-                        if "</svg>" in line:
+                    for i, line in enumerate(infile):
+                        if i < 2:
+                            continue
+                        elif "</svg>" in line:
                             continue
                         outfile.write(line)
                 shutil.copyfile(underlay[0:-4] + ".png", svg_path[0:-4] + "-underlay.png")
-                has_boilerplate = True
             if linework:
                 with open(linework) as infile:
                     should_skip = False
                     for i, line in enumerate(infile):
-                        if has_boilerplate and i == 0:
+                        if i == 0:
                             continue
                         if "</svg>" in line:
                             continue
@@ -174,11 +212,10 @@ class CreateDrawing(bpy.types.Operator):
                         elif should_skip:
                             continue
                         outfile.write(line)
-                has_boilerplate = True
             if annotation:
                 with open(annotation) as infile:
                     for i, line in enumerate(infile):
-                        if has_boilerplate and i in [0, 1]:
+                        if i < 2:
                             continue
                         if "</svg>" in line:
                             continue
@@ -223,25 +260,7 @@ class CreateDrawing(bpy.types.Operator):
             for name, value in previous_visibility.items():
                 bpy.data.objects[name].hide_set(value)
 
-        svg_writer = svgwriter.SvgWriter()
-        render = context.scene.render
-        if self.is_landscape(render):
-            width = self.camera.data.ortho_scale
-            height = width / render.resolution_x * render.resolution_y
-        else:
-            height = self.camera.data.ortho_scale
-            width = height / render.resolution_y * render.resolution_x
-        svg_writer.human_scale = self.human_scale
-        svg_writer.scale = self.scale
-        svg_writer.output = svg_path
-        svg_writer.data_dir = context.scene.BIMProperties.data_dir
-        svg_writer.vector_style = drawing_style.vector_style
-        svg_writer.camera = self.camera
-        svg_writer.camera_width = width
-        svg_writer.camera_height = height
-        svg_writer.camera_projection = tuple(self.camera.matrix_world.to_quaternion() @ Vector((0, 0, -1)))
-        svg_writer.background_image = context.scene.render.filepath
-        svg_writer.write("underlay")
+        self.svg_writer.create_blank_svg(svg_path).draw_underlay(context.scene.render.filepath).save()
         return svg_path
 
     def generate_linework(self, context):
@@ -251,13 +270,14 @@ class CreateDrawing(bpy.types.Operator):
         if os.path.isfile(svg_path) and self.props.should_use_linework_cache:
             return svg_path
 
-        # All very hackish whilst prototyping
-        exporter = blenderbim.bim.export_ifc.IfcExporter(None)
-        exporter.file = tool.Ifc.get()
-        invalidated_guids = exporter.sync_deletions()
-        invalidated_elements = exporter.sync_all_objects()
-        invalidated_elements += exporter.sync_edited_objects()
-        [invalidated_guids.append(e.GlobalId) for e in invalidated_elements if hasattr(e, "GlobalId")]
+        with profile("sync"):
+            # All very hackish whilst prototyping
+            exporter = blenderbim.bim.export_ifc.IfcExporter(None)
+            exporter.file = tool.Ifc.get()
+            invalidated_guids = exporter.sync_deletions()
+            invalidated_elements = exporter.sync_all_objects()
+            invalidated_elements += exporter.sync_edited_objects()
+            [invalidated_guids.append(e.GlobalId) for e in invalidated_elements if hasattr(e, "GlobalId")]
 
         # If we have already calculated it in the SVG in the past, don't recalculate
         edited_guids = set()
@@ -308,40 +328,46 @@ class CreateDrawing(bpy.types.Operator):
             cache = IfcStore.get_cache()
             [cache.remove(guid) for guid in invalidated_guids]
 
-            if target_view_contexts and elements:
-                geom_settings = ifcopenshell.geom.settings(
-                    DISABLE_TRIANGULATION=True, STRICT_TOLERANCE=True, INCLUDE_CURVES=True
-                )
-                geom_settings.set_context_ids(target_view_contexts)
-                it = ifcopenshell.geom.iterator(geom_settings, ifc, multiprocessing.cpu_count(), include=elements)
-                it.set_cache(cache)
-                processed = set()
-                for elem in self.yield_from_iterator(it):
-                    processed.add(ifc.by_id(elem.id))
-                    self.serialiser.write(elem)
-                elements -= processed
+            with profile("Processing target view context"):
+                if target_view_contexts and elements:
+                    geom_settings = ifcopenshell.geom.settings(
+                        DISABLE_TRIANGULATION=True, STRICT_TOLERANCE=True, INCLUDE_CURVES=True
+                    )
+                    geom_settings.set_context_ids(target_view_contexts)
+                    it = ifcopenshell.geom.iterator(geom_settings, ifc, multiprocessing.cpu_count(), include=elements)
+                    it.set_cache(cache)
+                    processed = set()
+                    for elem in self.yield_from_iterator(it):
+                        processed.add(ifc.by_id(elem.id))
+                        self.serialiser.write(elem)
+                    elements -= processed
 
-            if body_contexts and elements:
+            with profile("Processing body context"):
+                if body_contexts and elements:
+                    geom_settings = ifcopenshell.geom.settings(DISABLE_TRIANGULATION=True, STRICT_TOLERANCE=True)
+                    geom_settings.set_context_ids(body_contexts)
+                    it = ifcopenshell.geom.iterator(geom_settings, ifc, multiprocessing.cpu_count(), include=elements)
+                    it.set_cache(cache)
+                    for elem in self.yield_from_iterator(it):
+                        self.serialiser.write(elem)
+
+            with profile("Camera element"):
+                # @todo tfk: is this needed?
                 geom_settings = ifcopenshell.geom.settings(DISABLE_TRIANGULATION=True, STRICT_TOLERANCE=True)
-                geom_settings.set_context_ids(body_contexts)
-                it = ifcopenshell.geom.iterator(geom_settings, ifc, multiprocessing.cpu_count(), include=elements)
-                it.set_cache(cache)
+                it = ifcopenshell.geom.iterator(geom_settings, ifc, include=[self.camera_element])
                 for elem in self.yield_from_iterator(it):
                     self.serialiser.write(elem)
 
-            geom_settings = ifcopenshell.geom.settings(DISABLE_TRIANGULATION=True, STRICT_TOLERANCE=True)
-            it = ifcopenshell.geom.iterator(geom_settings, ifc, include=[self.camera_element])
-            for elem in self.yield_from_iterator(it):
-                self.serialiser.write(elem)
-
-        self.serialiser.finalize()
+        with profile("Finalizing"):
+            self.serialiser.finalize()
         results = self.svg_buffer.get_value()
 
-        root = etree.fromstring(results)
-        self.enrich_linework_with_metadata(root)
-        self.move_projection_to_bottom(root)
-        with open(svg_path, "wb") as svg:
-            svg.write(etree.tostring(root))
+        with profile("Post processing"):
+            root = etree.fromstring(results)
+            self.enrich_linework_with_metadata(root)
+            self.move_projection_to_bottom(root)
+            with open(svg_path, "wb") as svg:
+                svg.write(etree.tostring(root))
 
         return svg_path
 
@@ -415,35 +441,13 @@ class CreateDrawing(bpy.types.Operator):
         if os.path.isfile(svg_path) and self.props.should_use_annotation_cache:
             return svg_path
 
-        camera = self.camera
-        svg_writer = svgwriter.SvgWriter()
-
-        drawing_style = context.scene.DocProperties.drawing_styles[self.cprops.active_drawing_style_index]
-
-        render = context.scene.render
-        if self.is_landscape(render):
-            width = camera.data.ortho_scale
-            height = width / render.resolution_x * render.resolution_y
-        else:
-            height = camera.data.ortho_scale
-            width = height / render.resolution_y * render.resolution_x
-
-        svg_writer.human_scale = self.human_scale
-        svg_writer.scale = self.scale
-        svg_writer.output = svg_path
-        svg_writer.data_dir = context.scene.BIMProperties.data_dir
-        svg_writer.vector_style = drawing_style.vector_style
-        svg_writer.camera = camera
-        svg_writer.camera_width = width
-        svg_writer.camera_height = height
-        svg_writer.camera_projection = tuple(camera.matrix_world.to_quaternion() @ Vector((0, 0, -1)))
-
         elements = tool.Drawing.get_group_elements(tool.Drawing.get_drawing_group(self.camera_element))
-        svg_writer.annotations = sorted(elements, key=lambda a: tool.Drawing.get_annotation_z_index(a))
-        svg_writer.metadata = tool.Drawing.get_drawing_metadata(self.camera_element)
+        annotations = sorted(elements, key=lambda a: tool.Drawing.get_annotation_z_index(a))
 
-        svg_writer.write("annotation")
-        return svg_writer.output
+        self.svg_writer.metadata = tool.Drawing.get_drawing_metadata(self.camera_element)
+        self.svg_writer.create_blank_svg(svg_path).draw_annotations(annotations).save()
+
+        return svg_path
 
     def get_scale(self):
         if self.camera.data.BIMCameraProperties.diagram_scale == "CUSTOM":
@@ -505,8 +509,11 @@ class AddAnnotation(bpy.types.Operator, Operator):
     def _execute(self, context):
         drawing = tool.Ifc.get_entity(context.scene.camera)
         if not drawing:
+            self.report({"WARNING"}, "Not a BIM camera")
             return
-        core.add_annotation(tool.Ifc, tool.Collector, tool.Drawing, drawing=drawing, object_type=self.object_type)
+        r = core.add_annotation(tool.Ifc, tool.Collector, tool.Drawing, drawing=drawing, object_type=self.object_type)
+        if isinstance(r, str):
+            self.report({"WARNING"}, r)
 
 
 class AddSheet(bpy.types.Operator, Operator):
@@ -1188,7 +1195,7 @@ class AddSectionsAnnotations(bpy.types.Operator):
         ]
 
         def sideview(cam):
-            # leftmost and righmost points of camera view area, local coords
+            # leftmost and rightmost points of camera view area, local coords
             xmin, xmax, _, _, _, _ = helper.ortho_view_frame(cam.data, margin=0)
             proj = camera.matrix_world.inverted() @ cam.matrix_world
             p_l = proj @ Vector((xmin, 0, 0))
@@ -1246,34 +1253,34 @@ class DisableEditingText(bpy.types.Operator, Operator):
         core.disable_editing_text(tool.Drawing, obj=context.active_object)
 
 
-class EditTextProduct(bpy.types.Operator, Operator):
-    bl_idname = "bim.edit_text_product"
+class EditAssignedProduct(bpy.types.Operator, Operator):
+    bl_idname = "bim.edit_assigned_product"
     bl_label = "Edit Text Product"
     bl_options = {"REGISTER", "UNDO"}
 
     def _execute(self, context):
         product = None
-        if context.active_object.BIMTextProperties.relating_product:
-            product = tool.Ifc.get_entity(context.active_object.BIMTextProperties.relating_product)
-        core.edit_text_product(tool.Ifc, tool.Drawing, obj=context.active_object, product=product)
+        if context.active_object.BIMAssignedProductProperties.relating_product:
+            product = tool.Ifc.get_entity(context.active_object.BIMAssignedProductProperties.relating_product)
+        core.edit_assigned_product(tool.Ifc, tool.Drawing, obj=context.active_object, product=product)
 
 
-class EnableEditingTextProduct(bpy.types.Operator, Operator):
-    bl_idname = "bim.enable_editing_text_product"
+class EnableEditingAssignedProduct(bpy.types.Operator, Operator):
+    bl_idname = "bim.enable_editing_assigned_product"
     bl_label = "Enable Editing Text Product"
     bl_options = {"REGISTER", "UNDO"}
 
     def _execute(self, context):
-        core.enable_editing_text_product(tool.Drawing, obj=context.active_object)
+        core.enable_editing_assigned_product(tool.Drawing, obj=context.active_object)
 
 
-class DisableEditingTextProduct(bpy.types.Operator, Operator):
-    bl_idname = "bim.disable_editing_text_product"
+class DisableEditingAssignedProduct(bpy.types.Operator, Operator):
+    bl_idname = "bim.disable_editing_assigned_product"
     bl_label = "Disable Editing Text Product"
     bl_options = {"REGISTER", "UNDO"}
 
     def _execute(self, context):
-        core.disable_editing_text_product(tool.Drawing, obj=context.active_object)
+        core.disable_editing_assigned_product(tool.Drawing, obj=context.active_object)
 
 
 class LoadSheets(bpy.types.Operator, Operator):
@@ -1356,44 +1363,3 @@ class ContractSheet(bpy.types.Operator):
             sheet.is_expanded = False
         core.load_sheets(tool.Drawing)
         return {"FINISHED"}
-
-
-class ConvertEdgeToArc(bpy.types.Operator):
-    bl_idname = "bim.convert_edge_to_arc"
-    bl_label = "Convert Edge to Arc"
-    bl_options = {"REGISTER", "UNDO"}
-
-    resolution: bpy.props.IntProperty(name="Arc Resolution", min=1, default=1)
-    should_flip: bpy.props.BoolProperty(name="Flip", description="Flip arc", default=False)
-
-    def draw(self, context):
-        layout = self.layout
-        for prop in self.__class__.__annotations__.keys():
-            layout.prop(self, prop)
-
-    def execute(self, context):
-        if bpy.context.mode != "EDIT_MESH":
-            return {"CANCELLED"}
-        obj = bpy.context.active_object
-        cursor = obj.matrix_world.inverted() @ bpy.context.scene.cursor.location
-        mesh = obj.data
-        bm = bmesh.from_edit_mesh(mesh)
-        selected_verts = [v for v in bm.verts if v.select]
-        if len(selected_verts) != 2:
-            return {"CANCELLED"}
-        l1 = selected_verts[0].co - cursor
-        l2 = selected_verts[1].co - cursor
-        angle = l1.xy.angle_signed(l2.xy)
-
-        if self.should_flip:
-            if angle > 0:
-                angle = -((pi * 2) - angle)
-            else:
-                angle = (pi * 2) + angle
-
-        v = selected_verts[0]
-        bm.verts.remove(selected_verts[1])
-        bmesh.ops.spin(bm, geom=[v], axis=(0, 0, 1), cent=cursor, steps=self.resolution * 4, angle=-angle)
-        bmesh.update_edit_mesh(mesh)
-        mesh.update()
-        return {"FINISHED"}

src/blenderbim/blenderbim/bim/module/drawing/prop.py

@@ -377,7 +377,6 @@ class BIMCameraProperties(PropertyGroup):
 
 class BIMTextProperties(PropertyGroup):
     is_editing: BoolProperty(name="Is Editing", default=False)
-    is_editing_product: BoolProperty(name="Is Editing Product", default=False)
     attributes: CollectionProperty(name="Attributes", type=Attribute)
     value: StringProperty(name="Value", default="TEXT")
     font_size: EnumProperty(
@@ -392,4 +391,8 @@ class BIMTextProperties(PropertyGroup):
         update=refreshFontSize,
         name="Font Size",
     )
+
+
+class BIMAssignedProductProperties(PropertyGroup):
+    is_editing_product: BoolProperty(name="Is Editing Product", default=False)
     relating_product: PointerProperty(name="Relating Product", type=bpy.types.Object)

src/blenderbim/blenderbim/bim/module/drawing/sheeter.py

@@ -118,7 +118,7 @@ class SheetBuilder:
         sheet_tree = ET.parse(sheet_path)
         sheet_root = sheet_tree.getroot()
 
-        for g in sheet_root.findall('{http://www.w3.org/2000/svg}g'):
+        for g in sheet_root.findall("{http://www.w3.org/2000/svg}g"):
             if g.attrib.get("data-id") == str(reference.id()):
                 sheet_root.remove(g)
                 break

src/blenderbim/blenderbim/bim/module/drawing/svgwriter.py

@@ -20,7 +20,9 @@ import os
 import re
 import bpy
 import math
+import bmesh
 import pystache
+import mathutils
 import xml.etree.ElementTree as ET
 import svgwrite
 import ifcopenshell
@@ -34,14 +36,6 @@ from mathutils import geometry
 from blenderbim.bim.ifc import IfcStore
 
 
-def load_occ():
-    # Don't import until we really need to, as a temporary step before we can purge OCC
-    try:
-        from OCC.Core import BRep, BRepTools, TopExp, TopAbs
-    except ImportError:
-        from OCC import BRep, BRepTools, TopExp, TopAbs
-
-
 class External(svgwrite.container.Group):
     def __init__(self, xml, **extra):
         self.xml = xml
@@ -61,87 +55,78 @@ class External(svgwrite.container.Group):
 
 class SvgWriter:
     def __init__(self):
-        self.output = "out.svg"
         self.data_dir = None
-        self.vector_style = None
         self.human_scale = "NTS"
-        self.annotations = []
         self.metadata = []
-        self.background_image = None
         self.scale = 1 / 100  # 1:100
+        self.camera_width = None
+        self.camera_height = None
 
-    def write(self, layer):
+    def create_blank_svg(self, output_path):
         self.calculate_scale()
         self.svg = svgwrite.Drawing(
-            self.output,
-            debug=False,
+            output_path,
             size=("{}mm".format(self.width), "{}mm".format(self.height)),
             viewBox=("0 0 {} {}".format(self.width, self.height)),
             id="root",
             data_scale=self.human_scale,
+            debug=False,  # Disable validation so that we can insert the IFC namespace
         )
+        self.svg.attribs["xmlns:ifc"] = "http://www.ifcopenshell.org/ns"
+        return self
 
-        if layer == "underlay":
-            self.draw_background_image()
-        elif layer == "annotation":
-            self.add_stylesheet()
-            self.add_markers()
-            self.add_symbols()
-            self.add_patterns()
-            # self.draw_background_elements()
-            # self.draw_cut_polygons()
-            self.draw_annotations()
+    def save(self):
         self.svg.save(pretty=True)
 
-    def calculate_scale(self):
-        self.scale *= 1000  # IFC is in meters, SVG is in mm
-        self.raw_width = self.camera_width
-        self.raw_height = self.camera_height
-        self.width = self.raw_width * self.scale
-        self.height = self.raw_height * self.scale
-
-    def add_stylesheet(self):
-        with open(os.path.join(self.data_dir, "styles", f"{self.vector_style}.css"), "r") as stylesheet:
-            self.svg.defs.add(self.svg.style(stylesheet.read()))
-
-    def add_markers(self):
-        tree = ET.parse(os.path.join(self.data_dir, "templates", "markers.svg"))
-        root = tree.getroot()
-        for child in root:
-            self.svg.defs.add(External(child))
-
-    def add_symbols(self):
-        tree = ET.parse(os.path.join(self.data_dir, "templates", "symbols.svg"))
-        root = tree.getroot()
-        for child in root:
-            self.svg.defs.add(External(child))
-
-    def add_patterns(self):
-        tree = ET.parse(os.path.join(self.data_dir, "templates", "patterns.svg"))
-        root = tree.getroot()
-        for child in root:
-            self.svg.defs.add(External(child))
-
-    def draw_background_image(self):
+    def draw_underlay(self, image):
         self.svg.add(
             self.svg.image(
-                os.path.join("..", "diagrams", os.path.basename(self.background_image)),
-                **{"width": self.width, "height": self.height},
+                os.path.join("..", "diagrams", os.path.basename(image)),
+                width=self.width,
+                height=self.height,
             )
         )
+        return self
 
-    def draw_background_elements(self):
-        return  # TODO purge?
-        for element in self.ifc_cutter.background_elements:
-            if element["type"] == "polygon":
-                self.draw_polygon(element, "background")
-            elif element["type"] == "polyline":
-                self.draw_polyline(element, "background")
-            elif element["type"] == "line":
-                self.draw_line(element, "background")
+    def define_boilerplate(self, stylesheet=None, markers=None, symbols=None, patterns=None):
+        self.add_stylesheet(stylesheet)
+        self.add_markers(markers)
+        self.add_symbols(symbols)
+        self.add_patterns(patterns)
+        return self
 
-    def draw_annotations(self):
-        for element in self.annotations:
+    def calculate_scale(self):
+        self.svg_scale = self.scale * 1000  # IFC is in meters, SVG is in mm
+        self.raw_width = self.camera_width
+        self.raw_height = self.camera_height
+        self.width = self.raw_width * self.svg_scale
+        self.height = self.raw_height * self.svg_scale
+
+    def add_stylesheet(self, uri):
+        default_stylesheet = os.path.join(self.data_dir, "styles", f"default.css")
+        with open(tool.Ifc.resolve_uri(uri) or default_stylesheet, "r") as stylesheet:
+            self.svg.defs.add(self.svg.style(stylesheet.read()))
+
+    def add_markers(self, uri):
+        tree = ET.parse(tool.Ifc.resolve_uri(uri) or os.path.join(self.data_dir, "templates", "markers.svg"))
+        root = tree.getroot()
+        for child in root:
+            self.svg.defs.add(External(child))
+
+    def add_symbols(self, uri):
+        tree = ET.parse(tool.Ifc.resolve_uri(uri) or os.path.join(self.data_dir, "templates", "symbols.svg"))
+        root = tree.getroot()
+        for child in root:
+            self.svg.defs.add(External(child))
+
+    def add_patterns(self, uri):
+        tree = ET.parse(tool.Ifc.resolve_uri(uri) or os.path.join(self.data_dir, "templates", "patterns.svg"))
+        root = tree.getroot()
+        for child in root:
+            self.svg.defs.add(External(child))
+
+    def draw_annotations(self, annotations):
+        for element in annotations:
             obj = tool.Ifc.get_object(element)
             if not obj or element.ObjectType == "DRAWING":
                 continue
@@ -153,6 +138,8 @@ class SvgWriter:
                 self.draw_stair_annotation(obj)
             elif element.ObjectType == "DIMENSION":
                 self.draw_dimension_annotations(obj)
+            elif element.ObjectType == "ANGLE":
+                self.draw_angle_annotations(obj)
             elif element.ObjectType == "RADIUS":
                 self.draw_radius_annotations(obj)
             elif element.ObjectType == "DIAMETER":
@@ -176,6 +163,7 @@ class SvgWriter:
 
         # Experimental integration with the MeasureIt-ARCH Add-on
         self.draw_measureit_arch_dimension_annotations()
+        return self
 
     def draw_section_level_annotation(self, obj):
         x_offset = self.raw_width / 2
@@ -190,7 +178,7 @@ class SvgWriter:
             projected_points = [self.project_point_onto_camera(matrix_world @ p.co.xyz) for p in points]
             d = " ".join(
                 [
-                    "L {} {}".format((x_offset + p.x) * self.scale, (y_offset - p.y) * self.scale)
+                    "L {} {}".format((x_offset + p.x) * self.svg_scale, (y_offset - p.y) * self.svg_scale)
                     for p in projected_points
                 ]
             )
@@ -198,8 +186,8 @@ class SvgWriter:
             path = self.svg.add(self.svg.path(d=d, class_=" ".join(classes)))
             text_position = Vector(
                 (
-                    (x_offset + projected_points[0].x) * self.scale,
-                    ((y_offset - projected_points[0].y) * self.scale) - 3.5,
+                    (x_offset + projected_points[0].x) * self.svg_scale,
+                    ((y_offset - projected_points[0].y) * self.svg_scale) - 3.5,
                 )
             )
             # TODO: allow metric to be configurable
@@ -229,14 +217,14 @@ class SvgWriter:
             projected_points = [self.project_point_onto_camera(matrix_world @ p.co.xyz) for p in points]
             d = " ".join(
                 [
-                    "L {} {}".format((x_offset + p.x) * self.scale, (y_offset - p.y) * self.scale)
+                    "L {} {}".format((x_offset + p.x) * self.svg_scale, (y_offset - p.y) * self.svg_scale)
                     for p in projected_points
                 ]
             )
             d = "M{}".format(d[1:])
             start = Vector(((x_offset + projected_points[0].x), (y_offset - projected_points[0].y)))
             next_point = Vector(((x_offset + projected_points[1].x), (y_offset - projected_points[1].y)))
-            text_position = (start * self.scale) - ((next_point - start).normalized() * 5)
+            text_position = (start * self.svg_scale) - ((next_point - start).normalized() * 5)
             path = self.svg.add(self.svg.path(d=d, class_=" ".join(classes)))
             self.svg.add(
                 self.svg.text(
@@ -266,14 +254,16 @@ class SvgWriter:
             end = Vector(((x_offset + v1.x), (y_offset - v1.y)))
             vector = end - start
             line = self.svg.add(
-                self.svg.line(start=tuple(start * self.scale), end=tuple(end * self.scale), class_=" ".join(classes))
+                self.svg.line(
+                    start=tuple(start * self.svg_scale), end=tuple(end * self.svg_scale), class_=" ".join(classes)
+                )
             )
             line["stroke-dasharray"] = "12.5, 3, 3, 3"
             axis_tag = tool.Ifc.get_entity(obj).Name
             self.svg.add(
                 self.svg.text(
                     axis_tag,
-                    insert=tuple(start * self.scale),
+                    insert=tuple(start * self.svg_scale),
                     **{
                         "font-size": annotation.Annotator.get_svg_text_size(5.0),
                         "font-family": "OpenGost Type B TT",
@@ -286,7 +276,7 @@ class SvgWriter:
             self.svg.add(
                 self.svg.text(
                     axis_tag,
-                    insert=tuple(end * self.scale),
+                    insert=tuple(end * self.svg_scale),
                     **{
                         "font-size": annotation.Annotator.get_svg_text_size(5.0),
                         "font-family": "OpenGost Type B TT",
@@ -316,7 +306,7 @@ class SvgWriter:
             projected_points.append(projected_points[0])
             d = " ".join(
                 [
-                    "L {} {}".format((x_offset + p.x) * self.scale, (y_offset - p.y) * self.scale)
+                    "L {} {}".format((x_offset + p.x) * self.svg_scale, (y_offset - p.y) * self.svg_scale)
                     for p in projected_points
                 ]
             )
@@ -353,7 +343,7 @@ class SvgWriter:
                 projected_points = [self.project_point_onto_camera(matrix_world @ p.co.xyz) for p in points]
                 d = " ".join(
                     [
-                        "L {} {}".format((x_offset + p.x) * self.scale, (y_offset - p.y) * self.scale)
+                        "L {} {}".format((x_offset + p.x) * self.svg_scale, (y_offset - p.y) * self.svg_scale)
                         for p in projected_points
                     ]
                 )
@@ -375,7 +365,9 @@ class SvgWriter:
             end = Vector(((x_offset + v1.x), (y_offset - v1.y)))
             vector = end - start
             line = self.svg.add(
-                self.svg.line(start=tuple(start * self.scale), end=tuple(end * self.scale), class_=" ".join(classes))
+                self.svg.line(
+                    start=tuple(start * self.svg_scale), end=tuple(end * self.svg_scale), class_=" ".join(classes)
+                )
             )
 
     def draw_leader_annotation(self, obj):
@@ -404,17 +396,17 @@ class SvgWriter:
             symbol_position = Vector(((x_offset + symbol_position.x), (y_offset - symbol_position.y)))
             transform = "rotate({}, {}, {})".format(
                 angle,
-                (symbol_position * self.scale)[0],
-                (symbol_position * self.scale)[1],
+                (symbol_position * self.svg_scale)[0],
+                (symbol_position * self.svg_scale)[1],
             )
 
             self.svg.add(
-                self.svg.use("#section-arrow", insert=tuple(symbol_position * self.scale), transform=transform)
+                self.svg.use("#section-arrow", insert=tuple(symbol_position * self.svg_scale), transform=transform)
             )
-            self.svg.add(self.svg.use("#section-tag", insert=tuple(symbol_position * self.scale)))
+            self.svg.add(self.svg.use("#section-tag", insert=tuple(symbol_position * self.svg_scale)))
 
             reference_id, sheet_id = self.get_reference_and_sheet_id_from_annotation(tool.Ifc.get_entity(obj))
-            text_position = list(symbol_position * self.scale)
+            text_position = list(symbol_position * self.svg_scale)
             text_style = {
                 "font-size": annotation.Annotator.get_svg_text_size(2.5),
                 "font-family": "OpenGost Type B TT",
@@ -437,15 +429,17 @@ class SvgWriter:
 
         transform = "rotate({}, {}, {})".format(
             angle,
-            (symbol_position * self.scale)[0],
-            (symbol_position * self.scale)[1],
+            (symbol_position * self.svg_scale)[0],
+            (symbol_position * self.svg_scale)[1],
         )
 
-        self.svg.add(self.svg.use("#elevation-arrow", insert=tuple(symbol_position * self.scale), transform=transform))
-        self.svg.add(self.svg.use("#elevation-tag", insert=tuple(symbol_position * self.scale)))
+        self.svg.add(
+            self.svg.use("#elevation-arrow", insert=tuple(symbol_position * self.svg_scale), transform=transform)
+        )
+        self.svg.add(self.svg.use("#elevation-tag", insert=tuple(symbol_position * self.svg_scale)))
 
         reference_id, sheet_id = self.get_reference_and_sheet_id_from_annotation(tool.Ifc.get_entity(obj))
-        text_position = list(symbol_position * self.scale)
+        text_position = list(symbol_position * self.svg_scale)
         text_style = {
             "font-size": annotation.Annotator.get_svg_text_size(2.5),
             "font-family": "OpenGost Type B TT",
@@ -462,7 +456,7 @@ class SvgWriter:
         drawing = tool.Drawing.get_annotation_element(element)
         reference = tool.Drawing.get_drawing_reference(drawing)
         if reference:
-            sheet = tool.Drawing.get_reference_sheet(reference)
+            sheet = tool.Drawing.get_reference_document(reference)
             if sheet:
                 if tool.Ifc.get_schema() == "IFC2X3":
                     reference_id = reference.ItemReference or "-"
@@ -493,13 +487,13 @@ class SvgWriter:
 
         transform = "rotate({}, {}, {})".format(
             angle,
-            (text_position * self.scale)[0],
-            (text_position * self.scale)[1],
+            (text_position * self.svg_scale)[0],
+            (text_position * self.svg_scale)[1],
         )
 
         symbol = tool.Drawing.get_annotation_symbol(element)
         if symbol:
-            self.svg.add(self.svg.use(f"#{symbol}", insert=tuple(text_position * self.scale)))
+            self.svg.add(self.svg.use(f"#{symbol}", insert=tuple(text_position * self.svg_scale)))
 
         if text_literal.BoxAlignment == "top-left":
             alignment_baseline = "hanging"
@@ -531,17 +525,18 @@ class SvgWriter:
 
         literal = text_literal.Literal
 
-        product = tool.Drawing.get_text_product(element)
+        product = tool.Drawing.get_assigned_product(element)
         selector = ifcopenshell.util.selector.Selector
         variables = {}
-        for variable in re.findall("{{.*?}}", literal):
-            literal = literal.replace(variable, selector.get_element_value(product, variable[2:-2]) or "")
+        if product != None:
+            for variable in re.findall("{{.*?}}", literal):
+                literal = literal.replace(variable, str(selector.get_element_value(product, variable[2:-2]) or ""))
 
         for line_number, text_line in enumerate(literal.replace("\\n", "\n").split("\n")):
             self.svg.add(
                 self.svg.text(
                     text_line,
-                    insert=tuple((text_position * self.scale) + Vector((0, 3.5 * line_number))),
+                    insert=tuple((text_position * self.svg_scale) + Vector((0, 3.5 * line_number))),
                     class_=" ".join(self.get_attribute_classes(text_obj)),
                     **{
                         "font-size": annotation.Annotator.get_svg_text_size(text_obj.BIMTextProperties.font_size),
@@ -570,7 +565,7 @@ class SvgWriter:
             ]
             d = " ".join(
                 [
-                    "L {} {}".format((x_offset + p.x) * self.scale, (y_offset - p.y) * self.scale)
+                    "L {} {}".format((x_offset + p.x) * self.svg_scale, (y_offset - p.y) * self.svg_scale)
                     for p in projected_points
                 ]
             )
@@ -587,7 +582,7 @@ class SvgWriter:
             projected_points = [self.project_point_onto_camera(matrix_world @ p.co.xyz) for p in points]
             d = " ".join(
                 [
-                    "L {} {}".format((x_offset + p.x) * self.scale, (y_offset - p.y) * self.scale)
+                    "L {} {}".format((x_offset + p.x) * self.svg_scale, (y_offset - p.y) * self.svg_scale)
                     for p in projected_points
                 ]
             )
@@ -595,8 +590,8 @@ class SvgWriter:
             path = self.svg.add(self.svg.path(d=d, class_=" ".join(classes)))
             text_position = Vector(
                 (
-                    (x_offset + projected_points[0].x) * self.scale,
-                    ((y_offset - projected_points[0].y) * self.scale) - 2.5,
+                    (x_offset + projected_points[0].x) * self.svg_scale,
+                    ((y_offset - projected_points[0].y) * self.svg_scale) - 2.5,
                 )
             )
             # TODO: allow metric to be configurable
@@ -623,6 +618,119 @@ class SvgWriter:
                 )
             )
 
+    def draw_angle_annotations(self, obj):
+        # This implementation uses an SVG arc, which means that it can only draw
+        # arcs that are orthogonal to the view (e.g. not arcs in 3D).
+        # Gosh this is bad code :(
+        x_offset = self.raw_width / 2
+        y_offset = self.raw_height / 2
+        classes = self.get_attribute_classes(obj)
+        matrix_world = obj.matrix_world
+
+        points = [v.co for v in obj.data.vertices][:3]
+        center = tool.Cad.get_center_of_arc(points, obj)
+
+        bm = bmesh.new()
+        bm.from_mesh(obj.data)
+        bm.verts.ensure_lookup_table()
+        arc_end_verts = [v for v in bm.verts if len(v.link_edges) == 1]
+        arc_end_pts = [matrix_world @ v.co for v in arc_end_verts]
+
+        # Probably need this when rewriting to use an SVG polyline instead of an arc
+        # arc_path = [arc_end_verts[0]]
+        # while True:
+        #    last_point = arc_end_verts[0]
+        #    found_another_point = False
+        #    for edge in last_point.link_edges:
+        #        v = edge.other_vert(last_point)
+        #        if v not in arc_path:
+        #            found_another_point = True
+        #            arc_path.append(v)
+        #    if not found_another_point:
+        #        break
+
+        distance_between_end_verts = (arc_end_verts[0].co - arc_end_verts[1].co).length
+        arc_mid_vert = arc_end_verts[0].link_edges[0].other_vert(arc_end_verts[0])
+        is_reflex = 0 if (arc_mid_vert.co - arc_end_verts[1].co).length < distance_between_end_verts else 1
+
+        bm.free()
+
+        # Calculate the angle
+        # This is the true normal in 3D, whereas the camera projection we use is the drawing direction.
+        # This assumes (because we use SVG arcs) that the radius is always orthogonal to our view.
+        # When rewriting to use polylines, we should use this normal instead.
+        # normal = mathutils.geometry.normal([arc_end_pts[0], arc_end_pts[1], center])
+        normal = Vector(self.camera_projection)
+        dir1 = (arc_end_pts[0] - center).normalized()
+        dir2 = (arc_end_pts[1] - center).normalized()
+
+        # Let's get the matrix that represents the coordinate system of the arc.
+        # This matrix allows us to get 2D vectors for calculating the signed arc angle.
+        z = normal
+        x = (arc_end_pts[0] - center).normalized()
+        y = z.cross(x)
+        arc_matrix = mathutils.Matrix([x, y, z]).transposed().to_4x4()
+
+        dir1 = ((arc_matrix.inverted() @ arc_end_pts[0]) - (arc_matrix.inverted() @ center)).normalized()
+        dir2 = ((arc_matrix.inverted() @ arc_end_pts[1]) - (arc_matrix.inverted() @ center)).normalized()
+        angle = -dir1.xy.angle_signed(dir2.xy)
+
+        # if is_reflex:
+        #    angle = angle % (math.pi * 2)
+
+        # Center of gravity of all vertices, used to help position the text
+        cog = Vector((0, 0, 0))
+        for vert in obj.data.vertices:
+            cog += vert.co
+        cog = matrix_world @ (cog / len(obj.data.vertices))
+
+        radius = ((matrix_world @ obj.data.vertices[0].co) - center).length
+
+        arc_midpoint = center + ((cog - center).normalized() * radius)
+
+        text_position = self.project_point_onto_camera(arc_midpoint)
+        text_position = Vector(
+            ((x_offset + text_position.x) * self.svg_scale, (y_offset - text_position.y) * self.svg_scale)
+        )
+
+        center_projected = self.project_point_onto_camera(center)
+        center_position = Vector(
+            ((x_offset + center_projected.x) * self.svg_scale, (y_offset - center_projected.y) * self.svg_scale)
+        )
+        text_offset = (text_position - center_position).xy.normalized() * 5
+        text_position += text_offset
+
+        text_style = {
+            "font-size": annotation.Annotator.get_svg_text_size(2.5),
+            "font-family": "OpenGost Type B TT",
+            "text-anchor": "middle",
+            "alignment-baseline": "middle",
+            "dominant-baseline": "middle",
+        }
+
+        angle_text = abs(round(math.degrees(angle), 3))
+        if is_reflex:
+            angle_text = 360 - angle_text
+        self.svg.add(self.svg.text(f"{angle_text}deg", insert=tuple(text_position), **text_style))
+
+        # Draw SVG arc, see for details: http://xahlee.info/js/svg_circle_arc.html
+        arc_proj_end_pts = [self.project_point_onto_camera(v) for v in arc_end_pts]
+        p1 = Vector(
+            ((x_offset + arc_proj_end_pts[0].x) * self.svg_scale, (y_offset - arc_proj_end_pts[0].y) * self.svg_scale)
+        )
+        p2 = Vector(
+            ((x_offset + arc_proj_end_pts[1].x) * self.svg_scale, (y_offset - arc_proj_end_pts[1].y) * self.svg_scale)
+        )
+        r = radius * self.svg_scale
+        # reflex = 1 if angle > math.pi else 0
+        reflex = is_reflex
+        if reflex:
+            sense = 0 if angle > 0 else 1
+        else:
+            sense = 1 if angle > 0 else 0
+        d = f"M {p1.x} {p1.y} A {r} {r} 0 {reflex} {sense} {p2.x} {p2.y}"
+        path = self.svg.add(self.svg.path(d=d, class_=" ".join(classes)))
+
     def draw_radius_annotations(self, obj):
         x_offset = self.raw_width / 2
         y_offset = self.raw_height / 2
@@ -634,7 +742,7 @@ class SvgWriter:
             projected_points = [self.project_point_onto_camera(matrix_world @ p.co.xyz) for p in points]
             d = " ".join(
                 [
-                    "L {} {}".format((x_offset + p.x) * self.scale, (y_offset - p.y) * self.scale)
+                    "L {} {}".format((x_offset + p.x) * self.svg_scale, (y_offset - p.y) * self.svg_scale)
                     for p in projected_points
                 ]
             )
@@ -642,15 +750,21 @@ class SvgWriter:
             path = self.svg.add(self.svg.path(d=d, class_=" ".join(classes)))
 
             p0 = Vector(
-                ((x_offset + projected_points[0].x) * self.scale, (y_offset - projected_points[0].y) * self.scale)
+                (
+                    (x_offset + projected_points[0].x) * self.svg_scale,
+                    (y_offset - projected_points[0].y) * self.svg_scale,
+                )
             )
             p1 = Vector(
-                ((x_offset + projected_points[1].x) * self.scale, (y_offset - projected_points[1].y) * self.scale)
+                (
+                    (x_offset + projected_points[1].x) * self.svg_scale,
+                    (y_offset - projected_points[1].y) * self.svg_scale,
+                )
             )
             text_offset = (p0 - p1).xy.normalized() * 5
             text_position = projected_points[0]
             text_position = Vector(
-                ((x_offset + text_position.x) * self.scale, (y_offset - text_position.y) * self.scale)
+                ((x_offset + text_position.x) * self.svg_scale, (y_offset - text_position.y) * self.svg_scale)
             )
             text_position += text_offset
 
@@ -722,15 +836,17 @@ class SvgWriter:
         perpendicular = Vector((vector.y, -vector.x)).normalized()
         dimension = (v1_global - v0_global).length
         dimension = helper.format_distance(dimension)
-        sheet_dimension = ((end * self.scale) - (start * self.scale)).length
+        sheet_dimension = ((end * self.svg_scale) - (start * self.svg_scale)).length
         if sheet_dimension < 5:  # annotation can't fit
             # offset text to right of marker
-            text_position = (end * self.scale) + perpendicular + (3 * vector.normalized())
+            text_position = (end * self.svg_scale) + perpendicular + (3 * vector.normalized())
         else:
-            text_position = (mid * self.scale) + perpendicular
+            text_position = (mid * self.svg_scale) + perpendicular
         rotation = math.degrees(vector.angle_signed(Vector((1, 0))))
         line = self.svg.add(
-            self.svg.line(start=tuple(start * self.scale), end=tuple(end * self.scale), class_=" ".join(classes))
+            self.svg.line(
+                start=tuple(start * self.svg_scale), end=tuple(end * self.svg_scale), class_=" ".join(classes)
+            )
         )
         if text_override is not None:
             text = text_override
@@ -762,35 +878,8 @@ class SvgWriter:
     def get_spline_points(self, spline):
         return spline.bezier_points if spline.bezier_points else spline.points
 
-    def draw_cut_polygons(self):
-        return  # deprecate?
-        for polygon in self.ifc_cutter.cut_polygons:
-            self.draw_polygon(polygon, "cut")
-
-    def draw_polyline(self, element, position):
-        load_occ()
-        classes = self.get_classes(element["raw"], position)
-        exp = BRepTools.BRepTools_WireExplorer(element["geometry"])
-        points = []
-        while exp.More():
-            point = BRep.BRep_Tool.Pnt(exp.CurrentVertex())
-            points.append((point.X() * self.scale, -point.Y() * self.scale))
-            exp.Next()
-        self.svg.add(self.svg.polyline(points=points, class_=" ".join(classes)))
-
-    def draw_line(self, element, position):
-        load_occ()
-        classes = self.get_classes(element["raw"], position)
-        exp = TopExp.TopExp_Explorer(element["geometry"], TopAbs.TopAbs_VERTEX)
-        points = []
-        while exp.More():
-            point = BRep.BRep_Tool.Pnt(topods.Vertex(exp.Current()))
-            points.append((point.X() * self.scale, -point.Y() * self.scale))
-            exp.Next()
-        self.svg.add(self.svg.line(start=points[0], end=points[1], class_=" ".join(classes)))
-
     def draw_polygon(self, polygon, position):
-        points = [(p[0] * self.scale, p[1] * self.scale) for p in polygon["points"]]
+        points = [(p[0] * self.svg_scale, p[1] * self.svg_scale) for p in polygon["points"]]
         if "classes" in polygon["metadata"]:
             classes = " ".join(polygon["metadata"]["classes"])
         else:

src/blenderbim/blenderbim/bim/module/drawing/ui.py

@@ -20,7 +20,7 @@ import bpy
 import blenderbim.bim.helper
 import blenderbim.tool as tool
 from bpy.types import Panel
-from blenderbim.bim.module.drawing.data import TextData, SheetsData, SchedulesData, DrawingsData
+from blenderbim.bim.module.drawing.data import ProductAssignmentsData, TextData, SheetsData, SchedulesData, DrawingsData
 
 
 class BIM_PT_camera(Panel):
@@ -144,6 +144,10 @@ class BIM_PT_drawings(Panel):
     bl_region_type = "UI"
     bl_category = "BIM Documentation"
 
+    @classmethod
+    def poll(cls, context):
+        return tool.Ifc.get()
+
     def draw(self, context):
         if not DrawingsData.is_loaded:
             DrawingsData.load()
@@ -166,13 +170,16 @@ class BIM_PT_drawings(Panel):
             if self.props.active_drawing_index < len(self.props.drawings):
                 active_drawing = self.props.drawings[self.props.active_drawing_index]
                 row = self.layout.row(align=True)
-                row.alignment = "RIGHT"
+                col = row.column()
+                col.alignment = 'LEFT'
+                col.operator("bim.remove_drawing", icon="X", text="").drawing = active_drawing.ifc_definition_id
+                col = row.column()
+                col.alignment = 'RIGHT'
                 op = row.operator("bim.open_view", icon="URL", text="")
                 op.view = active_drawing.name
                 op = row.operator("bim.activate_view", icon="OUTLINER_OB_CAMERA", text="")
                 op.drawing = active_drawing.ifc_definition_id
                 row.operator("bim.create_drawing", text="", icon="OUTPUT")
-                row.operator("bim.remove_drawing", icon="X", text="").drawing = active_drawing.ifc_definition_id
             self.layout.template_list(
                 "BIM_UL_drawinglist", "", self.props, "drawings", self.props, "active_drawing_index"
             )
@@ -195,6 +202,10 @@ class BIM_PT_schedules(Panel):
     bl_region_type = "UI"
     bl_category = "BIM Documentation"
 
+    @classmethod
+    def poll(cls, context):
+        return tool.Ifc.get()
+
     def draw(self, context):
         if not SchedulesData.is_loaded:
             SchedulesData.load()
@@ -217,10 +228,14 @@ class BIM_PT_schedules(Panel):
                 row = self.layout.row(align=True)
                 row.alignment = "RIGHT"
                 row.operator("bim.open_schedule", icon="URL", text="").schedule = active_schedule.ifc_definition_id
-                row.operator("bim.build_schedule", icon="LINENUMBERS_ON", text="").schedule = active_schedule.ifc_definition_id
+                row.operator(
+                    "bim.build_schedule", icon="LINENUMBERS_ON", text=""
+                ).schedule = active_schedule.ifc_definition_id
                 row.operator("bim.remove_schedule", icon="X", text="").schedule = active_schedule.ifc_definition_id
 
-            self.layout.template_list("BIM_UL_generic", "", self.props, "schedules", self.props, "active_schedule_index")
+            self.layout.template_list(
+                "BIM_UL_generic", "", self.props, "schedules", self.props, "active_schedule_index"
+            )
 
 
 class BIM_PT_sheets(Panel):
@@ -230,6 +245,10 @@ class BIM_PT_sheets(Panel):
     bl_region_type = "UI"
     bl_category = "BIM Documentation"
 
+    @classmethod
+    def poll(cls, context):
+        return tool.Ifc.get()
+
     def draw(self, context):
         if not SheetsData.is_loaded:
             SheetsData.load()
@@ -264,6 +283,39 @@ class BIM_PT_sheets(Panel):
         self.layout.template_list("BIM_UL_sheets", "", self.props, "sheets", self.props, "active_sheet_index")
 
 
+class BIM_PT_product_assignments(Panel):
+    bl_label = "IFC Product Assignments"
+    bl_idname = "BIM_PT_product_assignments"
+    bl_space_type = "PROPERTIES"
+    bl_region_type = "WINDOW"
+    bl_context = "object"
+
+    @classmethod
+    def poll(cls, context):
+        if not tool.Ifc.get() or not context.active_object:
+            return
+        element = tool.Ifc.get_entity(context.active_object)
+        if not element:
+            return
+        return element.is_a("IfcAnnotation")
+
+    def draw(self, context):
+        if not ProductAssignmentsData.is_loaded:
+            ProductAssignmentsData.load()
+
+        props = context.active_object.BIMAssignedProductProperties
+
+        if props.is_editing_product:
+            row = self.layout.row(align=True)
+            row.prop(props, "relating_product", text="")
+            row.operator("bim.edit_assigned_product", icon="CHECKMARK", text="")
+            row.operator("bim.disable_editing_assigned_product", icon="CANCEL", text="")
+        else:
+            row = self.layout.row(align=True)
+            row.label(text=ProductAssignmentsData.data["relating_product"] or "No Relating Product", icon="OBJECT_DATA")
+            row.operator("bim.enable_editing_assigned_product", icon="GREASEPENCIL", text="")
+
+
 class BIM_PT_text(Panel):
     bl_label = "IFC Text"
     bl_idname = "BIM_PT_text"
@@ -300,16 +352,6 @@ class BIM_PT_text(Panel):
                 row.label(text=attribute["name"])
                 row.label(text=attribute["value"])
 
-        if props.is_editing_product:
-            row = self.layout.row(align=True)
-            row.prop(props, "relating_product", text="")
-            row.operator("bim.edit_text_product", icon="CHECKMARK", text="")
-            row.operator("bim.disable_editing_text_product", icon="CANCEL", text="")
-        else:
-            row = self.layout.row(align=True)
-            row.label(text=TextData.data["relating_product"] or "No Relating Product", icon="OBJECT_DATA")
-            row.operator("bim.enable_editing_text_product", icon="GREASEPENCIL", text="")
-
         row = self.layout.row()
         row.prop(props, "font_size")
         row = self.layout.row()
@@ -382,6 +424,7 @@ class BIM_PT_annotation_utilities(Panel):
 
         row = layout.row(align=True)
         row.prop(self.props, "should_draw_decorations", text="Viewport Annotations")
+        row.enabled = context.scene.camera is not None
 
 
 class BIM_UL_drawinglist(bpy.types.UIList):

src/blenderbim/blenderbim/bim/module/geometry/__init__.py

@@ -25,17 +25,20 @@ classes = (
     operator.EditObjectPlacement,
     operator.GetRepresentationIfcParameters,
     operator.OverrideDelete,
-    operator.OverrideOutlinerDelete,
     operator.OverrideDuplicateMove,
     operator.OverrideDuplicateMoveLinked,
+    operator.OverrideOutlinerDelete,
     operator.OverridePasteBuffer,
+    operator.RemoveConnection,
     operator.RemoveRepresentation,
+    operator.SelectConnection,
     operator.SwitchRepresentation,
     operator.UpdateParametricRepresentation,
     operator.UpdateRepresentation,
     prop.BIMGeometryProperties,
     ui.BIM_PT_derived_placements,
     ui.BIM_PT_representations,
+    ui.BIM_PT_connections,
     ui.BIM_PT_mesh,
     ui.BIM_PT_workarounds,
 )

src/blenderbim/blenderbim/bim/module/geometry/data.py

@@ -25,6 +25,7 @@ from mathutils import Vector
 def refresh():
     DerivedPlacementsData.is_loaded = False
     RepresentationsData.is_loaded = False
+    ConnectionsData.is_loaded = False
 
 
 class RepresentationsData:
@@ -64,6 +65,40 @@ class RepresentationsData:
         return results
 
 
+class ConnectionsData:
+    data = {}
+    is_loaded = False
+
+    @classmethod
+    def load(cls):
+        cls.data = {"connections": cls.connections()}
+        cls.is_loaded = True
+
+    @classmethod
+    def connections(cls):
+        results = []
+        element = tool.Ifc.get_entity(bpy.context.active_object)
+        for rel in getattr(element, "ConnectedTo", []):
+            results.append(
+                {
+                    "id": rel.id(),
+                    "is_relating": True,
+                    "Name": rel.RelatedElement.Name or "Unnamed",
+                    "ConnectionType": rel.RelatingConnectionType,
+                }
+            )
+        for rel in getattr(element, "ConnectedFrom", []):
+            results.append(
+                {
+                    "id": rel.id(),
+                    "is_relating": False,
+                    "Name": rel.RelatingElement.Name or "Unnamed",
+                    "ConnectionType": rel.RelatedConnectionType,
+                }
+            )
+        return results
+
+
 class DerivedPlacementsData:
     data = {}
     is_loaded = False

src/blenderbim/blenderbim/bim/module/geometry/helper.py

@@ -21,7 +21,7 @@ import bmesh
 import mathutils
 import ifcopenshell
 import ifcopenshell.util.unit
-from math import pi
+from math import pi, pow
 from mathutils import Vector, Matrix, geometry
 
 
@@ -112,6 +112,167 @@ class Helper:
 
         return {"profile": profile, "extrusion": extrusion}
 
+    def auto_detect_arbitrary_profile_with_voids(self, obj, mesh):
+        groups = {"IFCARCINDEX": [], "IFCCIRCLE": []}
+        for i, group in enumerate(obj.vertex_groups):
+            if "IFCARCINDEX" in group.name:
+                groups["IFCARCINDEX"].append(i)
+            elif "IFCCIRCLE" in group.name:
+                groups["IFCCIRCLE"].append(i)
+
+        bm = bmesh.new()
+        bm.from_mesh(mesh)
+        bmesh.ops.remove_doubles(bm, verts=bm.verts, dist=1e-5)
+        bmesh.ops.delete(bm, geom=bm.faces, context="FACES_ONLY")
+
+        # https://docs.blender.org/api/blender_python_api_2_63_8/bmesh.html#CustomDataAccess
+        # This is how we access vertex groups via bmesh, apparently, it's not very intuitive
+        deform_layer = bm.verts.layers.deform.active
+
+        # Sanity check
+        group_verts = {"IFCARCINDEX": {}, "IFCCIRCLE": {}}
+        for vert in bm.verts:
+            total_groups = 0
+            is_circle = False
+            for group_type, group_indices in groups.items():
+                for group_index in group_indices:
+                    if group_index in vert[deform_layer]:
+                        if group_type == "IFCCIRCLE":
+                            is_circle = True
+                        group_verts[group_type].setdefault(group_index, 0)
+                        group_verts[group_type][group_index] += 1
+                        total_groups += 0
+            if total_groups > 1:  # A vert can only belong to one group
+                return (False, "AMBIGUOUS_SPECIAL_VERTEX")
+            elif is_circle:
+                pass # Circles are allowed to be unclosed
+            elif total_groups == 0 and len(vert.link_edges) != 2:  # Unclosed loop or forked loop
+                return (False, "UNCLOSED_LOOP")
+
+        for group_type, group_counts in group_verts.items():
+            if group_type == "IFCARCINDEX":
+                for group_count in group_counts.values():
+                    if group_count != 3: # Each arc needs 3 verts
+                        return (False, "3POINT_ARC")
+            elif group_type == "IFCCIRCLE":
+                for group_count in group_counts.values():
+                    if group_count != 2: # Each circle needs 2 verts
+                        return (False, "CIRCLE")
+
+        loop_edges = set(bm.edges)
+
+        # Create loops from edges
+        loops = []
+        while loop_edges:
+            edge = loop_edges.pop()
+            loop = [edge]
+            has_found_connected_edge = True
+            while has_found_connected_edge:
+                has_found_connected_edge = False
+                for edge in loop_edges.copy():
+                    edge_verts = set(edge.verts)
+                    if edge_verts & set(loop[0].verts):
+                        loop.insert(0, edge)
+                        loop_edges.remove(edge)
+                        has_found_connected_edge = True
+                    elif edge_verts & set(loop[-1].verts):
+                        loop.append(edge)
+                        loop_edges.remove(edge)
+                        has_found_connected_edge = True
+            loops.append(loop)
+
+        # Determine outer loop
+        max_area = 0
+        outer_loop = None
+        inner_loops = []
+
+        for loop in loops:
+            loop_vertices = []
+            total_edges = len(loop)
+
+            if total_edges == 1:
+                loop_vertices = [loop[0].verts[0], loop[0].verts[1]]
+            else:
+                for i, edge in enumerate(loop):
+                    if i + 1 == total_edges and edge.verts[0] in loop[i - 1].verts:
+                        loop_vertices.append(edge.verts[0])
+                    elif i + 1 == total_edges and edge.verts[1] in loop[i - 1].verts:
+                        loop_vertices.append(edge.verts[1])
+                    elif edge.verts[0] in loop[i + 1].verts:
+                        loop_vertices.append(edge.verts[1])
+                    elif edge.verts[1] in loop[i + 1].verts:
+                        loop_vertices.append(edge.verts[0])
+
+            if len(loop_vertices) == 2:
+                # Unofficial convention right now that a loop of 2 verts always is a circle
+                radius = (loop_vertices[0].co - loop_vertices[1].co).length / 2
+                face_area = pi * pow(radius, 2)
+            else:
+                loop_bm = bmesh.new()
+                for vert in loop_vertices:
+                    loop_bm.verts.new(vert.co)
+                face = loop_bm.faces.new(loop_bm.verts)
+                face_area = face.calc_area()
+                loop_bm.free()
+
+            loop_vertex_indices = []
+            active_arc_id = None
+            arc_stack = []
+            last_index = len(loop_vertices) - 1
+
+            # It is possible to loop through loop_vertices halfway through an arc.
+            # If that is the case, we store it in incomplete_arc
+            incomplete_arc = []
+            for i, v in enumerate(loop_vertices):
+                if len(arc_stack) == 3:
+                    loop_vertex_indices.append(arc_stack)
+                    loop_vertex_indices.append((arc_stack[-1], v.index))
+                    arc_stack = []
+                    active_arc_id = None
+
+                is_arc = False
+                for group_index in groups["IFCARCINDEX"]:
+                    if group_index in v[deform_layer]:
+                        if active_arc_id is not None and active_arc_id != group_index:
+                            incomplete_arc = arc_stack
+                            arc_stack = []
+                        active_arc_id = group_index
+                        is_arc = True
+                        break
+
+                if i == last_index and not is_arc:
+                    continue
+
+                if is_arc:
+                    arc_stack.append(v.index)
+                else:
+                    if active_arc_id is not None:
+                        incomplete_arc = arc_stack
+                        active_arc_id = None
+                        arc_stack = []
+                    loop_vertex_indices.append((v.index, loop_vertices[i + 1].index))
+
+            if active_arc_id is not None:
+                arc_stack.extend(incomplete_arc)
+                loop_vertex_indices.append(arc_stack)
+
+            loop_vertex_indices.append((loop_vertex_indices[-1][-1], loop_vertex_indices[0][0]))
+
+            if face_area > max_area:
+                max_area = face_area
+                outer_loop = loop_vertex_indices
+            inner_loops.append(loop_vertex_indices)
+
+        inner_loops.remove(outer_loop)
+
+        points = [v.co for v in bm.verts]
+
+        bm.to_mesh(mesh)
+        mesh.update()
+        bm.free()
+
+        return {"points": points, "profile": outer_loop, "inner_curves": inner_loops}
+
     # An arbitrary closed profile with voids is similar to one without voids.
     # We start the same way with any ngon (no tri), but instead of being the entire
     # profile, it is only one of the possible faces that make up the end of our

src/blenderbim/blenderbim/bim/module/geometry/operator.py

@@ -86,6 +86,26 @@ class AddRepresentation(bpy.types.Operator, Operator):
         )
 
 
+class SelectConnection(bpy.types.Operator, Operator):
+    bl_idname = "bim.select_connection"
+    bl_label = "Select Connection"
+    bl_options = {"REGISTER", "UNDO"}
+    connection: bpy.props.IntProperty()
+
+    def _execute(self, context):
+        core.select_connection(tool.Geometry, connection=tool.Ifc.get().by_id(self.connection))
+
+
+class RemoveConnection(bpy.types.Operator, Operator):
+    bl_idname = "bim.remove_connection"
+    bl_label = "Remove Connection"
+    bl_options = {"REGISTER", "UNDO"}
+    connection: bpy.props.IntProperty()
+
+    def _execute(self, context):
+        core.remove_connection(tool.Geometry, connection=tool.Ifc.get().by_id(self.connection))
+
+
 class SwitchRepresentation(bpy.types.Operator, Operator):
     bl_idname = "bim.switch_representation"
     bl_label = "Switch Representation"
@@ -97,15 +117,28 @@ class SwitchRepresentation(bpy.types.Operator, Operator):
     should_switch_all_meshes: bpy.props.BoolProperty()
 
     def _execute(self, context):
-        core.switch_representation(
-            tool.Geometry,
-            obj=bpy.data.objects.get(self.obj) if self.obj else context.active_object,
-            representation=tool.Ifc.get().by_id(self.ifc_definition_id),
-            should_reload=self.should_reload,
-            enable_dynamic_voids=self.disable_opening_subtractions,
-            is_global=self.should_switch_all_meshes,
-            should_sync_changes_first=True,
-        )
+        target = tool.Ifc.get().by_id(self.ifc_definition_id).ContextOfItems
+        is_subcontext = target.is_a("IfcGeometricRepresentationSubContext")
+        for obj in context.selected_objects:
+            element = tool.Ifc.get_entity(obj)
+            if not element:
+                continue
+            if is_subcontext:
+                representation = ifcopenshell.util.representation.get_representation(
+                    element, target.ContextType, target.ContextIdentifier, target.TargetView
+                )
+            else:
+                representation = ifcopenshell.util.representation.get_representation(element, target.ContextType)
+            if not representation:
+                continue
+            core.switch_representation(
+                tool.Geometry,
+                obj=obj,
+                representation=representation,
+                should_reload=self.should_reload,
+                is_global=self.should_switch_all_meshes,
+                should_sync_changes_first=True,
+            )
 
 
 class RemoveRepresentation(bpy.types.Operator, Operator):
@@ -130,10 +163,6 @@ class UpdateRepresentation(bpy.types.Operator):
     obj: bpy.props.StringProperty()
     ifc_representation_class: bpy.props.StringProperty()
 
-    @classmethod
-    def poll(cls, context):
-        return context.active_object.mode == "OBJECT"
-
     def execute(self, context):
         return IfcStore.execute_ifc_operator(self, context)
 
@@ -141,6 +170,10 @@ class UpdateRepresentation(bpy.types.Operator):
         if not ContextData.is_loaded:
             ContextData.load(IfcStore.get_file())
 
+        if context.active_object and context.active_object.mode != "OBJECT":
+            # Ensure mode is object to prevent invalid mesh data causing CTD
+            bpy.ops.object.mode_set(mode="OBJECT", toggle=False)
+
         objs = [bpy.data.objects.get(self.obj)] if self.obj else context.selected_objects
         self.file = IfcStore.get_file()
 
@@ -156,18 +189,23 @@ class UpdateRepresentation(bpy.types.Operator):
 
     def update_obj_mesh_representation(self, context, obj):
         product = self.file.by_id(obj.BIMObjectProperties.ifc_definition_id)
+        material = ifcopenshell.util.element.get_material(product, should_skip_usage=True)
 
         if not product.is_a("IfcGridAxis"):
             tool.Geometry.clear_cache(product)
 
         if product.is_a("IfcGridAxis"):
+            # Grid geometry does not follow the "representation" paradigm and needs to be treated specially
             ifcopenshell.api.run("grid.create_axis_curve", self.file, **{"axis_curve": obj, "grid_axis": product})
             return
-        if product.is_a("IfcRelSpaceBoundary"):
+        elif product.is_a("IfcRelSpaceBoundary"):
             # TODO refactor
             settings = tool.Boundary.get_assign_connection_geometry_settings(obj)
             ifcopenshell.api.run("boundary.assign_connection_geometry", tool.Ifc.get(), **settings)
             return
+        elif material and material.is_a() in ["IfcMaterialProfileSet", "IfcMaterialLayerSet"]:
+            # These objects are parametrically based on an axis and should not be modified as a mesh
+            return
 
         core.edit_object_placement(tool.Ifc, tool.Geometry, tool.Surveyor, obj=obj)
 
@@ -207,7 +245,10 @@ class UpdateRepresentation(bpy.types.Operator):
         new_representation = ifcopenshell.api.run("geometry.add_representation", self.file, **representation_data)
 
         if tool.Geometry.is_body_representation(new_representation):
-            [tool.Geometry.run_style_add_style(obj=mat) for mat in tool.Geometry.get_object_materials_without_styles(obj)]
+            [
+                tool.Geometry.run_style_add_style(obj=mat)
+                for mat in tool.Geometry.get_object_materials_without_styles(obj)
+            ]
             ifcopenshell.api.run(
                 "style.assign_representation_styles",
                 self.file,
@@ -237,7 +278,7 @@ class UpdateParametricRepresentation(bpy.types.Operator):
 
     @classmethod
     def poll(cls, context):
-        return context.active_object.mode == "OBJECT"
+        return context.active_object and context.active_object.mode == "OBJECT"
 
     def execute(self, context):
         self.file = IfcStore.get_file()
@@ -251,7 +292,6 @@ class UpdateParametricRepresentation(bpy.types.Operator):
             obj=obj,
             representation=tool.Ifc.get().by_id(props.ifc_definition_id),
             should_reload=True,
-            enable_dynamic_voids=False,
             is_global=True,
             should_sync_changes_first=False,
         )
@@ -327,21 +367,27 @@ class OverrideDeleteTrait:
             if getattr(element, "FillsVoids", None):
                 self.remove_filling(element)
             if element.is_a("IfcOpeningElement"):
-                for rel in element.HasFillings:
-                    self.remove_filling(rel.RelatedBuildingElement)
-                if element.VoidsElements:
-                    self.delete_opening_element(element)
-            elif getattr(element, "HasOpenings", None):
-                for rel in element.HasOpenings:
-                    self.delete_opening_element(rel.RelatedOpeningElement)
+                if element.HasFillings:
+                    for rel in element.HasFillings:
+                        self.remove_filling(rel.RelatedBuildingElement)
+                else:
+                    if element.VoidsElements:
+                        self.delete_opening_element(element)
+            else:
+                if getattr(element, "HasOpenings", None):
+                    for rel in element.HasOpenings:
+                        self.delete_opening_element(rel.RelatedOpeningElement)
+                for port in ifcopenshell.util.system.get_ports(element):
+                    self.remove_port(port)
 
     def delete_opening_element(self, element):
-        obj = IfcStore.get_element(element.VoidsElements[0].RelatingBuildingElement.id())
-        bpy.ops.bim.remove_opening(opening_id=element.id(), obj=obj.name)
+        bpy.ops.bim.remove_opening(opening_id=element.id())
 
     def remove_filling(self, element):
-        obj = IfcStore.get_element(element.id())
-        bpy.ops.bim.remove_filling(obj=obj.name)
+        bpy.ops.bim.remove_filling(filling=element.id())
+
+    def remove_port(self, port):
+        blenderbim.core.system.remove_port(tool.Ifc, tool.System, port=port)
 
 
 class OverrideDelete(bpy.types.Operator, OverrideDeleteTrait):
@@ -485,6 +531,9 @@ class OverrideDuplicateMove(bpy.types.Operator):
 
     def _execute(self, context):
         self.new_active_obj = None
+        # Track decompositions so they can be recreated after the operation
+        relationships = tool.Root.get_decomposition_relationships(context.selected_objects)
+        old_to_new = {}
         for obj in context.selected_objects:
             new_obj = obj.copy()
             if obj.data:
@@ -495,8 +544,12 @@ class OverrideDuplicateMove(bpy.types.Operator):
                 collection.objects.link(new_obj)
             obj.select_set(False)
             new_obj.select_set(True)
-            # This is the only difference
-            blenderbim.core.root.copy_class(tool.Ifc, tool.Collector, tool.Geometry, tool.Root, obj=new_obj)
+            # Copy the actual class
+            new = blenderbim.core.root.copy_class(tool.Ifc, tool.Collector, tool.Geometry, tool.Root, obj=new_obj)
+            if new:
+                old_to_new[tool.Ifc.get_entity(obj)] = [new]
+        # Recreate decompositions
+        tool.Root.recreate_decompositions(relationships, old_to_new)
         bpy.ops.transform.translate("INVOKE_DEFAULT")
         blenderbim.bim.handler.purge_module_data()
 
@@ -533,6 +586,9 @@ class OverrideDuplicateMoveLinked(bpy.types.Operator):
 
     def _execute(self, context):
         self.new_active_obj = None
+        # Track decompositions so they can be recreated after the operation
+        relationships = tool.Root.get_decomposition_relationships(context.selected_objects)
+        old_to_new = {}
         for obj in context.selected_objects:
             new_obj = obj.copy()
             if obj == context.active_object:
@@ -541,8 +597,12 @@ class OverrideDuplicateMoveLinked(bpy.types.Operator):
                 collection.objects.link(new_obj)
             obj.select_set(False)
             new_obj.select_set(True)
-            # This is the only difference
-            blenderbim.core.root.copy_class(tool.Ifc, tool.Collector, tool.Geometry, tool.Root, obj=new_obj)
+            # Copy the actual class
+            new = blenderbim.core.root.copy_class(tool.Ifc, tool.Collector, tool.Geometry, tool.Root, obj=new_obj)
+            if new:
+                old_to_new[tool.Ifc.get_entity(obj)] = new
+        # Recreate decompositions
+        tool.Root.recreate_decompositions(relationships, old_to_new)
         bpy.ops.transform.translate("INVOKE_DEFAULT")
         blenderbim.bim.handler.purge_module_data()
         return {"FINISHED"}

src/blenderbim/blenderbim/bim/module/geometry/ui.py

@@ -19,7 +19,8 @@
 import bpy
 from bpy.types import Panel
 from blenderbim.bim.ifc import IfcStore
-from blenderbim.bim.module.geometry.data import RepresentationsData, DerivedPlacementsData
+from blenderbim.bim.helper import prop_with_search
+from blenderbim.bim.module.geometry.data import RepresentationsData, ConnectionsData, DerivedPlacementsData
 
 
 class BIM_PT_representations(Panel):
@@ -50,7 +51,7 @@ class BIM_PT_representations(Panel):
             layout.label(text="No representations found")
 
         row = layout.row(align=True)
-        row.prop(context.scene.BIMRootProperties, "contexts", text="")
+        prop_with_search(row, context.scene.BIMRootProperties, "contexts", text="")
         row.operator("bim.add_representation", icon="ADD", text="")
 
         for representation in RepresentationsData.data["representations"]:
@@ -67,6 +68,43 @@ class BIM_PT_representations(Panel):
             row.operator("bim.remove_representation", icon="X", text="").representation_id = representation["id"]
 
 
+class BIM_PT_connections(Panel):
+    bl_label = "IFC Connections"
+    bl_idname = "BIM_PT_connections"
+    bl_options = {"DEFAULT_CLOSED"}
+    bl_space_type = "PROPERTIES"
+    bl_region_type = "WINDOW"
+    bl_context = "object"
+    bl_parent_id = "BIM_PT_geometry_object"
+
+    @classmethod
+    def poll(cls, context):
+        if not context.active_object:
+            return False
+        if not IfcStore.get_element(context.active_object.BIMObjectProperties.ifc_definition_id):
+            return False
+        return IfcStore.get_file()
+
+    def draw(self, context):
+        if not ConnectionsData.is_loaded:
+            ConnectionsData.load()
+
+        layout = self.layout
+        props = context.active_object.BIMObjectProperties
+
+        if not ConnectionsData.data["connections"]:
+            layout.label(text="No connections found")
+
+        for connection in ConnectionsData.data["connections"]:
+            row = self.layout.row(align=True)
+            row.label(text=connection["Name"], icon="SNAP_ON" if connection["is_relating"] else "SNAP_OFF")
+            row.label(text=connection["ConnectionType"])
+            op = row.operator("bim.select_connection", icon="RESTRICT_SELECT_OFF", text="")
+            op.connection = connection["id"]
+            op = row.operator("bim.remove_connection", icon="X", text="")
+            op.connection = connection["id"]
+
+
 class BIM_PT_mesh(Panel):
     bl_label = "IFC Representation"
     bl_idname = "BIM_PT_mesh"
@@ -89,18 +127,6 @@ class BIM_PT_mesh(Panel):
         layout = self.layout
         props = context.active_object.data.BIMMeshProperties
 
-        row = layout.row(align=True)
-        op = row.operator("bim.switch_representation", text="Bake Voids", icon="SELECT_SUBTRACT")
-        op.should_switch_all_meshes = True
-        op.should_reload = True
-        op.ifc_definition_id = props.ifc_definition_id
-        op.disable_opening_subtractions = False
-        op = row.operator("bim.switch_representation", text="Dynamic Voids", icon="SELECT_INTERSECT")
-        op.should_switch_all_meshes = True
-        op.should_reload = True
-        op.ifc_definition_id = props.ifc_definition_id
-        op.disable_opening_subtractions = True
-
         row = layout.row()
         row.operator("bim.copy_representation")
 

src/blenderbim/blenderbim/bim/module/georeference/data.py

@@ -0,0 +1,123 @@
+# BlenderBIM Add-on - OpenBIM Blender Add-on
+# Copyright (C) 2022 Dion Moult <dion@thinkmoult.com>
+#
+# This file is part of BlenderBIM Add-on.
+#
+# BlenderBIM Add-on is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# BlenderBIM Add-on is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with BlenderBIM Add-on.  If not, see <http://www.gnu.org/licenses/>.
+
+
+import bpy
+import ifcopenshell.util.geolocation
+import blenderbim.tool as tool
+
+
+def refresh():
+    GeoreferenceData.is_loaded = False
+
+
+class GeoreferenceData:
+    data = {}
+    is_loaded = False
+
+    @classmethod
+    def load(cls):
+        cls.data["blender_derived_angle"] = cls.blender_derived_angle()
+        cls.data["map_conversion"] = cls.map_conversion()
+        cls.data["map_derived_angle"] = cls.map_derived_angle()
+        cls.data["projected_crs"] = cls.projected_crs()
+        cls.data["true_north"] = cls.true_north()
+        cls.data["true_derived_angle"] = cls.true_derived_angle()
+        cls.is_loaded = True
+
+    @classmethod
+    def blender_derived_angle(cls):
+        props = bpy.context.scene.BIMGeoreferenceProperties
+        if props.has_blender_offset:
+            return str(
+                round(
+                    ifcopenshell.util.geolocation.xaxis2angle(
+                        float(props.blender_x_axis_abscissa), float(props.blender_x_axis_ordinate)
+                    ),
+                    3,
+                )
+            )
+
+    @classmethod
+    def map_conversion(cls):
+        if tool.Ifc.get_schema() == "IFC2X3":
+            return {}
+
+        for context in tool.Ifc.get().by_type("IfcGeometricRepresentationContext", include_subtypes=False):
+            if context.HasCoordinateOperation:
+                map_conversion = context.HasCoordinateOperation[0].get_info()
+                del map_conversion["id"]
+                del map_conversion["type"]
+                del map_conversion["SourceCRS"]
+                del map_conversion["TargetCRS"]
+                return map_conversion
+        return {}
+
+    @classmethod
+    def map_derived_angle(cls):
+        if (
+            cls.data["map_conversion"]
+            and cls.data["map_conversion"]["XAxisAbscissa"] is not None
+            and cls.data["map_conversion"]["XAxisOrdinate"] is not None
+        ):
+            return str(
+                round(
+                    ifcopenshell.util.geolocation.xaxis2angle(
+                        cls.data["map_conversion"]["XAxisAbscissa"], cls.data["map_conversion"]["XAxisOrdinate"]
+                    ),
+                    3,
+                )
+            )
+        return ""
+
+    @classmethod
+    def projected_crs(cls):
+        if tool.Ifc.get_schema() == "IFC2X3":
+            return {}
+
+        for context in tool.Ifc.get().by_type("IfcGeometricRepresentationContext", include_subtypes=False):
+            if context.HasCoordinateOperation:
+                projected_crs = context.HasCoordinateOperation[0].TargetCRS.get_info()
+                del projected_crs["id"]
+                del projected_crs["type"]
+                if projected_crs["MapUnit"]:
+                    unit = projected_crs["MapUnit"]
+                    projected_crs["MapUnit"] = (getattr(unit, "Prefix", "") or "") + unit.Name
+                return projected_crs
+        return {}
+
+    @classmethod
+    def true_north(cls):
+        ifc = tool.Ifc.get()
+        true_north = {}
+
+        if ifc.schema == "IFC2X3":
+            return
+
+        for context in ifc.by_type("IfcGeometricRepresentationContext", include_subtypes=False):
+            if not context.TrueNorth:
+                continue
+            true_north = context.TrueNorth.DirectionRatios
+            break
+
+        return true_north
+
+    @classmethod
+    def true_derived_angle(cls):
+        if cls.data["true_north"]:
+            return str(round(ifcopenshell.util.geolocation.yaxis2angle(*cls.data["true_north"][0:2]), 3))

src/blenderbim/blenderbim/bim/module/georeference/operator.py

@@ -17,345 +17,157 @@
 # along with BlenderBIM Add-on.  If not, see <http://www.gnu.org/licenses/>.
 
 import bpy
-import json
-import ifcopenshell
-import ifcopenshell.util.unit
-import ifcopenshell.util.attribute
-import ifcopenshell.api
-import blenderbim.bim.helper
-from blenderbim.bim.ifc import IfcStore
-from ifcopenshell.api.georeference.data import Data
-from ifcopenshell.api.unit.data import Data as UnitData
-from math import radians, degrees, atan, tan, cos, sin
+
+import blenderbim.tool as tool
+import blenderbim.core.georeference as core
 
 
-class EnableEditingGeoreferencing(bpy.types.Operator):
-    bl_idname = "bim.enable_editing_georeferencing"
-    bl_label = "Enable Editing Georeferencing"
-    bl_options = {"REGISTER", "UNDO"}
-
-    def execute(self, context):
-        self.file = IfcStore.get_file()
-        props = context.scene.BIMGeoreferenceProperties
-        self.props = props
-
-        props.projected_crs.clear()
-
-        blenderbim.bim.helper.import_attributes(
-            "IfcProjectedCRS", props.projected_crs, Data.projected_crs, self.import_projected_crs_attributes
-        )
-
-        props.map_conversion.clear()
-        blenderbim.bim.helper.import_attributes(
-            "IfcMapConversion", props.map_conversion, Data.map_conversion, self.import_map_conversion_attributes
-        )
-
-        props.has_true_north = bool(Data.true_north)
-        if Data.true_north:
-            props.true_north_abscissa = str(Data.true_north[0])
-            props.true_north_ordinate = str(Data.true_north[1])
-
-        props.is_editing = True
-        return {"FINISHED"}
-
-    def import_projected_crs_attributes(self, name, prop, data):
-        if name == "MapUnit":
-            new = self.props.projected_crs.add()
-            new.name = name
-            new.data_type = "enum"
-            new.is_null = data[name] is None
-            new.is_optional = True
-            new.enum_items = json.dumps(
-                {u["id"]: u["Name"] for u in UnitData.units.values() if u["UnitType"] == "LENGTHUNIT"}
-            )
-            if data["MapUnit"]:
-                new.enum_value = str(data["MapUnit"]["id"])
-            return True
-
-    def import_map_conversion_attributes(self, name, prop, data):
-        if name not in ["SourceCRS", "TargetCRS"]:
-            # Enforce a string data type to prevent data loss in single-precision Blender props
-            prop.data_type = "string"
-            prop.string_value = "" if prop.is_null else str(data[name])
-            return True
-
-
-class DisableEditingGeoreferencing(bpy.types.Operator):
-    bl_idname = "bim.disable_editing_georeferencing"
-    bl_label = "Disable Editing Georeferencing"
-    bl_options = {"REGISTER", "UNDO"}
-
-    def execute(self, context):
-        props = context.scene.BIMGeoreferenceProperties
-        props.is_editing = False
-        return {"FINISHED"}
-
-
-class EditGeoreferencing(bpy.types.Operator):
-    bl_idname = "bim.edit_georeferencing"
-    bl_label = "Edit Georeferencing"
-    bl_options = {"REGISTER", "UNDO"}
-
-    def execute(self, context):
-        return IfcStore.execute_ifc_operator(self, context)
-
-    def _execute(self, context):
-        self.file = IfcStore.get_file()
-        props = context.scene.BIMGeoreferenceProperties
-
-        projected_crs = blenderbim.bim.helper.export_attributes(props.projected_crs, self.export_crs_attributes)
-        map_conversion = blenderbim.bim.helper.export_attributes(props.map_conversion, self.export_map_attributes)
-
-        true_north = None
-        if props.has_true_north:
-            try:
-                true_north = [float(props.true_north_abscissa), float(props.true_north_ordinate)]
-            except ValueError:
-                self.report({"ERROR"}, "True North Abscissa and Ordinate expect a number")
-
-        ifcopenshell.api.run(
-            "georeference.edit_georeferencing",
-            self.file,
-            **{
-                "map_conversion": map_conversion,
-                "projected_crs": projected_crs,
-                "true_north": true_north,
-            }
-        )
-        Data.load(self.file)
-        bpy.ops.bim.disable_editing_georeferencing()
-        return {"FINISHED"}
-
-    def export_map_attributes(self, attributes, prop):
-        if not prop.is_null and prop.data_type == "string":
-            # We store our floats as string to prevent single precision data loss
-            attributes[prop.name] = float(prop.string_value)
-            return True
-
-    def export_crs_attributes(self, attributes, prop):
-        if not prop.is_null and prop.name == "MapUnit":
-            attributes[prop.name] = self.file.by_id(int(prop.enum_value))
-            return True
-
-
-class SetBlenderGridNorth(bpy.types.Operator):
-    bl_idname = "bim.set_blender_grid_north"
-    bl_label = "Set Blender Grid North"
-    bl_options = {"REGISTER", "UNDO"}
-
-    def execute(self, context):
-        context.scene.sun_pos_properties.north_offset = -radians(
-            ifcopenshell.util.geolocation.xaxis2angle(
-                float(context.scene.BIMGeoreferenceProperties.map_conversion.get("XAxisAbscissa").string_value),
-                float(context.scene.BIMGeoreferenceProperties.map_conversion.get("XAxisOrdinate").string_value),
-            )
-        )
-        return {"FINISHED"}
-
-
-class SetIfcGridNorth(bpy.types.Operator):
-    bl_idname = "bim.set_ifc_grid_north"
-    bl_label = "Set IFC Grid North"
-    bl_options = {"REGISTER", "UNDO"}
-
-    def execute(self, context):
-        x_angle = -context.scene.sun_pos_properties.north_offset
-        context.scene.BIMGeoreferenceProperties.map_conversion.get("XAxisAbscissa").string_value = str(cos(x_angle))
-        context.scene.BIMGeoreferenceProperties.map_conversion.get("XAxisOrdinate").string_value = str(sin(x_angle))
-        return {"FINISHED"}
-
-
-class SetBlenderTrueNorth(bpy.types.Operator):
-    bl_idname = "bim.set_blender_true_north"
-    bl_label = "Set Blender True North"
-    bl_options = {"REGISTER", "UNDO"}
-
-    def execute(self, context):
-        context.scene.sun_pos_properties.north_offset = -radians(
-            ifcopenshell.util.geolocation.yaxis2angle(
-                float(context.scene.BIMGeoreferenceProperties.true_north_abscissa),
-                float(context.scene.BIMGeoreferenceProperties.true_north_ordinate),
-            )
-        )
-        return {"FINISHED"}
-
-
-class SetIfcTrueNorth(bpy.types.Operator):
-    bl_idname = "bim.set_ifc_true_north"
-    bl_label = "Set IFC True North"
-    bl_options = {"REGISTER", "UNDO"}
-
-    def execute(self, context):
-        y_angle = -context.scene.sun_pos_properties.north_offset + radians(90)
-        context.scene.BIMGeoreferenceProperties.true_north_abscissa = str(cos(y_angle))
-        context.scene.BIMGeoreferenceProperties.true_north_ordinate = str(sin(y_angle))
-        return {"FINISHED"}
-
-
-class RemoveGeoreferencing(bpy.types.Operator):
-    bl_idname = "bim.remove_georeferencing"
-    bl_label = "Remove Georeferencing"
-    bl_options = {"REGISTER", "UNDO"}
-
-    def execute(self, context):
-        return IfcStore.execute_ifc_operator(self, context)
-
-    def _execute(self, context):
-        ifcopenshell.api.run("georeference.remove_georeferencing", IfcStore.get_file())
-        Data.load(IfcStore.get_file())
-        return {"FINISHED"}
-
-
-class AddGeoreferencing(bpy.types.Operator):
+class AddGeoreferencing(bpy.types.Operator, tool.Ifc.Operator):
     bl_idname = "bim.add_georeferencing"
     bl_label = "Add Georeferencing"
     bl_options = {"REGISTER", "UNDO"}
-
-    def execute(self, context):
-        return IfcStore.execute_ifc_operator(self, context)
+    bl_description = "Add a new georeference"
 
     def _execute(self, context):
-        ifcopenshell.api.run("georeference.add_georeferencing", IfcStore.get_file())
-        Data.load(IfcStore.get_file())
-        return {"FINISHED"}
+        core.add_georeferencing(tool.Ifc)
 
 
-class ConvertLocalToGlobal(bpy.types.Operator):
-    bl_idname = "bim.convert_local_to_global"
-    bl_label = "Convert Local To Global"
+class EnableEditingGeoreferencing(bpy.types.Operator, tool.Ifc.Operator):
+    bl_idname = "bim.enable_editing_georeferencing"
+    bl_label = "Enable Editing Georeferencing"
     bl_options = {"REGISTER", "UNDO"}
+    bl_description = "Enable editing georeferencing"
 
-    @classmethod
-    def poll(cls, context):
-        file = IfcStore.get_file()
-        props = context.scene.BIMGeoreferenceProperties
-        return file and props.coordinate_input.count(",") == 2
-
-    def execute(self, context):
-        if not Data.is_loaded:
-            Data.load(IfcStore.get_file())
-        props = context.scene.BIMGeoreferenceProperties
-        x, y, z = [float(co) for co in props.coordinate_input.split(",")]
-
-        if props.has_blender_offset:
-            results = ifcopenshell.util.geolocation.xyz2enh(
-                x,
-                y,
-                z,
-                float(props.blender_eastings),
-                float(props.blender_northings),
-                float(props.blender_orthogonal_height),
-                float(props.blender_x_axis_abscissa),
-                float(props.blender_x_axis_ordinate),
-                1.0,
-            )
-            x, y, z = results
-
-        # TODO: what if the project CRS units and the project units are different?
-
-        if Data.map_conversion:
-            results = ifcopenshell.util.geolocation.xyz2enh(
-                x,
-                y,
-                z,
-                Data.map_conversion["Eastings"],
-                Data.map_conversion["Northings"],
-                Data.map_conversion["OrthogonalHeight"],
-                Data.map_conversion.get("XAxisAbscissa", 1.0),
-                Data.map_conversion.get("XAxisOrdinate", 0.0),
-                Data.map_conversion.get("Scale", 1.0),
-            )
-        else:
-            results = (x, y, z)
-
-        props.coordinate_output = ",".join([str(r) for r in results])
-        context.scene.cursor.location = results
-        return {"FINISHED"}
+    def _execute(self, context):
+        core.enable_editing_georeferencing(tool.Georeference)
 
 
-class ConvertGlobalToLocal(bpy.types.Operator):
-    bl_idname = "bim.convert_global_to_local"
-    bl_label = "Convert Global To Local"
+class RemoveGeoreferencing(bpy.types.Operator, tool.Ifc.Operator):
+    bl_idname = "bim.remove_georeferencing"
+    bl_label = "Remove Georeferencing"
     bl_options = {"REGISTER", "UNDO"}
+    bl_description = "Remove the georeferencing"
 
-    @classmethod
-    def poll(cls, context):
-        file = IfcStore.get_file()
-        props = context.scene.BIMGeoreferenceProperties
-        return file and file.by_type("IfcUnitAssignment") and props.coordinate_input.count(",") == 2
-
-    def execute(self, context):
-        if not Data.is_loaded:
-            Data.load(IfcStore.get_file())
-        props = context.scene.BIMGeoreferenceProperties
-        x, y, z = [float(co) for co in props.coordinate_input.split(",")]
-
-        if Data.map_conversion:
-            results = ifcopenshell.util.geolocation.enh2xyz(
-                x,
-                y,
-                z,
-                Data.map_conversion["Eastings"],
-                Data.map_conversion["Northings"],
-                Data.map_conversion["OrthogonalHeight"],
-                Data.map_conversion.get("XAxisAbscissa", 1.0),
-                Data.map_conversion.get("XAxisOrdinate", 0.0),
-                Data.map_conversion.get("Scale", 1.0),
-            )
-        else:
-            results = (x, y, z)
-
-        if props.has_blender_offset:
-            results = ifcopenshell.util.geolocation.enh2xyz(
-                results[0],
-                results[1],
-                results[2],
-                float(props.blender_eastings),
-                float(props.blender_northings),
-                float(props.blender_orthogonal_height),
-                float(props.blender_x_axis_abscissa),
-                float(props.blender_x_axis_ordinate),
-                1.0,
-            )
-
-        props.coordinate_output = ",".join([str(r) for r in results])
-
-        scale = ifcopenshell.util.unit.calculate_unit_scale(IfcStore.get_file())
-        context.scene.cursor.location = [o * scale for o in results]
-        return {"FINISHED"}
+    def _execute(self, context):
+        core.remove_georeferencing(tool.Ifc)
 
 
-class GetCursorLocation(bpy.types.Operator):
+class EditGeoreferencing(bpy.types.Operator, tool.Ifc.Operator):
+    bl_idname = "bim.edit_georeferencing"
+    bl_label = "Edit Georeferencing"
+    bl_options = {"REGISTER", "UNDO"}
+    bl_description = "Edit the georeferencing"
+
+    def _execute(self, context):
+        core.edit_georeferencing(tool.Ifc, tool.Georeference)
+
+
+class DisableEditingGeoreferencing(bpy.types.Operator, tool.Ifc.Operator):
+    bl_idname = "bim.disable_editing_georeferencing"
+    bl_label = "Disable Editing Georeferencing"
+    bl_options = {"REGISTER", "UNDO"}
+    bl_description = "Close editing panel"
+
+    def _execute(self, context):
+        core.disable_editing_georeferencing(tool.Georeference)
+
+
+class SetIfcGridNorth(bpy.types.Operator, tool.Ifc.Operator):
+    bl_idname = "bim.set_ifc_grid_north"
+    bl_label = "Set IFC Grid North"
+    bl_options = {"REGISTER", "UNDO"}
+    bl_description = "Set IFC grid north"
+
+    def _execute(self, context):
+        core.set_ifc_grid_north(tool.Georeference)
+
+
+class SetBlenderGridNorth(bpy.types.Operator, tool.Ifc.Operator):
+    bl_idname = "bim.set_blender_grid_north"
+    bl_label = "Set Blender Grid North"
+    bl_options = {"REGISTER", "UNDO"}
+    bl_description = "Set Blender grid north"
+
+    def _execute(self, context):
+        core.set_blender_grid_north(tool.Georeference)
+
+
+class GetCursorLocation(bpy.types.Operator, tool.Ifc.Operator):
     bl_idname = "bim.get_cursor_location"
     bl_label = "Get Cursor Location"
     bl_options = {"REGISTER", "UNDO"}
+    bl_description = "Insert the current cursor coordinates"
 
     @classmethod
     def poll(cls, context):
-        file = IfcStore.get_file()
-        return file and file.by_type("IfcUnitAssignment")
+        return tool.Ifc.get()
 
-    def execute(self, context):
-        props = context.scene.BIMGeoreferenceProperties
-        scale = ifcopenshell.util.unit.calculate_unit_scale(IfcStore.get_file())
-        project_coordinates = [o / scale for o in context.scene.cursor.location]
-        props.coordinate_input = ",".join([str(o) for o in project_coordinates])
-        return {"FINISHED"}
+    def _execute(self, context):
+        core.get_cursor_location(tool.Georeference)
 
 
-class SetCursorLocation(bpy.types.Operator):
+class SetCursorLocation(bpy.types.Operator, tool.Ifc.Operator):
     bl_idname = "bim.set_cursor_location"
     bl_label = "Set Cursor Location"
     bl_options = {"REGISTER", "UNDO"}
+    bl_description = "Move curson location to the specified coordinates"
 
     @classmethod
     def poll(cls, context):
-        file = IfcStore.get_file()
         props = context.scene.BIMGeoreferenceProperties
-        return file and file.by_type("IfcUnitAssignment") and props.coordinate_output.count(",") == 2
+        return tool.Ifc.get() and props.coordinate_output.count(",") == 2
 
-    def execute(self, context):
+    def _execute(self, context):
+        core.set_cursor_location(tool.Georeference)
+
+
+class SetIfcTrueNorth(bpy.types.Operator, tool.Ifc.Operator):
+    bl_idname = "bim.set_ifc_true_north"
+    bl_label = "Set IFC True North"
+    bl_options = {"REGISTER", "UNDO"}
+    bl_description = "Set IFC True north"
+
+    def _execute(self, context):
+        core.set_ifc_true_north(tool.Georeference)
+
+
+class SetBlenderTrueNorth(bpy.types.Operator, tool.Ifc.Operator):
+    bl_idname = "bim.set_blender_true_north"
+    bl_label = "Set Blender True North"
+    bl_options = {"REGISTER", "UNDO"}
+    bl_description = "Set Blender true north"
+
+    def _execute(self, context):
+        core.set_blender_true_north(tool.Georeference)
+
+
+class ConvertLocalToGlobal(bpy.types.Operator, tool.Ifc.Operator):
+    bl_idname = "bim.convert_local_to_global"
+    bl_label = "Convert Local To Global"
+    bl_options = {"REGISTER", "UNDO"}
+    bl_description = "Convert local coordinate to global coordinate"
+
+    @classmethod
+    def poll(cls, context):
+        file = tool.Ifc.get()
         props = context.scene.BIMGeoreferenceProperties
-        scale = ifcopenshell.util.unit.calculate_unit_scale(IfcStore.get_file())
-        context.scene.cursor.location = [float(co) * scale for co in props.coordinate_output.split(",")]
-        return {"FINISHED"}
+        return file and props.coordinate_input.count(",") == 2
+
+    def _execute(self, context):
+        core.convert_local_to_global(tool.Georeference)
+
+
+class ConvertGlobalToLocal(bpy.types.Operator, tool.Ifc.Operator):
+    bl_idname = "bim.convert_global_to_local"
+    bl_label = "Convert Global To Local"
+    bl_options = {"REGISTER", "UNDO"}
+    bl_description = "Convert global coordinate to local coordinate"
+
+    @classmethod
+    def poll(cls, context):
+        file = tool.Ifc.get()
+        props = context.scene.BIMGeoreferenceProperties
+        return file and file.by_type("IfcUnitAssignment") and props.coordinate_input.count(",") == 2
+
+    def _execute(self, context):
+        core.convert_global_to_local(tool.Georeference)

src/blenderbim/blenderbim/bim/module/georeference/ui.py

@@ -16,11 +16,10 @@
 # You should have received a copy of the GNU General Public License
 # along with BlenderBIM Add-on.  If not, see <http://www.gnu.org/licenses/>.
 
-import ifcopenshell.util.geolocation
+import blenderbim.tool as tool
 from bpy.types import Panel
-from ifcopenshell.api.georeference.data import Data
-from blenderbim.bim.ifc import IfcStore
 from blenderbim.bim.helper import draw_attributes, draw_attribute
+from blenderbim.bim.module.georeference.data import GeoreferenceData
 
 
 class BIM_PT_gis(Panel):
@@ -32,16 +31,13 @@ class BIM_PT_gis(Panel):
     bl_context = "scene"
     bl_parent_id = "BIM_PT_geometry"
 
-    @classmethod
-    def poll(cls, context):
-        return IfcStore.get_file()
-
     def draw(self, context):
         self.layout.use_property_split = True
         self.layout.use_property_decorate = False
         props = context.scene.BIMGeoreferenceProperties
-        if not Data.is_loaded:
-            Data.load(IfcStore.get_file())
+
+        if not GeoreferenceData.is_loaded:
+            GeoreferenceData.load()
 
         if props.is_editing:
             return self.draw_editable_ui(context)
@@ -82,10 +78,10 @@ class BIM_PT_gis(Panel):
     def draw_ui(self, context):
         props = context.scene.BIMGeoreferenceProperties
 
-        if not Data.projected_crs:
+        if not GeoreferenceData.data["projected_crs"]:
             row = self.layout.row(align=True)
             row.label(text="Not Georeferenced")
-            if IfcStore.get_file().schema != "IFC2X3":
+            if tool.Ifc.get_schema != "IFC2X3":
                 row.operator("bim.add_georeferencing", icon="ADD", text="")
 
         if props.has_blender_offset:
@@ -109,40 +105,27 @@ class BIM_PT_gis(Panel):
             row.label(text=props.blender_x_axis_ordinate)
             row = self.layout.row(align=True)
             row.label(text="Derived Grid North")
-            row.label(
-                text=str(
-                    round(
-                        ifcopenshell.util.geolocation.xaxis2angle(
-                            float(props.blender_x_axis_abscissa), float(props.blender_x_axis_ordinate)
-                        ),
-                        3,
-                    )
-                )
-            )
+            row.label(text=GeoreferenceData.data["blender_derived_angle"])
 
-        if Data.projected_crs:
+        if GeoreferenceData.data["projected_crs"]:
             row = self.layout.row(align=True)
             row.label(text="Projected CRS", icon="WORLD")
             row.operator("bim.enable_editing_georeferencing", icon="GREASEPENCIL", text="")
             row.operator("bim.remove_georeferencing", icon="X", text="")
 
-        for key, value in Data.projected_crs.items():
-            if key == "id" or key == "type" or not value:
+        for key, value in GeoreferenceData.data["projected_crs"].items():
+            if not value:
                 continue
-            if key == "MapUnit":
-                unit_value = value.get("Prefix", "") or ""
-                unit_value += value["Name"]
-                value = unit_value
             row = self.layout.row(align=True)
             row.label(text=key)
             row.label(text=str(value))
 
-        if Data.map_conversion:
+        if GeoreferenceData.data["map_conversion"]:
             row = self.layout.row(align=True)
             row.label(text="Map Conversion", icon="GRID")
 
-        for key, value in Data.map_conversion.items():
-            if key == "id" or key == "type" or key == "SourceCRS" or key == "TargetCRS" or value is None:
+        for key, value in GeoreferenceData.data["map_conversion"].items():
+            if value is None:
                 continue
             row = self.layout.row(align=True)
             row.label(text=key)
@@ -150,26 +133,17 @@ class BIM_PT_gis(Panel):
             if key == "XAxisOrdinate":
                 row = self.layout.row(align=True)
                 row.label(text="Derived Angle")
-                row.label(
-                    text=str(
-                        round(
-                            ifcopenshell.util.geolocation.xaxis2angle(
-                                Data.map_conversion["XAxisAbscissa"], Data.map_conversion["XAxisOrdinate"]
-                            ),
-                            3,
-                        )
-                    )
-                )
+                row.label(text=GeoreferenceData.data["map_derived_angle"])
 
-        if Data.true_north:
+        if GeoreferenceData.data["true_north"]:
             row = self.layout.row()
             row.label(text="True North", icon="LIGHT_SUN")
             row = self.layout.row(align=True)
             row.label(text="Vector")
-            row.label(text=str(Data.true_north[0:2])[1:-1])
+            row.label(text=str(GeoreferenceData.data["true_north"][0:2])[1:-1])
             row = self.layout.row(align=True)
             row.label(text="Derived Angle")
-            row.label(text=str(round(ifcopenshell.util.geolocation.yaxis2angle(*Data.true_north[0:2]), 3)))
+            row.label(text=GeoreferenceData.data["true_derived_angle"])
 
 
 class BIM_PT_gis_utilities(Panel):

src/blenderbim/blenderbim/bim/module/group/__init__.py

@@ -20,17 +20,20 @@ import bpy
 from . import ui, prop, operator
 
 classes = (
-    operator.LoadGroups,
-    operator.DisableGroupEditingUI,
     operator.AddGroup,
-    operator.EditGroup,
-    operator.RemoveGroup,
-    operator.ToggleAssigningGroup,
     operator.AssignGroup,
-    operator.UnassignGroup,
-    operator.EnableEditingGroup,
     operator.DisableEditingGroup,
+    operator.DisableGroupEditingUI,
+    operator.EditGroup,
+    operator.EnableEditingGroup,
+    operator.LoadGroups,
+    operator.RemoveGroup,
     operator.SelectGroupProducts,
+    operator.ToggleAssigningGroup,
+    operator.ToggleGroup,
+    operator.UnassignGroup,
+    operator.UpdateGroup,
+    prop.ExpandedGroups,
     prop.Group,
     prop.BIMGroupProperties,
     ui.BIM_PT_groups,
@@ -42,7 +45,9 @@ classes = (
 
 def register():
     bpy.types.Scene.BIMGroupProperties = bpy.props.PointerProperty(type=prop.BIMGroupProperties)
+    bpy.types.Scene.ExpandedGroups = bpy.props.PointerProperty(type=prop.ExpandedGroups)
 
 
 def unregister():
     del bpy.types.Scene.BIMGroupProperties
+    del bpy.types.Scene.ExpandedGroups

src/blenderbim/blenderbim/bim/module/group/operator.py

@@ -20,24 +20,89 @@ import bpy
 import ifcopenshell.util.attribute
 import ifcopenshell.api
 import blenderbim.bim.helper
+import blenderbim.tool as tool
 from blenderbim.bim.ifc import IfcStore
 from ifcopenshell.api.group.data import Data
+from ifcopenshell.util.selector import Selector
+import json
 
 
 class LoadGroups(bpy.types.Operator):
     bl_idname = "bim.load_groups"
     bl_label = "Load Groups"
     bl_options = {"REGISTER", "UNDO"}
+    is_refresh: bpy.props.BoolProperty(default=False)
 
     def execute(self, context):
-        props = context.scene.BIMGroupProperties
-        props.groups.clear()
+        self.props = context.scene.BIMGroupProperties
+        self.expanded_groups = json.loads(context.scene.ExpandedGroups.json_string)
+        self.props.groups.clear()
+        self.ifc = IfcStore.get_file()
+        if not self.is_refresh:
+            context.scene.ExpandedGroups.json_string = "{}"
+
         for ifc_definition_id, group in Data.groups.items():
-            new = props.groups.add()
-            new.ifc_definition_id = ifc_definition_id
-            new.name = group["Name"]
-        props.is_editing = True
+            if not group["HasAssignments"]:
+                new = self.props.groups.add()
+                new.ifc_definition_id = ifc_definition_id
+                new.name = group["Name"]
+                new.selection_query = group["Description"].split("*selector*")[1] if group["Description"] else ""
+                new.tree_depth = 0
+
+                if group["IsGroupedBy"]:
+                    #  assumes 1:1 cardinality, will need to be updated to reflect IFC4 changes
+                    # where the cardinality is 0:? - vulevukusej
+                    sub_groups = [g for g in group["IsGroupedBy"][0].RelatedObjects if g.is_a("IfcGroup")]
+                    new.has_children = True if len(sub_groups) != 0 else False
+
+                if self.is_refresh:
+                    self.recursively_load_sub_groups(ifc_definition_id, new)
+
+        self.props.is_editing = True
         bpy.ops.bim.disable_editing_group()
+        Data.load(IfcStore.get_file())
+        return {"FINISHED"}
+
+    def recursively_load_sub_groups(self, ifc_definition_id, parent):
+        sub_groups = [
+            k for k, v in Data.products.items() if self.ifc.by_id(k).is_a("IfcGroup") and ifc_definition_id in v
+        ]
+        if str(ifc_definition_id) not in self.expanded_groups or sub_groups == []:
+            return
+        else:
+            parent.is_expanded = True
+            parent.has_children = True
+            for group in sub_groups:
+                new = self.props.groups.add()
+                new.ifc_definition_id = group
+                new.name = Data.groups[group]["Name"]
+                new.selection_query = (
+                    Data.groups[group]["Description"].split("*selector*")[1]
+                    if Data.groups[group]["Description"]
+                    else ""
+                )
+                new.has_children = True if len(Data.groups[group]["IsGroupedBy"]) != 0 else False
+                new.tree_depth = parent.tree_depth + 1
+                self.recursively_load_sub_groups(new.ifc_definition_id, new)
+
+
+class ToggleGroup(bpy.types.Operator):
+    bl_idname = "bim.toggle_group"
+    bl_label = "Toggle Group"
+    bl_options = {"REGISTER", "UNDO"}
+    ifc_definition_id: bpy.props.IntProperty()
+    index: bpy.props.IntProperty()
+    option: bpy.props.StringProperty(name="Expand or Collapse")
+
+    def execute(self, context):
+        context.scene.BIMGroupProperties.groups[self.index].is_expanded = True if self.option == "Expand" else False
+        json_string = json.loads(context.scene.ExpandedGroups.json_string)
+        if self.option == "Expand":
+            json_string.setdefault(str(self.ifc_definition_id), None)
+        else:
+            json_string.pop(str(self.ifc_definition_id), None)
+        context.scene.ExpandedGroups.json_string = json.dumps(json_string)
+        bpy.ops.bim.load_groups(is_refresh=True)
         return {"FINISHED"}
 
 
@@ -54,17 +119,21 @@ class DisableGroupEditingUI(bpy.types.Operator):
 
 class AddGroup(bpy.types.Operator):
     bl_idname = "bim.add_group"
-    bl_label = "Add Group"
+    bl_label = "Add New Group"
     bl_options = {"REGISTER", "UNDO"}
+    group: bpy.props.IntProperty()
 
     def execute(self, context):
         return IfcStore.execute_ifc_operator(self, context)
 
     def _execute(self, context):
-        result = ifcopenshell.api.run("group.add_group", IfcStore.get_file())
-        Data.load(IfcStore.get_file())
-        bpy.ops.bim.load_groups()
-        bpy.ops.bim.enable_editing_group(group=result.id())
+        result = ifcopenshell.api.run("group.add_group", tool.Ifc.get())
+        if self.group:
+            ifcopenshell.api.run(
+                "group.assign_group", tool.Ifc.get(), products=[result], group=tool.Ifc.get().by_id(self.group)
+            )
+        Data.load(tool.Ifc.get())
+        bpy.ops.bim.load_groups(is_refresh=True)
         return {"FINISHED"}
 
 
@@ -72,6 +141,7 @@ class EditGroup(bpy.types.Operator):
     bl_idname = "bim.edit_group"
     bl_label = "Edit Group"
     bl_options = {"REGISTER", "UNDO"}
+    copy_from_selector: bpy.props.BoolProperty(name="Copy from Selector", default=False)
 
     def execute(self, context):
         return IfcStore.execute_ifc_operator(self, context)
@@ -84,12 +154,16 @@ class EditGroup(bpy.types.Operator):
                 attributes[attribute.name] = None
             else:
                 attributes[attribute.name] = attribute.string_value
+
+        if self.copy_from_selector:
+            attributes["Description"] = context.scene.IFCSelector.selection_query
+
         self.file = IfcStore.get_file()
         ifcopenshell.api.run(
             "group.edit_group", self.file, **{"group": self.file.by_id(props.active_group_id), "attributes": attributes}
         )
         Data.load(IfcStore.get_file())
-        bpy.ops.bim.load_groups()
+        bpy.ops.bim.load_groups(is_refresh=True)
         return {"FINISHED"}
 
 
@@ -107,7 +181,7 @@ class RemoveGroup(bpy.types.Operator):
         self.file = IfcStore.get_file()
         ifcopenshell.api.run("group.remove_group", self.file, **{"group": self.file.by_id(self.group)})
         Data.load(IfcStore.get_file())
-        bpy.ops.bim.load_groups()
+        bpy.ops.bim.load_groups(is_refresh=True)
         return {"FINISHED"}
 
 
@@ -120,9 +194,7 @@ class EnableEditingGroup(bpy.types.Operator):
     def execute(self, context):
         props = context.scene.BIMGroupProperties
         props.group_attributes.clear()
-
         blenderbim.bim.helper.import_attributes("IfcGroup", props.group_attributes, Data.groups[self.group])
-
         props.active_group_id = self.group
         return {"FINISHED"}
 
@@ -166,10 +238,8 @@ class AssignGroup(bpy.types.Operator):
             ifcopenshell.api.run(
                 "group.assign_group",
                 self.file,
-                **{
-                    "product": self.file.by_id(product.BIMObjectProperties.ifc_definition_id),
-                    "group": self.file.by_id(self.group),
-                }
+                products=[self.file.by_id(product.BIMObjectProperties.ifc_definition_id)],
+                group=self.file.by_id(self.group),
             )
         Data.load(self.file)
         return {"FINISHED"}
@@ -219,3 +289,32 @@ class SelectGroupProducts(bpy.types.Operator):
             if self.group in product_groups:
                 obj.select_set(True)
         return {"FINISHED"}
+
+
+class UpdateGroup(bpy.types.Operator):
+    bl_idname = "bim.update_group"
+    bl_label = "Update Group"
+    bl_options = {"REGISTER", "UNDO"}
+    query: bpy.props.StringProperty()
+    group_id: bpy.props.IntProperty()
+
+    def execute(self, context):
+        return IfcStore.execute_ifc_operator(self, context)
+
+    def _execute(self, context):
+        self.file = IfcStore.get_file()
+        group = self.file.by_id(self.group_id)
+        query = self.query
+
+        new_products = Selector.parse(self.file, query)
+        ifcopenshell.api.run(
+            "group.update_group_products",
+            self.file,
+            **{
+                "group": group,
+                "products": new_products,
+            }
+        )
+        Data.load(IfcStore.get_file())
+        bpy.ops.bim.load_groups(is_refresh=True)
+        return {"FINISHED"}

src/blenderbim/blenderbim/bim/module/group/prop.py

@@ -18,7 +18,10 @@
 
 import bpy
 from blenderbim.bim.prop import StrProperty, Attribute
+from blenderbim.bim.helper import import_attributes
+from ifcopenshell.api.group.data import Data
 from bpy.types import PropertyGroup
+import json
 from bpy.props import (
     PointerProperty,
     StringProperty,
@@ -31,9 +34,17 @@ from bpy.props import (
 )
 
 
+class ExpandedGroups(StrProperty):
+    json_string: StringProperty(name="JSON String", default="{}")
+
+
 class Group(PropertyGroup):
     name: StringProperty(name="Name")
     ifc_definition_id: IntProperty(name="IFC Definition ID")
+    selection_query: StringProperty(name="Selection Query")
+    is_expanded: BoolProperty(name="Is Expanded", default=False)
+    has_children: BoolProperty(name="Has Children", default=False)
+    tree_depth: IntProperty(name="Tree Depth")
 
 
 class BIMGroupProperties(PropertyGroup):

src/blenderbim/blenderbim/bim/module/group/ui.py

@@ -40,9 +40,9 @@ class BIM_PT_groups(Panel):
         self.props = context.scene.BIMGroupProperties
 
         row = self.layout.row(align=True)
-        row.label(text="{} Groups Found".format(len(Data.groups)), icon="OUTLINER")
+        row.label(text=f"{len(Data.groups)} Groups Found", icon="OUTLINER")
         if self.props.is_editing:
-            row.operator("bim.add_group", text="", icon="ADD")
+            row.operator("bim.add_group", text="", icon="ADD").group = 0
             row.operator("bim.disable_group_editing_ui", text="", icon="CANCEL")
         else:
             row.operator("bim.load_groups", text="", icon="GREASEPENCIL")
@@ -115,10 +115,22 @@ class BIM_PT_object_groups(Panel):
 
 
 class BIM_UL_groups(UIList):
-    def draw_item(self, context, layout, data, item, icon, active_data, active_propname):
+    def draw_item(self, context, layout, data, item, icon, active_data, active_propname, index):
         if item:
             row = layout.row(align=True)
-            row.label(text=item.name)
+            for i in range(0, item.tree_depth):
+                row.label(text="", icon="BLANK1")
+            if item.has_children:
+                op = row.operator(
+                    "bim.toggle_group", icon="TRIA_DOWN" if item.is_expanded else "TRIA_RIGHT", text="", emboss=False
+                )
+                op.ifc_definition_id = item.ifc_definition_id
+                op.index = index
+                op.option = "Collapse" if item.is_expanded else "Expand"
+            else:
+                row.label(text="", icon="BLANK1")
+
+            row.label(text=f"*{item.name}") if item.selection_query != "" else row.label(text=item.name)
             group_id = item.ifc_definition_id
             if context.scene.BIMGroupProperties.active_group_id == group_id:
                 op = row.operator("bim.select_group_products", text="", icon="RESTRICT_SELECT_OFF")
@@ -128,21 +140,46 @@ class BIM_UL_groups(UIList):
             elif context.scene.BIMGroupProperties.active_group_id:
                 op = row.operator("bim.select_group_products", text="", icon="RESTRICT_SELECT_OFF")
                 op.group = group_id
+                op = row.operator("bim.add_group", text="", icon="ADD")
+                op.group = group_id
                 op = row.operator("bim.remove_group", text="", icon="X")
                 op.group = group_id
+                if item.selection_query != "":
+                    op = row.operator("bim.update_group", text="", icon="FILE_REFRESH")
+                    op.group_id = item.ifc_definition_id
+                    op.query = item.selection_query
             else:
                 op = row.operator("bim.select_group_products", text="", icon="RESTRICT_SELECT_OFF")
                 op.group = group_id
                 op = row.operator("bim.enable_editing_group", text="", icon="GREASEPENCIL")
                 op.group = group_id
+                op = row.operator("bim.add_group", text="", icon="ADD")
+                op.group = group_id
                 op = row.operator("bim.remove_group", text="", icon="X")
                 op.group = group_id
+                if item.selection_query != "":
+                    op = row.operator("bim.update_group", text="", icon="FILE_REFRESH")
+                    op.group_id = item.ifc_definition_id
+                    op.query = item.selection_query
 
 
 class BIM_UL_object_groups(UIList):
-    def draw_item(self, context, layout, data, item, icon, active_data, active_propname):
+    def draw_item(self, context, layout, data, item, icon, active_data, active_propname, index):
         if item:
             row = layout.row(align=True)
+            for i in range(0, item.tree_depth):
+                row.label(text="", icon="BLANK1")
+            if item.has_children:
+                op = row.operator(
+                    "bim.toggle_group", icon="TRIA_DOWN" if item.is_expanded else "TRIA_RIGHT", text="", emboss=False
+                )
+                op.ifc_definition_id = item.ifc_definition_id
+                op.index = index
+                op.option = "Collapse" if item.is_expanded else "Expand"
+            else:
+                row.label(text="", icon="BLANK1")
             row.label(text=item.name)
+            op = row.operator("bim.remove_group", text="", icon="X")
+            op.group = item.ifc_definition_id
             op = row.operator("bim.assign_group", text="", icon="ADD")
             op.group = item.ifc_definition_id

src/blenderbim/blenderbim/bim/module/material/__init__.py

@@ -28,6 +28,7 @@ classes = (
     operator.AddProfile,
     operator.AssignMaterial,
     operator.AssignParameterizedProfile,
+    operator.ContractMaterialCategory,
     operator.CopyMaterial,
     operator.DisableEditingAssignedMaterial,
     operator.DisableEditingMaterialSetItem,
@@ -36,6 +37,7 @@ classes = (
     operator.EditMaterialSetItem,
     operator.EnableEditingAssignedMaterial,
     operator.EnableEditingMaterialSetItem,
+    operator.ExpandMaterialCategory,
     operator.LoadMaterials,
     operator.RemoveConstituent,
     operator.RemoveLayer,

src/blenderbim/blenderbim/bim/module/material/data.py

@@ -37,6 +37,7 @@ class MaterialsData:
         cls.data = {
             "total_materials": cls.total_materials(),
             "material_types": cls.material_types(),
+            "profiles": cls.profiles(),
         }
         cls.is_loaded = True
 
@@ -65,9 +66,16 @@ class MaterialsData:
             "IfcMaterialProfileSet",
             "IfcMaterialList",
         ]
-        if tool.Ifc.get_schema() == "IFC2X3":
+        version = tool.Ifc.get_schema()
+        if version == "IFC2X3":
             material_types = ["IfcMaterial", "IfcMaterialLayerSet", "IfcMaterialList"]
-        return [(m, m, "") for m in material_types]
+        return [
+            (m, m, ifcopenshell.util.doc.get_entity_doc(version, m).get("description", "")) for m in material_types
+        ]
+
+    @classmethod
+    def profiles(cls):
+        return [(str(p.id()), p.ProfileName or "Unnamed", "") for p in tool.Ifc.get().by_type("IfcProfileDef")]
 
 
 class ObjectMaterialData:
@@ -78,9 +86,26 @@ class ObjectMaterialData:
     def load(cls):
         cls.data = {
             "materials": cls.materials(),
+            "type_material": cls.type_material(),
         }
         cls.is_loaded = True
 
     @classmethod
     def materials(cls):
-        return sorted([(str(m.id()), m.Name or "Unnamed", "") for m in tool.Ifc.get().by_type("IfcMaterial")], key=lambda x: x[1])
+        return sorted(
+            [(str(m.id()), m.Name or "Unnamed", "") for m in tool.Ifc.get().by_type("IfcMaterial")], key=lambda x: x[1]
+        )
+
+    @classmethod
+    def type_material(cls):
+        element = tool.Ifc.get_entity(bpy.context.active_object)
+        element_type = ifcopenshell.util.element.get_type(element)
+        if element_type and element_type != element:
+            material = ifcopenshell.util.element.get_material(element_type)
+            if not material:
+                return
+            if material.is_a() in ("IfcMaterialLayerSetUsage", "IfcMaterialLayerSet"):
+                name_attr = "LayerSetName"
+            else:
+                name_attr = "Name"
+            return getattr(material, name_attr, "Unnamed") or "Unnamed"

src/blenderbim/blenderbim/bim/module/material/operator.py

@@ -28,7 +28,6 @@ import blenderbim.core.material as core
 from blenderbim.bim.module.material.prop import purge as material_prop_purge
 from blenderbim.bim.ifc import IfcStore
 from ifcopenshell.api.material.data import Data
-from ifcopenshell.api.profile.data import Data as ProfileData
 
 
 class LoadMaterials(bpy.types.Operator, tool.Ifc.Operator):
@@ -84,7 +83,6 @@ class AssignParameterizedProfile(bpy.types.Operator):
             **{"material_profile": self.file.by_id(self.material_profile), "profile": profile},
         )
         Data.load_profiles()
-        ProfileData.load(self.file)
         bpy.ops.bim.enable_editing_material_set_item(obj=obj.name, material_set_item=self.material_profile)
         return {"FINISHED"}
 
@@ -256,13 +254,11 @@ class AddProfile(bpy.types.Operator):
         ifcopenshell.api.run(
             "material.add_profile",
             self.file,
-            **{
-                "profile_set": self.file.by_id(self.profile_set),
-                "material": self.file.by_id(int(obj.BIMObjectMaterialProperties.material)),
-            },
+            profile_set=self.file.by_id(self.profile_set),
+            material=self.file.by_id(int(obj.BIMObjectMaterialProperties.material)),
+            profile=self.file.by_id(int(context.scene.BIMMaterialProperties.profiles)),
         )
         Data.load_profiles()
-        ProfileData.load(self.file)
         return {"FINISHED"}
 
 
@@ -281,7 +277,6 @@ class RemoveProfile(bpy.types.Operator):
         self.file = IfcStore.get_file()
         ifcopenshell.api.run("material.remove_profile", self.file, **{"profile": self.file.by_id(self.profile)})
         Data.load_profiles()
-        ProfileData.load(self.file)
         return {"FINISHED"}
 
 
@@ -341,7 +336,6 @@ class ReorderMaterialSetItem(bpy.types.Operator):
             Data.load_layers()
         elif material_set.is_a("IfcMaterialProfileSet"):
             Data.load_profiles()
-            ProfileData.load(self.file)
         elif material_set.is_a("IfcMaterialList"):
             Data.load_lists()
         return {"FINISHED"}
@@ -503,6 +497,7 @@ class DisableEditingAssignedMaterial(bpy.types.Operator):
     obj: bpy.props.StringProperty()
 
     def execute(self, context):
+        bpy.ops.bim.disable_editing_material_set_item()
         obj = bpy.data.objects.get(self.obj) if self.obj else context.active_object
         props = obj.BIMObjectMaterialProperties
         props.is_editing = False
@@ -526,6 +521,9 @@ class EditAssignedMaterial(bpy.types.Operator):
         props = obj.BIMObjectMaterialProperties
         product_data = Data.products[obj.BIMObjectProperties.ifc_definition_id]
 
+        if props.active_material_set_item_id != 0:  # We were editing a material layer set item
+            bpy.ops.bim.edit_material_set_item(material_set_item=props.active_material_set_item_id)
+
         if product_data["type"] == "IfcMaterial":
             bpy.ops.bim.unassign_material(obj=obj.name)
             bpy.ops.bim.assign_material(obj=obj.name, material_type="IfcMaterial")
@@ -582,6 +580,7 @@ class EnableEditingMaterialSetItem(bpy.types.Operator):
     def execute(self, context):
         self.file = IfcStore.get_file()
         obj = bpy.data.objects.get(self.obj) if self.obj else context.active_object
+        self.mprops = context.scene.BIMMaterialProperties
         self.props = obj.BIMObjectMaterialProperties
         self.props.active_material_set_item_id = self.material_set_item
         product_data = Data.products[obj.BIMObjectProperties.ifc_definition_id]
@@ -600,7 +599,8 @@ class EnableEditingMaterialSetItem(bpy.types.Operator):
 
         self.load_set_item_attributes(material_set_item, material_set_item_data)
         if material_set_item.is_a("IfcMaterialProfile"):
-            self.load_profile_attributes(material_set_item, material_set_item_data)
+            if material_set_item.Profile:
+                self.mprops.profiles = str(material_set_item.Profile.id())
 
         return {"FINISHED"}
 
@@ -613,6 +613,7 @@ class EnableEditingMaterialSetItem(bpy.types.Operator):
                 continue
             if attribute.name() in material_set_item_data:
                 new = self.props.material_set_item_attributes.add()
+                new.ifc_class = material_set_item.is_a()
                 new.name = attribute.name()
                 new.is_null = material_set_item_data[attribute.name()] is None
                 new.data_type = data_type
@@ -624,44 +625,8 @@ class EnableEditingMaterialSetItem(bpy.types.Operator):
                     new.int_value = 0 if new.is_null else material_set_item_data[attribute.name()]
                 elif data_type == "boolean":
                     new.bool_value = False if new.is_null else material_set_item_data[attribute.name()]
-
-    def load_profile_attributes(self, material_set_item, material_set_item_data):
-        self.props.material_set_item_profile_attributes.clear()
-
-        if not material_set_item_data["Profile"]:
-            return
-
-        profile = self.file.by_id(material_set_item_data["Profile"])
-        profile_data = ProfileData.profiles[material_set_item_data["Profile"]]
-
-        for attribute in IfcStore.get_schema().declaration_by_name(profile.is_a()).all_attributes():
-            data_type = ifcopenshell.util.attribute.get_primitive_type(attribute)
-            if data_type == "entity":
-                continue
-            if attribute.name() in profile_data:
-                new = self.props.material_set_item_profile_attributes.add()
-                new.name = attribute.name()
-                new.is_null = profile_data[attribute.name()] is None
-                new.is_optional = attribute.optional()
-                new.data_type = data_type
-                if data_type == "string":
-                    new.string_value = "" if new.is_null else profile_data[attribute.name()]
-                elif data_type == "float":
-                    new.float_value = 0.0 if new.is_null else profile_data[attribute.name()]
-                elif data_type == "integer":
-                    new.int_value = 0 if new.is_null else profile_data[attribute.name()]
-                elif data_type == "boolean":
-                    new.bool_value = False if new.is_null else profile_data[attribute.name()]
-                elif data_type == "enum":
-                    new.enum_items = json.dumps(ifcopenshell.util.attribute.get_enum_items(attribute))
-                    if profile_data[attribute.name()]:
-                        new.enum_value = profile_data[attribute.name()]
-
-                # Force null to be false if the attribute is mandatory because when we first assign a profile, all of
-                # its fields are null (which is illegal).
-                # TODO: find a better solution.
-                if not new.is_optional:
-                    new.is_null = False
+                blenderbim.bim.helper.add_attribute_description(new)
+                blenderbim.bim.helper.add_attribute_min_max(new)
 
 
 class DisableEditingMaterialSetItem(bpy.types.Operator):
@@ -691,6 +656,7 @@ class EditMaterialSetItem(bpy.types.Operator):
         obj = bpy.data.objects.get(self.obj) if self.obj else context.active_object
         self.file = IfcStore.get_file()
         props = obj.BIMObjectMaterialProperties
+        mprops = context.scene.BIMMaterialProperties
         product_data = Data.products[obj.BIMObjectProperties.ifc_definition_id]
 
         attributes = blenderbim.bim.helper.export_attributes(props.material_set_item_attributes)
@@ -718,19 +684,19 @@ class EditMaterialSetItem(bpy.types.Operator):
             )
             Data.load_layers()
         elif product_data["type"] == "IfcMaterialProfileSet" or product_data["type"] == "IfcMaterialProfileSetUsage":
-            profile_attributes = blenderbim.bim.helper.export_attributes(props.material_set_item_profile_attributes)
+            profile_def = None
+            if mprops.profiles:
+                profile_def = tool.Ifc.get().by_id(int(mprops.profiles))
+
             ifcopenshell.api.run(
                 "material.edit_profile",
                 self.file,
-                **{
-                    "profile": self.file.by_id(self.material_set_item),
-                    "attributes": attributes,
-                    "profile_attributes": profile_attributes,
-                    "material": self.file.by_id(int(obj.BIMObjectMaterialProperties.material_set_item_material)),
-                },
+                profile=self.file.by_id(self.material_set_item),
+                attributes=attributes,
+                profile_def=profile_def,
+                material=self.file.by_id(int(obj.BIMObjectMaterialProperties.material_set_item_material)),
             )
             Data.load_profiles()
-            ProfileData.load(self.file)
         else:
             pass
 
@@ -778,3 +744,31 @@ class CopyMaterial(bpy.types.Operator):
         if material.id() in object_material_ids:
             return
         obj.data.materials.append(IfcStore.get_element(material.id()))
+
+
+class ExpandMaterialCategory(bpy.types.Operator):
+    bl_idname = "bim.expand_material_category"
+    bl_label = "Expand Material Category"
+    bl_options = {"REGISTER", "UNDO"}
+    category: bpy.props.StringProperty()
+
+    def execute(self, context):
+        props = context.scene.BIMMaterialProperties
+        for category in [c for c in props.materials if c.is_category and c.name == self.category]:
+            category.is_expanded = True
+        core.load_materials(tool.Material, props.material_type)
+        return {"FINISHED"}
+
+
+class ContractMaterialCategory(bpy.types.Operator):
+    bl_idname = "bim.contract_material_category"
+    bl_label = "Contract Material Category"
+    bl_options = {"REGISTER", "UNDO"}
+    category: bpy.props.StringProperty()
+
+    def execute(self, context):
+        props = context.scene.BIMMaterialProperties
+        for category in [c for c in props.materials if c.is_category and c.name == self.category]:
+            category.is_expanded = False
+        core.load_materials(tool.Material, props.material_type)
+        return {"FINISHED"}

src/blenderbim/blenderbim/bim/module/material/prop.py

@@ -17,7 +17,9 @@
 # along with BlenderBIM Add-on.  If not, see <http://www.gnu.org/licenses/>.
 
 import bpy
+from ifcopenshell.util.doc import get_entity_doc
 from ifcopenshell.api.material.data import Data
+import blenderbim.tool as tool
 from blenderbim.bim.module.material.data import MaterialsData, ObjectMaterialData
 from blenderbim.bim.ifc import IfcStore
 from blenderbim.bim.prop import StrProperty, Attribute
@@ -47,28 +49,31 @@ def purge():
     parameterizedprofileclasses_enum = []
 
 
-def getProfileClasses(self, context):
+def get_profile_classes(self, context):
     global profileclasses_enum
     if len(profileclasses_enum) == 0 and IfcStore.get_schema():
+        version = tool.Ifc.get_schema()
         profileclasses_enum.clear()
         profileclasses_enum = [
-            (t.name(), t.name(), "") for t in IfcStore.get_schema().declaration_by_name("IfcProfileDef").subtypes()
+            (t.name(), t.name(), get_entity_doc(version, t.name()).get("description", ""))
+            for t in IfcStore.get_schema().declaration_by_name("IfcProfileDef").subtypes()
         ]
     return profileclasses_enum
 
 
-def getParameterizedProfileClasses(self, context):
+def get_parameterized_profile_classes(self, context):
     global parameterizedprofileclasses_enum
     if len(parameterizedprofileclasses_enum) == 0 and IfcStore.get_schema():
+        version = tool.Ifc.get_schema()
         parameterizedprofileclasses_enum.clear()
         parameterizedprofileclasses_enum = [
-            (t.name(), t.name(), "")
+            (t.name(), t.name(), get_entity_doc(version, t.name()).get("description", ""))
             for t in IfcStore.get_schema().declaration_by_name("IfcParameterizedProfileDef").subtypes()
         ]
         for ifc_class in parameterizedprofileclasses_enum:
             parameterizedprofileclasses_enum.extend(
                 [
-                    (t.name(), t.name(), "")
+                    (t.name(), t.name(), get_entity_doc(version, t.name()).get("description", ""))
                     for t in IfcStore.get_schema().declaration_by_name(ifc_class[0]).subtypes() or []
                 ]
             )
@@ -81,7 +86,7 @@ def get_materials(self, context):
     return ObjectMaterialData.data["materials"]
 
 
-def getMaterialTypes(self, context):
+def get_object_material_types(self, context):
     global materialtypes_enum
     if len(materialtypes_enum) == 0 and IfcStore.get_file():
         material_types = [
@@ -93,10 +98,11 @@ def getMaterialTypes(self, context):
             "IfcMaterialProfileSetUsage",
             "IfcMaterialList",
         ]
-        if IfcStore.get_file().schema == "IFC2X3":
+        version = tool.Ifc.get_schema()
+        if version == "IFC2X3":
             material_types = ["IfcMaterial", "IfcMaterialLayerSet", "IfcMaterialLayerSetUsage", "IfcMaterialList"]
         materialtypes_enum.clear()
-        materialtypes_enum = [(m, m, "") for m in material_types]
+        materialtypes_enum = [(m, m, get_entity_doc(version, m).get("description", "")) for m in material_types]
     return materialtypes_enum
 
 
@@ -106,9 +112,17 @@ def get_material_types(self, context):
     return MaterialsData.data["material_types"]
 
 
+def get_profiles(self, context):
+    if not MaterialsData.is_loaded:
+        MaterialsData.load()
+    return MaterialsData.data["profiles"]
+
+
 class Material(PropertyGroup):
     name: StringProperty(name="Name")
     ifc_definition_id: IntProperty(name="IFC Definition ID")
+    is_category: BoolProperty(name="Is Category", default=False)
+    is_expanded: BoolProperty(name="Is Expanded", default=True)
     total_elements: IntProperty(name="Total Elements")
 
 
@@ -117,21 +131,19 @@ class BIMMaterialProperties(PropertyGroup):
     material_type: EnumProperty(items=get_material_types, name="Material Type")
     materials: CollectionProperty(name="Materials", type=Material)
     active_material_index: IntProperty(name="Active Material Index")
+    profiles: EnumProperty(items=get_profiles, name="Profiles")
 
 
 class BIMObjectMaterialProperties(PropertyGroup):
-    material_type: EnumProperty(items=getMaterialTypes, name="Material Type")
+    material_type: EnumProperty(items=get_object_material_types, name="Material Type")
     material: EnumProperty(items=get_materials, name="Material")
     is_editing: BoolProperty(name="Is Editing", default=False)
     material_set_usage_attributes: CollectionProperty(name="Material Set Usage Attributes", type=Attribute)
     material_set_attributes: CollectionProperty(name="Material Set Attributes", type=Attribute)
     active_material_set_item_id: IntProperty(name="Active Material Set ID")
     material_set_item_attributes: CollectionProperty(name="Material Set Item Attributes", type=Attribute)
-    material_set_item_profile_attributes: CollectionProperty(
-        name="Material Set Item Profile Attributes", type=Attribute
-    )
     material_set_item_material: EnumProperty(items=get_materials, name="Material")
-    profile_classes: EnumProperty(items=getProfileClasses, name="Profile Classes")
+    profile_classes: EnumProperty(items=get_profile_classes, name="Profile Classes")
     parameterized_profile_classes: EnumProperty(
-        items=getParameterizedProfileClasses, name="Parameterized Profile Classes"
+        items=get_parameterized_profile_classes, name="Parameterized Profile Classes"
     )

src/blenderbim/blenderbim/bim/module/material/ui.py

@@ -19,9 +19,9 @@
 import blenderbim.bim.helper
 from bpy.types import Panel, UIList
 from ifcopenshell.api.material.data import Data
-from ifcopenshell.api.profile.data import Data as ProfileData
 from blenderbim.bim.ifc import IfcStore
 from blenderbim.bim.helper import draw_attributes
+from blenderbim.bim.helper import prop_with_search
 from blenderbim.bim.module.material.data import MaterialsData, ObjectMaterialData
 
 
@@ -50,7 +50,7 @@ class BIM_PT_materials(Panel):
             row.operator("bim.disable_editing_materials", text="", icon="CANCEL")
         else:
             row = self.layout.row(align=True)
-            row.prop(self.props, "material_type", text="")
+            prop_with_search(row, self.props, "material_type", text="")
             row.operator("bim.load_materials", text="", icon="IMPORT")
             return
 
@@ -61,16 +61,18 @@ class BIM_PT_materials(Panel):
             row.operator("bim.add_material", text="", icon="ADD")
             if self.props.materials and self.props.active_material_index < len(self.props.materials):
                 material = self.props.materials[self.props.active_material_index]
-                op = row.operator("bim.select_by_material", text="", icon="RESTRICT_SELECT_OFF")
-                op.material = material.ifc_definition_id
-                row.operator("bim.remove_material", text="", icon="X").material = material.ifc_definition_id
+                if material.ifc_definition_id:
+                    op = row.operator("bim.select_by_material", text="", icon="RESTRICT_SELECT_OFF")
+                    op.material = material.ifc_definition_id
+                    row.operator("bim.remove_material", text="", icon="X").material = material.ifc_definition_id
         else:
             row.operator("bim.add_material_set", text="", icon="ADD").set_type = self.props.material_type
             if self.props.materials and self.props.active_material_index < len(self.props.materials):
                 material = self.props.materials[self.props.active_material_index]
-                op = row.operator("bim.select_by_material", text="", icon="RESTRICT_SELECT_OFF")
-                op.material = material.ifc_definition_id
-                row.operator("bim.remove_material_set", text="", icon="X").material = material.ifc_definition_id
+                if material.ifc_definition_id:
+                    op = row.operator("bim.select_by_material", text="", icon="RESTRICT_SELECT_OFF")
+                    op.material = material.ifc_definition_id
+                    row.operator("bim.remove_material_set", text="", icon="X").material = material.ifc_definition_id
 
         self.layout.template_list("BIM_UL_materials", "", self.props, "materials", self.props, "active_material_index")
 
@@ -125,12 +127,11 @@ class BIM_PT_object_material(Panel):
         self.file = IfcStore.get_file()
         self.oprops = context.active_object.BIMObjectProperties
         self.props = context.active_object.BIMObjectMaterialProperties
+        self.mprops = context.scene.BIMMaterialProperties
         if not Data.is_loaded:
             Data.load(IfcStore.get_file())
         if self.oprops.ifc_definition_id not in Data.products:
             Data.load(IfcStore.get_file(), self.oprops.ifc_definition_id)
-        if not ProfileData.is_loaded:
-            ProfileData.load(self.file)
         self.product_data = Data.products[self.oprops.ifc_definition_id]
 
         if not ObjectMaterialData.data["materials"]:
@@ -139,6 +140,10 @@ class BIM_PT_object_material(Panel):
             row.operator("bim.add_material", icon="ADD", text="").obj = ""
             return
 
+        if ObjectMaterialData.data["type_material"]:
+            row = self.layout.row(align=True)
+            row.label(text="Inherited Material: " + ObjectMaterialData.data["type_material"], icon="FILE_PARENT")
+
         if self.product_data:
             if self.product_data["type"] == "IfcMaterialConstituentSet":
                 self.material_set_id = self.product_data["id"]
@@ -182,9 +187,9 @@ class BIM_PT_object_material(Panel):
             return self.draw_material_ui()
 
         row = self.layout.row(align=True)
-        row.prop(self.props, "material_type", text="")
+        prop_with_search(row, self.props, "material_type", text="")
         if self.props.material_type == "IfcMaterial" or self.props.material_type == "IfcMaterialList":
-            row.prop(self.props, "material", text="")
+            prop_with_search(row, self.props, "material", text="")
         row.operator("bim.assign_material", icon="ADD", text="")
 
     def draw_material_ui(self):
@@ -214,8 +219,7 @@ class BIM_PT_object_material(Panel):
         return self.draw_read_only_single_ui()
 
     def draw_editable_single_ui(self):
-        row = self.layout.row(align=True)
-        row.prop(self.props, "material", text="")
+        prop_with_search(self.layout, self.props, "material", text="")
 
     def draw_read_only_single_ui(self):
         material = Data.materials[self.product_data["id"]]
@@ -229,15 +233,13 @@ class BIM_PT_object_material(Panel):
         self.draw_read_only_set_ui()
 
     def draw_editable_set_ui(self):
+        blenderbim.bim.helper.draw_attributes(self.props.material_set_attributes, self.layout)
         blenderbim.bim.helper.draw_attributes(self.props.material_set_usage_attributes, self.layout)
 
-        for attribute in self.props.material_set_attributes:
-            row = self.layout.row(align=True)
-            row.prop(attribute, "string_value", text=attribute.name)
-            row.prop(attribute, "is_null", icon="RADIOBUT_OFF" if attribute.is_null else "RADIOBUT_ON", text="")
         row = self.layout.row(align=True)
-        row.prop(self.props, "material", text="")
-
+        if self.set_item_name == "profile":
+            row.prop(self.mprops, "profiles", icon="ITALIC", text="")
+        prop_with_search(row, self.props, "material", icon="MATERIAL", text="")
         op = row.operator(f"bim.add_{self.set_item_name}", icon="ADD", text="")
         setattr(op, f"{self.set_item_name}_set", self.material_set_id)
 
@@ -256,34 +258,18 @@ class BIM_PT_object_material(Panel):
 
         box = self.layout.box()
         row = box.row(align=True)
-        row.prop(self.props, "material_set_item_material", icon="MATERIAL")
-        op = row.operator("bim.edit_material_set_item", icon="CHECKMARK", text="")
+        op = row.operator("bim.edit_material_set_item", icon="CHECKMARK", text="Save Changes")
         op.material_set_item = set_item_id
         row.operator("bim.disable_editing_material_set_item", icon="CANCEL", text="")
 
-        draw_attributes(self.props.material_set_item_attributes, self.layout)
+        draw_attributes(self.props.material_set_item_attributes, box)
+
+        row = box.row()
+        row.prop(self.props, "material_set_item_material", icon="MATERIAL", text="Material")
 
         if self.set_item_name == "profile":
-            self.draw_assign_profile_ui(box, item)
-            self.draw_editable_profile_ui(box, item)
-
-    def draw_assign_profile_ui(self, layout, item):
-        row = layout.row(align=True)
-        row.prop(self.props, "profile_classes", text="")
-        if self.props.profile_classes == "IfcParameterizedProfileDef":
-            row.prop(self.props, "parameterized_profile_classes", text="")
-            op = row.operator(
-                "bim.assign_parameterized_profile", icon="GREASEPENCIL" if item["Profile"] else "ADD", text=""
-            )
-            op.ifc_class = self.props.parameterized_profile_classes
-            op.material_profile = item["id"]
-        else:
-            # TODO: support non parametric profiles by showing a list of named profiles to select from, or an
-            # eyedropper to pick profile geometry from the scene
-            row.operator("bim.disable_editing_material_set_item", icon="CANCEL", text="")
-
-    def draw_editable_profile_ui(self, layout, item):
-        draw_attributes(self.props.material_set_item_profile_attributes, self.layout)
+            row = box.row()
+            row.prop(self.mprops, "profiles", icon="ITALIC", text="Profile")
 
     def draw_read_only_set_item_ui(self, set_item_id, index, is_first=False, is_last=False):
         if self.product_data["type"] == "IfcMaterialList":
@@ -395,7 +381,21 @@ class BIM_UL_materials(UIList):
     def draw_item(self, context, layout, data, item, icon, active_data, active_propname):
         if item:
             row = layout.row(align=True)
-            row.label(text=item.name)
-            row2 = row.row()
-            row2.alignment = "RIGHT"
-            row2.label(text=str(item.total_elements))
+
+            if item.is_category:
+                if item.is_expanded:
+                    row.operator(
+                        "bim.contract_material_category", text="", emboss=False, icon="DISCLOSURE_TRI_DOWN"
+                    ).category = item.name
+                else:
+                    row.operator(
+                        "bim.expand_material_category", text="", emboss=False, icon="DISCLOSURE_TRI_RIGHT"
+                    ).category = item.name
+                row.label(text=item.name or "Uncategorised")
+            else:
+                row.label(text="", icon="BLANK1")
+                row.label(text=item.name, icon="MATERIAL")
+
+                row2 = row.row()
+                row2.alignment = "RIGHT"
+                row2.label(text=str(item.total_elements))