Add slicer to layer when container is new (#57)

* Remove OSL scripts to improve render

* Remove slice viewer

* Locator will be added next to selected node

* Improve specular in eevee

.github/workflows/release.yml

@@ -0,0 +1,64 @@
+name: Release Version
+
+on:
+  push:
+    tags:
+      - 'v*'
+
+jobs:
+  draft_release:
+    name: Draft Release
+    permissions:
+      contents: write
+      pull-requests: write
+    runs-on: ubuntu-latest
+    outputs:
+      upload_url: ${{ steps.draft_release.outputs.upload_url }}
+      version: ${{ steps.set_env.outputs.version }}
+    steps:
+      - name: Set Version Env
+        id: set_env
+        run: |
+          ref_name=${{ github.ref_name }}
+          echo "version=${ref_name#release/}" >> "$GITHUB_OUTPUT"
+      - name: Draft Release ${{ steps.set_env.outputs.version }}
+        uses: release-drafter/release-drafter@v5
+        id: draft_release
+        with:
+          name: ${{ steps.set_env.outputs.version }}
+          tag: ${{ steps.set_env.outputs.version }}
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+  build_extension:
+    name: Build Blender Extension
+    needs: draft_release
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        platform: ["windows-x64", "linux-x64", "macos-arm64", "macos-x64"]
+    steps:
+      - name: Checkout Code
+        uses: actions/checkout@v4
+        with:
+          lfs: "true"
+      - name: Set up Python
+        uses: actions/setup-python@v4
+        with:
+          python-version: 3.11
+      - name: Build Extension
+        run: | # build.py need tomlkit to edit blender_manifest.toml
+          pip install tomlkit
+          python build.py ${{ matrix.platform }}
+          cd src/bioxelnodes
+          zip -r ../../package.zip .
+      - name: Upload Extension
+        id: upload-release-asset
+        uses: actions/upload-release-asset@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          upload_url: ${{ needs.draft_release.outputs.upload_url }} # This pulls from the CREATE RELEASE step above, referencing it's ID to get its outputs object, which include a `upload_url`. See this blog post for more info: https://jasonet.co/posts/new-features-of-github-actions/#passing-data-to-future-steps
+          asset_path: ./package.zip
+          asset_name: BioxelNodes_${{ needs.draft_release.outputs.version }}_${{ matrix.platform }}.zip
+          asset_content_type: application/zip

.github/workflows/upload-assets.yml

@@ -1,106 +0,0 @@
-name: Upload Assets to Release
-
-on:
-  push:
-    branches:
-      - "release/*"
-
-jobs:
-  # draft_release:
-  #   name: Draft Release
-  #   runs-on: ubuntu-latest
-  #   outputs:
-  #     upload_url: ${{ steps.draft_release.outputs.upload_url }}
-  #     version: ${{ steps.set_env.outputs.version }}
-  #   steps:
-  #     - name: Set Version Env
-  #       id: set_env
-  #       run: |
-  #         ref_name=${{ github.ref_name }}
-  #         echo "version=${ref_name#release/}" >> "$GITHUB_OUTPUT"
-  #     - name: Get release
-  #       id: draft_release
-  #       uses: cardinalby/git-get-release-action@1.2.4
-  #       with:
-  #         releaseName: Upload
-  #       env:
-  #         GITHUB_TOKEN: ${{ github.token }}
-
-  draft_release:
-    name: Draft Release
-    permissions:
-      contents: write
-      pull-requests: write
-    runs-on: ubuntu-latest
-    outputs:
-      upload_url: ${{ steps.draft_release.outputs.upload_url }}
-      version: ${{ steps.set_env.outputs.version }}
-    steps:
-      - name: Set Version Env
-        id: set_env
-        run: |
-          ref_name=${{ github.ref_name }}
-          echo "version=${ref_name#release/}" >> "$GITHUB_OUTPUT"
-      - name: Draft Release ${{ steps.set_env.outputs.version }}
-        uses: release-drafter/release-drafter@v5
-        id: draft_release
-        with:
-          name: ${{ steps.set_env.outputs.version }}
-          tag: ${{ steps.set_env.outputs.version }}
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-
-  upload_blender_addon:
-    name: Upload Blender Add-on
-    needs: draft_release
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout Code
-        uses: actions/checkout@v4
-        with:
-          lfs: "true"
-      - name: Zip Add-on
-        run: |
-          zip -r package.zip bioxelnodes
-      - name: Upload Release Asset
-        id: upload-release-asset
-        uses: actions/upload-release-asset@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          upload_url: ${{ needs.draft_release.outputs.upload_url }} # This pulls from the CREATE RELEASE step above, referencing it's ID to get its outputs object, which include a `upload_url`. See this blog post for more info: https://jasonet.co/posts/new-features-of-github-actions/#passing-data-to-future-steps
-          asset_path: ./package.zip
-          asset_name: BioxelNodes_Addon_${{ needs.draft_release.outputs.version }}.zip
-          asset_content_type: application/zip
-
-  upload_blender_extension:
-    name: Upload Blender Extension
-    needs: draft_release
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout Code
-        uses: actions/checkout@v4
-        with:
-          lfs: "true"
-      - name: Set up Python
-        uses: actions/setup-python@v4
-        with:
-          python-version: 3.11
-      - name: Zip Extension
-        run: |
-          pip download SimpleITK==2.3.1 --dest bioxelnodes/wheels --only-binary=:all: --python-version=3.11 --platform=win_amd64
-          rm -r bioxelnodes/externalpackage
-          cp extension/__init__.py bioxelnodes/__init__.py
-          cp extension/preferences.py bioxelnodes/preferences.py
-          cp extension/blender_manifest.toml bioxelnodes/blender_manifest.toml
-          zip -r package.zip bioxelnodes
-      - name: Upload Release Asset
-        id: upload-release-asset
-        uses: actions/upload-release-asset@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          upload_url: ${{ needs.draft_release.outputs.upload_url }} # This pulls from the CREATE RELEASE step above, referencing it's ID to get its outputs object, which include a `upload_url`. See this blog post for more info: https://jasonet.co/posts/new-features-of-github-actions/#passing-data-to-future-steps
-          asset_path: ./package.zip
-          asset_name: BioxelNodes_Extension_${{ needs.draft_release.outputs.version }}.zip
-          asset_content_type: application/zip

.gitignore

@@ -133,4 +133,6 @@ blendcache_*
 
 .secrets
 
-!bioxelnodes/scipy/_nd_image.cp311-win_amd64.pyd
+.vdb
+
+!scipy_ndimage/*/**

.vscode/BioxelNodes.code-workspace

@@ -0,0 +1,11 @@
+{
+	"folders": [
+		{
+			"path": ".."
+		},
+		{
+			"path": "../src/bioxelnodes"
+		}
+	],
+	"settings": {}
+}

README.md

@@ -1,37 +1,43 @@
-[中文文档](https://uj6xfhbzp0.feishu.cn/wiki/Qx3VwHuNPimeI8kr6nDcvl1DnHf?from=from_copylink)
+[中文文档](https://uj6xfhbzp0.feishu.cn/wiki/LPKEwjooSivxjskWHlCcQznjnNf?from=from_copylink)
 
 # Bioxel Nodes
 
-![Static Badge](https://img.shields.io/badge/Blender-orange?style=for-the-badge&logo=blender&logoColor=white)
+[![For Blender](https://img.shields.io/badge/Blender-orange?style=for-the-badge&logo=blender&logoColor=white&color=black)](https://blender.org/)
-![GitHub License](https://img.shields.io/github/license/OmooLab/BioxelNodes?style=for-the-badge)
+![GitHub License](https://img.shields.io/github/license/OmooLab/BioxelNodes?style=for-the-badge&labelColor=black)
-![GitHub Release](https://img.shields.io/github/v/release/OmooLab/BioxelNodes?style=for-the-badge)
+![GitHub Release](https://img.shields.io/github/v/release/OmooLab/BioxelNodes?style=for-the-badge&labelColor=black)
-![GitHub Repo stars](https://img.shields.io/github/stars/OmooLab/BioxelNodes?style=for-the-badge)
+![GitHub Repo stars](https://img.shields.io/github/stars/OmooLab/BioxelNodes?style=for-the-badge&labelColor=black)
+
+[![Discord](https://img.shields.io/discord/1265129134397587457?style=for-the-badge&logo=discord&label=Discord&labelColor=white&color=black)](https://discord.gg/pYkNyq2TjE)
 
 Bioxel Nodes is a Blender addon for scientific volumetric data visualization. It using Blender's powerful **Geometry Nodes** and **Cycles** to process and render volumetric data.
 
 ![cover](https://omoolab.github.io/BioxelNodes/latest/assets/cover.png)
 
--   Fantastic rendering result, also support EEVEE NEXT
+-   Realistic rendering result, also support EEVEE NEXT.
--   Support multiple formats
+-   Support multiple formats.
--   Support 4D volumetric data
+-   Support 4D volumetric data.
--   All kinds of cutters
+-   All kinds of cutters.
--   Simple and powerful nodes
+-   Simple and powerful nodes.
 -   Based on blender natively, can work without addon.
 
-**Click [Getting Started](https://omoolab.github.io/BioxelNodes/latest/installation) to begin your journey into visualizing volumetric data!**
+**Read the [getting started](https://omoolab.github.io/BioxelNodes/latest/installation) to begin your journey into visualizing volumetric data!**
+
+Welcome to our [discord server](https://discord.gg/pYkNyq2TjE), if you have any problems with this add-on.
 
 ## Support Multiple Formats
 
-| Format | EXT                                      | Test    |
+| Format | EXT                                      |
-| ------ | ---------------------------------------- | ------- |
+| ------ | ---------------------------------------- |
-| DICOM  | .dcm, .DICOM                             | ✅ pass |
+| DICOM  | .dcm, .DCM, .DICOM, .ima, .IMA           |
-| BMP    | .bmp, .BMP                               | ✅ pass |
+| BMP    | .bmp, .BMP                               |
-| JPEG   | .jpg, .JPG, .jpeg, .JPEG                 | ✅ pass |
+| JPEG   | .jpg, .JPG, .jpeg, .JPEG                 |
-| PNG    | .png, .PNG                               | ✅ pass |
+| PNG    | .png, .PNG                               |
-| TIFF   | .tif, .TIF, .tiff, .TIFF                 | ✅ pass |
+| TIFF   | .tif, .TIF, .tiff, .TIFF                 |
-| Nifti  | .nia, .nii, .nii.gz, .hdr, .img, .img.gz | ✅ pass |
+| Nifti  | .nia, .nii, .nii.gz, .hdr, .img, .img.gz |
-| Nrrd   | .nrrd, .nhdr                             | ✅ pass |
+| Nrrd   | .nrrd, .nhdr                             |
-| HDF5   | .hdf, .h4, .hdf4, .he2, .h5, .hdf5, .he5 | ✅ pass |
+| HDF5   | .hdf, .h4, .hdf4, .he2, .h5, .hdf5, .he5 |
+| OME    | .ome.tiff, .ome.tif                      |
+| MRC    | .mrc, .mrc.gz, .map, .map.gz             |
 
 ## Support 4D volumetric data
 
@@ -53,16 +59,6 @@ Bioxel Nodes is a Blender addon for scientific volumetric data visualization. It
 -   Only works with Cycles CPU , Cycles GPU (OptiX), EEVEE
 -   Section surface cannot be generated when convert to mesh (will be supported soon)
 
-## Compatibile to Newer Version
-
-**Updating this addon may break old files, so read the following carefully before updating**
-
-Before updating this addon, you need to ask yourself whether this project file will be modified again or not, if it's an archived project file, I would recommend that you run **Bioxel Nodes > Save Staged Data** to make the addon nodes permanent. In this way, there will be no potential problem with the nodes not functioning due to the addon update.
-
-After the addon update, your old project files may not work either, this may be because you had executed **Save Staged Data**. If so, you need to execute **Bioxel Nodes > Relink Nodes to Addon** to relink them to make sure that the addon's new functionality and the addon nodes are synchronized.
-
-Also, unlike the newer versions, the older shaders are not based on OSL, so if you find that you can't render volumes, you need to turn on **Open Shading Language (OSL)** in the Render Settings.
-
 ## Roadmap
 
 -   Better multi-format import experience

bioxelnodes/__init__.py

@@ -1,28 +0,0 @@
-import bpy
-
-from . import auto_load
-from . import menus
-
-
-bl_info = {
-    "name": "Bioxel Nodes",
-    "author": "Ma Nan",
-    "description": "",
-    "blender": (4, 1, 0),
-    "version": (0, 2, 7),
-    "location": "File -> Import",
-    "warning": "",
-    "category": "Node"
-}
-
-auto_load.init()
-
-
-def register():
-    auto_load.register()
-    menus.add()
-
-
-def unregister():
-    menus.remove()
-    auto_load.unregister()

bioxelnodes/customnodes/__init__.py

@@ -1 +0,0 @@
-from .menus import CustomNodes

bioxelnodes/customnodes/menus.py

@@ -1,148 +0,0 @@
-import shutil
-import bpy
-from pathlib import Path
-from .nodes import AddCustomNode
-
-
-class CustomNodes():
-    def __init__(
-        self,
-        menu_items,
-        nodes_file,
-        class_prefix="CUSTOMNODES_MT_NODES",
-        root_label='CustomNodes',
-        root_icon='NONE'
-    ) -> None:
-        if not Path(nodes_file).is_file():
-            raise FileNotFoundError(str(Path(nodes_file).resolve()))
-
-        self.menu_items = menu_items
-        self.nodes_file = str(Path(nodes_file).resolve())
-        self.class_prefix = class_prefix
-        self.root_label = root_label
-        self.root_icon = root_icon
-        self.class_prefix = class_prefix
-
-        menu_classes = []
-        self._create_menu_class(
-            items=menu_items,
-            label=root_label,
-            menu_classes=menu_classes
-        )
-        self.menu_classes = menu_classes
-
-        idname = f"{class_prefix}_{root_label.replace(' ', '').upper()}"
-
-        def add_node_menu(self, context):
-            if ('GeometryNodeTree' == bpy.context.area.spaces[0].tree_type):
-                layout = self.layout
-                layout.separator()
-                layout.menu(idname, icon=root_icon)
-
-        self.add_node_menu = add_node_menu
-
-    def _create_menu_class(self, menu_classes, items, label='CustomNodes', icon=0, idname_namespace=None):
-        nodes_file = self.nodes_file
-        idname_namespace = idname_namespace or self.class_prefix
-        idname = f"{idname_namespace}_{label.replace(' ', '').upper()}"
-
-        # create submenu class if item is menu.
-        for item in items:
-            item_items = item.get('items') if item != 'separator' else None
-            if item_items:
-                menu_class = self._create_menu_class(
-                    menu_classes=menu_classes,
-                    items=item_items,
-                    label=item.get('label') or 'CustomNodes',
-                    icon=item.get('icon') or 0,
-                    idname_namespace=idname
-                )
-                item['menu_class'] = menu_class
-
-        # create menu class
-        class Menu(bpy.types.Menu):
-            bl_idname = idname
-            bl_label = label
-            nodes_file = self.nodes_file
-
-            def draw(self, context):
-                layout = self.layout
-
-                for item in items:
-                    # print(item)
-                    if item == "separator":
-                        layout.separator()
-                    elif item.get('menu_class'):
-                        layout.menu(
-                            item.get('menu_class').bl_idname,
-                            icon=item.get('icon') or 'NONE'
-                        )
-                    else:
-                        op = layout.operator(
-                            'customnodes.add_custom_node',
-                            text=item.get('label'),
-                            icon=item.get('icon') or 'NONE'
-                        )
-                        op.nodes_file = nodes_file
-                        op.node_type = item['node_type']
-                        op.node_label = item.get('label') or ""
-                        op.node_description = item.get(
-                            'node_description') or "Add Custom Node."
-                        op.node_link = item.get('link') or True
-                        op.node_callback = item.get('node_callback') or ""
-
-        menu_classes.append(Menu)
-        return Menu
-
-    def _find_item(self, found_items, menu_items, node_type: str):
-
-        for item in menu_items:
-            if item == 'separator':
-                continue
-
-            if item.get("node_type") == node_type:
-                found_items.append(item)
-
-            item_items = item.get('items')
-            if item_items:
-                self._find_item(found_items, item_items, node_type)
-
-    def find_item(self, node_type: str):
-        found_items = []
-        self._find_item(found_items, self.menu_items, node_type)
-        return found_items[0] if len(found_items) > 0 else None
-
-    def add_node(self, node_group, node_type: str):
-        item = self.find_item(node_type)
-        op = AddCustomNode()
-        op.nodes_file = self.nodes_file
-        op.node_type = node_type
-        if item:
-            op.node_label = item.get('label') or ""
-            op.node_link = item.get('link') or True
-            op.node_callback = item.get('node_callback') or ""
-        else:
-            op.node_label = ""
-            op.node_link = True
-            op.node_callback = ""
-        return op.add_node(node_group)
-
-    def register(self):
-        for cls in self.menu_classes:
-            bpy.utils.register_class(cls)
-
-        bpy.types.NODE_MT_add.append(self.add_node_menu)
-        bpy.types.Scene.customnodes_node_dir = bpy.props.StringProperty(
-            name="Node Directory",
-            subtype='DIR_PATH',
-            default="//"
-        )
-
-    def unregister(self):
-        bpy.types.NODE_MT_add.remove(self.add_node_menu)
-        try:
-            for cls in reversed(self.menu_classes):
-                bpy.utils.unregister_class(cls)
-
-        except RuntimeError:
-            pass

bioxelnodes/customnodes/nodes.py

@@ -1,125 +0,0 @@
-import bpy
-
-
-class AddCustomNode():
-
-    nodes_file: bpy.props.StringProperty(
-        name="nodes_file",
-        subtype='FILE_PATH',
-        default=""
-    )  # type: ignore
-
-    node_type: bpy.props.StringProperty(
-        name='node_type',
-        description='',
-        default='',
-        subtype='NONE',
-        maxlen=0
-    )  # type: ignore
-
-    node_label: bpy.props.StringProperty(
-        name='node_label',
-        default=''
-    )  # type: ignore
-
-    node_description: bpy.props.StringProperty(
-        name="node_description",
-        description="",
-        default="Add custom node group.",
-        subtype="NONE"
-    )  # type: ignore
-
-    node_link: bpy.props.BoolProperty(
-        name='node_link',
-        default=True
-    )  # type: ignore
-
-    node_callback: bpy.props.StringProperty(
-        name='node_callback',
-        default=''
-    )  # type: ignore
-
-    @classmethod
-    def description(cls, context, properties):
-        return properties.node_description
-
-    def assign_node_tree(self, node):
-        node.node_tree = bpy.data.node_groups[self.node_type]
-
-        node.width = 200.0
-        node.label = self.node_label or self.node_type
-        node.name = self.node_type
-
-        if self.node_callback:
-            exec(self.node_callback)
-
-        return node
-
-    def get_node_tree(self, node_type, node_link):
-        # try to get node from current file if exists
-        node_tree = bpy.data.node_groups.get(node_type)
-        # if not exists, get it from asset file.
-        if not node_tree:
-            bpy.ops.wm.append(
-                'EXEC_DEFAULT',
-                directory=f"{self.nodes_file}/NodeTree",
-                filename=node_type,
-                link=node_link,
-                use_recursive=True
-            )
-
-        node_tree = bpy.data.node_groups.get(node_type)
-        if node_tree:
-            # self.recursive_append_material(node_tree)
-            return node_tree
-        else:
-            raise RuntimeError('No custom node found')
-
-    def recursive_append_material(self, node_tree):
-        for child in node_tree.nodes:
-            material_socket = child.inputs.get('Material')
-            if material_socket:
-                print(material_socket.default_value)
-            try:
-                self.recursive_append_material(child.node_tree)
-            except:
-                ...
-
-    def add_node(self, node_group):
-        # Deselect all nodes first
-        for node in node_group.nodes:
-            if node.select:
-                node.select = False
-
-        self.get_node_tree(self.node_type, self.node_link)
-        node = node_group.nodes.new("GeometryNodeGroup")
-        self.assign_node_tree(node)
-
-        return node
-
-
-class CUSTOMNODES_OT_Add_Custom_Node(bpy.types.Operator, AddCustomNode):
-    bl_idname = "customnodes.add_custom_node"
-    bl_label = "Add Custom Node"
-    bl_options = {"REGISTER", "UNDO"}
-
-    def execute(self, context):
-        self.get_node_tree(self.node_type, self.node_link)
-
-        # intended to be called upon button press in the node tree
-        prev_context = bpy.context.area.type
-        bpy.context.area.type = 'NODE_EDITOR'
-        # actually invoke the operator to add a node to the current node tree
-        # use_transform=True ensures it appears where the user's mouse is and is currently
-        # being moved so the user can place it where they wish
-        bpy.ops.node.add_node(
-            'INVOKE_DEFAULT',
-            type='GeometryNodeGroup',
-            use_transform=True
-        )
-        bpy.context.area.type = prev_context
-        node = bpy.context.active_node
-
-        self.assign_node_tree(node)
-
-        return {"FINISHED"}

bioxelnodes/externalpackage/__init__.py

@@ -1,2 +0,0 @@
-from .preferences import ExternalPackagePreferences
-from .package import PackageInstaller

bioxelnodes/externalpackage/package.py

@@ -1,393 +0,0 @@
-"""
-Handling installation of external python packages inside of Blender's bundled python.
-"""
-import subprocess
-import sys
-import logging
-from importlib.metadata import version as get_version, PackageNotFoundError
-import bpy
-from pathlib import Path
-
-ADDON_NAME = __package__.split(".")[0]
-
-PYPI_MIRROR = {
-    # the original.
-    'Default': '',
-    # two mirrors in China Mainland to help those poor victims under GFW.
-    'BFSU (Beijing)': 'https://mirrors.bfsu.edu.cn/pypi/web/simple',
-    'TUNA (Beijing)': 'https://pypi.tuna.tsinghua.edu.cn/simple',
-    # append more if necessary.
-}
-
-
-class InstallationError(Exception):
-    """
-    Exception raised when there is an error installing a package.
-
-    Attributes
-    ----------
-    package_name : str
-        The name of the package that failed to install.
-    error_message : str
-        The error message returned by pip.
-
-    """
-
-    def __init__(self, package_name, error_message):
-        self.package_name = package_name
-        self.error_message = error_message
-        super().__init__(f"Failed to install {package_name}: {error_message}")
-
-
-class PackageInstaller():
-    def __init__(
-        self,
-        requirements_dir: str,
-        log_dir: str = None,
-        pypi_mirror_provider='Default',
-    ) -> None:
-        self.pypi_mirror_provider = pypi_mirror_provider
-        self.log_path: Path = Path(log_dir) if log_dir \
-            else Path.home() / '.externalpackage' / 'logs'
-        self.requirements_path: Path = Path(requirements_dir)
-
-    def start_logging(self, logfile_name: str = 'side-packages-install') -> logging.Logger:
-        """
-        Configure and start logging to a file.
-
-        Parameters
-        ----------
-        logfile_name : str, optional
-            The name of the log file. Defaults to 'side-packages-install'.
-
-        Returns
-        -------
-        logging.Logger
-            A Logger object that can be used to write log messages.
-
-        This function sets up a logging configuration with a specified log file name and logging level.
-        The log file will be created in the `ADDON_DIR/logs` directory. If the directory
-        does not exist, it will be created. The function returns a Logger object that can be used to
-        write log messages.
-
-        """
-        # Create the logs directory if it doesn't exist
-        self.log_path.mkdir(parents=True, exist_ok=True)
-
-        # Set up logging configuration
-        logfile_path = Path(self.log_path, f"{logfile_name}.log")
-        logging.basicConfig(filename=logfile_path,
-                            level=logging.INFO, encoding='utf-8')
-
-        # Return logger object
-        return logging.getLogger()
-
-    @property
-    def pypi_mirror_url(self) -> str:
-        """
-        Process a PyPI mirror provider and return the corresponding URL.
-
-        Parameters
-        ----------
-        pypi_mirror_provider : str
-            The PyPI mirror provider to process.
-
-        Returns
-        -------
-        str
-            The URL of the PyPI mirror.
-
-        Raises
-        ------
-        ValueError
-            If the provided PyPI mirror provider is invalid.
-
-        """
-        if self.pypi_mirror_provider.startswith('https:'):
-            return self.pypi_mirror_provider
-        elif self.pypi_mirror_provider in PYPI_MIRROR.keys():
-            return PYPI_MIRROR[self.pypi_mirror_provider]
-        else:
-            raise ValueError(
-                f"Invalid PyPI mirror provider: {self.pypi_mirror_provider}")
-
-    @property
-    def packages(self) -> dict:
-        """
-        Read a requirements file and extract package information into a dictionary.
-
-        Parameters
-        ----------
-        requirements : str, optional
-            The path to the requirements file. If not provided, the function looks for a `requirements.txt`
-            file in the same directory as the script.
-
-        Returns
-        -------
-        dict
-            A dictionary containing package information. Each element of the dictionary is a dictionary containing the package name, version, and description.
-
-        Example
-        -------
-        Given the following requirements file:
-        ```python
-        Flask==1.1.2 # A micro web framework for Python
-        pandas==1.2.3 # A fast, powerful, flexible, and easy-to-use data analysis and manipulation tool
-        numpy==1.20.1 # Fundamental package for scientific computing
-        ```
-        The function would return the following dictionary:
-        ```python
-        [
-            {
-                "package": "Flask",
-                "version": "1.1.2",
-                "description": "A micro web framework for Python"
-            },
-            {
-                "package": "pandas",
-                "version": "1.2.3",
-                "description": "A fast, powerful, flexible, and easy-to-use data analysis and manipulation tool"
-            },
-            {
-                "package": "numpy",
-                "version": "1.20.1",
-                "description": "Fundamental package for scientific computing"
-            }
-        ]
-        ```
-        """
-        requirements_filepath = self.requirements_path / "requirements.txt"
-        if requirements_filepath.is_file():
-            with requirements_filepath.open('r') as f:
-                lines = f.read().splitlines()
-                packages = {}
-                for line in lines:
-                    try:
-                        package, description = line.split('#')
-                        package_meta = package.split('==')
-                        name = package_meta[0].strip()
-                        packages[name] = {
-                            "name": name,
-                            "version": package_meta[1].strip(),
-                            "description": description.strip()
-                        }
-                    except ValueError:
-                        # Skip line if it doesn't have the expected format
-                        pass
-            return packages
-        else:
-            raise FileNotFoundError(requirements_filepath)
-
-    def is_installed(self, package_name: str) -> bool:
-        """
-        Check if the specified package is installed and the version matches that specified
-        in the `requirements.txt` file.
-
-        Parameters
-        ----------
-        package : str
-            The name of the package to check.
-
-        Returns
-        -------
-        bool
-            True if the package is the current version, False otherwise.
-
-        """
-        package = self.packages.get(package_name)
-        try:
-            available_version = get_version(package['name'])
-            return available_version == package['version']
-        except PackageNotFoundError:
-            return False
-
-    def run_python(self, cmd_list: list = None, timeout: int = 600):
-        """
-        Runs pip command using the specified command list and returns the command output.
-
-        Parameters
-        ----------
-        cmd_list : list, optional
-            List of pip commands to be executed. Defaults to None.
-        mirror_url : str, optional
-            URL of a package repository mirror to be used for the command. Defaults to ''.
-        timeout : int, optional
-            Time in seconds to wait for the command to complete. Defaults to 600.
-
-        Returns
-        -------
-        tuple
-            A tuple containing the command list, command return code, command standard output,
-            and command standard error.
-
-        Example
-        -------
-        Install numpy using pip and print the command output
-        ```python
-        cmd_list = ["-m", "pip", "install", "numpy"]
-        mirror_url = 'https://pypi.org/simple/'
-        cmd_output = run_python(cmd_list, timeout=300)
-        print(cmd_output)
-        ```
-
-        """
-
-        # path to python.exe
-        python_exe = str(Path(sys.executable).resolve())
-
-        # build the command list
-        cmd_list = [python_exe] + cmd_list
-
-        # add mirror to the command list if it's valid
-        if self.pypi_mirror_url and self.pypi_mirror_url.startswith('https'):
-            cmd_list += ['-i', self.pypi_mirror_url]
-
-        log = self.start_logging()
-        log.info(f"Running Pip: '{cmd_list}'")
-
-        # run the command and capture the output
-        result = subprocess.run(cmd_list, timeout=timeout,
-                                stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-
-        try:
-            if result.returncode != 0:
-                log.error('Command failed: %s', cmd_list)
-                log.error('stdout: %s', result.stdout.decode())
-                log.error('stderr: %s', result.stderr.decode(errors='ignore'))
-            else:
-                log.info('Command succeeded: %s', cmd_list)
-                log.info('stdout: %s', result.stdout.decode())
-        except:
-            ...
-        # return the command list, return code, stdout, and stderr as a tuple
-        return result
-
-    def install_package(self, package: str) -> list:
-        """
-        Install a Python package and its dependencies using pip.
-
-        Parameters
-        ----------
-        package : str
-            The name of the package to install.
-        pypi_mirror_provider : str, optional
-            The name/url of the PyPI mirror provider to use. Default is 'Default'.
-
-        Returns
-        -------
-        list
-            A list of tuples containing the command list, return code, stdout, and stderr
-            for each pip command run.
-
-        Raises
-        ------
-        ValueError
-            If the package name is not provided.
-
-        Example
-        -------
-        To install the package 'requests' from the PyPI mirror 'MyMirror', use:
-        ```
-        install_package('requests', 'MyMirror')
-        ```
-
-        """
-        if not package:
-            raise ValueError("Package name must be provided.")
-
-        print(f"Installing {package}...")
-        print(f"Using PyPI mirror: {self.pypi_mirror_provider}")
-
-        self.run_python(["-m", "ensurepip"]),
-        self.run_python(["-m", "pip", "install", "--upgrade", "pip"])
-        result = self.run_python(["-m", "pip", "install", package, "--user"])
-
-        return result
-
-    def install_all_packages(self, pypi_mirror_provider: str = 'Default') -> list:
-        """
-        Install all packages listed in the 'requirements.txt' file.
-
-        Parameters
-        ----------
-        pypi_mirror_provider : str, optional
-            The PyPI mirror to use for package installation. Defaults to 'Default',
-            which uses the official PyPI repository.
-
-        Returns
-        -------
-        list
-            A list of tuples containing the installation results for each package.
-
-        Raises
-        ------
-        InstallationError
-            If there is an error during package installation.
-
-        Example
-        -------
-        To install all packages listed in the 'requirements.txt' file, run the following command:
-        ```
-        install_all_packages(pypi_mirror_provider='https://pypi.org/simple/')
-        ```
-
-        """
-        results = []
-        for package in self.packages.items():
-
-            try:
-                result = self.install_package(
-                    package=f"{package.get('name')}=={package.get('version')}"
-                )
-                results.append(result)
-            except InstallationError as e:
-                raise InstallationError(
-                    f"Error installing package {package.get('name')}: {str(e)}")
-        return results
-
-
-class EXTERNALPACKAGE_OT_Install_Package(bpy.types.Operator):
-    bl_idname = 'externalpackage.install_package'
-    bl_label = 'Install Given Python Package'
-    bl_options = {'REGISTER', 'INTERNAL'}
-
-    package: bpy.props.StringProperty(
-        name='Python Package',
-        description='Python Package to Install'
-    )  # type: ignore
-
-    version: bpy.props.StringProperty(
-        name='Python Package',
-        description='Python Package to Install'
-    )  # type: ignore
-
-    description: bpy.props.StringProperty(
-        name='Operator description',
-        default='Install specified python package.'
-    )  # type: ignore
-
-    @classmethod
-    def description(cls, context, properties):
-        return properties.description
-
-    def execute(self, context):
-        preferences = context.preferences.addons[ADDON_NAME].preferences
-        installer = PackageInstaller(
-            pypi_mirror_provider=preferences.pypi_mirror_provider,
-            log_dir=preferences.log_dir,
-            requirements_dir=preferences.requirements_dir
-        )
-
-        result = installer.install_package(f"{self.package}=={self.version}")
-        if result.returncode == 0 or installer.is_installed(self.package):
-            self.report(
-                {'INFO'},
-                f"Successfully installed {self.package} v{self.version}"
-            )
-        else:
-            self.report(
-                {'ERROR'},
-                f"""Error installing package. Please check the log files
-in {preferences.log_dir}."""
-            )
-        return {'FINISHED'}

bioxelnodes/externalpackage/preferences.py

@@ -1,95 +0,0 @@
-import bpy
-import subprocess
-from pathlib import Path
-from .package import PackageInstaller, PYPI_MIRROR
-
-# Defines the preferences panel for the addon, which shows the buttons for
-# installing and reinstalling the required python packages defined in 'requirements.txt'
-
-
-def get_pypi_mirrors(self, context, edit_text):
-    return PYPI_MIRROR.keys()
-
-
-class RebootBlender(bpy.types.Operator):
-    bl_idname = "externalpackage.reboot_blender"
-    bl_label = "Reboot Blender"
-    bl_description = "Reboot Blender"
-    bl_options = {'UNDO'}
-
-    def invoke(self, context, event):
-        context.window_manager.invoke_confirm(self, event)
-        return {'RUNNING_MODAL'}
-    
-    def execute(self, context):
-        blender_launcher = Path(
-            bpy.app.binary_path).parent / "blender-launcher.exe"
-        subprocess.run([str(blender_launcher), "-con", "--python-expr",
-                       "import bpy; bpy.ops.wm.recover_last_session()"])
-        bpy.ops.wm.quit_blender()
-        return {'FINISHED'}
-
-
-class ExternalPackagePreferences():
-    requirements_dir: bpy.props.StringProperty(
-        name="requirements.txt Directory",
-        subtype='DIR_PATH',
-        default=str(Path(__file__).parent)
-    )  # type: ignore
-
-    log_dir: bpy.props.StringProperty(
-        name="Python Log Directory",
-        subtype='DIR_PATH',
-        default=str(Path(Path.home(), '.externalpackage', 'logs'))
-    )  # type: ignore
-
-    pypi_mirror_provider: bpy.props.StringProperty(
-        name='pypi_mirror_provider',
-        description='PyPI Mirror Provider',
-        options={'TEXTEDIT_UPDATE', 'LIBRARY_EDITABLE'},
-        default='Default',
-        subtype='NONE',
-        search=get_pypi_mirrors,
-    )  # type: ignore
-
-    def draw(self, context):
-        layout = self.layout
-        layout.label(
-            text='**Install the required packages, then hit "Reboot Blender"**')
-
-        col_main = layout.column(heading='', align=False)
-        row_import = col_main.row()
-        row_import.prop(self, 'pypi_mirror_provider', text='PyPI Mirror')
-
-        installer = PackageInstaller(
-            pypi_mirror_provider=self.pypi_mirror_provider,
-            log_dir=self.log_dir,
-            requirements_dir=self.requirements_dir
-        )
-
-        for package in installer.packages.values():
-
-            name = package.get('name')
-            version = package.get('version')
-            description = package.get('description')
-
-            if installer.is_installed(name):
-                row = layout.row()
-                row.label(text=f"{name} version {version} is installed.")
-                op = row.operator('externalpackage.install_package',
-                                  text=f'Reinstall {name}')
-                op.package = name
-                op.version = version
-                op.description = f'Reinstall {name}'
-            else:
-                row = layout.row(heading=f"Package: {name}")
-                col = row.column()
-                col.label(text=str(description))
-                col = row.column()
-                op = col.operator('externalpackage.install_package',
-                                  text=f'Install {name}')
-                op.package = name
-                op.version = version
-                op.description = f'Install required python package: {name}'
-
-        layout.operator(RebootBlender.bl_idname)

bioxelnodes/io.py

@@ -1,874 +0,0 @@
-import math
-import bpy
-import shutil
-from bpy_extras.io_utils import axis_conversion
-import pyopenvdb as vdb
-import numpy as np
-from pathlib import Path
-from uuid import uuid4
-import mathutils
-import random
-
-from . import skimage as ski
-from .nodes import custom_nodes
-from .props import BIOXELNODES_Series
-from .utils import (calc_bbox_verts, get_all_layers, get_container_from_selection, get_layer, get_text_index_str,
-                    get_nodes_by_type, hide_in_ray, lock_transform, move_node_between_nodes, move_node_to_node, save_vdb, save_vdbs, select_object, show_message)
-
-try:
-    import SimpleITK as sitk
-except:
-    ...
-
-SUPPORT_EXTS = ['', '.dcm', '.DCM', '.DICOM',
-                '.bmp', '.BMP',
-                '.PIC', '.pic',
-                '.gipl', '.gipl.gz',
-                '.jpg', '.JPG', '.jpeg', '.JPEG',
-                '.lsm', '.LSM',
-                '.tif', '.TIF', '.tiff', '.TIFF',
-                '.mnc', '.MNC',
-                '.mrc', '.rec',
-                '.mha', '.mhd',
-                '.hdf', '.h4', '.hdf4', '.he2', '.h5', '.hdf5', '.he5',
-                '.nia', '.nii', '.nii.gz', '.hdr', '.img', '.img.gz',
-                '.nrrd', '.nhdr',
-                '.png', '.PNG',
-                '.vtk']
-
-SEQUENCE_EXTS = ['.dcm', '.DCM', '.DICOM',
-                 '.bmp', '.BMP',
-                 '.jpg', '.JPG', '.jpeg', '.JPEG',
-                 '.tif', '.TIF', '.tiff', '.TIFF',
-                 '.png', '.PNG']
-
-DICOM_EXTS = ['', '.dcm', '.DCM', '.DICOM']
-
-FH_EXTS = ['', '.dcm', '.DCM', '.DICOM',
-           '.gipl', '.gipl.gz',
-           '.mnc', '.MNC',
-           '.mrc', '.rec',
-           '.mha', '.mhd',
-           '.nia', '.nii', '.nii.gz', '.hdr', '.img', '.img.gz',
-           '.hdf', '.h4', '.hdf4', '.he2', '.h5', '.hdf5', '.he5',
-           '.nrrd', '.nhdr',
-           '.vtk',
-           '.gz']
-
-
-def get_layer_shape(bioxel_size: float, orig_shape: tuple, orig_spacing: tuple):
-    shape = (int(orig_shape[0] / bioxel_size * orig_spacing[0]),
-             int(orig_shape[1] / bioxel_size * orig_spacing[1]),
-             int(orig_shape[2] / bioxel_size * orig_spacing[2]))
-
-    return (shape[0] if shape[0] > 0 else 1,
-            shape[1] if shape[1] > 0 else 1,
-            shape[2] if shape[2] > 0 else 1)
-
-
-def get_layer_size(shape: tuple, bioxel_size: float, scale: float = 1.0):
-    size = (float(shape[0] * bioxel_size * scale),
-            float(shape[1] * bioxel_size * scale),
-            float(shape[2] * bioxel_size * scale))
-
-    return size
-
-
-def get_ext(filepath: str) -> str:
-    file_path = Path(filepath)
-    if file_path.name.endswith(".nii.gz"):
-        return ".nii.gz"
-    elif file_path.name.endswith(".img.gz"):
-        return ".img.gz"
-    elif file_path.name.endswith(".gipl.gz"):
-        return ".gipl.gz"
-    else:
-        return file_path.suffix
-
-
-def get_sequence_name(filepath: str) -> str:
-    ext = get_ext(filepath)
-    filename = Path(filepath).name.removesuffix(ext)
-    index: str = get_text_index_str(filename)
-    return filename.removesuffix(index)
-
-
-def get_sequence_index(filepath: str) -> int:
-    ext = get_ext(filepath)
-    filename = Path(filepath).name.removesuffix(ext)
-    index: str = get_text_index_str(filename)
-    return int(index) if index else 0
-
-
-def collect_sequence(filepath: str):
-    file_path = Path(filepath).resolve()
-
-    files = list(file_path.parent.iterdir())
-    files = [f for f in files if f.is_file()
-             and get_ext(file_path) == get_ext(f)
-             and get_sequence_name(file_path) == get_sequence_name(f)]
-
-    files.sort(key=get_sequence_index)
-    sequence = [str(f) for f in files]
-    return sequence
-
-
-def parse_volume_data(filepath: str, series_id=""):
-    ext = get_ext(filepath)
-
-    if ext in DICOM_EXTS:
-        dir_path = Path(filepath).resolve().parent
-        reader = sitk.ImageSeriesReader()
-        reader.MetaDataDictionaryArrayUpdateOn()
-        reader.LoadPrivateTagsOn()
-        series_files = reader.GetGDCMSeriesFileNames(
-            str(dir_path), series_id)
-        reader.SetFileNames(series_files)
-
-        itk_volume = reader.Execute()
-        # for k in reader.GetMetaDataKeys(0):
-        #     v = reader.GetMetaData(0, k)
-        #     print(f'({k}) = = "{v}"')
-        name = dir_path.name
-
-    elif ext in SEQUENCE_EXTS:
-        itk_volume = sitk.ReadImage(filepath)
-        if itk_volume.GetDimension() == 2:
-            sequence = collect_sequence(filepath)
-            itk_volume = sitk.ReadImage(sequence)
-            name = get_sequence_name(filepath)
-        else:
-            itk_volume = sitk.ReadImage(filepath)
-            name = Path(filepath).name.removesuffix(ext)
-    else:
-        itk_volume = sitk.ReadImage(filepath)
-        name = Path(filepath).name.removesuffix(ext)
-
-    # for key in itk_volume.GetMetaDataKeys():
-    #     print(f"{key},{itk_volume.GetMetaData(key)}")
-
-    if itk_volume.GetDimension() == 3:
-        itk_volume = sitk.DICOMOrient(itk_volume, 'RAS')
-
-        meta = {
-            "name": name,
-            "shape": tuple(itk_volume.GetSize()),
-            "spacing": tuple(itk_volume.GetSpacing()),
-            "origin": tuple(itk_volume.GetOrigin()),
-            "direction": tuple(itk_volume.GetDirection()),
-            "is_oriented": True
-        }
-
-        volume = sitk.GetArrayFromImage(itk_volume)
-
-        # transpose ijk to kji
-        if volume.ndim == 4:
-            volume = np.transpose(volume, (2, 1, 0, 3))
-        else:
-            volume = np.transpose(volume)
-            volume = np.expand_dims(volume, axis=-1)
-
-    else:
-        # FIXME: not sure...
-        print(itk_volume.GetDirection())
-        direction = np.array(itk_volume.GetDirection())
-        direction = direction.reshape(3, 3) if itk_volume.GetDimension() == 3 \
-            else direction.reshape(4, 4)
-
-        direction = direction[1:, 1:]
-        direction = tuple(direction.flatten())
-
-        meta = {
-            "name": name,
-            "shape": tuple(itk_volume.GetSize()[:3]),
-            "spacing": tuple(itk_volume.GetSpacing()[:3]),
-            "origin": tuple(itk_volume.GetOrigin()[:3]),
-            "direction": direction,
-            "is_oriented": False
-        }
-
-        volume = sitk.GetArrayFromImage(itk_volume)
-
-        if volume.ndim == 5:
-            volume = np.transpose(volume, (0, 3, 2, 1, 4))
-        else:
-            volume = np.transpose(volume, (0, 3, 2, 1))
-            volume = np.expand_dims(volume, axis=-1)
-
-    return volume, meta
-
-
-class ImportVolumeDataDialog(bpy.types.Operator):
-    bl_idname = "bioxelnodes.import_volume_data_dialog"
-    bl_label = "Volumetric Data as Bioxel Layer"
-    bl_description = "Import Volumetric Data as Bioxel Layer"
-    bl_options = {'UNDO'}
-
-    filepath: bpy.props.StringProperty(
-        subtype="FILE_PATH"
-    )  # type: ignore
-
-    container_name: bpy.props.StringProperty(
-        name="Container Name"
-    )   # type: ignore
-
-    layer_name: bpy.props.StringProperty(
-        name="Layer Name",
-    )   # type: ignore
-
-    series_id: bpy.props.StringProperty()   # type: ignore
-
-    container: bpy.props.StringProperty()   # type: ignore
-
-    read_as: bpy.props.EnumProperty(
-        name="Read as",
-        default="scalar",
-        items=[("scalar", "Scalar", ""),
-               ("label", "Labels", "")]
-    )  # type: ignore
-
-    bioxel_size: bpy.props.FloatProperty(
-        name="Bioxel Size (Larger size means small resolution)",
-        soft_min=0.1, soft_max=10.0,
-        min=0.1, max=1e2,
-        default=1,
-    )  # type: ignore
-
-    orig_spacing: bpy.props.FloatVectorProperty(
-        name="Original Spacing",
-        default=(1, 1, 1),
-    )  # type: ignore
-
-    orig_shape: bpy.props.IntVectorProperty(
-        name="Original Shape",
-        default=(100, 100, 100)
-    )  # type: ignore
-
-    scene_scale: bpy.props.FloatProperty(
-        name="Scene Scale (Bioxel Unit pre Blender Unit)",
-        soft_min=0.0001, soft_max=10.0,
-        min=1e-6, max=1e6,
-        default=0.01,
-    )  # type: ignore
-
-    is_time_sequence: bpy.props.BoolProperty(
-        name="Is Time Sequence",
-        default=False,
-    )  # type: ignore
-
-    split_channels: bpy.props.BoolProperty(
-        name="Split Channels",
-        default=False,
-    )  # type: ignore
-
-    def execute(self, context):
-        is_first_import = len(get_all_layers()) == 0
-        volume, meta = parse_volume_data(self.filepath)
-        container_name = self.container_name or meta['name'] or "Container"
-        bioxel_size = self.bioxel_size
-        orig_spacing = self.orig_spacing
-
-        layer_spacing = (
-            meta['spacing'][0] / orig_spacing[0] * bioxel_size,
-            meta['spacing'][1] / orig_spacing[1] * bioxel_size,
-            meta['spacing'][2] / orig_spacing[2] * bioxel_size
-        )
-
-        dtype_index = volume.dtype.num
-
-        layer_shape = get_layer_shape(
-            bioxel_size, meta['shape'], orig_spacing)
-
-        # After sitk.DICOMOrient(), origin and direction will also orient base on LPS
-        # so we need to convert them into RAS
-        mat_lps2ras = axis_conversion(
-            from_forward='-Z',
-            from_up='-Y',
-            to_forward='-Z',
-            to_up='Y'
-        ).to_4x4()
-
-        mat_location = mathutils.Matrix.Translation(
-            mathutils.Vector(meta['origin'])
-        )
-
-        mat_rotation = mathutils.Matrix(
-            np.array(meta['direction']).reshape((3, 3))
-        ).to_4x4()
-
-        mat_scale = mathutils.Matrix.Scale(
-            bioxel_size, 4
-        )
-
-        transfrom = mat_lps2ras @ mat_location @ mat_rotation @ mat_scale \
-            if meta['is_oriented'] else mat_location @ mat_rotation @ mat_scale
-
-        # Wrapper a Container
-        if not self.container:
-            # Make transformation
-            scene_scale = float(self.scene_scale)
-
-            # (S)uperior  -Z -> Y
-            # (A)osterior  Y -> Z
-            mat_ras2blender = axis_conversion(
-                from_forward='-Z',
-                from_up='Y',
-                to_forward='Y',
-                to_up='Z'
-            ).to_4x4()
-
-            mat_scene_scale = mathutils.Matrix.Scale(
-                scene_scale, 4
-            )
-
-            bpy.ops.mesh.primitive_cube_add(
-                enter_editmode=False, align='WORLD', location=(0, 0, 0), scale=(1, 1, 1)
-            )
-            container = bpy.context.active_object
-
-            bbox_verts = calc_bbox_verts((0, 0, 0), layer_shape)
-            for index, vert in enumerate(container.data.vertices):
-                vert.co = transfrom @ mathutils.Vector(bbox_verts[index])
-
-            container.matrix_world = mat_ras2blender @ mat_scene_scale
-            container.name = container_name
-            container.data.name = container_name
-
-            container['bioxel_container'] = True
-            container['scene_scale'] = scene_scale
-            bpy.ops.node.new_geometry_nodes_modifier()
-            container_node_group = container.modifiers[0].node_group
-            input_node = get_nodes_by_type(container_node_group,
-                                           'NodeGroupInput')[0]
-            container_node_group.links.remove(input_node.outputs[0].links[0])
-
-        else:
-            container = bpy.data.objects[self.container]
-            container_node_group = container.modifiers[0].node_group
-
-        preferences = context.preferences.addons[__package__].preferences
-
-        # TODO: change to transform when 4.2?
-        loc, rot, sca = transfrom.decompose()
-        layer_origin = tuple(loc)
-        layer_rotation = tuple(rot.to_euler())
-
-        def create_layer(volume, layer_name, layer_shape, layer_type="scalar"):
-            if volume.ndim == 4:
-                grids_sequence = []
-                for f in range(volume.shape[0]):
-                    print(f"Resampling...")
-                    frame = ski.resize(volume[f, :, :, :],
-                                       layer_shape,
-                                       preserve_range=True,
-                                       anti_aliasing=volume.dtype.kind != "b")
-
-                    grid = vdb.FloatGrid()
-                    frame = frame.copy().astype(np.float32)
-                    grid.copyFromArray(frame)
-                    grid.transform = vdb.createLinearTransform(
-                        transfrom.transposed())
-                    grid.name = layer_type
-                    grids_sequence.append([grid])
-
-                vdb_paths = save_vdbs(grids_sequence, context)
-
-                # Read VDB
-                print(f"Loading the cache to Blender scene...")
-                files = [{"name": str(vdb_path.name), "name": str(vdb_path.name)}
-                         for vdb_path in vdb_paths]
-
-                bpy.ops.object.volume_import(filepath=str(vdb_paths[0]), directory=str(vdb_paths[0].parent),
-                                             files=files, align='WORLD', location=(0, 0, 0), scale=(1, 1, 1))
-
-            else:
-                volume = ski.resize(volume,
-                                    layer_shape,
-                                    preserve_range=True,
-                                    anti_aliasing=volume.dtype.kind != "b")
-
-                grid = vdb.FloatGrid()
-                volume = volume.copy().astype(np.float32)
-                grid.copyFromArray(volume)
-                grid.transform = vdb.createLinearTransform(
-                    transfrom.transposed())
-                grid.name = layer_type
-
-                vdb_path = save_vdb([grid], context)
-
-                # Read VDB
-                print(f"Loading the cache to Blender scene...")
-                bpy.ops.object.volume_import(filepath=str(vdb_path),
-                                             align='WORLD', location=(0, 0, 0), scale=(1, 1, 1))
-
-            layer = bpy.context.active_object
-            layer.data.sequence_mode = 'REPEAT'
-
-            # Set props to VDB object
-            layer.name = layer_name
-            layer.data.name = layer_name
-
-            lock_transform(layer)
-            hide_in_ray(layer)
-            layer.hide_select = True
-            layer.hide_render = True
-            layer.hide_viewport = True
-            layer.data.display.use_slice = True
-            layer.data.display.density = 1e-05
-
-            layer['bioxel_layer'] = True
-            layer['bioxel_layer_type'] = layer_type
-            layer.parent = container
-
-            for collection in layer.users_collection:
-                collection.objects.unlink(layer)
-
-            for collection in container.users_collection:
-                collection.objects.link(layer)
-
-            print(f"Creating layer ...")
-
-            bpy.ops.node.new_geometry_nodes_modifier()
-            node_group = layer.modifiers[0].node_group
-
-            input_node = get_nodes_by_type(node_group, 'NodeGroupInput')[0]
-            output_node = get_nodes_by_type(node_group, 'NodeGroupOutput')[0]
-
-            to_layer_node = custom_nodes.add_node(node_group,
-                                                  "BioxelNodes__ConvertToLayer")
-
-            node_group.links.new(input_node.outputs[0],
-                                 to_layer_node.inputs[0])
-            node_group.links.new(to_layer_node.outputs[0],
-                                 output_node.inputs[0])
-
-            # for compatibility to old vdb
-            # to_layer_node.inputs['Not Transfromed'].default_value = True
-            to_layer_node.inputs['Layer ID'].default_value = random.randint(-200000000,
-                                                                            200000000)
-            to_layer_node.inputs['Data Type'].default_value = dtype_index
-            to_layer_node.inputs['Bioxel Size'].default_value = bioxel_size
-            to_layer_node.inputs['Shape'].default_value = layer_shape
-            to_layer_node.inputs['Origin'].default_value = layer_origin
-            to_layer_node.inputs['Rotation'].default_value = layer_rotation
-
-            move_node_between_nodes(to_layer_node, [input_node, output_node])
-
-            return layer
-
-        def create_mask_node(layer, node_type, node_label, offset):
-            mask_node = custom_nodes.add_node(container_node_group,
-                                              node_type)
-            mask_node.label = node_label
-            mask_node.inputs[0].default_value = layer
-
-            # Connect to output if no output linked
-            output_node = get_nodes_by_type(container_node_group,
-                                            'NodeGroupOutput')[0]
-            if len(output_node.inputs[0].links) == 0:
-                container_node_group.links.new(mask_node.outputs[0],
-                                               output_node.inputs[0])
-                move_node_to_node(mask_node, output_node, (-300, 0))
-            else:
-                move_node_to_node(mask_node, output_node, offset)
-
-        # change shape as sequence or not
-        if self.is_time_sequence:
-            # 4->5 or 5->5
-            if volume.ndim == 4:
-                # channel as frame
-                volume = volume.transpose(3, 0, 1, 2)
-                volume = np.expand_dims(volume, axis=-1)
-
-        else:
-            # 4->4 or 5->4
-            if volume.ndim == 5:
-                # select frame 0
-                volume = volume[0, :, :, :, :]
-
-        if self.read_as == "label":
-            layer_name = self.layer_name or "Label"
-            volume = np.amax(volume, -1)
-            volume = volume.astype(int)
-            orig_max = int(np.max(volume))
-            orig_min = int(np.min(volume))
-
-            for i in range(orig_max):
-                label = volume == np.full_like(volume, i+1)
-                layer_name_i = f"{layer_name}_{i+1}"
-
-                layer = create_layer(volume=label,
-                                     layer_name=f"{container_name}_{layer_name_i}",
-                                     layer_shape=layer_shape,
-                                     layer_type="label")
-
-                mask_node = create_mask_node(layer=layer,
-                                             node_type='BioxelNodes_MaskByLabel',
-                                             node_label=layer_name_i,
-                                             offset=(0, -100 * (i+1)))
-
-        else:
-            layer_name = self.layer_name or "Scalar"
-            # SHOULD NOT change any value!
-            volume = volume.astype(np.float32)
-
-            if self.split_channels:
-                for i in range(volume.shape[-1]):
-                    scalar = volume[:, :, :, :,
-                                    0] if self.is_time_sequence else volume[:, :, :, i]
-                    orig_max = float(np.max(scalar))
-                    orig_min = float(np.min(scalar))
-
-                    scalar_offset = 0
-                    if orig_min < 0:
-                        scalar_offset = -orig_min
-                        scalar = scalar + np.full_like(scalar, scalar_offset)
-
-                    layer_name_i = f"{layer_name}_{i+1}"
-                    layer = create_layer(volume=scalar,
-                                         layer_name=f"{container_name}_{layer_name_i}",
-                                         layer_shape=layer_shape,
-                                         layer_type="scalar")
-
-                    layer_node_group = layer.modifiers[0].node_group
-                    to_layer_node = layer_node_group.nodes['BioxelNodes__ConvertToLayer']
-                    to_layer_node.inputs['Scalar Offset'].default_value = scalar_offset
-                    to_layer_node.inputs['Scalar Max'].default_value = orig_max
-                    to_layer_node.inputs['Scalar Min'].default_value = orig_min
-
-                    mask_node = create_mask_node(layer=layer,
-                                                 node_type='BioxelNodes_MaskByThreshold',
-                                                 node_label=layer_name_i,
-                                                 offset=(0, -100 * (i+1)))
-
-            else:
-                volume = np.amax(volume, -1)
-                orig_max = float(np.max(volume))
-                orig_min = float(np.min(volume))
-
-                scalar_offset = 0
-                if orig_min < 0:
-                    scalar_offset = -orig_min
-                    volume = volume + np.full_like(volume, scalar_offset)
-
-                layer = create_layer(volume=volume,
-                                     layer_name=f"{container_name}_{layer_name}",
-                                     layer_shape=layer_shape,
-                                     layer_type="scalar")
-
-                layer_node_group = layer.modifiers[0].node_group
-                to_layer_node = layer_node_group.nodes['BioxelNodes__ConvertToLayer']
-                to_layer_node.inputs['Scalar Offset'].default_value = scalar_offset
-                to_layer_node.inputs['Scalar Max'].default_value = orig_max
-                to_layer_node.inputs['Scalar Min'].default_value = orig_min
-
-                mask_node = create_mask_node(layer=layer,
-                                             node_type='BioxelNodes_MaskByThreshold',
-                                             node_label=layer_name,
-                                             offset=(0, -100))
-
-        select_object(container)
-
-        # Change render setting for better result
-        if preferences.do_change_render_setting and is_first_import:
-            bpy.context.scene.render.engine = 'CYCLES'
-            try:
-                bpy.context.scene.cycles.shading_system = True
-                bpy.context.scene.cycles.volume_bounces = 12
-                bpy.context.scene.cycles.transparent_max_bounces = 16
-                bpy.context.scene.cycles.volume_preview_step_rate = 10
-                bpy.context.scene.cycles.volume_step_rate = 10
-                bpy.context.scene.eevee.volumetric_tile_size = '2'
-                bpy.context.scene.eevee.volumetric_shadow_samples = 128
-                bpy.context.scene.eevee.volumetric_samples = 256
-            except:
-                pass
-
-        self.report({"INFO"}, "Successfully Imported")
-
-        return {'FINISHED'}
-
-    def invoke(self, context, event):
-        if self.read_as == "label":
-            volume_dtype = "Label"
-        elif self.read_as == "scalar":
-            volume_dtype = "Scalar"
-        title = f"Import as **{volume_dtype}** (Add to Container: {self.container})" \
-            if self.container != "" else f"Import as **{volume_dtype}** (Init a Container)"
-        context.window_manager.invoke_props_dialog(self,
-                                                   width=500,
-                                                   title=title)
-        return {'RUNNING_MODAL'}
-
-    def draw(self, context):
-        layer_shape = get_layer_shape(self.bioxel_size,
-                                      self.orig_shape,
-                                      self.orig_spacing)
-        layer_size = get_layer_size(layer_shape,
-                                    self.bioxel_size,
-                                    self.scene_scale)
-
-        bioxel_count = layer_shape[0] * layer_shape[1] * layer_shape[2]
-        layer_shape_text = f"Shape will be: {str(layer_shape)} {bioxel_count:,} "
-        if bioxel_count > 100000000:
-            layer_shape_text += "**TOO LARGE!**"
-
-        layer_size_text = f"Size will be: ({layer_size[0]:.2f}, {layer_size[1]:.2f}, {layer_size[2]:.2f}) m"
-
-        layout = self.layout
-        if self.container == "":
-            layout.prop(self, "container_name")
-        layout.prop(self, "layer_name")
-
-        panel = layout.box()
-        panel.prop(self, "bioxel_size")
-        row = panel.row()
-        row.prop(self, "orig_spacing")
-        panel.label(text=layer_shape_text)
-
-        panel = layout.box()
-        panel.prop(self, "is_time_sequence")
-        if self.read_as == "scalar":
-            panel.prop(self, "split_channels")
-
-        if self.container == "":
-            panel = layout.box()
-            panel.prop(self, "scene_scale")
-            panel.label(text=layer_size_text)
-
-
-def get_series_ids(self, context):
-    items = []
-    for index, series_id in enumerate(self.series_ids):
-        items.append((
-            series_id.id,
-            series_id.label,
-            "",
-            index
-        ))
-
-    return items
-
-
-class ParseVolumeData(bpy.types.Operator):
-    bl_idname = "bioxelnodes.parse_volume_data"
-    bl_label = "Volumetric Data as Bioxel Layer"
-    bl_description = "Import Volumetric Data as Bioxel Layer"
-    bl_options = {'UNDO'}
-
-    filepath: bpy.props.StringProperty(subtype="FILE_PATH")  # type: ignore
-    directory: bpy.props.StringProperty(subtype='DIR_PATH')  # type: ignore
-    container: bpy.props.StringProperty()   # type: ignore
-
-    read_as: bpy.props.EnumProperty(
-        name="Read as",
-        default="scalar",
-        items=[("scalar", "Scalar", ""),
-               ("label", "Labels", "")]
-    )  # type: ignore
-
-    series_id: bpy.props.EnumProperty(
-        name="Select Series",
-        items=get_series_ids
-    )  # type: ignore
-
-    series_ids: bpy.props.CollectionProperty(
-        type=BIOXELNODES_Series)  # type: ignore
-
-    def execute(self, context):
-        ext = get_ext(self.filepath)
-        if ext not in SUPPORT_EXTS:
-            self.report({"WARNING"}, "Not supported extension.")
-            return {'CANCELLED'}
-
-        print("Collecting Meta Data...")
-        volume, meta = parse_volume_data(self.filepath)
-
-        for key, value in meta.items():
-            print(f"{key}: {value}")
-
-        if self.read_as == "label":
-            not_int = volume.dtype.kind != "b" and volume.dtype.kind != "i" and volume.dtype.kind != "u"
-            too_large = np.max(volume) > 100
-
-            if not_int or too_large:
-                self.report(
-                    {"WARNING"}, "This volume data does not looks like label, please check again.")
-                return {'CANCELLED'}
-
-        # do_orient = ext not in SEQUENCE_EXTS or ext in DICOM_EXTS
-
-        orig_shape = meta['shape']
-        orig_spacing = meta['spacing']
-        min_size = min(orig_spacing[0], orig_spacing[1], orig_spacing[2])
-        bioxel_size = max(min_size, 1.0)
-
-        layer_size = get_layer_size(orig_shape,
-                                    bioxel_size)
-        log10 = math.floor(math.log10(max(*layer_size)))
-        scene_scale = math.pow(10, -log10)
-
-        if self.container:
-            container = bpy.data.objects[self.container]
-            container_name = container.name
-        else:
-            container_name = meta['name']
-
-        bpy.ops.bioxelnodes.import_volume_data_dialog(
-            'INVOKE_DEFAULT',
-            filepath=self.filepath,
-            container_name=container_name,
-            orig_shape=orig_shape,
-            orig_spacing=orig_spacing,
-            bioxel_size=bioxel_size,
-            series_id=self.series_id or "",
-            # do_orient=do_orient,
-            container=self.container,
-            read_as=self.read_as,
-            scene_scale=scene_scale
-        )
-
-        self.report({"INFO"}, "Successfully Readed.")
-
-        return {'FINISHED'}
-
-    def modal(self, context, event):
-        self.execute(context)
-        return {'FINISHED'}
-
-    def invoke(self, context, event):
-        if not self.filepath and not self.directory:
-            return {'CANCELLED'}
-
-        show_message('Parsing volume data, it may take a while...',
-                     'Please be patient...')
-
-        if get_ext(self.filepath) == '.dcm':
-            dir_path = Path(self.filepath).parent
-            reader = sitk.ImageSeriesReader()
-            reader.MetaDataDictionaryArrayUpdateOn()
-            reader.LoadPrivateTagsOn()
-            series_ids = reader.GetGDCMSeriesIDs(str(dir_path))
-
-            for _id in series_ids:
-                series_id = self.series_ids.add()
-                series_id.id = _id
-                series_id.label = _id
-
-            if len(series_ids) > 1:
-                context.window_manager.invoke_props_dialog(self, width=400)
-                return {'RUNNING_MODAL'}
-            else:
-                self.series_id = series_ids[0]
-
-        context.window_manager.modal_handler_add(self)
-        return {'RUNNING_MODAL'}
-
-    def draw(self, context):
-        layout = self.layout
-        layout.prop(self, "series_id")
-        layout.label(
-            text="Reading image data, it may take a while...")
-        layout.label(
-            text="Please be patient...")
-
-
-class ImportVolumeData():
-    bl_options = {'UNDO'}
-
-    filepath: bpy.props.StringProperty(subtype="FILE_PATH")  # type: ignore
-    directory: bpy.props.StringProperty(subtype='DIR_PATH')  # type: ignore
-
-    read_as = "scalar"
-
-    def execute(self, context):
-        containers = get_container_from_selection()
-
-        if len(containers) > 0:
-            bpy.ops.bioxelnodes.parse_volume_data(
-                'INVOKE_DEFAULT',
-                filepath=self.filepath,
-                directory=self.directory,
-                container=containers[0].name,
-                read_as=self.read_as
-            )
-        else:
-            bpy.ops.bioxelnodes.parse_volume_data(
-                'INVOKE_DEFAULT',
-                filepath=self.filepath,
-                directory=self.directory,
-                read_as=self.read_as
-            )
-
-        return {'FINISHED'}
-
-    def invoke(self, context, event):
-        context.window_manager.fileselect_add(self)
-        return {'RUNNING_MODAL'}
-
-
-class ImportAsScalarLayer(bpy.types.Operator, ImportVolumeData):
-    bl_idname = "bioxelnodes.import_as_scalar_layer"
-    bl_label = "Import as Scalar"
-    bl_description = "Import Volumetric Data to Container as Scalar"
-    read_as = "scalar"
-
-
-class ImportAsLabelLayer(bpy.types.Operator, ImportVolumeData):
-    bl_idname = "bioxelnodes.import_as_label_layer"
-    bl_label = "Import as Label"
-    bl_description = "Import Volumetric Data to Container as Label"
-    read_as = "label"
-
-
-try:
-    class BIOXELNODES_FH_ImportVolumeData(bpy.types.FileHandler):
-        bl_idname = "BIOXELNODES_FH_ImportVolumeData"
-        bl_label = "File handler for dicom import"
-        bl_import_operator = "bioxelnodes.parse_volume_data"
-        bl_file_extensions = ";".join(FH_EXTS)
-
-        @classmethod
-        def poll_drop(cls, context):
-            return (context.area and context.area.type == 'VIEW_3D')
-except:
-    ...
-
-
-class ExportVolumeData(bpy.types.Operator):
-    bl_idname = "bioxelnodes.export_volume_data"
-    bl_label = "Export Layer as VDB"
-    bl_description = "Export Layer as VDB"
-    bl_options = {'UNDO'}
-
-    filepath: bpy.props.StringProperty(
-        subtype="FILE_PATH"
-    )  # type: ignore
-
-    filename_ext = ".vdb"
-
-    @classmethod
-    def poll(cls, context):
-        layer = get_layer(bpy.context.active_object)
-        return True if layer else False
-
-    def invoke(self, context, event):
-        context.window_manager.fileselect_add(self)
-        return {'RUNNING_MODAL'}
-
-    def execute(self, context):
-        layer = get_layer(bpy.context.active_object)
-
-        filepath = f"{self.filepath.split('.')[0]}.vdb"
-        # "//"
-        source_dir = bpy.path.abspath(layer.data.filepath)
-
-        output_path: Path = Path(filepath).resolve()
-        source_path: Path = Path(source_dir).resolve()
-        # print('output_path', output_path)
-        # print('source_path', source_path)
-        shutil.copy(source_path, output_path)
-
-        self.report({"INFO"}, f"Successfully exported to {output_path}")
-
-        return {'FINISHED'}

bioxelnodes/io_points.py

@@ -1,25 +0,0 @@
-# TODO: WIP
-import bpy
-import bmesh
-
-
-def create_points_obj(points, name="points"):
-    bpy.ops.mesh.primitive_cube_add(
-        enter_editmode=False, align='WORLD', location=(0, 0, 0), scale=(1, 1, 1)
-    )
-    obj = bpy.context.active_object
-    mesh = obj.data
-
-    bm = bmesh.new()
-    value_layer = bm.verts.layers.float.new('value')
-
-    for point in points:
-        pos = point['pos']
-        value = point['value']
-        vert = bm.verts.new(pos)  # add a new vert
-        vert[value_layer] = value
-
-    # make the bmesh the object's mesh
-    bm.to_mesh(mesh)
-    bm.free()  # always do this when finished
-    return obj

bioxelnodes/menus.py

@@ -1,189 +0,0 @@
-import bpy
-
-from .utils import get_container_from_selection
-from .operators import (AddPieCutter, AddPlaneCutter, AddCylinderCutter, AddCubeCutter, AddSphereCutter, CombineLabels,
-                        ConvertToMesh, InvertScalar, FillByLabel, FillByThreshold, FillByRange, PickBboxWire, PickMesh, PickVolume)
-from .io import ExportVolumeData, ImportAsLabelLayer, ImportAsScalarLayer
-from .save import CleanAllCaches, ReLinkNodes, SaveLayers, SaveStagedData
-
-
-class PickFromContainerMenu(bpy.types.Menu):
-    bl_idname = "BIOXELNODES_MT_PICK"
-    bl_label = "Pick from Container"
-
-    def draw(self, context):
-        layout = self.layout
-        layout.operator(PickMesh.bl_idname)
-        layout.operator(PickVolume.bl_idname)
-        layout.operator(PickBboxWire.bl_idname)
-
-
-class ModifyLayerMenu(bpy.types.Menu):
-    bl_idname = "BIOXELNODES_MT_MODIFY_LAYERS"
-    bl_label = "Modify Layer"
-
-    def draw(self, context):
-        layout = self.layout
-        layout.operator(InvertScalar.bl_idname)
-        layout.operator(FillByThreshold.bl_idname)
-        layout.operator(FillByRange.bl_idname)
-        layout.operator(FillByLabel.bl_idname)
-        layout.operator(CombineLabels.bl_idname)
-
-
-class AddCutterMenu(bpy.types.Menu):
-    bl_idname = "BIOXELNODES_MT_CUTTERS"
-    bl_label = "Add a Cutter to Container"
-
-    def draw(self, context):
-        layout = self.layout
-        layout.operator(AddPlaneCutter.bl_idname, text="Plane Cutter")
-        layout.operator(AddCylinderCutter.bl_idname, text="Cylinder Cutter")
-        layout.operator(AddCubeCutter.bl_idname, text="Cube Cutter")
-        layout.operator(AddSphereCutter.bl_idname, text="Sphere Cutter")
-        layout.operator(AddPieCutter.bl_idname, text="Pie Cutter")
-
-
-class ImportLayerMenu(bpy.types.Menu):
-    bl_idname = "BIOXELNODES_MT_LAYERS"
-    bl_label = "Import Volumetric Data"
-
-    def draw(self, context):
-        layout = self.layout
-        layout.operator(ImportAsScalarLayer.bl_idname, text="as Scalar")
-        layout.operator(ImportAsLabelLayer.bl_idname, text="as Label")
-
-
-class BioxelNodesView3DMenu(bpy.types.Menu):
-    bl_idname = "BIOXELNODES_MT_VIEW3D"
-    bl_label = "Bioxel Nodes"
-
-    def draw(self, context):
-        layout = self.layout
-        containers = get_container_from_selection()
-        is_selected = len(containers) > 0
-        layout.operator(ImportAsScalarLayer.bl_idname,
-                        text=ImportAsScalarLayer.bl_label+" (Add to)"
-                        if is_selected else ImportAsScalarLayer.bl_label+" (Init)")
-        layout.operator(ImportAsLabelLayer.bl_idname,
-                        text=ImportAsLabelLayer.bl_label+" (Add to)"
-                        if is_selected else ImportAsLabelLayer.bl_label+" (Init)")
-        layout.separator()
-        layout.operator(AddPlaneCutter.bl_idname)
-        layout.operator(AddCylinderCutter.bl_idname)
-        layout.operator(AddCubeCutter.bl_idname)
-        layout.operator(AddSphereCutter.bl_idname)
-        layout.operator(AddPieCutter.bl_idname)
-        layout.separator()
-        layout.operator(PickMesh.bl_idname)
-        layout.operator(PickVolume.bl_idname)
-        layout.operator(PickBboxWire.bl_idname)
-        layout.separator()
-        layout.operator(SaveLayers.bl_idname)
-
-
-class BioxelNodesOutlinerMenu(bpy.types.Menu):
-    bl_idname = "BIOXELNODES_MT_OUTLINER"
-    bl_label = "Bioxel Nodes"
-
-    def draw(self, context):
-        layout = self.layout
-        containers = get_container_from_selection()
-        is_selected = len(containers) > 0
-        layout.operator(ImportAsScalarLayer.bl_idname,
-                        text=ImportAsScalarLayer.bl_label+" (Add to)"
-                        if is_selected else ImportAsScalarLayer.bl_label+" (Init)")
-        layout.operator(ImportAsLabelLayer.bl_idname,
-                        text=ImportAsLabelLayer.bl_label+" (Add to)"
-                        if is_selected else ImportAsLabelLayer.bl_label+" (Init)")
-        layout.separator()
-        layout.operator(AddPlaneCutter.bl_idname)
-        layout.operator(AddCylinderCutter.bl_idname)
-        layout.operator(AddCubeCutter.bl_idname)
-        layout.operator(AddSphereCutter.bl_idname)
-        layout.operator(AddPieCutter.bl_idname)
-        layout.separator()
-        layout.operator(PickMesh.bl_idname)
-        layout.operator(PickVolume.bl_idname)
-        layout.operator(PickBboxWire.bl_idname)
-        layout.separator()
-        layout.operator(SaveLayers.bl_idname)
-        layout.separator()
-        layout.operator(InvertScalar.bl_idname)
-        layout.operator(FillByThreshold.bl_idname)
-        layout.operator(FillByRange.bl_idname)
-        layout.operator(FillByLabel.bl_idname)
-        layout.operator(CombineLabels.bl_idname)
-        layout.separator()
-        layout.operator(ExportVolumeData.bl_idname)
-
-
-def TOPBAR_FILE_IMPORT(self, context):
-    layout = self.layout
-    containers = get_container_from_selection()
-    is_selected = len(containers) > 0
-
-    layout.separator()
-    layout.menu(ImportLayerMenu.bl_idname, text="Volumetric Data as Bioxel (Add to)"
-                if is_selected else "Volumetric Data as Bioxel (Init)")
-
-
-def TOPBAR_FILE_EXPORT(self, context):
-    layout = self.layout
-    layout.separator()
-    layout.operator(ExportVolumeData.bl_idname,
-                    text="Bioxel Layer (.vdb)")
-
-
-def VIEW3D_OBJECT(self, context):
-    layout = self.layout
-    layout.separator()
-    layout.menu(BioxelNodesView3DMenu.bl_idname, icon="FILE_VOLUME")
-
-
-def OUTLINER_OBJECT(self, context):
-    layout = self.layout
-    layout.separator()
-    layout.menu(BioxelNodesOutlinerMenu.bl_idname, icon="FILE_VOLUME")
-
-
-class BioxelNodesTopbarMenu(bpy.types.Menu):
-    bl_idname = "BIOXELNODES_MT_TOPBAR"
-    bl_label = "Bioxel Nodes"
-
-    def draw(self, context):
-        layout = self.layout
-        containers = get_container_from_selection()
-        is_selected = len(containers) > 0
-
-        layout.menu(ImportLayerMenu.bl_idname, text=ImportLayerMenu.bl_label+" (Add to)"
-                    if is_selected else ImportLayerMenu.bl_label+" (Init)")
-        layout.separator()
-        layout.menu(AddCutterMenu.bl_idname)
-        layout.menu(PickFromContainerMenu.bl_idname)
-        layout.separator()
-        layout.operator(SaveStagedData.bl_idname)
-        layout.operator(ReLinkNodes.bl_idname)
-        layout.separator()
-        layout.operator(CleanAllCaches.bl_idname)
-
-
-def TOPBAR(self, context):
-    layout = self.layout
-    layout.menu(BioxelNodesTopbarMenu.bl_idname)
-
-
-def add():
-    bpy.types.TOPBAR_MT_file_import.append(TOPBAR_FILE_IMPORT)
-    bpy.types.TOPBAR_MT_file_export.append(TOPBAR_FILE_EXPORT)
-    bpy.types.OUTLINER_MT_object.append(OUTLINER_OBJECT)
-    bpy.types.VIEW3D_MT_object_context_menu.append(VIEW3D_OBJECT)
-    bpy.types.TOPBAR_MT_editor_menus.append(TOPBAR)
-
-
-def remove():
-    bpy.types.TOPBAR_MT_file_import.remove(TOPBAR_FILE_IMPORT)
-    bpy.types.TOPBAR_MT_file_export.remove(TOPBAR_FILE_EXPORT)
-    bpy.types.OUTLINER_MT_object.remove(OUTLINER_OBJECT)
-    bpy.types.VIEW3D_MT_object_context_menu.remove(VIEW3D_OBJECT)
-    bpy.types.TOPBAR_MT_editor_menus.remove(TOPBAR)

bioxelnodes/nodes.py

@@ -1,282 +0,0 @@
-
-from pathlib import Path
-from .customnodes import CustomNodes
-import bpy
-
-# def set_object_to_node_factory(object_type:str):
-#     if object_type == "plane":
-#         create_object = """
-#     bpy.ops.mesh.primitive_plane_add(size=2, enter_editmode=False, align='WORLD', location=(0, 0, 0), scale=(1, 1, 1))
-#         """
-#     callback_str = f"""
-# import bpy
-# from ..utils import get_container
-# container = get_container(bpy.context.active_object)
-# if container:
-#     {create_object}
-#     object = bpy.context.active_object
-#     node.inputs[0].default_value = object
-# else:
-#     print('Cannot find any Bioxel Container.')
-#     """
-#     return callback_str
-
-
-# def add_driver_to_node_factory(source_prop, target_prop):
-#     callback_str = f"""
-# import bpy
-# from .utils import add_direct_driver, get_bioxels_obj
-# bioxels_obj = get_bioxels_obj(bpy.context.active_object)
-# if bioxels_obj:
-#     container_obj = bioxels_obj.parent
-#     add_direct_driver(
-#         target=node,
-#         target_prop='{target_prop}',
-#         source=container_obj,
-#         source_prop='{source_prop}'
-#     )
-# else:
-#     print('Cannot find any bioxels.')
-#     """
-#     return callback_str
-
-
-# def set_prop_to_node_factory(source_prop, target_prop):
-#     callback_str = f"""
-# import bpy
-# from .utils import get_bioxels_obj
-# bioxels_obj = get_bioxels_obj(bpy.context.active_object)
-# if bioxels_obj:
-#     container_obj = bioxels_obj.parent
-#     node.inputs.get('{target_prop}').default_value = container_obj.get(
-#         '{source_prop}')
-# else:
-#     print('Cannot find any bioxels.')
-#     """
-#     return callback_str
-
-
-NODE_FILE = "BioxelNodes_4.1"
-
-MENU_ITEMS = [
-    {
-        'label': 'Methods',
-        'icon': 'OUTLINER_DATA_VOLUME',
-        'items': [
-            {
-                'label': 'Mask by Threshold',
-                'icon': 'EMPTY_SINGLE_ARROW',
-                'node_type': 'BioxelNodes_MaskByThreshold',
-                'node_description': ''
-            },
-            {
-                'label': 'Mask by Range',
-                'icon': 'IPO_CONSTANT',
-                'node_type': 'BioxelNodes_MaskByRange',
-                'node_description': ''
-            },
-            {
-                'label': 'Mask by Label',
-                'icon': 'MESH_CAPSULE',
-                'node_type': 'BioxelNodes_MaskByLabel',
-                'node_description': ''
-            }
-        ]
-    },
-    {
-        'label': 'Shaders',
-        'icon': 'SHADING_RENDERED',
-        'items': [
-            {
-                'label': 'Membrane Shader',
-                'icon': 'NODE_MATERIAL',
-                'node_type': 'BioxelNodes_AssignMembraneShader',
-                'node_description': ''
-            },
-            {
-                'label': 'Solid Shader',
-                'icon': 'SHADING_SOLID',
-                'node_type': 'BioxelNodes_AssignSolidShader',
-                'node_description': ''
-            },
-            {
-                'label': 'Slime Shader',
-                'icon': 'OUTLINER_DATA_META',
-                'node_type': 'BioxelNodes_AssignSlimeShader',
-                'node_description': ''
-            },
-            {
-                'label': 'Volume Shader',
-                'icon': 'VOLUME_DATA',
-                'node_type': 'BioxelNodes_AssignVolumeShader',
-                'node_description': ''
-            },
-            {
-                'label': 'Universal Shader',
-                'icon': 'MATSHADERBALL',
-                'node_type': 'BioxelNodes_AssignUniversalShader',
-                'node_description': ''
-            }
-        ]
-    },
-    {
-        'label': 'Colors',
-        'icon': 'COLOR',
-        'items': [
-            {
-                'label': 'Color Presets',
-                'icon': 'COLOR',
-                'node_type': 'BioxelNodes_ColorPresets',
-                'node_description': ''
-            },
-            {
-                'label': 'Color Presets MRI',
-                'icon': 'COLOR',
-                'node_type': 'BioxelNodes_ColorPresets_MRI',
-                'node_description': ''
-            },
-            "separator",
-            {
-                'label': 'Color Ramp 2',
-                'icon': 'IPO_QUAD',
-                'node_type': 'BioxelNodes_SetColorRamp2',
-                'node_description': ''
-            },
-            {
-                'label': 'Color Ramp 3',
-                'icon': 'IPO_CUBIC',
-                'node_type': 'BioxelNodes_SetColorRamp3',
-                'node_description': ''
-            },
-            {
-                'label': 'Color Ramp 4',
-                'icon': 'IPO_QUART',
-                'node_type': 'BioxelNodes_SetColorRamp4',
-                'node_description': ''
-            },
-            {
-                'label': 'Color Ramp 5',
-                'icon': 'IPO_QUINT',
-                'node_type': 'BioxelNodes_SetColorRamp5',
-                'node_description': ''
-            }
-        ]
-    },
-    {
-        'label': 'Cutters',
-        'icon': 'MOD_BEVEL',
-        'items': [
-            {
-                'label': 'Cut',
-                'icon': 'MOD_BEVEL',
-                'node_type': 'BioxelNodes_Cut',
-                'node_description': ''
-            },
-            "separator",
-            {
-                'label': 'Primitive Cutter',
-                'icon': 'MOD_LINEART',
-                'node_type': 'BioxelNodes_PrimitiveCutter',
-                'node_description': ''
-            },
-            "separator",
-            {
-                'label': 'Plane Cutter',
-                'icon': 'MESH_PLANE',
-                'node_type': 'BioxelNodes_PlaneObjectCutter',
-                'node_description': ''
-            },
-            {
-                'label': 'Cylinder Cutter',
-                'icon': 'MESH_CYLINDER',
-                'node_type': 'BioxelNodes_CylinderObjectCutter',
-                'node_description': '',
-            },
-            {
-                'label': 'Cube Cutter',
-                'icon': 'MESH_CUBE',
-                'node_type': 'BioxelNodes_CubeObjectCutter',
-                'node_description': '',
-            },
-            {
-                'label': 'Sphere Cutter',
-                'icon': 'MESH_UVSPHERE',
-                'node_type': 'BioxelNodes_SphereObjectCutter',
-                'node_description': '',
-            },
-            {
-                'label': 'Pie Cutter',
-                'icon': 'MESH_CONE',
-                'node_type': 'BioxelNodes_PieObjectCutter',
-                'node_description': '',
-            }
-        ]
-    },
-    {
-        'label': 'Utils',
-        'icon': 'MODIFIER',
-        'items': [
-            {
-                'label': 'Join Component',
-                'icon': 'CONSTRAINT_BONE',
-                'node_type': 'BioxelNodes_JoinComponent',
-                'node_description': ''
-            },
-            "separator",
-            {
-                'label': 'Pick Mesh',
-                'icon': 'OUTLINER_OB_MESH',
-                'node_type': 'BioxelNodes_PickMesh',
-                'node_description': ''
-            },
-            {
-                'label': 'Pick Volume',
-                'icon': 'OUTLINER_OB_VOLUME',
-                'node_type': 'BioxelNodes_PickVolume',
-                'node_description': ''
-            },
-            {
-                'label': 'Pick Bbox Wire',
-                'icon': 'MESH_CUBE',
-                'node_type': 'BioxelNodes_PickBboxWire',
-                'node_description': ''
-            },
-            "separator",
-            {
-                'label': 'Inflate',
-                'icon': 'OUTLINER_OB_META',
-                'node_type': 'BioxelNodes_M_Inflate',
-                'node_description': ''
-            },
-            {
-                'label': 'Smooth',
-                'icon': 'MOD_SMOOTH',
-                'node_type': 'BioxelNodes_M_Smooth',
-                'node_description': ''
-            },
-            {
-                'label': 'Remove Small Island',
-                'icon': 'FORCE_LENNARDJONES',
-                'node_type': 'BioxelNodes_M_RemoveSmallIsland',
-                'node_description': ''
-            }
-        ]
-    }
-]
-
-
-custom_nodes = CustomNodes(
-    menu_items=MENU_ITEMS,
-    nodes_file=Path(__file__).parent / f"assets/Nodes/{NODE_FILE}.blend",
-    class_prefix="BIOXELNODES_MT_NODES",
-    root_label='Bioxel Nodes',
-    root_icon="FILE_VOLUME",
-)
-
-
-def register():
-    custom_nodes.register()
-
-
-def unregister():
-    custom_nodes.unregister()

bioxelnodes/operators.py

@@ -1,929 +0,0 @@
-from pathlib import Path
-import random
-import bpy
-import pyopenvdb as vdb
-import numpy as np
-import bmesh
-from . import skimage as ski
-from . import scipy
-from .nodes import custom_nodes
-from .utils import (get_container, get_container_from_selection, get_container_layers,
-                    get_layer, get_nodes_by_type, hide_in_ray, lock_transform, move_node_between_nodes, move_node_to_node, save_vdb, select_object)
-
-
-def get_layer_name(layer):
-    container = layer.parent
-    return layer.name.removeprefix(container.name).replace("_", "")
-
-
-def get_grids(layer):
-    layer_dir = bpy.path.abspath(layer.data.filepath)
-    grids, base_metadata = vdb.readAll(layer_dir)
-    return grids
-
-
-def set_volume(grids, index, volume):
-    grids[index].clear()
-    grids[index].copyFromArray(volume.copy().astype(np.float32))
-
-
-def get_volume(grids, index, shape):
-    volume = np.ndarray(shape, np.float32)
-    volume.fill(index)
-    grids[0].copyToArray(volume)
-    return volume
-
-
-def get_shape(layer):
-    layer_node = layer.modifiers[0].node_group.nodes['BioxelNodes__ConvertToLayer']
-    return [int(a)
-            for a in layer_node.inputs['Shape'].default_value]
-
-
-def get_layer_meta(layer, key: str):
-    layer_node = layer.modifiers[0].node_group.nodes['BioxelNodes__ConvertToLayer']
-    return layer_node.inputs[key].default_value
-
-
-def set_layer_meta(layer, key: str, value):
-    layer_node = layer.modifiers[0].node_group.nodes['BioxelNodes__ConvertToLayer']
-    layer_node.inputs[key].default_value = value
-
-
-def add_mask_node(container, layer, node_type: str, node_label: str):
-    modifier = container.modifiers[0]
-    container_node_group = modifier.node_group
-
-    mask_node = custom_nodes.add_node(container_node_group, node_type)
-    mask_node.label = node_label
-    mask_node.inputs[0].default_value = layer
-
-    # Connect to output if no output linked
-    output_node = get_nodes_by_type(container_node_group,
-                                    'NodeGroupOutput')[0]
-
-    if len(output_node.inputs[0].links) == 0:
-        container_node_group.links.new(mask_node.outputs[0],
-                                       output_node.inputs[0])
-        move_node_to_node(mask_node, output_node, (-300, 0))
-    else:
-        move_node_to_node(mask_node, output_node, (0, -100))
-
-    return mask_node
-
-
-def deep_copy_layer(vdb_path, base_layer, name):
-    # Read VDB
-    print(f"Loading the cache to Blender scene...")
-    bpy.ops.object.volume_import(
-        filepath=str(vdb_path), align='WORLD', location=(0, 0, 0), scale=(1, 1, 1))
-
-    copyed_layer = bpy.context.active_object
-
-    # Set props to VDB object
-    copyed_layer.name = name
-    copyed_layer.data.name = name
-
-    lock_transform(copyed_layer)
-    hide_in_ray(copyed_layer)
-    copyed_layer.hide_select = True
-    copyed_layer.hide_render = True
-    copyed_layer.hide_viewport = True
-    copyed_layer.data.display.use_slice = True
-    copyed_layer.data.display.density = 1e-05
-
-    copyed_layer['bioxel_layer'] = True
-    copyed_layer['bioxel_layer_type'] = base_layer['bioxel_layer_type']
-    copyed_layer.parent = base_layer.parent
-
-    for collection in copyed_layer.users_collection:
-        collection.objects.unlink(copyed_layer)
-
-    for collection in base_layer.users_collection:
-        collection.objects.link(copyed_layer)
-
-    # add convert to layer node
-    base_layer_node = base_layer.modifiers[0].node_group.nodes['BioxelNodes__ConvertToLayer']
-
-    not_transformed = base_layer_node.inputs['Not Transfromed'].default_value
-    dtype_index = base_layer_node.inputs['Data Type'].default_value
-    bioxel_size = base_layer_node.inputs['Bioxel Size'].default_value
-    layer_shape = base_layer_node.inputs['Shape'].default_value
-    layer_origin = base_layer_node.inputs['Origin'].default_value
-    layer_rotation = base_layer_node.inputs['Rotation'].default_value
-    scalar_offset = base_layer_node.inputs['Scalar Offset'].default_value
-    scalar_min = base_layer_node.inputs['Scalar Min'].default_value
-    scalar_max = base_layer_node.inputs['Scalar Max'].default_value
-
-    bpy.ops.node.new_geometry_nodes_modifier()
-    node_group = copyed_layer.modifiers[0].node_group
-
-    input_node = get_nodes_by_type(node_group, 'NodeGroupInput')[0]
-    output_node = get_nodes_by_type(node_group, 'NodeGroupOutput')[0]
-
-    copyed_layer_node = custom_nodes.add_node(node_group,
-                                              "BioxelNodes__ConvertToLayer")
-
-    node_group.links.new(input_node.outputs[0], copyed_layer_node.inputs[0])
-    node_group.links.new(copyed_layer_node.outputs[0], output_node.inputs[0])
-
-    # for compatibility to old vdb
-    copyed_layer_node.inputs['Not Transfromed'].default_value = not_transformed
-    copyed_layer_node.inputs['Layer ID'].default_value = random.randint(-200000000,
-                                                                        200000000)
-    copyed_layer_node.inputs['Data Type'].default_value = dtype_index
-    copyed_layer_node.inputs['Bioxel Size'].default_value = bioxel_size
-    copyed_layer_node.inputs['Shape'].default_value = layer_shape
-    copyed_layer_node.inputs['Origin'].default_value = layer_origin
-    copyed_layer_node.inputs['Rotation'].default_value = layer_rotation
-    copyed_layer_node.inputs['Scalar Offset'].default_value = scalar_offset
-    copyed_layer_node.inputs['Scalar Min'].default_value = scalar_min
-    copyed_layer_node.inputs['Scalar Max'].default_value = scalar_max
-
-    return copyed_layer
-
-
-def get_scalar_layer_selection(self, context):
-    items = [("None", "None", "")]
-    container = get_container(bpy.context.active_object)
-    for layer in get_container_layers(container):
-        if layer.get("bioxel_layer_type") == "scalar":
-            items.append((
-                layer.name,
-                layer.name,
-                ""
-            ))
-
-    return items
-
-
-def get_label_layer_selection(self, context):
-    items = [("None", "None", "")]
-    container = get_container(bpy.context.active_object)
-    for layer in get_container_layers(container):
-        if layer.get("bioxel_layer_type") == "label":
-            items.append((
-                layer.name,
-                layer.name,
-                ""
-            ))
-
-    return items
-
-
-# class JoinLayers(bpy.types.Operator):
-#     bl_idname = "bioxelnodes.join_layers"
-#     bl_label = "Join Bioxel Layers"
-#     bl_description = "Join Additional Bioxel Layers"
-#     bl_options = {'UNDO'}
-
-#     base_layer: bpy.props.StringProperty(
-#         options={"HIDDEN"}
-#     )   # type: ignore
-
-#     scalar_layer: bpy.props.EnumProperty(
-#         name="Scalar Layer",
-#         items=get_scalar_layer_selection
-#     )  # type: ignore
-
-#     label_layer: bpy.props.EnumProperty(
-#         name="Label Layer",
-#         items=get_label_layer_selection
-#     )  # type: ignore
-#     # color_layer: bpy.props.StringProperty()   # type: ignore
-
-#     @classmethod
-#     def poll(cls, context):
-#         layer = get_layer(bpy.context.active_object)
-#         return True if layer else False
-
-#     def execute(self, context):
-#         base_layer = bpy.data.objects[self.base_layer]
-
-#         if not base_layer:
-#             self.report({"WARNING"}, "Cannot find any bioxel layer as base.")
-#             return {'FINISHED'}
-
-#         base_layer_dir = bpy.path.abspath(base_layer.data.filepath)
-#         base_grids, base_metadata = vdb.readAll(base_layer_dir)
-
-#         layers = []
-#         if self.scalar_layer != "None":
-#             scalar_layer = bpy.data.objects[self.scalar_layer]
-#             layers.append(scalar_layer)
-
-#         if self.label_layer != "None":
-#             label_layer = bpy.data.objects[self.label_layer]
-#             layers.append(label_layer)
-
-#         # TODO: add color and vector
-
-#         if len(layers) == 0:
-#             self.report({"WARNING"}, "No additinal layers setted.")
-#             return {'FINISHED'}
-
-#         for layer in layers:
-#             layer_dir = bpy.path.abspath(layer.data.filepath)
-#             grids, metadata = vdb.readAll(layer_dir)
-#             base_grids.extend(grids)
-
-#         vdb_path = save_vdb(base_grids, context)
-
-#         joined_layer = deep_copy_layer(vdb_path,
-#                                        base_layer,
-#                                        f"{base_layer.name}_Joined")
-
-#         return {'FINISHED'}
-
-#     def invoke(self, context, event):
-#         base_layer = get_layer(bpy.context.active_object)
-#         self.base_layer = base_layer.name
-#         context.window_manager.invoke_props_dialog(self, width=400)
-#         return {'RUNNING_MODAL'}
-
-
-class InvertScalar(bpy.types.Operator):
-    bl_idname = "bioxelnodes.invert_scalar"
-    bl_label = "Invert Scalar"
-    bl_description = "Invert the scalar value"
-    bl_options = {'UNDO'}
-
-    @classmethod
-    def poll(cls, context):
-        layer = get_layer(bpy.context.active_object)
-        if layer:
-            return layer.get("bioxel_layer_type") == "scalar"
-        else:
-            return False
-
-    def execute(self, context):
-        base_layer = get_layer(bpy.context.active_object)
-
-        container = base_layer.parent
-        inverted_layer_name = f"{get_layer_name(base_layer)}_Inverted"
-
-        base_shape = get_shape(base_layer)
-        scalar_offset = get_layer_meta(base_layer, "Scalar Offset")
-
-        base_grids = get_grids(base_layer)
-        base_volume = get_volume(base_grids, 0, base_shape)
-
-        base_volume = -(base_volume - scalar_offset)
-
-        base_min = float(np.min(base_volume))
-        base_max = float(np.max(base_volume))
-
-        scalar_offset = 0
-        if base_min < 0:
-            scalar_offset = -base_min
-            base_volume = base_volume + scalar_offset
-
-        set_volume(base_grids, 0, base_volume)
-        vdb_path = save_vdb(base_grids, context)
-        inverted_layer = deep_copy_layer(vdb_path,
-                                         base_layer,
-                                         f"{container.name}_{inverted_layer_name}")
-        set_layer_meta(inverted_layer, 'Scalar Offset', scalar_offset)
-        set_layer_meta(inverted_layer, 'Scalar Min', base_min)
-        set_layer_meta(inverted_layer, 'Scalar Max', base_max)
-
-        add_mask_node(container,
-                      inverted_layer,
-                      "BioxelNodes_MaskByThreshold",
-                      inverted_layer_name)
-
-        select_object(container)
-
-        return {'FINISHED'}
-
-
-class FillByThreshold(bpy.types.Operator):
-    bl_idname = "bioxelnodes.fill_by_threshold"
-    bl_label = "Fill Value by Threshold"
-    bl_description = "Fill Value by Threshold"
-    bl_options = {'UNDO'}
-
-    threshold: bpy.props.FloatProperty(
-        name="Threshold",
-        soft_min=0, soft_max=1024,
-        default=128,
-    )  # type: ignore
-
-    fill_value: bpy.props.FloatProperty(
-        name="Fill Value",
-        soft_min=0, soft_max=1024.0,
-        default=0,
-    )  # type: ignore
-
-    invert: bpy.props.BoolProperty(
-        name="Invert Area",
-        default=True,
-    )  # type: ignore
-
-    @classmethod
-    def poll(cls, context):
-        layer = get_layer(bpy.context.active_object)
-        if layer:
-            return layer.get("bioxel_layer_type") == "scalar"
-        else:
-            return False
-
-    def execute(self, context):
-        base_layer = get_layer(bpy.context.active_object)
-
-        container = base_layer.parent
-        filled_layer_name = f"{get_layer_name(base_layer)}_{self.threshold}-Filled"
-        scalar_offset = get_layer_meta(base_layer, "Scalar Offset")
-        base_shape = get_shape(base_layer)
-
-        base_grids = get_grids(base_layer)
-        base_volume = get_volume(base_grids, 0, base_shape)
-        mask = base_volume > (self.threshold + scalar_offset)
-        mask = scipy.median_filter(mask.astype(np.float32), size=2)
-        if self.invert:
-            base_volume = mask * base_volume + \
-                (1-mask) * (self.fill_value + scalar_offset)
-        else:
-            base_volume = (1-mask) * base_volume + \
-                mask * (self.fill_value + scalar_offset)
-
-        set_volume(base_grids, 0, base_volume)
-        vdb_path = save_vdb(base_grids, context)
-        filled_layer = deep_copy_layer(vdb_path,
-                                       base_layer,
-                                       f"{container.name}_{filled_layer_name}")
-        mask_node = add_mask_node(container,
-                                  filled_layer,
-                                  "BioxelNodes_MaskByThreshold",
-                                  filled_layer_name)
-
-        mask_node.inputs[1].default_value = self.threshold
-
-        select_object(container)
-
-        return {'FINISHED'}
-
-    def invoke(self, context, event):
-        base_layer = get_layer(bpy.context.active_object)
-        scalar_min = get_layer_meta(base_layer, "Scalar Min")
-        self.fill_value = scalar_min
-        context.window_manager.invoke_props_dialog(self, width=400)
-        return {'RUNNING_MODAL'}
-
-
-class FillByRange(bpy.types.Operator):
-    bl_idname = "bioxelnodes.fill_by_range"
-    bl_label = "Fill Value by Range"
-    bl_description = "Fill Value by Range"
-    bl_options = {'UNDO'}
-
-    from_min: bpy.props.FloatProperty(
-        name="From Min",
-        soft_min=0, soft_max=1024,
-        default=128,
-    )  # type: ignore
-
-    from_max: bpy.props.FloatProperty(
-        name="From Max",
-        soft_min=0, soft_max=1024,
-        default=256,
-    )  # type: ignore
-
-    fill_value: bpy.props.FloatProperty(
-        name="Fill Value",
-        soft_min=0, soft_max=1024.0,
-        default=0,
-    )  # type: ignore
-
-    invert: bpy.props.BoolProperty(
-        name="Invert Area",
-        default=True,
-    )  # type: ignore
-
-    @classmethod
-    def poll(cls, context):
-        layer = get_layer(bpy.context.active_object)
-        if layer:
-            return layer.get("bioxel_layer_type") == "scalar"
-        else:
-            return False
-
-    def execute(self, context):
-        base_layer = get_layer(bpy.context.active_object)
-
-        container = base_layer.parent
-        filled_layer_name = f"{get_layer_name(base_layer)}_{self.from_min}-{self.from_max}-Filled"
-        scalar_offset = get_layer_meta(base_layer, "Scalar Offset")
-        base_shape = get_shape(base_layer)
-
-        base_grids = get_grids(base_layer)
-        base_volume = get_volume(base_grids, 0, base_shape)
-
-        mask = (base_volume > self.from_min + scalar_offset) \
-            & (base_volume < self.from_max + scalar_offset)
-        mask = scipy.median_filter(mask.astype(np.float32), size=2)
-
-        if self.invert:
-            base_volume = mask * base_volume + \
-                (1-mask) * (self.fill_value + scalar_offset)
-        else:
-            base_volume = (1-mask) * base_volume + \
-                mask * (self.fill_value + scalar_offset)
-
-        set_volume(base_grids, 0, base_volume)
-        vdb_path = save_vdb(base_grids, context)
-        filled_layer = deep_copy_layer(vdb_path,
-                                       base_layer,
-                                       f"{container.name}_{filled_layer_name}")
-        mask_node = add_mask_node(container,
-                                  filled_layer,
-                                  "BioxelNodes_MaskByThreshold",
-                                  filled_layer_name)
-
-        mask_node.inputs[1].default_value = self.from_min
-
-        select_object(container)
-
-        return {'FINISHED'}
-
-    def invoke(self, context, event):
-        base_layer = get_layer(bpy.context.active_object)
-        scalar_min = get_layer_meta(base_layer, "Scalar Min")
-        self.fill_value = scalar_min
-        context.window_manager.invoke_props_dialog(self, width=400)
-        return {'RUNNING_MODAL'}
-
-
-class FillByLabel(bpy.types.Operator):
-    bl_idname = "bioxelnodes.fill_by_label"
-    bl_label = "Fill Value by Label"
-    bl_description = "Fill Value by Label Area"
-    bl_options = {'UNDO'}
-
-    label_layer: bpy.props.EnumProperty(
-        name="Label Layer",
-        items=get_label_layer_selection
-    )  # type: ignore
-
-    fill_value: bpy.props.FloatProperty(
-        name="Fill Value",
-        soft_min=0, soft_max=1024.0,
-        default=0,
-    )  # type: ignore
-
-    invert: bpy.props.BoolProperty(
-        name="Invert Label",
-        default=True,
-    )  # type: ignore
-
-    @classmethod
-    def poll(cls, context):
-        layer = get_layer(bpy.context.active_object)
-        if layer:
-            return layer.get("bioxel_layer_type") == "scalar"
-        else:
-            return False
-
-    def execute(self, context):
-        base_layer = get_layer(bpy.context.active_object)
-        label_layer = bpy.data.objects[self.label_layer]
-
-        if not label_layer:
-            self.report({"WARNING"}, "Cannot find any label layer.")
-            return {'FINISHED'}
-
-        container = base_layer.parent
-        filled_layer_name = f"{get_layer_name(base_layer)}_{get_layer_name(label_layer)}-Filled"
-        scalar_offset = get_layer_meta(base_layer, "Scalar Offset")
-        base_shape = get_shape(base_layer)
-        label_shape = get_shape(label_layer)
-
-        base_grids = get_grids(base_layer)
-        base_volume = get_volume(base_grids, 0, base_shape)
-
-        label_grids = get_grids(label_layer)
-        mask = get_volume(label_grids, 0, label_shape)
-        mask = ski.resize(mask,
-                          base_shape,
-                          preserve_range=True,
-                          anti_aliasing=True)
-        mask = scipy.median_filter(mask.astype(np.float32), size=2)
-
-        if self.invert:
-            base_volume = mask * base_volume + \
-                (1-mask) * (self.fill_value + scalar_offset)
-        else:
-            base_volume = (1-mask) * base_volume + \
-                mask * (self.fill_value + scalar_offset)
-
-        set_volume(base_grids, 0, base_volume)
-        vdb_path = save_vdb(base_grids, context)
-        filled_layer = deep_copy_layer(vdb_path,
-                                       base_layer,
-                                       f"{container.name}_{filled_layer_name}")
-        add_mask_node(container,
-                      filled_layer,
-                      "BioxelNodes_MaskByThreshold",
-                      filled_layer_name)
-
-        select_object(container)
-
-        return {'FINISHED'}
-
-    def invoke(self, context, event):
-        base_layer = get_layer(bpy.context.active_object)
-        scalar_min = get_layer_meta(base_layer, "Scalar Min")
-        self.fill_value = scalar_min
-        context.window_manager.invoke_props_dialog(self, width=400)
-        return {'RUNNING_MODAL'}
-
-
-class CombineLabels(bpy.types.Operator):
-    bl_idname = "bioxelnodes.combine_labels"
-    bl_label = "Combine Labels"
-    bl_description = "Combine all selected labels"
-    bl_options = {'UNDO'}
-
-    @classmethod
-    def poll(cls, context):
-        labels = [obj for obj in context.selected_ids
-                  if obj.get("bioxel_layer_type") == "label"]
-        return True if len(labels) > 1 else False
-
-    def execute(self, context):
-        labels = [obj for obj in context.selected_ids
-                  if obj.get("bioxel_layer_type") == "label"]
-        base_layer = labels[0]
-        labels = labels[1:]
-        container = base_layer.parent
-        label_names = [get_layer_name(base_layer)]
-        base_shape = get_shape(base_layer)
-
-        base_grids = get_grids(base_layer)
-        base_volume = get_volume(base_grids, 0, base_shape)
-        base_volume = base_volume
-
-        for label in labels:
-            label_shape = get_shape(label)
-            label_grids = get_grids(label)
-            label_volume = get_volume(label_grids, 0, label_shape)
-            label_volume = ski.resize(label_volume,
-                                      base_shape,
-                                      preserve_range=True,
-                                      anti_aliasing=True)
-            base_volume = np.maximum(base_volume, label_volume)
-            label_names.append(get_layer_name(label))
-
-        set_volume(base_grids, 0, base_volume)
-
-        combined_layer_name = f"{'-'.join(label_names)}-Combined"
-        vdb_path = save_vdb(base_grids, context)
-        combined_layer = deep_copy_layer(vdb_path,
-                                         base_layer,
-                                         f"{container.name}_{combined_layer_name}")
-        add_mask_node(container,
-                      combined_layer,
-                      "BioxelNodes_MaskByLabel",
-                      combined_layer_name)
-
-        select_object(container)
-        return {'FINISHED'}
-
-
-class ConvertToMesh(bpy.types.Operator):
-    bl_idname = "bioxelnodes.convert_to_mesh"
-    bl_label = "Convert To Mesh"
-    bl_description = "Convert Container To Mesh"
-    bl_options = {'UNDO'}
-
-    @classmethod
-    def poll(cls, context):
-        containers = get_container_from_selection()
-        return len(containers) > 0
-
-    def execute(self, context):
-        containers = get_container_from_selection()
-
-        if len(containers) == 0:
-            self.report({"WARNING"}, "Cannot find any bioxel container.")
-            return {'FINISHED'}
-
-        container = containers[0]
-
-        bpy.ops.mesh.primitive_cube_add(
-            size=2, enter_editmode=False, align='WORLD', location=(0, 0, 0), scale=(1, 1, 1))
-        mesh = bpy.context.active_object
-
-        mesh.name = f"Mesh_{container.name}"
-
-        # bpy.ops.object.constraint_add(type='COPY_TRANSFORMS')
-        # mesh.constraints[0].target = container
-
-        bpy.ops.node.new_geometry_nodes_modifier()
-        modifier = mesh.modifiers[0]
-        node_group = modifier.node_group
-
-        output_node = get_nodes_by_type(node_group, 'NodeGroupOutput')[0]
-        to_mesh_node = custom_nodes.add_node(node_group,
-                                             "BioxelNodes_PickMesh")
-
-        to_mesh_node.inputs[0].default_value = container
-        node_group.links.new(to_mesh_node.outputs[0], output_node.inputs[0])
-
-        # bpy.ops.constraint.apply(
-        #     constraint=mesh.constraints[0].name, owner='OBJECT')
-        bpy.ops.object.modifier_apply(modifier=mesh.modifiers[0].name)
-
-        select_object(mesh)
-
-        self.report({"INFO"}, f"Successfully convert to mesh")
-
-        return {'FINISHED'}
-
-
-class PickMesh(bpy.types.Operator):
-    bl_idname = "bioxelnodes.pick_mesh"
-    bl_label = "Pick Mesh"
-    bl_description = "Pick Container Mesh"
-    bl_options = {'UNDO'}
-
-    @classmethod
-    def poll(cls, context):
-        containers = get_container_from_selection()
-        return len(containers) > 0
-
-    def execute(self, context):
-        containers = get_container_from_selection()
-
-        if len(containers) == 0:
-            self.report({"WARNING"}, "Cannot find any bioxel container.")
-            return {'FINISHED'}
-
-        container = containers[0]
-
-        bpy.ops.mesh.primitive_cube_add(
-            size=2, enter_editmode=False, align='WORLD', location=(0, 0, 0), scale=(1, 1, 1))
-        mesh = bpy.context.active_object
-
-        mesh.name = f"Mesh_{container.name}"
-
-        bpy.ops.node.new_geometry_nodes_modifier()
-        modifier = mesh.modifiers[0]
-        node_group = modifier.node_group
-
-        output_node = get_nodes_by_type(node_group, 'NodeGroupOutput')[0]
-        pick_mesh_node = custom_nodes.add_node(node_group,
-                                               "BioxelNodes_PickMesh")
-
-        pick_mesh_node.inputs[0].default_value = container
-        node_group.links.new(pick_mesh_node.outputs[0], output_node.inputs[0])
-
-        select_object(mesh)
-
-        self.report({"INFO"}, f"Successfully picked mesh")
-
-        return {'FINISHED'}
-
-
-class PickVolume(bpy.types.Operator):
-    bl_idname = "bioxelnodes.pick_volume"
-    bl_label = "Pick Volume"
-    bl_description = "Pick Container Volume"
-    bl_options = {'UNDO'}
-
-    @classmethod
-    def poll(cls, context):
-        containers = get_container_from_selection()
-        return len(containers) > 0
-
-    def execute(self, context):
-        containers = get_container_from_selection()
-
-        if len(containers) == 0:
-            self.report({"WARNING"}, "Cannot find any bioxel container.")
-            return {'FINISHED'}
-
-        container = containers[0]
-
-        bpy.ops.mesh.primitive_cube_add(
-            size=2, enter_editmode=False, align='WORLD', location=(0, 0, 0), scale=(1, 1, 1))
-        volume = bpy.context.active_object
-
-        volume.name = f"Volume_{container.name}"
-
-        bpy.ops.node.new_geometry_nodes_modifier()
-        modifier = volume.modifiers[0]
-        node_group = modifier.node_group
-
-        output_node = get_nodes_by_type(node_group, 'NodeGroupOutput')[0]
-        pick_volume_node = custom_nodes.add_node(node_group,
-                                                 "BioxelNodes_PickVolume")
-
-        pick_volume_node.inputs[0].default_value = container
-        node_group.links.new(
-            pick_volume_node.outputs[0], output_node.inputs[0])
-
-        select_object(volume)
-
-        self.report({"INFO"}, f"Successfully picked volume")
-
-        return {'FINISHED'}
-
-
-class PickBboxWire(bpy.types.Operator):
-    bl_idname = "bioxelnodes.pick_bbox_wire"
-    bl_label = "Pick Bbox Wire"
-    bl_description = "Pick Container Bbox Wire"
-    bl_options = {'UNDO'}
-
-    @classmethod
-    def poll(cls, context):
-        containers = get_container_from_selection()
-        return len(containers) > 0
-
-    def execute(self, context):
-        containers = get_container_from_selection()
-
-        if len(containers) == 0:
-            self.report({"WARNING"}, "Cannot find any bioxel container.")
-            return {'FINISHED'}
-
-        container = containers[0]
-
-        bpy.ops.mesh.primitive_cube_add(
-            size=2, enter_editmode=False, align='WORLD', location=(0, 0, 0), scale=(1, 1, 1))
-        bbox_wire = bpy.context.active_object
-
-        bbox_wire.name = f"Wire_{container.name}"
-
-        bpy.ops.node.new_geometry_nodes_modifier()
-        modifier = bbox_wire.modifiers[0]
-        node_group = modifier.node_group
-
-        output_node = get_nodes_by_type(node_group, 'NodeGroupOutput')[0]
-        pick_bbox_wire_node = custom_nodes.add_node(node_group,
-                                                    "BioxelNodes_PickBboxWire")
-
-        pick_bbox_wire_node.inputs[0].default_value = container
-        node_group.links.new(
-            pick_bbox_wire_node.outputs[0], output_node.inputs[0])
-
-        select_object(bbox_wire)
-
-        self.report({"INFO"}, f"Successfully picked bbox wire")
-
-        return {'FINISHED'}
-
-
-class AddCutter():
-    bl_options = {'UNDO'}
-
-    @classmethod
-    def poll(cls, context):
-        containers = get_container_from_selection()
-        return len(containers) > 0
-
-    def execute(self, context):
-        containers = get_container_from_selection()
-
-        if len(containers) == 0:
-            self.report({"WARNING"}, "Cannot find any bioxel container.")
-            return {'FINISHED'}
-
-        container = containers[0]
-
-        if self.object_type == "plane":
-            node_type = "BioxelNodes_PlaneObjectCutter"
-            bpy.ops.mesh.primitive_plane_add(
-                size=2, enter_editmode=False, align='WORLD', location=(0, 0, 0), scale=(1, 1, 1))
-        elif self.object_type == "cylinder":
-            node_type = "BioxelNodes_CylinderObjectCutter"
-            bpy.ops.mesh.primitive_cylinder_add(
-                radius=1, depth=2, enter_editmode=False, align='WORLD', location=(0, 0, 0), scale=(1, 1, 1))
-            bpy.context.object.rotation_euler[0] = container.rotation_euler[0]
-        elif self.object_type == "cube":
-            node_type = "BioxelNodes_CubeObjectCutter"
-            bpy.ops.mesh.primitive_cube_add(
-                size=2, enter_editmode=False, align='WORLD', location=(0, 0, 0), scale=(1, 1, 1))
-        elif self.object_type == "sphere":
-            node_type = "BioxelNodes_SphereObjectCutter"
-            bpy.ops.mesh.primitive_ico_sphere_add(
-                radius=1, enter_editmode=False, align='WORLD', location=(0, 0, 0), scale=(1, 1, 1))
-        elif self.object_type == "pie":
-            node_type = "BioxelNodes_PieObjectCutter"
-            # Create mesh
-            pie_mesh = bpy.data.meshes.new('Pie')
-
-            # Create object
-            pie = bpy.data.objects.new('Pie', pie_mesh)
-
-            # Link object to scene
-            bpy.context.scene.collection.objects.link(pie)
-            # Get a BMesh representation
-            bm = bmesh.new()   # create an empty BMesh
-            bm.from_mesh(pie_mesh)   # fill it in from a Mesh
-
-            # Hot to create vertices
-            v_0 = bm.verts.new((0.0, -1.0, 0.0))
-            v_1 = bm.verts.new((-1.0, -1.0, 1.0))
-            v_2 = bm.verts.new((0.0, 1.0, 0.0))
-            v_3 = bm.verts.new((-1.0, 1.0, 1.0))
-            v_4 = bm.verts.new((1.0, -1.0, 1.0))
-            v_5 = bm.verts.new((1.0, 1.0, 1.0))
-
-            # Initialize the index values of this sequence.
-            bm.verts.index_update()
-
-            # How to create a face
-            # it's not necessary to create the edges before, I made it only to show how create
-            # edges too
-            bm.faces.new((v_0, v_1, v_3, v_2))
-            bm.faces.new((v_0, v_2, v_5, v_4))
-
-            # Finish up, write the bmesh back to the mesh
-            bm.to_mesh(pie_mesh)
-            bpy.context.view_layer.objects.active = pie
-
-        cutter = bpy.context.active_object
-        cutter.visible_camera = False
-        cutter.visible_diffuse = False
-        cutter.visible_glossy = False
-        cutter.visible_transmission = False
-        cutter.visible_volume_scatter = False
-        cutter.visible_shadow = False
-        cutter.hide_render = True
-        cutter.display_type = 'WIRE'
-
-        modifier = container.modifiers[0]
-        node_group = modifier.node_group
-        cutter_node = custom_nodes.add_node(node_group, node_type)
-        cutter_node.inputs[0].default_value = cutter
-
-        cut_nodes = get_nodes_by_type(node_group,
-                                      'BioxelNodes_Cut')
-        output_node = get_nodes_by_type(node_group, 'NodeGroupOutput')[0]
-        if len(cut_nodes) == 0:
-            cut_node = custom_nodes.add_node(node_group, 'BioxelNodes_Cut')
-            if len(output_node.inputs[0].links) == 0:
-                node_group.links.new(cut_node.outputs[0],
-                                     output_node.inputs[0])
-                move_node_to_node(cut_node, output_node, (-300, 0))
-            else:
-                pre_output_node = output_node.inputs[0].links[0].from_node
-                node_group.links.new(pre_output_node.outputs[0],
-                                     cut_node.inputs[0])
-                node_group.links.new(cut_node.outputs[0],
-                                     output_node.inputs[0])
-                move_node_between_nodes(cut_node,
-                                        [pre_output_node, output_node])
-
-            node_group.links.new(cutter_node.outputs[0],
-                                 cut_node.inputs[1])
-
-            move_node_to_node(cutter_node, cut_node, (-300, -300))
-            select_object(cutter)
-        else:
-            move_node_to_node(cutter_node, output_node, (0, -100))
-            select_object(container)
-
-        return {'FINISHED'}
-
-
-class AddPlaneCutter(bpy.types.Operator, AddCutter):
-    bl_idname = "bioxelnodes.add_plane_cutter"
-    bl_label = "Add a Plane Cutter"
-    bl_description = "Add a Plane Cutter to Container"
-    bl_options = {'UNDO'}
-    object_type = "plane"
-
-
-class AddCylinderCutter(bpy.types.Operator, AddCutter):
-    bl_idname = "bioxelnodes.add_cylinder_cutter"
-    bl_label = "Add a Cylinder Cutter"
-    bl_description = "Add a Cylinder Cutter to Container"
-    bl_options = {'UNDO'}
-    object_type = "cylinder"
-
-
-class AddCubeCutter(bpy.types.Operator, AddCutter):
-    bl_idname = "bioxelnodes.add_cube_cutter"
-    bl_label = "Add a Cube Cutter"
-    bl_description = "Add a Cube Cutter to Container"
-    bl_options = {'UNDO'}
-    object_type = "cube"
-
-
-class AddSphereCutter(bpy.types.Operator, AddCutter):
-    bl_idname = "bioxelnodes.add_sphere_cutter"
-    bl_label = "Add a Sphere Cutter"
-    bl_description = "Add a Sphere Cutter to Container"
-    bl_options = {'UNDO'}
-    object_type = "sphere"
-
-
-class AddPieCutter(bpy.types.Operator, AddCutter):
-    bl_idname = "bioxelnodes.add_pie_cutter"
-    bl_label = "Add a Pie Cutter"
-    bl_description = "Add a Pie Cutter to Container"
-    bl_options = {'UNDO'}
-    object_type = "pie"

bioxelnodes/preferences.py

@@ -1,29 +0,0 @@
-import bpy
-from pathlib import Path
-from .externalpackage import ExternalPackagePreferences
-
-
-class BioxelNodesPreferences(bpy.types.AddonPreferences, ExternalPackagePreferences):
-    bl_idname = __package__
-
-    cache_dir: bpy.props.StringProperty(
-        name="Set Cache Directory",
-        subtype='DIR_PATH',
-        default=str(Path(Path.home(), '.bioxelnodes'))
-    )  # type: ignore
-
-    do_change_render_setting: bpy.props.BoolProperty(
-        name="Change Render Setting",
-        default=True,
-    )  # type: ignore
-
-    def draw(self, context):
-        layout = self.layout
-
-        # ExternalPackagePreferences Config
-        self.requirements_dir = str(Path(__file__).parent)
-        super().draw(context)
-
-        layout.label(text="Configuration")
-        layout.prop(self, 'cache_dir')
-        layout.prop(self, "do_change_render_setting")

bioxelnodes/props.py

@@ -1,5 +0,0 @@
-import bpy
-
-class BIOXELNODES_Series(bpy.types.PropertyGroup):
-    id: bpy.props.StringProperty()   # type: ignore
-    label: bpy.props.StringProperty()   # type: ignore

bioxelnodes/requirements.txt

@@ -1 +0,0 @@
-SimpleITK==2.3.1     # Insight Segmentation and Registration Toolkit.

bioxelnodes/save.py

@@ -1,212 +0,0 @@
-import re
-import bpy
-from pathlib import Path
-import shutil
-from .utils import copy_to_dir, get_all_layers, get_container, get_container_from_selection, get_container_layers
-from .nodes import custom_nodes
-
-CLASS_PREFIX = "BIOXELNODES_MT_NODES"
-
-
-class ReLinkNodes(bpy.types.Operator):
-    bl_idname = "bioxelnodes.relink_nodes"
-    bl_label = "Relink Nodes to Addon"
-    bl_description = "Relink all nodes to addon source"
-
-    def execute(self, context):
-        file_name = Path(custom_nodes.nodes_file).name
-        for lib in bpy.data.libraries:
-            lib_path = Path(bpy.path.abspath(lib.filepath)).resolve()
-            lib_name = lib_path.name
-            if lib_name == file_name:
-                if str(lib_path) != custom_nodes.nodes_file:
-                    lib.filepath = custom_nodes.nodes_file
-
-        self.report({"INFO"}, f"Successfully relinked.")
-
-        return {'FINISHED'}
-
-
-class SaveStagedData(bpy.types.Operator):
-    bl_idname = "bioxelnodes.save_staged_data"
-    bl_label = "Save Staged Data"
-    bl_description = "Save all staged data in this file for sharing"
-
-    save_layer: bpy.props.BoolProperty(
-        name="Save Layer VDB Cache",
-        default=True,
-    )  # type: ignore
-
-    cache_dir: bpy.props.StringProperty(
-        name="Cache Directory",
-        subtype='DIR_PATH',
-        default="//"
-    )  # type: ignore
-
-    save_lib: bpy.props.BoolProperty(
-        name="Save Node Library File",
-        default=True,
-    )  # type: ignore
-
-    lib_dir: bpy.props.StringProperty(
-        name="Library Directory",
-        subtype='DIR_PATH',
-        default="//"
-    )  # type: ignore
-
-    def execute(self, context):
-        if self.save_lib:
-            files = []
-            for classname in dir(bpy.types):
-                if CLASS_PREFIX in classname:
-                    cls = getattr(bpy.types, classname)
-                    files.append(cls.nodes_file)
-            files = list(set(files))
-
-            for file in files:
-                file_name = Path(file).name
-                # "//"
-                lib_dir = bpy.path.abspath(self.lib_dir)
-
-                output_path: Path = Path(lib_dir, file_name).resolve()
-                source_path: Path = Path(file).resolve()
-
-                if output_path != source_path:
-                    shutil.copy(source_path, output_path)
-
-                for lib in bpy.data.libraries:
-                    lib_path = Path(bpy.path.abspath(lib.filepath)).resolve()
-                    if lib_path == source_path:
-                        blend_path = Path(bpy.path.abspath("//")).resolve()
-                        lib.filepath = bpy.path.relpath(
-                            str(output_path), start=str(blend_path))
-
-                self.report({"INFO"}, f"Successfully saved to {output_path}")
-
-        if self.save_layer:
-            fails = []
-            for layer in get_all_layers():
-                try:
-                    save_layer(layer, self.cache_dir)
-                except:
-                    fails.append(layer)
-
-            if len(fails) == 0:
-                self.report({"INFO"}, f"Successfully saved bioxel layers.")
-            else:
-                self.report(
-                    {"WARNING"}, f"{','.join([layer.name for layer in fails])} fail to save.")
-
-        return {'FINISHED'}
-
-    def invoke(self, context, event):
-        context.window_manager.invoke_props_dialog(self,
-                                                   width=500)
-        return {'RUNNING_MODAL'}
-
-    @classmethod
-    def poll(cls, context):
-        return bpy.data.is_saved
-
-    def draw(self, context):
-        layout = self.layout
-        panel = layout.box()
-        panel.prop(self, "save_layer")
-        panel.prop(self, "cache_dir")
-        panel = layout.box()
-        panel.prop(self, "save_lib")
-        panel.prop(self, "lib_dir")
-
-
-def save_layer(layer, output_dir):
-
-    pattern = r'\.\d{4}\.'
-
-    # "//"
-    output_dir = bpy.path.abspath(output_dir)
-    source_dir = bpy.path.abspath(layer.data.filepath)
-
-    source_path: Path = Path(source_dir).resolve()
-    is_sequence = re.search(pattern, source_path.name) is not None
-    name = layer.name if is_sequence else f"{layer.name}.vdb"
-    output_path: Path = Path(output_dir, name, source_path.name).resolve() \
-        if is_sequence else Path(output_dir, name).resolve()
-
-    if output_path != source_path:
-        copy_to_dir(source_path.parent if is_sequence else source_path,
-                    output_path.parent.parent if is_sequence else output_path.parent,
-                    new_name=name)
-
-    blend_path = Path(bpy.path.abspath("//")).resolve()
-
-    layer.data.filepath = bpy.path.relpath(
-        str(output_path), start=str(blend_path))
-
-
-class SaveLayers(bpy.types.Operator):
-    bl_idname = "bioxelnodes.save_layers"
-    bl_label = "Save Layers"
-    bl_description = "Save Container Layers to Directory."
-
-    cache_dir: bpy.props.StringProperty(
-        name="Layer Directory",
-        subtype='DIR_PATH',
-        default="//"
-    )  # type: ignore
-
-    @classmethod
-    def poll(cls, context):
-        containers = get_container_from_selection()
-        return len(containers) > 0
-
-    def execute(self, context):
-        containers = get_container_from_selection()
-
-        if len(containers) == 0:
-            self.report({"WARNING"}, "Cannot find any bioxel container.")
-            return {'FINISHED'}
-
-        fails = []
-        for container in containers:
-            for layer in get_container_layers(container):
-                try:
-                    save_layer(layer, self.cache_dir)
-                except:
-                    fails.append(layer)
-
-        if len(fails) == 0:
-            self.report({"INFO"}, f"Successfully saved bioxel layers.")
-        else:
-            self.report(
-                {"WARNING"}, f"{','.join([layer.name for layer in fails])} fail to save.")
-
-        return {'FINISHED'}
-
-    def invoke(self, context, event):
-        context.window_manager.invoke_props_dialog(self,
-                                                   width=500)
-        return {'RUNNING_MODAL'}
-
-
-class CleanAllCaches(bpy.types.Operator):
-    bl_idname = "bioxelnodes.clear_all_caches"
-    bl_label = "Clean All Caches in Temp"
-    bl_description = "Clean all caches saved in temp"
-
-    def execute(self, context):
-        preferences = context.preferences.addons[__package__].preferences
-        cache_dir = Path(preferences.cache_dir, 'VDBs')
-        try:
-            shutil.rmtree(cache_dir)
-            self.report({"INFO"}, f"Successfully cleaned caches.")
-            return {'FINISHED'}
-        except:
-            self.report({"WARNING"},
-                        "Fail to clean caches, you may do it manually.")
-            return {'CANCELLED'}
-
-    def invoke(self, context, event):
-        context.window_manager.invoke_confirm(self,
-                                              event,
-                                              message="All caches will be cleaned, include other project files, do you still want to clean?")
-        return {'RUNNING_MODAL'}

bioxelnodes/scipy/__init__.py

@@ -1,2 +0,0 @@
-from ._interpolation import zoom
-from ._filters import gaussian_filter, median_filter

bioxelnodes/utils.py

@@ -1,287 +0,0 @@
-import bpy
-import mathutils
-from pathlib import Path
-import pyopenvdb as vdb
-from uuid import uuid4
-import shutil
-
-
-def select_object(target_obj):
-    for obj in bpy.data.objects:
-        obj.select_set(False)
-
-    target_obj.select_set(True)
-    bpy.context.view_layer.objects.active = target_obj
-
-
-def copy_to_dir(source_path, dir_path, new_name=None, exist_ok=True):
-    source = Path(source_path)
-    target = Path(dir_path)
-
-    # Check if the source exists
-    if not source.exists():
-        raise FileNotFoundError
-
-    # Check if the target exists
-    if not target.exists():
-        target.mkdir(parents=True, exist_ok=True)
-
-    target_path = target / new_name if new_name else target / source.name
-    # If source is a file, copy it to the target directory
-    if source.is_file():
-        try:
-            shutil.copy(source, target_path)
-        except shutil.SameFileError:
-            if exist_ok:
-                pass
-            else:
-                raise shutil.SameFileError
-    # If source is a directory, copy its contents to the target directory
-    elif source.is_dir():
-        shutil.copytree(source, target_path, dirs_exist_ok=exist_ok)
-
-    if not target_path.exists():
-        raise Exception
-
-
-def move_node_to_node(node, target_node, offset=(0, 0)):
-    node.location.x = target_node.location.x + offset[0]
-    node.location.y = target_node.location.y + offset[1]
-
-
-def move_node_between_nodes(node, target_nodes, offset=(0, 0)):
-    xs = []
-    ys = []
-    for target_node in target_nodes:
-        xs.append(target_node.location.x)
-        ys.append(target_node.location.y)
-
-    node.location.x = sum(xs) / len(xs) + offset[0]
-    node.location.y = sum(ys) / len(ys) + offset[1]
-
-
-def get_node_type(node):
-    node_type = type(node).__name__
-    if node_type == "GeometryNodeGroup":
-        node_type = node.node_tree.name
-
-    return node_type
-
-
-def get_nodes_by_type(node_group, type_name: str):
-    return [node for node in node_group.nodes if get_node_type(node) == type_name]
-
-
-def show_message(message="", title="Message Box", icon='INFO'):
-
-    def draw(self, context):
-        self.layout.label(text=message)
-
-    bpy.context.window_manager.popup_menu(draw, title=title, icon=icon)
-
-
-def calc_bbox_verts(origin, size):
-    bbox_origin = mathutils.Vector(
-        (origin[0], origin[1], origin[2]))
-    bbox_size = mathutils.Vector(
-        (size[0], size[1], size[2]))
-    bbox_verts = [
-        (
-            bbox_origin[0] + 0,
-            bbox_origin[1] + 0,
-            bbox_origin[2] + 0
-        ),
-        (
-            bbox_origin[0] + 0,
-            bbox_origin[1] + 0,
-            bbox_origin[2] + bbox_size[2]
-        ),
-        (
-            bbox_origin[0] + 0,
-            bbox_origin[1] + bbox_size[1],
-            bbox_origin[2] + 0
-        ),
-        (
-            bbox_origin[0] + 0,
-            bbox_origin[1] + bbox_size[1],
-            bbox_origin[2] + bbox_size[2]
-        ),
-        (
-            bbox_origin[0] + bbox_size[0],
-            bbox_origin[1] + 0,
-            bbox_origin[2] + 0
-        ),
-        (
-            bbox_origin[0] + bbox_size[0],
-            bbox_origin[1] + 0,
-            bbox_origin[2] + bbox_size[2],
-        ),
-        (
-            bbox_origin[0] + bbox_size[0],
-            bbox_origin[1] + bbox_size[1],
-            bbox_origin[2] + 0,
-        ),
-        (
-            bbox_origin[0] + bbox_size[0],
-            bbox_origin[1] + bbox_size[1],
-            bbox_origin[2] + bbox_size[2],
-        ),
-    ]
-    return bbox_verts
-
-
-def lock_transform(obj):
-    obj.lock_location[0] = True
-    obj.lock_location[1] = True
-    obj.lock_location[2] = True
-    obj.lock_rotation[0] = True
-    obj.lock_rotation[1] = True
-    obj.lock_rotation[2] = True
-    obj.lock_scale[0] = True
-    obj.lock_scale[1] = True
-    obj.lock_scale[2] = True
-
-
-def hide_in_ray(obj):
-    obj.visible_camera = False
-    obj.visible_diffuse = False
-    obj.visible_glossy = False
-    obj.visible_transmission = False
-    obj.visible_volume_scatter = False
-    obj.visible_shadow = False
-
-
-def save_vdb(grids, context):
-    preferences = context.preferences.addons[__package__].preferences
-    cache_dir = Path(preferences.cache_dir, 'VDBs')
-    cache_dir.mkdir(parents=True, exist_ok=True)
-
-    vdb_path = Path(cache_dir, f"{uuid4()}.vdb")
-    print(f"Storing the VDB file ({str(vdb_path)})...")
-    vdb.write(str(vdb_path), grids=grids)
-
-    return vdb_path
-
-
-def save_vdbs(grids_sequence, context):
-    preferences = context.preferences.addons[__package__].preferences
-    cache_dir = Path(preferences.cache_dir, 'VDBs')
-    cache_dir.mkdir(parents=True, exist_ok=True)
-    vdb_name = str(uuid4())
-    vdb_dir_path = Path(cache_dir, vdb_name)
-    vdb_dir_path.mkdir(parents=True, exist_ok=True)
-
-    vdb_paths = []
-    for f, grids in enumerate(grids_sequence):
-        vdb_path = Path(vdb_dir_path, f"{vdb_name}.{str(f+1).zfill(4)}.vdb")
-        print(f"Storing the VDB file ({str(vdb_path)})...")
-        vdb.write(str(vdb_path), grids=grids)
-        vdb_paths.append(vdb_path)
-
-    return vdb_paths
-
-
-def get_container_from_selection():
-    containers = []
-    for obj in bpy.context.selected_objects:
-        if get_container(obj):
-            containers.append(obj)
-    # if bpy.context.active_object:
-    #     if bpy.context.active_object.get('bioxel_layer'):
-    #         if bpy.context.active_object.parent.get('bioxel_container'):
-    #             containers.append(bpy.context.active_object.parent)
-
-    return list(set(containers))
-
-
-def get_container(current_obj):
-    if current_obj:
-        if current_obj.get('bioxel_container'):
-            return current_obj
-        elif current_obj.get('bioxel_layer'):
-            parent = current_obj.parent
-            return parent if parent.get('bioxel_container') else None
-    return None
-
-
-def get_layer(current_obj):
-    if current_obj:
-        if current_obj.get('bioxel_layer') and current_obj.parent:
-            if current_obj.parent.get('bioxel_container'):
-                return current_obj
-    return None
-
-
-def get_container_layers(container):
-    layers = []
-    for obj in bpy.data.objects:
-        if obj.parent == container and get_layer(obj):
-            layers.append(obj)
-
-    return layers
-
-
-def get_all_layers():
-    layers = []
-    for obj in bpy.data.objects:
-        if get_layer(obj):
-            layers.append(obj)
-
-    return layers
-
-
-def get_text_index_str(text):
-    # Initialize an empty string to store the digits
-    digits = ""
-
-    # Iterate through the characters in reverse order
-    started = False
-    for char in text[::-1]:
-        if char.isdigit():
-            started = True
-            # If the character is a digit, add it to the digits string
-            digits += char
-        else:
-            if started:
-                # If a non-digit character is encountered, stop the loop
-                break
-
-    # Reverse the digits string to get the correct order
-    last_number = digits[::-1]
-
-    return last_number
-
-
-def add_driver(target_prop, var_sources, expression):
-
-    driver = target_prop.driver_add("default_value")
-    is_vector = isinstance(driver, list)
-    drivers = driver if is_vector else [driver]
-
-    for i, driver in enumerate(drivers):
-        for j, var_source in enumerate(var_sources):
-
-            source = var_source['source']
-            prop = var_source['prop']
-
-            var = driver.driver.variables.new()
-            var.name = f"var{j}"
-
-            var.targets[0].id_type = source.id_type
-            var.targets[0].id = source
-            var.targets[0].data_path = f'["{prop}"][{i}]'\
-                if is_vector else f'["{prop}"]'
-
-        driver.driver.expression = expression
-
-
-def add_direct_driver(target, target_prop, source, source_prop):
-    target_prop = target.inputs.get(target_prop)
-    drivers = [
-        {
-            "source": source,
-            "prop": source_prop
-        }
-    ]
-    expression = "var0"
-    add_driver(target_prop, drivers, expression)

build.py

@@ -0,0 +1,90 @@
+from pathlib import Path
+import shutil
+import subprocess
+import sys
+from dataclasses import dataclass
+import tomlkit
+
+
+@dataclass
+class Platform:
+    pypi_suffix: str
+    blender_tag: str
+
+
+required_packages = ["SimpleITK==2.3.1",
+                     "pyometiff==1.0.0",
+                     "mrcfile==1.5.1",
+                     "h5py==3.11.0",
+                     "transforms3d==0.4.2",
+                     "tifffile==2024.7.24"]
+
+
+platforms = {"windows-x64": Platform(pypi_suffix="win_amd64",
+                                     blender_tag="windows-x64"),
+             "linux-x64": Platform(pypi_suffix="manylinux2014_x86_64",
+                                   blender_tag="linux-x64"),
+             "macos-arm64": Platform(pypi_suffix="macosx_12_0_arm64",
+                                     blender_tag="macos-arm64"),
+             "macos-x64": Platform(pypi_suffix="macosx_10_16_x86_64",
+                                   blender_tag="macos-x64")}
+
+packages_to_remove = {
+    "imagecodecs",
+    "numpy"
+}
+
+
+def run_python(args: str):
+    python = Path(sys.executable).resolve()
+    subprocess.run([python] + args.split(" "))
+
+
+def build_extension(platform: Platform, python_version="3.11") -> None:
+    wheel_dirpath = Path("./src/bioxelnodes/wheels")
+    toml_filepath = Path("./src/bioxelnodes/blender_manifest.toml")
+    scipy_ndimage_dirpath = Path("./scipy_ndimage", platform.blender_tag)
+
+    # download required_packages
+    run_python(
+        f"-m pip download {' '.join(required_packages)} --dest {wheel_dirpath.as_posix()} --only-binary=:all: --python-version={python_version} --platform={platform.pypi_suffix}"
+    )
+
+    for f in wheel_dirpath.glob('*.whl'):
+        if any([package in f.name for package in packages_to_remove]):
+            f.unlink(missing_ok=True)
+
+        elif platform.blender_tag == "macos-arm64" and \
+                "lxml" in f.name and "universal2" in f.name:
+            f.rename(Path(f.parent,
+                          f.name.replace("universal2", "arm64")))
+
+    for ndimage_filepath in scipy_ndimage_dirpath.iterdir():
+        to_filepath = Path("./src/bioxelnodes/bioxel/scipy", ndimage_filepath.name)
+        shutil.copy(ndimage_filepath, to_filepath)
+
+    # Load the TOML file
+    with toml_filepath.open("r") as file:
+        manifest = tomlkit.parse(file.read())
+
+    manifest["platforms"] = [platform.blender_tag]
+    manifest["wheels"] = [f"./wheels/{f.name}"
+                          for f in wheel_dirpath.glob('*.whl')]
+
+    # build.append('generated', generated)
+    # manifest.append('build', build)
+
+    # Write the updated TOML file
+    with toml_filepath.open("w") as file:
+        text = tomlkit.dumps(manifest)
+        file.write(text)
+
+
+def main():
+    platform_name = sys.argv[1]
+    platform = platforms[platform_name]
+    build_extension(platform)
+
+
+if __name__ == "__main__":
+    main()

docs/SARS-Cov-2.md

@@ -0,0 +1,99 @@
+# SARS-Cov-2
+
+![alt text](assets/SARS-Cov-2/image.png)
+
+![alt text](assets/SARS-Cov-2/image-1.png)
+
+In this tutorial, we'll make a structural visualzation of the SARS-Cov-2 Virus. Please see [step by step](step_by_step.md) to make sure you have a basic understanding of how to use the addon, and make sure the addon version is v1.0.2 or higher!
+
+Research data is from paper published in September 2020 in Cell Press ([https://www.cell.com/cell/fulltext/S0092-8674(20)31159-4](<https://www.cell.com/cell/fulltext/S0092-8674(20)31159-4>)) by Li Sai team at Tsinghua University. This research revealed the molecular assembly of the authentic SARS-CoV-2 virus using cryoelectron tomography (cryo-ET) and subtomogram averaging (STA). Here is an official video of this study
+
+<iframe width="560" height="315" src="https://www.youtube.com/embed/JSKl5VY4k5w?si=t4LhrCRebxrX_Saf&amp;controls=0" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" referrerpolicy="strict-origin-when-cross-origin" allowfullscreen></iframe>
+
+"It remains enigmatic how coronaviruses pack the ∼30-kb RNA into the ∼80-nm-diameter viral lumen. Are the RNPs ordered relative to each other to avoid RNA entangling, knotting, or even damage or are they involved in virus assembly?" Three assembly classes were proposed in the paper, we will make a visualzation of the "eggs-in-a-nest"-shaped RNPs assembly, based on real cryo-ET data.
+
+## Download and import data
+
+The data of this research is hosted on EMDB ([https://www.ebi.ac.uk/emdb](https://www.ebi.ac.uk/emdb)), and the website of SARS-Cov-2 virus is [here](https://www.ebi.ac.uk/emdb/EMD-30430). Open the page, find "Download" button and select the first selection "3D Volume (.map.gz)".
+
+In case you can't download data, you can download here.
+
+[SARS-Cov-2.map](https://drive.google.com/file/d/1LMybsmTVbwQ38_eqAx6hbZTc5p2fdcjK/view?usp=sharing)
+
+After downloading, put it into any directory and import the data. In the import options, it is recommended to adjust the Bioxel Size to 5, in order to reduce the shape of the data to increase the speed of calculation and rendering. If you are confident in the performance of your hardware, you can leave the original 2.72 unchanged. After adjusting the Bioxel Size, the shape of the converted data will be calculated below based on the current bioxel size. The amount of data will increase exponentially with larger shape, and may result in OOM (out of memory).
+
+## Cutout the Virus
+
+After importing, you can get the virus by creating and connecting nodes and setting parameters as shown below
+
+![alt text](assets/SARS-Cov-2/image-2.png)
+
+Place the light and the camera in the way as below. The backlight is a area light, color white, intensity 500W, spread 90°, and inside the virus, place a point light, color `FFD08D`, intensity 5W. Camera focal length is 200 mm. the background color is pure black. The Look of the color management is High Contrast.
+
+![alt text](assets/SARS-Cov-2/image-3.png)
+
+Continue editing the node, followed by "Set Properies" and "Set Color by Ramp 4" node, the parameters of these two nodes are set as shown in the figure, where the color part, from top to bottom, is set to `E1D0FC` (1.0), `FFE42D` (0.5), `3793FF` (0.5), `FFFF8EC` (0.1) (alpha value in parentheses). Color alpha also affects density.
+
+![alt text](assets/SARS-Cov-2/image-4.png)
+
+If you feel that rendering is too slow, see [here](improve_performance.md) for suggestions
+
+## Color the RNPs alone
+
+The current rendering is pretty good, but considering that my goal is to make it clear how the RNPs are arranged within the virus, the RNPs should be colored differently than the others. So how to color the RNPs alone?
+
+First of all, we have to separate the RNPs. The value of RNPs is between the membrane and S protein, so it is very difficult to separate. The good thing is that the virus is spherical, we can separate the RNPs part of the virus from the rest by using a sphere cutter. To do so, in the Geometry Nodes panel menu of the container, click **Bioxel Nodes > Add a Cutter > Sphere Cutter**, and adjust the scale and position of the newly created sphere object named "Sphere_Cutter" appropriately, so that it can just separate the internal RNPs and membrane of the virus.
+
+![alt text](assets/SARS-Cov-2/image-5.png)
+
+The process of changing the position of the "Sphere_Cutter" object can be very laggy, then you can turn off "With Surface" and do it in Slice Viewer mode. Once you are happy with it, you can restore the settings.
+
+Then we turn on Invert in the "Sphere Cutter" node and you can see the opposite result. This way we've managed to separate the two, next let's color them separately and finally merge them with Join Component. Create and join the nodes as shown below, where the second Cutter node is copied and the color value in Set Color is `FFDDFE` (0.5). If all is well, the rendering should look like below.
+
+![alt text](assets/SARS-Cov-2/image-6.png)
+
+At this point, the rendering of a SARS-Cov-2 virus is complete!
+
+## Render RNPs and Membranes
+
+Realistic rendering is great, but Non-photorealistic rendering (NPR) is better for presenting structural information. So I will render ultrastructure of the RNPs assembly with toon shader.
+
+![alt text](assets/SARS-Cov-2/image-7.png)
+
+The silhouettes of RNPs uses Blender's Line Art feature, but Line Art must be based on a mesh. Select the nodes that are extruding the RNPs (i.e., the "Cut" nodes that are in charge of cutting out the RNPs), and right-click, click **Bioxel Nodes > Extract Mesh**. This gives you a new mesh object of the RNPs.
+
+Extract the membrane mesh in the same way.
+
+The membrane has a much higher value than the rest of the virus, so let's create a new "Cutout" node, also after the ReCenter, but with the threshold adjusted to 0.13. After the Cutout, connect to the "To Surface" node and parameterize it as shown in the figure, noting that the Remove Island Threshold is set to 1000 so that any fragments smaller than 1000 pts be eliminated. Then select the "To Surface" node, and perform the operation of extracting the mesh.
+
+![alt text](assets/SARS-Cov-2/image-8.png)
+
+The mesh of the membrane needs to be cut in half, this can be done with the Box Trim brush in sculpt mode or with the Boolean modifier. the mesh of the RNPs may also need some repair work, I cleaned up some of the broken surfaces of the RNPs. all the meshes are now ready to be used.
+
+![alt text](assets/SARS-Cov-2/image-9.png)
+
+For Line Art, please see the video tutorial from Blender Secrets.
+
+<iframe width="560" height="315" src="https://www.youtube.com/embed/aIWdBq7-ias?si=CrcStx5VVJBwDpzu&amp;controls=0" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" referrerpolicy="strict-origin-when-cross-origin" allowfullscreen></iframe>
+
+Finally, an infographic on the ultrastructure of RNPs is done!
+
+![alt text](assets/SARS-Cov-2/image-1.png)
+
+If you have trouble following the docs, you can download the project files.
+
+[SARS-Cov-2.zip](https://drive.google.com/file/d/15GpIoIjVAE-Jr98zWo7oupuk1KfRVPmk/view?usp=sharing)
+
+## Homework
+
+Other data relevant to the study are provided in the paper, you could try visualizing them.
+
+![alt text](assets/SARS-Cov-2/image-10.png)
+
+Go to the official EMDB website https://www.ebi.ac.uk/emdb/ and enter the EMD number in the search box to get them.
+
+The Electron Microscopy Data Bank (EMDB) is a public repository for cryogenic-sample Electron Microscopy (cryoEM) volumes and representative tomograms of macromolecular complexes and subcellular structures. If you want to get data on other virus, just enter their name in the search box. For example, hepatitis B virus, enter it into the search box, then select Virus in the Sample Type on the left side, and download the data you need (it is better to find the corresponding paper to clarify the data information).
+
+**Try to visualize hepatitis B virus.**
+
+![alt text](assets/SARS-Cov-2/image-11.png)

docs/advanced_usage.md

@@ -0,0 +1,118 @@
+# Advanced Usage
+
+## Concepts
+
+In the previous section, I mentioned some key concepts, I'll describe them in detail so that you can better understand the following operations.
+
+### Container
+
+First is the **Container**, it is the easiest to describe, you can think of it as a scene, or a solver container. it is the stage that carries all stuffs.
+
+### Layer
+
+Second is the **Layer**, which represents different fields of data under the same location in container of the same subject. Just as view layers in any map app, one as roads, one as satellite view, while in Bioxel, one as MRI, one as CT, one as electrical signals, etc. Some layers are for material, such as color, density, etc., we call them **Material Layer**. One container contains different layers of one subject each. Any external data imported into the container is converted into the layer.
+
+### Component
+
+Finally, the **Component**, which is a fragment of **Material Layer**. Multiple materials (Matters) may exist within the same area with different meanings of presentation, like objects in blender, each representing a part of the scene. Bioxel Nodes provides a series of nodes and tools that allow the user to create material layers (Components) based on the other layers (serve as source data), In the previous section, we used the CT data (layer) to make the material (matter) of skull, this process known as materialization.
+
+## Attache the Muscles to the Skull
+
+Multiple components can exist in one container, just as multiple objects can exist in one scene. They can be controlled individually or combined with each other to build complex scenes. Next, let's try cutouting muscle from the VHP anatomical images and attaching the muscles to the skull that created in the previous section. The anatomical images are very large, so I've cropped and scaled them down to 1/4 of their original size for ease of use. Download the file and unzip it into a new directory.
+
+[VHP_M_AnatomicalImages_Head.zip](https://drive.google.com/file/d/164AjQX0tmgUpWZlleJ5i1IKHco4ytDu2/view?usp=drive_link)
+
+You can also download the data directly from the official website, [https://data.lhncbc.nlm.nih.gov/public/Visible-Human/Male-Images/PNG_format/head/index.html](https://data.lhncbc.nlm.nih.gov/public/Visible-Human/Male-Images/PNG_format/head/index.html)
+
+First import the CT data as described in [step by step](step_by_step.md). Then import the anatomical images, but unlike before, this time from the Geometry Nodes menu of the existing container (not the top menu), click **Bioxel Nodes > Import Volumetric Data (Init) > as Color**, locate to the unzipped folder, and select any .png file (do not multi-select, and do not select the folder). This way the imported layer will be in the same container as the previous CT data. You can also import by dragging it into the container geometry node interface instead of the 3D Viewport interface. Also note that **as Color** (not as Scalar) is clicked because the anatomical images are RGB data.
+
+![alt text](assets/advanced_usage/image.png)
+
+Let's take more time in the import options this time 🫡, first let's talk about what the **Original Spacing** is in the options, you can simply think of it as the original "pixel size" of a image, since the volume is 3D, its pixels (i.e., voxels) are cuboids with a length, width, and height rather than 2D rectangles. And their length, width, and height size is the **Spacing**.
+
+Normally, Bioxel Nodes can read the spacing from the data header, and you don't need to fill in the value, but there is no record of that in any PNG image, so you need to input it manually. in the official description of the VHP, it is mentioned that each pixel of the anatomical images corresponds to the size of .33mm, and the thickness of each slice is 1mm, so the Original Spacing of the anatomical images should be set to `(0.33, 0.33, 1)`.
+
+However, the file I provided is scaled by 1/4 for each image, so the X and Y axes need to be multiplied by 4. So the final Original Spacing should be set to `(1.33, 1.33, 1)`, which should be understandable, right? (If you are importing an official file, then it should still be set to `(0.33, 0.33, 1)`)
+Layer Name should be set to "Anatomical Images", other options remain default, click Ok.
+
+![alt text](assets/advanced_usage/image-1.png)
+
+After importing, connect the "Cutout by Hue" node (Add > Bioxel Nodes > Component > Cutout by Hue) after the newly created "Fetch Layer" node, and turn on the Slice Viewer mode preview, as shown below.
+
+![alt text](assets/advanced_usage/image-2.png)
+
+In addition to spacing, the Dicom file also records the subject's position and orientation, but those information is apparently not recorded in PNG format. This results in a mismatch between the CT data and the anatomical images in position. We need to manually align this two layers: First, set the threshold of the "Cutout by Threshold" node to 0.2 so that the full head can be cutouted and displayed. Then add "ReCenter" node before "Cutout by Hue" node and "Cutout by Threshold" node each, then add Locater to the "anatomical images" workflow (see [step by step](step_by_step.md) for details), and finally add "Join Component" node (Add > Bioxel Nodes > Component > Join Component), and connect them as shown below, with the parameters set as shown.
+
+![alt text](assets/advanced_usage/image-3.png)
+
+The "Join Component" node allows you to merge two components together. Move and rotate the Locater object so that the two components are exactly the same in position. If you're having trouble matching them up, here's the exact transform values to fill in the Locater object properties.
+
+![alt text](assets/advanced_usage/image-4.png)
+
+Next let's cutout the muscles individually.
+
+First let's talk about the "Cutout by Hue" node. Literally, it cutout regions by hue of color. If you select this node and press "M" key to temporarily mute it, you'll see that the data becomes a cube with blue parts in Slice Viewer mode. the default value of Hue in the "Cutout by Hue" node is red, meaning that the node retains areas of the body that are close to red, and strip out the blue, which is on the opposite side of the red in the hue ring, leaving the human body parts.
+
+If you turn down the value of Sensitivity, you'll see that the visabile part is decreasing, leaving only the part more closer to red, and the muscle happens to be red, so we can easily cutout the muscle. The color of the specimen tissue is not as vibrant as it is in the live state, and we can fine-tune the color to restore the vibrancy by using the "Set Color by Color" node (Add > Bioxel Nodes > Property > Set Color by Color).
+
+To finally put it all together, connect and set the nodes as shown below, where the two colors in "Set Color by Ramp 2" node are `E7D2C5` and `FFEDEC`. If everything is working correctly, you'll get the rendering below.
+
+![alt text](assets/advanced_usage/image-5.png)
+
+You can also add "Transfrom" and "Cutter" nodes at the end and all components.
+
+![alt text](assets/advanced_usage/image-6.png)
+
+The multimodal data of VHP do not have any deformation or scaling differences, but only positional differences, so all data can be aligned easily. However, in most cases, the differences of different modalities are so great that they need to be registered first, which is not possible with Bioxel Nodes at the moment (but it is in plan). Nevertheless, you can build different components based on the same layer and combine them together. For example, based on the CT data, with the "Cutout by Range" node, you can eliminate the low value regions (fat), eliminate the high value regions (bone), and you can still get the muscle. And then attach it to the skull.
+
+![alt text](assets/advanced_usage/image-7.png)
+
+However, the CT values of brain and muscle are very close to each other, so it is extremely difficult to separate the brain from the muscle by threshold. So how should cutout the brain?
+
+## Cutout the Brain
+
+We can use AI technology to realize the division of brain regions, this process is called Segmentation, and the brain regions are as label. There are many models and methods for medical image segmentation, here we recommend [Total Segmentator](https://github.com/wasserth/TotalSegmentator).
+
+It is an out-of-the-box CT/MRI medical image segmentation Python library. You can deploy Total Segmentator locally or process your data through the official online site [https://totalsegmentator.com](https://totalsegmentator.com).
+
+Let me demonstrate the operation, we are still using the CT data from VHP. Click on "Drop DICOM.zip or ..." and select the VHP_M_CT_Head.zip file. Enter "brain" below "Selected task", press Enter to confirm. Finally click "Process data" button.
+
+![alt text](assets/advanced_usage/image-8.png)
+
+Wait for the uploading and processing, after all, you will be redirected to the following page, click "Download results" button, download and unzip segmentations.zip to any folder directory.
+
+![alt text](assets/advanced_usage/image-9.png)
+
+In case you can't get the brain segment (label), you can download it directly (without unzipping it).
+
+[VHP_M_CT_Head_Brain.nii.gz](https://drive.google.com/file/d/1KGiZ3G11YLXkGszSrvWQ9kTF4TMpxUPd/view?usp=drive_link)
+
+Next we import the brain segment (label) into the container in the same way as we imported the anatomical imagess(under the same container), but this time selecting **as Label**, with the Layer Name set to "Brain", and leaving the other options as default. Once the import is complete, a new "Fetch Layer" node will be added. Create and set the node as shown below, and you should be able to see the surface of brain.
+
+![alt text](assets/advanced_usage/image-10.png)
+
+Do you see the "step" like shape on surface? this is due to the low precision of the AI segmentation results. So How to addressing the issue? Select the Fetch Layer node of the brain label, right-click to pop up menu, click **Bioxel Nodes > Resample Value**, in the dialog box, change the "Smooth Size" to 3 or higher (the higher it is, the slower the calculation will be), click OK and wait for the calculation to finish. When it is done, a new layer will be added, replace the original one, is it smoother? The following figure lists different levels of smoothing.
+
+![alt text](assets/advanced_usage/image-11.png)
+
+The smoother it is, the more comfortable it looks, but it also means that more details are lost and the calculation is slower.
+
+But if you cut the brain, you will find that the cross-section is homogeneous, this is because the label type layer is does not contain any modality data itself. Bioxel Nodes provides a function to fill in any layer values by label, if you set the value below brain tissue in the non-brain region of CT data, then any "Cutout" node will only keep the brain region.
+
+The operation is like this, select the "Fetch Layer" node of the CT data, right-click to pop up the menu, click **Bioxel Nodes > Fill Value by Label**, in the dialog box, Label is set to the newly imported brain label layer, Fill Value is set to -100 (as long as it is less than the Hu value of the brain tissue), click OK. wait for the data processing, a new data layer will be added to the container when it is finished.
+
+As shown in the following figure, connect the nodes and set the node parameters, in which the two colors of "Set Color by Ramp 2" node are `B26267` and `EBC5B7`, and the "Cutout by Range" and "Set Color by Ramp 2" node are changed to "Value" mode (the default is "Factor" mode), because the maximum and minimum values of the brain are too close to each other and difficult to adjust in "Factor" mode. To make the brain tissue look more transparent, I add the "Set Properties" (Add > Bioxel Nodes > Property > Set Properties) node at the end and changed the "Density" to 0.5.
+
+![alt text](assets/advanced_usage/image-12.png)
+
+(Still feel not smooth enough? It's really hard to get rid of "step" surface completely at the moment)
+
+Now the brain is done. Finally we combine all together and you get something like the following.
+
+![alt text](assets/advanced_usage/image-13.png)
+
+🤗 If you've followed the docs up to this point, give yourself a round of applause, you've mastered this addon! If you have trouble following the docs instruction, you can download the project files to understand how the nodes work.
+
+[VHP.zip](https://drive.google.com/file/d/1EHB7sxNSvJNwmoTfFnpyOSsm2M_2Y0hO/view?usp=sharing)
+
+AI segmentation is an essential part of volumetric data visualization. Therefore, the future Bioxel Nodes will integrate some commonly used AI segmentation models, so that users can complete the volumetric data visualization in place!