Updates From Main Branch

app.py

@@ -1607,7 +1607,7 @@ with gr.Blocks(title=title, delete_cache=(21600,86400)) as hexaGrid:
                         gr.update(visible=(x == "Custom List")),
                         gr.update(visible=(x != None))
                         ),
-                        inputs=add_hex_text,
+                        inputs=[add_hex_text],
                         outputs=[custom_text_list, custom_text_color_list, hex_text_info]
                     )
                 with gr.Row():

requirements.txt

@@ -1,10 +1,11 @@
 open3d
-git+https://github.com/huggingface/diffusers.git
-#diffusers[torch]==0.40.0
+#git+https://github.com/huggingface/diffusers.git
+diffusers[torch]==0.40.0
 transformers==5.17.0
 accelerate
 safetensors
 sentencepiece
+#sentence-transformers==6.1.0
 #invisible_watermark
 
 # -------------------------------------------------

trellis/models/structured_latent_flow.py

@@ -109,8 +109,9 @@ class SLatFlowModel(nn.Module):
         self.qk_rms_norm_cross = qk_rms_norm_cross
         self.dtype = torch.float16 if use_fp16 else torch.float32
 
-        assert int(np.log2(patch_size)) == np.log2(patch_size), "Patch size must be a power of 2"
-        assert np.log2(patch_size) == len(io_block_channels), "Number of IO ResBlocks must match the number of stages"
+        if self.io_block_channels is not None:
+            assert int(np.log2(patch_size)) == np.log2(patch_size), "Patch size must be a power of 2"
+            assert np.log2(patch_size) == len(io_block_channels), "Number of IO ResBlocks must match the number of stages"
 
         self.t_embedder = TimestepEmbedder(model_channels)
         if share_mod:
@@ -122,25 +123,27 @@ class SLatFlowModel(nn.Module):
         if pe_mode == "ape":
             self.pos_embedder = AbsolutePositionEmbedder(model_channels)
 
-        self.input_layer = sp.SparseLinear(in_channels, io_block_channels[0])
+        self.input_layer = sp.SparseLinear(in_channels, model_channels if io_block_channels is None else io_block_channels[0])
+        
         self.input_blocks = nn.ModuleList([])
