add rendering script

.gitignore

@@ -1,3 +1,5 @@
+scripts/rendering/blender-*
+
 # Byte-compiled / optimized / DLL files
 __pycache__/
 *.py[cod]

Makefile

@@ -10,10 +10,14 @@ lint: ## [Local development] Run mypy, pylint and black
 	python -m pylint objaverse_xl
 	python -m black --check objaverse_xl
 	python -m isort --check-only objaverse_xl
+	python -m black --check scripts --exclude scripts/rendering/blender-3.2.2-linux-x64/
+	python -m isort --check-only scripts/**/*.py --skip scripts/rendering/blender-3.2.2-linux-x64/
 
-format: ## [Local development] Auto-format python code using black
+format: ## [Local development] Auto-format python code using black, don't include blender
 	python -m isort objaverse_xl
 	python -m black objaverse_xl
+	python -m isort scripts/**/*.py --skip scripts/rendering/blender-3.2.2-linux-x64/
+	python -m black scripts --exclude scripts/rendering/blender-3.2.2-linux-x64/
 
 test: ## [Local development] Run unit tests
 	python -m pytest -x -s -v tests

requirements.txt

@@ -3,4 +3,5 @@ pandas
 pyarrow
 tqdm
 loguru
-fsspec>=2022.11.0
+fsspec>=2022.11.0
+gputil==1.4.0

scripts/rendering/README.md

@@ -0,0 +1,43 @@
+# Objaverse-XL Rendering Script
+
+## Setup
+
+1. Clone the repository and enter the rendering directory:
+
+```bash
+git clone https://github.com/allenai/objaverse-xl.git && \
+  cd objaverse-xl/scripts/rendering
+```
+
+2. Download Blender:
+
+```bash
+wget https://download.blender.org/release/Blender3.2/blender-3.2.2-linux-x64.tar.xz && \
+  tar -xf blender-3.2.2-linux-x64.tar.xz && \
+  rm blender-3.2.2-linux-x64.tar.xz
+```
+
+3. If you're on a headless Linux server, install Xorg and start it:
+
+```bash
+sudo apt-get install xserver-xorg -y && \
+  sudo python3 start_x_server.py start
+```
+
+4. Install the Python dependencies. Note that Python >3.8 is required:
+
+```bash
+cd ../.. && \
+  pip install -r requirements.txt && \
+  pip install -e . && \
+  cd scripts/rendering
+```
+
+## Usage
+
+After setup, you can render objects using the `main.py` script:
+
+```bash
+python3 main.py
+```
+

scripts/rendering/blender_script.py

