texture3d 0.2.0__py3-none-any.whl

texture3d/mapping/patches.py

@@ -0,0 +1,287 @@
+"""Stage 4: connected same-view faces become patches with a rectangle in
+their view, and the seam vertices between patches are catalogued."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Dict, List, Tuple
+
+import numpy as np
+from scipy.sparse import coo_matrix
+from scipy.sparse.csgraph import connected_components
+
+from texture3d.mapping import labeling
+from texture3d.mapping.topology import Topology
+from texture3d.mapping.types import NO_ID, FaceViews, Mesh, Rect, View
+
+PATCH_BORDER = 2
+
+
+@dataclass
+class TexturePatch:
+    #: View index, or NO_ID for the patch of untextured faces.
+    label: int
+    faces: np.ndarray
+    #: Bounding rectangle of the faces' projections in the view, with a
+    #: two-pixel border.
+    rect: Rect
+
+
+@dataclass
+class PatchSet:
+    #: The last patch holds the untextured faces.
+    patches: List[TexturePatch]
+    face_patch: np.ndarray
+    #: (F, 3, 2), relative to ``patches[face_patch[f]].rect``.
+    face_texcoords: np.ndarray
+    seam_edges: np.ndarray
+
+    @property
+    def patch_count(self) -> int:
+        return len(self.patches) - 1
+
+
+@dataclass
+class SeamData:
+    """A mesh vertex where two or more patches meet, with, per patch, its
+    projection in that patch's view and the seam edges leaving it."""
+
+    #: Per seam vertex, the mesh vertex.
+    vertex: np.ndarray
+    #: CSR over seam vertices of (patch, projection) entries, in the order
+    #: the seam edges registered them.
+    entry_offsets: np.ndarray
+    entry_patch: np.ndarray
+    entry_proj: np.ndarray  # (P, 2) float32, image coordinates of the view
+    #: CSR over entries of the seam edges leaving the vertex in that patch:
+    #: the seam vertex at the other end and the face along the edge.
+    edge_offsets: np.ndarray
+    edge_other: np.ndarray
+    edge_face: np.ndarray
+    #: (seam vertex, patch) -> entry index.
+    lookup: Dict[Tuple[int, int], int] = field(default_factory=dict)
+
+    @property
+    def count(self) -> int:
+        return len(self.vertex)
+
+    def entries_of(self, sv: int) -> range:
+        return range(int(self.entry_offsets[sv]), int(self.entry_offsets[sv + 1]))
+
+    def entry_count(self, sv: int) -> int:
+        return int(self.entry_offsets[sv + 1] - self.entry_offsets[sv])
+
+    def edges_of(self, entry: int) -> range:
+        return range(int(self.edge_offsets[entry]), int(self.edge_offsets[entry + 1]))
+
+    @property
+    def entry_sv(self) -> np.ndarray:
+        return np.repeat(np.arange(self.count), np.diff(self.entry_offsets))
+
+
+def build(mesh: Mesh, topology: Topology, face_views: FaceViews, outcome: labeling.Outcome, views: List[View]) -> PatchSet:
+    """Connected components of same-view faces become patches, numbered in
+    order of their lowest face, untextured faces collected last."""
+    face_count = mesh.face_count
+    labels = outcome.labels
+    textured = labels != NO_ID
+
+    # Adjacent faces with the same view join one component. Faces with no
+    # view never join anything; they all end in the empty patch regardless.
+    ff = topology.face_faces
+    f_idx = np.broadcast_to(np.arange(face_count)[:, None], ff.shape)
+    same = (ff != NO_ID) & (f_idx < ff) & textured[f_idx] & (labels[f_idx] == labels[np.where(ff != NO_ID, ff, 0)])
+    graph = coo_matrix(
+        (np.ones(int(same.sum()), dtype=np.int8), (f_idx[same], ff[same])), shape=(face_count, face_count)
+    )
+    n_components, component = connected_components(graph, directed=False)
+    textured_components = np.unique(component[textured])
+    patch_of_component = np.full(n_components, -1, dtype=np.int64)
+    patch_of_component[textured_components] = np.arange(len(textured_components))
+    num_patches = len(textured_components)
+    face_patch = np.where(textured, patch_of_component[component], num_patches)
+
+    order = np.argsort(face_patch, kind="stable")
+    counts = np.bincount(face_patch, minlength=num_patches + 1)
+    starts = np.concatenate([[0], np.cumsum(counts)])
+    patches: List[TexturePatch] = []
+    for p in range(num_patches):
+        faces = order[starts[p] : starts[p + 1]]
+        patches.append(TexturePatch(label=int(labels[faces[0]]), faces=faces, rect=Rect(0, 0, 0, 0)))
+    empty_faces = order[starts[num_patches] : starts[num_patches + 1]]
+    patches.append(TexturePatch(label=NO_ID, faces=empty_faces, rect=Rect(0, 0, 5, 5)))
+
+    # Project every patch into its view, take the bounding rectangle with a
+    # two-pixel border, and make the coordinates relative.
+    texcoords = np.zeros((face_count, 3, 2), dtype=np.float32)
+    for v in np.unique(labels[textured]):
+        faces_v = np.flatnonzero(labels == v)
+        proj = views[int(v)].camera.project(mesh.positions)
+        texcoords[faces_v] = proj[mesh.faces[faces_v]]
+    textured_sorted = order[: starts[num_patches]]
+    if num_patches:
+        corners = texcoords[textured_sorted].reshape(-1, 2)
+        corner_starts = starts[:num_patches] * 3
+        lo = np.minimum.reduceat(corners, corner_starts, axis=0)
+        hi = np.maximum.reduceat(corners, corner_starts, axis=0)
+        rx = np.floor(lo[:, 0]).astype(np.int64) - PATCH_BORDER
+        ry = np.floor(lo[:, 1]).astype(np.int64) - PATCH_BORDER
+        rw = np.ceil(hi[:, 0] - lo[:, 0]).astype(np.int64) + PATCH_BORDER * 2
+        rh = np.ceil(hi[:, 1] - lo[:, 1]).astype(np.int64) + PATCH_BORDER * 2
+        for p in range(num_patches):
+            patches[p].rect = Rect(int(rx[p]), int(ry[p]), int(rw[p]), int(rh[p]))
+        offset = np.stack([rx, ry], axis=-1).astype(np.float32)
+        texcoords[textured] -= offset[face_patch[textured]][:, None, :]
+    texcoords[empty_faces] = np.float32(0.5)
+    return PatchSet(patches=patches, face_patch=face_patch, face_texcoords=texcoords, seam_edges=outcome.seam_edges)
+
+
+def create_seam_vertices(mesh: Mesh, patch_set: PatchSet) -> SeamData:
+    """Every seam edge registers its two vertices with the patches on both
+    sides, remembering the face and the other seam vertex the edge leads to."""
+    num_patches = patch_set.patch_count
+    edges = patch_set.seam_edges
+    faces = mesh.faces
+    tex = patch_set.face_texcoords
+    f0 = edges[:, 0]
+    f1 = edges[:, 1]
+    p0 = patch_set.face_patch[f0]
+    p1 = patch_set.face_patch[f1]
+    fa = faces[f0]
+    fb = faces[f1]
+    shared = fa[:, :, None] == fb[:, None, :]  # (E, 3, 3)
+    in_f0 = shared.any(axis=2)
+    keep = (p0 != p1) & (in_f0.sum(axis=1) == 2)
+    e_idx = np.flatnonzero(keep)
+    slots0 = np.argsort(~in_f0[e_idx], axis=1, kind="stable")[:, :2]
+    slots1 = shared[e_idx][np.arange(len(e_idx))[:, None], slots0].argmax(axis=2)
+    vs = fa[e_idx][np.arange(len(e_idx))[:, None], slots0]
+    rect_x = np.array([p.rect.x for p in patch_set.patches], dtype=np.float32)
+    rect_y = np.array([p.rect.y for p in patch_set.patches], dtype=np.float32)
+
+    slot_of_vertex: Dict[int, int] = {}
+    sv_vertex: List[int] = []
+    sv_entries: List[List[int]] = []
+    entry_patch: List[int] = []
+    entry_proj: List[Tuple[float, float]] = []
+    entry_edges: List[List[Tuple[int, int]]] = []
+    lookup: Dict[Tuple[int, int], int] = {}
+
+    def seam_vertex(v: int) -> int:
+        s = slot_of_vertex.get(v)
+        if s is None:
+            s = len(sv_vertex)
+            slot_of_vertex[v] = s
+            sv_vertex.append(v)
+            sv_entries.append([])
+        return s
+
+    def entry(sv: int, patch: int) -> int:
+        e = lookup.get((sv, patch))
+        if e is None:
+            e = len(entry_patch)
+            lookup[(sv, patch)] = e
+            entry_patch.append(patch)
+            entry_proj.append((0.0, 0.0))
+            entry_edges.append([])
+            sv_entries[sv].append(e)
+        return e
+
+    for i, e in enumerate(e_idx):
+        v0, v1 = int(vs[i, 0]), int(vs[i, 1])
+        s0 = seam_vertex(v0)
+        s1 = seam_vertex(v1)
+        for patch, face, slots in ((int(p0[e]), int(f0[e]), slots0[i]), (int(p1[e]), int(f1[e]), slots1[i])):
+            if patch >= num_patches:
+                continue
+            ox, oy = float(rect_x[patch]), float(rect_y[patch])
+            a = entry(s0, patch)
+            entry_edges[a].append((s1, face))
+            t = tex[face, int(slots[0])]
+            entry_proj[a] = (float(t[0]) + ox, float(t[1]) + oy)
+            b = entry(s1, patch)
+            entry_edges[b].append((s0, face))
+            t = tex[face, int(slots[1])]
+            entry_proj[b] = (float(t[0]) + ox, float(t[1]) + oy)
+
+    # Flatten: entries per seam vertex in registration order, edges per entry.
+    entry_order = [e for entries in sv_entries for e in entries]
+    new_index = {old: new for new, old in enumerate(entry_order)}
+    entry_offsets = np.zeros(len(sv_vertex) + 1, dtype=np.int64)
+    np.cumsum([len(entries) for entries in sv_entries], out=entry_offsets[1:])
+    patch_arr = np.array([entry_patch[e] for e in entry_order], dtype=np.int64)
+    proj_arr = np.array([entry_proj[e] for e in entry_order], dtype=np.float32).reshape(-1, 2)
+    edge_counts = [len(entry_edges[e]) for e in entry_order]
+    edge_offsets = np.zeros(len(entry_order) + 1, dtype=np.int64)
+    np.cumsum(edge_counts, out=edge_offsets[1:])
+    edge_other = np.array([o for e in entry_order for o, _ in entry_edges[e]], dtype=np.int64)
+    edge_face = np.array([f for e in entry_order for _, f in entry_edges[e]], dtype=np.int64)
+    lookup_new = {key: new_index[old] for key, old in lookup.items()}
+    return SeamData(
+        vertex=np.array(sv_vertex, dtype=np.int64),
+        entry_offsets=entry_offsets,
+        entry_patch=patch_arr,
+        entry_proj=proj_arr,
+        edge_offsets=edge_offsets,
+        edge_other=edge_other,
+        edge_face=edge_face,
+        lookup=lookup_new,
+    )
+
+
+def merge_contained(patch_set: PatchSet) -> None:
+    """Fold a patch whose rectangle lies inside another in the same view.
+
+    Every patch joins the lowest-numbered surviving patch of its view whose
+    rectangle contains its own.
+    """
+    patches = patch_set.patches
+    num_patches = patch_set.patch_count
+    if num_patches < 2:
+        return
+    labels = np.array([p.label for p in patches[:num_patches]])
+    x = np.array([p.rect.x for p in patches[:num_patches]])
+    y = np.array([p.rect.y for p in patches[:num_patches]])
+    w = np.array([p.rect.width for p in patches[:num_patches]])
+    h = np.array([p.rect.height for p in patches[:num_patches]])
+    target = np.arange(num_patches)
+    for label in np.unique(labels):
+        ids = np.flatnonzero(labels == label)
+        if len(ids) < 2:
+            continue
+        xi, yi, wi, hi = x[ids], y[ids], w[ids], h[ids]
+        # contained[j, i]: rect j lies inside rect i.
+        contained = (
+            (xi[:, None] >= xi[None, :])
+            & (yi[:, None] >= yi[None, :])
+            & (xi[:, None] + wi[:, None] <= xi[None, :] + wi[None, :])
+            & (yi[:, None] + hi[:, None] <= yi[None, :] + hi[None, :])
+        )
+        identical = contained & contained.T
+        np.fill_diagonal(contained, False)
+        # Of two identical rectangles the earlier absorbs the later.
+        later = np.arange(len(ids))[None, :] > np.arange(len(ids))[:, None]
+        contained &= ~(identical & later)
+        has = contained.any(axis=1)
+        first = np.argmax(contained, axis=1)
+        target[ids[has]] = ids[first[has]]
+    # Follow chains: a patch absorbed into one that is itself absorbed ends in
+    # the final absorber, with the offsets adding up.
+    for _ in range(num_patches):
+        nxt = target[target]
+        if np.array_equal(nxt, target):
+            break
+        target = nxt
+    merged = target != np.arange(num_patches)
+    if not merged.any():
+        return
+    for j in np.flatnonzero(merged):
+        i = int(target[j])
+        small, big = patches[j], patches[i]
+        offset = np.array([small.rect.x - big.rect.x, small.rect.y - big.rect.y], dtype=np.float32)
+        patch_set.face_texcoords[small.faces] += offset
+        big.faces = np.concatenate([big.faces, small.faces])
+    survivors = [patches[p] for p in range(num_patches) if not merged[p]] + [patches[num_patches]]
+    patch_set.patches = survivors
+    for p, patch in enumerate(survivors):
+        patch_set.face_patch[patch.faces] = p

