Upload app.py

app.py

@@ -83,141 +83,155 @@ class UNetNoCondWrapper(nn.Module):
 #     b = base64.b64encode(buf.getvalue()).decode("utf-8")
 #     return f"data:image/png;base64,{b}"
 
-def user_inference(img1, img2):
-    try:
-        # si numpy array -> PIL
-        if isinstance(img1, np.ndarray):
-            img1 = Image.fromarray(img1)
-        if isinstance(img2, np.ndarray):
-            img2 = Image.fromarray(img2)
-        # 4 outputs tests
-        o1 = img1.copy().resize((512,512))
-        o2 = img2.copy().resize((512,512))
-        o3 = img1.transpose(Image.FLIP_LEFT_RIGHT).resize((512,512))
-        o4 = img2.rotate(90, expand=True).resize((512,512))
-        return [o1, o2, o3, o4]
-    except Exception:
-        blank = Image.new("RGB", (512,512), (200,200,200))
-        return [blank, blank, blank, blank]
+
     
-def build_textured_cube(textures, out_dir=None):
+def build_textured_cube(pil_imgs):
     """
-    Écrit les fichiers dans ./models/<uuid>/ pour être visibles dans le Space.
-    textures: list de 4 PIL.Image (RGB) -> mapping:
-      textures[0] -> right
-      textures[1] -> left
-      textures[2] -> front
-      textures[3] -> back
-    Retourne: (chemin_absolu_obj, out_dir)
+    Crée un .obj/.mtl et les textures pour un cube dont 4 faces latérales
+    sont les images données (ordre attendu : [right, left, front, back]) et
+    les faces top/bottom sont noires.
+
+    Entrée:
+        pil_imgs: liste de 4 PIL.Image (RGB)
+    Retour:
+        (obj_path_abs, tmpdir)  # obj_path absolu vers cube.obj, tmpdir contient aussi les textures et le .mtl
     """
-    import os, uuid
-    from pathlib import Path
+    import os
     import tempfile
-
-    # dossier racine "models" dans le repo (sera visible dans Files)
-    repo_models_dir = os.path.join(os.path.dirname(__file__), "models")
-    os.makedirs(repo_models_dir, exist_ok=True)
-
-    # crée un sous-dossier unique
-    if out_dir is None:
-        out_dir = os.path.join(repo_models_dir, f"cube_{uuid.uuid4().hex}")
-    os.makedirs(out_dir, exist_ok=True)
-
-    # vérifications
-    if len(textures) < 4:
-        raise ValueError("Il faut fournir 4 images dans `textures`.")
-
-    # normaliser taille (utilise la taille de la première texture)
-    base_w, base_h = textures[0].size
-    norm_texts = []
-    for im in textures[:4]:
-        if im.size != (base_w, base_h):
-            im = im.resize((base_w, base_h))
-        norm_texts.append(im.convert("RGB"))
-
-    # top & bottom : textures noires
     from PIL import Image
-    black_top = Image.new("RGB", (base_w, base_h), (0,0,0))
-    black_bottom = Image.new("RGB", (base_w, base_h), (0,0,0))
-
-    all_texts = norm_texts + [black_top, black_bottom]  # order: right,left,front,back,top,bottom
 
-    # Sauvegarde textures dans out_dir
-    tex_filenames = []
-    for i, im in enumerate(all_texts):
-        fn = f"tex_{i}.png"
-        path = os.path.join(out_dir, fn)
+    # Vérifications minimales
+    if not (isinstance(pil_imgs, (list, tuple)) and len(pil_imgs) >= 4):
+        raise ValueError("build_textured_cube attend une liste/tuple de 4 images PIL.")
+
+    # créer dossier temporaire
+    tmpdir = tempfile.mkdtemp(prefix="cube_")
+    # nom des textures (gardés simples)
+    tex_names = {
+        "right": "tex_right.png",
+        "left": "tex_left.png",
+        "front": "tex_front.png",
+        "back": "tex_back.png",
+        "top": "tex_top.png",
+        "bottom": "tex_bottom.png",
+    }
+
+    # uniformiser la taille des textures sur la taille de la première image
+    base_w, base_h = pil_imgs[0].size
+
+    # convertir et sauvegarder les 4 images fournies
+    mapping = ["right", "left", "front", "back"]
+    for img, name in zip(pil_imgs[:4], mapping):
+        im = img.convert("RGB")
+        if im.size != (base_w, base_h):
+            im = im.resize((base_w, base_h), Image.LANCZOS)
+        path = os.path.join(tmpdir, tex_names[name])
         im.save(path, format="PNG")
