fix: address CodeRabbit critical and major issues

Signed-off-by: Rusheel Sharma <rusheelhere@gmail.com>

Author: Rusheel86

monai/metrics/generalized_dice.py

@@ -156,11 +156,11 @@ def compute_generalized_dice(
 
     # Apply ignore_index masking
     if ignore_index is not None:
-        if ignore_index < y.shape[1]:
+        if 0 <= ignore_index < y.shape[1]:
             # For one-hot: use the ignored class channel
             mask = 1.0 - y[:, ignore_index : ignore_index + 1]
         else:
-            # For sentinel values, check if any channel is valid
+            # For sentinel values (like 255 or -100), check if any channel is valid
             mask = (y.sum(dim=1, keepdim=True) > 0).float()
         y_pred = y_pred * mask
         y = y * mask
@@ -171,7 +171,7 @@ def compute_generalized_dice(
     if not include_background:
         channels_to_use.pop(0)
 
-    if ignore_index is not None:
+    if ignore_index is not None and 0 <= ignore_index < n_channels:
         # If background was 0 and we ignore class 2, we need the correct absolute index
         if ignore_index in channels_to_use:
             channels_to_use.remove(ignore_index)
@@ -181,35 +181,33 @@ def compute_generalized_dice(
 
     # Reducing only spatial dimensions (not batch nor channels), compute the intersection and non-weighted denominator
     reduce_axis = list(range(2, y_pred.dim()))
-    y_o_full = torch.sum(y, dim=reduce_axis)  # shape: (B, C)
     intersection = torch.sum(y[:, channels_to_use, ...] * y_pred[:, channels_to_use, ...], dim=reduce_axis)
     y_o = torch.sum(y[:, channels_to_use, ...], dim=reduce_axis)
     y_pred_o = torch.sum(y_pred[:, channels_to_use, ...], dim=reduce_axis)
 
     denominator = y_o + y_pred_o
 
     # Set the class weights
+    # Set the class weights (computed from scored channels only)
     weight_type = look_up_option(weight_type, Weight)
-    y_o_float = y_o_full.float()
+    y_o_float = y_o.float()
 
     if weight_type == Weight.SIMPLE:
-        w_full = torch.reciprocal(y_o_float)
+        w = torch.reciprocal(y_o_float)
     elif weight_type == Weight.SQUARE:
-        w_full = torch.reciprocal(y_o_float * y_o_float)
+        w = torch.reciprocal(y_o_float * y_o_float)
     else:
-        w_full = torch.ones_like(y_o_float)
+        w = torch.ones_like(y_o_float)
 
     # Replace infinite values for non-appearing classes by the maximum weight
-    for b_idx in range(w_full.shape[0]):
-        batch_w = w_full[b_idx]
+    for b_idx in range(w.shape[0]):
+        batch_w = w[b_idx]
         infs = torch.isinf(batch_w)
         if infs.any():
             batch_w[infs] = 0
             max_w = torch.max(batch_w)
             batch_w[infs] = max_w if max_w > 0 else 1.0
 
-    w = w_full[:, channels_to_use]
-
     if sum_over_classes:
         intersection = (intersection * w).sum(dim=1, keepdim=True)
         denominator = (denominator * w).sum(dim=1, keepdim=True)

monai/metrics/utils.py

@@ -75,6 +75,17 @@ def ignore_index_mask(
     """
     Masks out the specified ignore_index from both predictions and ground truth.
     This is a helper for #8667 to allow 'Ignore Class' functionality in metrics.
+
+    Note: This function assumes label-encoded tensors. For one-hot encoded inputs,
+    use the two-case masking approach as shown in compute_generalized_dice.
+
+    Args:
+        y_pred: predicted tensor with shape (B, C, H, W, [D])
+        y: ground truth tensor with shape (B, C, H, W, [D])
+        ignore_index: class index to ignore. If None, returns inputs unchanged.
+
+    Returns:
+        Tuple of (masked y_pred, masked y) where ignored regions are zeroed out.
     """
     if ignore_index is None:
         return y_pred, y
@@ -284,7 +295,6 @@ def get_surface_distance(
             (1) If a single number, isotropic spacing with that value is used.
             (2) If a sequence of numbers, the length of the sequence must be equal to the image dimensions.
             (3) If ``None``, spacing of unity is used. Defaults to ``None``.
-        mask: optional boolean mask. Pixels where mask is False will be ignored in the distance computation.
 
     Note:
         If seg_pred or seg_gt is all 0, may result in nan/inf distance.
@@ -308,12 +318,10 @@ def get_surface_distance(
 
     dis = convert_to_dst_type(dis, seg_pred, dtype=lib.float32)[0]
     if isinstance(seg_pred, torch.Tensor):
-        out = dis[seg_pred.bool()]  # type: ignore[union-attr]
-        return out if out is not None else np.empty((0,), dtype=dis.dtype)  # type: ignore[union-attr,no-any-return]
+        return dis[seg_pred.bool()]  # type: ignore[union-attr]
     else:
         # NumPy array
-        out = dis[seg_pred.astype(bool)]  # type: ignore[union-attr]
-        return out if out is not None else np.empty((0,), dtype=dis.dtype)  # type: ignore[union-attr]
+        return dis[seg_pred.astype(bool)]  # type: ignore[union-attr,no-any-return]
 
 
 def get_edge_surface_distance(