Allow use of external bpy package from python environment

blenderproc/__init__.py

@@ -3,6 +3,21 @@
 import os
 import sys
 from .version import __version__
+from .python.utility.SetupUtility import SetupUtility, is_using_external_bpy_module
+
+# If "USE_EXTERNAL_BPY_MODULE" is set, we expect the bpy module is provided from the outside
+if is_using_external_bpy_module():
+    try:
+        import bpy
+        if bpy.app.version[0] != 4 and bpy.app.version[1] != 2:
+            raise RuntimeError("\n###############\nUSE_EXTERNAL_BPY_MODULE is set, but bpy module is not from Blender 4.2.\n\tpip install bpy==4.2.0\n###############\n")
+
+        print(f"BlenderProc is using external 'bpy' ({bpy.app.version_string}) module found in the environment.")
+        # If we successfully imported bpy of correct version, we can signal that we are in the internal blender python environment
+        os.environ.setdefault("INSIDE_OF_THE_INTERNAL_BLENDER_PYTHON_ENVIRONMENT", "1")
+    except ImportError:
+        raise RuntimeError("\n###############\nUSE_EXTERNAL_BPY_MODULE is set, but bpy module could not be imported. Make sure bpy module is present in your python environment.\n\tpip install bpy==4.2.0\n###############\n")
+
 
 # check the python version, only python 3.X is allowed:
 if sys.version_info.major < 3:
@@ -19,8 +34,10 @@
     # Also clean the python path as this might disturb the pip installs
     if "PYTHONPATH" in os.environ:
         del os.environ["PYTHONPATH"]
-    from .python.utility.SetupUtility import SetupUtility
-    SetupUtility.setup([])
+
+    if not is_using_external_bpy_module():
+        SetupUtility.setup([])
+
     from .api import loader
     from .api import utility
     from .api import sampler
@@ -46,7 +63,7 @@
     stack_summary = traceback.extract_stack()
     file_names_of_stack = [os.path.basename(file_summary.filename) for file_summary in stack_summary]
     # check if blenderproc is called via python3 -m blenderproc ...
-    is_module_call = file_names_of_stack[0] == "runpy.py"
+    is_module_call = file_names_of_stack[0] == "runpy.py" or file_names_of_stack[0] == "blenderproc-script.py"
     if sys.platform == "win32":
         is_bproc_shell_called = file_names_of_stack[2] in ["metadata.py", "__main__.py"]
         is_command_line_script_called = file_names_of_stack[0] == "command_line.py"
@@ -57,10 +74,11 @@
         # check if the name of this file is either blenderproc or if the
         # "OUTSIDE_OF_THE_INTERNAL_BLENDER_PYTHON_ENVIRONMENT_BUT_IN_RUN_SCRIPT" is set, which is set in the cli.py
         is_correct_startup_command = is_bproc_shell_called or is_module_call
+
     if "OUTSIDE_OF_THE_INTERNAL_BLENDER_PYTHON_ENVIRONMENT_BUT_IN_RUN_SCRIPT" not in os.environ \
-            and not is_correct_startup_command:
+            and not is_correct_startup_command and not is_using_external_bpy_module():
         # pylint: disable=consider-using-f-string
         raise RuntimeError("\n###############\nThis script can only be run by \"blenderproc run\", instead of calling:"
-                           "\n\tpython {}\ncall:\n\tblenderproc run {}\n###############".format(sys.argv[0],
-                                                                                                sys.argv[0]))
+                           "\n\tpython {}\ncall:\n\tblenderproc run {}\n\nor consider using 'USE_EXTERNAL_BPY_MODULE=1'"
+                           "\n###############".format(sys.argv[0], sys.argv[0]))
         # pylint: enable=consider-using-f-string

blenderproc/command_line.py

@@ -2,16 +2,16 @@
 
 import argparse
 import os
-import shutil
 import signal
 import sys
+import shutil
 import subprocess
 
 repo_root_directory = os.path.join(os.path.dirname(os.path.dirname(__file__)))
 sys.path.append(repo_root_directory)
 
 # pylint: disable=wrong-import-position
-from blenderproc.python.utility.SetupUtility import SetupUtility
+from blenderproc.python.utility.SetupUtility import SetupUtility, is_using_external_bpy_module
 from blenderproc.python.utility.InstallUtility import InstallUtility
 # pylint: enable=wrong-import-position
 
@@ -129,13 +129,23 @@ def cli():
         # pylint: enable=import-outside-toplevel
         print(__version__)
     elif args.mode in ["run", "debug", "quickstart"]:
