procfunc 0.30.0__py3-none-any.whl

procfunc/ops/primitives/mesh.py

@@ -0,0 +1,358 @@
+from typing import Any
+
+import bpy
+import numpy as np
+from mathutils import Euler, Vector
+
+from procfunc import types as t
+
+
+def mesh_single_vertex() -> t.MeshObject:
+    mesh = bpy.data.meshes.new(mesh_single_vertex.__name__)
+    mesh.vertices.add(1)
+    mesh.vertices[0].co = (0, 0, 0)
+    obj = bpy.data.objects.new(mesh_single_vertex.__name__, mesh)
+    bpy.context.scene.collection.objects.link(obj)
+    return t.MeshObject(obj)
+
+
+"""
+def point_cloud(
+    points: list[Vector],
+    edges: list[tuple[int, int]] | None = None,
+) -> t.MeshObject:
+    mesh = bpy.data.meshes.new(point_cloud.__name__)
+    mesh.from_pydata(points, edges, [])
+    obj = bpy.data.objects.new(point_cloud.__name__, mesh)
+    bpy.context.scene.collection.objects.link(obj)
+    return t.MeshObject(obj)
+"""
+
+
+def mesh_from_numpy(
+    vertices: np.ndarray | None = None,
+    edges: np.ndarray | None = None,
+    faces: np.ndarray | None = None,
+) -> t.MeshObject:
+    if vertices is None:
+        vertices = np.array([])
+    if edges is None:
+        edges = np.array([])
+    if faces is None:
+        faces = np.array([])
+
+    mesh = bpy.data.meshes.new(mesh_from_numpy.__name__)
+    mesh.from_pydata(vertices, edges, faces)
+    obj = bpy.data.objects.new(mesh_from_numpy.__name__, mesh)
+    bpy.context.scene.collection.objects.link(obj)
+    return t.MeshObject(obj)
+
+
+def mesh_line(
+    points: list[Vector] | np.ndarray,
+) -> t.MeshObject:
+    idxs = np.arange(len(points))
+    edges = np.stack([idxs[:-1], idxs[1:]], axis=-1)
+
+    mesh = bpy.data.meshes.new(mesh_line.__name__)
+    mesh.from_pydata(points, edges, [])
+    obj = bpy.data.objects.new(mesh_line.__name__, mesh)
+    bpy.context.scene.collection.objects.link(obj)
+    return t.MeshObject(obj)
+
+
+def empty(
+    disp_type: str = "PLAIN_AXES",
+    display_size: float = 0.1,
+) -> t.MeshObject:
+    obj = bpy.data.objects.new(empty.__name__, None)
+    bpy.context.scene.collection.objects.link(obj)
+    obj.empty_display_size = display_size
+    obj.empty_display_type = disp_type
+    return t.MeshObject(obj)
+
+
+def mesh_uv_sphere(
+    segments: int = 32,
+    ring_count: int = 16,
+    radius: float = 1.0,
+    calc_uvs: bool = True,
+    enter_editmode: bool = False,
+    align: str = "WORLD",
+    location: Vector = Vector((0.0, 0.0, 0.0)),
+    rotation: Euler = Euler((0.0, 0.0, 0.0)),
+    scale: Vector = Vector((1.0, 1.0, 1.0)),
+    **kwargs: Any,
+) -> t.MeshObject:
+    """Generate a UV sphere primitive with specified parameters."""
+    bpy.ops.mesh.primitive_uv_sphere_add(
+        segments=segments,
+        ring_count=ring_count,
+        radius=radius,
+        calc_uvs=calc_uvs,
+        enter_editmode=enter_editmode,
+        align=align,
+        location=location,
+        rotation=rotation,
+        scale=scale,
+        **kwargs,
+    )
+    obj = bpy.context.active_object
+    return t.MeshObject(obj)
+
+
+def mesh_plane(
+    size: float = 2.0,
+    calc_uvs: bool = True,
+    enter_editmode: bool = False,
+    align: str = "WORLD",
+    location: Vector = Vector((0.0, 0.0, 0.0)),
+    rotation: Euler = Euler((0.0, 0.0, 0.0)),
+    scale: Vector = Vector((1.0, 1.0, 1.0)),
+    **kwargs: Any,
+) -> t.MeshObject:
+    """Generate a plane primitive with specified parameters."""
+    bpy.ops.mesh.primitive_plane_add(
+        size=size,
+        calc_uvs=calc_uvs,
+        enter_editmode=enter_editmode,
+        align=align,
+        location=location,
+        rotation=rotation,
+        scale=scale,
+        **kwargs,
+    )
+    obj = bpy.context.active_object
+    return t.MeshObject(obj)
+
+
+def mesh_cube(
+    size: float = 2.0,
+    calc_uvs: bool = True,
+    enter_editmode: bool = False,
+    align: str = "WORLD",
+    location: Vector = Vector((0.0, 0.0, 0.0)),
+    rotation: Euler = Euler((0.0, 0.0, 0.0)),
+    scale: Vector = Vector((1.0, 1.0, 1.0)),
+    **kwargs: Any,
+) -> t.MeshObject:
+    """Generate a cube primitive with specified parameters."""
+    bpy.ops.mesh.primitive_cube_add(
+        size=size,
+        calc_uvs=calc_uvs,
+        enter_editmode=enter_editmode,
+        align=align,
+        location=Vector(location),
+        rotation=Euler(rotation),
+        scale=Vector(scale),
+        **kwargs,
+    )
+    obj = bpy.context.active_object
+    return t.MeshObject(obj)
+
+
+def mesh_icosphere(
+    subdivisions: int = 2,
+    radius: float = 1.0,
+    calc_uvs: bool = True,
+    enter_editmode: bool = False,
+    align: str = "WORLD",
+    location: Vector = Vector((0.0, 0.0, 0.0)),
+    rotation: Euler = Euler((0.0, 0.0, 0.0)),
+    scale: Vector = Vector((1.0, 1.0, 1.0)),
+    **kwargs: Any,
+) -> t.MeshObject:
+    """Generate an icosphere primitive with specified parameters."""
+    bpy.ops.mesh.primitive_ico_sphere_add(
+        subdivisions=subdivisions,
+        radius=radius,
+        calc_uvs=calc_uvs,
+        enter_editmode=enter_editmode,
+        align=align,
+        location=location,
+        rotation=rotation,
+        scale=scale,
+        **kwargs,
+    )
+    obj = bpy.context.active_object
+    return t.MeshObject(obj)
+
+
+def mesh_cylinder(
+    vertices: int = 32,
+    radius: float = 1.0,
+    depth: float = 2.0,
+    end_fill_type: str = "NGON",
+    calc_uvs: bool = True,
+    enter_editmode: bool = False,
+    align: str = "WORLD",
+    location: Vector = Vector((0.0, 0.0, 0.0)),
+    rotation: Euler = Euler((0.0, 0.0, 0.0)),
+    scale: Vector = Vector((1.0, 1.0, 1.0)),
+    **kwargs: Any,
+) -> t.MeshObject:
+    """Generate a cylinder primitive with specified parameters."""
+    bpy.ops.mesh.primitive_cylinder_add(
+        vertices=vertices,
+        radius=radius,
+        depth=depth,
+        end_fill_type=end_fill_type,
+        calc_uvs=calc_uvs,
+        enter_editmode=enter_editmode,
+        align=align,
+        location=location,
+        rotation=rotation,
+        scale=scale,
+        **kwargs,
+    )
+    obj = bpy.context.active_object
+    return t.MeshObject(obj)
+
+
+def mesh_cone(
+    vertices: int = 32,
+    radius1: float = 1.0,
+    radius2: float = 0.0,
+    depth: float = 2.0,
+    end_fill_type: str = "NGON",
+    calc_uvs: bool = True,
+    enter_editmode: bool = False,
+    align: str = "WORLD",
+    location: Vector = Vector((0.0, 0.0, 0.0)),
+    rotation: Euler = Euler((0.0, 0.0, 0.0)),
+    scale: Vector = Vector((1.0, 1.0, 1.0)),
+    **kwargs: Any,
+) -> t.MeshObject:
+    """Generate a cone primitive with specified parameters."""
+    bpy.ops.mesh.primitive_cone_add(
+        vertices=vertices,
+        radius1=radius1,
+        radius2=radius2,
+        depth=depth,
+        end_fill_type=end_fill_type,
+        calc_uvs=calc_uvs,
+        enter_editmode=enter_editmode,
+        align=align,
+        location=location,
+        rotation=rotation,
+        scale=scale,
+        **kwargs,
+    )
+    obj = bpy.context.active_object
+    return t.MeshObject(obj)
+
+
+def mesh_torus(
+    align: str = "WORLD",
+    location: Vector = Vector((0.0, 0.0, 0.0)),
+    rotation: Euler = Euler((0.0, 0.0, 0.0)),
+    major_segments: int = 48,
+    minor_segments: int = 12,
+    mode: str = "MAJOR_MINOR",
+    major_radius: float = 1.0,
+    minor_radius: float = 0.25,
+    abso_major_rad: float = 1.25,
+    abso_minor_rad: float = 0.75,
+    generate_uvs: bool = True,
+    **kwargs: Any,
+) -> t.MeshObject:
+    """Generate a torus primitive with specified parameters."""
+    bpy.ops.mesh.primitive_torus_add(
+        align=align,
+        location=location,
+        rotation=rotation,
+        major_segments=major_segments,
+        minor_segments=minor_segments,
+        mode=mode,
+        major_radius=major_radius,
+        minor_radius=minor_radius,
+        abso_major_rad=abso_major_rad,
+        abso_minor_rad=abso_minor_rad,
+        generate_uvs=generate_uvs,
+        **kwargs,
+    )
+    obj = bpy.context.active_object
+    return t.MeshObject(obj)
+
+
+def mesh_circle(
+    vertices: int = 32,
+    radius: float = 1.0,
+    fill_type: str = "NOTHING",
+    calc_uvs: bool = True,
+    enter_editmode: bool = False,
+    align: str = "WORLD",
+    location: Vector = Vector((0.0, 0.0, 0.0)),
+    rotation: Euler = Euler((0.0, 0.0, 0.0)),
+    scale: Vector = Vector((1.0, 1.0, 1.0)),
+    **kwargs: Any,
+) -> t.MeshObject:
+    """Generate a circle primitive with specified parameters."""
+    bpy.ops.mesh.primitive_circle_add(
+        vertices=vertices,
+        radius=radius,
+        fill_type=fill_type,
+        calc_uvs=calc_uvs,
+        enter_editmode=enter_editmode,
+        align=align,
+        location=location,
+        rotation=rotation,
+        scale=scale,
+        **kwargs,
+    )
+    obj = bpy.context.active_object
+    return t.MeshObject(obj)
+
+
+def mesh_grid(
+    x_subdivisions: int = 10,
+    y_subdivisions: int = 10,
+    size: float = 2.0,
+    calc_uvs: bool = True,
+    enter_editmode: bool = False,
+    align: str = "WORLD",
+    location: Vector = Vector((0.0, 0.0, 0.0)),
+    rotation: Euler = Euler((0.0, 0.0, 0.0)),
+    scale: Vector = Vector((1.0, 1.0, 1.0)),
+    **kwargs: Any,
+) -> t.MeshObject:
+    """Generate a grid primitive with specified parameters."""
+    bpy.ops.mesh.primitive_grid_add(
+        x_subdivisions=x_subdivisions,
+        y_subdivisions=y_subdivisions,
+        size=size,
+        calc_uvs=calc_uvs,
+        enter_editmode=enter_editmode,
+        align=align,
+        location=location,
+        rotation=rotation,
+        scale=scale,
+        **kwargs,
+    )
+    obj = bpy.context.active_object
+    return t.MeshObject(obj)
+
+
+def mesh_monkey(
+    size: float = 2.0,
+    calc_uvs: bool = True,
+    enter_editmode: bool = False,
+    align: str = "WORLD",
+    location: Vector = Vector((0.0, 0.0, 0.0)),
+    rotation: Euler = Euler((0.0, 0.0, 0.0)),
+    scale: Vector = Vector((1.0, 1.0, 1.0)),
+    **kwargs: Any,
+) -> t.MeshObject:
+    """Generate a monkey (Suzanne) primitive with specified parameters."""
+    bpy.ops.mesh.primitive_monkey_add(
+        size=size,
+        calc_uvs=calc_uvs,
+        enter_editmode=enter_editmode,
+        align=align,
+        location=location,
+        rotation=rotation,
+        scale=scale,
+        **kwargs,
+    )
+    obj = bpy.context.active_object
+    return t.MeshObject(obj)