@@ -0,0 +1,899 @@
+"""Blender script to render images of 3D models."""
+
+import argparse
+import json
+import math
+import os
+import random
+import sys
+from typing import Any, Callable, Dict, Generator, List, Literal, Optional, Set, Tuple
+
+import bpy
+import numpy as np
+from mathutils import Matrix, Vector
+
+IMPORT_FUNCTIONS: Dict[str, Callable] = {
+    "obj": bpy.ops.import_scene.obj,
+    "glb": bpy.ops.import_scene.gltf,
+    "gltf": bpy.ops.import_scene.gltf,
+    "usd": bpy.ops.import_scene.usd,
+    "fbx": bpy.ops.import_scene.fbx,
+    "stl": bpy.ops.import_mesh.stl,
+    "usda": bpy.ops.import_scene.usda,
+    "dae": bpy.ops.wm.collada_import,
+    "ply": bpy.ops.import_mesh.ply,
+    "abc": bpy.ops.wm.alembic_import,
+    "blend": bpy.ops.wm.append,
+}
+
+
+def reset_cameras() -> None:
+    """Resets the cameras in the scene to a single default camera."""
+    # Delete all existing cameras
+    bpy.ops.object.select_all(action="DESELECT")
+    bpy.ops.object.select_by_type(type="CAMERA")
+    bpy.ops.object.delete()
+
+    # Create a new camera with default properties
+    bpy.ops.object.camera_add()
+
+    # Rename the new camera to 'NewDefaultCamera'
+    new_camera = bpy.context.active_object
+    new_camera.name = "Camera"
+
+    # Set the new camera as the active camera for the scene
+    scene.camera = new_camera
+
+
+def sample_point_on_sphere(radius: float) -> Tuple[float, float, float]:
+    """Samples a point on a sphere with the given radius.
+
+    Args:
+        radius (float): Radius of the sphere.
+
+    Returns:
+        Tuple[float, float, float]: A point on the sphere.
+    """
+    theta = random.random() * 2 * math.pi
+    phi = math.acos(2 * random.random() - 1)
+    return (
+        radius * math.sin(phi) * math.cos(theta),
+        radius * math.sin(phi) * math.sin(theta),
+        radius * math.cos(phi),
+    )
+
+
+def _sample_spherical(
+    radius_min: float = 1.5,
+    radius_max: float = 2.0,
+    maxz: float = 1.6,
+    minz: float = -0.75,
+) -> np.ndarray:
+    """Sample a random point in a spherical shell.
+
+    Args:
+        radius_min (float): Minimum radius of the spherical shell.
+        radius_max (float): Maximum radius of the spherical shell.
+        maxz (float): Maximum z value of the spherical shell.
+        minz (float): Minimum z value of the spherical shell.
+
+    Returns:
+        np.ndarray: A random (x, y, z) point in the spherical shell.
+    """
+    correct = False
+    vec = np.array([0, 0, 0])
+    while not correct:
+        vec = np.random.uniform(-1, 1, 3)
+        #         vec[2] = np.abs(vec[2])
+        radius = np.random.uniform(radius_min, radius_max, 1)
+        vec = vec / np.linalg.norm(vec, axis=0) * radius[0]
+        if maxz > vec[2] > minz:
+            correct = True
+    return vec
+
+
+def randomize_camera(
+    radius_min: float = 1.5,
+    radius_max: float = 2.2,
+    maxz: float = 2.2,
+    minz: float = -2.2,
+    only_northern_hemisphere: bool = False,
+) -> bpy.types.Object:
+    """Randomizes the camera location and rotation inside of a spherical shell.
+
+    Args:
+        radius_min (float, optional): Minimum radius of the spherical shell. Defaults to
+            1.5.
+        radius_max (float, optional): Maximum radius of the spherical shell. Defaults to
+            2.0.
+        maxz (float, optional): Maximum z value of the spherical shell. Defaults to 1.6.
+        minz (float, optional): Minimum z value of the spherical shell. Defaults to
+            -0.75.
+        only_northern_hemisphere (bool, optional): Whether to only sample points in the
+            northern hemisphere. Defaults to False.
+
+    Returns:
+        bpy.types.Object: The camera object.
+    """
+
+    x, y, z = _sample_spherical(
+        radius_min=radius_min, radius_max=radius_max, maxz=maxz, minz=minz
+    )
+    camera = bpy.data.objects["Camera"]
+
+    # only positive z
+    if only_northern_hemisphere:
+        z = abs(z)
+
+    camera.location = Vector(np.array([x, y, z]))
+
+    direction = -camera.location
+    rot_quat = direction.to_track_quat("-Z", "Y")
+    camera.rotation_euler = rot_quat.to_euler()
+
+    return camera
+
+
+def _set_camera_at_size(i: int, scale: float = 1.5) -> bpy.types.Object:
+    """Debugging function to set the camera on the 6 faces of a cube.
+
+    Args:
+        i (int): Index of the face of the cube.
+        scale (float, optional): Scale of the cube. Defaults to 1.5.
+
+    Returns:
+        bpy.types.Object: The camera object.
+    """
+    if i == 0:
+        x, y, z = scale, 0, 0
+    elif i == 1:
+        x, y, z = -scale, 0, 0
+    elif i == 2:
+        x, y, z = 0, scale, 0
+    elif i == 3:
+        x, y, z = 0, -scale, 0
+    elif i == 4:
+        x, y, z = 0, 0, scale
+    elif i == 5:
+        x, y, z = 0, 0, -scale
+    else:
+        raise ValueError(f"Invalid index: i={i}, must be int in range [0, 5].")
+    camera = bpy.data.objects["Camera"]
+    camera.location = Vector(np.array([x, y, z]))
+    direction = -camera.location
+    rot_quat = direction.to_track_quat("-Z", "Y")
+    camera.rotation_euler = rot_quat.to_euler()
+    return camera
+
+
+def _create_light(
+    name: str,
+    light_type: Literal["POINT", "SUN", "SPOT", "AREA"],
+    location: Tuple[float, float, float],
+    rotation: Tuple[float, float, float],
+    energy: float,
+    use_shadow: bool = False,
+    specular_factor: float = 1.0,
+):
+    """Creates a light object.
+
+    Args:
+        name (str): Name of the light object.
+        light_type (Literal["POINT", "SUN", "SPOT", "AREA"]): Type of the light.
+        location (Tuple[float, float, float]): Location of the light.
+        rotation (Tuple[float, float, float]): Rotation of the light.
+        energy (float): Energy of the light.
+        use_shadow (bool, optional): Whether to use shadows. Defaults to False.
+        specular_factor (float, optional): Specular factor of the light. Defaults to 1.0.
+
+    Returns:
+        bpy.types.Object: The light object.
+    """
+
+    light_data = bpy.data.lights.new(name=name, type=light_type)
+    light_object = bpy.data.objects.new(name, light_data)
+    bpy.context.collection.objects.link(light_object)
+    light_object.location = location
+    light_object.rotation_euler = rotation
+    light_data.use_shadow = use_shadow
+    light_data.specular_factor = specular_factor
+    light_data.energy = energy
+    return light_object
+
+
+def randomize_lighting() -> Dict[str, bpy.types.Object]:
+    """Randomizes the lighting in the scene.
+
+    Returns:
+        Dict[str, bpy.types.Object]: Dictionary of the lights in the scene. The keys are
+            "key_light", "fill_light", "rim_light", and "bottom_light".
+    """
+
+    # Clear existing lights
+    bpy.ops.object.select_all(action="DESELECT")
+    bpy.ops.object.select_by_type(type="LIGHT")
+    bpy.ops.object.delete()
+
+    # Create key light
+    key_light = _create_light(
+        name="Key_Light",
+        light_type="SUN",
+        location=(0, 0, 0),
+        rotation=(0.785398, 0, -0.785398),
+        energy=random.choice([3, 4, 5]),
+    )
+
+    # Create fill light
+    fill_light = _create_light(
+        name="Fill_Light",
+        light_type="SUN",
+        location=(0, 0, 0),
+        rotation=(0.785398, 0, 2.35619),
+        energy=random.choice([2, 3, 4]),
+    )
+
+    # Create rim light
+    rim_light = _create_light(
+        name="Rim_Light",
+        light_type="SUN",
+        location=(0, 0, 0),
+        rotation=(-0.785398, 0, -3.92699),
+        energy=random.choice([3, 4, 5]),
+    )
+
+    # Create bottom light
+    bottom_light = _create_light(
+        name="Bottom_Light",
+        light_type="SUN",
+        location=(0, 0, 0),
+        rotation=(3.14159, 0, 0),
+        energy=random.choice([1, 2, 3]),
+    )
+
+    return dict(
+        key_light=key_light,
+        fill_light=fill_light,
+        rim_light=rim_light,
+        bottom_light=bottom_light,
+    )
+
+
+def reset_scene() -> None:
+    """Resets the scene to a clean state.
+
+    Returns:
+        None
+    """
+    # delete everything that isn't part of a camera or a light
+    for obj in bpy.data.objects:
+        if obj.type not in {"CAMERA", "LIGHT"}:
+            bpy.data.objects.remove(obj, do_unlink=True)
+
+    # delete all the materials
+    for material in bpy.data.materials:
+        bpy.data.materials.remove(material, do_unlink=True)
+
+    # delete all the textures
+    for texture in bpy.data.textures:
+        bpy.data.textures.remove(texture, do_unlink=True)
+
+    # delete all the images
+    for image in bpy.data.images:
+        bpy.data.images.remove(image, do_unlink=True)
+
+
+def load_object(object_path: str) -> None:
+    """Loads a model with a supported file extension into the scene.
+
+    Args:
+        object_path (str): Path to the model file.
+
+    Raises:
+        ValueError: If the file extension is not supported.
+
+    Returns:
+        None
+    """
+    file_extension = object_path.split(".")[-1].lower()
+    if file_extension is None:
+        raise ValueError(f"Unsupported file type: {object_path}")
+
+    if file_extension == "usdz":
+        # install usdz io package
+        dirname = os.path.dirname(os.path.realpath(__file__))
+        usdz_package = os.path.join(dirname, "io_scene_usdz.zip")
+        bpy.ops.preferences.addon_install(filepath=usdz_package)
+        # enable it
+        addon_name = "io_scene_usdz"
+        bpy.ops.preferences.addon_enable(module=addon_name)
+        # import the usdz
+        from io_scene_usdz.import_usdz import import_usdz
+
+        import_usdz(context, filepath=object_path, materials=True, animations=True)
+        return None
+
+    # load from existing import functions
+    import_function = IMPORT_FUNCTIONS[file_extension]
+
+    if file_extension == "blend":
+        import_function(directory=object_path, link=False)
+    elif file_extension in {"glb", "gltf"}:
+        import_function(filepath=object_path, merge_vertices=True)
+    else:
+        import_function(filepath=object_path)
+
+
+def scene_bbox(
+    single_obj: Optional[bpy.types.Object] = None, ignore_matrix: bool = False
+) -> Tuple[Vector, Vector]:
+    """Returns the bounding box of the scene.
+
+    Taken from Shap-E rendering script
+    (https://github.com/openai/shap-e/blob/main/shap_e/rendering/blender/blender_script.py#L68-L82)
+
+    Args:
+        single_obj (Optional[bpy.types.Object], optional): If not None, only computes
+            the bounding box for the given object. Defaults to None.
+        ignore_matrix (bool, optional): Whether to ignore the object's matrix. Defaults
+            to False.
+
+    Raises:
+        RuntimeError: If there are no objects in the scene.
+
+    Returns:
+        Tuple[Vector, Vector]: The minimum and maximum coordinates of the bounding box.
+    """
+    bbox_min = (math.inf,) * 3
+    bbox_max = (-math.inf,) * 3
+    found = False
+    for obj in get_scene_meshes() if single_obj is None else [single_obj]:
+        found = True
+        for coord in obj.bound_box:
+            coord = Vector(coord)
+            if not ignore_matrix:
+                coord = obj.matrix_world @ coord
+            bbox_min = tuple(min(x, y) for x, y in zip(bbox_min, coord))
+            bbox_max = tuple(max(x, y) for x, y in zip(bbox_max, coord))
+
+    if not found:
+        raise RuntimeError("no objects in scene to compute bounding box for")
+
+    return Vector(bbox_min), Vector(bbox_max)
+
+
+def get_scene_root_objects() -> Generator[bpy.types.Object, None, None]:
+    """Returns all root objects in the scene.
+
+    Yields:
+        Generator[bpy.types.Object, None, None]: Generator of all root objects in the
+            scene.
+    """
+    for obj in bpy.context.scene.objects.values():
+        if not obj.parent:
+            yield obj
+
+
+def get_scene_meshes() -> Generator[bpy.types.Object, None, None]:
+    """Returns all meshes in the scene.
+
+    Yields:
+        Generator[bpy.types.Object, None, None]: Generator of all meshes in the scene.
+    """
+    for obj in bpy.context.scene.objects.values():
+        if isinstance(obj.data, (bpy.types.Mesh)):
+            yield obj
+
+
+def get_3x4_RT_matrix_from_blender(cam: bpy.types.Object) -> Matrix:
+    """Returns the 3x4 RT matrix from the given camera.
+
+    Taken from Zero123, which in turn was taken from
+    https://github.com/panmari/stanford-shapenet-renderer/blob/master/render_blender.py
+
+    Args:
+        cam (bpy.types.Object): The camera object.
+
+    Returns:
+        Matrix: The 3x4 RT matrix from the given camera.
+    """
+    # Use matrix_world instead to account for all constraints
+    location, rotation = cam.matrix_world.decompose()[0:2]
+    R_world2bcam = rotation.to_matrix().transposed()
+
+    # Use location from matrix_world to account for constraints:
+    T_world2bcam = -1 * R_world2bcam @ location
+
+    # put into 3x4 matrix
+    RT = Matrix(
+        (
+            R_world2bcam[0][:] + (T_world2bcam[0],),
+            R_world2bcam[1][:] + (T_world2bcam[1],),
+            R_world2bcam[2][:] + (T_world2bcam[2],),
+        )
+    )
+    return RT
+
+
+def delete_invisible_objects() -> None:
+    """Deletes all invisible objects in the scene.
+
+    Returns:
+        None
+    """
+    bpy.ops.object.select_all(action="DESELECT")
+    for obj in scene.objects:
+        if obj.hide_viewport or obj.hide_render:
+            obj.hide_viewport = False
+            obj.hide_render = False
+            obj.hide_select = False
+            obj.select_set(True)
+    bpy.ops.object.delete()
+
+    # Delete invisible collections
+    invisible_collections = [col for col in bpy.data.collections if col.hide_viewport]
+    for col in invisible_collections:
+        bpy.data.collections.remove(col)
+
+
+def normalize_scene() -> None:
+    """Normalizes the scene by scaling and translating it to fit in a unit cube centered
+    at the origin.
+
+    Mostly taken from the Point-E / Shap-E rendering script
+    (https://github.com/openai/point-e/blob/main/point_e/evals/scripts/blender_script.py#L97-L112),
+    but fix for multiple root objects: (see bug report here:
+    https://github.com/openai/shap-e/pull/60).
+
+    Returns:
+        None
+    """
+    if len(list(get_scene_root_objects())) > 1:
+        # create an empty object to be used as a parent for all root objects
+        parent_empty = bpy.data.objects.new("ParentEmpty", None)
+        bpy.context.scene.collection.objects.link(parent_empty)
+
+        # parent all root objects to the empty object
+        for obj in get_scene_root_objects():
+            if obj != parent_empty:
+                obj.parent = parent_empty
+
+    bbox_min, bbox_max = scene_bbox()
+    scale = 1 / max(bbox_max - bbox_min)
+    for obj in get_scene_root_objects():
+        obj.scale = obj.scale * scale
+
+    # Apply scale to matrix_world.
+    bpy.context.view_layer.update()
+    bbox_min, bbox_max = scene_bbox()
+    offset = -(bbox_min + bbox_max) / 2
+    for obj in get_scene_root_objects():
+        obj.matrix_world.translation += offset
+    bpy.ops.object.select_all(action="DESELECT")
+
+    # unparent the camera
+    bpy.data.objects["Camera"].parent = None
+
+
+def delete_missing_textures() -> Dict[str, Any]:
+    """Deletes all missing textures in the scene.
+
+    Returns:
+        Dict[str, Any]: Dictionary with keys "count", "files", and "file_path_to_color".
+            "count" is the number of missing textures, "files" is a list of the missing
+            texture file paths, and "file_path_to_color" is a dictionary mapping the
+            missing texture file paths to a random color.
+    """
+    missing_file_count = 0
+    out_files = []
+    file_path_to_color = {}
+
+    # Check all materials in the scene
+    for material in bpy.data.materials:
+        if material.use_nodes:
+            for node in material.node_tree.nodes:
+                if node.type == "TEX_IMAGE":
+                    image = node.image
+                    if image is not None:
+                        file_path = bpy.path.abspath(image.filepath)
+                        if file_path == "":
+                            # means it's embedded
+                            continue
+
+                        if not os.path.exists(file_path):
+                            # Find the connected Principled BSDF node
+                            connected_node = node.outputs[0].links[0].to_node
+
+                            if connected_node.type == "BSDF_PRINCIPLED":
+                                if file_path not in file_path_to_color:
+                                    # Set a random color for the unique missing file path
+                                    random_color = [random.random() for _ in range(3)]
+                                    file_path_to_color[file_path] = random_color + [1]
+
+                                connected_node.inputs[
+                                    "Base Color"
+                                ].default_value = file_path_to_color[file_path]
+
+                            # Delete the TEX_IMAGE node
+                            material.node_tree.nodes.remove(node)
+                            missing_file_count += 1
+                            out_files.append(image.filepath)
+    return {
+        "count": missing_file_count,
+        "files": out_files,
+        "file_path_to_color": file_path_to_color,
+    }
+
+
+def _get_random_color() -> Tuple[float, float, float, float]:
+    """Generates a random RGB-A color.
+
+    The alpha value is always 1.
+
+    Returns:
+        Tuple[float, float, float, float]: A random RGB-A color. Each value is in the
+        range [0, 1].
+    """
+    return (random.random(), random.random(), random.random(), 1)
+
+
+def _apply_color_to_object(
+    obj: bpy.types.Object, color: Tuple[float, float, float, float]
+) -> None:
+    """Applies the given color to the object.
+
+    Args:
+        obj (bpy.types.Object): The object to apply the color to.
+        color (Tuple[float, float, float, float]): The color to apply to the object.
+
+    Returns:
+        None
+    """
+    mat = bpy.data.materials.new(name=f"RandomMaterial_{obj.name}")
+    mat.use_nodes = True
+    nodes = mat.node_tree.nodes
+    principled_bsdf = nodes.get("Principled BSDF")
+    if principled_bsdf:
+        principled_bsdf.inputs["Base Color"].default_value = color
+    obj.data.materials.append(mat)
+
+
+def apply_single_random_color_to_all_objects() -> Tuple[float, float, float, float]:
+    """Applies a single random color to all objects in the scene.
+
+    Returns:
+        Tuple[float, float, float, float]: The random color that was applied to all
+        objects.
+    """
+    rand_color = _get_random_color()
+    for obj in bpy.context.scene.objects:
+        if obj.type == "MESH":
+            _apply_color_to_object(obj, rand_color)
+    return rand_color
+
+
+class MetadataExtractor:
+    """Class to extract metadata from a Blender scene."""
+
+    def __init__(
+        self, object_path: str, scene: bpy.types.Scene, bdata: bpy.types.BlendData
+    ) -> None:
+        """Initializes the MetadataExtractor.
+
+        Args:
+            object_path (str): Path to the object file.
+            scene (bpy.types.Scene): The current scene object from `bpy.context.scene`.
+            bdata (bpy.types.BlendData): The current blender data from `bpy.data`.
+
+        Returns:
+            None
+        """
+        self.object_path = object_path
+        self.scene = scene
+        self.bdata = bdata
+
+    def get_poly_count(self) -> int:
+        """Returns the total number of polygons in the scene."""
+        total_poly_count = 0
+        for obj in self.scene.objects:
+            if obj.type == "MESH":
+                total_poly_count += len(obj.data.polygons)
+        return total_poly_count
+
+    def get_vertex_count(self) -> int:
+        """Returns the total number of vertices in the scene."""
+        total_vertex_count = 0
+        for obj in self.scene.objects:
+            if obj.type == "MESH":
+                total_vertex_count += len(obj.data.vertices)
+        return total_vertex_count
+
+    def get_edge_count(self) -> int:
+        """Returns the total number of edges in the scene."""
+        total_edge_count = 0
+        for obj in self.scene.objects:
+            if obj.type == "MESH":
+                total_edge_count += len(obj.data.edges)
+        return total_edge_count
+
+    def get_lamp_count(self) -> int:
+        """Returns the number of lamps in the scene."""
+        return sum(1 for obj in self.scene.objects if obj.type == "LIGHT")
+
+    def get_mesh_count(self) -> int:
+        """Returns the number of meshes in the scene."""
+        return sum(1 for obj in self.scene.objects if obj.type == "MESH")
+
+    def get_material_count(self) -> int:
+        """Returns the number of materials in the scene."""
+        return len(self.bdata.materials)
+
+    def get_object_count(self) -> int:
+        """Returns the number of objects in the scene."""
+        return len(self.bdata.objects)
+
+    def get_animation_count(self) -> int:
+        """Returns the number of animations in the scene."""
+        return len(self.bdata.actions)
+
+    def get_linked_files(self) -> List[str]:
+        """Returns the filepaths of all linked files."""
+        image_filepaths = self._get_image_filepaths()
+        material_filepaths = self._get_material_filepaths()
+        linked_libraries_filepaths = self._get_linked_libraries_filepaths()
+
+        all_filepaths = (
+            image_filepaths | material_filepaths | linked_libraries_filepaths
+        )
+        if "" in all_filepaths:
+            all_filepaths.remove("")
+        return list(all_filepaths)
+
+    def _get_image_filepaths(self) -> Set[str]:
+        """Returns the filepaths of all images used in the scene."""
+        filepaths = set()
+        for image in self.bdata.images:
+            if image.source == "FILE":
+                filepaths.add(bpy.path.abspath(image.filepath))
+        return filepaths
+
+    def _get_material_filepaths(self) -> Set[str]:
+        """Returns the filepaths of all images used in materials."""
+        filepaths = set()
+        for material in self.bdata.materials:
+            if material.use_nodes:
+                for node in material.node_tree.nodes:
+                    if node.type == "TEX_IMAGE":
+                        image = node.image
+                        if image is not None:
+                            filepaths.add(bpy.path.abspath(image.filepath))
+        return filepaths
+
+    def _get_linked_libraries_filepaths(self) -> Set[str]:
+        """Returns the filepaths of all linked libraries."""
+        filepaths = set()
+        for library in self.bdata.libraries:
+            filepaths.add(bpy.path.abspath(library.filepath))
+        return filepaths
+
+    def get_scene_size(self) -> Dict[str, list]:
+        """Returns the size of the scene bounds in meters."""
+        bbox_min, bbox_max = scene_bbox()
+        return {"bbox_max": list(bbox_max), "bbox_min": list(bbox_min)}
+
+    def get_shape_key_count(self) -> int:
+        """Returns the number of shape keys in the scene."""
+        total_shape_key_count = 0
+        for obj in self.scene.objects:
+            if obj.type == "MESH":
+                shape_keys = obj.data.shape_keys
+                if shape_keys is not None:
+                    total_shape_key_count += (
+                        len(shape_keys.key_blocks) - 1
+                    )  # Subtract 1 to exclude the Basis shape key
+        return total_shape_key_count
+
+    def get_armature_count(self) -> int:
+        """Returns the number of armatures in the scene."""
+        total_armature_count = 0
+        for obj in self.scene.objects:
+            if obj.type == "ARMATURE":
+                total_armature_count += 1
+        return total_armature_count
+
+    def read_file_size(self) -> int:
+        """Returns the size of the file in bytes."""
+        return os.path.getsize(self.object_path)
+
+    def get_metadata(self) -> Dict[str, Any]:
+        """Returns the metadata of the scene.
+
+        Returns:
+            Dict[str, Any]: Dictionary of the metadata with keys for "file_size",
+            "poly_count", "vert_count", "edge_count", "material_count", "object_count",
+            "lamp_count", "mesh_count", "animation_count", "linked_files", "scene_size",
+            "shape_key_count", and "armature_count".
+        """
+        return {
+            "file_size": self.read_file_size(),
+            "poly_count": self.get_poly_count(),
+            "vert_count": self.get_vertex_count(),
+            "edge_count": self.get_edge_count(),
+            "material_count": self.get_material_count(),
+            "object_count": self.get_object_count(),
+            "lamp_count": self.get_lamp_count(),
+            "mesh_count": self.get_mesh_count(),
+            "animation_count": self.get_animation_count(),
+            "linked_files": self.get_linked_files(),
+            "scene_size": self.get_scene_size(),
+            "shape_key_count": self.get_shape_key_count(),
+            "armature_count": self.get_armature_count(),
+        }
+
+
+def render_object(
+    object_file: str,
+    num_renders: int,
+    only_northern_hemisphere: bool,
+    output_dir: str,
+) -> None:
+    """Saves rendered images with its camera matrix and metadata of the object.
+
+    Args:
+        object_file (str): Path to the object file.
+        num_renders (int): Number of renders to save of the object.
+        only_northern_hemisphere (bool): Whether to only render sides of the object that
+            are in the northern hemisphere. This is useful for rendering objects that
+            are photogrammetrically scanned, as the bottom of the object often has
+            holes.
+        output_dir (str): Path to the directory where the rendered images and metadata
+            will be saved.
+
+    Returns:
+        None
+    """
+    os.makedirs(output_dir, exist_ok=True)
+
+    # load the object
+    if object_file.endswith(".blend"):
+        bpy.ops.object.mode_set(mode="OBJECT")
+        reset_cameras()
+        delete_invisible_objects()
+    else:
+        reset_scene()
+        load_object(object_file)
+
+    # Set up cameras
+    cam = scene.objects["Camera"]
+    cam.data.lens = 35
+    cam.data.sensor_width = 32
+
+    # Set up camera constraints
+    cam_constraint = cam.constraints.new(type="TRACK_TO")
+    cam_constraint.track_axis = "TRACK_NEGATIVE_Z"
+    cam_constraint.up_axis = "UP_Y"
+    empty = bpy.data.objects.new("Empty", None)
+    scene.collection.objects.link(empty)
+    cam_constraint.target = empty
+
+    # Extract the metadata. This must be done before normalizing the scene to get
+    # accurate bounding box information.
+    metadata_extractor = MetadataExtractor(
+        object_path=object_file, scene=scene, bdata=bpy.data
+    )
+    metadata = metadata_extractor.get_metadata()
+
+    # delete all objects that are not meshes
+    if object_file.lower().endswith(".usdz"):
+        # don't delete missing textures on usdz files, lots of them are embedded
+        missing_textures = None
+    else:
+        missing_textures = delete_missing_textures()
+    metadata["missing_textures"] = missing_textures
+
+    # possibly apply a random color to all objects
+    if object_file.endswith(".stl") or object_file.endswith(".ply"):
+        assert len(bpy.context.selected_objects) == 1
+        rand_color = apply_single_random_color_to_all_objects()
+        metadata["random_color"] = rand_color
+    else:
+        metadata["random_color"] = None
+
+    # save metadata
+    metadata_path = os.path.join(output_dir, "metadata.json")
+    os.makedirs(os.path.dirname(metadata_path), exist_ok=True)
+    with open(metadata_path, "w", encoding="utf-8") as f:
+        json.dump(metadata, f, sort_keys=True, indent=2)
+
+    # normalize the scene
+    normalize_scene()
+
+    # randomize the lighting
+    randomize_lighting()
+
+    # render the images
+    for i in range(num_renders):
+        # set camera
+        camera = randomize_camera(
+            only_northern_hemisphere=only_northern_hemisphere,
+        )
+
+        # render the image
+        render_path = os.path.join(output_dir, f"{i:03d}.png")
+        scene.render.filepath = render_path
+        bpy.ops.render.render(write_still=True)
+
+        # save camera RT matrix
+        rt_matrix = get_3x4_RT_matrix_from_blender(camera)
+        rt_matrix_path = os.path.join(output_dir, f"{i:03d}.npy")
+        np.save(rt_matrix_path, rt_matrix)
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--object_path",
+        type=str,
+        required=True,
+        help="Path to the object file",
+    )
+    parser.add_argument(
+        "--output_dir",
+        type=str,
+        required=True,
+        help="Path to the directory where the rendered images and metadata will be saved.",
+    )
+    parser.add_argument(
+        "--engine",
+        type=str,
+        default="BLENDER_EEVEE",
+        choices=["CYCLES", "BLENDER_EEVEE"],
+    )
+    parser.add_argument(
+        "--only_northern_hemisphere",
+        action="store_true",
+        help="Only render the northern hemisphere of the object.",
+        default=False,
+    )
+    parser.add_argument(
+        "--num_renders",
+        type=int,
+        default=12,
+        help="Number of renders to save of the object.",
+    )
+    argv = sys.argv[sys.argv.index("--") + 1 :]
+    args = parser.parse_args(argv)
+
+    context = bpy.context
+    scene = context.scene
+    render = scene.render
+
+    # Set render settings
+    render.engine = args.engine
+    render.image_settings.file_format = "PNG"
+    render.image_settings.color_mode = "RGBA"
+    render.resolution_x = 512
+    render.resolution_y = 512
+    render.resolution_percentage = 100
+
+    # Set cycles settings
+    scene.cycles.device = "GPU"
+    scene.cycles.samples = 128
+    scene.cycles.diffuse_bounces = 1
+    scene.cycles.glossy_bounces = 1
+    scene.cycles.transparent_max_bounces = 3
+    scene.cycles.transmission_bounces = 3
+    scene.cycles.filter_width = 0.01
+    scene.cycles.use_denoising = True
+    scene.render.film_transparent = True
+    bpy.context.preferences.addons["cycles"].preferences.get_devices()
+    bpy.context.preferences.addons[
+        "cycles"
+    ].preferences.compute_device_type = "CUDA"  # or "OPENCL"
+
+    # Render the images
+    render_object(
+        object_file=args.object_path,
+        num_renders=args.num_renders,
+        only_northern_hemisphere=args.only_northern_hemisphere,
+        output_dir=args.output_dir,
+    )

scripts/rendering/io_scene_usdz.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ec07ab6125fe0a021ed08c64169eceda126330401aba3d494d5203d26ac4b093
+size 34685

scripts/rendering/main.py

@@ -0,0 +1,404 @@
+import glob
+import json
+import multiprocessing
+import os
+import platform
+import random
+import subprocess
+import tempfile
+import zipfile
+import time
+from functools import partial
+from typing import List, Literal, Optional, Union
+
+import fire
+import fsspec
+import GPUtil
+import pandas as pd
+from loguru import logger
+
+from objaverse_xl.github import download_github_objects
+from objaverse_xl.utils import get_uid_from_str
+
+
+def log_processed_object(object_id: str, sha256: str, csv_filename: str) -> None:
+    """Log when an object is done being used.
+
+    Args:
+        object_id (str): ID of the object.
+        sha256 (str): SHA256 of the object.
+        csv_filename (str): Name of the CSV file to save the logs to.
+
+    Returns:
+        None
+    """
+    # log that this object was rendered successfully
+    # saving locally to avoid excessive writes to the cloud
+    dirname = os.path.expanduser(f"~/.objaverse/github/logs/")
+    os.makedirs(dirname, exist_ok=True)
+    with open(os.path.join(dirname, csv_filename), "a", encoding="utf-8") as f:
+        f.write(f"{time.time()},{object_id},{sha256}\n")
+
+
+def zipdir(path: str, ziph: zipfile.ZipFile) -> None:
+    """Zip up a directory with an arcname structure.
+
+    Args:
+        path (str): Path to the directory to zip.
+        ziph (zipfile.ZipFile): ZipFile handler object to write to.
+
+    Returns:
+        None
+    """
+    # ziph is zipfile handle
+    for root, dirs, files in os.walk(path):
+        for file in files:
+            # this ensures the structure inside the zip starts at folder/
+            arcname = os.path.join(os.path.basename(root), file)
+            ziph.write(os.path.join(root, file), arcname=arcname)
+
+
+def handle_found_object(
+    file: str,
+    github_url: str,
+    sha256: str,
+    repo: str,
+    organization: str,
+    num_renders: int,
+    render_dir: str,
+    only_northern_hemisphere: bool,
+    gpu_devices: Union[int, List[int]],
+    render_timeout: int,
+    successful_log_file: str = "handle-found-object-successful.csv",
+    failed_log_file: str = "handle-found-object-failed.csv",
+) -> None:
+    """Called when an object is successfully found and downloaded.
+
+    Here, the object has the same sha256 as the one that was downloaded with
+    Objaverse-XL. If None, the object will be downloaded, but nothing will be done with
+    it.
+
+    Args:
+        file (str): Local path to the downloaded 3D object.
+        github_url (str): GitHub URL of the 3D object.
+        sha256 (str): SHA256 of the contents of the 3D object.
+        repo (str): Name of the GitHub repo where the 3D object comes from.
+        organization (str): Name of the GitHub organization where the 3D object
+            comes from.
+        num_renders (int): Number of renders to save of the object.
+        render_dir (str): Directory where the objects will be rendered.
+        only_northern_hemisphere (bool): Only render the northern hemisphere of the
+            object.
+        gpu_devices (Union[int, List[int]]): GPU device(s) to use for rendering. If
+            an int, the GPU device will be randomly selected from 0 to gpu_devices - 1.
+            If a list, the GPU device will be randomly selected from the list.
+            If 0, the CPU will be used for rendering.
+        render_timeout (int): Number of seconds to wait for the rendering job to
+            complete.
+        successful_log_file (str): Name of the log file to save successful renders to.
+        failed_log_file (str): Name of the log file to save failed renders to.
+
+    Returns:
+        None
+    """
+    save_uid = get_uid_from_str(github_url)
+    args = f"--object_path '{file}' --num_renders {num_renders}"
+
+    # get the GPU to use for rendering
+    using_gpu: bool = True
+    gpu_i = 0
+    if isinstance(gpu_devices, int) and gpu_devices > 0:
+        num_gpus = gpu_devices
+        gpu_i = random.randint(0, num_gpus - 1)
+    elif isinstance(gpu_devices, list):
+        gpu_i = random.choice(gpu_devices)
+    elif isinstance(gpu_devices, int) and gpu_devices == 0:
+        using_gpu = False
+    else:
+        raise ValueError(
+            f"gpu_devices must be an int > 0, 0, or a list of ints. Got {gpu_devices}."
+        )
+
+    with tempfile.TemporaryDirectory() as temp_dir:
+        # get the target directory for the rendering job
+        target_directory = os.path.join(temp_dir, save_uid)
+        os.makedirs(target_directory, exist_ok=True)
+        args += f" --output_dir {target_directory}"
+
+        # check for Linux / Ubuntu or MacOS
+        if platform.system() == "Linux" and using_gpu:
+            args += " --engine BLENDER_EEVEE"
+        elif platform.system() == "Darwin" or (
+            platform.system() == "Linux" and not using_gpu
+        ):
+            # As far as I know, MacOS does not support BLENER_EEVEE, which uses GPU
+            # rendering. Generally, I'd only recommend using MacOS for debugging and
+            # small rendering jobs, since CYCLES is much slower than BLENDER_EEVEE.
+            args += " --engine CYCLES"
+        else:
+            raise NotImplementedError(f"Platform {platform.system()} is not supported.")
+
+        # check if we should only render the northern hemisphere
+        if only_northern_hemisphere:
+            args += " --only_northern_hemisphere"
+
+        # get the command to run
+        command = f"blender-3.2.2-linux-x64/blender --background --python blender_script.py -- {args}"
+        if using_gpu:
+            command = f"export DISPLAY=:0.{gpu_i} && {command}"
+
+        # render the object
+        subprocess.run(["bash", "-c", command], timeout=render_timeout, check=False)
+
+        # check that the renders were saved successfully
+        png_files = glob.glob(os.path.join(target_directory, "*.png"))
+        metadata_files = glob.glob(os.path.join(target_directory, "*.json"))
+        npy_files = glob.glob(os.path.join(target_directory, "*.npy"))
+        if (
+            (len(png_files) != num_renders)
+            or (len(npy_files) != num_renders)
+            or (len(metadata_files) != 1)
+        ):
+            logger.error(f"Found object {github_url} was not rendered successfully!")
+            log_processed_object(github_url, sha256, failed_log_file)
+            return
+
+        # update the metadata
+        with open(f"{target_directory}/metadata.json", "r", encoding="utf-8") as f:
+            metadata = json.load(f)
+        metadata["sha256"] = sha256
+        metadata["file_identifier"] = github_url
+        metadata["save_uid"] = save_uid
+        with open(f"{target_directory}/metadata.json", "w", encoding="utf-8") as f:
+            json.dump(metadata, f, sort_keys=True, indent=2)
+
+        # Make a zip of the target_directory.
+        # Keeps the {save_uid} directory structure when unzipped
+        with zipfile.ZipFile(
+            f"{target_directory}.zip", "w", zipfile.ZIP_DEFLATED
+        ) as zipf:
+            zipdir(target_directory, zipf)
+
+        # move the zip to the render_dir
+        fs, path = fsspec.core.url_to_fs(render_dir)
+
+        # move the zip to the render_dir
+        fs.makedirs(os.path.join(path, "github", "renders"), exist_ok=True)
+        fs.put(
+            os.path.join(f"{target_directory}.zip"),
+            os.path.join(path, "github", "renders", f"{save_uid}.zip"),
+        )
+
+        # log that this object was rendered successfully
+        log_processed_object(github_url, sha256, successful_log_file)
+
+
+def handle_new_object(
+    file: str,
+    github_url: str,
+    sha256: str,
+    repo: str,
+    organization: str,
+    log_file: str = "handle-new-object.csv",
+) -> None:
+    """Called when a new object is found.
+
+    Here, the object is not used in Objaverse-XL, but is still downloaded with the
+    repository. The object may have not been used because it does not successfully
+    import into Blender. If None, the object will be downloaded, but nothing will be
+    done with it.
+
+    Args:
+        file (str): Local path to the downloaded 3D object.
+        github_url (str): GitHub URL of the 3D object.
+        sha256 (str): SHA256 of the contents of the 3D object.
+        repo (str): Name of the GitHub repo where the 3D object comes from.
+        organization (str): Name of the GitHub organization where the 3D object
+            comes from.
+        log_file (str): Name of the log file to save the handle_new_object logs to.
+
+    Returns:
+        None
+    """
+    # log the new object
+    log_processed_object(github_url, sha256, log_file)
+
+
+def handle_modified_object(
+    file: str,
+    github_url: str,
+    sha256: str,
+    repo: str,
+    organization: str,
+    num_renders: int,
+    render_dir: str,
+    only_northern_hemisphere: bool,
+    gpu_devices: Union[int, List[int]],
+    render_timeout: int,
+) -> None:
+    """Called when a modified object is found and downloaded.
+
+    Here, the object is successfully downloaded, but it has a different sha256 than the
+    one that was downloaded with Objaverse-XL. This is not expected to happen very
+    often, because the same commit hash is used for each repo. If None, the object will
+    be downloaded, but nothing will be done with it.
+
+    Args:
+        file (str): Local path to the downloaded 3D object.
+        github_url (str): GitHub URL of the 3D object.
+        sha256 (str): SHA256 of the contents of the 3D object.
+        repo (str): Name of the GitHub repo where the 3D object comes from.
+        organization (str): Name of the GitHub organization where the 3D object
+            comes from.
+        num_renders (int): Number of renders to save of the object.
+        render_dir (str): Directory where the objects will be rendered.
+        only_northern_hemisphere (bool): Only render the northern hemisphere of the
+            object.
+        gpu_devices (Union[int, List[int]]): GPU device(s) to use for rendering. If
+            an int, the GPU device will be randomly selected from 0 to gpu_devices - 1.
+            If a list, the GPU device will be randomly selected from the list.
+            If 0, the CPU will be used for rendering.
+        render_timeout (int): Number of seconds to wait for the rendering job to
+            complete.
+
+    Returns:
+        None
+    """
+    handle_found_object(
+        file=file,
+        github_url=github_url,
+        sha256=sha256,
+        repo=repo,
+        organization=organization,
+        num_renders=num_renders,
+        render_dir=render_dir,
+        only_northern_hemisphere=only_northern_hemisphere,
+        gpu_devices=gpu_devices,
+        render_timeout=render_timeout,
+        successful_log_file="handle-modified-object-successful.csv",
+        failed_log_file="handle-modified-object-failed.csv",
+    )
+
+
+def handle_missing_object(
+    github_url: str,
+    sha256: str,
+    repo: str,
+    organization: str,
+    log_file: str = "handle-missing-object.csv",
+) -> None:
+    """Called when an object that is in Objaverse-XL is not found.
+
+    Here, it is likely that the repository was deleted or renamed. If None, nothing
+    will be done with the missing object.
+
+    Args:
+        github_url (str): GitHub URL of the 3D object.
+        sha256 (str): SHA256 of the contents of the original 3D object.
+        repo (str): Name of the GitHub repo where the 3D object comes from.
+        organization (str): Name of the GitHub organization where the 3D object comes from.
+        log_file (str): Name of the log file to save missing renders to.
+
+    Returns:
+        None
+    """
+    # log the missing object
+    log_processed_object(github_url, sha256, log_file)
+
+
+def get_example_objects() -> pd.DataFrame:
+    """Returns a DataFrame of example objects to use for debugging."""
+    return pd.DataFrame(
+        [
+            {
+                "githubUrl": "https://github.com/mattdeitke/objaverse-xl-test-files/blob/6928b08a2501aa7a4a4aabac1f888b66e7782056/example.fbx",
+                "license": None,
+                "sha256": "7037575f47816118e5a34e7c0da9927e1be7be3f5b4adfac337710822eb50fa9",
+            },
+            {
+                "githubUrl": "https://github.com/mattdeitke/objaverse-xl-test-files/blob/6928b08a2501aa7a4a4aabac1f888b66e7782056/example.glb",
+                "license": None,
+                "sha256": "04e6377317d6818e32c5cbd1951e76deb3641bbf4f6db6933046221d5fbf1c5c",
+            },
+            {
+                "githubUrl": "https://github.com/mattdeitke/objaverse-xl-test-files/blob/6928b08a2501aa7a4a4aabac1f888b66e7782056/example.obj",
+                "license": None,
+                "sha256": "d2b9a5d7c47dc93526082c9b630157ab6bce4fd8669610d942176f4a36444e71",
+            },
+        ]
+    )
+
+
+def render_github_objects(
+    render_dir: str = "~/.objaverse",
+    num_renders: int = 12,
+    processes: Optional[int] = None,
+    save_repo_format: Optional[Literal["zip", "tar", "tar.gz"]] = None,
+    only_northern_hemisphere: bool = False,
+    render_timeout: int = 300,
+    gpu_devices: Optional[Union[int, List[int]]] = None,
+) -> None:
+    """Renders all GitHub objects in the Objaverse-XL dataset.
+
+    Args:
+        render_dir (str): Directory where the objects will be rendered.
+        num_renders (int): Number of renders to save of the object.
+        processes (Optional[int]): Number of processes to use for downloading the
+            objects. If None, defaults to multiprocessing.cpu_count() * 3.
+        save_repo_format (Optional[Literal["zip", "tar", "tar.gz"]]): If not None,
+            the GitHub repo will be deleted after rendering each object from it.
+        only_northern_hemisphere (bool): Only render the northern hemisphere of the
+            object. Useful for rendering objects that are obtained from photogrammetry,
+            since the southern hemisphere is often has holes.
+        render_timeout (int): Number of seconds to wait for the rendering job to
+            complete.
+        gpu_devices (Optional[Union[int, List[int]]]): GPU device(s) to use for
+            rendering. If an int, the GPU device will be randomly selected from 0 to
+            gpu_devices - 1. If a list, the GPU device will be randomly selected from
+            the list. If 0, the CPU will be used for rendering. If None, defaults to
+            use all available GPUs.
+
+    Returns:
+        None
+    """
+    if platform.system() not in ["Linux", "Darwin"]:
+        raise NotImplementedError(
+            f"Platform {platform.system()} is not supported. Use Linux or MacOS."
+        )
+
+    # get the gpu devices to use
+    parsed_gpu_devices: Union[int, List[int]] = 0
+    if gpu_devices is None:
+        parsed_gpu_devices = len(GPUtil.getGPUs())
+
+    if processes is None:
+        processes = multiprocessing.cpu_count() * 3
+
+    objects = get_example_objects()
+    download_github_objects(
+        objects=objects,
+        processes=processes,
+        save_repo_format=save_repo_format,
+        download_dir=render_dir,  # only used when save_repo_format is not None
+        handle_found_object=partial(
+            handle_found_object,
+            render_dir=render_dir,
+            num_renders=num_renders,
+            only_northern_hemisphere=only_northern_hemisphere,
+            gpu_devices=parsed_gpu_devices,
+            render_timeout=render_timeout,
+        ),
+        handle_new_object=handle_new_object,
+        handle_modified_object=partial(
+            handle_modified_object,
+            render_dir=render_dir,
+            num_renders=num_renders,
+            gpu_devices=parsed_gpu_devices,
+            only_northern_hemisphere=only_northern_hemisphere,
+        ),
+        handle_missing_object=handle_missing_object,
+    )
+
+
+if __name__ == "__main__":
+    fire.Fire(render_github_objects)