texture3d/mapping/raster.py

@@ -0,0 +1,185 @@
+"""Rasterisers: barycentric for view face maps and colour-adjustment maps,
+fixed-point for the local leveling mask, and Bresenham lines for the seams."""
+
+from __future__ import annotations
+
+from typing import Iterator, Tuple
+
+import numpy as np
+
+from texture3d.mapping.types import round2int
+
+
+def edge(x0: np.ndarray, x1: np.ndarray, x2: np.ndarray) -> np.ndarray:
+    """Signed parallelogram area ``(x2 - x0) × (x1 - x0)``, float32."""
+    a = x2 - x0
+    b = x1 - x0
+    return a[..., 0] * b[..., 1] - a[..., 1] * b[..., 0]
+
+
+def perspective_correct(bary: np.ndarray, z: np.ndarray) -> np.ndarray:
+    """Perspective-correct barycentrics for (N, 3) bary and (N, 3) z."""
+    pb = np.stack(
+        [bary[:, 0] * z[:, 1] * z[:, 2], bary[:, 1] * z[:, 0] * z[:, 2], bary[:, 2] * z[:, 0] * z[:, 1]], axis=-1
+    )
+    return pb / pb.sum(axis=1, keepdims=True)
+
+
+def triangles_bary(
+    tri: np.ndarray, width: int, height: int, cull: bool = True, max_candidates: int = 1 << 24
+) -> Iterator[Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]]:
+    """Barycentric rasteriser over (N, 3, 2) float32 triangles.
+
+    Yields chunks of ``(triangle index, x, y, bary)`` for every pixel whose
+    centre has non-negative barycentric coordinates, within the image,
+    culling triangles whose signed area is not positive. Within a chunk the
+    pixels are in triangle order, then row-major inside each triangle.
+    """
+    tri = np.asarray(tri, dtype=np.float32)
+    n = len(tri)
+    if n == 0:
+        return
+    box_min = tri.min(axis=1)
+    box_max = tri.max(axis=1)
+    outside = (box_max[:, 0] < 0) | (box_min[:, 0] > width - 1) | (box_max[:, 1] < 0) | (box_min[:, 1] > height - 1)
+    area = edge(tri[:, 0], tri[:, 1], tri[:, 2])
+    keep = ~outside
+    if cull:
+        keep &= area > 0
+    else:
+        keep &= area != 0
+    idx = np.flatnonzero(keep)
+    if len(idx) == 0:
+        return
+    min_x = np.clip(np.floor(box_min[idx, 0]).astype(np.int64), 0, width - 1)
+    min_y = np.clip(np.floor(box_min[idx, 1]).astype(np.int64), 0, height - 1)
+    max_x = np.clip(np.ceil(box_max[idx, 0]).astype(np.int64), 0, width - 1)
+    max_y = np.clip(np.ceil(box_max[idx, 1]).astype(np.int64), 0, height - 1)
+    bw = max_x - min_x + 1
+    bh = max_y - min_y + 1
+    counts = bw * bh
+    inv_area = (np.float32(1) / area[idx]).astype(np.float32)
+
+    start = 0
+    total = len(idx)
+    while start < total:
+        # Take triangles until the candidate budget is reached.
+        cum = np.cumsum(counts[start:])
+        take = int(np.searchsorted(cum, max_candidates, side="right"))
+        take = max(1, min(take, total - start))
+        sel = slice(start, start + take)
+        c = counts[sel]
+        rep = np.repeat(np.arange(start, start + take), c)
+        offsets = np.repeat(np.cumsum(c) - c, c)
+        local = np.arange(int(c.sum())) - offsets
+        x = min_x[rep] + local % bw[rep]
+        y = min_y[rep] + local // bw[rep]
+        p = np.stack([x, y], axis=-1).astype(np.float32)
+        t = tri[idx[rep]]
+        ia = inv_area[rep]
+        b1 = edge(t[:, 1], t[:, 2], p) * ia
+        b2 = edge(t[:, 2], t[:, 0], p) * ia
+        b3 = edge(t[:, 0], t[:, 1], p) * ia
+        inside = (b1 >= 0) & (b2 >= 0) & (b3 >= 0)
+        yield idx[rep[inside]], x[inside], y[inside], np.stack([b1[inside], b2[inside], b3[inside]], axis=-1)
+        start += take
+
+
+def triangles_fixed(tri: np.ndarray, width: int, height: int) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
+    """28.4 fixed-point half-space rasteriser with a top-left fill
+    convention, over (N, 3, 2) triangles. Returns ``(triangle index, x, y)``
+    for the covered pixels inside ``width`` x ``height``."""
+    tri = np.asarray(tri, dtype=np.float32)
+    n = len(tri)
+    if n == 0:
+        empty = np.zeros(0, dtype=np.int64)
+        return empty, empty, empty
+    X = round2int(16 * tri[..., 0])
+    Y = round2int(16 * tri[..., 1])
+    X1, X2, X3 = X[:, 0], X[:, 1], X[:, 2]
+    Y1, Y2, Y3 = Y[:, 0], Y[:, 1], Y[:, 2]
+    DX12, DX23, DX31 = X1 - X2, X2 - X3, X3 - X1
+    DY12, DY23, DY31 = Y1 - Y2, Y2 - Y3, Y3 - Y1
+    min_x = (X.min(axis=1) + 0xF) >> 4
+    max_x = (X.max(axis=1) + 0xF) >> 4
+    min_y = (Y.min(axis=1) + 0xF) >> 4
+    max_y = (Y.max(axis=1) + 0xF) >> 4
+    C1 = DY12 * X1 - DX12 * Y1 + ((DY12 < 0) | ((DY12 == 0) & (DX12 > 0)))
+    C2 = DY23 * X2 - DX23 * Y2 + ((DY23 < 0) | ((DY23 == 0) & (DX23 > 0)))
+    C3 = DY31 * X3 - DX31 * Y3 + ((DY31 < 0) | ((DY31 == 0) & (DX31 > 0)))
+    # Only pixels inside the image can be reported, so clip the boxes first.
+    lo_x = np.clip(min_x, 0, width)
+    hi_x = np.clip(max_x, 0, width)
+    lo_y = np.clip(min_y, 0, height)
+    hi_y = np.clip(max_y, 0, height)
+    bw = np.maximum(hi_x - lo_x, 0)
+    bh = np.maximum(hi_y - lo_y, 0)
+    counts = bw * bh
+    rep = np.repeat(np.arange(n), counts)
+    if len(rep) == 0:
+        empty = np.zeros(0, dtype=np.int64)
+        return empty, empty, empty
+    offsets = np.repeat(np.cumsum(counts) - counts, counts)
+    local = np.arange(int(counts.sum())) - offsets
+    x = lo_x[rep] + local % bw[rep]
+    y = lo_y[rep] + local // bw[rep]
+    x16 = x << 4
+    y16 = y << 4
+    inside = (
+        (C1[rep] + DX12[rep] * y16 - DY12[rep] * x16 > 0)
+        & (C2[rep] + DX23[rep] * y16 - DY23[rep] * x16 > 0)
+        & (C3[rep] + DX31[rep] * y16 - DY31[rep] * x16 > 0)
+    )
+    return rep[inside], x[inside], y[inside]
+
+
+def lines(p1: np.ndarray, p2: np.ndarray) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
+    """Bresenham from the rounded start to the rounded end, end exclusive,
+    over (N, 2) endpoints. Returns ``(line index, x, y)`` with each line's
+    pixels in drawing order, lines in input order."""
+    p1 = np.asarray(p1, dtype=np.float32).copy()
+    p2 = np.asarray(p2, dtype=np.float32).copy()
+    n = len(p1)
+    if n == 0:
+        empty = np.zeros(0, dtype=np.int64)
+        return empty, empty, empty
+    x1, y1 = p1[:, 0].copy(), p1[:, 1].copy()
+    x2, y2 = p2[:, 0].copy(), p2[:, 1].copy()
+    steep = np.abs(y2 - y1) > np.abs(x2 - x1)
+    x1s, y1s = np.where(steep, y1, x1), np.where(steep, x1, y1)
+    x2s, y2s = np.where(steep, y2, x2), np.where(steep, x2, y2)
+    flip = x1s > x2s
+    xa, xb = np.where(flip, x2s, x1s), np.where(flip, x1s, x2s)
+    ya, yb = np.where(flip, y2s, y1s), np.where(flip, y1s, y2s)
+    dx = (xb - xa).astype(np.float32)
+    dy = np.abs(yb - ya).astype(np.float32)
+    error = dx / np.float32(2)
+    y = round2int(ya)
+    ystep = np.where(ya < yb, 1, -1)
+    x = round2int(xa)
+    max_x = round2int(xb)
+    steps = np.maximum(max_x - x, 0)
+    total = int(steps.sum())
+    out_line = np.empty(total, dtype=np.int64)
+    out_x = np.empty(total, dtype=np.int64)
+    out_y = np.empty(total, dtype=np.int64)
+    # Each line's pixels are contiguous in the output; step k of line i goes to
+    # slot start[i] + k.
+    start = np.cumsum(steps) - steps
+    active = steps > 0
+    k = 0
+    while active.any():
+        ids = np.flatnonzero(active)
+        slot = start[ids] + k
+        px, py = x[ids], y[ids]
+        out_line[slot] = ids
+        out_x[slot] = np.where(steep[ids], py, px)
+        out_y[slot] = np.where(steep[ids], px, py)
+        error[ids] -= dy[ids]
+        inc = error[ids] < 0
+        y[ids] += np.where(inc, ystep[ids], 0)
+        error[ids] += np.where(inc, dx[ids], np.float32(0))
+        x[ids] += 1
+        k += 1
+        active = steps > k
+    return out_line, out_x, out_y