Update app.py

app.py

@@ -347,29 +347,46 @@ def extract_glb(state: dict, mesh_simplify: float, texture_size: int) -> Tuple[s
         # GLB 변환
         with torch.inference_mode():
             try:
-                # Gaussian 객체의 텐서들에 대해 requires_grad 설정
+                # Gaussian 텐서들을 requires_grad=True로 설정
                 for attr_name in ['_xyz', '_features_dc', '_scaling', '_rotation', '_opacity']:
                     if hasattr(gs, attr_name):
                         tensor = getattr(gs, attr_name)
                         if torch.is_tensor(tensor):
-                            tensor.requires_grad_(False)
+                            # 텐서를 복제하고 requires_grad 설정
+                            new_tensor = tensor.clone().detach().requires_grad_(True)
+                            setattr(gs, attr_name, new_tensor)
                 
-                # Mesh 텐서들에 대해 requires_grad 설정
+                # Mesh 텐서들을 requires_grad=True로 설정
                 if hasattr(mesh, 'vertices') and torch.is_tensor(mesh.vertices):
-                    mesh.vertices.requires_grad_(False)
+                    mesh.vertices = mesh.vertices.clone().detach().requires_grad_(True)
                 if hasattr(mesh, 'faces') and torch.is_tensor(mesh.faces):
-                    mesh.faces.requires_grad_(False)
+                    mesh.faces = mesh.faces.clone().detach().requires_grad_(True)
                 
-                glb = postprocessing_utils.to_glb(
-                    gs, 
-                    mesh, 
-                    simplify=mesh_simplify, 
-                    texture_size=texture_size, 
-                    verbose=True
-                )
+                # GLB 변환 시도
+                try:
+                    glb = postprocessing_utils.to_glb(
+                        gs, 
+                        mesh, 
+                        simplify=mesh_simplify, 
+                        texture_size=texture_size, 
+                        verbose=True,
+                        optimize_uv=True,  # UV 최적화 활성화
+                        optimize_steps=2500  # 최적화 스텝 수 설정
+                    )
+                except RuntimeError as e:
+                    print(f"GLB conversion failed with RuntimeError: {str(e)}")
+                    # 최적화 없이 다시 시도
+                    glb = postprocessing_utils.to_glb(
+                        gs, 
+                        mesh, 
+                        simplify=mesh_simplify, 
+                        texture_size=texture_size, 
+                        verbose=True,
+                        optimize_uv=False  # UV 최적화 비활성화
+                    )
                 
-            except RuntimeError as e:
-                print(f"Runtime error during GLB conversion: {str(e)}")
+            except Exception as e:
+                print(f"Error during GLB conversion: {str(e)}")
                 return None, None
             
         if glb is None: