blender

plantimager.blender

Camera

Camera(scene, data, hdri_enabled=False)

Source code in plantimager/blender.py

def __init__(self, scene, data, hdri_enabled=False):
    self.scene = scene
    self.cam = scene.camera
    self.render = scene.render
    self.data = data
    self.hdri_enabled = hdri_enabled
    if hdri_enabled:
        self.setup_hdri()
    else:
        self.setup_background()

set_intrinsics

set_intrinsics(width, height, focal)

:input w image width :input h image height :input f focal length (equiv. 35mm)

Source code in plantimager/blender.py

def set_intrinsics(self, width, height, focal):
    """
    :input w image width
    :input h image height
    :input f focal length (equiv. 35mm)
    """

    self.render.resolution_x = width
    self.render.resolution_y = height
    self.render.resolution_percentage = 100

    # Set camera fov in degrees
    self.cam.data.angle = 2 * np.arctan(35 / focal)
    self.cam.data.clip_end = 10000

MultiClassObject

MultiClassObject(scene, data)

Source code in plantimager/blender.py

def __init__(self, scene, data):
    self.data = data
    self.scene = scene
    self.objects = {}
    self.classes = []
    self.scene_materials = [m.name for m in self.data.materials]
    self.scene_objects = [o.name for o in self.data.objects]

load_obj

load_obj(fname, dx=None, dy=None, dz=None, colorize=True, palette_location=None)

move object by dx, dy, dz if specified

Source code in plantimager/blender.py

def load_obj(self, fname, dx=None, dy=None, dz=None, colorize=True, palette_location=None):
    """move object by dx, dy, dz if specified"""

    for o in self.objects.values():
        self.data.objects.remove(o, do_unlink=True)
    self.objects = {}

    for m in bpy.data.materials:
        if not m.name in self.scene_materials:
            bpy.data.materials.remove(m)

    bpy.ops.import_scene.obj(filepath=fname)
    self.update_classes(colorize, palette_location)

    for m in self.classes:
        for o in self.data.objects:
            if m in o.name:
                self.objects[m] = o
                break

    try:
        dx = float(dx)
    except:
        dx = 0.0
    try:
        dy = float(dy)
    except:
        dy = 0.0
    try:
        dz = float(dz)
    except:
        dz = 0.0

    for o in bpy.context.scene.objects:
        if o.name not in self.scene_objects:
            bpy.ops.object.select_all(action='DESELECT')
            # bpy.context.scene.objects.link(o)
            o.location.x = dx
            o.location.y = dy
            o.location.x = dz
            o.select_set(True)
            bpy.context.view_layer.objects.active = o
            logger.debug("transform %s" % o.name)
            bpy.ops.object.select_all(action='DESELECT')

    self.location = {
        "x": dx,
        "y": dy,
        "z": dz
    }

_get_log_filepath

_get_log_filepath(path)

Returns a path for the blender log file.

Parameters:

Name	Type	Description	Default
path	str	A file path or directory to use as blender log file location.	required

Returns:

Type	Description
str	The blender log file path.

Source code in plantimager/blender.py

def _get_log_filepath(path):
    """Returns a path for the blender log file.

    Parameters
    ----------
    path : str
        A file path or directory to use as blender log file location.

    Returns
    -------
    str
        The blender log file path.
    """
    from pathlib import Path
    path = Path(path)
    if path.is_file():
        path = path.parent
    return str(path.joinpath('blender.log'))

check_engine

check_engine(engine='CYCLES')

Check the rendering engine.

Parameters:

Name	Type	Description	Default
engine	(CYCLES, BLENDER_EEVEE, BLENDER_WORKBENCH)	The name of the rendering engine to use. Defaults to CYCLES.	"CYCLES"

Source code in plantimager/blender.py

def check_engine(engine="CYCLES"):
    """Check the rendering engine.

    Parameters
    ----------
    engine : {"CYCLES", "BLENDER_EEVEE", "BLENDER_WORKBENCH"}, optional
        The name of the rendering engine to use.
        Defaults to ``CYCLES``.
    """
    engine = engine.upper()
    try:
        assert bpy.context.scene.render.engine == engine
    except AssertionError:
        logger.warning(f"The selected engine is not '{engine}', it is '{bpy.context.scene.render.engine}'!")
    return

