Upload app.py

app.py

@@ -298,103 +298,209 @@ class UNetNoCondWrapper(nn.Module):
 #     return (os.path.abspath(obj_path), tmpdir)
 
 
-def build_textured_cube(pil_imgs):
+def build_textured_cube(pil_imgs, face_rotations=None):
     """
-    pil_imgs: [front, right, back, left]
-    Renvoie : path absolu vers cube.obj
+    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:
+        default_rots = {"front": 0, "right": 270, "back": 180, "left": 90, "top": 0, "bottom": 0}
+        face_order = ["top","right","bottom","left","front","back"]
+    Notes:
+      - Ecrit les fichiers dans /tmp/gradio si possible (HF Spaces).
+      - front/back utilisent la taille de pil_imgs[0] ; left/right utilisent leur propre largeur (rectangles).
     """
-
-    # -------------------------
-    # 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
+    import os
+    import tempfile
+    from PIL import Image
+
+    # validation
+    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).")
+
+    # defaults rotation & ordre
+    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)
+
+    # dossier temporaire (préférer /tmp/gradio sur HF)
+    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 relatifs pour textures (mtl utilisera ces noms)
+    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",
     }
 
-    # -------------------------
-    # 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
-    # -------------------------
+    # récupérer tailles (on suppose que inference a déjà redimensionné left/right si besoin)
+    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
+
+    # définir dimensions physiques du parallélépipède (en "px" puis on normalise)
+    width_px = float(front_w)    # largeur X (front width)
+    height_px = float(front_h)   # hauteur Z
+    # profondeur Y : on prend la largeur des faces latérales (moyenne left/right)
+    depth_px = float((right_w + left_w) / 2.0)
+
+    # normalisation pour garder des coordonnées de l'ordre de ±0.5
+    max_dim = max(width_px, depth_px, height_px, 1.0)
+    scale = 1.0 / max_dim
+    half_x = (width_px * 0.5) * scale   # demi-largeur en X
+    half_y = (depth_px * 0.5) * scale   # demi-profondeur en Y
+    half_z = (height_px * 0.5) * scale  # demi-hauteur en Z
+
+    # mapping attendu pour pil_imgs
+    mapping_order = ["front", "right", "back", "left"]
+    # sauvegarder textures (avec rotation demandée) dans tmpdir
+    for img, face_name in zip(pil_imgs[:4], mapping_order):
+        im = img.convert("RGB")
+        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 taille que front pour cohérence)
+    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
+
+    # --- géométrie : définir quads par face (CCW en regardant la face de l'extérieur)
+    # Convention: +X = right, +Y = front, +Z = up
+    # Les 8 coins (pour référence)
+    #   (-x,-y,-z), ( x,-y,-z), ( x, y,-z), (-x, y,-z),
+    #   (-x,-y, z), ( x,-y, z), ( x, y, z), (-x, y, z)
     quads = {
-        "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]
+        # top (+Z)  : regarder depuis +Z (au-dessus)
+        "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) : regarder depuis +X (côté droit)
+        "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) : regarder depuis -Z (dessous)
+        "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) : regarder depuis -X (côté gauche)
+        "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) : regarder depuis +Y (face avant)
+        "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) : regarder depuis -Y (face arrière)
+        "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),
+        ],
     }
 
-    # -------------------------
-    # 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
+    # --- écrire l'OBJ (24 vertices, 24 vt, triangulé) selon face_order demandé ---
+    face_order = ["top", "right", "bottom", "left", "front", "back"]
+    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 : 4 UVs par face (0..1). On garde origine UV bas-gauche.
+        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), en s'assurant que les matériaux correspondent
+        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
+            # 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, face_rotations=None):
 #     """