Upload app.py

app.py

@@ -83,219 +83,318 @@ class UNetNoCondWrapper(nn.Module):
 #     b = base64.b64encode(buf.getvalue()).decode("utf-8")
 #     return f"data:image/png;base64,{b}"
 
-def build_textured_cube(pil_imgs, face_rotations=None):
+# def build_textured_cube(pil_imgs, face_rotations=None):
+#     """
+#     Crée un parallélépipède texturé (OBJ + MTL + textures).
+#     - pil_imgs: liste/tuple de 4 PIL.Image dans l'ordre [front, right, back, left]
+#     - Retour: (chemin_absolu_obj, tmpdir)
+#     - Defaults (comme demandé) :
+#         default_rots = {"front": 0, "right": 270, "back": 180, "left": 90, "top": 0, "bottom": 0}
+#         face_order = ["top","right","bottom","left","front","back"]
+#     Notes:
+#       - Les textures sont écrites dans un dossier temporaire (préférentiellement sous /tmp/gradio).
+#       - Les faces front/back utiliseront la largeur/hauteur de pil_imgs[0].
+#       - Les faces right/left utiliseront la largeur de pil_imgs[1] et pil_imgs[3] (moyenne si différentes).
+#     """
+#     import os
+#     import tempfile
+#     from PIL import Image
+
+#     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 (front, right, back, left).")
+
+#     # rotations & ordre demandés
+#     default_rots = {"front": 0, "right": 270, "back": 180, "left": 90, "top": 0, "bottom": 0}
+#     if face_rotations is None:
+#         face_rotations = default_rots
+#     else:
+#         for k, v in default_rots.items():
+#             face_rotations.setdefault(k, v)
+
+#     # --- creer dossier temporaire preferentiellement sous /tmp/gradio (HF Spaces) ---
+#     base_dir = "/tmp/gradio"
+#     if os.path.isdir(base_dir) and os.access(base_dir, os.W_OK):
+#         tmpdir = tempfile.mkdtemp(prefix="parallelep_", dir=base_dir)
+#     else:
+#         tmpdir = tempfile.mkdtemp(prefix="parallelep_")
+
+#     # noms de fichiers textures (relatifs)
+#     tex_names = {
+#         "front": "tex_front.png",
+#         "right": "tex_right.png",
+#         "back": "tex_back.png",
+#         "left": "tex_left.png",
+#         "top": "tex_top.png",
+#         "bottom": "tex_bottom.png",
+#     }
+
+#     # récupérer tailles (on accepte que les images aient déjà été redimensionnées
+#     # (ex: left/right résized par ton code d'inference à new_width x original_height))
+#     front_w, front_h = pil_imgs[0].size
+#     right_w, right_h = pil_imgs[1].size
+#     back_w, back_h = pil_imgs[2].size
+#     left_w, left_h = pil_imgs[3].size
+
+#     # On définit les dimensions principales du box :
+#     # width (X)  = front_w
+#     # depth (Y)  = moyenne des largeurs de left/right (i.e. largeur le long Y)
+#     # height (Z) = front_h
+#     width_px = float(front_w)
+#     height_px = float(front_h)
+#     # depth: moyenne des largeurs horizontales des textures latérales (right & left)
+#     depth_px = float((right_w + left_w) / 2.0)
+
+#     # Normaliser pour garder la boîte à des tailles raisonnables (max dimension -> 1.0)
+#     max_dim = max(width_px, depth_px, height_px, 1.0)
+#     scale = 1.0 / max_dim
+#     half_x = (width_px * 0.5) * scale
+#     half_y = (depth_px * 0.5) * scale
+#     half_z = (height_px * 0.5) * scale
+
+#     # Mapping attendu pour pil_imgs
+#     mapping_order = ["front", "right", "back", "left"]
+
+#     # Sauvegarder les textures avec rotation demandée (et permissions)
+#     for img, face_name in zip(pil_imgs[:4], mapping_order):
+#         im = img.convert("RGB")
+#         # si la taille diffère (sécurité), on la respecte : on n'uniformise pas ici
+#         angle = face_rotations.get(face_name, 0)
+#         if angle % 360 != 0:
+#             # PIL rotate: angle en degrés, positif = CCW
+#             im = im.rotate(angle, resample=Image.BICUBIC, expand=False)
+#         path = os.path.join(tmpdir, tex_names[face_name])
+#         im.save(path, format="PNG")
+#         try:
+#             os.chmod(path, 0o644)
+#         except Exception:
+#             pass
+
+#     # top / bottom textures noires (même hauteur que front pour homogénéité)
+#     black = Image.new("RGB", (front_w, front_h), (0, 0, 0))
+#     for face_name in ("top", "bottom"):
+#         im = black
+#         angle = face_rotations.get(face_name, 0)
+#         if angle % 360 != 0:
+#             im = im.rotate(angle, resample=Image.BICUBIC, expand=False)
+#         p = os.path.join(tmpdir, tex_names[face_name])
+#         im.save(p, format="PNG")
+#         try:
+#             os.chmod(p, 0o644)
+#         except Exception:
+#             pass
+
+#     # --- écrire le .mtl (références relatives) ---
+#     mtl_path = os.path.join(tmpdir, "parallelep.mtl")
+#     with open(mtl_path, "w", encoding="utf-8") as f:
+#         f.write("# Material file for parallelepiped\n")
+#         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("Ns 10.000\n")
+#             f.write("illum 2\n")
+#             f.write(f"map_Kd {tex_file}\n\n")
+#     try:
+#         os.chmod(mtl_path, 0o644)
+#     except Exception:
+#         pass
+
+#     # --- construire la géométrie : on écrit 24 vertices (4 par face) dans l'ordre
+#     # On utilise l'ordre des faces demandé par toi :
+#     face_order = ["top", "right", "bottom", "left", "front", "back"]
+
+#     # Pour éviter toute confusion d'indices, on définit pour chaque face les 4 sommets (en coordonnées)
+#     # Convention de coordonnées : +X = right, +Y = front, +Z = up
+#     # coins du parallélépipède (en coordonnées globales) si on utilisait 8 sommets :
+#     # but ici on énumère 4-verts par face afin d'avoir des UVs distincts
+#     # Définition des quads (ordre: v0, v1, v2, v3) orientés CCW quand on regarde la face (face avant)
+#     quads = {
+#         # top (+Z) : côté supérieur, couvrira width x depth
+#         "top": [
+#             (-half_x, -half_y,  half_z),
+#             ( half_x, -half_y,  half_z),
+#             ( half_x,  half_y,  half_z),
+#             (-half_x,  half_y,  half_z),
+#         ],
+#         # right (+X) : face latérale droite, couvrira depth x height (u=0..1 mappe largeur depth)
+#         "right": [
+#             ( half_x, -half_y, -half_z),
+#             ( half_x,  half_y, -half_z),
+#             ( half_x,  half_y,  half_z),
+#             ( half_x, -half_y,  half_z),
+#         ],
+#         # bottom (-Z)
+#         "bottom": [
+#             (-half_x,  half_y, -half_z),
+#             ( half_x,  half_y, -half_z),
+#             ( half_x, -half_y, -half_z),
+#             (-half_x, -half_y, -half_z),
+#         ],
+#         # left (-X)
+#         "left": [
+#             (-half_x, -half_y,  half_z),
+#             (-half_x,  half_y,  half_z),
+#             (-half_x,  half_y, -half_z),
+#             (-half_x, -half_y, -half_z),
+#         ],
+#         # front (+Y)
+#         "front": [
+#             (-half_x,  half_y, -half_z),
+#             (-half_x,  half_y,  half_z),
+#             ( half_x,  half_y,  half_z),
+#             ( half_x,  half_y, -half_z),
+#         ],
+#         # back (-Y)
+#         "back": [
+#             ( half_x, -half_y, -half_z),
+#             ( half_x, -half_y,  half_z),
+#             (-half_x, -half_y,  half_z),
+#             (-half_x, -half_y, -half_z),
+#         ],
+#     }
+
+#     # écrire l'OBJ (triangulé, 24 vertices, 24 vt)
+#     obj_path = os.path.join(tmpdir, "parallelep.obj")
+#     with open(obj_path, "w", encoding="utf-8") as f:
+#         f.write("# Parallelepiped OBJ generated by build_textured_cube\n")
+#         f.write("mtllib parallelep.mtl\n\n")
+
+#         # écrire vertices (4 par face dans l'ordre face_order)
+#         for face_name in face_order:
+#             for v in quads[face_name]:
+#                 f.write("v {:.6f} {:.6f} {:.6f}\n".format(*v))
+#         f.write("\n")
+
+#         # écrire UVs : pour chaque face on écrit 4 UVs (0..1)
+#         # note : si la texture est rectangulaire, UVs restent 0..1 et mapperont l'image entière
+#         uvs = [(0.0, 0.0), (1.0, 0.0), (1.0, 1.0), (0.0, 1.0)]
+#         for _ in range(6):
+#             for (u, v) in uvs:
+#                 f.write("vt {:.6f} {:.6f}\n".format(u, v))
+#         f.write("\n")
+
+#         # faces (2 triangles par face), indices 1-based
+#         for i, face_name in enumerate(face_order):
+#             f.write(f"usemtl m_{face_name}\n")
+#             v_base = i * 4 + 1
+#             t_base = i * 4 + 1
+#             v1, v2, v3, v4 = v_base, v_base + 1, v_base + 2, v_base + 3
+#             t1, t2, t3, t4 = t_base, t_base + 1, t_base + 2, t_base + 3
+#             # écrire deux triangles (v/vt)
+#             f.write(f"f {v1}/{t1} {v2}/{t2} {v3}/{t3}\n")
+#             f.write(f"f {v1}/{t1} {v3}/{t3} {v4}/{t4}\n\n")
+#     try:
+#         os.chmod(obj_path, 0o644)
+#     except Exception:
+#         pass
+
+#     # vérifications rapides
+#     for fname in ["parallelep.obj", "parallelep.mtl"] + list(tex_names.values()):
+#         p = os.path.join(tmpdir, fname)
+#         if not os.path.exists(p):
+#             raise FileNotFoundError(f"Fichier attendu introuvable : {p}")
+
+#     return (os.path.abspath(obj_path), tmpdir)
+
+
+def build_textured_cube(pil_imgs):
     """
-    Crée un parallélépipède texturé (OBJ + MTL + textures).
-    - pil_imgs: liste/tuple de 4 PIL.Image dans l'ordre [front, right, back, left]
-    - Retour: (chemin_absolu_obj, tmpdir)
-    - Defaults (comme demandé) :
-        default_rots = {"front": 0, "right": 270, "back": 180, "left": 90, "top": 0, "bottom": 0}
-        face_order = ["top","right","bottom","left","front","back"]
-    Notes:
-      - Les textures sont écrites dans un dossier temporaire (préférentiellement sous /tmp/gradio).
-      - Les faces front/back utiliseront la largeur/hauteur de pil_imgs[0].
-      - Les faces right/left utiliseront la largeur de pil_imgs[1] et pil_imgs[3] (moyenne si différentes).
+    pil_imgs: [front, right, back, left]
+    Renvoie : path absolu vers cube.obj
     """