procfunc/ops/uv.py

@@ -0,0 +1,271 @@
+from typing import Literal
+
+import bpy
+import numpy as np
+
+import procfunc as pf
+from procfunc import types as t
+from procfunc.ops._util import execute_mesh_op
+
+
+def _ensure_uv_layer(obj: bpy.types.Object, uv_name: str) -> None:
+    """Ensure a UV layer exists with the given name, removing any existing one first."""
+    mesh = obj.data
+    if uv_name in mesh.uv_layers:
+        mesh.uv_layers.remove(mesh.uv_layers[uv_name])
+    new_layer = mesh.uv_layers.new(name=uv_name)
+    mesh.uv_layers.active = new_layer
+
+
+@pf.tracer.primitive(mutates=["mutates_obj"])
+def cube_project(
+    mutates_obj: t.MeshObject,
+    vertex_mask: np.ndarray | None = None,
+    edge_mask: np.ndarray | None = None,
+    face_mask: np.ndarray | None = None,
+    uv_name: str = "UVMap",
+    cube_size: float = 1.0,
+    correct_aspect: bool = True,
+    clip_to_bounds: bool = False,
+    scale_to_bounds: bool = False,
+) -> None:
+    """
+    Project the UV vertices of the mesh over the six faces of a cube
+
+    Based on bpy.ops.uv.cube_project
+
+    Args:
+        vertex_mask: Boolean array selecting vertices to project.
+        edge_mask: Boolean array selecting edges to project.
+        face_mask: Boolean array selecting faces to project.
+        uv_name: Name of the UV layer to create/replace.
+    """
+    _ensure_uv_layer(mutates_obj.item(), uv_name)
+    execute_mesh_op(
+        bpy.ops.uv.cube_project,
+        mutates_obj,
+        vertex_mask=vertex_mask,
+        edge_mask=edge_mask,
+        face_mask=face_mask,
+        cube_size=cube_size,
+        correct_aspect=correct_aspect,
+        clip_to_bounds=clip_to_bounds,
+        scale_to_bounds=scale_to_bounds,
+    )
+
+
+@pf.tracer.primitive(mutates=["mutates_obj"])
+def cylinder_project(
+    mutates_obj: t.MeshObject,
+    vertex_mask: np.ndarray | None = None,
+    edge_mask: np.ndarray | None = None,
+    face_mask: np.ndarray | None = None,
+    uv_name: str = "UVMap",
+    direction: Literal[
+        "VIEW_ON_EQUATOR", "VIEW_ON_POLES", "ALIGN_TO_OBJECT"
+    ] = "VIEW_ON_EQUATOR",
+    align: Literal["POLAR_ZX", "POLAR_ZY"] = "POLAR_ZX",
+    pole: Literal["PINCH", "FAN"] = "PINCH",
+    seam: bool = False,
+    radius: float = 1.0,
+    correct_aspect: bool = True,
+    clip_to_bounds: bool = False,
+    scale_to_bounds: bool = False,
+) -> None:
+    """
+    Project the UV vertices of the mesh over the curved wall of a cylinder
+
+    Based on bpy.ops.uv.cylinder_project
+
+    Args:
+        vertex_mask: Boolean array selecting vertices to project.
+        edge_mask: Boolean array selecting edges to project.
+        face_mask: Boolean array selecting faces to project.
+        uv_name: Name of the UV layer to create/replace.
+    """
+    _ensure_uv_layer(mutates_obj.item(), uv_name)
+    execute_mesh_op(
+        bpy.ops.uv.cylinder_project,
+        mutates_obj,
+        vertex_mask=vertex_mask,
+        edge_mask=edge_mask,
+        face_mask=face_mask,
+        direction=direction,
+        align=align,
+        pole=pole,
+        seam=seam,
+        radius=radius,
+        correct_aspect=correct_aspect,
+        clip_to_bounds=clip_to_bounds,
+        scale_to_bounds=scale_to_bounds,
+    )
+
+
+@pf.tracer.primitive(mutates=["mutates_obj"])
+def project_from_view(
+    mutates_obj: t.MeshObject,
+    vertex_mask: np.ndarray | None = None,
+    edge_mask: np.ndarray | None = None,
+    face_mask: np.ndarray | None = None,
+    uv_name: str = "UVMap",
+    orthographic: bool = False,
+    camera_bounds: bool = True,
+    correct_aspect: bool = True,
+    clip_to_bounds: bool = False,
+    scale_to_bounds: bool = False,
+) -> None:
+    """
+    Project the UV vertices of the mesh as seen in current 3D view
+
+    Based on bpy.ops.uv.project_from_view
+
+    Args:
+        vertex_mask: Boolean array selecting vertices to project.
+        edge_mask: Boolean array selecting edges to project.
+        face_mask: Boolean array selecting faces to project.
+        uv_name: Name of the UV layer to create/replace.
+    """
+    _ensure_uv_layer(mutates_obj.item(), uv_name)
+    execute_mesh_op(
+        bpy.ops.uv.project_from_view,
+        mutates_obj,
+        vertex_mask=vertex_mask,
+        edge_mask=edge_mask,
+        face_mask=face_mask,
+        orthographic=orthographic,
+        camera_bounds=camera_bounds,
+        correct_aspect=correct_aspect,
+        clip_to_bounds=clip_to_bounds,
+        scale_to_bounds=scale_to_bounds,
+    )
+
+
+@pf.tracer.primitive(mutates=["mutates_obj"])
+def smart_project(
+    mutates_obj: t.MeshObject,
+    vertex_mask: np.ndarray | None = None,
+    edge_mask: np.ndarray | None = None,
+    face_mask: np.ndarray | None = None,
+    uv_name: str = "UVMap",
+    angle_limit: float = 1.15192,
+    margin_method: Literal["SCALED", "ADD", "FRACTION"] = "SCALED",
+    rotate_method: Literal[
+        "AXIS_ALIGNED", "AXIS_ALIGNED_X", "AXIS_ALIGNED_Y"
+    ] = "AXIS_ALIGNED_Y",
+    island_margin: float = 0.0,
+    area_weight: float = 0.0,
+    correct_aspect: bool = True,
+    scale_to_bounds: bool = False,
+) -> None:
+    """
+    Projection unwraps the selected faces of mesh objects
+
+    Based on bpy.ops.uv.smart_project
+
+    Args:
+        vertex_mask: Boolean array selecting vertices to project.
+        edge_mask: Boolean array selecting edges to project.
+        face_mask: Boolean array selecting faces to project.
+        uv_name: Name of the UV layer to create/replace.
+    """
+    _ensure_uv_layer(mutates_obj.item(), uv_name)
+    execute_mesh_op(
+        bpy.ops.uv.smart_project,
+        mutates_obj,
+        vertex_mask=vertex_mask,
+        edge_mask=edge_mask,
+        face_mask=face_mask,
+        angle_limit=angle_limit,
+        margin_method=margin_method,
+        rotate_method=rotate_method,
+        island_margin=island_margin,
+        area_weight=area_weight,
+        correct_aspect=correct_aspect,
+        scale_to_bounds=scale_to_bounds,
+    )
+
+
+@pf.tracer.primitive(mutates=["mutates_obj"])
+def sphere_project(
+    mutates_obj: t.MeshObject,
+    vertex_mask: np.ndarray | None = None,
+    edge_mask: np.ndarray | None = None,
+    face_mask: np.ndarray | None = None,
+    uv_name: str = "UVMap",
+    direction: Literal[
+        "VIEW_ON_EQUATOR", "VIEW_ON_POLES", "ALIGN_TO_OBJECT"
+    ] = "VIEW_ON_EQUATOR",
+    align: Literal["POLAR_ZX", "POLAR_ZY"] = "POLAR_ZX",
+    pole: Literal["PINCH", "FAN"] = "PINCH",
+    seam: bool = False,
+    correct_aspect: bool = True,
+    clip_to_bounds: bool = False,
+    scale_to_bounds: bool = False,
+) -> None:
+    """
+    Project the UV vertices of the mesh over the curved surface of a sphere
+
+    Based on bpy.ops.uv.sphere_project
+
+    Args:
+        vertex_mask: Boolean array selecting vertices to project.
+        edge_mask: Boolean array selecting edges to project.
+        face_mask: Boolean array selecting faces to project.
+        uv_name: Name of the UV layer to create/replace.
+    """
+    _ensure_uv_layer(mutates_obj.item(), uv_name)
+    execute_mesh_op(
+        bpy.ops.uv.sphere_project,
+        mutates_obj,
+        vertex_mask=vertex_mask,
+        edge_mask=edge_mask,
+        face_mask=face_mask,
+        direction=direction,
+        align=align,
+        pole=pole,
+        seam=seam,
+        correct_aspect=correct_aspect,
+        clip_to_bounds=clip_to_bounds,
+        scale_to_bounds=scale_to_bounds,
+    )
+
+
+@pf.tracer.primitive(mutates=["mutates_obj"])
+def unwrap(
+    mutates_obj: t.MeshObject,
+    vertex_mask: np.ndarray | None = None,
+    edge_mask: np.ndarray | None = None,
+    face_mask: np.ndarray | None = None,
+    uv_name: str = "UVMap",
+    method: Literal["ANGLE_BASED", "CONFORMAL"] = "ANGLE_BASED",
+    fill_holes: bool = True,
+    correct_aspect: bool = True,
+    use_subsurf_data: bool = False,
+    margin_method: Literal["SCALED", "ADD", "FRACTION"] = "SCALED",
+    margin: float = 0.001,
+) -> None:
+    """
+    Unwrap the mesh of the object being edited
+
+    Based on bpy.ops.uv.unwrap
+
+    Args:
+        vertex_mask: Boolean array selecting vertices to unwrap.
+        edge_mask: Boolean array selecting edges to unwrap.
+        face_mask: Boolean array selecting faces to unwrap.
+        uv_name: Name of the UV layer to create/replace.
+    """
+    _ensure_uv_layer(mutates_obj.item(), uv_name)
+    execute_mesh_op(
+        bpy.ops.uv.unwrap,
+        mutates_obj,
+        vertex_mask=vertex_mask,
+        edge_mask=edge_mask,
+        face_mask=face_mask,
+        method=method,
+        fill_holes=fill_holes,
+        correct_aspect=correct_aspect,
+        use_subsurf_data=use_subsurf_data,
+        margin_method=margin_method,
+        margin=margin,
+    )