ENH: Update from copilot

Author: aylward

experiments/Heart-GatedCT_To_USD/1-register_images.ipynb

@@ -103,7 +103,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "for i in range(0, 21, 1):  # Process every 4th slice to save time testing\n",
+    "for i in range(0, 21, 4):  # Process every 4th slice to save time testing\n",
     "    print(f\"Processing slice {i:03d}\")\n",
     "    moving_image = itk.imread(os.path.join(data_dir, f\"slice_{i:03d}.mha\"))\n",
     "    result = seg.segment(moving_image, contrast_enhanced_study=True)\n",
@@ -239,4 +239,4 @@
  },
  "nbformat": 4,
  "nbformat_minor": 5
-}
+}

src/physiomotion4d/register_models_pca.py

@@ -81,7 +81,7 @@ def __init__(
         pca_template_model_point_subsample: int = 4,
         pre_pca_transform: Optional[itk.Transform] = None,
         fixed_distance_map: Optional[itk.Image] = None,
-        fixed_model: Optional[pv.UnstructuredGrid] = None,
+        fixed_model: Optional[pv.UnstructuredGrid | pv.PolyData] = None,
         reference_image: Optional[itk.Image] = None,
         log_level: int | str = logging.INFO,
     ):
@@ -186,7 +186,7 @@ def from_json(
         pca_template_model_point_subsample: int = 4,
         pre_pca_transform: Optional[itk.Transform] = None,
         fixed_distance_map: Optional[itk.Image] = None,
-        fixed_model: Optional[pv.UnstructuredGrid] = None,
+        fixed_model: Optional[pv.UnstructuredGrid | pv.PolyData] = None,
         reference_image: Optional[itk.Image] = None,
         log_level: int | str = logging.INFO,
     ) -> Self:

src/physiomotion4d/usd_tools.py

