Upload 2 files

app.py

@@ -83,14 +83,18 @@ 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):
     """
-    Crée cube.obj + cube.mtl + 6 textures (4 fournies + top/bottom noires).
-    - Attendu: pil_imgs = [front, right, back, left] (PIL.Image)
-    - Les faces latérales seront tournée de +90° (par défaut) pour être toutes dans le même sens.
-    Retour: (chemin_absolu_obj, tmpdir)
+    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
@@ -99,7 +103,7 @@ def build_textured_cube(pil_imgs, face_rotations=None):
     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 par défaut : +90° pour les 4 faces latérales, 0 pour top/bottom
+    # 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
@@ -107,13 +111,14 @@ def build_textured_cube(pil_imgs, face_rotations=None):
         for k, v in default_rots.items():
             face_rotations.setdefault(k, v)
 
-    # --- créer un dossier dans /tmp/gradio si possible (compat HF Spaces) ---
+    # --- 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="cube_", dir=base_dir)
+        tmpdir = tempfile.mkdtemp(prefix="parallelep_", dir=base_dir)
     else:
-        tmpdir = tempfile.mkdtemp(prefix="cube_")
+        tmpdir = tempfile.mkdtemp(prefix="parallelep_")
 
+    # noms de fichiers textures (relatifs)
     tex_names = {
         "front": "tex_front.png",
         "right": "tex_right.png",
@@ -123,17 +128,39 @@ def build_textured_cube(pil_imgs, face_rotations=None):
         "bottom": "tex_bottom.png",
     }
 
-    # uniformiser la taille sur la première image (référence)
-    base_w, base_h = pil_imgs[0].size
-
-    # mapping : pil_imgs est [front, right, back, left]
+    # 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")
-        if im.size != (base_w, base_h):
-            im = im.resize((base_w, base_h), Image.LANCZOS)
+        # 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")
@@ -142,8 +169,8 @@ def build_textured_cube(pil_imgs, face_rotations=None):
         except Exception:
             pass
 
-    # top / bottom : textures noires
-    black = Image.new("RGB", (base_w, base_h), (0, 0, 0))
+    # 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)
@@ -156,10 +183,10 @@ def build_textured_cube(pil_imgs, face_rotations=None):
         except Exception:
             pass
 
-    # --- écrire le MTL (références relatives simples) ---
-    mtl_path = os.path.join(tmpdir, "cube.mtl")
+    # --- é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("# cube material file\n")
+        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")
@@ -173,67 +200,88 @@ def build_textured_cube(pil_imgs, face_rotations=None):
     except Exception:
         pass
 
-    # --- écrire l'OBJ --- 
-    # Nous définissons les blocs de 4 vertices dans l'ordre : front, right, back, left, top, bottom
-    obj_path = os.path.join(tmpdir, "cube.obj")
+    # --- 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("# Cube OBJ generated by build_textured_cube (front,right,back,left,top,bottom)\n")
-        f.write("mtllib cube.mtl\n\n")
-
-        s = 0.5
-        verts = [
-            # front (+Y)
-            (-s,  s, -s),
-            (-s,  s,  s),
-            ( s,  s,  s),
-            ( s,  s, -s),
-            # right (+X)
-            ( 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),
-            # left (-X)
-            (-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("v {:.6f} {:.6f} {:.6f}\n".format(*v))
+        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 24 UVs (4 par face)
-        uvs = [(0.0,0.0),(1.0,0.0),(1.0,1.0),(0.0,1.0)]
+        # é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))
+            for (u, v) in uvs:
+                f.write("vt {:.6f} {:.6f}\n".format(u, v))
         f.write("\n")
 
-        # faces dans le même ordre que les vertices ci-dessus
-        # face_order = ["front", "right", "back", "left", "top", "bottom"]
-        face_order = ["top", "right", "bottom", "left", "front", "back"]
+        # 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
-            # deux triangles (triangulation)
+            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:
@@ -241,13 +289,176 @@ def build_textured_cube(pil_imgs, face_rotations=None):
     except Exception:
         pass
 
-    # vérification rapide
-    for fname in ["cube.obj", "cube.mtl"] + list(tex_names.values()):
+    # 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):
+#     """
+#     Crée cube.obj + cube.mtl + 6 textures (4 fournies + top/bottom noires).
+#     - Attendu: pil_imgs = [front, right, back, left] (PIL.Image)
+#     - Les faces latérales seront tournée de +90° (par défaut) pour être toutes dans le même sens.
+#     Retour: (chemin_absolu_obj, tmpdir)
+#     """
+#     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 par défaut : +90° pour les 4 faces latérales, 0 pour top/bottom
+#     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)
+
+#     # --- créer un dossier dans /tmp/gradio si possible (compat HF Spaces) ---
+#     base_dir = "/tmp/gradio"
+#     if os.path.isdir(base_dir) and os.access(base_dir, os.W_OK):
+#         tmpdir = tempfile.mkdtemp(prefix="cube_", dir=base_dir)
+#     else:
+#         tmpdir = tempfile.mkdtemp(prefix="cube_")
+
+#     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",
+#     }
+
+#     # uniformiser la taille sur la première image (référence)
+#     base_w, base_h = pil_imgs[0].size
+
+#     # mapping : pil_imgs est [front, right, back, left]
+#     mapping_order = ["front", "right", "back", "left"]
+#     for img, face_name in zip(pil_imgs[:4], mapping_order):
+#         im = img.convert("RGB")
+#         if im.size != (base_w, base_h):
+#             im = im.resize((base_w, base_h), Image.LANCZOS)
+#         angle = face_rotations.get(face_name, 0)
+#         if angle % 360 != 0:
+#             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
+#     black = Image.new("RGB", (base_w, base_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 simples) ---
+#     mtl_path = os.path.join(tmpdir, "cube.mtl")
+#     with open(mtl_path, "w", encoding="utf-8") as f:
+#         f.write("# cube material file\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
+
+#     # --- écrire l'OBJ --- 
+#     # Nous définissons les blocs de 4 vertices dans l'ordre : front, right, back, left, top, bottom
+#     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 (front,right,back,left,top,bottom)\n")
+#         f.write("mtllib cube.mtl\n\n")
+
+#         s = 0.5
+#         verts = [
+#             # front (+Y)
+#             (-s,  s, -s),
+#             (-s,  s,  s),
+#             ( s,  s,  s),
+#             ( s,  s, -s),
+#             # right (+X)
+#             ( 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),
+#             # left (-X)
+#             (-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("v {:.6f} {:.6f} {:.6f}\n".format(*v))
+#         f.write("\n")
+
+#         # écrire 24 UVs (4 par face)
+#         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 dans le même ordre que les vertices ci-dessus
+#         face_order = ["top", "right", "bottom", "left", "front", "back"]
+#         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 (triangulation)
+#             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érification rapide
+#     for fname in ["cube.obj", "cube.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)
 
 # -------------------------
 # Fonction appelée par Gradio

inference.py

@@ -14,6 +14,7 @@ from transformers import CLIPTokenizer, CLIPTextModel, CLIPImageProcessor
 from PIL import Image
 import random
 from contextlib import nullcontext
+import cv2
 
 def pil_from(x):
     """Return a PIL.Image given either a PIL.Image or a path string."""
@@ -87,7 +88,8 @@ def inference(fiber_imgs, ring_imgs, num_steps):
     bl = ring_imgs.crop((0, tile, tile, canvas_size))
     br = ring_imgs.crop((tile, tile, canvas_size, canvas_size))
     
-    # resized_img_2 = cv2.resize(tr, (new_width, original_height), interpolation=cv2.INTER_LANCZOS4)
+    tr = cv2.resize(tr, (new_width, original_height), interpolation=cv2.INTER_LANCZOS4)
+    br = cv2.resize(br, (new_width, original_height), interpolation=cv2.INTER_LANCZOS4)
 
     # close opened images to free handles
     fiber_imgs.close()