clean_mesh

clean_mesh(fname, out)

Mesh cleaning function.

Parameters:

Name	Type	Description	Default
fname	str	The file path to the mesh object to load in Blender.	required
out	str	The file path to us to export the cleaned mesh object.	required

Source code in plantimager/blender.py

def clean_mesh(fname, out):
    """Mesh cleaning function.

    Parameters
    ----------
    fname : str
        The file path to the mesh object to load in Blender.
    out : str
        The file path to us to export the cleaned mesh object.
    """
    check_engine()
    log = _get_log_filepath(fname)
    load_obj(fname, log=log)

    def _clean_obj(out):
        bpy.ops.object.select_all(action='SELECT')
        bpy.ops.object.mode_set(mode='EDIT')
        bpy.ops.mesh.select_all(action='SELECT')
        # Remove vertices that are too close:
        bpy.ops.mesh.remove_doubles(threshold=0.01)
        # Close any hole in the mesh:
        bpy.ops.mesh.fill_holes(0)
        bpy.ops.mesh.set_normals_from_faces()
        # Export the mesh:
        bpy.ops.export_scene.obj(filepath=out)

    # Redirect blender outputs to a log file:
    with open(log, mode="a") as f:
        with redirect_stdout(f), redirect_stderr(f):
            _clean_obj(out)

    return

load_obj

load_obj(fname, log=None)

Load a mesh in Blender.

Parameters:

Name	Type	Description	Default
fname	str	The file path to the mesh object to load in Blender.	required
log	str	The blender log file path.	None

Source code in plantimager/blender.py

def load_obj(fname, log=None):
    """Load a mesh in Blender.

    Parameters
    ----------
    fname : str
        The file path to the mesh object to load in Blender.
    log : str, optional
        The blender log file path.
    """
    if log is None:
        log = _get_log_filepath(fname)

    def _clean_scene():
        # Start by selecting all objects from initialized scene (with a cube) and remove them all:
        bpy.ops.object.select_all(action='SELECT')
        bpy.ops.object.delete()

    def _open_obj(fname):
        # Load the mesh in Blender:
        bpy.ops.import_scene.obj(filepath=fname)

    with open(log, mode="a") as f:
        # Redirect blender outputs to a log file:
        with redirect_stdout(f), redirect_stderr(f):
            _clean_scene()
            _open_obj(fname)

    # List all imported objects & set them as active:
    o = bpy.data.objects[list(bpy.data.objects.keys())[0]]
    bpy.context.view_layer.objects.active = o
    return

split_by_material

split_by_material(fname, out, material_class_corres)

Mesh splitting function.

Parameters:

Name	Type	Description	Default
fname	str	The file path to the mesh object to load in Blender.	required
out	str	The file path to us to export the cleaned mesh object.	required
material_class_corres	dict	A renaming dictionary, map LPY class names to semantic class names.	required

Source code in plantimager/blender.py

def split_by_material(fname, out, material_class_corres):
    """Mesh splitting function.

    Parameters
    ----------
    fname : str
        The file path to the mesh object to load in Blender.
    out : str
        The file path to us to export the cleaned mesh object.
    material_class_corres : dict
        A renaming dictionary, map LPY class names to semantic class names.
    """
    check_engine()
    log = _get_log_filepath(fname)
    load_obj(fname, log=log)

    bpy.ops.object.mode_set(mode='EDIT')
    bpy.ops.mesh.select_all(action='SELECT')
    bpy.ops.mesh.separate(type='MATERIAL')
    bpy.ops.object.mode_set(mode='OBJECT')

    # After separating, all pieces are selected and named accordingly:
    for o in bpy.context.selected_objects:
        # Remove x rotation from LPY
        o.rotation_euler[0] = 0
        # Rename object by the material applied to it
        if o.active_material.name in material_class_corres:
            class_name = material_class_corres[o.active_material.name]
            o.name = class_name
            o.active_material.name = class_name
        else:
            o.name = o.active_material.name

    # Export the mesh:
    with open(log, mode="a") as f:
        with redirect_stdout(f), redirect_stderr(f):
            bpy.ops.export_scene.obj(filepath=out)

    return