texture3d 0.2.0__py3-none-any.whl

texture3d/__init__.py

@@ -0,0 +1,31 @@
+"""texture3d: texture a triangle mesh from posed RGB-D frames.
+
+Each face is textured from one keyframe. Patches of same-keyframe faces are
+cut from that image, seams between patches are levelled, and the patches
+are packed into a single atlas (see `texture3d.mapping`). Built on trimesh.
+
+    import texture3d
+
+    frames = texture3d.load_dataset("apt0_seq0")   # or build RGBDFrames yourself
+    result = texture3d.bake("mesh.ply", frames)
+    result.export("textured.obj")                # or .glb
+"""
+
+from texture3d.bake import BakeResult, bake
+from texture3d.camera import PinholeCamera, RGBDFrame
+from texture3d.config import BakeConfig, KeyframeConfig, MappingConfig
+from texture3d.io import load_dataset
+
+__version__ = "0.2.0"
+
+__all__ = [
+    "bake",
+    "BakeResult",
+    "BakeConfig",
+    "KeyframeConfig",
+    "MappingConfig",
+    "PinholeCamera",
+    "RGBDFrame",
+    "load_dataset",
+    "__version__",
+]

texture3d/bake.py

@@ -0,0 +1,159 @@
+"""End-to-end texture baking: mesh + posed RGB-D frames -> textured trimesh.
+
+  keyframes -> views -> texture mapping (score, label, patch, level, pack)
+  -> textured trimesh
+
+The mapping (`texture3d.mapping`) textures each face from one keyframe, cuts
+patches of same-keyframe faces out of that keyframe, levels the seams and
+packs the patches into one atlas.
+"""
+
+from __future__ import annotations
+
+import time
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Iterable, List, Optional, Union
+
+import cv2
+import numpy as np
+import trimesh
+
+from texture3d import mapping
+from texture3d.camera import RGBDFrame
+from texture3d.config import BakeConfig
+from texture3d.keyframes import select_keyframes
+
+MeshLike = Union[trimesh.Trimesh, str, Path]
+
+
+@dataclass
+class BakeResult:
+    mesh: trimesh.Trimesh  # textured mesh (TextureVisuals with baked image)
+    texture: np.ndarray  # (S, S, 3) uint8 RGB
+    stats: dict
+
+    def export(self, path: Union[str, Path]) -> Path:
+        """Write the textured mesh (format from extension: .obj, .glb, ...)."""
+        path = Path(path)
+        path.parent.mkdir(parents=True, exist_ok=True)
+        self.mesh.export(path)
+        return path
+
+
+def _load_mesh(mesh: MeshLike) -> trimesh.Trimesh:
+    if isinstance(mesh, trimesh.Trimesh):
+        return mesh
+    # process=False preserves vertex/face order and never merges vertices.
+    loaded = trimesh.load(mesh, process=False, force="mesh")
+    if not isinstance(loaded, trimesh.Trimesh) or len(loaded.faces) == 0:
+        raise ValueError(f"Not a triangle mesh: {mesh}")
+    return loaded
+
+
+def _material(texture: np.ndarray):
+    from PIL import Image
+
+    # Ka/Kd white + Ks black: viewers multiply the texture by Kd, and
+    # trimesh's default 0.4 grey would darken everything.
+    return trimesh.visual.material.SimpleMaterial(
+        image=Image.fromarray(texture),
+        name="texture3d",
+        ambient=[255, 255, 255, 255],
+        diffuse=[255, 255, 255, 255],
+        specular=[0, 0, 0, 255],
+    )
+
+
+def _views(keyframes: List[RGBDFrame]) -> List[mapping.View]:
+    """The mapping's views: BGR pixels and a camera with R world-to-camera and
+    C the centre in world coordinates, from each frame's camera-to-world pose."""
+    views = []
+    for frame in keyframes:
+        w2c = frame.pose_w2c
+        cam = frame.camera
+        camera = mapping.Camera(
+            fx=cam.fx, fy=cam.fy, cx=cam.cx, cy=cam.cy, R=w2c[:3, :3].copy(), C=frame.pose_c2w[:3, 3].copy()
+        )
+        views.append(mapping.View(bgr=cv2.cvtColor(frame.load_rgb(), cv2.COLOR_RGB2BGR), camera=camera))
+    return views
+
+
+def _output_mesh(mesh: trimesh.Trimesh, result: mapping.Result, texture: np.ndarray) -> trimesh.Trimesh:
+    """The textured result as a trimesh with per-vertex UVs. A vertex has one
+    texture coordinate per patch it belongs to (its projection into that
+    patch's view), so vertices are split along patch borders."""
+    faces = np.asarray(mesh.faces)
+    vertices = np.asarray(mesh.vertices, dtype=np.float64)
+    size = result.atlas_size
+    corner_vertex = faces.ravel()
+    corner_patch = np.repeat(result.face_patch, 3)
+    key = corner_vertex * (result.patch_count + 1) + corner_patch
+    unique_key, new_index = np.unique(key, return_inverse=True)
+    new_vertices = vertices[unique_key // (result.patch_count + 1)]
+    # Pixel centres to OBJ UVs: u right, v up from the bottom-left.
+    tc = result.face_texcoords.reshape(-1, 2).astype(np.float64)
+    uv = np.empty((len(unique_key), 2), dtype=np.float64)
+    uv[new_index] = np.stack([(tc[:, 0] + 0.5) / size, 1.0 - (tc[:, 1] + 0.5) / size], axis=-1)
+    visual = trimesh.visual.TextureVisuals(uv=uv, material=_material(texture))
+    return trimesh.Trimesh(vertices=new_vertices, faces=new_index.reshape(-1, 3), visual=visual, process=False)
+
+
+def bake(
+    mesh: MeshLike,
+    frames: Iterable[RGBDFrame],
+    config: Optional[BakeConfig] = None,
+    verbose: bool = True,
+) -> BakeResult:
+    """Texture `mesh` from posed RGB-D `frames`: every face from one keyframe,
+    seams levelled. Any UVs the mesh carries are ignored, since the mapping's
+    UVs follow the labelling. Returns a `BakeResult` whose `.mesh` is a
+    textured `trimesh.Trimesh` ready to `.export()`."""
+    cfg = config or BakeConfig()
+    t0 = time.time()
+    mesh = _load_mesh(mesh)
+
+    def log(msg: str) -> None:
+        if verbose:
+            print(msg)
+
+    vertices = np.asarray(mesh.vertices, dtype=np.float32)
+    faces = np.asarray(mesh.faces)
+    log(f"mesh: {len(vertices)} verts, {len(faces)} faces")
+    frames = list(frames)
+    keyframes = select_keyframes(frames, cfg.keyframes)
+    log(f"keyframes: {len(keyframes)} / {len(frames)} frames")
+    views = _views(keyframes)
+    m = cfg.mapping
+    empty = m.empty_color
+    tuning = mapping.Tuning(
+        outlier_threshold=m.outlier_threshold,
+        data_smoothness_ratio=m.data_smoothness_ratio,
+        global_seam_leveling=m.global_seam_leveling,
+        local_seam_leveling=m.local_seam_leveling,
+        empty_color_bgr=(int(empty[2]), int(empty[1]), int(empty[0])),
+        sharpness_weight=m.sharpness_weight,
+        max_texture_size=m.max_texture_size,
+        local_leveling_strip_width=m.local_leveling_strip_width,
+        scoring_workers=m.scoring_workers,
+        exact_packing_limit=m.exact_packing_limit,
+        fill_unseen=m.fill_unseen,
+    )
+    log("mapping: scoring views, labelling faces, levelling seams, packing...")
+    result = mapping.run(mapping.Mesh(positions=vertices, faces=faces), views, tuning, log)
+    texture = cv2.cvtColor(result.atlas_bgr, cv2.COLOR_BGR2RGB)
+    out_mesh = _output_mesh(mesh, result, texture)
+    textured = int((result.labels != mapping.types.NO_ID).sum())
+    stats = {
+        "num_frames": len(frames),
+        "num_keyframes": len(keyframes),
+        "num_patches": result.patch_count,
+        "texture_size": result.atlas_size,
+        "num_faces": int(len(faces)),
+        "textured_faces": textured,
+        "textured_fraction": round(textured / max(1, len(faces)), 4),
+        "output_vertices": int(len(out_mesh.vertices)),
+        "stage_seconds": result.timings,
+        "elapsed_seconds": round(time.time() - t0, 1),
+    }
+    return BakeResult(mesh=out_mesh, texture=texture, stats=stats)

texture3d/blur.py

@@ -0,0 +1,54 @@
+"""Image blurriness estimation.
+
+Crete et al., "The blur effect: perception and estimation with a new
+no-reference perceptual blur metric" (SPIE 2007). The image is blurred with
+a 1x9 box kernel horizontally and vertically; the loss of neighboring-pixel
+variation between the original and the blurred image measures how sharp the
+original was. Returns a value in [0, 1] where higher means blurrier.
+"""
+
+from __future__ import annotations
+
+import cv2
+import numpy as np
+
+
+def _abs_diff_vertical(img: np.ndarray) -> np.ndarray:
+    """|I(y, x) - I(y, x-1)| with a zero first column."""
+    out = np.zeros_like(img)
+    out[:, 1:] = np.abs(img[:, 1:] - img[:, :-1])
+    return out
+
+
+def _abs_diff_horizontal(img: np.ndarray) -> np.ndarray:
+    """|I(y, x) - I(y-1, x)| with a zero first row."""
+    out = np.zeros_like(img)
+    out[1:, :] = np.abs(img[1:, :] - img[:-1, :])
+    return out
+
+
+def estimate_blurriness(rgb: np.ndarray) -> float:
+    """Blurriness of an HxWx3 RGB uint8 image."""
+    gray = cv2.cvtColor(rgb, cv2.COLOR_RGB2GRAY).astype(np.float32)
+
+    kernel = np.full((1, 9), 1.0 / 9, dtype=np.float32)
+    b_ver = cv2.filter2D(gray, -1, kernel)  # blur along rows
+    b_hor = cv2.filter2D(gray, -1, kernel.T)  # blur along columns
+
+    d_f_ver = _abs_diff_vertical(gray)
+    d_f_hor = _abs_diff_horizontal(gray)
+    d_b_ver = _abs_diff_vertical(b_ver)
+    d_b_hor = _abs_diff_horizontal(b_hor)
+
+    v_ver = np.maximum(d_f_ver - d_b_ver, 0.0)
+    v_hor = np.maximum(d_f_hor - d_b_hor, 0.0)
+
+    # Sums exclude the first row and column.
+    s_f_ver = float(d_f_ver[1:, 1:].sum())
+    s_f_hor = float(d_f_hor[1:, 1:].sum())
+    s_v_ver = float(v_ver[1:, 1:].sum())
+    s_v_hor = float(v_hor[1:, 1:].sum())
+
+    b_f_ver = (s_f_ver - s_v_ver) / s_f_ver if s_f_ver > 0 else 0.0
+    b_f_hor = (s_f_hor - s_v_hor) / s_f_hor if s_f_hor > 0 else 0.0
+    return max(b_f_ver, b_f_hor)

texture3d/camera.py

@@ -0,0 +1,108 @@
+"""Camera and posed-frame primitives.
+
+The library is dataset-agnostic: callers hand `bake()` a sequence of
+`RGBDFrame`s, each holding (or lazily pointing at) an RGB image, a metric
+depth image, a camera-to-world pose, and pinhole intrinsics. Convenience
+loaders for on-disk layouts live in `texture3d.io`.
+
+Conventions:
+- camera looks down +z, x right, y down (OpenCV pinhole);
+- poses are 4x4 camera-to-world;
+- RGB images are HxWx3 uint8 in RGB channel order;
+- depth images are HxW float32 meters (0 = invalid).
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Optional, Union
+
+import cv2
+import numpy as np
+
+ImageSource = Union[np.ndarray, str, Path]
+
+
+@dataclass(frozen=True)
+class PinholeCamera:
+    width: int
+    height: int
+    fx: float
+    fy: float
+    cx: float
+    cy: float
+
+    @classmethod
+    def from_matrix(cls, k: np.ndarray, width: int, height: int) -> PinholeCamera:
+        k = np.asarray(k, dtype=np.float64)
+        return cls(
+            width=int(width), height=int(height),
+            fx=float(k[0, 0]), fy=float(k[1, 1]),
+            cx=float(k[0, 2]), cy=float(k[1, 2]),
+        )
+
+    @property
+    def matrix(self) -> np.ndarray:
+        return np.array(
+            [[self.fx, 0.0, self.cx], [0.0, self.fy, self.cy], [0.0, 0.0, 1.0]],
+            dtype=np.float64,
+        )
+
+    def project(self, points_cam: np.ndarray) -> tuple[np.ndarray, np.ndarray]:
+        """Project (N, 3) camera-space points. Returns ((N, 2) pixels, (N,) z)."""
+        z = points_cam[:, 2]
+        zsafe = np.where(z != 0, z, 1.0)
+        u = points_cam[:, 0] / zsafe * self.fx + self.cx
+        v = points_cam[:, 1] / zsafe * self.fy + self.cy
+        return np.stack([u, v], axis=-1), z
+
+
+@dataclass
+class RGBDFrame:
+    """One posed RGB-D frame. Images may be in-memory arrays or file paths.
+
+    `depth` semantics: float arrays are metric meters already; integer arrays
+    and integer image files are multiplied by `depth_scale` (meters per unit,
+    e.g. 1e-3 for millimeter PNGs). Zeros mean invalid.
+    """
+
+    pose_c2w: np.ndarray  # (4, 4)
+    camera: PinholeCamera
+    rgb: ImageSource
+    depth: ImageSource
+    depth_scale: float = 1.0e-3
+    depth_camera: Optional[PinholeCamera] = None
+    name: str = ""
+
+    def __post_init__(self):
+        self.pose_c2w = np.asarray(self.pose_c2w, dtype=np.float64)
+        if self.pose_c2w.shape != (4, 4):
+            raise ValueError(f"pose_c2w must be 4x4, got {self.pose_c2w.shape}")
+        if self.depth_camera is None:
+            self.depth_camera = self.camera
+
+    @property
+    def pose_w2c(self) -> np.ndarray:
+        return np.linalg.inv(self.pose_c2w)
+
+    def load_rgb(self) -> np.ndarray:
+        """HxWx3 uint8, RGB order."""
+        if isinstance(self.rgb, np.ndarray):
+            return self.rgb
+        bgr = cv2.imread(str(self.rgb), cv2.IMREAD_COLOR)
+        if bgr is None:
+            raise OSError(f"Failed to read RGB image {self.rgb}")
+        return cv2.cvtColor(bgr, cv2.COLOR_BGR2RGB)
+
+    def load_depth_m(self) -> np.ndarray:
+        """HxW float32 meters, 0 = invalid."""
+        if isinstance(self.depth, np.ndarray):
+            arr = self.depth
+        else:
+            arr = cv2.imread(str(self.depth), cv2.IMREAD_UNCHANGED)
+            if arr is None:
+                raise OSError(f"Failed to read depth image {self.depth}")
+        if np.issubdtype(arr.dtype, np.floating):
+            return arr.astype(np.float32)
+        return arr.astype(np.float32) * self.depth_scale

texture3d/cli.py

@@ -0,0 +1,74 @@
+"""Command-line interface.
+
+    texture3d DATASET_DIR --mesh mesh.ply [--out DIR] [--format obj|glb] ...
+
+DATASET_DIR must follow the dataset.json layout understood by
+texture3d.io.load_dataset. When --mesh is omitted, the repo convention
+reconstructions/<dataset>/mesh.ply is tried.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+
+from texture3d.bake import bake
+from texture3d.config import BakeConfig
+from texture3d.io import load_dataset
+
+
+def main(argv=None) -> None:
+    p = argparse.ArgumentParser(prog="texture3d", description=__doc__)
+    p.add_argument("dataset", help="dataset directory (dataset.json layout)")
+    p.add_argument("--mesh", type=Path, default=None, help="mesh to texture (.ply/.obj/.stl)")
+    p.add_argument("--out", type=Path, default=None, help="output dir (default textured/<dataset>)")
+    p.add_argument("--format", choices=["obj", "glb"], default="obj")
+    # Keyframes
+    p.add_argument("--gap", type=int, default=5, help="1 keyframe per N frames (1 = all)")
+    # Mapping
+    p.add_argument("--outlier", type=float, default=0.06,
+                   help="Gaussian likelihood below which a view is an outlier for a face (0 = off)")
+    p.add_argument("--data-ratio", type=float, default=0.1,
+                   help="data cost relative to the smoothness cost; lower = larger patches")
+    p.add_argument("--no-global-leveling", action="store_true", help="skip the global seam leveling")
+    p.add_argument("--no-local-leveling", action="store_true", help="skip the local seam leveling")
+    p.add_argument("--strip-width", type=int, default=20, help="local leveling strip width in px")
+    p.add_argument("--sharpness", type=float, default=0.5, help="unsharp-mask weight on the atlas (0 = off)")
+    p.add_argument("--max-texture", type=int, default=8192, help="largest atlas edge in px")
+    p.add_argument("--no-fill-unseen", action="store_true",
+                   help="leave sub-pixel faces no view rasterised in the empty colour")
+    args = p.parse_args(argv)
+
+    dataset_dir = Path(args.dataset)
+    mesh_path = args.mesh or Path("reconstructions") / dataset_dir.name / "mesh.ply"
+    if not mesh_path.exists():
+        raise SystemExit(f"Mesh not found: {mesh_path} (pass --mesh)")
+    out_dir = args.out or Path("textured") / dataset_dir.name
+
+    cfg = BakeConfig()
+    cfg.keyframes.rgbd_frame_gap = args.gap
+    cfg.mapping.outlier_threshold = args.outlier
+    cfg.mapping.data_smoothness_ratio = args.data_ratio
+    cfg.mapping.global_seam_leveling = not args.no_global_leveling
+    cfg.mapping.local_seam_leveling = not args.no_local_leveling
+    cfg.mapping.local_leveling_strip_width = args.strip_width
+    cfg.mapping.sharpness_weight = args.sharpness
+    cfg.mapping.max_texture_size = args.max_texture
+    cfg.mapping.fill_unseen = not args.no_fill_unseen
+
+    frames = load_dataset(dataset_dir)
+    result = bake(mesh_path, frames, cfg)
+
+    out_dir.mkdir(parents=True, exist_ok=True)
+    out_path = result.export(out_dir / f"textured_mesh.{args.format}")
+    (out_dir / "config.json").write_text(cfg.to_json() + "\n")
+    result.stats["output"] = str(out_path)
+    result.stats["mesh_input"] = str(mesh_path)
+    result.stats["dataset_dir"] = str(dataset_dir)
+    (out_dir / "summary.json").write_text(json.dumps(result.stats, indent=2) + "\n")
+    print(f"Done: {out_path}")
+
+
+if __name__ == "__main__":
+    main()

texture3d/config.py

@@ -0,0 +1,57 @@
+"""Bake configuration."""
+
+from __future__ import annotations
+
+import json
+from dataclasses import asdict, dataclass, field
+
+
+@dataclass
+class KeyframeConfig:
+    """Keyframe selection: the least blurry frame of every window, skipping
+    near-duplicate poses."""
+
+    # 1 keyframe per window of this many frames (the least blurry). 1 = use all.
+    rgbd_frame_gap: int = 5
+    # Candidates whose pose is close to the previous keyframe are skipped.
+    closest_pose_translation: float = 0.05  # meters
+    closest_pose_rotation_angle: float = 0.09  # radians
+
+
+@dataclass
+class MappingConfig:
+    """The one-keyframe-per-face mapping (`texture3d.mapping`)."""
+
+    # Views whose mean face colour falls below this Gaussian likelihood against
+    # the other views' colours are dropped for that face. 0 disables the test.
+    outlier_threshold: float = 0.06
+    # Data cost scale relative to the Potts smoothness cost. Lower makes
+    # larger, fewer patches.
+    data_smoothness_ratio: float = 0.1
+    global_seam_leveling: bool = True
+    local_seam_leveling: bool = True
+    # Width in pixels of the border strip the local leveling blends.
+    local_leveling_strip_width: int = 20
+    # Unsharp-mask weight applied to the finished atlas. 0 disables it.
+    sharpness_weight: float = 0.5
+    # The atlas is the smallest power of two that packs the patches, up to this.
+    max_texture_size: int = 8192
+    # Colour of atlas texels no patch covers (RGB).
+    empty_color: tuple = (255, 255, 255)
+    # Views scored at once; each holds a face map and a depth map while scored.
+    scoring_workers: int = 4
+    # Give a face no keyframe rasterised (smaller than a pixel in every view)
+    # the view of a textured neighbour instead of leaving it the empty colour.
+    fill_unseen: bool = True
+    # Patch count up to which the atlas is packed with MaxRects (quadratic in
+    # the patch count); beyond it a shelf packer runs. 0 = always MaxRects.
+    exact_packing_limit: int = 4000
+
+
+@dataclass
+class BakeConfig:
+    keyframes: KeyframeConfig = field(default_factory=KeyframeConfig)
+    mapping: MappingConfig = field(default_factory=MappingConfig)
+
+    def to_json(self) -> str:
+        return json.dumps(asdict(self), indent=2)

texture3d/io.py

@@ -0,0 +1,52 @@
+"""Dataset loaders.
+
+`load_dataset` reads the per-frame RGB-D layout produced by
+create_rgbd_dataset.py (dataset.json index + <frame_id>/{rgb.jpg, depth.png,
+pose.txt}), returning plain `RGBDFrame`s. Other layouts can be adapted by
+constructing `RGBDFrame`s directly.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import List
+
+import numpy as np
+
+from texture3d.camera import PinholeCamera, RGBDFrame
+
+
+def load_dataset(dataset_dir: str | Path) -> List[RGBDFrame]:
+    root = Path(dataset_dir)
+    index_path = root / "dataset.json"
+    if not index_path.exists():
+        raise FileNotFoundError(f"No dataset.json in {root}")
+    index = json.loads(index_path.read_text())
+
+    size = index["image_size"]
+    color = PinholeCamera.from_matrix(
+        np.asarray(index["intrinsics"]["color_matrix_3x3"]), size["width"], size["height"]
+    )
+    depth_k = index["intrinsics"].get("depth_matrix_3x3")
+    depth_cam = (
+        PinholeCamera.from_matrix(np.asarray(depth_k), size["width"], size["height"])
+        if depth_k is not None
+        else color
+    )
+    depth_scale = float(index["depth"]["scale_to_meters"])
+
+    frames = []
+    for rec in index["frames"]:
+        frames.append(
+            RGBDFrame(
+                pose_c2w=np.loadtxt(root / rec["pose"]).reshape(4, 4),
+                camera=color,
+                rgb=root / rec["rgb"],
+                depth=root / rec["depth"],
+                depth_scale=depth_scale,
+                depth_camera=depth_cam,
+                name=rec.get("frame_id", ""),
+            )
+        )
+    return frames

texture3d/keyframes.py

@@ -0,0 +1,42 @@
+"""Keyframe selection.
+
+From every window of `rgbd_frame_gap` frames, take the least blurry one
+(Crete metric); drop it if its pose is too close to the previously accepted
+keyframe.
+"""
+
+from __future__ import annotations
+
+from typing import List, Sequence
+
+import numpy as np
+from scipy.spatial.transform import Rotation
+
+from texture3d.blur import estimate_blurriness
+from texture3d.camera import RGBDFrame
+from texture3d.config import KeyframeConfig
+
+
+def poses_close(t1: np.ndarray, t2: np.ndarray, cfg: KeyframeConfig) -> bool:
+    """True when translation or relative rotation is under the threshold."""
+    if np.linalg.norm(t1[:3, 3] - t2[:3, 3]) < cfg.closest_pose_translation:
+        return True
+    relative = t1[:3, :3].T @ t2[:3, :3]
+    angles = Rotation.from_matrix(relative).as_euler("xyz")
+    return bool(np.linalg.norm(angles) < cfg.closest_pose_rotation_angle)
+
+
+def select_keyframes(frames: Sequence[RGBDFrame], cfg: KeyframeConfig) -> List[RGBDFrame]:
+    selected: List[RGBDFrame] = []
+    n = len(frames)
+    gap = max(1, cfg.rgbd_frame_gap)
+    for start in range(0, n, gap):
+        window = frames[start : min(start + gap, n)]
+        if len(window) == 1:
+            best = window[0]
+        else:
+            best = min(window, key=lambda f: estimate_blurriness(f.load_rgb()))
+        if selected and poses_close(selected[-1].pose_c2w, best.pose_c2w, cfg):
+            continue
+        selected.append(best)
+    return selected

texture3d/mapping/__init__.py

@@ -0,0 +1,31 @@
+"""One-keyframe-per-face texture mapping with seam leveling.
+
+See ``texture3d.mapping.types`` for the stage list and conventions.
+"""
+
+from texture3d.mapping.mapper import Tuning, run
+from texture3d.mapping.types import (
+    Camera,
+    EmptyMesh,
+    MappingError,
+    Mesh,
+    NoViews,
+    NoVisibleFace,
+    PatchTooLarge,
+    Result,
+    View,
+)
+
+__all__ = [
+    "run",
+    "Tuning",
+    "Mesh",
+    "Camera",
+    "View",
+    "Result",
+    "MappingError",
+    "EmptyMesh",
+    "NoViews",
+    "NoVisibleFace",
+    "PatchTooLarge",
+]