-
-        # Install blender, if not already done
-        determine_result = InstallUtility.determine_blender_install_path(args)
-        custom_blender_path, blender_install_path = determine_result
-        blender_run_path, major_version = InstallUtility.make_sure_blender_is_installed(custom_blender_path,
-                                                                                        blender_install_path,
-                                                                                        args.reinstall_blender)
+        # BlenderProc has two modes based on the environment variable USE_EXTERNAL_BPY_MODULE. If the
+        # variable is set, we expect the bpy module and all relevant dependencies to be provided from the outside.
+        # If not set, the script will install blender, setup the environment and run the script inside Blender. 
+
+        # Any run commands are not supported in this mode and have to be executed directly via python.
+        if is_using_external_bpy_module():
+            if args.mode == "run":
+                print("USE_EXTERNAL_BPY_MODULE is set, run the script directly through python:\n\n"
+                    f"python {args.file}")
+            elif args.mode == "debug":
+                print("USE_EXTERNAL_BPY_MODULE is set, debug mode is not supported.")
+            elif args.mode == "quickstart":
+                path_src_run = os.path.join(repo_root_directory, "blenderproc", "scripts", "quickstart.py")
+                print(f"USE_EXTERNAL_BPY_MODULE is set, quickstart is not supported, instead run:\n\n"
+                      f"python {os.path.join(path_src_run)}")
+
+            sys.exit(1)
 
         # Setup script path that should be executed
         if args.mode == "quickstart":
@@ -154,6 +164,11 @@ def cli():
         # this is done to enable the import of blenderproc inside the blender internal python environment
         used_environment["INSIDE_OF_THE_INTERNAL_BLENDER_PYTHON_ENVIRONMENT"] = "1"
 
+        # Install blender, if not already done
+        custom_blender_path, blender_install_path = InstallUtility.determine_blender_install_path(args)
+        blender_run_path, major_version = InstallUtility.make_sure_blender_is_installed(custom_blender_path,
+                                                                                        blender_install_path,
+                                                                                        args.reinstall_blender)
         # If pip update is forced, remove pip package cache
         if args.force_pip_update:
             SetupUtility.clean_installed_packages_cache(os.path.dirname(blender_run_path), major_version)
@@ -162,19 +177,20 @@ def cli():
         if args.mode == "debug":
             # pylint: disable=consider-using-with
             p = subprocess.Popen([blender_run_path, "--python-use-system-env", "--python-exit-code", "0", "--python",
-                                  os.path.join(repo_root_directory, "blenderproc/debug_startup.py"), "--",
-                                  path_src_run, temp_dir] + unknown_args,
-                                 env=used_environment)
+                                os.path.join(repo_root_directory, "blenderproc/debug_startup.py"), "--",
+                                path_src_run, temp_dir] + unknown_args,
+                                env=used_environment)
             # pylint: enable=consider-using-with
         else:
             # pylint: disable=consider-using-with
             p = subprocess.Popen([blender_run_path, "--background", "--python-use-system-env", "--python-exit-code",
-                                  "2", "--python", path_src_run, "--", args.file, temp_dir] + unknown_args,
-                                 env=used_environment)
+                                "2", "--python", path_src_run, "--", args.file, temp_dir] + unknown_args,
+                                env=used_environment)
             # pylint: enable=consider-using-with
 
         def clean_temp_dir():
-            # If temp dir should not be kept and temp dir still exists => remove it
+            # If temp dir should not be kept and temp dir still exists => remove it,
+            # in external bpy mode this is handled in the `Initializer`.
             if not args.keep_temp_dir and os.path.exists(temp_dir):
                 print("Cleaning temporary directory")
                 shutil.rmtree(temp_dir)
@@ -232,11 +248,17 @@ def handle_sigterm(_signum, _frame):
         # Call the script
         current_cli()
     elif args.mode == "pip":