-        tex_filenames.append(fn)  # NOTE: on garde juste le basename pour le .mtl
-
-    # Écrire le .mtl (utilise seulement les basenames car .mtl est dans le même dossier)
-    mtl_name = "cube.mtl"
-    mtl_path = os.path.join(out_dir, mtl_name)
-    with open(mtl_path, "w") as f:
-        f.write("# cube materials\n")
-        names = ["mat_right", "mat_left", "mat_front", "mat_back", "mat_top", "mat_bottom"]
-        for name, tex in zip(names, tex_filenames):
-            f.write(f"newmtl {name}\n")
-            f.write("  Ns 10\n")
-            f.write("  Ka 1.000 1.000 1.000\n")
-            f.write("  Kd 1.000 1.000 1.000\n")
-            # map_Kd doit référencer le fichier image *tel quel* (basename)
-            f.write(f"  map_Kd {tex}\n\n")
-
-    # Écrire l'OBJ triangulé (vt par face)
-    obj_name = "cube.obj"
-    obj_path = os.path.join(out_dir, obj_name)
-    with open(obj_path, "w") as f:
-        f.write(f"mtllib {mtl_name}\n")
-        f.write("o CubeTextured\n")
-
-        # vertices (v1..v8)
+
+    # créer faces top et bottom noires (même taille)
+    black = Image.new("RGB", (base_w, base_h), (0, 0, 0))
+    black.save(os.path.join(tmpdir, tex_names["top"]), format="PNG")
+    black.save(os.path.join(tmpdir, tex_names["bottom"]), format="PNG")
+
+    # écrire le .mtl
+    mtl_path = os.path.join(tmpdir, "cube.mtl")
+    with open(mtl_path, "w", encoding="utf-8") as f:
+        for mat_name, tex_file in tex_names.items():
+            f.write(f"newmtl m_{mat_name}\n")
+            f.write("Ka 1.000 1.000 1.000\n")
+            f.write("Kd 1.000 1.000 1.000\n")
+            f.write("Ks 0.000 0.000 0.000\n")
+            f.write("d 1.0\n")
+            f.write("illum 2\n")
+            f.write(f"map_Kd {tex_file}\n\n")
+
+    # écrire le .obj (24 sommets - 4 par face pour avoir des UV distincts)
+    obj_path = os.path.join(tmpdir, "cube.obj")
+    with open(obj_path, "w", encoding="utf-8") as f:
+        f.write("# Cube OBJ generated by build_textured_cube\n")
+        f.write("mtllib cube.mtl\n\n")
+
+        # définir 24 vertices (4 par face)
+        # cube de côté 1 centré en 0
+        s = 0.5
+        # each face uses its own 4 vertices (to allow distinct UVs)
         verts = [
-            (-1.0, -1.0, -1.0),  # v1 (1)
-            ( 1.0, -1.0, -1.0),  # v2 (2)
-            ( 1.0,  1.0, -1.0),  # v3 (3)
-            (-1.0,  1.0, -1.0),  # v4 (4)
-            (-1.0, -1.0,  1.0),  # v5 (5)
-            ( 1.0, -1.0,  1.0),  # v6 (6)
-            ( 1.0,  1.0,  1.0),  # v7 (7)
-            (-1.0,  1.0,  1.0),  # v8 (8)
+            # right (+X)
+            ( s, -s, -s),
+            ( s,  s, -s),
+            ( s,  s,  s),
+            ( s, -s,  s),
+            # left (-X)
+            (-s, -s,  s),
+            (-s,  s,  s),
+            (-s,  s, -s),
+            (-s, -s, -s),
+            # front (+Y)
+            (-s,  s, -s),
+            (-s,  s,  s),
+            ( s,  s,  s),
+            ( s,  s, -s),
+            # back (-Y)
+            ( s, -s, -s),
+            ( s, -s,  s),
+            (-s, -s,  s),
+            (-s, -s, -s),
+            # top (+Z)
+            (-s, -s,  s),
+            ( s, -s,  s),
+            ( s,  s,  s),
+            (-s,  s,  s),
+            # bottom (-Z)
+            (-s,  s, -s),
+            ( s,  s, -s),
+            ( s, -s, -s),
+            (-s, -s, -s),
         ]
         for v in verts:
-            f.write(f"v {v[0]} {v[1]} {v[2]}\n")
-
-        # vt : 4 par face (0,0),(1,0),(1,1),(0,1)
-        uv_coords = [(0.0,0.0),(1.0,0.0),(1.0,1.0),(0.0,1.0)]
+            f.write("v {:.6f} {:.6f} {:.6f}\n".format(*v))
+        f.write("\n")
+
+        # écrire les coordonnées de texture (pour chaque face on mappe (0,0)-(1,1))
+        uvs = [
+            (0.0, 0.0),
+            (1.0, 0.0),
+            (1.0, 1.0),
+            (0.0, 1.0),
+        ]
+        # répéter pour les 6 faces (4 uv each)
         for _ in range(6):
-            for uv in uv_coords:
-                f.write(f"vt {uv[0]} {uv[1]}\n")
-
-        # faces (triangle pairs) ; ordre des matériaux = right,left,front,back,top,bottom
-        faces = {
-            "mat_right": [2,6,7,3],   # x = +1
-            "mat_left":  [5,1,4,8],   # x = -1
-            "mat_front": [5,6,7,8],   # z = +1
-            "mat_back":  [1,2,3,4],   # z = -1
-            "mat_top":   [4,3,7,8],   # y = +1
-            "mat_bottom":[1,5,6,2],   # y = -1
-        }
-
-        # écriture en même ordre que les vt (i.e. 0..5)
-        mats_order = ["mat_right","mat_left","mat_front","mat_back","mat_top","mat_bottom"]
-        for i, mat in enumerate(mats_order):
-            verts_idx = faces[mat]
-            vt_base = i*4 + 1
-            a, b, c, d = verts_idx
-            v1 = f"{a}/{vt_base}"
-            v2 = f"{b}/{vt_base+1}"
-            v3 = f"{c}/{vt_base+2}"
-            v4 = f"{d}/{vt_base+3}"
-            f.write(f"usemtl {mat}\n")
-            f.write(f"f {v1} {v2} {v3}\n")
-            f.write(f"f {v1} {v3} {v4}\n")
-
-    # Retourne le chemin absolu vers .obj (Gradio accepte ça)
-    print(obj_path)
-    return os.path.abspath(obj_path), out_dir
+            for uv in uvs:
+                f.write("vt {:.6f} {:.6f}\n".format(uv[0], uv[1]))
+        f.write("\n")
+
+        # maintenant définir les faces en utilisant v/t indices (1-indexed)
+        # ordre des faces et indices (chaque face a 4 sommets consécutifs)
+        # face vertex index start positions (1-based)
+        # right: verts 1..4  -> vertex indices 1..4, uv 1..4
+        # left: verts 5..8   -> 5..8, uv 5..8
+        # front: 9..12
+        # back: 13..16
+        # top: 17..20
+        # bottom:21..24
+        face_order = ["right", "left", "front", "back", "top", "bottom"]
+        vert_base = 1
+        uv_base = 1
+        for i, face_name in enumerate(face_order):
+            f.write(f"usemtl m_{face_name}\n")
+            # indices for this face
+            v1 = vert_base + i*4
+            v2 = v1 + 1
+            v3 = v1 + 2
+            v4 = v1 + 3
+            t1 = uv_base + i*4
+            t2 = t1 + 1
+            t3 = t1 + 2
+            t4 = t1 + 3
+            # écrire la face comme quad (v/t)
+            f.write(f"f {v1}/{t1} {v2}/{t2} {v3}/{t3} {v4}/{t4}\n\n")
+
+    # retourner le chemin absolu du .obj et le dossier temporaire
+    return (os.path.abspath(obj_path), tmpdir)
 
 # -------------------------
 # Fonction appelée par Gradio