-        for chs, next_chs in zip(io_block_channels, io_block_channels[1:] + [model_channels]):
-            self.input_blocks.extend([
-                SparseResBlock3d(
-                    chs,
-                    model_channels,
-                    out_channels=chs,
-                )
-                for _ in range(num_io_res_blocks-1)
-            ])
-            self.input_blocks.append(
-                SparseResBlock3d(
-                    chs,
-                    model_channels,
-                    out_channels=next_chs,
-                    downsample=True,
+        if io_block_channels is not None:
+            for chs, next_chs in zip(io_block_channels, io_block_channels[1:] + [model_channels]):
+                self.input_blocks.extend([
+                    SparseResBlock3d(
+                        chs,
+                        model_channels,
+                        out_channels=chs,
+                    )
+                    for _ in range(num_io_res_blocks-1)
+                ])
+                self.input_blocks.append(
+                    SparseResBlock3d(
+                        chs,
+                        model_channels,
+                        out_channels=next_chs,
+                        downsample=True,
+                    )
                 )
-            )
             
         self.blocks = nn.ModuleList([
             ModulatedSparseTransformerCrossBlock(
@@ -159,24 +162,26 @@ class SLatFlowModel(nn.Module):
         ])
 
         self.out_blocks = nn.ModuleList([])
-        for chs, prev_chs in zip(reversed(io_block_channels), [model_channels] + list(reversed(io_block_channels[1:]))):
-            self.out_blocks.append(
-                SparseResBlock3d(
-                    prev_chs * 2 if self.use_skip_connection else prev_chs,
-                    model_channels,
-                    out_channels=chs,
-                    upsample=True,
+        if io_block_channels is not None:
+            for chs, prev_chs in zip(reversed(io_block_channels), [model_channels] + list(reversed(io_block_channels[1:]))):
+                self.out_blocks.append(
+                    SparseResBlock3d(
+                        prev_chs * 2 if self.use_skip_connection else prev_chs,
+                        model_channels,
+                        out_channels=chs,
+                        upsample=True,
+                    )
                 )
-            )
-            self.out_blocks.extend([
-                SparseResBlock3d(
-                    chs * 2 if self.use_skip_connection else chs,
-                    model_channels,
-                    out_channels=chs,
-                )
-                for _ in range(num_io_res_blocks-1)
-            ])
-        self.out_layer = sp.SparseLinear(io_block_channels[0], out_channels)
+                self.out_blocks.extend([
+                    SparseResBlock3d(
+                        chs * 2 if self.use_skip_connection else chs,
+                        model_channels,
+                        out_channels=chs,
+                    )
+                    for _ in range(num_io_res_blocks-1)
+                ])
+            
+        self.out_layer = sp.SparseLinear(model_channels if io_block_channels is None else io_block_channels[0], out_channels)
 
         self.initialize_weights()
         if use_fp16:
@@ -260,3 +265,4 @@ class SLatFlowModel(nn.Module):
         h = h.replace(F.layer_norm(h.feats, h.feats.shape[-1:]))
         h = self.out_layer(h.type(x.dtype))
         return h
+    

trellis/pipelines/samplers/flow_euler.py

@@ -37,6 +37,8 @@ class FlowEulerSampler(Sampler):
 
     def _inference_model(self, model, x_t, t, cond=None, **kwargs):
         t = torch.tensor([1000 * t] * x_t.shape[0], device=x_t.device, dtype=torch.float32)
+        if cond is not None and cond.shape[0] == 1 and x_t.shape[0] > 1:
+            cond = cond.repeat(x_t.shape[0], *([1] * (len(cond.shape) - 1)))
         return model(x_t, t, cond, **kwargs)
 
     def _get_model_prediction(self, model, x_t, t, cond=None, **kwargs):

trellis/pipelines/trellis_image_to_3d.py

@@ -148,6 +148,7 @@ class TrellisImageTo3DPipeline(Pipeline):
             raise ValueError(f"Unsupported type of image: {type(image)}")
     
         image = self.image_cond_model_transform(image).to(self.device)
+        self.models['image_cond_model'].to(self.device)
         features = self.models['image_cond_model'](image, is_training=True)['x_prenorm']
         patchtokens = F.layer_norm(features, features.shape[-1:])
         return patchtokens

trellis/representations/mesh/tables.py

@@ -1,10 +1,17 @@
-# Copyright (c) 2023, NVIDIA CORPORATION & AFFILIATES.  All rights reserved.
+# Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
 #
-# NVIDIA CORPORATION & AFFILIATES and its licensors retain all intellectual property
-# and proprietary rights in and to this software, related documentation
-# and any modifications thereto.  Any use, reproduction, disclosure or
-# distribution of this software and related documentation without an express
-# license agreement from NVIDIA CORPORATION & AFFILIATES is strictly prohibited.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
 dmc_table = [
 [[-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
 [[0, 3, 8, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],

utils/misc.py

@@ -116,10 +116,10 @@ def update_dimensions_on_ratio(aspect_ratio_str, base_height):
     new_width, new_height = convert_ratio_to_dimensions(aspect_ratio, base_height)
     return new_width, new_height
 
-def install_torch():    
+def install_torch(torch_version="2.4.0", torchvision_version = "0.19.0"):    
     print("\nInstalling PyTorch with CUDA support...")
     # Define the package and index URL
-    package = "torch==2.4.0"
+    package = f"torch=={torch_version}"
     index_url = "https://download.pytorch.org/whl/cu124"
     # Construct the pip install command
     command = [
@@ -130,7 +130,7 @@ def install_torch():
     subprocess.run(command, check=True)
     print("\nPyTorch installation completed.")
     print("\nInstalling torchvision...")
-    package = "torchvision==0.19.0"
+    package = f"torchvision=={torchvision_version}"
     index_url = "https://download.pytorch.org/whl/cu124"
     # Construct the pip install command
     command = [
@@ -148,13 +148,13 @@ def _get_output(cmd):
         logging.exception(ex)
     return None
 
-def install_cuda_toolkit():    
+def install_cuda_toolkit(cuda_toolkit_file ="https://developer.download.nvidia.com/compute/cuda/12.4.1/local_installers/cuda_12.4.1_550.54.15_linux.run"):    
     #CUDA_TOOLKIT_URL = "https://developer.download.nvidia.com/compute/cuda/11.8.0/local_installers/cuda_11.8.0_520.61.05_linux.run"
     # CUDA_TOOLKIT_URL = "https://developer.download.nvidia.com/compute/cuda/12.2.0/local_installers/cuda_12.2.0_535.54.03_linux.run"
-    CUDA_TOOLKIT_URL = "https://developer.download.nvidia.com/compute/cuda/12.4.1/local_installers/cuda_12.4.1_550.54.15_linux.run"
-    CUDA_TOOLKIT_FILE = "/tmp/%s" % os.path.basename(CUDA_TOOLKIT_URL)
-    print("\nDownloading CUDA Toolkit from %s" % CUDA_TOOLKIT_URL)
-    subprocess.call(["wget", "-q", CUDA_TOOLKIT_URL, "-O", CUDA_TOOLKIT_FILE])
+    # CUDA_TOOLKIT_URL = "https://developer.download.nvidia.com/compute/cuda/12.4.1/local_installers/cuda_12.4.1_550.54.15_linux.run"
+    CUDA_TOOLKIT_FILE = "/tmp/%s" % os.path.basename(cuda_toolkit_file)
+    print("\nDownloading CUDA Toolkit from %s" % cuda_toolkit_file)
+    subprocess.call(["wget", "-q", cuda_toolkit_file, "-O", CUDA_TOOLKIT_FILE])
     subprocess.call(["chmod", "+x", CUDA_TOOLKIT_FILE])
     subprocess.call([CUDA_TOOLKIT_FILE, "--silent", "--toolkit"])    
     os.environ["CUDA_HOME"] = "/usr/local/cuda"