@@ -909,7 +909,21 @@ def apply_colormap_from_primvar(
 
         # Value range: use provided intensity_range or compute from data
         if intensity_range is not None:
-            vmin, vmax = intensity_range
+            try:
+                vmin, vmax = float(intensity_range[0]), float(intensity_range[1])
+            except (TypeError, IndexError) as e:
+                raise ValueError(
+                    "intensity_range must be a sequence of two floats (vmin, vmax)"
+                ) from e
+            if not (np.isfinite(vmin) and np.isfinite(vmax)):
+                raise ValueError(
+                    f"intensity_range values must be finite; got ({vmin}, {vmax})"
+                )
+            if vmin >= vmax:
+                vmin, vmax = vmax, vmin
+                self.log_info(
+                    f"intensity_range was (vmax, vmin); swapped to {vmin:.6g} to {vmax:.6g}"
+                )
             self.log_info(f"Using specified intensity range: {vmin:.6g} to {vmax:.6g}")
         else:
             all_values = np.concatenate([s for _, s in scalar_samples])
@@ -952,7 +966,7 @@ def apply_colormap_from_primvar(
                 normalized = np.full_like(scalar, 0.5)
 
             if use_sigmoid_scale:
-                normalized = 1 / (1 + np.exp(-4 * normalized))
+                normalized = 1 / (1 + np.exp(-4 * (normalized - 0.5)))
 
             normalized = np.clip(normalized, 0.0, 1.0)
 
@@ -1046,6 +1060,7 @@ def set_solid_display_color(
                 color_array = Vt.Vec3fArray([vec] * n_points)
                 display_color_pv.Set(color_array)
         else:
+            default_point_count: int | None = None
             for tc in time_codes:
                 # Normalize to a Usd.TimeCode
                 usd_tc = tc if isinstance(tc, Usd.TimeCode) else Usd.TimeCode(tc)
@@ -1059,12 +1074,20 @@ def set_solid_display_color(
                     n_points = len(pts) if pts is not None else 0
                 if n_points == 0:
                     continue
+                if default_point_count is None:
+                    default_point_count = n_points
                 color_array = Vt.Vec3fArray([vec] * n_points)
                 if usd_tc.IsDefault():
                     display_color_pv.Set(color_array)
                 else:
                     display_color_pv.Set(color_array, usd_tc)
 
+            # Author a default (time-independent) value so consumers that query the
+            # default when not time-scrubbing still see the solid color.
+            if default_point_count is not None:
+                default_color_array = Vt.Vec3fArray([vec] * default_point_count)
+                display_color_pv.Set(default_color_array)
+
         if bind_vertex_color_material:
             self._ensure_vertex_color_material(stage, mesh_prim)
         if stage_path:

src/physiomotion4d/vtk_to_usd/converter.py

@@ -112,6 +112,83 @@ def convert_file(
 
         return stage
 
+    def convert_files_static(
+        self,
+        vtk_files: Sequence[str | Path],
+        output_usd: str | Path,
+        mesh_name: str = "Mesh",
+        material: Optional[MaterialData] = None,
+        extract_surface: bool = True,
+    ) -> Usd.Stage:
+        """Convert multiple VTK files into one static USD stage (no time samples).
+
+        All meshes from all files are added to the scene at default time. Use this
+        when multiple files are provided but filenames do not match a time-series
+        pattern, so they should be combined as a single static scene rather than
+        time steps.
+
+        Args:
+            vtk_files: List of VTK file paths
+            output_usd: Path to output USD file
+            mesh_name: Base name for meshes (each file/part gets a unique name)
+            material: Optional material data. If None, uses default.
+            extract_surface: For .vtu files, whether to extract surface
+
+        Returns:
+            Usd.Stage: Created USD stage
+        """
+        if len(vtk_files) == 0:
+            raise ValueError("Empty file list")
+
+        logger.info(
+            "Converting %d files to static USD (no time samples): %s",
+            len(vtk_files),
+            output_usd,
+        )
+
+        # Create USD stage once (no time range)
+        self._create_stage(output_usd)
+        stage = self.stage
+        mesh_converter = self.mesh_converter
+        material_mgr = self.material_mgr
+        assert stage is not None
+        assert mesh_converter is not None
+        assert material_mgr is not None
+
+        if material is not None:
+            material_mgr.get_or_create_material(material)
+
+        for file_idx, vtk_file in enumerate(vtk_files):
+            mesh_data = read_vtk_file(vtk_file, extract_surface=extract_surface)
+            if material is not None:
+                mesh_data.material_id = material.name
+
+            # Unique base per file to avoid prim path collisions
+            file_base = f"{mesh_name}_{file_idx}"
+
+            if self.settings.separate_objects_by_connectivity:
+                parts = split_mesh_data_by_connectivity(mesh_data, mesh_name=file_base)
+                for _idx, (part_data, base_name) in enumerate(parts):
+                    mesh_path = f"/World/Meshes/{base_name}"
+                    self._ensure_parent_path(mesh_path)
+                    mesh_converter.create_mesh(part_data, mesh_path, bind_material=True)
+            elif self.settings.separate_objects_by_cell_type:
+                parts = split_mesh_data_by_cell_type(mesh_data, mesh_name=file_base)
+                for idx, (part_data, base_name) in enumerate(parts):
+                    prim_name = f"{base_name}_{idx}"
+                    mesh_path = f"/World/Meshes/{prim_name}"
+                    self._ensure_parent_path(mesh_path)
+                    mesh_converter.create_mesh(part_data, mesh_path, bind_material=True)
+            else:
+                mesh_path = f"/World/Meshes/{file_base}"
+                self._ensure_parent_path(mesh_path)
+                mesh_converter.create_mesh(mesh_data, mesh_path, bind_material=True)
+
+        stage.Save()
+        logger.info(f"Saved USD file: {output_usd}")
+
+        return stage
+
     def convert_sequence(
         self,
         vtk_files: Sequence[str | Path],

src/physiomotion4d/vtk_to_usd/mesh_utils.py

@@ -34,15 +34,17 @@ def split_mesh_data_by_cell_type(
 ) -> list[tuple[MeshData, str]]:
     """Split MeshData into one mesh per distinct face vertex count (cell type).
 
-    Each part is named by cell type (e.g. Triangle, Quad, Hexahedron). The caller
-    should append a unique number to form final prim names (e.g. Triangle_0, Quad_0).
+    Each part is named as mesh_name plus the cell type (e.g. MeshName_Triangle,
+    MeshName_Quad). The caller should append a unique number to form final prim
+    names (e.g. MeshName_Triangle_0, MeshName_Quad_0).
 
     Args:
         mesh_data: Single mesh that may contain mixed cell types.
+        mesh_name: Name of the source mesh; used as prefix in returned base_name.
 
     Returns:
         List of (MeshData, base_name) for each cell type present. base_name is
-        the cell type name (e.g. "Triangle", "Quad").
+        mesh_name + "_" + cell type name (e.g. "MeshName_Triangle", "MeshName_Quad").
     """
     counts = np.asarray(mesh_data.face_vertex_counts, dtype=np.int32)
     indices = np.asarray(mesh_data.face_vertex_indices, dtype=np.int32)
@@ -282,14 +284,15 @@ def split_mesh_data_by_connectivity(
     """Split MeshData into one mesh per connected component.
 
     A connected component is a maximal set of cells that share vertices (directly
-    or transitively). Components are named object1, object2, etc.
+    or transitively). Components are named mesh_name_object1, mesh_name_object2, etc.
 
     Args:
         mesh_data: Single mesh that may contain multiple disconnected parts.
+        mesh_name: Name of the source mesh; used as prefix in returned base_name.
 
     Returns:
         List of (MeshData, base_name) for each component. base_name is
-        "object1", "object2", ...
+        mesh_name + "_objectN" (e.g. "MeshName_object1", "MeshName_object2", ...).
     """
     counts = np.asarray(mesh_data.face_vertex_counts, dtype=np.int32)
     indices = np.asarray(mesh_data.face_vertex_indices, dtype=np.int32)

src/physiomotion4d/workflow_convert_vtk_to_usd.py

@@ -27,26 +27,30 @@
 def discover_time_series(
     paths: list[Path],
     pattern: str = r"\.t(\d+)\.(vtk|vtp|vtu)$",
-) -> list[tuple[int, Path]]:
+) -> tuple[list[tuple[int, Path]], bool]:
     """Discover and sort time-series VTK files by extracted time index.
 
     Args:
         paths: List of paths to VTK files
         pattern: Regex with one group for time step number (default matches .t123.vtk)
 
     Returns:
-        Sorted list of (time_step, path) tuples. If no match, returns [(0, p) for p in paths].
+        (time_series, pattern_matched): Sorted list of (time_step, path) tuples, and
+        a flag True if at least one path matched the pattern. If no path matches,
+        time_series is [(0, p) for p in paths] and pattern_matched is False.
     """
     time_series: list[tuple[int, Path]] = []
     regex = re.compile(pattern, re.IGNORECASE)
+    pattern_matched = False
     for p in paths:
         match = regex.search(p.name)
         if match:
             time_series.append((int(match.group(1)), Path(p)))
+            pattern_matched = True
         else:
             time_series.append((0, Path(p)))
     time_series.sort(key=lambda x: (x[0], str(x[1])))
-    return time_series
+    return time_series, pattern_matched
 
 
 AppearanceKind = Literal["solid", "anatomy", "colormap"]
@@ -141,17 +145,24 @@ def run(self) -> str:
             raise ValueError("vtk_files must not be empty")
 
         # Discover time series
-        time_series = discover_time_series(
+        time_series, pattern_matched = discover_time_series(
             self.vtk_files, pattern=self.time_series_pattern
         )
         time_steps = [t for t, _ in time_series]
         time_codes = [float(t) for t in time_steps]
         paths_ordered = [p for _, p in time_series]
         n_frames = len(paths_ordered)
 
+        # Multiple files but no pattern match: treat as static scene (all at time 0, no time samples)
+        is_static_merge = n_frames > 1 and not pattern_matched
+
         self.log_info("Input: %d file(s), time steps: %s", n_frames, time_steps[:5])
         if n_frames > 5:
             self.log_info("  ... and %d more", n_frames - 5)
+        if is_static_merge:
+            self.log_info(
+                "Filenames do not match time-series pattern; outputting static scene (no time samples)"
+            )
         self.log_info("Output: %s", self.output_usd)
 
         settings = ConversionSettings(
@@ -163,7 +174,7 @@ def run(self) -> str:
             separate_objects_by_cell_type=self.separate_by_cell_type,
             up_axis=self.up_axis,
             times_per_second=self.times_per_second,
-            use_time_samples=True,
+            use_time_samples=not is_static_merge,
         )
 
         converter = VTKToUSDConverter(settings)
@@ -181,13 +192,22 @@ def run(self) -> str:
                 material=default_material,
                 extract_surface=self.extract_surface,
             )
+        elif is_static_merge:
+            stage = converter.convert_files_static(
+                paths_ordered,
+                self.output_usd,
+                mesh_name=self.mesh_name,
+                material=default_material,
+                extract_surface=self.extract_surface,
+            )
         else:
+            # Load mesh sequence once for both validation and conversion (avoids double I/O)
+            mesh_sequence = [
+                read_vtk_file(p, extract_surface=self.extract_surface)
+                for p in paths_ordered
+            ]
             # Optional: validate topology consistency across frames
             try:
-                mesh_sequence = [
-                    read_vtk_file(p, extract_surface=self.extract_surface)
-                    for p in paths_ordered
-                ]
                 report = validate_time_series_topology(mesh_sequence)
                 if report.get("topology_changes"):
                     self.log_warning(
@@ -197,13 +217,12 @@ def run(self) -> str:
             except Exception as e:
                 self.log_debug("Time series validation skipped: %s", e)
 
-            stage = converter.convert_sequence(
-                paths_ordered,
+            stage = converter.convert_mesh_data_sequence(
+                mesh_sequence,
                 self.output_usd,
                 mesh_name=self.mesh_name,
                 time_codes=time_codes,
                 material=default_material,
-                extract_surface=self.extract_surface,
             )
 
         # Post-process: apply chosen appearance to all meshes under /World/Meshes
@@ -215,6 +234,9 @@ def run(self) -> str:
             self.log_warning("No mesh prims found under /World/Meshes")
             return str(self.output_usd)
 
+        # Static merge has no time samples; pass None so only default time is used
+        appearance_time_codes = None if is_static_merge else time_codes
+
         self.log_info(
             "Applying appearance '%s' to %d mesh(es)", self.appearance, len(mesh_paths)
         )
@@ -225,7 +247,7 @@ def run(self) -> str:
                     str(self.output_usd),
                     mesh_path,
                     self.solid_color,
-                    time_codes=time_codes,
+                    time_codes=appearance_time_codes,
                     bind_vertex_color_material=True,
                 )
 
@@ -249,7 +271,6 @@ def run(self) -> str:
                     self.log_warning(
                         "No color primvar found for %s; skip colormap", mesh_path
                     )
-                    primvar = self.colormap_primvar
                     continue
                 self.log_info(
                     "Applying colormap to %s from primvar %s", mesh_path, primvar