Fixed preprocessing

processing.py

@@ -58,6 +58,16 @@ def preprocess_nifti(file_path, device=None):
         raw_data = nifti_img.get_fdata(dtype=np.float32)
         print(f"  → Raw data stats: min={raw_data.min():.4f}, max={raw_data.max():.4f}, mean={raw_data.mean():.4f}, std={raw_data.std():.4f}")
         
+        if raw_data.max() - raw_data.min() < 1e-6:
+            raise ValueError(f"Input NIfTI file contains constant values (min=max={raw_data.min():.4f}). Cannot process.")
+        
+        nonzero_mask = raw_data > 1e-6
+        nonzero_count = nonzero_mask.sum()
+        total_count = raw_data.size
+        nonzero_ratio = nonzero_count / total_count if total_count > 0 else 0.0
+        
+        print(f"  → Non-zero voxels: {nonzero_count:,} / {total_count:,} ({100*nonzero_ratio:.2f}%)")
+        
         use_enhanced_preprocessing = os.environ.get("USE_ENHANCED_PREPROCESSING", "false").lower() == "true"
         
         if use_enhanced_preprocessing:
@@ -80,15 +90,28 @@ def preprocess_nifti(file_path, device=None):
             transform = transforms.Compose([
                 transforms.LoadImaged(keys=["image"]),
                 transforms.EnsureChannelFirstD(keys=["image"], channel_dim="no_channel"),
-                transforms.NormalizeIntensityd(keys="image", nonzero=True, channel_wise=True),
+                transforms.NormalizeIntensityd(keys="image", nonzero=True, channel_wise=True, eps=1e-8),
                 transforms.ToTensord(keys=["image"])
             ])
             print("  → Using training-matched preprocessing (for optimal accuracy)")
         
         data = {"image": file_path}
         print("Applying transforms...")
-        augmented = transform(data)
-        image_data = augmented["image"]
+        
+        try:
+            augmented = transform(data)
+            image_data = augmented["image"]
+        except Exception as e:
+            print(f"  ⚠ Transform failed: {e}. Trying fallback preprocessing...")
+            try:
+                raw_data_norm = (raw_data - raw_data.min()) / (raw_data.max() - raw_data.min() + 1e-8)
+                if raw_data_norm.std() < 1e-6:
+                    raise ValueError("Normalized data is still constant")
+                image_data = torch.from_numpy(raw_data_norm).float()
+                image_data = image_data.unsqueeze(0)
+                print("  → Used fallback normalization (min-max scaling)")
+            except Exception as e2:
+                raise ValueError(f"Both standard and fallback preprocessing failed: {e2}")
         
         if not isinstance(image_data, torch.Tensor):
             image_data = torch.from_numpy(np.array(image_data))
@@ -98,8 +121,30 @@ def preprocess_nifti(file_path, device=None):
         
         img_np = image_data.numpy() if not hasattr(image_data, 'device') or image_data.device.type == 'cpu' else image_data.cpu().numpy()
         vmin, vmax = float(img_np.min()), float(img_np.max())
+        
         if vmax - vmin < 1e-6:
-            raise ValueError(f"Preprocessing produced near-constant image: min={vmin:.6f}, max={vmax:.6f}")
+            print(f"  ⚠ WARNING: Preprocessing produced near-constant image (min={vmin:.6f}, max={vmax:.6f}). Trying alternative preprocessing...")
+            try:
+                if nonzero_ratio > 0.01:
+                    nonzero_mean = raw_data[nonzero_mask].mean()
+                    nonzero_std = raw_data[nonzero_mask].std() + 1e-8
+                    raw_data_norm = np.zeros_like(raw_data)
+                    raw_data_norm[nonzero_mask] = (raw_data[nonzero_mask] - nonzero_mean) / nonzero_std
+                    raw_data_norm = (raw_data_norm - raw_data_norm.min()) / (raw_data_norm.max() - raw_data_norm.min() + 1e-8)
+                else:
+                    raw_data_norm = (raw_data - raw_data.min()) / (raw_data.max() - raw_data.min() + 1e-8)
+                
+                if raw_data_norm.std() < 1e-6:
+                    raise ValueError("Alternative normalization also produced constant data")
+                
+                image_data = torch.from_numpy(raw_data_norm).float()
+                image_data = image_data.unsqueeze(0)
+                img_np = image_data.numpy()
+                vmin, vmax = float(img_np.min()), float(img_np.max())
+                print(f"  → Alternative preprocessing successful: min={vmin:.4f}, max={vmax:.4f}, mean={img_np.mean():.4f}, std={img_np.std():.4f}")
+            except Exception as e3:
+                raise ValueError(f"Preprocessing produced near-constant image: min={vmin:.6f}, max={vmax:.6f}. Alternative preprocessing also failed: {e3}")
+        
         print(f"  → After transforms: min={vmin:.4f}, max={vmax:.4f}, mean={img_np.mean():.4f}, std={img_np.std():.4f}")
         
         if device is not None and device.type == 'cuda':