-        # Install blender, if not already done
-        custom_blender_path, blender_install_path = InstallUtility.determine_blender_install_path(args)
-        blender_bin, major_version = InstallUtility.make_sure_blender_is_installed(custom_blender_path,
-                                                                                   blender_install_path)
-        blender_path = os.path.dirname(blender_bin)
+        if is_using_external_bpy_module():
+            # In external mode we can't determine the blender_install_path correctly. Populate with
+            # stub values, so the SetupUtility can print the user suggestion in one place.
+            blender_path = None
+            major_version = None
+        else:
+            # Install blender, if not already done
+            custom_blender_path, blender_install_path = InstallUtility.determine_blender_install_path(args)
+            blender_bin, major_version = InstallUtility.make_sure_blender_is_installed(custom_blender_path,
+                                                                                    blender_install_path)
+            blender_path = os.path.dirname(blender_bin)
 
         if args.pip_mode == "install":
             SetupUtility.setup_pip(user_required_packages=args.pip_packages, blender_path=blender_path,

blenderproc/python/loader/URDFLoader.py

@@ -39,11 +39,11 @@ def load_urdf(urdf_file: str, weight_distribution: str = 'rigid',
                       visualization in blender.
     :return: URDF object instance.
     """
-    # install urdfpy
-    SetupUtility.setup_pip(user_required_packages=["git+https://github.com/wboerdijk/urdfpy.git"])
-    # This import is done inside to avoid having the requirement that BlenderProc depends on urdfpy
+    # install urchin
+    SetupUtility.setup_pip(user_required_packages=["urchin"])
+    # This import is done inside to avoid having the requirement that BlenderProc depends on urchin
     # pylint: disable=import-outside-toplevel
-    from urdfpy import URDF
+    from urchin import URDF
     # pylint: enable=import-outside-toplevel
 
     if fk_offset is None:
@@ -94,22 +94,22 @@ def load_urdf(urdf_file: str, weight_distribution: str = 'rigid',
     return urdf_object
 
 
-def get_joints_which_have_link_as_parent(link_name: str, joint_trees: List["urdfpy.Joint"]) -> List["urdfpy.Joint"]:
+def get_joints_which_have_link_as_parent(link_name: str, joint_trees: List["urchin.Joint"]) -> List["urchin.Joint"]:
     """ Returns a list of joints which have a specific link as parent.
 
     :param link_name: Name of the link.
-    :param joint_trees: List of urdfpy.Joint objects.
-    :return: List of urdfpy.Joint objects.
+    :param joint_trees: List of urchin.Joint objects.
+    :return: List of urchin.Joint objects.
     """
     return [joint_tree for i, joint_tree in enumerate(joint_trees) if joint_tree.parent == link_name]
 
 
-def get_joints_which_have_link_as_child(link_name: str, joint_trees: List["urdfpy.Joint"]) -> Optional["urdfpy.Joint"]:
+def get_joints_which_have_link_as_child(link_name: str, joint_trees: List["urchin.Joint"]) -> Optional["urchin.Joint"]:
     """ Returns the joint which is the parent of a specific link.
 
     :param link_name: Name of the link.
-    :param joint_trees: List of urdfpy.Joint objects.
-    :return: List of urdfpy.Joint objects, or None if no joint is defined as parent for the respective link.
+    :param joint_trees: List of urchin.Joint objects.
+    :return: List of urchin.Joint objects, or None if no joint is defined as parent for the respective link.
     """
     valid_joint_trees = [joint_tree for i, joint_tree in enumerate(joint_trees) if joint_tree.child == link_name]
     if not valid_joint_trees:  # happens for the very first link
@@ -121,7 +121,7 @@ def get_joints_which_have_link_as_child(link_name: str, joint_trees: List["urdfp
                               f"{link_name}")
 
 
-def create_bone(armature: bpy.types.Armature, joint_tree: "urdfpy.Joint", all_joint_trees: List["urdfpy.Joint"],
+def create_bone(armature: bpy.types.Armature, joint_tree: "urchin.Joint", all_joint_trees: List["urchin.Joint"],
                 parent_bone_name: Optional[str] = None, create_recursive: bool = True,
                 parent_origin: Optional[Matrix] = None,
                 fk_offset: Union[List[float], Vector, np.array] = None,
@@ -237,9 +237,9 @@ def create_bone(armature: bpy.types.Armature, joint_tree: "urdfpy.Joint", all_jo
                         parent_origin=origin, fk_offset=fk_offset, ik_offset=ik_offset)
 
 
-def load_links(link_trees: List["urdfpy.Link"], joint_trees: List["urdfpy.Joint"], armature: bpy.types.Armature,
+def load_links(link_trees: List["urchin.Link"], joint_trees: List["urchin.Joint"], armature: bpy.types.Armature,
                urdf_path: str) -> List[Link]:
-    """ Loads links and their visual, collision and inertial objects from a list of urdfpy.Link objects.
+    """ Loads links and their visual, collision and inertial objects from a list of urchin.Link objects.
 
     :param link_trees: List of urdf definitions for all links.
     :param joint_trees: List of urdf definitions for all joints.
@@ -288,9 +288,9 @@ def load_links(link_trees: List["urdfpy.Link"], joint_trees: List["urdfpy.Joint"
     return links
 
 
-def propagate_pose(links: List[Link], joint_tree: "urdfpy.Joint", joint_trees: List["urdfpy.Joint"],
+def propagate_pose(links: List[Link], joint_tree: "urchin.Joint", joint_trees: List["urchin.Joint"],
                    armature: bpy.types.Armature, recursive: bool = True):
-    """ Loads links and their visual, collision and inertial objects from a list of urdfpy.Link objects.
+    """ Loads links and their visual, collision and inertial objects from a list of urchin.Link objects.
 
     :param links: List of links.
     :param joint_tree: The urdf definition for the joint.
@@ -320,7 +320,7 @@ def propagate_pose(links: List[Link], joint_tree: "urdfpy.Joint", joint_trees: L
             propagate_pose(links, child_joint_tree, joint_trees, armature, recursive=True)
 
 
-def load_geometry(geometry_tree: "urdfpy.Geometry", urdf_path: Optional[str] = None) -> MeshObject:
+def load_geometry(geometry_tree: "urchin.Geometry", urdf_path: Optional[str] = None) -> MeshObject:
     """ Loads a geometric element from an urdf tree.
 
     :param geometry_tree: The urdf representation of the geometric element.
@@ -355,7 +355,7 @@ def load_geometry(geometry_tree: "urdfpy.Geometry", urdf_path: Optional[str] = N
     return obj
 
 
-def load_visual_collision_obj(viscol_tree: Union["urdfpy.Visual", "urdfpy.Collision"], name: str,
+def load_visual_collision_obj(viscol_tree: Union["urchin.Visual", "urchin.Collision"], name: str,
                               urdf_path: Optional[str] = None) -> MeshObject:
     """ Loads a visual / collision element from an urdf tree.
 
@@ -423,7 +423,7 @@ def load_visual_collision_obj(viscol_tree: Union["urdfpy.Visual", "urdfpy.Collis
     return obj
 
 
-def load_inertial(inertial_tree: "urdfpy.Inertial", name: str) -> Inertial:
+def load_inertial(inertial_tree: "urchin.Inertial", name: str) -> Inertial:
     """ Loads an inertial element from an urdf tree.
 
     :param inertial_tree: The urdf representation of the inertial element.
@@ -444,7 +444,7 @@ def load_inertial(inertial_tree: "urdfpy.Inertial", name: str) -> Inertial:
     return inertial
 
 
-def get_size_from_geometry(geometry: "urdfpy.Geometry") -> Optional[float]:
+def get_size_from_geometry(geometry: "urchin.Geometry") -> Optional[float]:
     """ Helper to derive the link size from the largest geometric element.
 
     :param geometry: The urdf representation of the geometric element.

blenderproc/python/postprocessing/StereoGlobalMatching.py

@@ -124,7 +124,7 @@ def stereo_global_matching(left_color_image: np.ndarray, right_color_image: np.n
         disparity = np.float32(np.copy(disparity_to_be_written)) / 16.0
 
         # Triangulation
-        depth = (1.0 / disparity) * baseline * focal_length
+        depth = ((1.0 / disparity) * baseline * focal_length).astype(np.float32)
 
         # Clip from depth map to 25 meters
         depth[depth > depth_max] = depth_max

blenderproc/python/types/MeshObjectUtility.py

@@ -551,8 +551,7 @@ def add_auto_smooth_modifier(self, angle: float = 30.0) -> bpy.types.Modifier:
         # Known issue: https://projects.blender.org/blender/blender/issues/117399
 
         # The datafiles are expected to be in the same folder relative to blender's python binary.
-        python_bin = SetupUtility.determine_python_paths(None, None)[0]
-        path = Path(python_bin).parent.parent.parent / "datafiles" / "assets" / "geometry_nodes" / "smooth_by_angle.blend"
+        path = Path(bpy.utils.resource_path('LOCAL')) / "datafiles" / "assets" / "geometry_nodes" / "smooth_by_angle.blend"
         if not path.exists():
             raise RuntimeError(f"Could not find the path to the 'ESSENTIALS' asset folder expected at {path}")
 

blenderproc/python/types/URDFUtility.py

@@ -21,7 +21,7 @@ class URDFObject(Entity):
     This class represents an URDF object, which is comprised of an armature and one or multiple links. Among others, it
     serves as an interface for manipulation of the URDF model.
     """
-    def __init__(self, armature: bpy.types.Armature, links: List[Link], xml_tree: Optional["urdfpy.URDF"] = None):
+    def __init__(self, armature: bpy.types.Armature, links: List[Link], xml_tree: Optional["urchin.URDF"] = None):
         super().__init__(bpy_object=armature)
 
         object.__setattr__(self, "links", links)