liblaf.melon.ext

Modules:

• wrap –

Functions:

• annotate_landmarks –
• fast_wrapping –
• mesh_fix –
• tetwild –

annotate_landmarks

annotate_landmarks(
    left: Any,
    right: Any,
    *,
    left_landmarks: Float[ArrayLike, "L 3"] | None = None,
    right_landmarks: Float[ArrayLike, "L 3"] | None = None,
) -> tuple[Float[ndarray, "L 3"], Float[ndarray, "L 3"]]

Source code in src/liblaf/melon/ext/wrap/_annotate_landmarks.py

def annotate_landmarks(
    left: Any,
    right: Any,
    *,
    left_landmarks: Float[ArrayLike, "L 3"] | None = None,
    right_landmarks: Float[ArrayLike, "L 3"] | None = None,
) -> tuple[Float[np.ndarray, "L 3"], Float[np.ndarray, "L 3"]]:
    if left_landmarks is None:
        left_landmarks = np.zeros((0, 3))
    if right_landmarks is None:
        right_landmarks = np.zeros((0, 3))
    with tempfile.TemporaryDirectory() as tmpdir_str:
        tmpdir: Path = Path(tmpdir_str).absolute()
        project_file: Path = tmpdir / "annotate-landmarks.wrap"
        left_file: Path = tmpdir / "left.obj"
        right_file: Path = tmpdir / "right.obj"
        left_landmarks_file: Path = tmpdir / "left.landmarks.json"
        right_landmarks_file: Path = tmpdir / "right.landmarks.json"
        io.save(left_file, left)
        io.save(right_file, right)
        io.save_landmarks(left_landmarks_file, left_landmarks)
        io.save_landmarks(right_landmarks_file, right_landmarks)
        template: jinja2.Template = environment.get_template("annotate-landmarks.wrap")
        project: str = template.render(
            {
                "left": left_file,
                "right": right_file,
                "left_landmarks": left_landmarks_file,
                "right_landmarks": right_landmarks_file,
            }
        )
        project_file.write_text(project)
        sp.run(["Wrap.sh", project_file], check=True)
        left_landmarks = io.load_landmarks(left_landmarks_file)
        right_landmarks = io.load_landmarks(right_landmarks_file)
    return left_landmarks, right_landmarks

fast_wrapping

fast_wrapping(
    source: Any,
    target: Any,
    *,
    source_landmarks: Float[ArrayLike, "L 3"] | None = None,
    target_landmarks: Float[ArrayLike, "L 3"] | None = None,
    free_polygons_floating: Bool[ArrayLike, " full"]
    | Integer[ArrayLike, " free"]
    | None = None,
    verbose: bool = False,
) -> PolyData

Source code in src/liblaf/melon/ext/wrap/_fast_wrapping.py

def fast_wrapping(
    source: Any,
    target: Any,
    *,
    source_landmarks: Float[ArrayLike, "L 3"] | None = None,
    target_landmarks: Float[ArrayLike, "L 3"] | None = None,
    free_polygons_floating: Bool[ArrayLike, " full"]
    | Integer[ArrayLike, " free"]
    | None = None,
    verbose: bool = False,
) -> pv.PolyData:
    source_landmarks = (
        source_landmarks if source_landmarks is not None else np.empty((0, 3))
    )
    target_landmarks = (
        target_landmarks if target_landmarks is not None else np.empty((0, 3))
    )
    free_polygons_floating = (
        free_polygons_floating if free_polygons_floating is not None else np.empty((0,))
    )
    with tempfile.TemporaryDirectory() as tmpdir_str:
        tmpdir: Path = Path(tmpdir_str).absolute()
        project_file: Path = tmpdir / "fast-wrapping.wrap"
        source_file: Path = tmpdir / "source.obj"
        target_file: Path = tmpdir / "target.obj"
        output_file: Path = tmpdir / "output.obj"
        source_landmarks_file: Path = tmpdir / "source.landmarks.json"
        target_landmarks_file: Path = tmpdir / "target.landmarks.json"
        free_polygons_floating_file: Path = tmpdir / "free-polygons-floating.json"
        io.save(source_file, source)
        io.save(target_file, target)
        io.save_landmarks(source_landmarks_file, source_landmarks)
        io.save_landmarks(target_landmarks_file, target_landmarks)
        io.save_polygons(free_polygons_floating_file, free_polygons_floating)
        template: jinja2.Template = environment.get_template("fast-wrapping.wrap")
        project: str = template.render(
            {
                "source": str(source_file),
                "target": str(target_file),
                "output": str(output_file),
                "source_landmarks": str(source_landmarks_file),
                "target_landmarks": str(target_landmarks_file),
                "free_polygons_floating": str(free_polygons_floating_file),
            }
        )
        project_file.write_text(project)
        args: list[str | Path] = ["WrapCmd.sh", "compute", project_file]
        if verbose:
            args.append("--verbose")
        sp.run(args, check=True)
        result: pv.PolyData = io.load_polydata(output_file)
        result.copy_attributes(source)
        return result

mesh_fix

mesh_fix(
    mesh: Any,
    *,
    check: bool = True,
    joincomp: bool = False,
    remove_smallest_components: bool = True,
) -> PolyData

Source code in src/liblaf/melon/ext/_mesh_fix.py

def mesh_fix(
    mesh: Any,
    *,
    check: bool = True,
    joincomp: bool = False,
    remove_smallest_components: bool = True,
) -> pv.PolyData:
    result: pv.PolyData
    if importlib.util.find_spec("pymeshfix") is not None:
        result = _pymeshfix(
            mesh,
            joincomp=joincomp,
            remove_smallest_components=remove_smallest_components,
        )
    elif shutil.which("MeshFix"):
        result = _mesh_fix_exe(mesh)
    else:
        raise NotImplementedError
    result = tri.fix_inversion(result)
    if check:
        assert tri.is_volume(result)
    mesh: pv.PolyData = io.as_polydata(mesh)
    result.field_data.update(mesh.field_data)
    return result

tetwild

tetwild(
    surface: Any,
    *,
    fix_winding: bool = True,
    lr: float | None = None,
    epsr: float | None = None,
    level: int | None = None,
    color: bool = False,
    coarsen: bool = False,
    csg: bool = False,
    **kwargs,
) -> UnstructuredGrid

Source code in src/liblaf/melon/ext/_tetwild.py

def tetwild(
    surface: Any,
    *,
    fix_winding: bool = True,
    lr: float | None = None,
    epsr: float | None = None,
    level: int | None = None,
    color: bool = False,
    coarsen: bool = False,
    csg: bool = False,
    **kwargs,
) -> pv.UnstructuredGrid:
    surface: pv.PolyData = copy_structure(surface)  # pyright: ignore[reportAssignmentType]
    if shutil.which("fTetWild"):
        mesh: pv.UnstructuredGrid = _tetwild_exe(
            surface,
            lr=lr,
            epsr=epsr,
            level=level,
            no_color=not color,
            csg=csg,
            coarsen=coarsen,
            **kwargs,
        )
    else:
        raise NotImplementedError
    if fix_winding:
        mesh = tet.fix_winding(mesh)
    return mesh