scripts/rendering/start_x_server.py

@@ -0,0 +1,272 @@
+# Taken from https://github.com/allenai/ai2thor/blob/main/scripts/ai2thor-xorg
+# Starts an x-server to support running Blender on a headless machine with
+# dedicated NVIDIA GPUs
+
+import argparse
+
+#!/usr/bin/env python3
+import os
+import platform
+import re
+import shlex
+import signal
+import subprocess
+import sys
+import time
+
+# Turning off automatic black formatting for this script as it breaks quotes.
+# fmt: off
+from typing import List
+
+PID_FILE = "/var/run/ai2thor-xorg.pid"
+CONFIG_FILE = "/tmp/ai2thor-xorg.conf"
+
+DEFAULT_HEIGHT = 768
+DEFAULT_WIDTH = 1024
+
+
+def process_alive(pid):
+    """
+    Use kill(0) to determine if pid is alive
+    :param pid: process id
+    :rtype: bool
+    """
+    try:
+        os.kill(pid, 0)
+    except OSError:
+        return False
+
+    return True
+
+
+def find_devices(excluded_device_ids):
+    devices = []
+    id_counter = 0
+    for r in pci_records():
+        if r.get("Vendor", "") == "NVIDIA Corporation" and r["Class"] in [
+            "VGA compatible controller",
+            "3D controller",
+        ]:
+            bus_id = "PCI:" + ":".join(
+                map(lambda x: str(int(x, 16)), re.split(r"[:\.]", r["Slot"]))
+            )
+
+            if id_counter not in excluded_device_ids:
+                devices.append(bus_id)
+
+            id_counter += 1
+
+    if not devices:
+        print("Error: ai2thor-xorg requires at least one NVIDIA device")
+        sys.exit(1)
+
+    return devices
+
+def active_display_bus_ids():
+    # this determines whether a monitor is connected to the GPU
+    # if one is, the following Option is added for the Screen "UseDisplayDevice" "None"
+    command = "nvidia-smi --query-gpu=pci.bus_id,display_active --format=csv,noheader"
+    active_bus_ids = set()
+    result = subprocess.run(command, shell=True, stdout=subprocess.PIPE)
+    if result.returncode == 0:
+        for line in result.stdout.decode().strip().split("\n"):
+            nvidia_bus_id, display_status = re.split(r",\s?", line.strip())
+            bus_id = "PCI:" + ":".join(
+                map(lambda x: str(int(x, 16)), re.split(r"[:\.]", nvidia_bus_id)[1:])
+            )
+            if display_status.lower() == "enabled":
+                active_bus_ids.add(bus_id)
+
+    return active_bus_ids
+
+def pci_records():
+    records = []
+    command = shlex.split("lspci -vmm")
+    output = subprocess.check_output(command).decode()
+
+    for devices in output.strip().split("\n\n"):
+        record = {}
+        records.append(record)
+        for row in devices.split("\n"):
+            key, value = row.split("\t")
+            record[key.split(":")[0]] = value
+
+    return records
+
+
+def read_pid():
+    if os.path.isfile(PID_FILE):
+        with open(PID_FILE) as f:
+            return int(f.read())
+    else:
+        return None
+
+
+def start(display: str, excluded_device_ids: List[int], width: int, height: int):
+    pid = read_pid()
+
+    if pid and process_alive(pid):
+        print("Error: ai2thor-xorg is already running with pid: %s" % pid)
+        sys.exit(1)
+
+    with open(CONFIG_FILE, "w") as f:
+        f.write(generate_xorg_conf(excluded_device_ids, width=width, height=height))
+
+    log_file = "/var/log/ai2thor-xorg.%s.log" % display
+    error_log_file = "/var/log/ai2thor-xorg-error.%s.log" % display
+    command = shlex.split(
+        "Xorg -quiet -maxclients 1024 -noreset +extension GLX +extension RANDR +extension RENDER -logfile %s -config %s :%s"
+        % (log_file, CONFIG_FILE, display)
+    )
+
+    pid = None
+    with open(error_log_file, "w") as error_log_f:
+        proc = subprocess.Popen(command, stdin=subprocess.DEVNULL, stdout=subprocess.DEVNULL, stderr=error_log_f)
+        pid = proc.pid
+        try:
+            proc.wait(timeout=0.25)
+        except subprocess.TimeoutExpired:
+            pass
+
+    if pid and process_alive(pid):
+        with open(PID_FILE, "w") as f:
+            f.write(str(proc.pid))
+    else:
+        print("Error: error with command '%s'" % " ".join(command))
+        with open(error_log_file, "r") as f:
+            print(f.read())
+
+
+def print_config(excluded_device_ids: List[int], width: int, height: int):
+    print(generate_xorg_conf(excluded_device_ids, width=width, height=height))
+
+
+def stop():
+    pid = read_pid()
+    if pid and process_alive(pid):
+        os.kill(pid, signal.SIGTERM)
+
+        for i in range(10):
+            time.sleep(0.2)
+            if not process_alive(pid):
+                os.unlink(PID_FILE)
+                break
+
+
+def generate_xorg_conf(
+        excluded_device_ids: List[int], width: int, height: int
+):
+    devices = find_devices(excluded_device_ids)
+    active_display_devices = active_display_bus_ids()
+
+    xorg_conf = []
+
+    device_section = """
+Section "Device"
+    Identifier     "Device{device_id}"
+    Driver         "nvidia"
+    VendorName     "NVIDIA Corporation"
+    BusID          "{bus_id}"
+EndSection
+"""
+    server_layout_section = """
+Section "ServerLayout"
+    Identifier     "Layout0"
+    {screen_records}
+EndSection
+"""
+    screen_section = """
+Section "Screen"
+    Identifier     "Screen{screen_id}"
+    Device         "Device{device_id}"
+    DefaultDepth    24
+    Option         "AllowEmptyInitialConfiguration" "True"
+    Option         "Interactive" "False"
+    {extra_options}
+    SubSection     "Display"
+        Depth       24
+        Virtual {width} {height}
+    EndSubSection
+EndSection
+"""
+    screen_records = []
+    for i, bus_id in enumerate(devices):
+        extra_options = ""
+        if bus_id in active_display_devices:
+            # See https://github.com/allenai/ai2thor/pull/990
+            # when a monitor is connected, this option must be used otherwise
+            # Xorg will fail to start
+            extra_options = 'Option         "UseDisplayDevice" "None"'
+        xorg_conf.append(device_section.format(device_id=i, bus_id=bus_id))
+        xorg_conf.append(screen_section.format(device_id=i, screen_id=i, width=width, height=height, extra_options=extra_options))
+        screen_records.append(
+            'Screen {screen_id} "Screen{screen_id}" 0 0'.format(screen_id=i)
+        )
+
+    xorg_conf.append(
+        server_layout_section.format(screen_records="\n    ".join(screen_records))
+    )
+
+    output = "\n".join(xorg_conf)
+    return output
+
+
+# fmt: on
+
+if __name__ == "__main__":
+    if os.geteuid() != 0:
+        path = os.path.abspath(__file__)
+        print("Executing ai2thor-xorg with sudo")
+        args = ["--", path] + sys.argv[1:]
+        os.execvp("sudo", args)
+
+    if platform.system() != "Linux":
+        print("Error: Can only run ai2thor-xorg on linux")
+        sys.exit(1)
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--exclude-device",
+        help="exclude a specific GPU device",
+        action="append",
+        type=int,
+        default=[],
+    )
+    parser.add_argument(
+        "--width",
+        help="width of the screen to start (should be greater than the maximum"
+        f" width of any ai2thor instance you will start) [default: {DEFAULT_WIDTH}]",
+        type=int,
+        default=DEFAULT_WIDTH,
+    )
+    parser.add_argument(
+        "--height",
+        help="height of the screen to start (should be greater than the maximum"
+        f" height of any ai2thor instance you will start) [default: {DEFAULT_HEIGHT}]",
+        type=int,
+        default=DEFAULT_HEIGHT,
+    )
+    parser.add_argument(
+        "command",
+        help="command to be executed",
+        choices=["start", "stop", "print-config"],
+    )
+    parser.add_argument(
+        "display", help="display to be used", nargs="?", type=int, default=0
+    )
+    args = parser.parse_args()
+    if args.command == "start":
+        start(
+            display=args.display,
+            excluded_device_ids=args.exclude_device,
+            height=args.height,
+            width=args.width,
+        )
+    elif args.command == "stop":
+        stop()
+    elif args.command == "print-config":
+        print_config(
+            excluded_device_ids=args.exclude_device,
+            width=args.width,
+            height=args.height,
+        )

tests/test_api.py

@@ -7,10 +7,6 @@ import pytest
 
 from objaverse_xl.github import _process_repo, download_github_objects
 
-# @pytest.mark.parametrize("message", ["hello", "world"])
-# def test_hello_world(message):
-#     hello_world(message)
-
 
 def test_github_process_repo():
     download_dir = "~/.objaverse-tests"