Refactor texture baking in vertex_color_to_uv_textured_glb function to use a hybrid approach for barycentric calculations. This change enhances accuracy while maintaining performance, replacing vectorized operations with a loop-based method for improved precision in texture generation.

inference.py

@@ -21,13 +21,11 @@ def vertex_color_to_uv_textured_glb(obj_path, glb_path, texture_size=512):
     vertex_colors = vertex_colors[vmapping]
     mesh.vertices = vertices
     mesh.faces = indices
-    # Bake texture (vectorized)
+    # Bake texture (hybrid: per-pixel barycentric for accuracy)
     buffer_size = texture_size * 2
     texture_buffer = np.zeros((buffer_size, buffer_size, 4), dtype=np.uint8)
-    # Precompute face data
     face_uvs = uvs[mesh.faces]
     face_colors = vertex_colors[mesh.faces]
-    # Compute bounding boxes for all faces
     min_xy = np.floor(np.min(face_uvs, axis=1) * (buffer_size - 1)).astype(int)
     max_xy = np.ceil(np.max(face_uvs, axis=1) * (buffer_size - 1)).astype(int)
     for i in range(len(mesh.faces)):
@@ -35,44 +33,22 @@ def vertex_color_to_uv_textured_glb(obj_path, glb_path, texture_size=512):
         c0, c1, c2 = face_colors[i]
         min_x, min_y = min_xy[i]
         max_x, max_y = max_xy[i]
-        # Create a grid of pixel coordinates in the bounding box
-        xs = np.arange(min_x, max_x + 1)
-        ys = np.arange(min_y, max_y + 1)
-        xv, yv = np.meshgrid(xs, ys)
-        pts = np.stack([xv, yv], axis=-1).reshape(-1, 2) + 0.5
-        # Barycentric test (vectorized)
-        v0, v1, v2 = uv0 * (buffer_size - 1), uv1 * (buffer_size - 1), uv2 * (buffer_size - 1)
-        def sign(p1, p2, p3):
-            return (p1[..., 0] - p3[0]) * (p2[1] - p3[1]) - (p2[0] - p3[0]) * (p1[..., 1] - p3[1])
-        d1 = sign(pts, v0, v1)
-        d2 = sign(pts, v1, v2)
-        d3 = sign(pts, v2, v0)
-        mask = ~((d1 < 0) | (d2 < 0) | (d3 < 0)) & ~((d1 > 0) & (d2 > 0) & (d3 > 0))
-        inside_pts = pts[mask]
-        if len(inside_pts) == 0:
-            continue
-        # Barycentric coordinates (vectorized)
-        def barycentric(p, v0, v1, v2):
-            v0v1 = v1 - v0
-            v0v2 = v2 - v0
-            v0p = p - v0
-            d00 = np.dot(v0v1, v0v1)
-            d01 = np.dot(v0v1, v0v2)
-            d11 = np.dot(v0v2, v0v2)
-            d20 = np.dot(v0p, v0v1)
-            d21 = np.dot(v0p, v0v2)
-            denom = d00 * d11 - d01 * d01
-            v = (d11 * d20 - d01 * d21) / denom
-            w = (d00 * d21 - d01 * d20) / denom
-            u = 1.0 - v - w
-            return np.clip(u, 0, 1), np.clip(v, 0, 1), np.clip(w, 0, 1)
-        u, v, w = barycentric(inside_pts, v0, v1, v2)
-        colors = (u[:, None] * c0 + v[:, None] * c1 + w[:, None] * c2)
-        xi = inside_pts[:, 0].astype(int)
-        yi = inside_pts[:, 1].astype(int)
-        texture_buffer[yi, xi, :3] = np.clip(colors, 0, 255).astype(np.uint8)
-        texture_buffer[yi, xi, 3] = 255
-    # Inpainting, filtering, and downsampling
+        for y in range(min_y, max_y + 1):
+            for x in range(min_x, max_x + 1):
+                p = np.array([x + 0.5, y + 0.5]) / (buffer_size - 1)
+                # Barycentric coordinates
+                v0, v1, v2 = uv0, uv1, uv2
+                denom = (v1[1] - v2[1]) * (v0[0] - v2[0]) + (v2[0] - v1[0]) * (v0[1] - v2[1])
+                if denom == 0:
+                    continue
+                u = ((v1[1] - v2[1]) * (p[0] - v2[0]) + (v2[0] - v1[0]) * (p[1] - v2[1])) / denom
+                v = ((v2[1] - v0[1]) * (p[0] - v2[0]) + (v0[0] - v2[0]) * (p[1] - v2[1])) / denom
+                w = 1 - u - v
+                if (u >= 0) and (v >= 0) and (w >= 0):
+                    color = u * c0 + v * c1 + w * c2
+                    texture_buffer[y, x, :3] = np.clip(color, 0, 255).astype(np.uint8)
+                    texture_buffer[y, x, 3] = 255
+    # Inpainting, filtering, and downsampling (keep optimized)
     image_bgra = texture_buffer.copy()
     mask = (image_bgra[:, :, 3] == 0).astype(np.uint8) * 255
     image_bgr = cv2.cvtColor(image_bgra, cv2.COLOR_BGRA2BGR)