-    import os
-    import tempfile
-    from PIL import Image
-
-    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 (front, right, back, left).")
-
-    # rotations & ordre demandés
-    default_rots = {"front": 0, "right": 270, "back": 180, "left": 90, "top": 0, "bottom": 0}
-    if face_rotations is None:
-        face_rotations = default_rots
-    else:
-        for k, v in default_rots.items():
-            face_rotations.setdefault(k, v)
-
-    # --- creer dossier temporaire preferentiellement sous /tmp/gradio (HF Spaces) ---
-    base_dir = "/tmp/gradio"
-    if os.path.isdir(base_dir) and os.access(base_dir, os.W_OK):
-        tmpdir = tempfile.mkdtemp(prefix="parallelep_", dir=base_dir)
-    else:
-        tmpdir = tempfile.mkdtemp(prefix="parallelep_")
-
-    # noms de fichiers textures (relatifs)
-    tex_names = {
-        "front": "tex_front.png",
-        "right": "tex_right.png",
-        "back": "tex_back.png",
-        "left": "tex_left.png",
-        "top": "tex_top.png",
-        "bottom": "tex_bottom.png",
+
+    # -------------------------
+    # 1. Création du répertoire temporaire
+    # -------------------------
+    tmpdir = tempfile.mkdtemp()
+    
+    # Créer les images noires pour top et bottom
+    size_square = pil_imgs[0].size[0]  # front est carré
+    black = Image.new("RGB", (size_square, size_square), (0, 0, 0))
+    textures = {
+        "front": pil_imgs[0],
+        "right": pil_imgs[1],
+        "back": pil_imgs[2],
+        "left": pil_imgs[3],
+        "top": black,
+        "bottom": black
     }
 
-    # récupérer tailles (on accepte que les images aient déjà été redimensionnées
-    # (ex: left/right résized par ton code d'inference à new_width x original_height))
-    front_w, front_h = pil_imgs[0].size
-    right_w, right_h = pil_imgs[1].size
-    back_w, back_h = pil_imgs[2].size
-    left_w, left_h = pil_imgs[3].size
-
-    # On définit les dimensions principales du box :
-    # width (X)  = front_w
-    # depth (Y)  = moyenne des largeurs de left/right (i.e. largeur le long Y)
-    # height (Z) = front_h
-    width_px = float(front_w)
-    height_px = float(front_h)
-    # depth: moyenne des largeurs horizontales des textures latérales (right & left)
-    depth_px = float((right_w + left_w) / 2.0)
-
-    # Normaliser pour garder la boîte à des tailles raisonnables (max dimension -> 1.0)
-    max_dim = max(width_px, depth_px, height_px, 1.0)
-    scale = 1.0 / max_dim
-    half_x = (width_px * 0.5) * scale
-    half_y = (depth_px * 0.5) * scale
-    half_z = (height_px * 0.5) * scale
-
-    # Mapping attendu pour pil_imgs
-    mapping_order = ["front", "right", "back", "left"]
-
-    # Sauvegarder les textures avec rotation demandée (et permissions)
-    for img, face_name in zip(pil_imgs[:4], mapping_order):
-        im = img.convert("RGB")
-        # si la taille diffère (sécurité), on la respecte : on n'uniformise pas ici
-        angle = face_rotations.get(face_name, 0)
-        if angle % 360 != 0:
-            # PIL rotate: angle en degrés, positif = CCW
-            im = im.rotate(angle, resample=Image.BICUBIC, expand=False)
-        path = os.path.join(tmpdir, tex_names[face_name])
-        im.save(path, format="PNG")
-        try:
-            os.chmod(path, 0o644)
-        except Exception:
-            pass
-
-    # top / bottom textures noires (même hauteur que front pour homogénéité)
-    black = Image.new("RGB", (front_w, front_h), (0, 0, 0))
-    for face_name in ("top", "bottom"):
-        im = black
-        angle = face_rotations.get(face_name, 0)
-        if angle % 360 != 0:
-            im = im.rotate(angle, resample=Image.BICUBIC, expand=False)
-        p = os.path.join(tmpdir, tex_names[face_name])
-        im.save(p, format="PNG")
-        try:
-            os.chmod(p, 0o644)
-        except Exception:
-            pass
-
-    # --- écrire le .mtl (références relatives) ---
-    mtl_path = os.path.join(tmpdir, "parallelep.mtl")
-    with open(mtl_path, "w", encoding="utf-8") as f:
-        f.write("# Material file for parallelepiped\n")
-        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("Ns 10.000\n")
-            f.write("illum 2\n")
-            f.write(f"map_Kd {tex_file}\n\n")
-    try:
-        os.chmod(mtl_path, 0o644)
-    except Exception:
-        pass
-
-    # --- construire la géométrie : on écrit 24 vertices (4 par face) dans l'ordre
-    # On utilise l'ordre des faces demandé par toi :
-    face_order = ["top", "right", "bottom", "left", "front", "back"]
-
-    # Pour éviter toute confusion d'indices, on définit pour chaque face les 4 sommets (en coordonnées)
-    # Convention de coordonnées : +X = right, +Y = front, +Z = up
-    # coins du parallélépipède (en coordonnées globales) si on utilisait 8 sommets :
-    # but ici on énumère 4-verts par face afin d'avoir des UVs distincts
-    # Définition des quads (ordre: v0, v1, v2, v3) orientés CCW quand on regarde la face (face avant)
+    # -------------------------
+    # 2. Rotation des textures si nécessaire
+    # -------------------------
+    # Toutes les faces +90° pour être dans le même sens
+    rotations = {"front": 0, "right": 270, "back": 180, "left": 90, "top": 0, "bottom": 0}
+    for face, img in textures.items():
+        if rotations[face] != 0:
+            textures[face] = img.rotate(rotations[face], expand=True)
+        # sauvegarder l'image
+        textures[face].save(os.path.join(tmpdir, f"{face}.png"))
+
+    # -------------------------
+    # 3. Dimensions du parallélépipède
+    # -------------------------
+    # front/back = carré
+    w = pil_imgs[0].width
+    h = pil_imgs[0].height
+    # left/right = rectangles
+    d = pil_imgs[1].width  # largeur du rectangle (X) correspond à profondeur
+    # hauteur Z = front.height
+    half_x = w / 2
+    half_y = d / 2
+    half_z = h / 2
+
+    # -------------------------
+    # 4. Définition des sommets
+    # -------------------------
+    verts = [
+        (-half_x, -half_y, -half_z),
+        ( half_x, -half_y, -half_z),
+        ( half_x,  half_y, -half_z),
+        (-half_x,  half_y, -half_z),
+        (-half_x, -half_y,  half_z),
+        ( half_x, -half_y,  half_z),
+        ( half_x,  half_y,  half_z),
+        (-half_x,  half_y,  half_z),
+    ]
+
+    # -------------------------
+    # 5. Faces et textures
+    # -------------------------
     quads = {
-        # top (+Z) : côté supérieur, couvrira width x depth
-        "top": [
-            (-half_x, -half_y,  half_z),
-            ( half_x, -half_y,  half_z),
-            ( half_x,  half_y,  half_z),
-            (-half_x,  half_y,  half_z),
-        ],
-        # right (+X) : face latérale droite, couvrira depth x height (u=0..1 mappe largeur depth)
-        "right": [
-            ( half_x, -half_y, -half_z),
-            ( half_x,  half_y, -half_z),
-            ( half_x,  half_y,  half_z),
-            ( half_x, -half_y,  half_z),
-        ],
-        # bottom (-Z)
-        "bottom": [
-            (-half_x,  half_y, -half_z),
-            ( half_x,  half_y, -half_z),
-            ( half_x, -half_y, -half_z),
-            (-half_x, -half_y, -half_z),
-        ],
-        # left (-X)
-        "left": [
-            (-half_x, -half_y,  half_z),
-            (-half_x,  half_y,  half_z),
-            (-half_x,  half_y, -half_z),
-            (-half_x, -half_y, -half_z),
-        ],
-        # front (+Y)
-        "front": [
-            (-half_x,  half_y, -half_z),
-            (-half_x,  half_y,  half_z),
-            ( half_x,  half_y,  half_z),
-            ( half_x,  half_y, -half_z),
-        ],
-        # back (-Y)
-        "back": [
-            ( half_x, -half_y, -half_z),
-            ( half_x, -half_y,  half_z),
-            (-half_x, -half_y,  half_z),
-            (-half_x, -half_y, -half_z),
-        ],
+        "front":  [4,5,6,7],
+        "back":   [0,1,2,3],
+        "left":   [0,4,7,3],
+        "right":  [1,5,6,2],
+        "top":    [3,7,6,2],
+        "bottom": [0,4,5,1]
     }
 
-    # écrire l'OBJ (triangulé, 24 vertices, 24 vt)
-    obj_path = os.path.join(tmpdir, "parallelep.obj")
-    with open(obj_path, "w", encoding="utf-8") as f:
-        f.write("# Parallelepiped OBJ generated by build_textured_cube\n")
-        f.write("mtllib parallelep.mtl\n\n")
-
-        # écrire vertices (4 par face dans l'ordre face_order)
-        for face_name in face_order:
-            for v in quads[face_name]:
-                f.write("v {:.6f} {:.6f} {:.6f}\n".format(*v))
-        f.write("\n")
-
-        # écrire UVs : pour chaque face on écrit 4 UVs (0..1)
-        # note : si la texture est rectangulaire, UVs restent 0..1 et mapperont l'image entière
-        uvs = [(0.0, 0.0), (1.0, 0.0), (1.0, 1.0), (0.0, 1.0)]
-        for _ in range(6):
-            for (u, v) in uvs:
-                f.write("vt {:.6f} {:.6f}\n".format(u, v))
-        f.write("\n")
-
-        # faces (2 triangles par face), indices 1-based
-        for i, face_name in enumerate(face_order):
-            f.write(f"usemtl m_{face_name}\n")
-            v_base = i * 4 + 1
-            t_base = i * 4 + 1
-            v1, v2, v3, v4 = v_base, v_base + 1, v_base + 2, v_base + 3
-            t1, t2, t3, t4 = t_base, t_base + 1, t_base + 2, t_base + 3
-            # écrire deux triangles (v/vt)
-            f.write(f"f {v1}/{t1} {v2}/{t2} {v3}/{t3}\n")
-            f.write(f"f {v1}/{t1} {v3}/{t3} {v4}/{t4}\n\n")
-    try:
-        os.chmod(obj_path, 0o644)
-    except Exception:
-        pass
-
-    # vérifications rapides
-    for fname in ["parallelep.obj", "parallelep.mtl"] + list(tex_names.values()):
-        p = os.path.join(tmpdir, fname)
-        if not os.path.exists(p):
-            raise FileNotFoundError(f"Fichier attendu introuvable : {p}")
-
-    return (os.path.abspath(obj_path), tmpdir)
+    # -------------------------
+    # 6. Création du fichier OBJ et MTL
+    # -------------------------
+    obj_path = os.path.join(tmpdir, "cube.obj")
+    mtl_path = os.path.join(tmpdir, "cube.mtl")
+    
+    with open(mtl_path, "w") as f:
+        for face in quads:
+            f.write(f"newmtl {face}\n")
+            f.write(f"Ka 1.0 1.0 1.0\nKd 1.0 1.0 1.0\nKs 0.0 0.0 0.0\n")
+            f.write(f"map_Kd {face}.png\n\n")
+
+    with open(obj_path, "w") as f:
+        f.write(f"mtllib cube.mtl\n")
+        for v in verts:
+            f.write(f"v {v[0]} {v[1]} {v[2]}\n")
+        # coordonnées UV simples (coin-bas-gauche à coin-haut-droit)
+        f.write("vt 0 0\nvt 1 0\nvt 1 1\nvt 0 1\n")
+        f.write("vn 0 0 1\n")
+        for face, idxs in quads.items():
+            f.write(f"usemtl {face}\n")
+            f.write(f"f {idxs[0]+1}/1 {idxs[1]+1}/2 {idxs[2]+1}/3 {idxs[3]+1}/4\n")
+
+    return obj_path, tmpdir
     
 # def build_textured_cube(pil_imgs, face_rotations=None):
 #     """