Add files using upload-large-folder tool

source_code/SegMamba/monai/_extensions/gmm/gmm.cpp

@@ -0,0 +1,83 @@
+/*
+Copyright (c) MONAI Consortium
+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.
+*/
+
+#include <torch/extension.h>
+
+#include "gmm.h"
+
+py::tuple init() {
+  torch::Tensor gmm_tensor =
+      torch::zeros({GMM_COUNT, GMM_COMPONENT_COUNT}, torch::dtype(torch::kFloat32).device(torch::kCUDA));
+  torch::Tensor scratch_tensor = torch::empty({1}, torch::dtype(torch::kFloat32).device(torch::kCUDA));
+  return py::make_tuple(gmm_tensor, scratch_tensor);
+}
+
+void learn(
+    torch::Tensor gmm_tensor,
+    torch::Tensor scratch_tensor,
+    torch::Tensor input_tensor,
+    torch::Tensor label_tensor) {
+  c10::DeviceType device_type = input_tensor.device().type();
+
+  unsigned int batch_count = input_tensor.size(0);
+  unsigned int element_count = input_tensor.stride(1);
+
+  unsigned int scratch_size =
+      batch_count * (element_count + GMM_COMPONENT_COUNT * GMM_COUNT * (element_count / (32 * 32)));
+
+  if (scratch_tensor.size(0) < scratch_size) {
+    scratch_tensor.resize_({scratch_size});
+  }
+
+  float* gmm = gmm_tensor.data_ptr<float>();
+  float* scratch = scratch_tensor.data_ptr<float>();
+  float* input = input_tensor.data_ptr<float>();
+  int* labels = label_tensor.data_ptr<int>();
+
+  if (device_type == torch::kCUDA) {
+    learn_cuda(input, labels, gmm, scratch, batch_count, element_count);
+  } else {
+    learn_cpu(input, labels, gmm, scratch, batch_count, element_count);
+  }
+}
+
+torch::Tensor apply(torch::Tensor gmm_tensor, torch::Tensor input_tensor) {
+  c10::DeviceType device_type = input_tensor.device().type();
+
+  unsigned int dim = input_tensor.dim();
+  unsigned int batch_count = input_tensor.size(0);
+  unsigned int element_count = input_tensor.stride(1);
+
+  auto output_size = input_tensor.sizes().vec();
+  output_size[1] = MIXTURE_COUNT;
+  torch::Tensor output_tensor =
+      torch::empty(c10::IntArrayRef(output_size), torch::dtype(torch::kFloat32).device(device_type));
+
+  const float* gmm = gmm_tensor.data_ptr<float>();
+  const float* input = input_tensor.data_ptr<float>();
+  float* output = output_tensor.data_ptr<float>();
+
+  if (device_type == torch::kCUDA) {
+    apply_cuda(gmm, input, output, batch_count, element_count);
+  } else {
+    apply_cpu(gmm, input, output, batch_count, element_count);
+  }
+
+  return output_tensor;
+}
+
+PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) {
+  m.def("init", torch::wrap_pybind_function(init));
+  m.def("learn", torch::wrap_pybind_function(learn));
+  m.def("apply", torch::wrap_pybind_function(apply));
+}

source_code/SegMamba/monai/_extensions/gmm/gmm.h

@@ -0,0 +1,53 @@
+/*
+Copyright (c) MONAI Consortium
+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.
+*/
+
+#if !defined(CHANNEL_COUNT) || !defined(MIXTURE_COUNT) || !defined(MIXTURE_SIZE)
+#error Definition of CHANNEL_COUNT, MIXTURE_COUNT, and MIXTURE_SIZE required
+#endif
+
+#if CHANNEL_COUNT < 1 || MIXTURE_COUNT < 1 || MIXTURE_SIZE < 1
+#error CHANNEL_COUNT, MIXTURE_COUNT, and MIXTURE_SIZE must be positive
+#endif
+
+#define MATRIX_COMPONENT_COUNT ((CHANNEL_COUNT + 1) * (CHANNEL_COUNT + 2) / 2)
+#define SUB_MATRIX_COMPONENT_COUNT (CHANNEL_COUNT * (CHANNEL_COUNT + 1) / 2)
+#define GMM_COMPONENT_COUNT (MATRIX_COMPONENT_COUNT + 1)
+#define GMM_COUNT (MIXTURE_COUNT * MIXTURE_SIZE)
+
+void learn_cpu(
+    const float* input,
+    const int* labels,
+    float* gmm,
+    float* scratch_memory,
+    unsigned int batch_count,
+    unsigned int element_count);
+void apply_cpu(
+    const float* gmm,
+    const float* input,
+    float* output,
+    unsigned int batch_count,
+    unsigned int element_count);
+
+void learn_cuda(
+    const float* input,
+    const int* labels,
+    float* gmm,
+    float* scratch_memory,
+    unsigned int batch_count,
+    unsigned int element_count);
+void apply_cuda(
+    const float* gmm,
+    const float* input,
+    float* output,
+    unsigned int batch_count,
+    unsigned int element_count);

source_code/SegMamba/monai/_extensions/gmm/gmm_cpu.cpp

@@ -0,0 +1,35 @@
+/*
+Copyright (c) MONAI Consortium
+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.
+*/
+
+#include <stdexcept>
+
+#include "gmm.h"
+
+void learn_cpu(
+    const float* input,
+    const int* labels,
+    float* gmm,
+    float* scratch_memory,
+    unsigned int batch_count,
+    unsigned int element_count) {
+  throw std::invalid_argument("GMM received a cpu tensor but is not yet implemented for the cpu");
+}
+
+void apply_cpu(
+    const float* gmm,
+    const float* input,
+    float* output,
+    unsigned int batch_count,
+    unsigned int element_count) {
+  throw std::invalid_argument("GMM received a cpu tensor but is not yet implemented for the cpu");
+}

source_code/SegMamba/monai/apps/auto3dseg/__init__.py

@@ -0,0 +1,25 @@
+# Copyright (c) MONAI Consortium
+# 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.
+
+from __future__ import annotations
+
+from .auto_runner import AutoRunner
+from .bundle_gen import BundleAlgo, BundleGen
+from .data_analyzer import DataAnalyzer
+from .ensemble_builder import (
+    AlgoEnsemble,
+    AlgoEnsembleBestByFold,
+    AlgoEnsembleBestN,
+    AlgoEnsembleBuilder,
+    EnsembleRunner,
+)
+from .hpo_gen import NNIGen, OptunaGen
+from .utils import export_bundle_algo_history, get_name_from_algo_id, import_bundle_algo_history

source_code/SegMamba/monai/apps/auto3dseg/__main__.py

@@ -0,0 +1,35 @@
+# Copyright (c) MONAI Consortium
+# 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.
+
+from __future__ import annotations
+
+from monai.apps.auto3dseg.auto_runner import AutoRunner
+from monai.apps.auto3dseg.bundle_gen import BundleAlgo, BundleGen
+from monai.apps.auto3dseg.data_analyzer import DataAnalyzer
+from monai.apps.auto3dseg.ensemble_builder import AlgoEnsembleBuilder, EnsembleRunner
+from monai.apps.auto3dseg.hpo_gen import NNIGen, OptunaGen
+
+if __name__ == "__main__":
+    from monai.utils import optional_import
+
+    fire, _ = optional_import("fire")
+    fire.Fire(
+        {
+            "DataAnalyzer": DataAnalyzer,
+            "BundleGen": BundleGen,
+            "BundleAlgo": BundleAlgo,
+            "AlgoEnsembleBuilder": AlgoEnsembleBuilder,
+            "EnsembleRunner": EnsembleRunner,
+            "AutoRunner": AutoRunner,
+            "NNIGen": NNIGen,
+            "OptunaGen": OptunaGen,
+        }
+    )

source_code/SegMamba/monai/apps/auto3dseg/transforms.py

@@ -0,0 +1,85 @@
+# Copyright (c) MONAI Consortium
+# 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.
+
+from __future__ import annotations
+
+import warnings
+from collections.abc import Hashable, Mapping
+
+import numpy as np
+import torch
+
+from monai.config import KeysCollection
+from monai.networks.utils import pytorch_after
+from monai.transforms import MapTransform
+from monai.utils.misc import ImageMetaKey
+
+
+class EnsureSameShaped(MapTransform):
+    """
+    Checks if segmentation label images (in keys) have the same spatial shape as the main image (in source_key),
+    and raise an error if the shapes are significantly different.
+    If the shapes are only slightly different (within an allowed_shape_difference in each dim), then resize the label using
+    nearest interpolation. This transform is designed to correct datasets with slight label shape mismatches.
+    Generally image and segmentation label must have the same spatial shape, however some public datasets are having slight
+    shape mismatches, which will cause potential crashes when calculating loss or metric functions.
+    """
+
+    def __init__(
+        self,
+        keys: KeysCollection = "label",
+        allow_missing_keys: bool = False,
+        source_key: str = "image",
+        allowed_shape_difference: int = 5,
+        warn: bool = True,
+    ) -> None:
+        """
+        Args:
+            keys: keys of the corresponding items to be compared to the source_key item shape.
+            allow_missing_keys: do not raise exception if key is missing.
+            source_key: key of the item with the reference shape.
+            allowed_shape_difference: raises error if shapes are different more than this value in any dimension,
+                otherwise corrects for the shape mismatch using nearest interpolation.
+            warn: if `True` prints a warning if the label image is resized
+
+
+        """
+        super().__init__(keys=keys, allow_missing_keys=allow_missing_keys)
+        self.source_key = source_key
+        self.allowed_shape_difference = allowed_shape_difference
+        self.warn = warn
+
+    def __call__(self, data: Mapping[Hashable, torch.Tensor]) -> dict[Hashable, torch.Tensor]:
+        d = dict(data)
+        image_shape = d[self.source_key].shape[1:]
+        for key in self.key_iterator(d):
+            label_shape = d[key].shape[1:]
+            if label_shape != image_shape:
+                filename = ""
+                if hasattr(d[key], "meta") and isinstance(d[key].meta, Mapping):  # type: ignore[attr-defined]
+                    filename = d[key].meta.get(ImageMetaKey.FILENAME_OR_OBJ)  # type: ignore[attr-defined]
+
+                if np.allclose(list(label_shape), list(image_shape), atol=self.allowed_shape_difference):
+                    if self.warn:
+                        warnings.warn(
+                            f"The {key} with shape {label_shape} was resized to match the source shape {image_shape}"
+                            f", the metadata was not updated {filename}."
+                        )
+                    d[key] = torch.nn.functional.interpolate(
+                        input=d[key].unsqueeze(0),
+                        size=image_shape,
+                        mode="nearest-exact" if pytorch_after(1, 11) else "nearest",
+                    ).squeeze(0)
+                else:
+                    raise ValueError(
+                        f"The {key} shape {label_shape} is different from the source shape {image_shape} {filename}."
+                    )
+        return d

source_code/SegMamba/monai/apps/auto3dseg/utils.py

@@ -0,0 +1,90 @@
+# Copyright (c) MONAI Consortium
+# 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.
+
+from __future__ import annotations
+
+import os
+
+from monai.apps.auto3dseg.bundle_gen import BundleAlgo
+from monai.auto3dseg import algo_from_pickle, algo_to_pickle
+from monai.utils.enums import AlgoKeys
+
+__all__ = ["import_bundle_algo_history", "export_bundle_algo_history", "get_name_from_algo_id"]
+
+
+def import_bundle_algo_history(
+    output_folder: str = ".", template_path: str | None = None, only_trained: bool = True
+) -> list:
+    """
+    import the history of the bundleAlgo objects as a list of algo dicts.
+    each algo_dict has keys name (folder name), algo (bundleAlgo), is_trained (bool),
+
+    Args:
+        output_folder: the root path of the algorithms templates.
+        template_path: the algorithm_template. It must contain algo.py in the follow path:
+            ``{algorithm_templates_dir}/{network}/scripts/algo.py``.
+        only_trained: only read the algo history if the algo is trained.
+    """
+
+    history = []
+
+    for name in sorted(os.listdir(output_folder)):
+        write_path = os.path.join(output_folder, name)
+
+        if not os.path.isdir(write_path):
+            continue
+
+        obj_filename = os.path.join(write_path, "algo_object.pkl")
+        if not os.path.isfile(obj_filename):  # saved mode pkl
+            continue
+
+        algo, algo_meta_data = algo_from_pickle(obj_filename, template_path=template_path)
+
+        best_metric = algo_meta_data.get(AlgoKeys.SCORE, None)
+        if best_metric is None:
+            try:
+                best_metric = algo.get_score()
+            except BaseException:
+                pass
+
+        is_trained = best_metric is not None
+
+        if (only_trained and is_trained) or not only_trained:
+            history.append(
+                {AlgoKeys.ID: name, AlgoKeys.ALGO: algo, AlgoKeys.SCORE: best_metric, AlgoKeys.IS_TRAINED: is_trained}
+            )
+
+    return history
+
+
+def export_bundle_algo_history(history: list[dict[str, BundleAlgo]]) -> None:
+    """
+    Save all the BundleAlgo in the history to algo_object.pkl in each individual folder
+
+    Args:
+        history: a List of Bundle. Typically, the history can be obtained from BundleGen get_history method
+    """
+    for algo_dict in history:
+        algo = algo_dict[AlgoKeys.ALGO]
+        algo_to_pickle(algo, template_path=algo.template_path)
+
+
+def get_name_from_algo_id(id: str) -> str:
+    """
+    Get the name of Algo from the identifier of the Algo.
+
+    Args:
+        id: identifier which follows a convention of "name_fold_other".
+
+    Returns:
+        name of the Algo.
+    """
+    return id.split("_")[0]

source_code/SegMamba/monai/apps/detection/networks/retinanet_network.py

@@ -0,0 +1,432 @@
+# Copyright (c) MONAI Consortium
+# 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.
+
+# =========================================================================
+# Adapted from https://github.com/pytorch/vision/blob/main/torchvision/models/detection/retinanet.py
+# which has the following license...
+# https://github.com/pytorch/vision/blob/main/LICENSE
+
+# BSD 3-Clause License
+
+# Copyright (c) Soumith Chintala 2016,
+# All rights reserved.
+
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+
+# * Redistributions of source code must retain the above copyright notice, this
+#   list of conditions and the following disclaimer.
+
+# * Redistributions in binary form must reproduce the above copyright notice,
+#   this list of conditions and the following disclaimer in the documentation
+#   and/or other materials provided with the distribution.
+
+# * Neither the name of the copyright holder nor the names of its
+#   contributors may be used to endorse or promote products derived from
+#   this software without specific prior written permission.
+"""
+Part of this script is adapted from
+https://github.com/pytorch/vision/blob/main/torchvision/models/detection/retinanet.py
+"""
+
+from __future__ import annotations
+
+import math
+import warnings
+from collections.abc import Callable, Sequence
+from typing import Any, Dict
+
+import torch
+from torch import Tensor, nn
+
+from monai.networks.blocks.backbone_fpn_utils import BackboneWithFPN, _resnet_fpn_extractor
+from monai.networks.layers.factories import Conv
+from monai.networks.nets import resnet
+from monai.utils import ensure_tuple_rep, look_up_option, optional_import
+
+_validate_trainable_layers, _ = optional_import(
+    "torchvision.models.detection.backbone_utils", name="_validate_trainable_layers"
+)
+
+
+class RetinaNetClassificationHead(nn.Module):
+    """
+    A classification head for use in RetinaNet.
+
+    This head takes a list of feature maps as inputs, and outputs a list of classification maps.
+    Each output map has same spatial size with the corresponding input feature map,
+    and the number of output channel is num_anchors * num_classes.
+
+    Args:
+        in_channels: number of channels of the input feature
+        num_anchors: number of anchors to be predicted
+        num_classes: number of classes to be predicted
+        spatial_dims: spatial dimension of the network, should be 2 or 3.
+        prior_probability: prior probability to initialize classification convolutional layers.
+    """
+
+    def __init__(
+        self, in_channels: int, num_anchors: int, num_classes: int, spatial_dims: int, prior_probability: float = 0.01
+    ):
+        super().__init__()
+
+        conv_type: Callable = Conv[Conv.CONV, spatial_dims]
+        conv = []
+        for _ in range(4):
+            conv.append(conv_type(in_channels, in_channels, kernel_size=3, stride=1, padding=1))
+            conv.append(nn.GroupNorm(num_groups=8, num_channels=in_channels))
+            conv.append(nn.ReLU())
+        self.conv = nn.Sequential(*conv)
+
+        for layer in self.conv.children():
+            if isinstance(layer, conv_type):  # type: ignore
+                torch.nn.init.normal_(layer.weight, std=0.01)
+                torch.nn.init.constant_(layer.bias, 0)
+
+        self.cls_logits = conv_type(in_channels, num_anchors * num_classes, kernel_size=3, stride=1, padding=1)
+        torch.nn.init.normal_(self.cls_logits.weight, std=0.01)
+        torch.nn.init.constant_(self.cls_logits.bias, -math.log((1 - prior_probability) / prior_probability))
+
+        self.num_classes = num_classes
+        self.num_anchors = num_anchors
+
+    def forward(self, x: list[Tensor]) -> list[Tensor]:
+        """
+        It takes a list of feature maps as inputs, and outputs a list of classification maps.
+        Each output classification map has same spatial size with the corresponding input feature map,
+        and the number of output channel is num_anchors * num_classes.
+
+        Args:
+            x: list of feature map, x[i] is a (B, in_channels, H_i, W_i) or (B, in_channels, H_i, W_i, D_i) Tensor.
+
+        Return:
+            cls_logits_maps, list of classification map. cls_logits_maps[i] is a
+            (B, num_anchors * num_classes, H_i, W_i) or (B, num_anchors * num_classes, H_i, W_i, D_i) Tensor.
+
+        """
+        cls_logits_maps = []
+
+        if isinstance(x, Tensor):
+            feature_maps = [x]
+        else:
+            feature_maps = x
+
+        for features in feature_maps:
+            cls_logits = self.conv(features)
+            cls_logits = self.cls_logits(cls_logits)
+
+            cls_logits_maps.append(cls_logits)
+
+            if torch.isnan(cls_logits).any() or torch.isinf(cls_logits).any():
+                if torch.is_grad_enabled():
+                    raise ValueError("cls_logits is NaN or Inf.")
+                else:
+                    warnings.warn("cls_logits is NaN or Inf.")
+
+        return cls_logits_maps
+
+
+class RetinaNetRegressionHead(nn.Module):
+    """
+    A regression head for use in RetinaNet.
+
+    This head takes a list of feature maps as inputs, and outputs a list of box regression maps.
+    Each output box regression map has same spatial size with the corresponding input feature map,
+    and the number of output channel is num_anchors * 2 * spatial_dims.
+
+    Args:
+        in_channels: number of channels of the input feature
+        num_anchors: number of anchors to be predicted
+        spatial_dims: spatial dimension of the network, should be 2 or 3.
+    """
+
+    def __init__(self, in_channels: int, num_anchors: int, spatial_dims: int):
+        super().__init__()
+
+        conv_type: Callable = Conv[Conv.CONV, spatial_dims]
+
+        conv = []
+        for _ in range(4):
+            conv.append(conv_type(in_channels, in_channels, kernel_size=3, stride=1, padding=1))
+            conv.append(nn.GroupNorm(num_groups=8, num_channels=in_channels))
+            conv.append(nn.ReLU())
+
+        self.conv = nn.Sequential(*conv)
+
+        self.bbox_reg = conv_type(in_channels, num_anchors * 2 * spatial_dims, kernel_size=3, stride=1, padding=1)
+        torch.nn.init.normal_(self.bbox_reg.weight, std=0.01)
+        torch.nn.init.zeros_(self.bbox_reg.bias)
+
+        for layer in self.conv.children():
+            if isinstance(layer, conv_type):  # type: ignore
+                torch.nn.init.normal_(layer.weight, std=0.01)
+                torch.nn.init.zeros_(layer.bias)
+
+    def forward(self, x: list[Tensor]) -> list[Tensor]:
+        """
+        It takes a list of feature maps as inputs, and outputs a list of box regression maps.
+        Each output box regression map has same spatial size with the corresponding input feature map,
+        and the number of output channel is num_anchors * 2 * spatial_dims.
+
+        Args:
+            x: list of feature map, x[i] is a (B, in_channels, H_i, W_i) or (B, in_channels, H_i, W_i, D_i) Tensor.
+
+        Return:
+            box_regression_maps, list of box regression map. cls_logits_maps[i] is a
+            (B, num_anchors * 2 * spatial_dims, H_i, W_i) or (B, num_anchors * 2 * spatial_dims, H_i, W_i, D_i) Tensor.
+
+        """
+        box_regression_maps = []
+
+        if isinstance(x, Tensor):
+            feature_maps = [x]
+        else:
+            feature_maps = x
+
+        for features in feature_maps:
+            box_regression = self.conv(features)
+            box_regression = self.bbox_reg(box_regression)
+
+            box_regression_maps.append(box_regression)
+
+            if torch.isnan(box_regression).any() or torch.isinf(box_regression).any():
+                if torch.is_grad_enabled():
+                    raise ValueError("box_regression is NaN or Inf.")
+                else:
+                    warnings.warn("box_regression is NaN or Inf.")
+
+        return box_regression_maps
+
+
+class RetinaNet(nn.Module):
+    """
+    The network used in RetinaNet.
+
+    It takes an image tensor as inputs, and outputs either 1) a dictionary ``head_outputs``.
+    ``head_outputs[self.cls_key]`` is the predicted classification maps, a list of Tensor.
+    ``head_outputs[self.box_reg_key]`` is the predicted box regression maps, a list of Tensor.
+    or 2) a list of 2N tensors ``head_outputs``, with first N tensors being the predicted
+    classification maps and second N tensors being the predicted box regression maps.
+
+    Args:
+        spatial_dims: number of spatial dimensions of the images. We support both 2D and 3D images.
+        num_classes: number of output classes of the model (excluding the background).
+        num_anchors: number of anchors at each location.
+        feature_extractor: a network that outputs feature maps from the input images,
+            each feature map corresponds to a different resolution.
+            Its output can have a format of Tensor, Dict[Any, Tensor], or Sequence[Tensor].
+            It can be the output of ``resnet_fpn_feature_extractor(*args, **kwargs)``.
+        size_divisible: the spatial size of the network input should be divisible by size_divisible,
+            decided by the feature_extractor.
+        use_list_output: default False. If False, the network outputs a dictionary ``head_outputs``,
+            ``head_outputs[self.cls_key]`` is the predicted classification maps, a list of Tensor.
+            ``head_outputs[self.box_reg_key]`` is the predicted box regression maps, a list of Tensor.
+            If True, the network outputs a list of 2N tensors ``head_outputs``, with first N tensors being
+            the predicted classification maps and second N tensors being the predicted box regression maps.
+
+    Example:
+
+        .. code-block:: python
+
+            from monai.networks.nets import resnet
+            spatial_dims = 3  # 3D network
+            conv1_t_stride = (2,2,1)  # stride of first convolutional layer in backbone
+            backbone = resnet.ResNet(
+                spatial_dims = spatial_dims,
+                block = resnet.ResNetBottleneck,
+                layers = [3, 4, 6, 3],
+                block_inplanes = resnet.get_inplanes(),
+                n_input_channels= 1,
+                conv1_t_stride = conv1_t_stride,
+                conv1_t_size = (7,7,7),
+            )
+            # This feature_extractor outputs 4-level feature maps.
+            # number of output feature maps is len(returned_layers)+1
+            returned_layers = [1,2,3]  # returned layer from feature pyramid network
+            feature_extractor = resnet_fpn_feature_extractor(
+                backbone = backbone,
+                spatial_dims = spatial_dims,
+                pretrained_backbone = False,
+                trainable_backbone_layers = None,
+                returned_layers = returned_layers,
+            )
+            # This feature_extractor requires input image spatial size
+            # to be divisible by (32, 32, 16).
+            size_divisible = tuple(2*s*2**max(returned_layers) for s in conv1_t_stride)
+            model = RetinaNet(
+                spatial_dims = spatial_dims,
+                num_classes = 5,
+                num_anchors = 6,
+                feature_extractor=feature_extractor,
+                size_divisible = size_divisible,
+            ).to(device)
+            result = model(torch.rand(2, 1, 128,128,128))
+            cls_logits_maps = result["classification"]  # a list of len(returned_layers)+1 Tensor
+            box_regression_maps = result["box_regression"]  # a list of len(returned_layers)+1 Tensor
+    """
+
+    def __init__(
+        self,
+        spatial_dims: int,
+        num_classes: int,
+        num_anchors: int,
+        feature_extractor: nn.Module,
+        size_divisible: Sequence[int] | int = 1,
+        use_list_output: bool = False,
+    ):
+        super().__init__()
+
+        self.spatial_dims = look_up_option(spatial_dims, supported=[1, 2, 3])
+        self.num_classes = num_classes
+        self.size_divisible = ensure_tuple_rep(size_divisible, self.spatial_dims)
+        self.use_list_output = use_list_output
+
+        if not hasattr(feature_extractor, "out_channels"):
+            raise ValueError(
+                "feature_extractor should contain an attribute out_channels "
+                "specifying the number of output channels (assumed to be the "
+                "same for all the levels)"
+            )
+        self.feature_extractor = feature_extractor
+
+        self.feature_map_channels: int = self.feature_extractor.out_channels
+        self.num_anchors = num_anchors
+        self.classification_head = RetinaNetClassificationHead(
+            self.feature_map_channels, self.num_anchors, self.num_classes, spatial_dims=self.spatial_dims
+        )
+        self.regression_head = RetinaNetRegressionHead(
+            self.feature_map_channels, self.num_anchors, spatial_dims=self.spatial_dims
+        )
+
+        self.cls_key: str = "classification"
+        self.box_reg_key: str = "box_regression"
+
+    def forward(self, images: Tensor) -> Any:
+        """
+        It takes an image tensor as inputs, and outputs predicted classification maps
+        and predicted box regression maps in ``head_outputs``.
+
+        Args:
+            images: input images, sized (B, img_channels, H, W) or (B, img_channels, H, W, D).
+
+        Return:
+            1) If self.use_list_output is False, output a dictionary ``head_outputs`` with
+            keys including self.cls_key and self.box_reg_key.
+            ``head_outputs[self.cls_key]`` is the predicted classification maps, a list of Tensor.
+            ``head_outputs[self.box_reg_key]`` is the predicted box regression maps, a list of Tensor.
+            2) if self.use_list_output is True, outputs a list of 2N tensors ``head_outputs``, with first N tensors being
+            the predicted classification maps and second N tensors being the predicted box regression maps.
+
+        """
+        # compute features maps list from the input images.
+        features = self.feature_extractor(images)
+        if isinstance(features, Tensor):
+            feature_maps = [features]
+        elif torch.jit.isinstance(features, Dict[str, Tensor]):
+            feature_maps = list(features.values())
+        else:
+            feature_maps = list(features)
+
+        if not isinstance(feature_maps[0], Tensor):
+            raise ValueError("feature_extractor output format must be Tensor, Dict[str, Tensor], or Sequence[Tensor].")
+
+        # compute classification and box regression maps from the feature maps
+        # expandable for mask prediction in the future
+
+        if not self.use_list_output:
+            # output dict
+            head_outputs = {self.cls_key: self.classification_head(feature_maps)}
+            head_outputs[self.box_reg_key] = self.regression_head(feature_maps)
+            return head_outputs
+        else:
+            # output list of tensor, first half is classification, second half is box regression
+            head_outputs_sequence = self.classification_head(feature_maps) + self.regression_head(feature_maps)
+            return head_outputs_sequence
+
+
+def resnet_fpn_feature_extractor(
+    backbone: resnet.ResNet,
+    spatial_dims: int,
+    pretrained_backbone: bool = False,
+    returned_layers: Sequence[int] = (1, 2, 3),
+    trainable_backbone_layers: int | None = None,
+) -> BackboneWithFPN:
+    """
+    Constructs a feature extractor network with a ResNet-FPN backbone, used as feature_extractor in RetinaNet.
+
+    Reference: `"Focal Loss for Dense Object Detection" <https://arxiv.org/abs/1708.02002>`_.
+
+    The returned feature_extractor network takes an image tensor as inputs,
+    and outputs a dictionary that maps string to the extracted feature maps (Tensor).
+
+    The input to the returned feature_extractor is expected to be a list of tensors,
+    each of shape ``[C, H, W]`` or ``[C, H, W, D]``,
+    one for each image. Different images can have different sizes.
+
+
+    Args:
+        backbone: a ResNet model, used as backbone.
+        spatial_dims: number of spatial dimensions of the images. We support both 2D and 3D images.
+        pretrained_backbone: whether the backbone has been pre-trained.
+        returned_layers: returned layers to extract feature maps. Each returned layer should be in the range [1,4].
+            len(returned_layers)+1 will be the number of extracted feature maps.
+            There is an extra maxpooling layer LastLevelMaxPool() appended.
+        trainable_backbone_layers: number of trainable (not frozen) resnet layers starting from final block.
+            Valid values are between 0 and 5, with 5 meaning all backbone layers are trainable.
+            When pretrained_backbone is False, this value is set to be 5.
+            When pretrained_backbone is True, if ``None`` is passed (the default) this value is set to 3.
+
+    Example:
+
+        .. code-block:: python
+
+            from monai.networks.nets import resnet
+            spatial_dims = 3 # 3D network
+            backbone = resnet.ResNet(
+                spatial_dims = spatial_dims,
+                block = resnet.ResNetBottleneck,
+                layers = [3, 4, 6, 3],
+                block_inplanes = resnet.get_inplanes(),
+                n_input_channels= 1,
+                conv1_t_stride = (2,2,1),
+                conv1_t_size = (7,7,7),
+            )
+            # This feature_extractor outputs 4-level feature maps.
+            # number of output feature maps is len(returned_layers)+1
+            feature_extractor = resnet_fpn_feature_extractor(
+                backbone = backbone,
+                spatial_dims = spatial_dims,
+                pretrained_backbone = False,
+                trainable_backbone_layers = None,
+                returned_layers = [1,2,3],
+            )
+            model = RetinaNet(
+                spatial_dims = spatial_dims,
+                num_classes = 5,
+                num_anchors = 6,
+                feature_extractor=feature_extractor,
+                size_divisible = 32,
+            ).to(device)
+    """
+    # If pretrained_backbone is False, valid_trainable_backbone_layers = 5.
+    # If pretrained_backbone is True, valid_trainable_backbone_layers = trainable_backbone_layers or 3 if None.
+    valid_trainable_backbone_layers: int = _validate_trainable_layers(
+        pretrained_backbone, trainable_backbone_layers, max_value=5, default_value=3
+    )
+
+    feature_extractor = _resnet_fpn_extractor(
+        backbone,
+        spatial_dims,
+        valid_trainable_backbone_layers,
+        returned_layers=list(returned_layers),
+        extra_blocks=None,
+    )
+    return feature_extractor

source_code/SegMamba/monai/apps/mmars/model_desc.py

@@ -0,0 +1,229 @@
+# Copyright (c) MONAI Consortium
+# 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.
+"""
+Collection of the remote MMAR descriptors
+
+See Also:
+    - https://docs.nvidia.com/clara/clara-train-sdk/pt/mmar.html
+"""
+
+from __future__ import annotations
+
+import os
+from typing import Any
+
+__all__ = ["MODEL_DESC", "RemoteMMARKeys"]
+
+
+class RemoteMMARKeys:
+    """
+    Data keys used for loading MMAR.
+    ID must uniquely define an MMAR.
+    """
+
+    ID = "id"  # unique MMAR
+    NAME = "name"  # MMAR name for readability
+    URL = "url"  # remote location of the MMAR, see also: `monai.apps.mmars.mmars._get_ngc_url`
+    DOC = "doc"  # documentation page of the remote model, see also: `monai.apps.mmars.mmars._get_ngc_doc_url`
+    FILE_TYPE = "file_type"  # type of the compressed MMAR
+    HASH_TYPE = "hash_type"  # hashing method for the compressed MMAR
+    HASH_VAL = "hash_val"  # hashing value for the compressed MMAR
+    MODEL_FILE = "model_file"  # within an MMAR folder, the relative path to the model file
+    CONFIG_FILE = "config_file"  # within an MMAR folder, the relative path to the config file (for model config)
+    VERSION = "version"  # version of the MMAR
+
+
+MODEL_DESC: tuple[dict[Any, Any], ...] = (
+    {
+        RemoteMMARKeys.ID: "clara_pt_spleen_ct_segmentation_1",
+        RemoteMMARKeys.NAME: "clara_pt_spleen_ct_segmentation",
+        RemoteMMARKeys.FILE_TYPE: "zip",
+        RemoteMMARKeys.HASH_TYPE: "md5",
+        RemoteMMARKeys.HASH_VAL: None,
+        RemoteMMARKeys.MODEL_FILE: os.path.join("models", "model.pt"),
+        RemoteMMARKeys.CONFIG_FILE: os.path.join("config", "config_train.json"),
+        RemoteMMARKeys.VERSION: 1,
+    },
+    {
+        RemoteMMARKeys.ID: "clara_pt_prostate_mri_segmentation_1",
+        RemoteMMARKeys.NAME: "clara_pt_prostate_mri_segmentation",
+        RemoteMMARKeys.FILE_TYPE: "zip",
+        RemoteMMARKeys.HASH_TYPE: "md5",
+        RemoteMMARKeys.HASH_VAL: None,
+        RemoteMMARKeys.MODEL_FILE: os.path.join("models", "model.pt"),
+        RemoteMMARKeys.CONFIG_FILE: os.path.join("config", "config_train.json"),
+        RemoteMMARKeys.VERSION: 1,
+    },
+    {
+        RemoteMMARKeys.ID: "clara_pt_covid19_ct_lesion_segmentation_1",
+        RemoteMMARKeys.NAME: "clara_pt_covid19_ct_lesion_segmentation",
+        RemoteMMARKeys.FILE_TYPE: "zip",
+        RemoteMMARKeys.HASH_TYPE: "md5",
+        RemoteMMARKeys.HASH_VAL: None,
+        RemoteMMARKeys.MODEL_FILE: os.path.join("models", "model.pt"),
+        RemoteMMARKeys.VERSION: 1,
+    },
+    {
+        RemoteMMARKeys.ID: "clara_pt_covid19_3d_ct_classification_1",
+        RemoteMMARKeys.NAME: "clara_pt_covid19_3d_ct_classification",
+        RemoteMMARKeys.FILE_TYPE: "zip",
+        RemoteMMARKeys.HASH_TYPE: "md5",
+        RemoteMMARKeys.HASH_VAL: None,
+        RemoteMMARKeys.MODEL_FILE: os.path.join("models", "model.pt"),
+        RemoteMMARKeys.CONFIG_FILE: os.path.join("config", "config_train.json"),
+        RemoteMMARKeys.VERSION: 1,
+    },
+    {
+        RemoteMMARKeys.ID: "clara_pt_covid19_ct_lung_annotation_1",
+        RemoteMMARKeys.NAME: "clara_pt_covid19_ct_lung_annotation",
+        RemoteMMARKeys.FILE_TYPE: "zip",
+        RemoteMMARKeys.HASH_TYPE: "md5",
+        RemoteMMARKeys.HASH_VAL: None,
+        RemoteMMARKeys.MODEL_FILE: os.path.join("models", "model.pt"),
+        RemoteMMARKeys.VERSION: 1,
+    },
+    {
+        RemoteMMARKeys.ID: "clara_pt_fed_learning_brain_tumor_mri_segmentation_1",
+        RemoteMMARKeys.NAME: "clara_pt_fed_learning_brain_tumor_mri_segmentation",
+        RemoteMMARKeys.FILE_TYPE: "zip",
+        RemoteMMARKeys.HASH_TYPE: "md5",
+        RemoteMMARKeys.HASH_VAL: None,
+        RemoteMMARKeys.MODEL_FILE: os.path.join("models", "server", "best_FL_global_model.pt"),
+        RemoteMMARKeys.VERSION: 1,
+    },
+    {
+        RemoteMMARKeys.ID: "clara_pt_pathology_metastasis_detection_1",
+        RemoteMMARKeys.NAME: "clara_pt_pathology_metastasis_detection",
+        RemoteMMARKeys.FILE_TYPE: "zip",
+        RemoteMMARKeys.HASH_TYPE: "md5",
+        RemoteMMARKeys.HASH_VAL: None,
+        RemoteMMARKeys.MODEL_FILE: os.path.join("models", "model.pt"),
+        RemoteMMARKeys.CONFIG_FILE: os.path.join("config", "config_train.json"),
+        RemoteMMARKeys.VERSION: 1,
+    },
+    {
+        RemoteMMARKeys.ID: "clara_pt_brain_mri_segmentation_1",
+        RemoteMMARKeys.NAME: "clara_pt_brain_mri_segmentation",
+        RemoteMMARKeys.FILE_TYPE: "zip",
+        RemoteMMARKeys.HASH_TYPE: "md5",
+        RemoteMMARKeys.HASH_VAL: None,
+        RemoteMMARKeys.MODEL_FILE: os.path.join("models", "model.pt"),
+        RemoteMMARKeys.VERSION: 1,
+    },
+    {
+        RemoteMMARKeys.ID: "clara_pt_brain_mri_segmentation_t1c_1",
+        RemoteMMARKeys.NAME: "clara_pt_brain_mri_segmentation_t1c",
+        RemoteMMARKeys.FILE_TYPE: "zip",
+        RemoteMMARKeys.HASH_TYPE: "md5",
+        RemoteMMARKeys.HASH_VAL: None,
+        RemoteMMARKeys.MODEL_FILE: os.path.join("models", "model.pt"),
+        RemoteMMARKeys.VERSION: 1,
+    },
+    {
+        RemoteMMARKeys.ID: "clara_pt_liver_and_tumor_ct_segmentation_1",
+        RemoteMMARKeys.NAME: "clara_pt_liver_and_tumor_ct_segmentation",
+        RemoteMMARKeys.FILE_TYPE: "zip",
+        RemoteMMARKeys.HASH_TYPE: "md5",
+        RemoteMMARKeys.HASH_VAL: None,
+        RemoteMMARKeys.MODEL_FILE: os.path.join("models", "model.pt"),
+        RemoteMMARKeys.CONFIG_FILE: os.path.join("config", "config_train.json"),
+        RemoteMMARKeys.VERSION: 1,
+    },
+    {
+        RemoteMMARKeys.ID: "clara_pt_pancreas_and_tumor_ct_segmentation_1",
+        RemoteMMARKeys.NAME: "clara_pt_pancreas_and_tumor_ct_segmentation",
+        RemoteMMARKeys.FILE_TYPE: "zip",
+        RemoteMMARKeys.HASH_TYPE: "md5",
+        RemoteMMARKeys.HASH_VAL: None,
+        RemoteMMARKeys.MODEL_FILE: os.path.join("models", "model.pt"),
+        RemoteMMARKeys.CONFIG_FILE: os.path.join("config", "config_train.json"),
+        RemoteMMARKeys.VERSION: 1,
+    },
+    {
+        RemoteMMARKeys.ID: "clara_pt_brain_mri_annotation_t1c_1",
+        RemoteMMARKeys.NAME: "clara_pt_brain_mri_annotation_t1c",
+        RemoteMMARKeys.FILE_TYPE: "zip",
+        RemoteMMARKeys.HASH_TYPE: "md5",
+        RemoteMMARKeys.HASH_VAL: None,
+        RemoteMMARKeys.MODEL_FILE: os.path.join("models", "model.pt"),
+        RemoteMMARKeys.VERSION: 1,
+    },
+    {
+        RemoteMMARKeys.ID: "clara_pt_spleen_ct_annotation_1",
+        RemoteMMARKeys.NAME: "clara_pt_spleen_ct_annotation",
+        RemoteMMARKeys.FILE_TYPE: "zip",
+        RemoteMMARKeys.HASH_TYPE: "md5",
+        RemoteMMARKeys.HASH_VAL: None,
+        RemoteMMARKeys.MODEL_FILE: os.path.join("models", "model.pt"),
+        RemoteMMARKeys.CONFIG_FILE: os.path.join("config", "config_train.json"),
+        RemoteMMARKeys.VERSION: 1,
+    },
+    {
+        RemoteMMARKeys.ID: "clara_pt_deepgrow_3d_annotation_1",
+        RemoteMMARKeys.NAME: "clara_pt_deepgrow_3d_annotation",
+        RemoteMMARKeys.FILE_TYPE: "zip",
+        RemoteMMARKeys.HASH_TYPE: "md5",
+        RemoteMMARKeys.HASH_VAL: None,
+        RemoteMMARKeys.MODEL_FILE: os.path.join("models", "model.pt"),
+        RemoteMMARKeys.CONFIG_FILE: os.path.join("config", "config_train.json"),
+        RemoteMMARKeys.VERSION: 1,
+    },
+    {
+        RemoteMMARKeys.ID: "clara_pt_deepgrow_2d_annotation_1",
+        RemoteMMARKeys.NAME: "clara_pt_deepgrow_2d_annotation",
+        RemoteMMARKeys.FILE_TYPE: "zip",
+        RemoteMMARKeys.HASH_TYPE: "md5",
+        RemoteMMARKeys.HASH_VAL: None,
+        RemoteMMARKeys.MODEL_FILE: os.path.join("models", "model.pt"),
+        RemoteMMARKeys.CONFIG_FILE: os.path.join("config", "config_train.json"),
+        RemoteMMARKeys.VERSION: 1,
+    },
+    {
+        RemoteMMARKeys.ID: "clara_pt_covid19_ct_lung_segmentation_1",
+        RemoteMMARKeys.NAME: "clara_pt_covid19_ct_lung_segmentation",
+        RemoteMMARKeys.FILE_TYPE: "zip",
+        RemoteMMARKeys.HASH_TYPE: "md5",
+        RemoteMMARKeys.HASH_VAL: None,
+        RemoteMMARKeys.MODEL_FILE: os.path.join("models", "model.pt"),
+        RemoteMMARKeys.CONFIG_FILE: os.path.join("config", "config_train.json"),
+        RemoteMMARKeys.VERSION: 1,
+    },
+    {
+        RemoteMMARKeys.ID: "clara_pt_unetr_ct_btcv_segmentation",
+        RemoteMMARKeys.NAME: "clara_pt_unetr_ct_btcv_segmentation",
+        RemoteMMARKeys.FILE_TYPE: "zip",
+        RemoteMMARKeys.HASH_TYPE: "md5",
+        RemoteMMARKeys.HASH_VAL: None,
+        RemoteMMARKeys.MODEL_FILE: os.path.join("models", "model.pt"),
+        RemoteMMARKeys.CONFIG_FILE: os.path.join("config", "config_train.json"),
+        RemoteMMARKeys.VERSION: 4.1,
+    },
+    {
+        RemoteMMARKeys.ID: "clara_pt_chest_xray_classification",
+        RemoteMMARKeys.NAME: "clara_pt_chest_xray_classification",
+        RemoteMMARKeys.FILE_TYPE: "zip",
+        RemoteMMARKeys.HASH_TYPE: "md5",
+        RemoteMMARKeys.HASH_VAL: None,
+        RemoteMMARKeys.MODEL_FILE: os.path.join("models", "model.pt"),
+        RemoteMMARKeys.CONFIG_FILE: os.path.join("config", "config_train.json"),
+        RemoteMMARKeys.VERSION: 4.1,
+    },
+    {
+        RemoteMMARKeys.ID: "clara_pt_self_supervised_learning_segmentation",
+        RemoteMMARKeys.NAME: "clara_pt_self_supervised_learning_segmentation",
+        RemoteMMARKeys.FILE_TYPE: "zip",
+        RemoteMMARKeys.HASH_TYPE: "md5",
+        RemoteMMARKeys.HASH_VAL: None,
+        RemoteMMARKeys.MODEL_FILE: os.path.join("models_2gpu", "best_metric_model.pt"),
+        RemoteMMARKeys.CONFIG_FILE: os.path.join("config", "config_train.json"),
+        RemoteMMARKeys.VERSION: 4.1,
+    },
+)

source_code/SegMamba/monai/apps/pathology/inferers/__init__.py

@@ -0,0 +1,14 @@
+# Copyright (c) MONAI Consortium
+# 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.
+
+from __future__ import annotations
+
+from .inferer import SlidingWindowHoVerNetInferer

source_code/SegMamba/monai/apps/pathology/inferers/inferer.py

@@ -0,0 +1,210 @@
+# Copyright (c) MONAI Consortium
+# 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.
+
+from __future__ import annotations
+
+from typing import Any, Callable, Sequence
+
+import numpy as np
+import torch
+import torch.nn.functional as F
+
+from monai.inferers import SlidingWindowInferer
+from monai.inferers.utils import sliding_window_inference
+from monai.utils import BlendMode, PytorchPadMode, look_up_option
+
+__all__ = ["SlidingWindowHoVerNetInferer"]
+
+
+class SlidingWindowHoVerNetInferer(SlidingWindowInferer):
+    """
+    Sliding window method for HoVerNet model inference,
+    with `sw_batch_size` windows for every model.forward().
+    Usage example can be found in the :py:class:`monai.inferers.Inferer` base class.
+
+    Args:
+        roi_size: the window size to execute SlidingWindow evaluation.
+            If it has non-positive components, the corresponding `inputs` size will be used.
+            if the components of the `roi_size` are non-positive values, the transform will use the
+            corresponding components of img size. For example, `roi_size=(32, -1)` will be adapted
+            to `(32, 64)` if the second spatial dimension size of img is `64`.
+        sw_batch_size: the batch size to run window slices.
+        overlap: Amount of overlap between scans.
+        mode: {``"constant"``, ``"gaussian"``}
+            How to blend output of overlapping windows. Defaults to ``"constant"``.
+
+            - ``"constant``": gives equal weight to all predictions.
+            - ``"gaussian``": gives less weight to predictions on edges of windows.
+
+        sigma_scale: the standard deviation coefficient of the Gaussian window when `mode` is ``"gaussian"``.
+            Default: 0.125. Actual window sigma is ``sigma_scale`` * ``dim_size``.
+            When sigma_scale is a sequence of floats, the values denote sigma_scale at the corresponding
+            spatial dimensions.
+        padding_mode: {``"constant"``, ``"reflect"``, ``"replicate"``, ``"circular"``}
+            Padding mode when ``roi_size`` is larger than inputs. Defaults to ``"constant"``
+            See also: https://pytorch.org/docs/stable/generated/torch.nn.functional.pad.html
+        cval: fill value for 'constant' padding mode. Default: 0
+        sw_device: device for the window data.
+            By default the device (and accordingly the memory) of the `inputs` is used.
+            Normally `sw_device` should be consistent with the device where `predictor` is defined.
+        device: device for the stitched output prediction.
+            By default the device (and accordingly the memory) of the `inputs` is used. If for example
+            set to device=torch.device('cpu') the gpu memory consumption is less and independent of the
+            `inputs` and `roi_size`. Output is on the `device`.
+        progress: whether to print a tqdm progress bar.
+        cache_roi_weight_map: whether to pre-compute the ROI weight map.
+        cpu_thresh: when provided, dynamically switch to stitching on cpu (to save gpu memory)
+            when input image volume is larger than this threshold (in pixels/voxels).
+            Otherwise use ``"device"``. Thus, the output may end-up on either cpu or gpu.
+        extra_input_padding: the amount of padding for the input image, which is a tuple of even number of pads.
+            Refer to to the `pad` argument of `torch.nn.functional.pad` for more details.
+
+    Note:
+        ``sw_batch_size`` denotes the max number of windows per network inference iteration,
+        not the batch size of inputs.
+
+    """
+
+    def __init__(
+        self,
+        roi_size: Sequence[int] | int,
+        sw_batch_size: int = 1,
+        overlap: float = 0.25,
+        mode: BlendMode | str = BlendMode.CONSTANT,
+        sigma_scale: Sequence[float] | float = 0.125,
+        padding_mode: PytorchPadMode | str = PytorchPadMode.CONSTANT,
+        cval: float = 0.0,
+        sw_device: torch.device | str | None = None,
+        device: torch.device | str | None = None,
+        progress: bool = False,
+        cache_roi_weight_map: bool = False,
+        cpu_thresh: int | None = None,
+        extra_input_padding: tuple[int] | None = None,
+    ) -> None:
+        super().__init__(
+            roi_size=roi_size,
+            sw_batch_size=sw_batch_size,
+            overlap=overlap,
+            mode=mode,
+            sigma_scale=sigma_scale,
+            padding_mode=padding_mode,
+            cval=cval,
+            sw_device=sw_device,
+            device=device,
+            progress=progress,
+            cache_roi_weight_map=cache_roi_weight_map,
+            cpu_thresh=cpu_thresh,
+        )
+        self.extra_input_padding = extra_input_padding
+
+    def process_output(self, seg_prob_tuple, window_data, importance_map_):
+        window_shape = window_data.shape[2:]
+        seg_shape = seg_prob_tuple[0].shape[2:]
+
+        window_pad_size = []
+        window_pad_slices = []
+        for window_s, output_s in zip(window_shape, seg_shape):
+            pad_width = max(window_s - output_s, 0)
+            pad_half_1 = pad_width // 2
+            pad_half_2 = pad_width - pad_half_1
+            window_pad_size.extend([pad_half_1, pad_half_2])
+            window_pad_slices.append(slice(pad_half_1, window_s - pad_half_2))
+
+        # Make the padding area of the importance map zero
+        importance_map = torch.zeros(window_shape, dtype=importance_map_.dtype, device=importance_map_.device)
+        importance_map[window_pad_slices] = importance_map_[window_pad_slices]
+
+        seg_prob_tuple = tuple(
+            F.pad(seg_prob, pad=tuple(window_pad_size), mode=self.padding_mode, value=self.cval)
+            for seg_prob in seg_prob_tuple
+        )
+
+        return seg_prob_tuple, importance_map
+
+    def __call__(
+        self,
+        inputs: torch.Tensor,
+        network: Callable[..., torch.Tensor | Sequence[torch.Tensor] | dict[Any, torch.Tensor]],
+        *args: Any,
+        **kwargs: Any,
+    ) -> torch.Tensor | tuple[torch.Tensor, ...] | dict[Any, torch.Tensor]:
+        """
+
+        Args:
+            inputs: model input data for inference.
+            network: target model to execute inference.
+                supports callables such as ``lambda x: my_torch_model(x, additional_config)``
+            args: optional args to be passed to ``network``.
+            kwargs: optional keyword args to be passed to ``network``.
+
+        """
+
+        device = self.device
+        if device is None and self.cpu_thresh is not None and inputs.shape[2:].numel() > self.cpu_thresh:
+            device = "cpu"  # stitch in cpu memory if image is too large
+
+        if self.extra_input_padding:
+            image_size_original = inputs.shape[2:]
+            num_spatial_dims = len(image_size_original)
+            inputs = F.pad(
+                inputs,
+                pad=tuple(self.extra_input_padding),
+                mode=look_up_option(self.padding_mode, PytorchPadMode),
+                value=self.cval,
+            )
+
+        results = sliding_window_inference(
+            inputs,
+            self.roi_size,
+            self.sw_batch_size,
+            network,
+            self.overlap,
+            self.mode,
+            self.sigma_scale,
+            self.padding_mode,
+            self.cval,
+            self.sw_device,
+            device,
+            self.progress,
+            self.roi_weight_map,
+            self.process_output,
+            self.buffer_steps,
+            self.buffer_dim,
+            False,
+            *args,
+            **kwargs,
+        )
+
+        if self.extra_input_padding:
+            extra_slicing: list[slice] = []
+            num_padded_dims = len(self.extra_input_padding) // 2
+            for sp in range(num_padded_dims):
+                slice_dim = slice(
+                    self.extra_input_padding[sp * 2],
+                    image_size_original[num_spatial_dims - sp - 1] + self.extra_input_padding[sp * 2],
+                )
+                extra_slicing.insert(0, slice_dim)
+            for _ in range(len(inputs.shape) - num_padded_dims):
+                extra_slicing.insert(0, slice(None))
+
+            if isinstance(results, dict):
+                for k, v in results.items():
+                    results[k] = v[extra_slicing]
+            elif isinstance(results, (list, tuple)):
+                results = type(results)([res[extra_slicing] for res in results])
+            elif isinstance(results, (torch.Tensor, np.ndarray)):
+                results = results[extra_slicing]
+            else:
+                raise ValueError(
+                    f"The output [{type(results)}] should be either dict, list, tuple, torch.Tensor, or numpy array."
+                )
+
+        return results

source_code/SegMamba/monai/apps/pathology/transforms/post/array.py

@@ -0,0 +1,837 @@
+# Copyright (c) MONAI Consortium
+# 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.
+
+from __future__ import annotations
+
+import warnings
+from typing import Callable, Sequence
+
+import numpy as np
+import torch
+
+from monai.config.type_definitions import DtypeLike, NdarrayOrTensor
+from monai.transforms import (
+    Activations,
+    AsDiscrete,
+    BoundingRect,
+    FillHoles,
+    GaussianSmooth,
+    RemoveSmallObjects,
+    SobelGradients,
+)
+from monai.transforms.transform import Transform
+from monai.transforms.utils_pytorch_numpy_unification import max, maximum, min, sum, unique
+from monai.utils import TransformBackends, convert_to_numpy, optional_import
+from monai.utils.misc import ensure_tuple_rep
+from monai.utils.type_conversion import convert_to_dst_type, convert_to_tensor
+
+label, _ = optional_import("scipy.ndimage.measurements", name="label")
+disk, _ = optional_import("skimage.morphology", name="disk")
+opening, _ = optional_import("skimage.morphology", name="opening")
+watershed, _ = optional_import("skimage.segmentation", name="watershed")
+find_contours, _ = optional_import("skimage.measure", name="find_contours")
+centroid, _ = optional_import("skimage.measure", name="centroid")
+
+__all__ = [
+    "Watershed",
+    "GenerateWatershedMask",
+    "GenerateInstanceBorder",
+    "GenerateDistanceMap",
+    "GenerateWatershedMarkers",
+    "GenerateSuccinctContour",
+    "GenerateInstanceContour",
+    "GenerateInstanceCentroid",
+    "GenerateInstanceType",
+    "HoVerNetInstanceMapPostProcessing",
+    "HoVerNetNuclearTypePostProcessing",
+]
+
+
+class Watershed(Transform):
+    """
+    Use `skimage.segmentation.watershed` to get instance segmentation results from images.
+    See: https://scikit-image.org/docs/stable/api/skimage.segmentation.html#skimage.segmentation.watershed.
+
+    Args:
+        connectivity: an array with the same number of dimensions as image whose non-zero elements indicate
+            neighbors for connection. Following the scipy convention, default is a one-connected array of
+            the dimension of the image.
+        dtype: target data content type to convert, default is np.int64.
+
+    """
+
+    backend = [TransformBackends.NUMPY]
+
+    def __init__(self, connectivity: int | None = 1, dtype: DtypeLike = np.int64) -> None:
+        self.connectivity = connectivity
+        self.dtype = dtype
+
+    def __call__(
+        self, image: NdarrayOrTensor, mask: NdarrayOrTensor | None = None, markers: NdarrayOrTensor | None = None
+    ) -> NdarrayOrTensor:
+        """
+        Args:
+            image: image where the lowest value points are labeled first. Shape must be [1, H, W, [D]].
+            mask: optional, the same shape as image. Only points at which mask == True will be labeled.
+                If None (no mask given), it is a volume of all 1s.
+            markers: optional, the same shape as image. The desired number of markers, or an array marking
+                the basins with the values to be assigned in the label matrix. Zero means not a marker.
+                If None (no markers given), the local minima of the image are used as markers.
+        """
+
+        image = convert_to_numpy(image)
+        markers = convert_to_numpy(markers)
+        mask = convert_to_numpy(mask)
+
+        instance_seg = watershed(image, markers=markers, mask=mask, connectivity=self.connectivity)
+
+        return convert_to_dst_type(instance_seg, image, dtype=self.dtype)[0]
+
+
+class GenerateWatershedMask(Transform):
+    """
+    generate mask used in `watershed`. Only points at which mask == True will be labeled.
+
+    Args:
+        activation: the activation layer to be applied on the input probability map.
+            It can be "softmax" or "sigmoid" string, or any callable. Defaults to "softmax".
+        threshold: an optional float value to threshold to binarize probability map.
+            If not provided, defaults to 0.5 when activation is not "softmax", otherwise None.
+        min_object_size: objects smaller than this size (in pixel) are removed. Defaults to 10.
+        dtype: target data content type to convert, default is np.uint8.
+
+    """
+
+    backend = [TransformBackends.NUMPY]
+
+    def __init__(
+        self,
+        activation: str | Callable = "softmax",
+        threshold: float | None = None,
+        min_object_size: int = 10,
+        dtype: DtypeLike = np.uint8,
+    ) -> None:
+        self.dtype = dtype
+
+        # set activation layer
+        use_softmax = False
+        use_sigmoid = False
+        activation_fn = None
+        if isinstance(activation, str):
+            if activation.lower() == "softmax":
+                use_softmax = True
+            elif activation.lower() == "sigmoid":
+                use_sigmoid = True
+            else:
+                raise ValueError(
+                    f"The activation should be 'softmax' or 'sigmoid' string, or any callable. '{activation}' was given."
+                )
+        elif callable(activation):
+            activation_fn = activation
+        else:
+            raise ValueError(f"The activation type should be either str or callable. '{type(activation)}' was given.")
+        self.activation = Activations(softmax=use_softmax, sigmoid=use_sigmoid, other=activation_fn)
+
+        # set discretization transform
+        if not use_softmax and threshold is None:
+            threshold = 0.5
+        self.as_discrete = AsDiscrete(threshold=threshold, argmax=use_softmax)
+
+        # set small object removal transform
+        self.remove_small_objects = RemoveSmallObjects(min_size=min_object_size) if min_object_size > 0 else None
+
+    def __call__(self, prob_map: NdarrayOrTensor) -> NdarrayOrTensor:
+        """
+        Args:
+            prob_map: probability map of segmentation, shape must be [C, H, W, [D]]
+        """
+
+        pred = self.activation(prob_map)
+        pred = self.as_discrete(pred)
+
+        pred = convert_to_numpy(pred)
+
+        pred = label(pred)[0]
+        if self.remove_small_objects is not None:
+            pred = self.remove_small_objects(pred)
+        pred[pred > 0] = 1
+
+        return convert_to_dst_type(pred, prob_map, dtype=self.dtype)[0]
+
+
+class GenerateInstanceBorder(Transform):
+    """
+    Generate instance border by hover map. The more parts of the image that cannot be identified as foreground areas,
+    the larger the grey scale value. The grey value of the instance's border will be larger.
+
+    Args:
+        kernel_size: the size of the Sobel kernel. Defaults to 5.
+        dtype: target data type to convert to. Defaults to np.float32.
+
+
+    Raises:
+        ValueError: when the `mask` shape is not [1, H, W].
+        ValueError: when the `hover_map` shape is not [2, H, W].
+
+    """
+
+    backend = [TransformBackends.NUMPY]
+
+    def __init__(self, kernel_size: int = 5, dtype: DtypeLike = np.float32) -> None:
+        self.dtype = dtype
+        self.sobel_gradient = SobelGradients(kernel_size=kernel_size)
+
+    def __call__(self, mask: NdarrayOrTensor, hover_map: NdarrayOrTensor) -> NdarrayOrTensor:  # type: ignore
+        """
+        Args:
+            mask: binary segmentation map, the output of :py:class:`GenerateWatershedMask`.
+                Shape must be [1, H, W] or [H, W].
+            hover_map:  horizontal and vertical distances of nuclear pixels to their centres of mass. Shape must be [2, H, W].
+                The first and second channel represent the horizontal and vertical maps respectively. For more details refer
+                to papers: https://arxiv.org/abs/1812.06499.
+        """
+        if len(hover_map.shape) != 3:
+            raise ValueError(f"The hover map should have the shape of [C, H, W], but got {hover_map.shape}.")
+        if len(mask.shape) == 3:
+            if mask.shape[0] != 1:
+                raise ValueError(f"The mask should have only one channel, but got {mask.shape[0]}.")
+        elif len(mask.shape) == 2:
+            mask = mask[None]
+        else:
+            raise ValueError(f"The mask should have the shape of [1, H, W] or [H, W], but got {mask.shape}.")
+        if hover_map.shape[0] != 2:
+            raise ValueError(f"Suppose the hover map only has two channels, but got {hover_map.shape[0]}")
+
+        hover_h = hover_map[0:1, ...]
+        hover_v = hover_map[1:2, ...]
+
+        hover_h_min, hover_h_max = min(hover_h), max(hover_h)
+        hover_v_min, hover_v_max = min(hover_v), max(hover_v)
+        if (hover_h_max - hover_h_min) == 0 or (hover_v_max - hover_v_min) == 0:
+            raise ValueError("Not a valid hover map, please check your input")
+        hover_h = (hover_h - hover_h_min) / (hover_h_max - hover_h_min)
+        hover_v = (hover_v - hover_v_min) / (hover_v_max - hover_v_min)
+        sobelh = self.sobel_gradient(hover_h)[1, ...]
+        sobelv = self.sobel_gradient(hover_v)[0, ...]
+        sobelh_min, sobelh_max = min(sobelh), max(sobelh)
+        sobelv_min, sobelv_max = min(sobelv), max(sobelv)
+        if (sobelh_max - sobelh_min) == 0 or (sobelv_max - sobelv_min) == 0:
+            raise ValueError("Not a valid sobel gradient map")
+        sobelh = 1 - (sobelh - sobelh_min) / (sobelh_max - sobelh_min)
+        sobelv = 1 - (sobelv - sobelv_min) / (sobelv_max - sobelv_min)
+
+        # combine the h & v values using max
+        overall = maximum(sobelh, sobelv)
+        overall = overall - (1 - mask)
+        overall[overall < 0] = 0
+
+        return convert_to_dst_type(overall, mask, dtype=self.dtype)[0]
+
+
+class GenerateDistanceMap(Transform):
+    """
+    Generate distance map.
+    In general, the instance map is calculated from the distance to the background.
+    Here, we use 1 - "instance border map" to generate the distance map.
+    Nuclei values form mountains so invert them to get basins.
+
+    Args:
+        smooth_fn: smoothing function for distance map, which can be any callable object.
+            If not provided :py:class:`monai.transforms.GaussianSmooth()` is used.
+        dtype: target data type to convert to. Defaults to np.float32.
+    """
+
+    backend = [TransformBackends.NUMPY]
+
+    def __init__(self, smooth_fn: Callable | None = None, dtype: DtypeLike = np.float32) -> None:
+        self.smooth_fn = smooth_fn if smooth_fn is not None else GaussianSmooth()
+        self.dtype = dtype
+
+    def __call__(self, mask: NdarrayOrTensor, instance_border: NdarrayOrTensor) -> NdarrayOrTensor:  # type: ignore
+        """
+        Args:
+            mask: binary segmentation map, the output of :py:class:`GenerateWatershedMask`.
+                Shape must be [1, H, W] or [H, W].
+            instance_border: instance border map, the output of :py:class:`GenerateInstanceBorder`.
+                Shape must be [1, H, W].
+        """
+        if len(mask.shape) == 3:
+            if mask.shape[0] != 1:
+                raise ValueError(f"The mask should have only one channel, but got {mask.shape[0]}.")
+        elif len(mask.shape) == 2:
+            mask = mask[None]
+        else:
+            raise ValueError(f"The mask should have the shape of [1, H, W] or [H, W], but got {mask.shape}.")
+        if instance_border.shape[0] != 1 or instance_border.ndim != 3:
+            raise ValueError(f"Input instance_border should be with size of [1, H, W], but got {instance_border.shape}")
+
+        distance_map = (1.0 - instance_border) * mask
+        distance_map = self.smooth_fn(distance_map)  # type: ignore
+
+        return convert_to_dst_type(-distance_map, mask, dtype=self.dtype)[0]
+
+
+class GenerateWatershedMarkers(Transform):
+    """
+    Generate markers to be used in `watershed`. The watershed algorithm treats pixels values as a local topography
+    (elevation). The algorithm floods basins from the markers until basins attributed to different markers meet on
+    watershed lines. Generally, markers are chosen as local minima of the image, from which basins are flooded.
+    Here is the implementation from HoVerNet paper.
+    For more details refer to papers: https://arxiv.org/abs/1812.06499.
+
+    Args:
+        threshold: a float value to threshold to binarize instance border map.
+            It turns uncertain area to 1 and other area to 0. Defaults to 0.4.
+        radius: the radius of the disk-shaped footprint used in `opening`. Defaults to 2.
+        min_object_size: objects smaller than this size (in pixel) are removed. Defaults to 10.
+        postprocess_fn: additional post-process function on the markers.
+            If not provided, :py:class:`monai.transforms.post.FillHoles()` will be used.
+        dtype: target data type to convert to. Defaults to np.int64.
+
+    """
+
+    backend = [TransformBackends.NUMPY]
+
+    def __init__(
+        self,
+        threshold: float = 0.4,
+        radius: int = 2,
+        min_object_size: int = 10,
+        postprocess_fn: Callable | None = None,
+        dtype: DtypeLike = np.int64,
+    ) -> None:
+        self.threshold = threshold
+        self.radius = radius
+        self.dtype = dtype
+        if postprocess_fn is None:
+            postprocess_fn = FillHoles()
+
+        self.postprocess_fn = postprocess_fn
+        self.remove_small_objects = RemoveSmallObjects(min_size=min_object_size) if min_object_size > 0 else None
+
+    def __call__(self, mask: NdarrayOrTensor, instance_border: NdarrayOrTensor) -> NdarrayOrTensor:  # type: ignore
+        """
+        Args:
+            mask: binary segmentation map, the output of :py:class:`GenerateWatershedMask`.
+                Shape must be [1, H, W] or [H, W].
+            instance_border: instance border map, the output of :py:class:`GenerateInstanceBorder`.
+                Shape must be [1, H, W].
+        """
+        if len(mask.shape) == 3:
+            if mask.shape[0] != 1:
+                raise ValueError(f"The mask should have only one channel, but got {mask.shape[0]}.")
+        elif len(mask.shape) == 2:
+            mask = mask[None]
+        else:
+            raise ValueError(f"The mask should have the shape of [1, H, W] or [H, W], but got {mask.shape}.")
+        if instance_border.shape[0] != 1 or instance_border.ndim != 3:
+            raise ValueError(f"Input instance_border should be with size of [1, H, W], but got {instance_border.shape}")
+
+        instance_border = instance_border >= self.threshold  # uncertain area
+
+        marker = mask - convert_to_dst_type(instance_border, mask)[0]  # certain foreground
+        marker[marker < 0] = 0
+        marker = self.postprocess_fn(marker)
+        marker = convert_to_numpy(marker)
+
+        marker = opening(marker.squeeze(), disk(self.radius))
+        marker = label(marker)[0][None]
+        if self.remove_small_objects is not None:
+            marker = self.remove_small_objects(marker)
+
+        return convert_to_dst_type(marker, mask, dtype=self.dtype)[0]
+
+
+class GenerateSuccinctContour(Transform):
+    """
+    Converts SciPy-style contours (generated by skimage.measure.find_contours) to a more succinct version which only includes
+    the pixels to which lines need to be drawn (i.e. not the intervening pixels along each line).
+
+    Args:
+        height: height of bounding box, used to detect direction of line segment.
+        width: width of bounding box, used to detect direction of line segment.
+
+    Returns:
+        the pixels that need to be joined by straight lines to describe the outmost pixels of the foreground similar to
+            OpenCV's cv.CHAIN_APPROX_SIMPLE (counterclockwise)
+    """
+
+    def __init__(self, height: int, width: int) -> None:
+        self.height = height
+        self.width = width
+
+    def _generate_contour_coord(self, current: np.ndarray, previous: np.ndarray) -> tuple[int, int]:
+        """
+        Generate contour coordinates. Given the previous and current coordinates of border positions,
+        returns the int pixel that marks the extremity of the segmented pixels.
+
+        Args:
+            current: coordinates of the current border position.
+            previous: coordinates of the previous border position.
+        """
+
+        p_delta = (current[0] - previous[0], current[1] - previous[1])
+
+        if p_delta in ((0.0, 1.0), (0.5, 0.5), (1.0, 0.0)):
+            row = int(current[0] + 0.5)
+            col = int(current[1])
+        elif p_delta in ((0.0, -1.0), (0.5, -0.5)):
+            row = int(current[0])
+            col = int(current[1])
+        elif p_delta in ((-1, 0.0), (-0.5, -0.5)):
+            row = int(current[0])
+            col = int(current[1] + 0.5)
+        elif p_delta == (-0.5, 0.5):
+            row = int(current[0] + 0.5)
+            col = int(current[1] + 0.5)
+
+        return row, col
+
+    def _calculate_distance_from_top_left(self, sequence: Sequence[tuple[int, int]]) -> int:
+        """
+        Each sequence of coordinates describes a boundary between foreground and background starting and ending at two sides
+        of the bounding box. To order the sequences correctly, we compute the distance from the top-left of the bounding box
+        around the perimeter in a clockwise direction.
+
+        Args:
+            sequence: list of border points coordinates.
+
+        Returns:
+            the distance round the perimeter of the bounding box from the top-left origin
+        """
+        distance: int
+        first_coord = sequence[0]
+        if first_coord[0] == 0:
+            distance = first_coord[1]
+        elif first_coord[1] == self.width - 1:
+            distance = self.width + first_coord[0]
+        elif first_coord[0] == self.height - 1:
+            distance = 2 * self.width + self.height - first_coord[1]
+        else:
+            distance = 2 * (self.width + self.height) - first_coord[0]
+
+        return distance
+
+    def __call__(self, contours: list[np.ndarray]) -> np.ndarray:
+        """
+        Args:
+            contours: list of (n, 2)-ndarrays, scipy-style clockwise line segments, with lines separating foreground/background.
+                Each contour is an ndarray of shape (n, 2), consisting of n (row, column) coordinates along the contour.
+        """
+        pixels: list[tuple[int, int]] = []
+        sequences = []
+        corners = [False, False, False, False]
+
+        for group in contours:
+            sequence: list[tuple[int, int]] = []
+            last_added = None
+            prev = None
+            corner = -1
+
+            for i, coord in enumerate(group):
+                if i == 0:
+                    # originating from the top, so must be heading south east
+                    if coord[0] == 0.0:
+                        corner = 1
+                        pixel = (0, int(coord[1] - 0.5))
+                        if pixel[1] == self.width - 1:
+                            corners[1] = True
+                        elif pixel[1] == 0.0:
+                            corners[0] = True
+                    # originating from the left, so must be heading north east
+                    elif coord[1] == 0.0:
+                        corner = 0
+                        pixel = (int(coord[0] + 0.5), 0)
+                    # originating from the bottom, so must be heading north west
+                    elif coord[0] == self.height - 1:
+                        corner = 3
+                        pixel = (int(coord[0]), int(coord[1] + 0.5))
+                        if pixel[1] == self.width - 1:
+                            corners[2] = True
+                    # originating from the right, so must be heading south west
+                    elif coord[1] == self.width - 1:
+                        corner = 2
+                        pixel = (int(coord[0] - 0.5), int(coord[1]))
+                    else:
+                        warnings.warn(f"Invalid contour coord {coord} is generated, skip this instance.")
+                        return None  # type: ignore
+                    sequence.append(pixel)
+                    last_added = pixel
+                elif i == len(group) - 1:
+                    # add this point
+                    pixel = self._generate_contour_coord(coord, prev)  # type: ignore
+                    if pixel != last_added:
+                        sequence.append(pixel)
+                        last_added = pixel
+                elif np.any(coord - prev != group[i + 1] - coord):
+                    pixel = self._generate_contour_coord(coord, prev)  # type: ignore
+                    if pixel != last_added:
+                        sequence.append(pixel)
+                        last_added = pixel
+
+                # flag whether each corner has been crossed
+                if i == len(group) - 1:
+                    if corner == 0:
+                        if coord[0] == 0:
+                            corners[corner] = True
+                    elif corner == 1:
+                        if coord[1] == self.width - 1:
+                            corners[corner] = True
+                    elif corner == 2:
+                        if coord[0] == self.height - 1:
+                            corners[corner] = True
+                    elif corner == 3:
+                        if coord[1] == 0.0:
+                            corners[corner] = True
+
+                prev = coord
+            dist = self._calculate_distance_from_top_left(sequence)
+
+            sequences.append({"distance": dist, "sequence": sequence})
+
+        # check whether we need to insert any missing corners
+        if corners[0] is False:
+            sequences.append({"distance": 0, "sequence": [(0, 0)]})
+        if corners[1] is False:
+            sequences.append({"distance": self.width, "sequence": [(0, self.width - 1)]})
+        if corners[2] is False:
+            sequences.append({"distance": self.width + self.height, "sequence": [(self.height - 1, self.width - 1)]})
+        if corners[3] is False:
+            sequences.append({"distance": 2 * self.width + self.height, "sequence": [(self.height - 1, 0)]})
+
+        # join the sequences into a single contour
+        # starting at top left and rotating clockwise
+        sequences.sort(key=lambda x: x.get("distance"))  # type: ignore
+
+        last = (-1, -1)
+        for _sequence in sequences:
+            if _sequence["sequence"][0] == last:  # type: ignore
+                pixels.pop()
+            if pixels:
+                pixels = [*pixels, *_sequence["sequence"]]  # type: ignore
+            else:
+                pixels = _sequence["sequence"]  # type: ignore
+            last = pixels[-1]
+
+        if pixels[0] == last:
+            pixels.pop(0)
+
+        if pixels[0] == (0, 0):
+            pixels.append(pixels.pop(0))
+
+        return np.flip(convert_to_numpy(pixels, dtype=np.int32))  # type: ignore
+
+
+class GenerateInstanceContour(Transform):
+    """
+    Generate contour for each instance in a 2D array. Use `GenerateSuccinctContour` to only include
+    the pixels to which lines need to be drawn
+
+    Args:
+        min_num_points: assumed that the created contour does not form a contour if it does not contain more points
+            than the specified value. Defaults to 3.
+        contour_level: an optional value for `skimage.measure.find_contours` to find contours in the array.
+            If not provided, the level is set to `(max(image) + min(image)) / 2`.
+
+    """
+
+    backend = [TransformBackends.NUMPY]
+
+    def __init__(self, min_num_points: int = 3, contour_level: float | None = None) -> None:
+        self.contour_level = contour_level
+        self.min_num_points = min_num_points
+
+    def __call__(self, inst_mask: NdarrayOrTensor, offset: Sequence[int] | None = (0, 0)) -> np.ndarray | None:
+        """
+        Args:
+            inst_mask: segmentation mask for a single instance. Shape should be [1, H, W, [D]]
+            offset: optional offset of starting position of the instance mask in the original array. Default to 0 for each dim.
+        """
+        inst_mask = inst_mask.squeeze()  # squeeze channel dim
+        inst_mask = convert_to_numpy(inst_mask)
+        inst_contour_cv = find_contours(inst_mask, level=self.contour_level)
+        generate_contour = GenerateSuccinctContour(inst_mask.shape[0], inst_mask.shape[1])
+        inst_contour = generate_contour(inst_contour_cv)
+        if inst_contour is None:
+            return None
+        # less than `self.min_num_points` points don't make a contour, so skip.
+        # They are likely to be artifacts as the contours obtained via approximation.
+        if inst_contour.shape[0] < self.min_num_points:
+            print(f"< {self.min_num_points} points don't make a contour, so skipped!")
+            return None
+        # check for tricky shape
+        elif len(inst_contour.shape) != 2:
+            print(f"{len(inst_contour.shape)} != 2, check for tricky shapes!")
+            return None
+        else:
+            inst_contour[:, 0] += offset[0]  # type: ignore
+            inst_contour[:, 1] += offset[1]  # type: ignore
+            return inst_contour
+
+
+class GenerateInstanceCentroid(Transform):
+    """
+    Generate instance centroid using `skimage.measure.centroid`.
+
+    Args:
+        dtype: the data type of output centroid.
+
+    """
+
+    backend = [TransformBackends.NUMPY]
+
+    def __init__(self, dtype: DtypeLike | None = int) -> None:
+        self.dtype = dtype
+
+    def __call__(self, inst_mask: NdarrayOrTensor, offset: Sequence[int] | int = 0) -> NdarrayOrTensor:
+        """
+        Args:
+            inst_mask: segmentation mask for a single instance. Shape should be [1, H, W, [D]]
+            offset: optional offset of starting position of the instance mask in the original array. Default to 0 for each dim.
+
+        """
+        inst_mask = convert_to_numpy(inst_mask)
+        inst_mask = inst_mask.squeeze(0)  # squeeze channel dim
+        ndim = len(inst_mask.shape)
+        offset = ensure_tuple_rep(offset, ndim)
+
+        inst_centroid = centroid(inst_mask)
+        for i in range(ndim):
+            inst_centroid[i] += offset[i]
+
+        return convert_to_dst_type(inst_centroid, inst_mask, dtype=self.dtype)[0]
+
+
+class GenerateInstanceType(Transform):
+    """
+    Generate instance type and probability for each instance.
+    """
+
+    backend = [TransformBackends.NUMPY]
+
+    def __call__(  # type: ignore
+        self, type_pred: NdarrayOrTensor, seg_pred: NdarrayOrTensor, bbox: np.ndarray, instance_id: int
+    ) -> tuple[int, float]:
+        """
+        Args:
+            type_pred: pixel-level type prediction map after activation function.
+            seg_pred: pixel-level segmentation prediction map after activation function.
+            bbox: bounding box coordinates of the instance, shape is [channel, 2 * spatial dims].
+            instance_id: get instance type from specified instance id.
+        """
+
+        rmin, rmax, cmin, cmax = bbox.flatten()
+        seg_map_crop = seg_pred[0, rmin:rmax, cmin:cmax]
+        type_map_crop = type_pred[0, rmin:rmax, cmin:cmax]
+
+        seg_map_crop = convert_to_dst_type(seg_map_crop == instance_id, type_map_crop, dtype=bool)[0]
+
+        inst_type = type_map_crop[seg_map_crop]
+        type_list, type_pixels = unique(inst_type, return_counts=True)
+        type_list = list(zip(type_list, type_pixels))
+        type_list = sorted(type_list, key=lambda x: x[1], reverse=True)
+        inst_type = type_list[0][0]
+        if inst_type == 0:  # ! pick the 2nd most dominant if exist
+            if len(type_list) > 1:
+                inst_type = type_list[1][0]
+        type_dict = {v[0]: v[1] for v in type_list}
+        type_prob = type_dict[inst_type] / (sum(seg_map_crop) + 1.0e-6)
+
+        return (int(inst_type), float(type_prob))
+
+
+class HoVerNetInstanceMapPostProcessing(Transform):
+    """
+    The post-processing transform for HoVerNet model to generate instance segmentation map.
+    It generates an instance segmentation map as well as a dictionary containing centroids, bounding boxes, and contours
+    for each instance.
+
+    Args:
+        activation: the activation layer to be applied on the input probability map.
+            It can be "softmax" or "sigmoid" string, or any callable. Defaults to "softmax".
+        mask_threshold: a float value to threshold to binarize probability map to generate mask.
+        min_object_size: objects smaller than this size (in pixel) are removed. Defaults to 10.
+        sobel_kernel_size: the size of the Sobel kernel used in :py:class:`GenerateInstanceBorder`. Defaults to 5.
+        distance_smooth_fn: smoothing function for distance map.
+            If not provided, :py:class:`monai.transforms.intensity.GaussianSmooth()` will be used.
+        marker_threshold: a float value to threshold to binarize instance border map for markers.
+            It turns uncertain area to 1 and other area to 0. Defaults to 0.4.
+        marker_radius: the radius of the disk-shaped footprint used in `opening` of markers. Defaults to 2.
+        marker_postprocess_fn: post-process function for watershed markers.
+            If not provided, :py:class:`monai.transforms.post.FillHoles()` will be used.
+        watershed_connectivity: `connectivity` argument of `skimage.segmentation.watershed`.
+        min_num_points: minimum number of points to be considered as a contour. Defaults to 3.
+        contour_level: an optional value for `skimage.measure.find_contours` to find contours in the array.
+            If not provided, the level is set to `(max(image) + min(image)) / 2`.
+        device: target device to put the output Tensor data.
+    """
+
+    def __init__(
+        self,
+        activation: str | Callable = "softmax",
+        mask_threshold: float | None = None,
+        min_object_size: int = 10,
+        sobel_kernel_size: int = 5,
+        distance_smooth_fn: Callable | None = None,
+        marker_threshold: float = 0.4,
+        marker_radius: int = 2,
+        marker_postprocess_fn: Callable | None = None,
+        watershed_connectivity: int | None = 1,
+        min_num_points: int = 3,
+        contour_level: float | None = None,
+        device: str | torch.device | None = None,
+    ) -> None:
+        super().__init__()
+        self.device = device
+        self.generate_watershed_mask = GenerateWatershedMask(
+            activation=activation, threshold=mask_threshold, min_object_size=min_object_size
+        )
+        self.generate_instance_border = GenerateInstanceBorder(kernel_size=sobel_kernel_size)
+        self.generate_distance_map = GenerateDistanceMap(smooth_fn=distance_smooth_fn)
+        self.generate_watershed_markers = GenerateWatershedMarkers(
+            threshold=marker_threshold,
+            radius=marker_radius,
+            postprocess_fn=marker_postprocess_fn,
+            min_object_size=min_object_size,
+        )
+        self.watershed = Watershed(connectivity=watershed_connectivity)
+        self.generate_instance_contour = GenerateInstanceContour(
+            min_num_points=min_num_points, contour_level=contour_level
+        )
+        self.generate_instance_centroid = GenerateInstanceCentroid()
+
+    def __call__(  # type: ignore
+        self, nuclear_prediction: NdarrayOrTensor, hover_map: NdarrayOrTensor
+    ) -> tuple[dict, NdarrayOrTensor]:
+        """post-process instance segmentation branches (NP and HV) to generate instance segmentation map.
+
+        Args:
+            nuclear_prediction: the output of NP (nuclear prediction) branch of HoVerNet model
+            hover_map: the output of HV (hover map) branch of HoVerNet model
+        """
+
+        # Process NP and HV branch using watershed algorithm
+        watershed_mask = self.generate_watershed_mask(nuclear_prediction)
+        instance_borders = self.generate_instance_border(watershed_mask, hover_map)
+        distance_map = self.generate_distance_map(watershed_mask, instance_borders)
+        watershed_markers = self.generate_watershed_markers(watershed_mask, instance_borders)
+        instance_map = self.watershed(distance_map, watershed_mask, watershed_markers)
+
+        # Create bounding boxes, contours and centroids
+        instance_ids = set(np.unique(instance_map)) - {0}  # exclude background
+        instance_info = {}
+        for inst_id in instance_ids:
+            instance_mask = instance_map == inst_id
+            instance_bbox = BoundingRect()(instance_mask)
+
+            instance_mask = instance_mask[
+                :, instance_bbox[0][0] : instance_bbox[0][1], instance_bbox[0][2] : instance_bbox[0][3]
+            ]
+            offset = [instance_bbox[0][2], instance_bbox[0][0]]
+            instance_contour = self.generate_instance_contour(FillHoles()(instance_mask), offset)
+            if instance_contour is not None:
+                instance_centroid = self.generate_instance_centroid(instance_mask, offset)
+                instance_info[inst_id] = {
+                    "bounding_box": instance_bbox,
+                    "centroid": instance_centroid,
+                    "contour": instance_contour,
+                }
+        instance_map = convert_to_tensor(instance_map, device=self.device)
+        return instance_info, instance_map
+
+
+class HoVerNetNuclearTypePostProcessing(Transform):
+    """
+    The post-processing transform for HoVerNet model to generate nuclear type information.
+    It updates the input instance info dictionary with information about types of the nuclei (value and probability).
+    Also if requested (`return_type_map=True`), it generates a pixel-level type map.
+
+    Args:
+        activation: the activation layer to be applied on nuclear type branch. It can be "softmax" or "sigmoid" string,
+            or any callable. Defaults to "softmax".
+        threshold: an optional float value to threshold to binarize probability map.
+            If not provided, defaults to 0.5 when activation is not "softmax", otherwise None.
+        return_type_map: whether to calculate and return pixel-level type map.
+        device: target device to put the output Tensor data.
+
+    """
+
+    def __init__(
+        self,
+        activation: str | Callable = "softmax",
+        threshold: float | None = None,
+        return_type_map: bool = True,
+        device: str | torch.device | None = None,
+    ) -> None:
+        super().__init__()
+        self.device = device
+        self.return_type_map = return_type_map
+        self.generate_instance_type = GenerateInstanceType()
+
+        # set activation layer
+        use_softmax = False
+        use_sigmoid = False
+        activation_fn = None
+        if isinstance(activation, str):
+            if activation.lower() == "softmax":
+                use_softmax = True
+            elif activation.lower() == "sigmoid":
+                use_sigmoid = True
+            else:
+                raise ValueError(
+                    f"The activation should be 'softmax' or 'sigmoid' string, or any callable. '{activation}' was given."
+                )
+        elif callable(activation):
+            activation_fn = activation
+        else:
+            raise ValueError(f"The activation type should be either str or callable. '{type(activation)}' was given.")
+        self.activation = Activations(softmax=use_softmax, sigmoid=use_sigmoid, other=activation_fn)
+
+        # set discretization transform
+        if not use_softmax and threshold is None:
+            threshold = 0.5
+        self.as_discrete = AsDiscrete(threshold=threshold, argmax=use_softmax)
+
+    def __call__(  # type: ignore
+        self, type_prediction: NdarrayOrTensor, instance_info: dict[int, dict], instance_map: NdarrayOrTensor
+    ) -> tuple[dict, NdarrayOrTensor | None]:
+        """Process NC (type prediction) branch and combine it with instance segmentation
+        It updates the instance_info with instance type and associated probability, and generate instance type map.
+
+        Args:
+            instance_info: instance information dictionary, the output of :py:class:`HoVerNetInstanceMapPostProcessing`
+            instance_map: instance segmentation map, the output of :py:class:`HoVerNetInstanceMapPostProcessing`
+            type_prediction: the output of NC (type prediction) branch of HoVerNet model
+        """
+        type_prediction = self.activation(type_prediction)
+        type_prediction = self.as_discrete(type_prediction)
+
+        type_map = None
+        if self.return_type_map:
+            type_map = convert_to_dst_type(torch.zeros(instance_map.shape), instance_map)[0]
+
+        for inst_id in instance_info:
+            instance_type, instance_type_prob = self.generate_instance_type(
+                type_pred=type_prediction,
+                seg_pred=instance_map,
+                bbox=instance_info[inst_id]["bounding_box"],
+                instance_id=inst_id,
+            )
+            # update instance info dict with type data
+            instance_info[inst_id]["type_prob"] = instance_type_prob
+            instance_info[inst_id]["type"] = instance_type
+
+            # update instance type map
+            if type_map is not None:
+                type_map[instance_map == inst_id] = instance_type
+                type_map = convert_to_tensor(type_map, device=self.device)
+
+        return instance_info, type_map

source_code/SegMamba/monai/apps/reconstruction/__init__.py

@@ -0,0 +1,10 @@
+# Copyright (c) MONAI Consortium
+# 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.

source_code/SegMamba/monai/apps/reconstruction/networks/blocks/varnetblock.py

@@ -0,0 +1,81 @@
+# Copyright (c) MONAI Consortium
+# 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.
+
+from __future__ import annotations
+
+import torch
+import torch.nn as nn
+from torch import Tensor
+
+from monai.apps.reconstruction.networks.nets.utils import sensitivity_map_expand, sensitivity_map_reduce
+
+
+class VarNetBlock(nn.Module):
+    """
+    A variational block based on Sriram et. al., "End-to-end variational networks for accelerated MRI reconstruction".
+    It applies data consistency and refinement to the intermediate kspace and combines those results.
+
+    Modified and adopted from: https://github.com/facebookresearch/fastMRI
+
+    Args:
+        refinement_model: the model used for refinement (typically a U-Net but can be any deep learning model
+            that performs well when the input and output are in image domain (e.g., a convolutional network).
+        spatial_dims: is 2 for 2D data and is 3 for 3D data
+    """
+
+    def __init__(self, refinement_model: nn.Module, spatial_dims: int = 2):
+        super().__init__()
+        self.model = refinement_model
+        self.spatial_dims = spatial_dims
+        self.dc_weight = nn.Parameter(torch.ones(1))  # learned scalar as the multiplier of the DC block
+
+        buffer_shape = [1 for _ in range(spatial_dims + 3)]  # 3 denotes the batch, channel, and real/complex dimensions
+        self.register_buffer("zeros", torch.zeros(buffer_shape))
+
+    def soft_dc(self, x: Tensor, ref_kspace: Tensor, mask: Tensor) -> Tensor:
+        """
+        Applies data consistency to input x. Suppose x is an intermediate estimate of the kspace and ref_kspace
+        is the reference under-sampled measurement. This function returns mask * (x - ref_kspace). View this as the
+        residual between the original under-sampled kspace and the estimate given by the network.
+
+        Args:
+            x: 2D kspace (B,C,H,W,2) with the last dimension being 2 (for real/imaginary parts) and C denoting the
+                coil dimension. 3D data will have the shape (B,C,H,W,D,2).
+            ref_kspace: original under-sampled kspace with the same shape as x.
+            mask: the under-sampling mask with shape (1,1,1,W,1) for 2D data or (1,1,1,1,D,1) for 3D data.
+
+        Returns:
+            Output of DC block with the same shape as x
+        """
+        return torch.where(mask, x - ref_kspace, self.zeros) * self.dc_weight
+
+    def forward(self, current_kspace: Tensor, ref_kspace: Tensor, mask: Tensor, sens_maps: Tensor) -> Tensor:
+        """
+        Args:
+            current_kspace: Predicted kspace from the previous block. It's a 2D kspace (B,C,H,W,2)
+                with the last dimension being 2 (for real/imaginary parts) and C denoting the
+                coil dimension. 3D data will have the shape (B,C,H,W,D,2).
+            ref_kspace: reference kspace for applying data consistency (is the under-sampled kspace in MRI reconstruction).
+                Its shape is the same as current_kspace.
+            mask: the under-sampling mask with shape (1,1,1,W,1) for 2D data or (1,1,1,1,D,1) for 3D data.
+            sens_maps: coil sensitivity maps with the same shape as current_kspace
+
+        Returns:
+            Output of VarNetBlock with the same shape as current_kspace
+        """
+        dc_out = self.soft_dc(current_kspace, ref_kspace, mask)  # output of DC block
+        refinement_out = sensitivity_map_expand(
+            self.model(sensitivity_map_reduce(current_kspace, sens_maps, spatial_dims=self.spatial_dims)),
+            sens_maps,
+            spatial_dims=self.spatial_dims,
+        )  # output of refinement model
+        output = current_kspace - dc_out - refinement_out
+        return output

source_code/SegMamba/monai/apps/reconstruction/networks/nets/__init__.py

@@ -0,0 +1,10 @@
+# Copyright (c) MONAI Consortium
+# 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.

source_code/SegMamba/monai/apps/reconstruction/networks/nets/coil_sensitivity_model.py

@@ -0,0 +1,142 @@
+# Copyright (c) MONAI Consortium
+# 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.
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+
+import torch
+import torch.nn as nn
+from torch import Tensor
+
+from monai.apps.reconstruction.mri_utils import root_sum_of_squares_t
+from monai.apps.reconstruction.networks.nets.complex_unet import ComplexUnet
+from monai.apps.reconstruction.networks.nets.utils import (
+    reshape_batch_channel_to_channel_dim,
+    reshape_channel_to_batch_dim,
+)
+from monai.networks.blocks.fft_utils_t import ifftn_centered_t
+
+
+class CoilSensitivityModel(nn.Module):
+    """
+    This class uses a convolutional model to learn coil sensitivity maps for multi-coil MRI reconstruction.
+    The convolutional model is :py:class:`monai.apps.reconstruction.networks.nets.complex_unet` by default
+    but can be specified by the user as well. Learning is done on the center of the under-sampled
+    kspace (that region is fully sampled).
+
+    The data being a (complex) 2-channel tensor is a requirement for using this model.
+
+    Modified and adopted from: https://github.com/facebookresearch/fastMRI
+
+    Args:
+        spatial_dims: number of spatial dimensions.
+        features: six integers as numbers of features. denotes number of channels in each layer.
+        act: activation type and arguments. Defaults to LeakyReLU.
+        norm: feature normalization type and arguments. Defaults to instance norm.
+        bias: whether to have a bias term in convolution blocks. Defaults to True.
+        dropout: dropout ratio. Defaults to 0.0.
+        upsample: upsampling mode, available options are
+            ``"deconv"``, ``"pixelshuffle"``, ``"nontrainable"``.
+        coil_dim: coil dimension in the data
+        conv_net: the learning model used to estimate the coil sensitivity maps. default
+            is :py:class:`monai.apps.reconstruction.networks.nets.complex_unet`. The only
+            requirement on the model is to have 2 as input and output number of channels.
+    """
+
+    def __init__(
+        self,
+        spatial_dims: int = 2,
+        features: Sequence[int] = (32, 32, 64, 128, 256, 32),
+        act: str | tuple = ("LeakyReLU", {"negative_slope": 0.1, "inplace": True}),
+        norm: str | tuple = ("instance", {"affine": True}),
+        bias: bool = True,
+        dropout: float | tuple = 0.0,
+        upsample: str = "deconv",
+        coil_dim: int = 1,
+        conv_net: nn.Module | None = None,
+    ):
+        super().__init__()
+        if conv_net is None:
+            self.conv_net = ComplexUnet(
+                spatial_dims=spatial_dims,
+                features=features,
+                act=act,
+                norm=norm,
+                bias=bias,
+                dropout=dropout,
+                upsample=upsample,
+            )
+        else:
+            # assume the first layer is convolutional and
+            # check whether in_channels == 2
+            params = [p.shape for p in conv_net.parameters()]
+            if params[0][1] != 2:
+                raise ValueError(f"in_channels should be 2 but it's {params[0][1]}.")
+            self.conv_net = conv_net  # type: ignore
+        self.spatial_dims = spatial_dims
+        self.coil_dim = coil_dim
+
+    def get_fully_sampled_region(self, mask: Tensor) -> tuple[int, int]:
+        """
+        Extracts the size of the fully-sampled part of the kspace. Note that when a kspace
+        is under-sampled, a part of its center is fully sampled. This part is called the Auto
+        Calibration Region (ACR). ACR is used for sensitivity map computation.
+
+        Args:
+            mask: the under-sampling mask of shape (..., S, 1) where S denotes the sampling dimension
+
+        Returns:
+            A tuple containing
+                (1) left index of the region
+                (2) right index of the region
+
+        Note:
+            Suppose the mask is of shape (1,1,20,1). If this function returns 8,12 as left and right
+                indices, then it means that the fully-sampled center region has size 4 starting from 8 to 12.
+        """
+        left = right = mask.shape[-2] // 2
+        while mask[..., right, :]:
+            right += 1
+
+        while mask[..., left, :]:
+            left -= 1
+
+        return left + 1, right
+
+    def forward(self, masked_kspace: Tensor, mask: Tensor) -> Tensor:
+        """
+        Args:
+            masked_kspace: the under-sampled kspace (which is the input measurement). Its shape
+                is (B,C,H,W,2) for 2D data or (B,C,H,W,D,2) for 3D data.
+            mask: the under-sampling mask with shape (1,1,1,W,1) for 2D data or (1,1,1,1,D,1) for 3D data.
+
+        Returns:
+            predicted coil sensitivity maps with shape (B,C,H,W,2) for 2D data or (B,C,H,W,D,2) for 3D data.
+        """
+        left, right = self.get_fully_sampled_region(mask)
+        num_low_freqs = right - left  # size of the fully-sampled center
+
+        # take out the fully-sampled region and set the rest of the data to zero
+        x = torch.zeros_like(masked_kspace)
+        start = (mask.shape[-2] - num_low_freqs + 1) // 2  # this marks the start of center extraction
+        x[..., start : start + num_low_freqs, :] = masked_kspace[..., start : start + num_low_freqs, :]
+
+        # apply inverse fourier to the extracted fully-sampled data
+        x = ifftn_centered_t(x, spatial_dims=self.spatial_dims, is_complex=True)
+
+        x, b = reshape_channel_to_batch_dim(x)  # shape of x will be (B*C,1,...)
+        x = self.conv_net(x)
+        x = reshape_batch_channel_to_channel_dim(x, b)  # shape will be (B,C,...)
+        # normalize the maps
+        x = x / root_sum_of_squares_t(x, spatial_dim=self.coil_dim).unsqueeze(self.coil_dim)
+
+        return x

source_code/SegMamba/monai/csrc/filtering/bilateral/bilateral.cpp

@@ -0,0 +1,49 @@
+/*
+Copyright (c) MONAI Consortium
+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.
+*/
+
+#include <torch/extension.h>
+#include <stdexcept>
+#include <string>
+
+#include "bilateral.h"
+#include "utils/common_utils.h"
+
+torch::Tensor BilateralFilter(torch::Tensor input, float spatial_sigma, float color_sigma, bool usePHL) {
+  torch::Tensor (*filterFunction)(torch::Tensor, float, float);
+
+#ifdef WITH_CUDA
+
+  if (torch::cuda::is_available() && input.is_cuda()) {
+    CHECK_CONTIGUOUS_CUDA(input);
+
+    if (input.size(1) > BF_CUDA_MAX_CHANNELS) {
+      throw std::runtime_error(
+          "Bilateral filtering not implemented for channel count > " + std::to_string(BF_CUDA_MAX_CHANNELS));
+    }
+
+    if (input.dim() - 2 > BF_CUDA_MAX_SPATIAL_DIMENSION) {
+      throw std::runtime_error(
+          "Bilateral filtering not implemented for spatial dimension > " +
+          std::to_string(BF_CUDA_MAX_SPATIAL_DIMENSION));
+    }
+
+    filterFunction = usePHL ? &BilateralFilterPHLCuda : &BilateralFilterCuda;
+  } else {
+    filterFunction = usePHL ? &BilateralFilterPHLCpu : &BilateralFilterCpu;
+  }
+#else
+  filterFunction = usePHL ? &BilateralFilterPHLCpu : &BilateralFilterCpu;
+#endif
+
+  return filterFunction(input, spatial_sigma, color_sigma);
+}

source_code/SegMamba/monai/csrc/filtering/bilateral/bilateralfilter_cpu.cpp

@@ -0,0 +1,136 @@
+/*
+Copyright (c) MONAI Consortium
+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.
+*/
+
+#include <math.h>
+#include <torch/extension.h>
+
+#include "utils/tensor_description.h"
+#include "utils/tensor_indexing.h"
+
+template <typename scalar_t>
+void BilateralFilterCpu(torch::Tensor inputTensor, torch::Tensor outputTensor, float spatialSigma, float colorSigma) {
+  // Getting tensor description.
+  TensorDescription desc = TensorDescription(inputTensor);
+
+  // Raw tensor data pointers.
+  scalar_t* inputTensorData = inputTensor.data_ptr<scalar_t>();
+  scalar_t* outputTensorData = outputTensor.data_ptr<scalar_t>();
+
+  // Pre-calculate common values
+  int windowSize = (int)ceil(5.0f * spatialSigma) | 1; // ORing last bit to ensure odd window size
+  int halfWindowSize = floor(0.5f * windowSize);
+  scalar_t spatialExpConstant = -1.0f / (2 * spatialSigma * spatialSigma);
+  scalar_t colorExpConstant = -1.0f / (2 * colorSigma * colorSigma);
+
+  // Kernel sizes.
+  int* kernelSizes = new int[desc.dimensions];
+
+  for (int i = 0; i < desc.dimensions; i++) {
+    kernelSizes[i] = windowSize;
+  }
+
+  // Pre-calculate gaussian kernel in 1D.
+  scalar_t* gaussianKernel = new scalar_t[windowSize];
+
+  for (int i = 0; i < windowSize; i++) {
+    int distance = i - halfWindowSize;
+    gaussianKernel[i] = exp(distance * distance * spatialExpConstant);
+  }
+
+  // Kernel aggregates used to calculate
+  // the output value.
+  scalar_t* valueSum = new scalar_t[desc.channelCount];
+  scalar_t weightSum = 0;
+
+  // Looping over the batches
+  for (int b = 0; b < desc.batchCount; b++) {
+    int batchOffset = b * desc.batchStride;
+
+    // Looping over all dimensions for the home element
+    Indexer homeIndex = Indexer(desc.dimensions, desc.sizes);
+    do // while(homeIndex++)
+    {
+      // Calculating indexing offset for the home element
+      int homeOffset = batchOffset;
+
+      for (int i = 0; i < desc.dimensions; i++) {
+        homeOffset += homeIndex[i] * desc.strides[i];
+      }
+
+      // Zero kernel aggregates.
+      for (int i = 0; i < desc.channelCount; i++) {
+        valueSum[i] = 0;
+      }
+
+      weightSum = 0.0f;
+
+      // Looping over all dimensions for the neighbour element
+      Indexer kernelIndex = Indexer(desc.dimensions, kernelSizes);
+      do // while(kernelIndex++)
+      {
+        // Calculating buffer offset for the neighbour element
+        // Index is clamped to the border in each dimension.
+        int neighbourOffset = batchOffset;
+
+        for (int i = 0; i < desc.dimensions; i++) {
+          int neighbourIndex = homeIndex[i] + kernelIndex[i] - halfWindowSize;
+          int neighbourIndexClamped = std::min(desc.sizes[i] - 1, std::max(0, neighbourIndex));
+          neighbourOffset += neighbourIndexClamped * desc.strides[i];
+        }
+
+        // Euclidean color distance.
+        scalar_t colorDistanceSquared = 0;
+
+        for (int i = 0; i < desc.channelCount; i++) {
+          scalar_t diff = inputTensorData[homeOffset + i * desc.channelStride] -
+              inputTensorData[neighbourOffset + i * desc.channelStride];
+          colorDistanceSquared += diff * diff;
+        }
+
+        // Calculating and combining the spatial
+        // and color weights.
+        scalar_t spatialWeight = 1;
+
+        for (int i = 0; i < desc.dimensions; i++) {
+          spatialWeight *= gaussianKernel[kernelIndex[i]];
+        }
+
+        scalar_t colorWeight = exp(colorDistanceSquared * colorExpConstant);
+        scalar_t totalWeight = spatialWeight * colorWeight;
+
+        // Aggregating values.
+        for (int i = 0; i < desc.channelCount; i++) {
+          valueSum[i] += inputTensorData[neighbourOffset + i * desc.channelStride] * totalWeight;
+        }
+
+        weightSum += totalWeight;
+      } while (kernelIndex++);
+
+      for (int i = 0; i < desc.channelCount; i++) {
+        outputTensorData[homeOffset + i * desc.channelStride] = valueSum[i] / weightSum;
+      }
+    } while (homeIndex++);
+  }
+}
+
+torch::Tensor BilateralFilterCpu(torch::Tensor inputTensor, float spatialSigma, float colorSigma) {
+  // Preparing output tensor.
+  torch::Tensor outputTensor = torch::zeros_like(inputTensor);
+
+  AT_DISPATCH_FLOATING_TYPES_AND_HALF(inputTensor.scalar_type(), "BilateralFilterCpu", ([&] {
+                                        BilateralFilterCpu<scalar_t>(
+                                            inputTensor, outputTensor, spatialSigma, colorSigma);
+                                      }));
+
+  return outputTensor;
+}

source_code/SegMamba/monai/csrc/filtering/bilateral/bilateralfilter_cpu_phl.cpp

@@ -0,0 +1,88 @@
+/*
+Copyright (c) MONAI Consortium
+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.
+*/
+
+#include <torch/extension.h>
+
+#include "filtering/permutohedral/permutohedral.h"
+#include "utils/tensor_description.h"
+
+template <typename scalar_t>
+void BilateralFilterPHLCpu(
+    torch::Tensor inputTensor,
+    torch::Tensor outputTensor,
+    float spatialSigma,
+    float colorSigma) {
+  // Getting tensor description.
+  TensorDescription desc = TensorDescription(inputTensor);
+
+  int featureChannels = desc.channelCount + desc.dimensions;
+
+  // Preparing memory
+  scalar_t* inputTensorData = inputTensor.data_ptr<scalar_t>();
+  scalar_t* outputTensorData = outputTensor.data_ptr<scalar_t>();
+  scalar_t* data = new scalar_t[desc.channelStride * desc.channelCount];
+  scalar_t* features = new scalar_t[desc.channelStride * featureChannels];
+
+  // Precalculating inverse sigmas
+  float invSpatialSigma = 1.0f / spatialSigma;
+  float invColorSigma = 1.0f / colorSigma;
+
+  // Looping over batches
+  for (int b = 0; b < desc.batchCount; b++) {
+    int batchOffset = b * desc.batchStride;
+
+    // Creating features (also permuting input data to be channel last. Permutohedral
+    // implementation should be changed to channel first to avoid this)
+    for (int i = 0; i < desc.channelStride; i++) {
+      // Color features (and permutation)
+      for (int c = 0; c < desc.channelCount; c++) {
+        features[i * featureChannels + c] = invColorSigma * inputTensorData[batchOffset + i + c * desc.channelStride];
+        data[i * desc.channelCount + c] = inputTensorData[batchOffset + i + c * desc.channelStride];
+      }
+
+      // Spatial features
+      int offsetRemainder = i;
+
+      for (int d = 0; d < desc.dimensions; d++) {
+        int coord = offsetRemainder / desc.strides[d];
+        offsetRemainder -= coord * desc.strides[d];
+
+        features[i * featureChannels + desc.channelCount + d] = (scalar_t)invSpatialSigma * coord;
+      }
+    }
+
+    // Filtering data with respect to the features.
+    PermutohedralCPU<scalar_t>(data, features, desc.channelCount, featureChannels, desc.channelStride);
+
+    // Writing output tensor.
+    for (int i = 0; i < desc.channelStride; i++) {
+      for (int c = 0; c < desc.channelCount; c++) {
+        outputTensorData[batchOffset + i + c * desc.channelStride] = data[i * desc.channelCount + c];
+      }
+    }
+  }
+
+  delete[] data;
+  delete[] features;
+}
+
+// Function to choose template implementation based on dynamic, channels and dimensions
+torch::Tensor BilateralFilterPHLCpu(torch::Tensor inputTensor, float spatialSigma, float colorSigma) {
+  torch::Tensor outputTensor = torch::zeros_like(inputTensor);
+
+  AT_DISPATCH_FLOATING_TYPES(inputTensor.scalar_type(), "BilateralFilterPhlCpu", ([&] {
+                               BilateralFilterPHLCpu<scalar_t>(inputTensor, outputTensor, spatialSigma, colorSigma);
+                             }));
+
+  return outputTensor;
+}

source_code/SegMamba/monai/csrc/filtering/bilateral/bilateralfilter_cuda.cu

@@ -0,0 +1,260 @@
+/*
+Copyright (c) MONAI Consortium
+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.
+*/
+
+#include <cuda.h>
+#include <cuda_runtime.h>
+#include <torch/extension.h>
+
+#include "bilateral.h"
+#include "utils/meta_macros.h"
+#include "utils/tensor_description.h"
+
+__constant__ int cBatchStride;
+__constant__ int cColorStride;
+
+__constant__ int cSizes[3];
+__constant__ int cStrides[3];
+
+__constant__ int cKernelSize;
+__constant__ float cKernel[256];
+
+__constant__ float cColorExponentFactor;
+
+template <typename scalar_t, int C>
+__global__ void BilateralFilterCudaKernel1D(scalar_t* input, scalar_t* output) {
+  int kernelHalfSize = cKernelSize / 2;
+
+  int homeOffset = blockIdx.x * blockDim.x + threadIdx.x;
+  int batchOffset = blockIdx.y * cBatchStride;
+
+  if (homeOffset >= cColorStride)
+    return;
+
+  scalar_t weightSum = 0;
+
+  for (int kernelOffset = 0; kernelOffset < cKernelSize; kernelOffset++) {
+    int neighbourOffset = max(0, min(homeOffset + (kernelOffset - kernelHalfSize), cSizes[0] - 1));
+    scalar_t gaussian = cKernel[kernelOffset];
+
+    scalar_t distanceSquared = 0;
+
+#pragma unroll
+    for (int c = 0; c < C; c++) {
+      scalar_t a = input[batchOffset + homeOffset + c * cColorStride];
+      scalar_t b = input[batchOffset + neighbourOffset + c * cColorStride];
+      scalar_t diff = a - b;
+      distanceSquared += diff * diff;
+    }
+
+    scalar_t spatialWeight = gaussian;
+    scalar_t colorWeight = exp(cColorExponentFactor * distanceSquared);
+    scalar_t totalWeight = spatialWeight * colorWeight;
+
+#pragma unroll
+    for (int c = 0; c < C; c++) {
+      scalar_t a = input[batchOffset + neighbourOffset + c * cColorStride];
+
+      output[batchOffset + homeOffset + c * cColorStride] += a * totalWeight;
+    }
+
+    weightSum += totalWeight;
+  }
+
+#pragma unroll
+  for (int c = 0; c < C; c++) {
+    output[batchOffset + homeOffset + c * cColorStride] /= weightSum;
+  }
+}
+
+template <typename scalar_t, int C>
+__global__ void BilateralFilterCudaKernel2D(scalar_t* input, scalar_t* output) {
+  int kernelHalfSize = cKernelSize / 2;
+
+  int homeOffset = blockIdx.x * blockDim.x + threadIdx.x;
+  int batchOffset = blockIdx.y * cBatchStride;
+
+  if (homeOffset >= cColorStride)
+    return;
+
+  int homeX = homeOffset / cStrides[0];
+  int homeY = (homeOffset - homeX * cStrides[0]) / cStrides[1];
+
+  scalar_t weightSum = 0;
+
+  for (int kernelX = 0; kernelX < cKernelSize; kernelX++) {
+    int neighbourX = max(0, min(homeX + (kernelX - kernelHalfSize), cSizes[0] - 1));
+    scalar_t gaussianX = cKernel[kernelX];
+
+    for (int kernelY = 0; kernelY < cKernelSize; kernelY++) {
+      int neighbourY = max(0, min(homeY + (kernelY - kernelHalfSize), cSizes[1] - 1));
+      scalar_t gaussianY = cKernel[kernelY];
+
+      int neighbourOffset = neighbourX * cStrides[0] + neighbourY;
+
+      scalar_t distanceSquared = 0;
+
+#pragma unroll
+      for (int c = 0; c < C; c++) {
+        scalar_t a = input[batchOffset + homeOffset + c * cColorStride];
+        scalar_t b = input[batchOffset + neighbourOffset + c * cColorStride];
+        scalar_t diff = a - b;
+        distanceSquared += diff * diff;
+      }
+
+      scalar_t spatialWeight = gaussianX * gaussianY;
+      scalar_t colorWeight = exp(cColorExponentFactor * distanceSquared);
+      scalar_t totalWeight = spatialWeight * colorWeight;
+
+#pragma unroll
+      for (int c = 0; c < C; c++) {
+        scalar_t a = input[batchOffset + neighbourOffset + c * cColorStride];
+
+        output[batchOffset + homeOffset + c * cColorStride] += a * totalWeight;
+      }
+
+      weightSum += totalWeight;
+    }
+  }
+
+#pragma unroll
+  for (int c = 0; c < C; c++) {
+    output[batchOffset + homeOffset + c * cColorStride] /= weightSum;
+  }
+}
+
+template <typename scalar_t, int C>
+__global__ void BilateralFilterCudaKernel3D(scalar_t* input, scalar_t* output) {
+  int kernelHalfSize = cKernelSize / 2;
+
+  int homeOffset = blockIdx.x * blockDim.x + threadIdx.x;
+  int batchOffset = blockIdx.y * cBatchStride;
+
+  if (homeOffset >= cColorStride)
+    return;
+
+  int homeX = homeOffset / cStrides[0];
+  int homeY = (homeOffset - homeX * cStrides[0]) / cStrides[1];
+  int homeZ = (homeOffset - homeX * cStrides[0] - homeY * cStrides[1]) / cStrides[2];
+
+  scalar_t weightSum = 0;
+
+  for (int kernelX = 0; kernelX < cKernelSize; kernelX++) {
+    int neighbourX = max(0, min(homeX + (kernelX - kernelHalfSize), cSizes[0] - 1));
+    scalar_t gaussianX = cKernel[kernelX];
+
+    for (int kernelY = 0; kernelY < cKernelSize; kernelY++) {
+      int neighbourY = max(0, min(homeY + (kernelY - kernelHalfSize), cSizes[1] - 1));
+      scalar_t gaussianY = cKernel[kernelY];
+
+      for (int kernelZ = 0; kernelZ < cKernelSize; kernelZ++) {
+        int neighbourZ = max(0, min(homeZ + (kernelZ - kernelHalfSize), cSizes[2] - 1));
+        scalar_t gaussianZ = cKernel[kernelZ];
+
+        int neighbourOffset = neighbourX * cStrides[0] + neighbourY * cStrides[1] + neighbourZ;
+
+        scalar_t distanceSquared = 0;
+
+#pragma unroll
+        for (int c = 0; c < C; c++) {
+          scalar_t a = input[batchOffset + homeOffset + c * cColorStride];
+          scalar_t b = input[batchOffset + neighbourOffset + c * cColorStride];
+          scalar_t diff = a - b;
+          distanceSquared += diff * diff;
+        }
+
+        scalar_t spatialWeight = gaussianX * gaussianY * gaussianZ;
+        scalar_t colorWeight = exp(cColorExponentFactor * distanceSquared);
+        scalar_t totalWeight = spatialWeight * colorWeight;
+
+#pragma unroll
+        for (int c = 0; c < C; c++) {
+          scalar_t a = input[batchOffset + neighbourOffset + c * cColorStride];
+          output[batchOffset + homeOffset + c * cColorStride] += a * totalWeight;
+        }
+
+        weightSum += totalWeight;
+      }
+    }
+  }
+
+#pragma unroll
+  for (int c = 0; c < C; c++) {
+    output[batchOffset + homeOffset + c * cColorStride] /= weightSum;
+  }
+}
+
+template <int C, int D>
+void BilateralFilterCuda(torch::Tensor inputTensor, torch::Tensor outputTensor, float spatialSigma, float colorSigma) {
+  // Getting tensor description.
+  TensorDescription desc = TensorDescription(inputTensor);
+
+  // Pre-calculating exponent factors.
+  float spatialExponentFactor = -1.0f / (2 * spatialSigma * spatialSigma);
+  float colorExponentFactor = -1.0f / (2 * colorSigma * colorSigma);
+
+  // Pre-calculating gaussian kernel.
+  int kernelSize = (int)ceil(5.0f * spatialSigma) | 1; // ORing last bit to ensure odd window size
+  int kernelHalfSize = floor(0.5f * kernelSize);
+  float* kernel = new float[kernelSize];
+
+  for (int i = 0; i < kernelSize; i++) {
+    int distance = i - kernelHalfSize;
+    kernel[i] = exp(distance * distance * spatialExponentFactor);
+  }
+
+  // Writing constant memory.
+  cudaMemcpyToSymbol(cBatchStride, &desc.batchStride, sizeof(int));
+  cudaMemcpyToSymbol(cColorStride, &desc.channelStride, sizeof(int));
+  cudaMemcpyToSymbol(cSizes, desc.sizes, sizeof(int) * D);
+  cudaMemcpyToSymbol(cStrides, desc.strides, sizeof(int) * D);
+  cudaMemcpyToSymbol(cKernelSize, &kernelSize, sizeof(int));
+  cudaMemcpyToSymbol(cKernel, kernel, sizeof(float) * kernelSize);
+  cudaMemcpyToSymbol(cColorExponentFactor, &colorExponentFactor, sizeof(float));
+
+#define BLOCK_SIZE 32
+
+  AT_DISPATCH_FLOATING_TYPES_AND_HALF(
+      inputTensor.scalar_type(), "BilateralFilterCudaKernel", ([&] {
+        // Dispatch kernel. (Partial template function specialisation not supported at present so using this switch
+        // instead)
+        switch (D) {
+          case (1):
+            BilateralFilterCudaKernel1D<scalar_t, C>
+                <<<dim3(int(desc.channelStride / BLOCK_SIZE) + 1, desc.batchCount), dim3(BLOCK_SIZE, 1)>>>(
+                    inputTensor.data_ptr<scalar_t>(), outputTensor.data_ptr<scalar_t>());
+            break;
+          case (2):
+            BilateralFilterCudaKernel2D<scalar_t, C>
+                <<<dim3(int(desc.channelStride / BLOCK_SIZE) + 1, desc.batchCount), dim3(BLOCK_SIZE, 1)>>>(
+                    inputTensor.data_ptr<scalar_t>(), outputTensor.data_ptr<scalar_t>());
+            break;
+          case (3):
+            BilateralFilterCudaKernel3D<scalar_t, C>
+                <<<dim3(int(desc.channelStride / BLOCK_SIZE) + 1, desc.batchCount), dim3(BLOCK_SIZE, 1)>>>(
+                    inputTensor.data_ptr<scalar_t>(), outputTensor.data_ptr<scalar_t>());
+            break;
+        }
+      }));
+
+  delete[] kernel;
+}
+
+// Function to choose template implementation based on dynamic, channels and dimensions
+torch::Tensor BilateralFilterCuda(torch::Tensor inputTensor, float spatialSigma, float colorSigma) {
+  torch::Tensor outputTensor = torch::zeros_like(inputTensor);
+
+#define CASE(c, d) BilateralFilterCuda<c, d>(inputTensor, outputTensor, spatialSigma, colorSigma);
+  SWITCH_AB(CASE, BF_CUDA_MAX_CHANNELS, BF_CUDA_MAX_SPATIAL_DIMENSION, inputTensor.size(1), inputTensor.dim() - 2);
+
+  return outputTensor;
+}

source_code/SegMamba/monai/csrc/filtering/bilateral/bilateralfilter_cuda_phl.cu

@@ -0,0 +1,142 @@
+/*
+Copyright (c) MONAI Consortium
+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.
+*/
+
+#include <cuda.h>
+#include <cuda_runtime.h>
+#include <torch/extension.h>
+
+#include "bilateral.h"
+#include "filtering/permutohedral/permutohedral.h"
+#include "utils/meta_macros.h"
+#include "utils/tensor_description.h"
+
+__constant__ int cBatchStride;
+__constant__ int cChannelStride;
+__constant__ int cSpatialStrides[3];
+__constant__ float cInvSpatialSigma;
+__constant__ float cInvColorSigma;
+
+template <typename scalar_t, int C, int D>
+__global__ void FeatureCreation(const scalar_t* inputTensor, scalar_t* outputData, scalar_t* outputFeatures) {
+  int elementIndex = blockIdx.x * blockDim.x + threadIdx.x;
+  int batchIndex = blockIdx.y;
+
+  if (elementIndex >= cChannelStride)
+    return;
+
+  int dataBatchOffset = batchIndex * cBatchStride;
+  int featureBatchOffset = batchIndex * (D + C) * cChannelStride;
+
+#pragma unroll
+  for (int i = 0; i < C; i++) {
+    outputData[dataBatchOffset + elementIndex * C + i] =
+        inputTensor[dataBatchOffset + elementIndex + i * cChannelStride];
+    outputFeatures[featureBatchOffset + elementIndex * (C + D) + i] =
+        inputTensor[dataBatchOffset + elementIndex + i * cChannelStride] * cInvColorSigma;
+  }
+
+  int remainder = elementIndex;
+
+#pragma unroll
+  for (int i = 0; i < D; i++) {
+    int coord = remainder / cSpatialStrides[i];
+    remainder -= coord * cSpatialStrides[i];
+
+    outputFeatures[featureBatchOffset + elementIndex * (C + D) + C + i] = coord * cInvSpatialSigma;
+  }
+}
+
+template <typename scalar_t, int C>
+__global__ void WriteOutput(const scalar_t* data, scalar_t* outputTensor) {
+  int elementIndex = blockIdx.x * blockDim.x + threadIdx.x;
+  int batchIndex = blockIdx.y;
+
+  if (elementIndex >= cChannelStride)
+    return;
+
+  int batchOffset = batchIndex * cBatchStride;
+
+#pragma unroll
+  for (int i = 0; i < C; i++) {
+    outputTensor[batchOffset + elementIndex + i * cChannelStride] = data[batchOffset + elementIndex * C + i];
+  }
+}
+
+template <typename scalar_t, int C, int D>
+void BilateralFilterPHLCuda(
+    torch::Tensor inputTensor,
+    torch::Tensor outputTensor,
+    float spatialSigma,
+    float colorSigma) {
+  // Getting tensor description.
+  TensorDescription desc = TensorDescription(inputTensor);
+
+  int featureChannelCount = desc.channelCount + desc.dimensions;
+
+  // Pre calculating inverse sigmas.
+  float invSpatialSigma = 1.0f / spatialSigma;
+  float invColorSigma = 1.0f / colorSigma;
+
+  // Preparing global memory
+  scalar_t* inputTensorData = inputTensor.data_ptr<scalar_t>();
+  scalar_t* outputTensorData = outputTensor.data_ptr<scalar_t>();
+
+  scalar_t* data;
+  scalar_t* features;
+  cudaMalloc(&data, desc.batchCount * desc.channelStride * desc.channelCount * sizeof(scalar_t));
+  cudaMalloc(&features, desc.batchCount * desc.channelStride * featureChannelCount * sizeof(scalar_t));
+
+  // Preparing constant memory
+  cudaMemcpyToSymbol(cBatchStride, &desc.batchStride, sizeof(int));
+  cudaMemcpyToSymbol(cChannelStride, &desc.channelStride, sizeof(int));
+  cudaMemcpyToSymbol(cSpatialStrides, desc.strides, sizeof(int) * desc.dimensions);
+  cudaMemcpyToSymbol(cInvSpatialSigma, &invSpatialSigma, sizeof(float));
+  cudaMemcpyToSymbol(cInvColorSigma, &invColorSigma, sizeof(float));
+
+#define BLOCK_SIZE 32
+
+  // Creating features
+  FeatureCreation<scalar_t, C, D>
+      <<<dim3(int(desc.channelStride / BLOCK_SIZE) + 1, desc.batchCount), dim3(BLOCK_SIZE, 1)>>>(
+          inputTensorData, data, features);
+
+  // Filtering data with respect to the features for each sample in batch
+  for (int batchIndex = 0; batchIndex < desc.batchCount; batchIndex++) {
+    scalar_t* offsetData = data + batchIndex * desc.batchStride;
+    scalar_t* offsetFeatures = features + batchIndex * featureChannelCount * desc.channelStride;
+
+    PermutohedralCuda<scalar_t, C, C + D>(offsetData, offsetFeatures, desc.channelStride, true);
+  }
+
+  // Writing output
+  WriteOutput<scalar_t, C><<<dim3(int(desc.channelStride / BLOCK_SIZE) + 1, desc.batchCount), dim3(BLOCK_SIZE, 1)>>>(
+      data, outputTensorData);
+
+  cudaFree(data);
+  cudaFree(features);
+}
+
+// Function to choose template implementation based on dynamic, channels and dimensions
+torch::Tensor BilateralFilterPHLCuda(torch::Tensor inputTensor, float spatialSigma, float colorSigma) {
+  torch::Tensor outputTensor = torch::zeros_like(inputTensor);
+
+#define CASE(c, d)                                                                       \
+  AT_DISPATCH_FLOATING_TYPES(inputTensor.scalar_type(), "BilateralFilterCudaPHL", ([&] { \
+                               BilateralFilterPHLCuda<scalar_t, c, d>(                   \
+                                   inputTensor, outputTensor, spatialSigma, colorSigma); \
+                             }));
+
+  SWITCH_AB(CASE, BF_CUDA_MAX_CHANNELS, BF_CUDA_MAX_SPATIAL_DIMENSION, inputTensor.size(1), inputTensor.dim() - 2);
+
+  return outputTensor;
+}

source_code/SegMamba/monai/csrc/filtering/filtering.h

@@ -0,0 +1,19 @@
+/*
+Copyright (c) MONAI Consortium
+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.
+*/
+
+#pragma once
+
+#include "bilateral/bilateral.h"
+#include "permutohedral/permutohedral.h"
+#include "trainable_bilateral/trainable_bilateral.h"
+#include "trainable_joint_bilateral/trainable_joint_bilateral.h"

source_code/SegMamba/monai/csrc/filtering/permutohedral/hash_table.cuh

@@ -0,0 +1,260 @@
+/*
+Copyright (c) MONAI Consortium
+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.
+*/
+
+#include <torch/extension.h>
+
+//#define USE_ADDITIVE_HASH
+
+// turn this on if you want to get slightly less memory consumption and slightly longer run times.
+//#define LINEAR_D_MEMORY
+
+#define USE_CUSTOM_MODULO
+
+__device__ __constant__ signed short* table_keys;
+__device__ __constant__ int* table_entries;
+__device__ __constant__ unsigned int table_capacity;
+__device__ __constant__ signed short* table_zeros;
+__device__ __constant__ char* table_rank;
+
+/*************************************************************/
+/* Fast computation of modulo operator with constant divisor */
+/*************************************************************/
+__device__ __constant__ unsigned int __div_m;
+__device__ __constant__ unsigned int __div_l;
+__device__ __constant__ unsigned int __div_c;
+
+#ifdef USE_CUSTOM_MODULO
+__device__ inline unsigned int modHash(unsigned int n) {
+  unsigned int t1 = __umulhi(__div_m, n);
+  return n - ((t1 + ((n - t1) >> 1)) >> (__div_l - 1)) * __div_c;
+}
+
+#else
+#define modHash(n) ((n) % (2 * table_capacity));
+#endif
+
+/*************************************************************/
+/* End modulo                                                */
+/*************************************************************/
+
+__device__ __constant__ static unsigned int hOffset[64];
+
+template <typename scalar_t, int kd, int vd>
+static scalar_t* createHashTable(int capacity) {
+  scalar_t* values;
+  cudaMalloc(&values, capacity * vd * sizeof(scalar_t));
+  cudaMemset(values, 0, capacity * vd * sizeof(scalar_t));
+
+  int* entries;
+  cudaMalloc(&entries, capacity * 2 * sizeof(int));
+  cudaMemset(entries, -1, capacity * 2 * sizeof(int));
+
+  cudaMemcpyToSymbol(table_capacity, &capacity, sizeof(int));
+
+  cudaMemcpyToSymbol(table_entries, &entries, sizeof(int*));
+
+#ifdef LINEAR_D_MEMORY
+
+  char* ranks;
+  cudaMalloc(&ranks, capacity * sizeof(char));
+
+  signed short* zeros;
+  cudaMalloc(&zeros, capacity * sizeof(signed short));
+
+  cudaMemcpyToSymbol(table_rank, &ranks, sizeof(char*));
+  cudaMemcpyToSymbol(table_zeros, &zeros, sizeof(char*));
+
+#else
+
+  signed short* keys;
+  cudaMalloc(&keys, capacity * kd * sizeof(signed short));
+  cudaMemset(keys, 0, capacity * kd * sizeof(signed short));
+
+  cudaMemcpyToSymbol(table_keys, &keys, sizeof(unsigned int*));
+
+#endif
+
+  return values;
+}
+
+template <typename scalar_t>
+static void destroyHashTable() {
+#ifndef LINEAR_D_MEMORY
+  signed short* keys;
+  cudaMemcpyFromSymbol(&keys, table_keys, sizeof(unsigned int*));
+  cudaFree(keys);
+#endif
+
+  int* entries;
+  cudaMemcpyFromSymbol(&entries, table_entries, sizeof(int*));
+  cudaFree(entries);
+}
+
+template <int kd>
+__device__ __host__ static unsigned int hash(signed short* key) {
+  unsigned int k = 0;
+  for (int i = 0; i < kd; i++) {
+    k += key[i];
+    k = k * 2531011;
+  }
+  return k;
+}
+
+template <int kd>
+__device__ __host__ static unsigned int hash(int* key) {
+  unsigned int k = 0;
+  for (int i = 0; i < kd; i++) {
+    k += key[i];
+    k = k * 2531011;
+  }
+  return k;
+}
+
+template <int d>
+__device__ static bool matchKey(int idx, signed short* key) {
+  bool match = true;
+  int slot = idx / (d + 1), color = idx - slot * (d + 1);
+  char* rank = table_rank + slot * (d + 1);
+  signed short* zero = table_zeros + slot * (d + 1);
+
+  for (int i = 0; i < d && match; i++) {
+    match = (key[i] == zero[i] + color - (rank[i] > d - color ? (d + 1) : 0));
+  }
+
+  return match;
+}
+
+template <int d>
+__device__ static void generateKey(int idx, signed short* key) {
+  int slot = idx / (d + 1), color = idx - slot * (d + 1);
+  char* rank = table_rank + slot * (d + 1);
+  signed short* zero = table_zeros + slot * (d + 1);
+
+  for (int i = 0; i < d; i++) {
+    key[i] = zero[i] + color - (rank[i] > d - color ? (d + 1) : 0);
+  }
+}
+
+template <int kd>
+__device__ static int hashTableInsert(unsigned int fh, signed short* key, unsigned int slot) {
+  int h = modHash(fh);
+  while (1) {
+    int* e = &table_entries[h];
+
+    // If the cell is empty (-1), lock it (-2)
+    int contents = atomicCAS(e, -1, -2);
+
+    if (contents == -2) {
+      // If it was locked already, move on to the next cell
+    } else if (contents == -1) {
+      // If it was empty, we successfully locked it. Write our key.
+
+#ifndef LINEAR_D_MEMORY
+      for (int i = 0; i < kd; i++) {
+        table_keys[slot * kd + i] = key[i];
+      }
+#endif
+
+      // Unlock
+      atomicExch(e, slot);
+
+      return h;
+    } else {
+// The cell is unlocked and has a key in it, check if it matches
+#ifdef LINEAR_D_MEMORY
+      if (matchKey<kd>(contents, key))
+        return h;
+#else
+      bool match = true;
+
+      for (int i = 0; i < kd && match; i++) {
+        match = (table_keys[contents * kd + i] == key[i]);
+      }
+
+      if (match)
+        return h;
+#endif
+    }
+    // increment the bucket with wraparound
+    h++;
+
+    if (h == table_capacity * 2)
+      h = 0;
+  }
+}
+
+template <int kd>
+__device__ static int hashTableInsert(signed short* key, unsigned int slot) {
+  unsigned int myHash = hash<kd>(key);
+  return hashTableInsert<kd>(myHash, key, slot);
+}
+
+template <int kd>
+__device__ static int hashTableRetrieveWithHash(unsigned int fh, signed short* key) {
+  int h = modHash(fh);
+  while (1) {
+    int* e = table_entries + h;
+
+    if (*e == -1)
+      return -1;
+
+#ifdef LINEAR_D_MEMORY
+    if (matchKey<kd>((*e), key))
+      return *e;
+#else
+    bool match = true;
+
+    for (int i = 0; i < kd && match; i++) {
+      match = (table_keys[(*e) * kd + i] == key[i]);
+    }
+
+    if (match)
+      return *e;
+#endif
+
+    h++;
+
+    if (h == table_capacity * 2)
+      h = 0;
+  }
+}
+
+template <int kd>
+__device__ static int hashTableRetrieve(signed short* key) {
+  int h = modHash(hash<kd>(key));
+  while (1) {
+    int* e = table_entries + h;
+
+    if (*e == -1)
+      return -1;
+
+#ifdef LINEAR_D_MEMORY
+    if (matchKey<kd>((*e), key))
+      return *e;
+#else
+    bool match = true;
+
+    for (int i = 0; i < kd && match; i++) {
+      match = (table_keys[(*e) * kd + i] == key[i]);
+    }
+
+    if (match)
+      return *e;
+#endif
+
+    h++;
+
+    if (h == table_capacity * 2)
+      h = 0;
+  }
+}

source_code/SegMamba/monai/csrc/filtering/permutohedral/permutohedral.cpp

@@ -0,0 +1,97 @@
+/*
+Copyright (c) MONAI Consortium
+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.
+*/
+
+#include <stdexcept>
+#include <string>
+
+#include "utils/common_utils.h"
+#include "utils/meta_macros.h"
+
+#include "permutohedral.h"
+
+torch::Tensor PermutohedralFilter(torch::Tensor input, torch::Tensor features) {
+  input = input.contiguous();
+
+  int batchCount = input.size(0);
+  int batchStride = input.stride(0);
+  int elementCount = input.stride(1);
+  int channelCount = input.size(1);
+  int featureCount = features.size(1);
+
+// movedim not support in torch < 1.7.1
+#if MONAI_TORCH_VERSION >= 10701
+  torch::Tensor data = input.clone().movedim(1, -1).contiguous();
+  features = features.movedim(1, -1).contiguous();
+#else
+  torch::Tensor data = input.clone();
+  features = features;
+
+  for (int i = 1; i < input.dim() - 1; i++) {
+    data = data.transpose(i, i + 1);
+    features = features.transpose(i, i + 1);
+  }
+
+  data = data.contiguous();
+  features = features.contiguous();
+#endif
+
+#ifdef WITH_CUDA
+  if (torch::cuda::is_available() && data.is_cuda()) {
+    CHECK_CONTIGUOUS_CUDA(data);
+
+    if (channelCount > PHL_CUDA_MAX_CHANNELS) {
+      throw std::runtime_error(
+          "PHL filtering not implemented for channel count > " + std::to_string(PHL_CUDA_MAX_CHANNELS));
+    }
+
+    if (featureCount > PHL_CUDA_MAX_FEATURES) {
+      throw std::runtime_error(
+          "PHL filtering not implemented for feature count > " + std::to_string(PHL_CUDA_MAX_FEATURES));
+    }
+
+#define CASE(dc, fc)                                                                                                  \
+  AT_DISPATCH_FLOATING_TYPES(data.scalar_type(), "PermutohedralCuda", ([&] {                                          \
+                               for (int batchIndex = 0; batchIndex < batchCount; batchIndex++) {                      \
+                                 scalar_t* offsetData = data.data_ptr<scalar_t>() + batchIndex * batchStride;         \
+                                 scalar_t* offsetFeatures =                                                           \
+                                     features.data_ptr<scalar_t>() + batchIndex * fc * elementCount;                  \
+                                 PermutohedralCuda<scalar_t, dc, fc>(offsetData, offsetFeatures, elementCount, true); \
+                               }                                                                                      \
+                             }));
+    SWITCH_AB(CASE, PHL_CUDA_MAX_CHANNELS, PHL_CUDA_MAX_FEATURES, channelCount, featureCount);
+
+  } else {
+#endif
+    AT_DISPATCH_FLOATING_TYPES(
+        data.scalar_type(), "PermutohedralCPU", ([&] {
+          for (int batchIndex = 0; batchIndex < batchCount; batchIndex++) {
+            scalar_t* offsetData = data.data_ptr<scalar_t>() + batchIndex * batchStride;
+            scalar_t* offsetFeatures = features.data_ptr<scalar_t>() + batchIndex * featureCount * elementCount;
+            PermutohedralCPU<scalar_t>(offsetData, offsetFeatures, channelCount, featureCount, elementCount);
+          }
+        }));
+#ifdef WITH_CUDA
+  }
+#endif
+
+// movedim not support in torch < 1.7.1
+#if MONAI_TORCH_VERSION >= 10701
+  data = data.movedim(-1, 1);
+#else
+  for (int i = input.dim() - 1; i > 1; i--) {
+    data = data.transpose(i - 1, i);
+  }
+#endif
+
+  return data;
+}

source_code/SegMamba/monai/csrc/filtering/permutohedral/permutohedral.h

@@ -0,0 +1,28 @@
+/*
+Copyright (c) MONAI Consortium
+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.
+*/
+
+#pragma once
+
+#include <torch/extension.h>
+
+#define PHL_CUDA_MAX_CHANNELS 16
+#define PHL_CUDA_MAX_FEATURES 19
+
+template <typename scalar_t>
+void PermutohedralCPU(scalar_t* data, scalar_t* features, int dataChannels, int featureChannels, int elementCount);
+#ifdef WITH_CUDA
+template <typename scalar_t, int dc, int fc>
+void PermutohedralCuda(scalar_t* data, scalar_t* features, int elementCount, bool accurate);
+#endif
+
+torch::Tensor PermutohedralFilter(torch::Tensor input, torch::Tensor features);

source_code/SegMamba/monai/csrc/filtering/permutohedral/permutohedral_cpu.cpp

@@ -0,0 +1,502 @@
+/*
+Copyright (c) MONAI Consortium
+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.
+*/
+
+/*
+Adapted from https://github.com/abadams/permutohedral
+which has the following license...
+
+MIT License
+
+Copyright (c) 2020 Andrew Adams
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/
+
+#include <math.h>
+#include <string.h>
+
+#include <torch/extension.h>
+
+using namespace std;
+
+/***************************************************************/
+/* Hash table implementation for permutohedral lattice
+ *
+ * The lattice points are stored sparsely using a hash table.
+ * The key for each point is its spatial location in the (d+1)-
+ * dimensional space.
+ */
+/***************************************************************/
+template <typename scalar_t>
+class HashTablePermutohedral {
+ public:
+  /* Constructor
+   *  kd_: the dimensionality of the position vectors on the hyperplane.
+   *  vd_: the dimensionality of the value vectors
+   */
+  HashTablePermutohedral(int kd_, int vd_) : kd(kd_), vd(vd_) {
+    capacity = 1 << 15;
+    filled = 0;
+    entries = new Entry[capacity];
+    keys = new short[kd * capacity / 2];
+    values = new scalar_t[vd * capacity / 2];
+    memset(values, 0, sizeof(scalar_t) * vd * capacity / 2);
+  }
+
+  // Returns the number of vectors stored.
+  int size() {
+    return filled;
+  }
+
+  // Returns a pointer to the keys array.
+  short* getKeys() {
+    return keys;
+  }
+
+  // Returns a pointer to the values array.
+  scalar_t* getValues() {
+    return values;
+  }
+
+  /* Returns the index into the hash table for a given key.
+   *     key: a pointer to the position vector.
+   *       h: hash of the position vector.
+   *  create: a flag specifying whether an entry should be created,
+   *          should an entry with the given key not found.
+   */
+  int lookupOffset(short* key, size_t h, bool create = true) {
+    // Double hash table size if necessary
+    if (filled >= (capacity / 2) - 1) {
+      grow();
+    }
+
+    // Find the entry with the given key
+    while (1) {
+      Entry e = entries[h];
+      // check if the cell is empty
+      if (e.keyIdx == -1) {
+        if (!create)
+          return -1; // Return not found.
+        // need to create an entry. Store the given key.
+        for (int i = 0; i < kd; i++)
+          keys[filled * kd + i] = key[i];
+        e.keyIdx = filled * kd;
+        e.valueIdx = filled * vd;
+        entries[h] = e;
+        filled++;
+        return e.valueIdx;
+      }
+
+      // check if the cell has a matching key
+      bool match = true;
+      for (int i = 0; i < kd && match; i++)
+        match = keys[e.keyIdx + i] == key[i];
+      if (match)
+        return e.valueIdx;
+
+      // increment the bucket with wraparound
+      h++;
+      if (h == capacity)
+        h = 0;
+    }
+  }
+
+  /* Looks up the value vector associated with a given key vector.
+   *        k : pointer to the key vector to be looked up.
+   *   create : true if a non-existing key should be created.
+   */
+  scalar_t* lookup(short* k, bool create = true) {
+    size_t h = hash(k) % capacity;
+    int offset = lookupOffset(k, h, create);
+    if (offset < 0)
+      return NULL;
+    else
+      return values + offset;
+  };
+
+  /* Hash function used in this implementation. A simple base conversion. */
+  size_t hash(const short* key) {
+    size_t k = 0;
+    for (int i = 0; i < kd; i++) {
+      k += key[i];
+      k *= 2531011;
+    }
+    return k;
+  }
+
+ private:
+  /* Grows the size of the hash table */
+  void grow() {
+    size_t oldCapacity = capacity;
+    capacity *= 2;
+
+    // Migrate the value vectors.
+    scalar_t* newValues = new scalar_t[vd * capacity / 2];
+    memset(newValues, 0, sizeof(scalar_t) * vd * capacity / 2);
+    memcpy(newValues, values, sizeof(scalar_t) * vd * filled);
+    delete[] values;
+    values = newValues;
+
+    // Migrate the key vectors.
+    short* newKeys = new short[kd * capacity / 2];
+    memcpy(newKeys, keys, sizeof(short) * kd * filled);
+    delete[] keys;
+    keys = newKeys;
+
+    Entry* newEntries = new Entry[capacity];
+
+    // Migrate the table of indices.
+    for (size_t i = 0; i < oldCapacity; i++) {
+      if (entries[i].keyIdx == -1)
+        continue;
+      size_t h = hash(keys + entries[i].keyIdx) % capacity;
+      while (newEntries[h].keyIdx != -1) {
+        h++;
+        if (h == capacity)
+          h = 0;
+      }
+      newEntries[h] = entries[i];
+    }
+    delete[] entries;
+    entries = newEntries;
+  }
+
+  // Private struct for the hash table entries.
+  struct Entry {
+    Entry() : keyIdx(-1), valueIdx(-1) {}
+    int keyIdx;
+    int valueIdx;
+  };
+
+  short* keys;
+  scalar_t* values;
+  Entry* entries;
+  size_t capacity, filled;
+  int kd, vd;
+};
+
+/***************************************************************/
+/* The algorithm class that performs the filter
+ *
+ * PermutohedralLattice::filter(...) does all the work.
+ *
+ */
+/***************************************************************/
+template <typename scalar_t>
+class PermutohedralLattice {
+ public:
+  /* Filters given image against a reference image.
+   *   im : image to be bilateral-filtered.
+   *  ref : reference image whose edges are to be respected.
+   */
+  static void filter(scalar_t* data, scalar_t* features, int dataChannels, int featureChannels, int elementCount) {
+    // Create lattice
+    PermutohedralLattice lattice(featureChannels, dataChannels + 1, elementCount);
+
+    // Splat into the lattice
+    scalar_t* col = new scalar_t[dataChannels + 1];
+    col[dataChannels] = 1; // homogeneous coordinate
+
+    for (int i = 0, e = 0; e < elementCount; e++) {
+      for (int c = 0; c < dataChannels; c++, i++) {
+        col[c] = data[i];
+      }
+
+      scalar_t* featureVec = features + e * featureChannels;
+      lattice.splat(featureVec, col);
+    }
+
+    // Blur the lattice
+    lattice.blur();
+
+    // Slice from the lattice
+    lattice.beginSlice();
+
+    for (int i = 0, e = 0; e < elementCount; e++) {
+      lattice.slice(col);
+
+      scalar_t scale = 1.0f / col[dataChannels];
+      for (int c = 0; c < dataChannels; c++, i++) {
+        data[i] = col[c] * scale;
+      }
+    }
+  }
+
+  /* Constructor
+   *     d_ : dimensionality of key vectors
+   *    vd_ : dimensionality of value vectors
+   * nData_ : number of points in the input
+   */
+  PermutohedralLattice(int d_, int vd_, int nData_) : d(d_), vd(vd_), nData(nData_), hashTable(d_, vd_) {
+    // Allocate storage for various arrays
+    elevated = new scalar_t[d + 1];
+    scaleFactor = new scalar_t[d];
+
+    greedy = new short[d + 1];
+    rank = new char[d + 1];
+    barycentric = new scalar_t[d + 2];
+    replay = new ReplayEntry[nData * (d + 1)];
+    nReplay = 0;
+    canonical = new short[(d + 1) * (d + 1)];
+    key = new short[d + 1];
+
+    // compute the coordinates of the canonical simplex, in which
+    // the difference between a contained point and the zero
+    // remainder vertex is always in ascending order. (See pg.4 of paper.)
+    for (int i = 0; i <= d; i++) {
+      for (int j = 0; j <= d - i; j++)
+        canonical[i * (d + 1) + j] = i;
+      for (int j = d - i + 1; j <= d; j++)
+        canonical[i * (d + 1) + j] = i - (d + 1);
+    }
+
+    // Compute parts of the rotation matrix E. (See pg.4-5 of paper.)
+    for (int i = 0; i < d; i++) {
+      // the diagonal entries for normalization
+      scaleFactor[i] = 1.0f / (sqrtf((scalar_t)(i + 1) * (i + 2)));
+
+      /* We presume that the user would like to do a Gaussian blur of standard deviation
+       * 1 in each dimension (or a total variance of d, summed over dimensions.)
+       * Because the total variance of the blur performed by this algorithm is not d,
+       * we must scale the space to offset this.
+       *
+       * The total variance of the algorithm is (See pg.6 and 10 of paper):
+       *  [variance of splatting] + [variance of blurring] + [variance of splatting]
+       *   = d(d+1)(d+1)/12 + d(d+1)(d+1)/2 + d(d+1)(d+1)/12
+       *   = 2d(d+1)(d+1)/3.
+       *
+       * So we need to scale the space by (d+1)sqrt(2/3).
+       */
+      scaleFactor[i] *= (d + 1) * sqrtf(2.0 / 3);
+    }
+  }
+
+  /* Performs splatting with given position and value vectors */
+  void splat(scalar_t* position, scalar_t* value) {
+    // first rotate position into the (d+1)-dimensional hyperplane
+    elevated[d] = -d * position[d - 1] * scaleFactor[d - 1];
+    for (int i = d - 1; i > 0; i--)
+      elevated[i] =
+          (elevated[i + 1] - i * position[i - 1] * scaleFactor[i - 1] + (i + 2) * position[i] * scaleFactor[i]);
+    elevated[0] = elevated[1] + 2 * position[0] * scaleFactor[0];
+
+    // prepare to find the closest lattice points
+    scalar_t scale = 1.0f / (d + 1);
+    char* myrank = rank;
+    short* mygreedy = greedy;
+
+    // greedily search for the closest zero-colored lattice point
+    int sum = 0;
+    for (int i = 0; i <= d; i++) {
+      scalar_t v = elevated[i] * scale;
+      scalar_t up = ceilf(v) * (d + 1);
+      scalar_t down = floorf(v) * (d + 1);
+
+      if (up - elevated[i] < elevated[i] - down)
+        mygreedy[i] = (short)up;
+      else
+        mygreedy[i] = (short)down;
+
+      sum += mygreedy[i];
+    }
+    sum /= d + 1;
+
+    // rank differential to find the permutation between this simplex and the canonical one.
+    // (See pg. 3-4 in paper.)
+    memset(myrank, 0, sizeof(char) * (d + 1));
+    for (int i = 0; i < d; i++)
+      for (int j = i + 1; j <= d; j++)
+        if (elevated[i] - mygreedy[i] < elevated[j] - mygreedy[j])
+          myrank[i]++;
+        else
+          myrank[j]++;
+
+    if (sum > 0) {
+      // sum too large - the point is off the hyperplane.
+      // need to bring down the ones with the smallest differential
+      for (int i = 0; i <= d; i++) {
+        if (myrank[i] >= d + 1 - sum) {
+          mygreedy[i] -= d + 1;
+          myrank[i] += sum - (d + 1);
+        } else
+          myrank[i] += sum;
+      }
+    } else if (sum < 0) {
+      // sum too small - the point is off the hyperplane
+      // need to bring up the ones with largest differential
+      for (int i = 0; i <= d; i++) {
+        if (myrank[i] < -sum) {
+          mygreedy[i] += d + 1;
+          myrank[i] += (d + 1) + sum;
+        } else
+          myrank[i] += sum;
+      }
+    }
+
+    // Compute barycentric coordinates (See pg.10 of paper.)
+    memset(barycentric, 0, sizeof(scalar_t) * (d + 2));
+    for (int i = 0; i <= d; i++) {
+      barycentric[d - myrank[i]] += (elevated[i] - mygreedy[i]) * scale;
+      barycentric[d + 1 - myrank[i]] -= (elevated[i] - mygreedy[i]) * scale;
+    }
+    barycentric[0] += 1.0f + barycentric[d + 1];
+
+    // Splat the value into each vertex of the simplex, with barycentric weights.
+    for (int remainder = 0; remainder <= d; remainder++) {
+      // Compute the location of the lattice point explicitly (all but the last coordinate - it's redundant because they
+      // sum to zero)
+      for (int i = 0; i < d; i++)
+        key[i] = mygreedy[i] + canonical[remainder * (d + 1) + myrank[i]];
+
+      // Retrieve pointer to the value at this vertex.
+      scalar_t* val = hashTable.lookup(key, true);
+
+      // Accumulate values with barycentric weight.
+      for (int i = 0; i < vd; i++)
+        val[i] += barycentric[remainder] * value[i];
+
+      // Record this interaction to use later when slicing
+      replay[nReplay].offset = val - hashTable.getValues();
+      replay[nReplay].weight = barycentric[remainder];
+      nReplay++;
+    }
+  }
+
+  // Prepare for slicing
+  void beginSlice() {
+    nReplay = 0;
+  }
+
+  /* Performs slicing out of position vectors. Note that the barycentric weights and the simplex
+   * containing each position vector were calculated and stored in the splatting step.
+   * We may reuse this to accelerate the algorithm. (See pg. 6 in paper.)
+   */
+  void slice(scalar_t* col) {
+    scalar_t* base = hashTable.getValues();
+    for (int j = 0; j < vd; j++)
+      col[j] = 0;
+    for (int i = 0; i <= d; i++) {
+      ReplayEntry r = replay[nReplay++];
+      for (int j = 0; j < vd; j++) {
+        col[j] += r.weight * base[r.offset + j];
+      }
+    }
+  }
+
+  /* Performs a Gaussian blur along each projected axis in the hyperplane. */
+  void blur() {
+    // Prepare arrays
+    short* neighbor1 = new short[d + 1];
+    short* neighbor2 = new short[d + 1];
+    scalar_t* newValue = new scalar_t[vd * hashTable.size()];
+    scalar_t* oldValue = hashTable.getValues();
+    scalar_t* hashTableBase = oldValue;
+
+    scalar_t* zero = new scalar_t[vd];
+    for (int k = 0; k < vd; k++)
+      zero[k] = 0;
+
+    // For each of d+1 axes,
+    for (int j = 0; j <= d; j++) {
+      // For each vertex in the lattice,
+      for (int i = 0; i < hashTable.size(); i++) { // blur point i in dimension j
+        short* key = hashTable.getKeys() + i * (d); // keys to current vertex
+        for (int k = 0; k < d; k++) {
+          neighbor1[k] = key[k] + 1;
+          neighbor2[k] = key[k] - 1;
+        }
+        neighbor1[j] = key[j] - d;
+        neighbor2[j] = key[j] + d; // keys to the neighbors along the given axis.
+
+        scalar_t* oldVal = oldValue + i * vd;
+        scalar_t* newVal = newValue + i * vd;
+
+        scalar_t *vm1, *vp1;
+
+        vm1 = hashTable.lookup(neighbor1, false); // look up first neighbor
+        if (vm1)
+          vm1 = vm1 - hashTableBase + oldValue;
+        else
+          vm1 = zero;
+
+        vp1 = hashTable.lookup(neighbor2, false); // look up second neighbor
+        if (vp1)
+          vp1 = vp1 - hashTableBase + oldValue;
+        else
+          vp1 = zero;
+
+        // Mix values of the three vertices
+        for (int k = 0; k < vd; k++)
+          newVal[k] = (0.25f * vm1[k] + 0.5f * oldVal[k] + 0.25f * vp1[k]);
+      }
+      scalar_t* tmp = newValue;
+      newValue = oldValue;
+      oldValue = tmp;
+      // the freshest data is now in oldValue, and newValue is ready to be written over
+    }
+
+    // depending where we ended up, we may have to copy data
+    if (oldValue != hashTableBase) {
+      memcpy(hashTableBase, oldValue, hashTable.size() * vd * sizeof(scalar_t));
+      delete[] oldValue;
+    } else {
+      delete[] newValue;
+    }
+
+    delete[] zero;
+    delete[] neighbor1;
+    delete[] neighbor2;
+  }
+
+ private:
+  int d, vd, nData;
+  scalar_t *elevated, *scaleFactor, *barycentric;
+  short* canonical;
+  short* key;
+
+  // slicing is done by replaying splatting (ie storing the sparse matrix)
+  struct ReplayEntry {
+    int offset;
+    scalar_t weight;
+  } * replay;
+  int nReplay, nReplaySub;
+
+ public:
+  char* rank;
+  short* greedy;
+  HashTablePermutohedral<scalar_t> hashTable;
+};
+
+template <typename scalar_t>
+void PermutohedralCPU(scalar_t* data, scalar_t* features, int dataChannels, int featureChannels, int elementCount) {
+  PermutohedralLattice<scalar_t>::filter(data, features, dataChannels, featureChannels, elementCount);
+}
+
+template void PermutohedralCPU(float* data, float* features, int dataChannels, int featureChannels, int elementCount);
+template void PermutohedralCPU(double* data, double* features, int dataChannels, int featureChannels, int elementCount);

source_code/SegMamba/monai/csrc/filtering/permutohedral/permutohedral_cuda.cu

@@ -0,0 +1,540 @@
+/*
+Copyright (c) MONAI Consortium
+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.
+*/
+
+/*
+Adapted from https://github.com/abadams/permutohedral
+which has the following license...
+
+MIT License
+
+Copyright (c) 2020 Andrew Adams
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/
+
+#define BLOCK_SIZE 32
+
+#include <cuda.h>
+#include <cuda_runtime.h>
+#include <stdio.h>
+#include <torch/extension.h>
+#include <THC/THCAtomics.cuh>
+
+#include "hash_table.cuh"
+#include "permutohedral.h"
+#include "utils/meta_macros.h"
+
+template <typename scalar_t>
+struct MatrixEntry {
+  int index;
+  scalar_t weight;
+};
+
+template <typename scalar_t, int pd>
+__global__ static void createMatrix(
+    const int elementCount,
+    const scalar_t* positions,
+    const scalar_t* values,
+    const scalar_t* scaleFactor,
+    MatrixEntry<scalar_t>* matrix) {
+  const int threadId = threadIdx.x;
+  const int idx = threadIdx.x + blockIdx.x * BLOCK_SIZE;
+  const bool outOfBounds = idx >= elementCount;
+
+  scalar_t myElevated[pd + 1];
+  const scalar_t* myPosition = positions + idx * pd;
+
+  int myGreedy[pd + 1];
+  int myRank[pd + 1];
+
+  scalar_t myBarycentric[pd + 2];
+  __shared__ short keys[pd * BLOCK_SIZE];
+  short* myKey = keys + threadId * pd;
+
+  if (!outOfBounds) {
+    myElevated[pd] = -pd * myPosition[pd - 1] * scaleFactor[pd - 1];
+
+    for (int i = pd - 1; i > 0; i--) {
+      myElevated[i] =
+          myElevated[i + 1] - i * (myPosition[i - 1]) * scaleFactor[i - 1] + (i + 2) * myPosition[i] * scaleFactor[i];
+    }
+
+    myElevated[0] = myElevated[1] + 2 * myPosition[0] * scaleFactor[0];
+
+    // find the closest zero-colored lattice point
+
+    // greedily search for the closest zero-colored lattice point
+    signed short sum = 0;
+
+    for (int i = 0; i <= pd; i++) {
+      scalar_t v = myElevated[i] * (1.0f / (pd + 1));
+      scalar_t up = ceilf(v) * (pd + 1);
+      scalar_t down = floorf(v) * (pd + 1);
+
+      myGreedy[i] = (signed short)(up - myElevated[i] < myElevated[i] - down ? up : down);
+      sum += myGreedy[i];
+    }
+
+    sum /= pd + 1;
+
+    // sort differential to find the permutation between this simplex and the canonical one
+    for (int i = 0; i <= pd; i++) {
+      myRank[i] = 0;
+
+      for (int j = 0; j <= pd; j++) {
+        scalar_t iDiff = myElevated[i] - myGreedy[i];
+        scalar_t jDiff = myElevated[j] - myGreedy[j];
+
+        if (iDiff < jDiff || (iDiff == jDiff && i > j)) {
+          myRank[i]++;
+        }
+      }
+    }
+
+    if (sum > 0) // sum too large, need to bring down the ones with the smallest differential
+    {
+      for (int i = 0; i <= pd; i++) {
+        if (myRank[i] >= pd + 1 - sum) {
+          myGreedy[i] -= (pd + 1);
+          myRank[i] += sum - (pd + 1);
+        } else {
+          myRank[i] += sum;
+        }
+      }
+    } else if (sum < 0) // sum too small, need to bring up the ones with largest differential
+    {
+      for (int i = 0; i <= pd; i++) {
+        if (myRank[i] < -sum) {
+          myGreedy[i] += (pd + 1);
+          myRank[i] += sum + (pd + 1);
+        } else {
+          myRank[i] += sum;
+        }
+      }
+    }
+
+#ifdef LINEAR_D_MEMORY
+    for (int i = 0; i <= pd; i++) {
+      table_zeros[idx * (pd + 1) + i] = myGreedy[i];
+      table_rank[idx * (pd + 1) + i] = myRank[i];
+    }
+#endif
+
+    // turn delta into barycentric coords
+    for (int i = 0; i <= pd + 1; i++) {
+      myBarycentric[i] = 0;
+    }
+
+    for (int i = 0; i <= pd; i++) {
+      scalar_t delta = (myElevated[i] - myGreedy[i]) * (1.0f / (pd + 1));
+      myBarycentric[pd - myRank[i]] += delta;
+      myBarycentric[pd + 1 - myRank[i]] -= delta;
+    }
+
+    myBarycentric[0] += 1.0f + myBarycentric[pd + 1];
+  }
+
+#ifdef USE_ADDITIVE_HASH
+  unsigned int cumulative_hash = hash<pd>(myGreedy);
+#endif
+
+  for (int color = 0; color <= pd; color++) {
+    // Compute the location of the lattice point explicitly (all but
+    // the last coordinate - it's redundant because they sum to zero)
+    if (!outOfBounds) {
+      for (int i = 0; i < pd; i++) {
+        myKey[i] = myGreedy[i] + color;
+
+        if (myRank[i] > pd - color) {
+          myKey[i] -= (pd + 1);
+        }
+      }
+    }
+
+#ifdef USE_ADDITIVE_HASH
+    for (int i = 0; i < pd; i++) {
+      if (myRank[i] == pd - color) {
+        cumulative_hash += hOffset[i];
+      }
+    }
+#endif
+
+    if (!outOfBounds) {
+      MatrixEntry<scalar_t> r;
+
+#ifdef USE_ADDITIVE_HASH
+      r.index = hashTableInsert<pd>(cumulative_hash, myKey, idx * (pd + 1) + color);
+#else
+      r.index = hashTableInsert<pd>(myKey, idx * (pd + 1) + color);
+#endif
+
+      r.weight = myBarycentric[color];
+      matrix[idx * (pd + 1) + color] = r;
+    }
+  }
+}
+
+template <typename scalar_t, int kd>
+__global__ static void cleanHashTable(const int elementCount, MatrixEntry<scalar_t>* matrix) {
+  const int idx = threadIdx.x + blockIdx.x * blockDim.x;
+
+  if (idx >= elementCount)
+    return;
+
+  // find my hash table entry
+  int* e = table_entries + idx;
+
+  // Check if I created my own key in the previous phase
+  if (*e >= 0) {
+    // Rehash my key and reset the pointer in order to merge with
+    // any other pixel that created a different entry under the
+    // same key. If the computation was serial this would never
+    // happen, but sometimes race conditions can make the same key
+    // be inserted twice. hashTableRetrieve always returns the
+    // earlier, so it's no problem as long as we rehash now.
+
+#ifdef LINEAR_D_MEMORY
+    // Get my key
+    short myKey[kd];
+    generateKey<kd>(*e, myKey);
+    *e = hashTableRetrieve<kd>(myKey);
+#else
+    *e = hashTableRetrieve<kd>(table_keys + *e * kd);
+#endif
+  }
+}
+
+template <typename scalar_t, int pd, int vd>
+__global__ static void splat(
+    const int elementCount,
+    scalar_t* values,
+    MatrixEntry<scalar_t>* matrix,
+    scalar_t* table_values) {
+  const int color = threadIdx.y;
+  const int idx = threadIdx.x + blockIdx.x * blockDim.x;
+
+  const bool outOfBounds = idx >= elementCount;
+
+  if (outOfBounds) {
+    return;
+  }
+
+  scalar_t* myValue = values + idx * vd;
+
+  MatrixEntry<scalar_t> r = matrix[idx * (pd + 1) + color];
+
+  matrix[idx * (pd + 1) + color].index = r.index = table_entries[r.index];
+  scalar_t* val = table_values + r.index * (vd + 1);
+
+  for (int j = 0; j < vd; j++) {
+    gpuAtomicAdd(val + j, myValue[j] * r.weight);
+  }
+
+  gpuAtomicAdd(val + vd, r.weight);
+}
+
+// splat splits by color, so extend the y coordinate to our blocks to represent that
+// dim3 oldblocks((w-1)/8+1, (h-1)/8+1, 1);
+// dim3 oldblockSize(8, 8, 1);
+// oldblocks.y *= pd+1;
+// splatCache<pd, vd><<<oldblocks, oldblockSize>>>(w, h, values, matrix);
+
+// int blockCount = (elementCount + 1) / BLOCK_SIZE + 1;
+// int blockSize = BLOCK_SIZE;
+
+// splatCache<pd, vd><<<dim3(blockCount, 1), dim3(blockSize, pd+1)>>>(elementCount, values, matrix);
+
+template <typename scalar_t, int pd, int vd>
+__global__ static void splatCache(
+    const int elementCount,
+    scalar_t* values,
+    MatrixEntry<scalar_t>* matrix,
+    scalar_t* table_values) {
+  // const int x = threadIdx.x + blockIdx.x * blockDim.x;
+  // const int y = threadIdx.y + (blockIdx.y/(pd+1)) * blockDim.y;
+
+  // const int threadId = threadIdx.y*blockDim.x + threadIdx.x;
+  // const int color = blockIdx.y % (pd+1);
+  // const int idx = y*w + x;
+
+  const int threadId = threadIdx.x;
+  const int color = threadIdx.y;
+  const int idx = threadIdx.x + blockIdx.x * BLOCK_SIZE;
+
+  const bool outOfBounds = idx >= elementCount;
+
+  __shared__ int sharedOffsets[BLOCK_SIZE];
+  __shared__ scalar_t sharedValues[BLOCK_SIZE * (vd + 1)];
+
+  int myOffset = -1;
+  scalar_t* myValue = sharedValues + threadId * (vd + 1);
+
+  if (!outOfBounds) {
+    scalar_t* value = values + idx * vd;
+
+    MatrixEntry<scalar_t> r = matrix[idx * (pd + 1) + color];
+
+    // convert the matrix entry from a pointer into the entries array to a pointer into the keys/values array
+    matrix[idx * (pd + 1) + color].index = r.index = table_entries[r.index];
+    // record the offset into the keys/values array in shared space
+    myOffset = sharedOffsets[threadId] = r.index * (vd + 1);
+
+    for (int j = 0; j < vd; j++) {
+      myValue[j] = value[j] * r.weight;
+    }
+    myValue[vd] = r.weight;
+
+  } else {
+    sharedOffsets[threadId] = -1;
+  }
+
+  __syncthreads();
+
+  // am I the first thread in this block to care about this key?
+
+  if (outOfBounds)
+    return;
+
+  for (int i = 0; i < BLOCK_SIZE; i++) {
+    if (i < threadId) {
+      if (myOffset == sharedOffsets[i]) {
+        // somebody else with higher priority cares about this key
+        return;
+      }
+    } else if (i > threadId) {
+      if (myOffset == sharedOffsets[i]) {
+        // someone else with lower priority cares about this key, accumulate it into mine
+        for (int j = 0; j <= vd; j++) {
+          sharedValues[threadId * (vd + 1) + j] += sharedValues[i * (vd + 1) + j];
+        }
+      }
+    }
+  }
+
+  // only the threads with something to write to main memory are still going
+  scalar_t* val = table_values + myOffset;
+  for (int j = 0; j <= vd; j++) {
+    gpuAtomicAdd(val + j, myValue[j]);
+  }
+}
+
+template <typename scalar_t, int pd, int vd>
+__global__ static void blur(
+    int n,
+    scalar_t* newValues,
+    MatrixEntry<scalar_t>* matrix,
+    int color,
+    scalar_t* table_values) {
+  const int idx = (blockIdx.y * gridDim.x + blockIdx.x) * blockDim.x * blockDim.y + threadIdx.x;
+
+  if (idx >= n)
+    return;
+
+  // Check if I'm valid
+  if (matrix[idx].index != idx)
+    return;
+
+  // find my key and the keys of my neighbours
+  short myKey[pd + 1];
+  short np[pd + 1];
+  short nm[pd + 1];
+
+#ifdef LINEAR_D_MEMORY
+  generateKey<pd>(idx, myKey);
+  for (int i = 0; i < pd; i++) {
+    np[i] = myKey[i] + 1;
+    nm[i] = myKey[i] - 1;
+  }
+#else
+  for (int i = 0; i < pd; i++) {
+    myKey[i] = table_keys[idx * pd + i];
+    np[i] = myKey[i] + 1;
+    nm[i] = myKey[i] - 1;
+  }
+#endif
+
+  np[color] -= pd + 1;
+  nm[color] += pd + 1;
+
+#ifdef USE_ADDITIVE_HASH
+  unsigned int hCurrent = hash<pd>(myKey);
+  int offNp = hashTableRetrieveWithHash<pd>(hCurrent + hOffset[color], np);
+  int offNm = hashTableRetrieveWithHash<pd>(hCurrent - hOffset[color], nm);
+#else
+  int offNp = hashTableRetrieve<pd>(np);
+  int offNm = hashTableRetrieve<pd>(nm);
+#endif
+
+  scalar_t* valMe = table_values + (vd + 1) * idx;
+  scalar_t* valNp = table_values + (vd + 1) * offNp;
+  scalar_t* valNm = table_values + (vd + 1) * offNm;
+  scalar_t* valOut = newValues + (vd + 1) * idx;
+
+  if (offNp >= 0 && offNm >= 0) {
+    for (int i = 0; i <= vd; i++) {
+      valOut[i] = (valNp[i] + (valMe[i] * 2) + valNm[i]) / 4;
+    }
+  } else if (offNp >= 0) {
+    for (int i = 0; i <= vd; i++) {
+      valOut[i] = (valNp[i] + (valMe[i] * 2)) / 4;
+    }
+  } else if (offNm >= 0) {
+    for (int i = 0; i <= vd; i++) {
+      valOut[i] = (valNm[i] + (valMe[i] * 2)) / 4;
+    }
+  } else {
+    for (int i = 0; i <= vd; i++) {
+      valOut[i] = valMe[i] * 2;
+    }
+  }
+}
+
+template <typename scalar_t, int pd, int vd>
+__global__ static void slice(
+    const int elementCount,
+    scalar_t* values,
+    MatrixEntry<scalar_t>* matrix,
+    scalar_t* table_values) {
+  const int threadId = threadIdx.x;
+  const int idx = threadIdx.x + blockIdx.x * BLOCK_SIZE;
+  const bool outOfBounds = idx >= elementCount;
+
+  if (outOfBounds)
+    return;
+
+  __shared__ scalar_t localValue[BLOCK_SIZE * vd];
+
+  scalar_t* myValue = localValue + threadId * vd;
+  scalar_t myWeight = 0;
+
+  for (int i = 0; i < vd; i++) {
+    myValue[i] = 0;
+  }
+
+  for (int i = 0; i <= pd; i++) {
+    MatrixEntry<scalar_t> r = matrix[idx * (pd + 1) + i];
+    scalar_t* val = table_values + r.index * (vd + 1);
+
+    for (int j = 0; j < vd; j++) {
+      myValue[j] += r.weight * val[j];
+    }
+
+    myWeight += r.weight * val[vd];
+  }
+
+  myWeight = 1.0f / myWeight;
+
+  for (int j = 0; j < vd; j++) {
+    values[idx * vd + j] = myValue[j] * myWeight;
+  }
+}
+
+template <typename scalar_t, int vd, int pd>
+void PermutohedralCuda(scalar_t* values, scalar_t* positions, int elementCount, bool accurate) {
+  scalar_t blurVariance = accurate ? 0.5 : 0;
+
+  scalar_t* scaleFactor;
+  cudaMalloc(&scaleFactor, pd * sizeof(scalar_t));
+
+  scalar_t scaleFactorHost[pd];
+  for (int i = 0; i < pd; i++) {
+    scaleFactorHost[i] = (pd + 1) * sqrtf((1.0 / 6 + blurVariance) / ((i + 1) * (i + 2)));
+  }
+
+  cudaMemcpy(scaleFactor, scaleFactorHost, pd * sizeof(scalar_t), cudaMemcpyHostToDevice);
+
+  MatrixEntry<scalar_t>* matrix;
+  cudaMalloc(&matrix, elementCount * (pd + 1) * sizeof(MatrixEntry<scalar_t>));
+
+  scalar_t* table_values = createHashTable<scalar_t, pd, vd + 1>(elementCount * (pd + 1));
+
+  // Populate constant memory for hash helpers
+  unsigned long long int __host_two32 = ((unsigned long long int)1) << 32;
+  unsigned int __host_div_c = 2 * (elementCount * (pd + 1));
+  unsigned int __host_div_l = ceilf(logf((float)__host_div_c) / logf(2.0f));
+  unsigned int __host_div_m = (__host_two32 << __host_div_l) / __host_div_c - __host_two32 + 1;
+  cudaMemcpyToSymbol(__div_c, &__host_div_c, sizeof(unsigned int));
+  cudaMemcpyToSymbol(__div_l, &__host_div_l, sizeof(unsigned int));
+  cudaMemcpyToSymbol(__div_m, &__host_div_m, sizeof(unsigned int));
+
+  // Populate constant memory with hash of offset vectors
+  unsigned int hOffset_host[pd + 1];
+  signed short offset[pd + 1];
+  for (int i = 0; i < pd; offset[i] = 1, i++)
+    ;
+  for (int i = 0; i <= pd; i++) {
+    offset[i] -= pd + 1;
+    hOffset_host[i] = hash<pd>(offset);
+    offset[i] += pd + 1;
+  }
+  cudaMemcpyToSymbol(hOffset, &hOffset_host, sizeof(unsigned int) * (pd + 1));
+
+  int blockCount = (elementCount + 1) / BLOCK_SIZE + 1;
+  int blockSize = BLOCK_SIZE;
+
+  createMatrix<scalar_t, pd><<<blockCount, blockSize>>>(elementCount, positions, values, scaleFactor, matrix);
+
+  // fix duplicate hash table entries
+  int tableSize = elementCount * 2 * (pd + 1);
+  int cleanBlockSize = 32;
+  int cleanBlocks = (tableSize - 1) / cleanBlockSize + 1;
+
+  cleanHashTable<scalar_t, pd><<<cleanBlocks, cleanBlockSize>>>(tableSize, matrix);
+
+  splat<scalar_t, pd, vd><<<dim3(blockCount, 1), dim3(blockSize, pd + 1)>>>(elementCount, values, matrix, table_values);
+
+  if (accurate) {
+    scalar_t* newValues;
+    cudaMalloc(&newValues, elementCount * (pd + 1) * (vd + 1) * sizeof(scalar_t));
+    cudaMemset(newValues, 0, elementCount * (pd + 1) * (vd + 1) * sizeof(scalar_t));
+
+    for (int color = 0; color <= pd; color++) {
+      blur<scalar_t, pd, vd>
+          <<<cleanBlocks, cleanBlockSize>>>(elementCount * (pd + 1), newValues, matrix, color, table_values);
+
+      scalar_t* swap = newValues;
+      newValues = table_values;
+      table_values = swap;
+    }
+
+    cudaFree(newValues);
+  }
+
+  slice<scalar_t, pd, vd><<<blockCount, blockSize>>>(elementCount, values, matrix, table_values);
+
+  destroyHashTable<scalar_t>();
+  cudaFree(table_values);
+  cudaFree(scaleFactor);
+  cudaFree(matrix);
+}
+
+#define DECLARATION(dc, fc)                                                                                         \
+  template void PermutohedralCuda<float, dc, fc>(float* values, float* positions, int elementCount, bool accurate); \
+  template void PermutohedralCuda<double, dc, fc>(double* values, double* positions, int elementCount, bool accurate);
+DO_FOR_AB(DECLARATION, 16, 19)

source_code/SegMamba/monai/csrc/filtering/trainable_bilateral/bf_layer_cpu_backward.cpp

@@ -0,0 +1,232 @@
+/*
+Copyright (c) MONAI Consortium
+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.
+
+=========================================================================
+Adapted from https://github.com/faebstn96/trainable-bilateral-filter-source
+which has the following license...
+https://github.com/faebstn96/trainable-bilateral-filter-source/blob/main/LICENSE.md
+
+Copyright 2022 Fabian Wagner, Pattern Recognition Lab, FAU Erlangen-Nuernberg, Erlangen, Germany
+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.
+*/
+
+#include "trainable_bilateral.h"
+#include "utils/tensor_description.h"
+#include "utils/tensor_indexing.h"
+
+template <typename scalar_t>
+void BilateralFilterCpuBackward_3d(
+    torch::Tensor gradientInputTensor,
+    torch::Tensor gradientOutputTensor,
+    torch::Tensor inputTensor,
+    torch::Tensor outputTensor,
+    torch::Tensor outputWeightsTensor,
+    torch::Tensor dO_dx_ki,
+    float sigma_x,
+    float sigma_y,
+    float sigma_z,
+    float colorSigma) {
+  // Getting tensor description.
+  TensorDescription desc = TensorDescription(gradientInputTensor);
+
+  // Raw tensor data pointers.
+  scalar_t* gradientInputTensorData = gradientInputTensor.data_ptr<scalar_t>();
+  scalar_t* gradientOutputTensorData = gradientOutputTensor.data_ptr<scalar_t>();
+  scalar_t* inputTensorData = inputTensor.data_ptr<scalar_t>();
+  scalar_t* outputTensorData = outputTensor.data_ptr<scalar_t>();
+  scalar_t* outputWeightsTensorData = outputWeightsTensor.data_ptr<scalar_t>();
+  scalar_t* dO_dx_kiData = dO_dx_ki.data_ptr<scalar_t>();
+
+  // Pre-calculate common values
+  int windowSize_x = std::max(((int)ceil(5.0f * sigma_x) | 1), 5); // ORing last bit to ensure odd window size
+  int windowSize_y = std::max(((int)ceil(5.0f * sigma_y) | 1), 5); // ORing last bit to ensure odd window size
+  int windowSize_z = std::max(((int)ceil(5.0f * sigma_z) | 1), 5); // ORing last bit to ensure odd window size
+  int halfWindowSize_x = floor(0.5f * windowSize_x);
+  int halfWindowSize_y = floor(0.5f * windowSize_y);
+  int halfWindowSize_z = floor(0.5f * windowSize_z);
+  int halfWindowSize_arr[] = {halfWindowSize_x, halfWindowSize_y, halfWindowSize_z};
+  scalar_t spatialExpConstant_x = -1.0f / (2 * sigma_x * sigma_x);
+  scalar_t spatialExpConstant_y = -1.0f / (2 * sigma_y * sigma_y);
+  scalar_t spatialExpConstant_z = -1.0f / (2 * sigma_z * sigma_z);
+  scalar_t colorExpConstant = -1.0f / (2 * colorSigma * colorSigma);
+
+  // Set kernel sizes with respect to the defined spatial sigmas.
+  int* kernelSizes = new int[desc.dimensions];
+
+  kernelSizes[0] = windowSize_x;
+  kernelSizes[1] = windowSize_y;
+  kernelSizes[2] = windowSize_z;
+
+  // Pre-calculate gaussian kernel and distance map in 1D.
+  scalar_t* gaussianKernel_x = new scalar_t[windowSize_x];
+  scalar_t* gaussianKernel_y = new scalar_t[windowSize_y];
+  scalar_t* gaussianKernel_z = new scalar_t[windowSize_z];
+  scalar_t* xDistanceSquared = new scalar_t[windowSize_x];
+  scalar_t* yDistanceSquared = new scalar_t[windowSize_y];
+  scalar_t* zDistanceSquared = new scalar_t[windowSize_z];
+
+  for (int i = 0; i < windowSize_x; i++) {
+    int distance = i - halfWindowSize_x;
+    gaussianKernel_x[i] = exp(distance * distance * spatialExpConstant_x);
+    xDistanceSquared[i] = distance * distance;
+  }
+  for (int i = 0; i < windowSize_y; i++) {
+    int distance = i - halfWindowSize_y;
+    gaussianKernel_y[i] = exp(distance * distance * spatialExpConstant_y);
+    yDistanceSquared[i] = distance * distance;
+  }
+  for (int i = 0; i < windowSize_z; i++) {
+    int distance = i - halfWindowSize_z;
+    gaussianKernel_z[i] = exp(distance * distance * spatialExpConstant_z);
+    zDistanceSquared[i] = distance * distance;
+  }
+
+  // Looping over the batches
+  for (int b = 0; b < desc.batchCount; b++) {
+    int batchOffset = b * desc.batchStride;
+
+    // Looping over all dimensions for the home element
+    for (int z = 0; z < desc.sizes[2]; z++)
+#pragma omp parallel for
+      for (int y = 0; y < desc.sizes[1]; y++) {
+        for (int x = 0; x < desc.sizes[0]; x++) {
+          // Calculating indexing offset for the home element
+          int homeOffset = batchOffset;
+
+          int homeIndex[] = {x, y, z};
+          homeOffset += x * desc.strides[0];
+          homeOffset += y * desc.strides[1];
+          homeOffset += z * desc.strides[2];
+
+          // Zero kernel aggregates.
+          scalar_t filter_kernel = 0;
+          scalar_t valueSum = 0;
+
+          // Looping over all dimensions for the neighbour element
+          Indexer kernelIndex = Indexer(desc.dimensions, kernelSizes);
+          do // while(kernelIndex++)
+          {
+            // Calculating buffer offset for the neighbour element
+            // Index is clamped to the border in each dimension.
+            int neighbourOffset = batchOffset;
+            bool flagNotClamped = true;
+
+            for (int i = 0; i < desc.dimensions; i++) {
+              int neighbourIndex = homeIndex[i] + kernelIndex[i] - halfWindowSize_arr[i];
+              int neighbourIndexClamped = std::min(desc.sizes[i] - 1, std::max(0, neighbourIndex));
+              neighbourOffset += neighbourIndexClamped * desc.strides[i];
+              if (neighbourIndex != neighbourIndexClamped) {
+                flagNotClamped = false;
+              }
+            }
+
+            // Euclidean color distance.
+            scalar_t colorDistance = 0;
+            scalar_t colorDistanceSquared = 0;
+
+            for (int i = 0; i < desc.channelCount; i++) {
+              scalar_t diff = inputTensorData[neighbourOffset + i * desc.channelStride] -
+                  inputTensorData[homeOffset +
+                                  i * desc.channelStride]; // Be careful: Here it is (X_k - X_i) and not (X_i - X_q)
+              colorDistance += diff; // Do not take the absolute value here. Be careful with the signs.
+              colorDistanceSquared += diff * diff;
+            }
+
+            // Calculating and combining the spatial
+            // and color weights.
+            scalar_t spatialWeight = 1;
+
+            spatialWeight =
+                gaussianKernel_x[kernelIndex[0]] * gaussianKernel_y[kernelIndex[1]] * gaussianKernel_z[kernelIndex[2]];
+
+            scalar_t colorWeight = exp(colorDistanceSquared * colorExpConstant);
+            scalar_t totalWeight = spatialWeight * colorWeight;
+
+            // Aggregating values. Only do this if flagNotClamped: Pixels outside the image are disregarded.
+            if (flagNotClamped) {
+              for (int i = 0; i < desc.channelCount; i++) {
+                // Distinguish cases for k!=i (calculation is done here)
+                // and k==i (partial derivatives are precalculated).
+                // If statement replaces center element of neighborhood/kernel.
+                if (kernelIndex[0] != halfWindowSize_x || kernelIndex[1] != halfWindowSize_y ||
+                    kernelIndex[2] != halfWindowSize_z) {
+                  filter_kernel = -(1 / outputWeightsTensorData[neighbourOffset + i * desc.channelStride]) *
+                          outputTensorData[neighbourOffset + i * desc.channelStride] * totalWeight * colorDistance /
+                          (colorSigma * colorSigma) +
+                      (1 / outputWeightsTensorData[neighbourOffset + i * desc.channelStride]) * totalWeight *
+                          (1 +
+                           inputTensorData[homeOffset + i * desc.channelStride] * colorDistance /
+                               (colorSigma * colorSigma)); // inputTensorData[homeOffset] !!
+                } else {
+                  filter_kernel = dO_dx_kiData[homeOffset + i * desc.channelStride];
+                }
+
+                valueSum += gradientInputTensorData[neighbourOffset + i * desc.channelStride] * filter_kernel;
+              }
+            }
+          } while (kernelIndex++);
+
+          // Do the filtering and calculate the values for the backward pass.
+          for (int i = 0; i < desc.channelCount; i++) {
+            // Filtering:
+            gradientOutputTensorData[homeOffset + i * desc.channelStride] = valueSum;
+          }
+        }
+      }
+  }
+
+  delete[] kernelSizes;
+  delete[] gaussianKernel_x;
+  delete[] gaussianKernel_y;
+  delete[] gaussianKernel_z;
+  delete[] xDistanceSquared;
+  delete[] yDistanceSquared;
+  delete[] zDistanceSquared;
+}
+
+torch::Tensor BilateralFilterCpuBackward(
+    torch::Tensor gradientInputTensor,
+    torch::Tensor inputTensor,
+    torch::Tensor outputTensor,
+    torch::Tensor outputWeightsTensor,
+    torch::Tensor dO_dx_ki,
+    float sigma_x,
+    float sigma_y,
+    float sigma_z,
+    float colorSigma) {
+  // Preparing output tensor.
+  torch::Tensor gradientOutputTensor = torch::zeros_like(gradientInputTensor);
+
+  AT_DISPATCH_FLOATING_TYPES_AND_HALF(gradientInputTensor.scalar_type(), "BilateralFilterCpuBackward_3d", ([&] {
+                                        BilateralFilterCpuBackward_3d<scalar_t>(
+                                            gradientInputTensor,
+                                            gradientOutputTensor,
+                                            inputTensor,
+                                            outputTensor,
+                                            outputWeightsTensor,
+                                            dO_dx_ki,
+                                            sigma_x,
+                                            sigma_y,
+                                            sigma_z,
+                                            colorSigma);
+                                      }));
+
+  return gradientOutputTensor;
+}

source_code/SegMamba/monai/csrc/filtering/trainable_bilateral/bf_layer_gpu_backward.cu

@@ -0,0 +1,296 @@
+/*
+Copyright (c) MONAI Consortium
+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.
+
+=========================================================================
+Adapted from https://github.com/faebstn96/trainable-bilateral-filter-source
+which has the following license...
+https://github.com/faebstn96/trainable-bilateral-filter-source/blob/main/LICENSE.md
+
+Copyright 2022 Fabian Wagner, Pattern Recognition Lab, FAU Erlangen-Nuernberg, Erlangen, Germany
+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.
+*/
+
+#include <cuda.h>
+#include <cuda_runtime.h>
+
+#include "trainable_bilateral.h"
+//#include "../utils/cuda_error_check.h"
+#include "utils/meta_macros.h"
+#include "utils/tensor_description.h"
+
+__constant__ int cBatchStrideBack;
+__constant__ int cColorStrideBack;
+
+__constant__ int cSizesBack[3];
+__constant__ int cStridesBack[3];
+
+__constant__ int cKernelSizesBack[3];
+__constant__ int cHalfWindowSize_arrBack[3];
+__constant__ float cGaussianKernel_xBack[256];
+__constant__ float cGaussianKernel_yBack[256];
+__constant__ float cGaussianKernel_zBack[256];
+__constant__ float cXDistanceSquaredBack[256];
+__constant__ float cYDistanceSquaredBack[256];
+__constant__ float cZDistanceSquaredBack[256];
+__constant__ float cColorExponentConstantBack;
+__constant__ float cSigma_xBack;
+__constant__ float cSigma_yBack;
+__constant__ float cSigma_zBack;
+__constant__ float cColorSigmaBack;
+
+template <typename scalar_t, int C>
+__global__ void BilateralFilterCudaKernel3DBackward(
+    scalar_t* gradientInputTensor,
+    scalar_t* gradientOutputTensor,
+    scalar_t* inputTensor,
+    scalar_t* outputTensor,
+    scalar_t* outputWeightsTensor,
+    scalar_t* dO_dx_ki) {
+  int homeOffset = blockIdx.x * blockDim.x + threadIdx.x;
+  int batchOffset = blockIdx.y * cBatchStrideBack;
+
+  if (homeOffset >= cColorStrideBack)
+    return;
+
+  int homeX = homeOffset / cStridesBack[0];
+  int homeY = (homeOffset - homeX * cStridesBack[0]) / cStridesBack[1];
+  int homeZ = (homeOffset - homeX * cStridesBack[0] - homeY * cStridesBack[1]) / cStridesBack[2];
+  int homeIndex[] = {homeX, homeY, homeZ};
+
+  // Zero kernel aggregates.
+  scalar_t valueSum = 0;
+
+  for (int kernelX = 0; kernelX < cKernelSizesBack[0]; kernelX++) {
+    int neighbourX = max(0, min(homeX + (kernelX - cHalfWindowSize_arrBack[0]), cSizesBack[0] - 1));
+    scalar_t gaussianX = cGaussianKernel_xBack[kernelX];
+
+    for (int kernelY = 0; kernelY < cKernelSizesBack[1]; kernelY++) {
+      int neighbourY = max(0, min(homeY + (kernelY - cHalfWindowSize_arrBack[1]), cSizesBack[1] - 1));
+      scalar_t gaussianY = cGaussianKernel_yBack[kernelY];
+
+      for (int kernelZ = 0; kernelZ < cKernelSizesBack[2]; kernelZ++) {
+        int neighbourZ = max(0, min(homeZ + (kernelZ - cHalfWindowSize_arrBack[2]), cSizesBack[2] - 1));
+        scalar_t gaussianZ = cGaussianKernel_zBack[kernelZ];
+
+        int neighbourOffset = neighbourX * cStridesBack[0] + neighbourY * cStridesBack[1] + neighbourZ;
+
+        bool flagNotClamped = true;
+        int kernelIndex[] = {kernelX, kernelY, kernelZ};
+        int dimensions = 3; // Must equal the number of spatial dimensions.
+
+        for (int i = 0; i < dimensions; i++) {
+          int HalfWindowSizeBack = cHalfWindowSize_arrBack[i]; // Define constant memory as new variable here (!!),
+                                                               // otherwise: cudaErrorMisalignedAddress
+          int neighbourIndex = homeIndex[i] + kernelIndex[i] - HalfWindowSizeBack;
+          int neighbourIndexClamped = min(cSizesBack[i] - 1, max(0, neighbourIndex));
+          if (neighbourIndex != neighbourIndexClamped) {
+            flagNotClamped = false;
+          }
+        }
+
+        scalar_t colorDistance = 0;
+        scalar_t colorDistanceSquared = 0;
+
+#pragma unroll
+        for (int c = 0; c < C; c++) {
+          scalar_t a = inputTensor[batchOffset + neighbourOffset + c * cColorStrideBack];
+          scalar_t b = inputTensor[batchOffset + homeOffset + c * cColorStrideBack]; // Be careful: Here it is (X_k -
+                                                                                     // X_i) and not (X_i - X_q)
+          scalar_t diff = a - b;
+          colorDistance += diff; // Do not take the absolute value here. Be careful with the signs.
+          colorDistanceSquared += diff * diff;
+        }
+
+        scalar_t spatialWeight = gaussianX * gaussianY * gaussianZ;
+        scalar_t colorWeight = exp(cColorExponentConstantBack * colorDistanceSquared);
+        scalar_t totalWeight = spatialWeight * colorWeight;
+
+        // Aggregating values. Only do this if flagNotClamped: Pixels outside the image are disregarded.
+        if (flagNotClamped) {
+          scalar_t filter_kernel_back;
+
+#pragma unroll
+          for (int c = 0; c < C; c++) {
+            // Distinguish cases for k!=i (calculation is done here)
+            // and k==i (partial derivatives are precalculated).
+            // If statement replaces center element of neighborhood/kernel.
+            if (kernelX != cHalfWindowSize_arrBack[0] || kernelY != cHalfWindowSize_arrBack[1] ||
+                kernelZ != cHalfWindowSize_arrBack[2]) {
+              filter_kernel_back = -(1 / outputWeightsTensor[batchOffset + neighbourOffset + c * cColorStrideBack]) *
+                      outputTensor[batchOffset + neighbourOffset + c * cColorStrideBack] * totalWeight * colorDistance /
+                      (cColorSigmaBack * cColorSigmaBack) +
+                  (1 / outputWeightsTensor[batchOffset + neighbourOffset + c * cColorStrideBack]) * totalWeight *
+                      (1 +
+                       inputTensor[batchOffset + homeOffset + c * cColorStrideBack] * colorDistance /
+                           (cColorSigmaBack * cColorSigmaBack)); // inputTensorData[homeOffset] !!
+            } else {
+              filter_kernel_back = dO_dx_ki[batchOffset + homeOffset + c * cColorStrideBack];
+            }
+
+            valueSum += gradientInputTensor[batchOffset + neighbourOffset + c * cColorStrideBack] * filter_kernel_back;
+          }
+        }
+      }
+    }
+  }
+
+#pragma unroll
+  for (int c = 0; c < C; c++) {
+    gradientOutputTensor[batchOffset + homeOffset + c * cColorStrideBack] = valueSum;
+  }
+}
+
+template <int C, int D>
+void BilateralFilterCudaBackwardFunction(
+    torch::Tensor gradientInputTensor,
+    torch::Tensor gradientOutputTensor,
+    torch::Tensor inputTensor,
+    torch::Tensor outputTensor,
+    torch::Tensor outputWeightsTensor,
+    torch::Tensor dO_dx_ki,
+    float sigma_x,
+    float sigma_y,
+    float sigma_z,
+    float colorSigma) {
+  // Getting tensor description.
+  TensorDescription desc = TensorDescription(inputTensor);
+
+  // Pre-calculating gaussian kernel.
+  int windowSize_x = std::max(((int)ceil(5.0f * sigma_x) | 1), 5); // ORing last bit to ensure odd window size
+  int windowSize_y = std::max(((int)ceil(5.0f * sigma_y) | 1), 5); // ORing last bit to ensure odd window size
+  int windowSize_z = std::max(((int)ceil(5.0f * sigma_z) | 1), 5); // ORing last bit to ensure odd window size
+  int halfWindowSize_x = floor(0.5f * windowSize_x);
+  int halfWindowSize_y = floor(0.5f * windowSize_y);
+  int halfWindowSize_z = floor(0.5f * windowSize_z);
+  int halfWindowSize_arr[] = {halfWindowSize_x, halfWindowSize_y, halfWindowSize_z};
+  float spatialExpConstant_x = -1.0f / (2 * sigma_x * sigma_x);
+  float spatialExpConstant_y = -1.0f / (2 * sigma_y * sigma_y);
+  float spatialExpConstant_z = -1.0f / (2 * sigma_z * sigma_z);
+  float colorExpConstant = -1.0f / (2 * colorSigma * colorSigma);
+
+  int* kernelSizes = new int[desc.dimensions];
+  kernelSizes[0] = windowSize_x;
+  kernelSizes[1] = windowSize_y;
+  kernelSizes[2] = windowSize_z;
+
+  auto* gaussianKernel_x = new float[windowSize_x];
+  auto* gaussianKernel_y = new float[windowSize_y];
+  auto* gaussianKernel_z = new float[windowSize_z];
+  auto* xDistanceSquared = new float[windowSize_x];
+  auto* yDistanceSquared = new float[windowSize_y];
+  auto* zDistanceSquared = new float[windowSize_z];
+
+  for (int i = 0; i < windowSize_x; i++) {
+    int distance = i - halfWindowSize_x;
+    gaussianKernel_x[i] = exp(distance * distance * spatialExpConstant_x);
+    xDistanceSquared[i] = distance * distance;
+  }
+  for (int i = 0; i < windowSize_y; i++) {
+    int distance = i - halfWindowSize_y;
+    gaussianKernel_y[i] = exp(distance * distance * spatialExpConstant_y);
+    yDistanceSquared[i] = distance * distance;
+  }
+  for (int i = 0; i < windowSize_z; i++) {
+    int distance = i - halfWindowSize_z;
+    gaussianKernel_z[i] = exp(distance * distance * spatialExpConstant_z);
+    zDistanceSquared[i] = distance * distance;
+  }
+
+  // Writing constant memory.
+  cudaMemcpyToSymbol(cBatchStrideBack, &desc.batchStride, sizeof(int));
+  cudaMemcpyToSymbol(cColorStrideBack, &desc.channelStride, sizeof(int));
+  cudaMemcpyToSymbol(cSizesBack, desc.sizes, sizeof(int) * 3);
+  cudaMemcpyToSymbol(cStridesBack, desc.strides, sizeof(int) * 3);
+  cudaMemcpyToSymbol(cKernelSizesBack, kernelSizes, sizeof(int) * desc.dimensions);
+  cudaMemcpyToSymbol(cHalfWindowSize_arrBack, halfWindowSize_arr, sizeof(int) * desc.dimensions);
+  cudaMemcpyToSymbol(cGaussianKernel_xBack, gaussianKernel_x, sizeof(float) * windowSize_x);
+  cudaMemcpyToSymbol(cGaussianKernel_yBack, gaussianKernel_y, sizeof(float) * windowSize_y);
+  cudaMemcpyToSymbol(cGaussianKernel_zBack, gaussianKernel_z, sizeof(float) * windowSize_z);
+  cudaMemcpyToSymbol(cXDistanceSquaredBack, xDistanceSquared, sizeof(float) * windowSize_x);
+  cudaMemcpyToSymbol(cYDistanceSquaredBack, yDistanceSquared, sizeof(float) * windowSize_y);
+  cudaMemcpyToSymbol(cZDistanceSquaredBack, zDistanceSquared, sizeof(float) * windowSize_z);
+  cudaMemcpyToSymbol(cColorExponentConstantBack, &colorExpConstant, sizeof(float));
+  cudaMemcpyToSymbol(cSigma_xBack, &sigma_x, sizeof(float));
+  cudaMemcpyToSymbol(cSigma_yBack, &sigma_y, sizeof(float));
+  cudaMemcpyToSymbol(cSigma_zBack, &sigma_z, sizeof(float));
+  cudaMemcpyToSymbol(cColorSigmaBack, &colorSigma, sizeof(float));
+
+  //  cuda_error_check("Cuda check before kernel call.");
+
+#define BLOCK_SIZE 32
+
+  AT_DISPATCH_FLOATING_TYPES_AND_HALF(
+      inputTensor.scalar_type(), "BilateralFilterCudaKernel3DBackward", ([&] {
+        BilateralFilterCudaKernel3DBackward<scalar_t, C>
+            <<<dim3(int(desc.channelStride / BLOCK_SIZE) + 1, desc.batchCount), dim3(BLOCK_SIZE, 1)>>>(
+                gradientInputTensor.data_ptr<scalar_t>(),
+                gradientOutputTensor.data_ptr<scalar_t>(),
+                inputTensor.data_ptr<scalar_t>(),
+                outputTensor.data_ptr<scalar_t>(),
+                outputWeightsTensor.data_ptr<scalar_t>(),
+                dO_dx_ki.data_ptr<scalar_t>());
+      }));
+
+  //  cuda_error_check("Cuda check after kernel call.");
+  //  delete[] kernel;
+  delete[] kernelSizes;
+  delete[] gaussianKernel_x;
+  delete[] gaussianKernel_y;
+  delete[] gaussianKernel_z;
+  delete[] xDistanceSquared;
+  delete[] yDistanceSquared;
+  delete[] zDistanceSquared;
+}
+
+// Function to choose template implementation based on dynamic, channels and dimensions
+torch::Tensor BilateralFilterCudaBackward(
+    torch::Tensor gradientInputTensor,
+    torch::Tensor inputTensor,
+    torch::Tensor outputTensor,
+    torch::Tensor outputWeightsTensor,
+    torch::Tensor dO_dx_ki,
+    float sigma_x,
+    float sigma_y,
+    float sigma_z,
+    float colorSigma) {
+  torch::Tensor gradientOutputTensor = torch::zeros_like(gradientInputTensor);
+  //  cuda_error_check("beginning");
+
+#define CASE(c, d)                           \
+  BilateralFilterCudaBackwardFunction<c, d>( \
+      gradientInputTensor,                   \
+      gradientOutputTensor,                  \
+      inputTensor,                           \
+      outputTensor,                          \
+      outputWeightsTensor,                   \
+      dO_dx_ki,                              \
+      sigma_x,                               \
+      sigma_y,                               \
+      sigma_z,                               \
+      colorSigma);
+  SWITCH_AB(
+      CASE,
+      BF_CUDA_MAX_CHANNELS,
+      BF_CUDA_MAX_SPATIAL_DIMENSION,
+      gradientInputTensor.size(1),
+      gradientInputTensor.dim() - 2);
+
+  return gradientOutputTensor;
+}

source_code/SegMamba/monai/csrc/filtering/trainable_bilateral/trainable_bilateral.cpp

@@ -0,0 +1,121 @@
+/*
+Copyright (c) MONAI Consortium
+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.
+
+=========================================================================
+Adapted from https://github.com/faebstn96/trainable-bilateral-filter-source
+which has the following license...
+https://github.com/faebstn96/trainable-bilateral-filter-source/blob/main/LICENSE.md
+
+Copyright 2022 Fabian Wagner, Pattern Recognition Lab, FAU Erlangen-Nuernberg, Erlangen, Germany
+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.
+*/
+
+#include <torch/extension.h>
+#include <stdexcept>
+#include <string>
+
+#include "trainable_bilateral.h"
+#include "utils/common_utils.h"
+
+std::tuple<torch::Tensor, torch::Tensor, torch::Tensor, torch::Tensor, torch::Tensor, torch::Tensor, torch::Tensor>
+TrainableBilateralFilterForward(
+    torch::Tensor inputTensor,
+    float sigma_x,
+    float sigma_y,
+    float sigma_z,
+    float colorSigma) {
+  std::tuple<torch::Tensor, torch::Tensor, torch::Tensor, torch::Tensor, torch::Tensor, torch::Tensor, torch::Tensor> (
+      *filterFunction)(torch::Tensor, float, float, float, float);
+
+#ifdef WITH_CUDA
+
+  if (torch::cuda::is_available() && inputTensor.is_cuda()) {
+    CHECK_CONTIGUOUS_CUDA(inputTensor);
+
+    if (inputTensor.size(1) > BF_CUDA_MAX_CHANNELS) {
+      throw std::runtime_error(
+          "Bilateral filtering not implemented for channel count > " + std::to_string(BF_CUDA_MAX_CHANNELS));
+    }
+
+    if (inputTensor.dim() - 2 > BF_CUDA_MAX_SPATIAL_DIMENSION) {
+      throw std::runtime_error(
+          "Bilateral filtering not implemented for spatial dimension > " +
+          std::to_string(BF_CUDA_MAX_SPATIAL_DIMENSION));
+    }
+
+    filterFunction = &BilateralFilterCudaForward;
+  } else {
+    filterFunction = &BilateralFilterCpuForward;
+  }
+#else
+  filterFunction = &BilateralFilterCpuForward;
+#endif
+
+  return filterFunction(inputTensor, sigma_x, sigma_y, sigma_z, colorSigma);
+}
+
+torch::Tensor TrainableBilateralFilterBackward(
+    torch::Tensor gradientInputTensor,
+    torch::Tensor inputTensor,
+    torch::Tensor outputTensor,
+    torch::Tensor outputWeightsTensor,
+    torch::Tensor dO_dx_ki,
+    float sigma_x,
+    float sigma_y,
+    float sigma_z,
+    float colorSigma) {
+  torch::Tensor (*filterFunction)(
+      torch::Tensor, torch::Tensor, torch::Tensor, torch::Tensor, torch::Tensor, float, float, float, float);
+
+#ifdef WITH_CUDA
+
+  if (torch::cuda::is_available() && gradientInputTensor.is_cuda()) {
+    CHECK_CONTIGUOUS_CUDA(gradientInputTensor);
+
+    if (gradientInputTensor.size(1) > BF_CUDA_MAX_CHANNELS) {
+      throw std::runtime_error(
+          "Bilateral filtering not implemented for channel count > " + std::to_string(BF_CUDA_MAX_CHANNELS));
+    }
+
+    if (gradientInputTensor.dim() - 2 > BF_CUDA_MAX_SPATIAL_DIMENSION) {
+      throw std::runtime_error(
+          "Bilateral filtering not implemented for spatial dimension > " +
+          std::to_string(BF_CUDA_MAX_SPATIAL_DIMENSION));
+    }
+
+    filterFunction = &BilateralFilterCudaBackward;
+  } else {
+    filterFunction = &BilateralFilterCpuBackward;
+  }
+#else
+  filterFunction = &BilateralFilterCpuBackward;
+#endif
+
+  return filterFunction(
+      gradientInputTensor,
+      inputTensor,
+      outputTensor,
+      outputWeightsTensor,
+      dO_dx_ki,
+      sigma_x,
+      sigma_y,
+      sigma_z,
+      colorSigma);
+}

source_code/SegMamba/monai/csrc/filtering/trainable_bilateral/trainable_bilateral.h

@@ -0,0 +1,88 @@
+/*
+Copyright (c) MONAI Consortium
+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.
+
+=========================================================================
+Adapted from https://github.com/faebstn96/trainable-bilateral-filter-source
+which has the following license...
+https://github.com/faebstn96/trainable-bilateral-filter-source/blob/main/LICENSE.md
+
+Copyright 2022 Fabian Wagner, Pattern Recognition Lab, FAU Erlangen-Nuernberg, Erlangen, Germany
+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.
+*/
+
+#pragma once
+
+#include <torch/extension.h>
+#include <algorithm>
+#include <iostream>
+#include <vector>
+#include "utils/common_utils.h"
+//#include "utils/tensor_description.h"
+
+#define BF_CUDA_MAX_CHANNELS 16
+#define BF_CUDA_MAX_SPATIAL_DIMENSION 3
+
+#ifdef WITH_CUDA
+std::tuple<torch::Tensor, torch::Tensor, torch::Tensor, torch::Tensor, torch::Tensor, torch::Tensor, torch::Tensor>
+BilateralFilterCudaForward(torch::Tensor inputTensor, float sigma_x, float sigma_y, float sigma_z, float colorSigma);
+torch::Tensor BilateralFilterCudaBackward(
+    torch::Tensor gradientInputTensor,
+    torch::Tensor inputTensor,
+    torch::Tensor outputTensor,
+    torch::Tensor outputWeightsTensor,
+    torch::Tensor dO_dx_ki,
+    float sigma_x,
+    float sigma_y,
+    float sigma_z,
+    float colorSigma);
+#endif
+
+std::tuple<torch::Tensor, torch::Tensor, torch::Tensor, torch::Tensor, torch::Tensor, torch::Tensor, torch::Tensor>
+BilateralFilterCpuForward(torch::Tensor inputTensor, float sigma_x, float sigma_y, float sigma_z, float colorSigma);
+
+torch::Tensor BilateralFilterCpuBackward(
+    torch::Tensor gradientInputTensor,
+    torch::Tensor inputTensor,
+    torch::Tensor outputTensor,
+    torch::Tensor outputWeightsTensor,
+    torch::Tensor dO_dx_ki,
+    float sigma_x,
+    float sigma_y,
+    float sigma_z,
+    float colorSigma);
+
+std::tuple<torch::Tensor, torch::Tensor, torch::Tensor, torch::Tensor, torch::Tensor, torch::Tensor, torch::Tensor>
+TrainableBilateralFilterForward(
+    torch::Tensor inputTensor,
+    float sigma_x,
+    float sigma_y,
+    float sigma_z,
+    float colorSigma);
+
+torch::Tensor TrainableBilateralFilterBackward(
+    torch::Tensor gradientInputTensor,
+    torch::Tensor inputTensor,
+    torch::Tensor outputTensor,
+    torch::Tensor outputWeightsTensor,
+    torch::Tensor dO_dx_ki,
+    float sigma_x,
+    float sigma_y,
+    float sigma_z,
+    float colorSigma);

source_code/SegMamba/monai/csrc/filtering/trainable_joint_bilateral/jbf_layer_cpu_backward.cpp

@@ -0,0 +1,246 @@
+/*
+Copyright (c) MONAI Consortium
+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.
+
+=========================================================================
+Adapted from https://github.com/faebstn96/trainable-joint-bilateral-filter-source
+which has the following license...
+https://github.com/faebstn96/trainable-joint-bilateral-filter-source/blob/main/LICENSE
+
+Copyright 2022 Fabian Wagner, Pattern Recognition Lab, FAU Erlangen-Nuernberg, Erlangen, Germany
+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.
+*/
+
+#include "trainable_joint_bilateral.h"
+#include "utils/tensor_description.h"
+#include "utils/tensor_indexing.h"
+
+template <typename scalar_t>
+void JointBilateralFilterCpuBackward_3d(
+    torch::Tensor gradientInputTensor,
+    torch::Tensor gradientGuidanceTensor,
+    torch::Tensor gradientOutputTensor,
+    torch::Tensor inputTensor,
+    torch::Tensor guidanceTensor,
+    torch::Tensor outputTensor,
+    torch::Tensor outputWeightsTensor,
+    torch::Tensor dO_dz_ki,
+    float sigma_x,
+    float sigma_y,
+    float sigma_z,
+    float colorSigma) {
+  // Getting tensor description.
+  TensorDescription desc = TensorDescription(gradientInputTensor);
+
+  // Raw tensor data pointers.
+  scalar_t* gradientInputTensorData = gradientInputTensor.data_ptr<scalar_t>();
+  scalar_t* gradientGuidanceTensorData = gradientGuidanceTensor.data_ptr<scalar_t>();
+  scalar_t* gradientOutputTensorData = gradientOutputTensor.data_ptr<scalar_t>();
+  scalar_t* inputTensorData = inputTensor.data_ptr<scalar_t>();
+  scalar_t* guidanceTensorData = guidanceTensor.data_ptr<scalar_t>();
+  scalar_t* outputTensorData = outputTensor.data_ptr<scalar_t>();
+  scalar_t* outputWeightsTensorData = outputWeightsTensor.data_ptr<scalar_t>();
+  scalar_t* dO_dz_kiData = dO_dz_ki.data_ptr<scalar_t>();
+  //    scalar_t* dw_dx_kiData = dw_dx_ki_Tensor.data_ptr<scalar_t>();
+  //    scalar_t* dfilter_dx_kiData = dfilter_dx_ki_Tensor.data_ptr<scalar_t>();
+
+  // Pre-calculate common values
+  int windowSize_x = std::max(((int)ceil(5.0f * sigma_x) | 1), 5); // ORing last bit to ensure odd window size
+  int windowSize_y = std::max(((int)ceil(5.0f * sigma_y) | 1), 5); // ORing last bit to ensure odd window size
+  int windowSize_z = std::max(((int)ceil(5.0f * sigma_z) | 1), 5); // ORing last bit to ensure odd window size
+  int halfWindowSize_x = floor(0.5f * windowSize_x);
+  int halfWindowSize_y = floor(0.5f * windowSize_y);
+  int halfWindowSize_z = floor(0.5f * windowSize_z);
+  int halfWindowSize_arr[] = {halfWindowSize_x, halfWindowSize_y, halfWindowSize_z};
+  scalar_t spatialExpConstant_x = -1.0f / (2 * sigma_x * sigma_x);
+  scalar_t spatialExpConstant_y = -1.0f / (2 * sigma_y * sigma_y);
+  scalar_t spatialExpConstant_z = -1.0f / (2 * sigma_z * sigma_z);
+  scalar_t colorExpConstant = -1.0f / (2 * colorSigma * colorSigma);
+
+  // Set kernel sizes with respect to the defined spatial sigmas.
+  int* kernelSizes = new int[desc.dimensions];
+
+  kernelSizes[0] = windowSize_x;
+  kernelSizes[1] = windowSize_y;
+  kernelSizes[2] = windowSize_z;
+
+  // Pre-calculate gaussian kernel and distance map in 1D.
+  scalar_t* gaussianKernel_x = new scalar_t[windowSize_x];
+  scalar_t* gaussianKernel_y = new scalar_t[windowSize_y];
+  scalar_t* gaussianKernel_z = new scalar_t[windowSize_z];
+  scalar_t* xDistanceSquared = new scalar_t[windowSize_x];
+  scalar_t* yDistanceSquared = new scalar_t[windowSize_y];
+  scalar_t* zDistanceSquared = new scalar_t[windowSize_z];
+
+  for (int i = 0; i < windowSize_x; i++) {
+    int distance = i - halfWindowSize_x;
+    gaussianKernel_x[i] = exp(distance * distance * spatialExpConstant_x);
+    xDistanceSquared[i] = distance * distance;
+  }
+  for (int i = 0; i < windowSize_y; i++) {
+    int distance = i - halfWindowSize_y;
+    gaussianKernel_y[i] = exp(distance * distance * spatialExpConstant_y);
+    yDistanceSquared[i] = distance * distance;
+  }
+  for (int i = 0; i < windowSize_z; i++) {
+    int distance = i - halfWindowSize_z;
+    gaussianKernel_z[i] = exp(distance * distance * spatialExpConstant_z);
+    zDistanceSquared[i] = distance * distance;
+  }
+
+  // Looping over the batches
+  for (int b = 0; b < desc.batchCount; b++) {
+    int batchOffset = b * desc.batchStride;
+
+    // Looping over all dimensions for the home element
+    for (int z = 0; z < desc.sizes[2]; z++)
+#pragma omp parallel for
+      for (int y = 0; y < desc.sizes[1]; y++) {
+        for (int x = 0; x < desc.sizes[0]; x++) {
+          // Calculating indexing offset for the home element
+          int homeOffset = batchOffset;
+
+          int homeIndex[] = {x, y, z};
+          homeOffset += x * desc.strides[0];
+          homeOffset += y * desc.strides[1];
+          homeOffset += z * desc.strides[2];
+
+          // Zero kernel aggregates.
+          scalar_t filter_kernel_guidance = 0;
+          scalar_t valueSumGuidance = 0;
+          scalar_t valueSumInput = 0;
+
+          // Looping over all dimensions for the neighbour element
+          Indexer kernelIndex = Indexer(desc.dimensions, kernelSizes);
+          do // while(kernelIndex++)
+          {
+            // Calculating buffer offset for the neighbour element
+            // Index is clamped to the border in each dimension.
+            int neighbourOffset = batchOffset;
+            bool flagNotClamped = true;
+
+            for (int i = 0; i < desc.dimensions; i++) {
+              int neighbourIndex = homeIndex[i] + kernelIndex[i] - halfWindowSize_arr[i];
+              int neighbourIndexClamped = std::min(desc.sizes[i] - 1, std::max(0, neighbourIndex));
+              neighbourOffset += neighbourIndexClamped * desc.strides[i];
+              if (neighbourIndex != neighbourIndexClamped) {
+                flagNotClamped = false;
+              }
+            }
+
+            // Euclidean color distance.
+            scalar_t colorDistance = 0;
+            scalar_t colorDistanceSquared = 0;
+
+            for (int i = 0; i < desc.channelCount; i++) {
+              scalar_t diff = guidanceTensorData[neighbourOffset + i * desc.channelStride] -
+                  guidanceTensorData[homeOffset + i * desc.channelStride]; // Be careful: Here it is (Z_k - Z_i) and not
+                                                                           // (Z_i - Z_q)
+              colorDistance += diff; // Do not take the absolute value here. Be careful with the signs.
+              colorDistanceSquared += diff * diff;
+            }
+
+            // Calculating and combining the spatial
+            // and color weights.
+            scalar_t spatialWeight = 1;
+
+            spatialWeight =
+                gaussianKernel_x[kernelIndex[0]] * gaussianKernel_y[kernelIndex[1]] * gaussianKernel_z[kernelIndex[2]];
+
+            scalar_t colorWeight = exp(colorDistanceSquared * colorExpConstant);
+            scalar_t totalWeight = spatialWeight * colorWeight;
+
+            // Aggregating values. Only do this if flagNotClamped: Pixels outside the image are disregarded.
+            if (flagNotClamped) {
+              for (int i = 0; i < desc.channelCount; i++) {
+                // Distinguish cases for k!=i (calculation is done here)
+                // and k==i (partial derivatives are precalculated).
+                // If statement replaces center element of neighborhood/kernel.
+                if (kernelIndex[0] != halfWindowSize_x || kernelIndex[1] != halfWindowSize_y ||
+                    kernelIndex[2] != halfWindowSize_z) {
+                  filter_kernel_guidance = -(1 / outputWeightsTensorData[neighbourOffset + i * desc.channelStride]) *
+                          outputTensorData[neighbourOffset + i * desc.channelStride] * totalWeight * colorDistance /
+                          (colorSigma * colorSigma) +
+                      (1 / outputWeightsTensorData[neighbourOffset + i * desc.channelStride]) * totalWeight *
+                          (inputTensorData[homeOffset + i * desc.channelStride] * colorDistance /
+                           (colorSigma * colorSigma)); // inputTensorData[homeOffset] !!, no +1!!
+                } else {
+                  filter_kernel_guidance = dO_dz_kiData[homeOffset + i * desc.channelStride];
+                }
+
+                valueSumGuidance +=
+                    gradientInputTensorData[neighbourOffset + i * desc.channelStride] * filter_kernel_guidance;
+                valueSumInput += gradientInputTensorData[neighbourOffset + i * desc.channelStride] *
+                    (1 / outputWeightsTensorData[neighbourOffset + i * desc.channelStride]) * totalWeight;
+              }
+            }
+          } while (kernelIndex++);
+
+          // Do the filtering and calculate the values for the backward pass.
+          for (int i = 0; i < desc.channelCount; i++) {
+            // Filtering:
+            gradientGuidanceTensorData[homeOffset + i * desc.channelStride] = valueSumGuidance;
+            gradientOutputTensorData[homeOffset + i * desc.channelStride] = valueSumInput;
+          }
+        }
+      }
+  }
+
+  delete[] kernelSizes;
+  delete[] gaussianKernel_x;
+  delete[] gaussianKernel_y;
+  delete[] gaussianKernel_z;
+  delete[] xDistanceSquared;
+  delete[] yDistanceSquared;
+  delete[] zDistanceSquared;
+}
+
+std::tuple<torch::Tensor, torch::Tensor> JointBilateralFilterCpuBackward(
+    torch::Tensor gradientInputTensor,
+    torch::Tensor inputTensor,
+    torch::Tensor guidanceTensor,
+    torch::Tensor outputTensor,
+    torch::Tensor outputWeightsTensor,
+    torch::Tensor dO_dz_ki,
+    float sigma_x,
+    float sigma_y,
+    float sigma_z,
+    float colorSigma) {
+  // Preparing output tensor.
+  torch::Tensor gradientOutputTensor = torch::zeros_like(gradientInputTensor);
+  torch::Tensor gradientGuidanceTensor = torch::zeros_like(gradientInputTensor);
+
+  AT_DISPATCH_FLOATING_TYPES_AND_HALF(gradientInputTensor.scalar_type(), "JointBilateralFilterCpuBackward_3d", ([&] {
+                                        JointBilateralFilterCpuBackward_3d<scalar_t>(
+                                            gradientInputTensor,
+                                            gradientGuidanceTensor,
+                                            gradientOutputTensor,
+                                            inputTensor,
+                                            guidanceTensor,
+                                            outputTensor,
+                                            outputWeightsTensor,
+                                            dO_dz_ki,
+                                            sigma_x,
+                                            sigma_y,
+                                            sigma_z,
+                                            colorSigma);
+                                      }));
+
+  return {gradientOutputTensor, gradientGuidanceTensor};
+}

source_code/SegMamba/monai/csrc/filtering/trainable_joint_bilateral/jbf_layer_cpu_forward.cpp

@@ -0,0 +1,278 @@
+/*
+Copyright (c) MONAI Consortium
+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.
+
+=========================================================================
+Adapted from https://github.com/faebstn96/trainable-joint-bilateral-filter-source
+which has the following license...
+https://github.com/faebstn96/trainable-joint-bilateral-filter-source/blob/main/LICENSE
+
+Copyright 2022 Fabian Wagner, Pattern Recognition Lab, FAU Erlangen-Nuernberg, Erlangen, Germany
+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.
+*/
+
+#include "trainable_joint_bilateral.h"
+#include "utils/tensor_description.h"
+#include "utils/tensor_indexing.h"
+
+template <typename scalar_t>
+void JointBilateralFilterCpuForward_3d(
+    torch::Tensor inputTensor,
+    torch::Tensor guidanceTensor,
+    torch::Tensor outputTensor,
+    torch::Tensor outputWeightsTensor,
+    torch::Tensor dO_dz_ki,
+    torch::Tensor dO_dsig_r,
+    torch::Tensor dO_dsig_x,
+    torch::Tensor dO_dsig_y,
+    torch::Tensor dO_dsig_z,
+    float sigma_x,
+    float sigma_y,
+    float sigma_z,
+    float colorSigma) {
+  // Getting tensor description.
+  TensorDescription desc = TensorDescription(inputTensor);
+
+  // Raw tensor data pointers.
+  scalar_t* inputTensorData = inputTensor.data_ptr<scalar_t>();
+  scalar_t* guidanceTensorData = guidanceTensor.data_ptr<scalar_t>();
+  scalar_t* outputTensorData = outputTensor.data_ptr<scalar_t>();
+  scalar_t* outputWeightsTensorData = outputWeightsTensor.data_ptr<scalar_t>();
+  scalar_t* dO_dz_kiData = dO_dz_ki.data_ptr<scalar_t>();
+  scalar_t* dO_dsig_rData = dO_dsig_r.data_ptr<scalar_t>();
+  scalar_t* dO_dsig_xData = dO_dsig_x.data_ptr<scalar_t>();
+  scalar_t* dO_dsig_yData = dO_dsig_y.data_ptr<scalar_t>();
+  scalar_t* dO_dsig_zData = dO_dsig_z.data_ptr<scalar_t>();
+
+  // Pre-calculate common values
+  int windowSize_x = std::max(((int)ceil(5.0f * sigma_x) | 1), 5); // ORing last bit to ensure odd window size
+  int windowSize_y = std::max(((int)ceil(5.0f * sigma_y) | 1), 5); // ORing last bit to ensure odd window size
+  int windowSize_z = std::max(((int)ceil(5.0f * sigma_z) | 1), 5); // ORing last bit to ensure odd window size
+  int halfWindowSize_x = floor(0.5f * windowSize_x);
+  int halfWindowSize_y = floor(0.5f * windowSize_y);
+  int halfWindowSize_z = floor(0.5f * windowSize_z);
+  int halfWindowSize_arr[] = {halfWindowSize_x, halfWindowSize_y, halfWindowSize_z};
+  scalar_t spatialExpConstant_x = -1.0f / (2 * sigma_x * sigma_x);
+  scalar_t spatialExpConstant_y = -1.0f / (2 * sigma_y * sigma_y);
+  scalar_t spatialExpConstant_z = -1.0f / (2 * sigma_z * sigma_z);
+  scalar_t colorExpConstant = -1.0f / (2 * colorSigma * colorSigma);
+
+  // Set kernel sizes with respect to the defined spatial sigmas.
+  int* kernelSizes = new int[desc.dimensions];
+
+  kernelSizes[0] = windowSize_x;
+  kernelSizes[1] = windowSize_y;
+  kernelSizes[2] = windowSize_z;
+
+  // Pre-calculate gaussian kernel and distance map in 1D.
+  scalar_t* gaussianKernel_x = new scalar_t[windowSize_x];
+  scalar_t* gaussianKernel_y = new scalar_t[windowSize_y];
+  scalar_t* gaussianKernel_z = new scalar_t[windowSize_z];
+  scalar_t* xDistanceSquared = new scalar_t[windowSize_x];
+  scalar_t* yDistanceSquared = new scalar_t[windowSize_y];
+  scalar_t* zDistanceSquared = new scalar_t[windowSize_z];
+
+  for (int i = 0; i < windowSize_x; i++) {
+    int distance = i - halfWindowSize_x;
+    gaussianKernel_x[i] = exp(distance * distance * spatialExpConstant_x);
+    xDistanceSquared[i] = distance * distance;
+  }
+  for (int i = 0; i < windowSize_y; i++) {
+    int distance = i - halfWindowSize_y;
+    gaussianKernel_y[i] = exp(distance * distance * spatialExpConstant_y);
+    yDistanceSquared[i] = distance * distance;
+  }
+  for (int i = 0; i < windowSize_z; i++) {
+    int distance = i - halfWindowSize_z;
+    gaussianKernel_z[i] = exp(distance * distance * spatialExpConstant_z);
+    zDistanceSquared[i] = distance * distance;
+  }
+
+  // Looping over the batches
+  for (int b = 0; b < desc.batchCount; b++) {
+    int batchOffset = b * desc.batchStride;
+
+    // Looping over all dimensions for the home element
+    for (int z = 0; z < desc.sizes[2]; z++)
+#pragma omp parallel for
+      for (int y = 0; y < desc.sizes[1]; y++) {
+        for (int x = 0; x < desc.sizes[0]; x++) {
+          // Calculating indexing offset for the home element
+          int homeOffset = batchOffset;
+
+          int homeIndex[] = {x, y, z};
+          homeOffset += x * desc.strides[0];
+          homeOffset += y * desc.strides[1];
+          homeOffset += z * desc.strides[2];
+
+          // Zero kernel aggregates.
+          scalar_t valueSum = 0;
+          scalar_t dw_dz_ki = 0;
+          scalar_t dfilter_dz_ki = 0;
+          scalar_t colorSum_w = 0;
+          scalar_t colorSum_alpha = 0;
+          scalar_t xSum_w = 0;
+          scalar_t xSum_alpha = 0;
+          scalar_t ySum_w = 0;
+          scalar_t ySum_alpha = 0;
+          scalar_t zSum_w = 0;
+          scalar_t zSum_alpha = 0;
+
+          scalar_t weightSum = 0.0f;
+
+          // Looping over all dimensions for the neighbour element
+          Indexer kernelIndex = Indexer(desc.dimensions, kernelSizes);
+          do // while(kernelIndex++)
+          {
+            // Calculating buffer offset for the neighbour element
+            // Index is clamped to the border in each dimension.
+            int neighbourOffset = batchOffset;
+            bool flagNotClamped = true;
+
+            for (int i = 0; i < desc.dimensions; i++) {
+              int neighbourIndex = homeIndex[i] + kernelIndex[i] - halfWindowSize_arr[i];
+              int neighbourIndexClamped = std::min(desc.sizes[i] - 1, std::max(0, neighbourIndex));
+              neighbourOffset += neighbourIndexClamped * desc.strides[i];
+              if (neighbourIndex != neighbourIndexClamped) {
+                flagNotClamped = false;
+              }
+            }
+
+            // Euclidean color distance.
+            scalar_t colorDistance = 0;
+            scalar_t colorDistanceSquared = 0;
+
+            for (int i = 0; i < desc.channelCount; i++) {
+              scalar_t diff = guidanceTensorData[homeOffset + i * desc.channelStride] -
+                  guidanceTensorData[neighbourOffset + i * desc.channelStride];
+              colorDistance += diff; // Do not take the absolute value here. Be careful with the signs.
+              colorDistanceSquared += diff * diff;
+            }
+
+            // Calculating and combining the spatial
+            // and color weights.
+            scalar_t spatialWeight = 1;
+
+            spatialWeight =
+                gaussianKernel_x[kernelIndex[0]] * gaussianKernel_y[kernelIndex[1]] * gaussianKernel_z[kernelIndex[2]];
+
+            scalar_t colorWeight = exp(colorDistanceSquared * colorExpConstant);
+            scalar_t totalWeight = spatialWeight * colorWeight;
+
+            // Aggregating values. Only do this if flagNotClamped: Pixels outside the image are disregarded.
+            if (flagNotClamped) {
+              for (int i = 0; i < desc.channelCount; i++) {
+                valueSum += inputTensorData[neighbourOffset + i * desc.channelStride] * totalWeight;
+
+                // Derivative of weights with respect to X_i while i=k.
+                dw_dz_ki += (-1) * totalWeight * colorDistance / (colorSigma * colorSigma);
+                // Derivative of convolved image with respect to X_i while i=k.
+                dfilter_dz_ki += (-1) * totalWeight * inputTensorData[neighbourOffset + i * desc.channelStride] *
+                    colorDistance /
+                    (colorSigma *
+                     colorSigma); // Be careful, the +1 is missing here -> Added before filling dfilter_dx_kiData
+
+                colorSum_w += totalWeight * colorDistanceSquared / std::abs(colorSigma * colorSigma * colorSigma);
+                colorSum_alpha += totalWeight * inputTensorData[neighbourOffset + i * desc.channelStride] *
+                    colorDistanceSquared / std::abs(colorSigma * colorSigma * colorSigma);
+
+                xSum_w += totalWeight * xDistanceSquared[kernelIndex[0]] / std::abs(sigma_x * sigma_x * sigma_x);
+                xSum_alpha += totalWeight * inputTensorData[neighbourOffset + i * desc.channelStride] *
+                    xDistanceSquared[kernelIndex[0]] / std::abs(sigma_x * sigma_x * sigma_x);
+
+                ySum_w += totalWeight * yDistanceSquared[kernelIndex[1]] / std::abs(sigma_y * sigma_y * sigma_y);
+                ySum_alpha += totalWeight * inputTensorData[neighbourOffset + i * desc.channelStride] *
+                    yDistanceSquared[kernelIndex[1]] / std::abs(sigma_y * sigma_y * sigma_y);
+
+                zSum_w += totalWeight * zDistanceSquared[kernelIndex[2]] / std::abs(sigma_z * sigma_z * sigma_z);
+                zSum_alpha += totalWeight * inputTensorData[neighbourOffset + i * desc.channelStride] *
+                    zDistanceSquared[kernelIndex[2]] / std::abs(sigma_z * sigma_z * sigma_z);
+              }
+
+              weightSum += totalWeight;
+            }
+          } while (kernelIndex++);
+
+          // Do the filtering and calculate the values for the backward pass.
+          for (int i = 0; i < desc.channelCount; i++) {
+            // Filtering:
+            outputTensorData[homeOffset + i * desc.channelStride] = valueSum / weightSum;
+
+            // Pre-computations for the backward pass:
+            outputWeightsTensorData[homeOffset + i * desc.channelStride] = weightSum;
+            dO_dz_kiData[homeOffset + i * desc.channelStride] = -(1 / weightSum) * (valueSum / weightSum) * dw_dz_ki +
+                (1 / weightSum) * (dfilter_dz_ki); // no +1 for dfilter_dz_ki for JBF added here!
+            dO_dsig_rData[homeOffset + i * desc.channelStride] =
+                -(1 / weightSum) * (valueSum / weightSum) * colorSum_w + (1 / weightSum) * colorSum_alpha;
+            dO_dsig_xData[homeOffset + i * desc.channelStride] =
+                -(1 / weightSum) * (valueSum / weightSum) * xSum_w + (1 / weightSum) * xSum_alpha;
+            dO_dsig_yData[homeOffset + i * desc.channelStride] =
+                -(1 / weightSum) * (valueSum / weightSum) * ySum_w + (1 / weightSum) * ySum_alpha;
+            dO_dsig_zData[homeOffset + i * desc.channelStride] =
+                -(1 / weightSum) * (valueSum / weightSum) * zSum_w + (1 / weightSum) * zSum_alpha;
+          }
+        }
+      }
+  }
+
+  delete[] kernelSizes;
+  delete[] gaussianKernel_x;
+  delete[] gaussianKernel_y;
+  delete[] gaussianKernel_z;
+  delete[] xDistanceSquared;
+  delete[] yDistanceSquared;
+  delete[] zDistanceSquared;
+}
+
+std::tuple<torch::Tensor, torch::Tensor, torch::Tensor, torch::Tensor, torch::Tensor, torch::Tensor, torch::Tensor>
+JointBilateralFilterCpuForward(
+    torch::Tensor inputTensor,
+    torch::Tensor guidanceTensor,
+    float sigma_x,
+    float sigma_y,
+    float sigma_z,
+    float colorSigma) {
+  // Preparing output tensor.
+  torch::Tensor outputTensor = torch::zeros_like(inputTensor);
+  torch::Tensor outputWeightsTensor = torch::zeros_like(inputTensor);
+  torch::Tensor dO_dz_ki = torch::zeros_like(inputTensor);
+  torch::Tensor dO_dsig_r = torch::zeros_like(inputTensor);
+  torch::Tensor dO_dsig_x = torch::zeros_like(inputTensor);
+  torch::Tensor dO_dsig_y = torch::zeros_like(inputTensor);
+  torch::Tensor dO_dsig_z = torch::zeros_like(inputTensor);
+
+  AT_DISPATCH_FLOATING_TYPES_AND_HALF(inputTensor.scalar_type(), "JointBilateralFilterCpuForward_3d", ([&] {
+                                        JointBilateralFilterCpuForward_3d<scalar_t>(
+                                            inputTensor,
+                                            guidanceTensor,
+                                            outputTensor,
+                                            outputWeightsTensor,
+                                            dO_dz_ki,
+                                            dO_dsig_r,
+                                            dO_dsig_x,
+                                            dO_dsig_y,
+                                            dO_dsig_z,
+                                            sigma_x,
+                                            sigma_y,
+                                            sigma_z,
+                                            colorSigma);
+                                      }));
+
+  return {outputTensor, outputWeightsTensor, dO_dz_ki, dO_dsig_r, dO_dsig_x, dO_dsig_y, dO_dsig_z};
+}

source_code/SegMamba/monai/csrc/filtering/trainable_joint_bilateral/jbf_layer_gpu_backward.cu

@@ -0,0 +1,311 @@
+/*
+Copyright (c) MONAI Consortium
+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.
+
+=========================================================================
+Adapted from https://github.com/faebstn96/trainable-joint-bilateral-filter-source
+which has the following license...
+https://github.com/faebstn96/trainable-joint-bilateral-filter-source/blob/main/LICENSE
+
+Copyright 2022 Fabian Wagner, Pattern Recognition Lab, FAU Erlangen-Nuernberg, Erlangen, Germany
+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.
+*/
+
+#include <cuda.h>
+#include <cuda_runtime.h>
+
+#include "trainable_joint_bilateral.h"
+//#include "../utils/cuda_error_check.h"
+#include "utils/meta_macros.h"
+#include "utils/tensor_description.h"
+
+__constant__ int cBatchStrideBack;
+__constant__ int cColorStrideBack;
+
+__constant__ int cSizesBack[3];
+__constant__ int cStridesBack[3];
+
+__constant__ int cKernelSizesBack[3];
+__constant__ int cHalfWindowSize_arrBack[3];
+__constant__ float cGaussianKernel_xBack[256];
+__constant__ float cGaussianKernel_yBack[256];
+__constant__ float cGaussianKernel_zBack[256];
+__constant__ float cXDistanceSquaredBack[256];
+__constant__ float cYDistanceSquaredBack[256];
+__constant__ float cZDistanceSquaredBack[256];
+__constant__ float cColorExponentConstantBack;
+__constant__ float cSigma_xBack;
+__constant__ float cSigma_yBack;
+__constant__ float cSigma_zBack;
+__constant__ float cColorSigmaBack;
+
+template <typename scalar_t, int C>
+__global__ void JointBilateralFilterCudaKernel3DBackward(
+    scalar_t* gradientInputTensor,
+    scalar_t* gradientGuidanceTensor,
+    scalar_t* gradientOutputTensor,
+    scalar_t* inputTensor,
+    scalar_t* guidanceTensor,
+    scalar_t* outputTensor,
+    scalar_t* outputWeightsTensor,
+    scalar_t* dO_dz_ki) {
+  int homeOffset = blockIdx.x * blockDim.x + threadIdx.x;
+  int batchOffset = blockIdx.y * cBatchStrideBack;
+
+  if (homeOffset >= cColorStrideBack)
+    return;
+
+  int homeX = homeOffset / cStridesBack[0];
+  int homeY = (homeOffset - homeX * cStridesBack[0]) / cStridesBack[1];
+  int homeZ = (homeOffset - homeX * cStridesBack[0] - homeY * cStridesBack[1]) / cStridesBack[2];
+  int homeIndex[] = {homeX, homeY, homeZ};
+
+  // Zero kernel aggregates.
+  scalar_t valueSumGuidance = 0;
+  scalar_t valueSumInput = 0;
+
+  for (int kernelX = 0; kernelX < cKernelSizesBack[0]; kernelX++) {
+    int neighbourX = max(0, min(homeX + (kernelX - cHalfWindowSize_arrBack[0]), cSizesBack[0] - 1));
+    scalar_t gaussianX = cGaussianKernel_xBack[kernelX];
+
+    for (int kernelY = 0; kernelY < cKernelSizesBack[1]; kernelY++) {
+      int neighbourY = max(0, min(homeY + (kernelY - cHalfWindowSize_arrBack[1]), cSizesBack[1] - 1));
+      scalar_t gaussianY = cGaussianKernel_yBack[kernelY];
+
+      for (int kernelZ = 0; kernelZ < cKernelSizesBack[2]; kernelZ++) {
+        int neighbourZ = max(0, min(homeZ + (kernelZ - cHalfWindowSize_arrBack[2]), cSizesBack[2] - 1));
+        scalar_t gaussianZ = cGaussianKernel_zBack[kernelZ];
+
+        int neighbourOffset = neighbourX * cStridesBack[0] + neighbourY * cStridesBack[1] + neighbourZ;
+
+        bool flagNotClamped = true;
+        int kernelIndex[] = {kernelX, kernelY, kernelZ};
+        int dimensions = 3; // Must equal the number of spatial dimensions.
+
+        for (int i = 0; i < dimensions; i++) {
+          int HalfWindowSizeBack = cHalfWindowSize_arrBack[i]; // Define constant memory as new variable here (!!),
+                                                               // otherwise: cudaErrorMisalignedAddress
+          int neighbourIndex = homeIndex[i] + kernelIndex[i] - HalfWindowSizeBack;
+          int neighbourIndexClamped = min(cSizesBack[i] - 1, max(0, neighbourIndex));
+          if (neighbourIndex != neighbourIndexClamped) {
+            flagNotClamped = false;
+          }
+        }
+
+        scalar_t colorDistance = 0;
+        scalar_t colorDistanceSquared = 0;
+
+#pragma unroll
+        for (int c = 0; c < C; c++) {
+          scalar_t a = guidanceTensor[batchOffset + neighbourOffset + c * cColorStrideBack];
+          scalar_t b = guidanceTensor[batchOffset + homeOffset + c * cColorStrideBack]; // Be careful: Here it is (Z_k -
+                                                                                        // Z_i) and not (Z_i - Z_q)
+          scalar_t diff = a - b;
+          colorDistance += diff; // Do not take the absolute value here. Be careful with the signs.
+          colorDistanceSquared += diff * diff;
+        }
+
+        scalar_t spatialWeight = gaussianX * gaussianY * gaussianZ;
+        scalar_t colorWeight = exp(cColorExponentConstantBack * colorDistanceSquared);
+        scalar_t totalWeight = spatialWeight * colorWeight;
+
+        // Aggregating values. Only do this if flagNotClamped: Pixels outside the image are disregarded.
+        if (flagNotClamped) {
+          scalar_t filter_kernel_guidance_back;
+
+#pragma unroll
+          for (int c = 0; c < C; c++) {
+            // Distinguish cases for k!=i (calculation is done here)
+            // and k==i (partial derivatives are precalculated).
+            // If statement replaces center element of neighborhood/kernel.
+            if (kernelX != cHalfWindowSize_arrBack[0] || kernelY != cHalfWindowSize_arrBack[1] ||
+                kernelZ != cHalfWindowSize_arrBack[2]) {
+              filter_kernel_guidance_back =
+                  -(1 / outputWeightsTensor[batchOffset + neighbourOffset + c * cColorStrideBack]) *
+                      outputTensor[batchOffset + neighbourOffset + c * cColorStrideBack] * totalWeight * colorDistance /
+                      (cColorSigmaBack * cColorSigmaBack) +
+                  (1 / outputWeightsTensor[batchOffset + neighbourOffset + c * cColorStrideBack]) * totalWeight *
+                      (inputTensor[batchOffset + homeOffset + c * cColorStrideBack] * colorDistance /
+                       (cColorSigmaBack * cColorSigmaBack)); // inputTensorData[homeOffset] !!, no +1!!
+            } else {
+              filter_kernel_guidance_back = dO_dz_ki[batchOffset + homeOffset + c * cColorStrideBack];
+            }
+
+            valueSumGuidance +=
+                gradientInputTensor[batchOffset + neighbourOffset + c * cColorStrideBack] * filter_kernel_guidance_back;
+            valueSumInput += gradientInputTensor[batchOffset + neighbourOffset + c * cColorStrideBack] *
+                (1 / outputWeightsTensor[batchOffset + neighbourOffset + c * cColorStrideBack]) * totalWeight;
+          }
+        }
+      }
+    }
+  }
+
+#pragma unroll
+  for (int c = 0; c < C; c++) {
+    gradientGuidanceTensor[batchOffset + homeOffset + c * cColorStrideBack] = valueSumGuidance;
+    gradientOutputTensor[batchOffset + homeOffset + c * cColorStrideBack] = valueSumInput;
+  }
+}
+
+template <int C, int D>
+void JointBilateralFilterCudaBackwardFunction(
+    torch::Tensor gradientInputTensor,
+    torch::Tensor gradientGuidanceTensor,
+    torch::Tensor gradientOutputTensor,
+    torch::Tensor inputTensor,
+    torch::Tensor guidanceTensor,
+    torch::Tensor outputTensor,
+    torch::Tensor outputWeightsTensor,
+    torch::Tensor dO_dz_ki,
+    float sigma_x,
+    float sigma_y,
+    float sigma_z,
+    float colorSigma) {
+  // Getting tensor description.
+  TensorDescription desc = TensorDescription(inputTensor);
+
+  // Pre-calculating gaussian kernel.
+  int windowSize_x = std::max(((int)ceil(5.0f * sigma_x) | 1), 5); // ORing last bit to ensure odd window size
+  int windowSize_y = std::max(((int)ceil(5.0f * sigma_y) | 1), 5); // ORing last bit to ensure odd window size
+  int windowSize_z = std::max(((int)ceil(5.0f * sigma_z) | 1), 5); // ORing last bit to ensure odd window size
+  int halfWindowSize_x = floor(0.5f * windowSize_x);
+  int halfWindowSize_y = floor(0.5f * windowSize_y);
+  int halfWindowSize_z = floor(0.5f * windowSize_z);
+  int halfWindowSize_arr[] = {halfWindowSize_x, halfWindowSize_y, halfWindowSize_z};
+  float spatialExpConstant_x = -1.0f / (2 * sigma_x * sigma_x);
+  float spatialExpConstant_y = -1.0f / (2 * sigma_y * sigma_y);
+  float spatialExpConstant_z = -1.0f / (2 * sigma_z * sigma_z);
+  float colorExpConstant = -1.0f / (2 * colorSigma * colorSigma);
+
+  int* kernelSizes = new int[desc.dimensions];
+  kernelSizes[0] = windowSize_x;
+  kernelSizes[1] = windowSize_y;
+  kernelSizes[2] = windowSize_z;
+
+  auto* gaussianKernel_x = new float[windowSize_x];
+  auto* gaussianKernel_y = new float[windowSize_y];
+  auto* gaussianKernel_z = new float[windowSize_z];
+  auto* xDistanceSquared = new float[windowSize_x];
+  auto* yDistanceSquared = new float[windowSize_y];
+  auto* zDistanceSquared = new float[windowSize_z];
+
+  for (int i = 0; i < windowSize_x; i++) {
+    int distance = i - halfWindowSize_x;
+    gaussianKernel_x[i] = exp(distance * distance * spatialExpConstant_x);
+    xDistanceSquared[i] = distance * distance;
+  }
+  for (int i = 0; i < windowSize_y; i++) {
+    int distance = i - halfWindowSize_y;
+    gaussianKernel_y[i] = exp(distance * distance * spatialExpConstant_y);
+    yDistanceSquared[i] = distance * distance;
+  }
+  for (int i = 0; i < windowSize_z; i++) {
+    int distance = i - halfWindowSize_z;
+    gaussianKernel_z[i] = exp(distance * distance * spatialExpConstant_z);
+    zDistanceSquared[i] = distance * distance;
+  }
+
+  // Writing constant memory.
+  cudaMemcpyToSymbol(cBatchStrideBack, &desc.batchStride, sizeof(int));
+  cudaMemcpyToSymbol(cColorStrideBack, &desc.channelStride, sizeof(int));
+  cudaMemcpyToSymbol(cSizesBack, desc.sizes, sizeof(int) * 3);
+  cudaMemcpyToSymbol(cStridesBack, desc.strides, sizeof(int) * 3);
+  cudaMemcpyToSymbol(cKernelSizesBack, kernelSizes, sizeof(int) * desc.dimensions);
+  cudaMemcpyToSymbol(cHalfWindowSize_arrBack, halfWindowSize_arr, sizeof(int) * desc.dimensions);
+  cudaMemcpyToSymbol(cGaussianKernel_xBack, gaussianKernel_x, sizeof(float) * windowSize_x);
+  cudaMemcpyToSymbol(cGaussianKernel_yBack, gaussianKernel_y, sizeof(float) * windowSize_y);
+  cudaMemcpyToSymbol(cGaussianKernel_zBack, gaussianKernel_z, sizeof(float) * windowSize_z);
+  cudaMemcpyToSymbol(cXDistanceSquaredBack, xDistanceSquared, sizeof(float) * windowSize_x);
+  cudaMemcpyToSymbol(cYDistanceSquaredBack, yDistanceSquared, sizeof(float) * windowSize_y);
+  cudaMemcpyToSymbol(cZDistanceSquaredBack, zDistanceSquared, sizeof(float) * windowSize_z);
+  cudaMemcpyToSymbol(cColorExponentConstantBack, &colorExpConstant, sizeof(float));
+  cudaMemcpyToSymbol(cSigma_xBack, &sigma_x, sizeof(float));
+  cudaMemcpyToSymbol(cSigma_yBack, &sigma_y, sizeof(float));
+  cudaMemcpyToSymbol(cSigma_zBack, &sigma_z, sizeof(float));
+  cudaMemcpyToSymbol(cColorSigmaBack, &colorSigma, sizeof(float));
+
+  //  cuda_error_check("Cuda check before kernel call.");
+
+#define BLOCK_SIZE 32
+
+  AT_DISPATCH_FLOATING_TYPES_AND_HALF(
+      inputTensor.scalar_type(), "JointBilateralFilterCudaKernel3DBackward", ([&] {
+        JointBilateralFilterCudaKernel3DBackward<scalar_t, C>
+            <<<dim3(int(desc.channelStride / BLOCK_SIZE) + 1, desc.batchCount), dim3(BLOCK_SIZE, 1)>>>(
+                gradientInputTensor.data_ptr<scalar_t>(),
+                gradientGuidanceTensor.data_ptr<scalar_t>(),
+                gradientOutputTensor.data_ptr<scalar_t>(),
+                inputTensor.data_ptr<scalar_t>(),
+                guidanceTensor.data_ptr<scalar_t>(),
+                outputTensor.data_ptr<scalar_t>(),
+                outputWeightsTensor.data_ptr<scalar_t>(),
+                dO_dz_ki.data_ptr<scalar_t>());
+      }));
+
+  //  cuda_error_check("Cuda check after kernel call.");
+  //  delete[] kernel;
+  delete[] kernelSizes;
+  delete[] gaussianKernel_x;
+  delete[] gaussianKernel_y;
+  delete[] gaussianKernel_z;
+  delete[] xDistanceSquared;
+  delete[] yDistanceSquared;
+  delete[] zDistanceSquared;
+}
+
+// Function to choose template implementation based on dynamic, channels and dimensions
+std::tuple<torch::Tensor, torch::Tensor> JointBilateralFilterCudaBackward(
+    torch::Tensor gradientInputTensor,
+    torch::Tensor inputTensor,
+    torch::Tensor guidanceTensor,
+    torch::Tensor outputTensor,
+    torch::Tensor outputWeightsTensor,
+    torch::Tensor dO_dz_ki,
+    float sigma_x,
+    float sigma_y,
+    float sigma_z,
+    float colorSigma) {
+  torch::Tensor gradientOutputTensor = torch::zeros_like(gradientInputTensor);
+  torch::Tensor gradientGuidanceTensor = torch::zeros_like(gradientInputTensor);
+  //  cuda_error_check("beginning");
+
+#define CASE(c, d)                                \
+  JointBilateralFilterCudaBackwardFunction<c, d>( \
+      gradientInputTensor,                        \
+      gradientGuidanceTensor,                     \
+      gradientOutputTensor,                       \
+      inputTensor,                                \
+      guidanceTensor,                             \
+      outputTensor,                               \
+      outputWeightsTensor,                        \
+      dO_dz_ki,                                   \
+      sigma_x,                                    \
+      sigma_y,                                    \
+      sigma_z,                                    \
+      colorSigma);
+  SWITCH_AB(
+      CASE,
+      BF_CUDA_MAX_CHANNELS,
+      BF_CUDA_MAX_SPATIAL_DIMENSION,
+      gradientInputTensor.size(1),
+      gradientInputTensor.dim() - 2);
+
+  return {gradientOutputTensor, gradientGuidanceTensor};
+}

source_code/SegMamba/monai/csrc/filtering/trainable_joint_bilateral/trainable_joint_bilateral.cpp

@@ -0,0 +1,133 @@
+/*
+Copyright (c) MONAI Consortium
+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.
+
+=========================================================================
+Adapted from https://github.com/faebstn96/trainable-joint-bilateral-filter-source
+which has the following license...
+https://github.com/faebstn96/trainable-joint-bilateral-filter-source/blob/main/LICENSE
+
+Copyright 2022 Fabian Wagner, Pattern Recognition Lab, FAU Erlangen-Nuernberg, Erlangen, Germany
+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.
+*/
+
+#include <torch/extension.h>
+#include <stdexcept>
+#include <string>
+
+#include "trainable_joint_bilateral.h"
+#include "utils/common_utils.h"
+
+std::tuple<torch::Tensor, torch::Tensor, torch::Tensor, torch::Tensor, torch::Tensor, torch::Tensor, torch::Tensor>
+TrainableJointBilateralFilterForward(
+    torch::Tensor inputTensor,
+    torch::Tensor guidanceTensor,
+    float sigma_x,
+    float sigma_y,
+    float sigma_z,
+    float colorSigma) {
+  std::tuple<torch::Tensor, torch::Tensor, torch::Tensor, torch::Tensor, torch::Tensor, torch::Tensor, torch::Tensor> (
+      *filterFunction)(torch::Tensor, torch::Tensor, float, float, float, float);
+
+#ifdef WITH_CUDA
+
+  if (torch::cuda::is_available() && inputTensor.is_cuda()) {
+    CHECK_CONTIGUOUS_CUDA(inputTensor);
+
+    if (inputTensor.size(1) > BF_CUDA_MAX_CHANNELS) {
+      throw std::runtime_error(
+          "Bilateral filtering not implemented for channel count > " + std::to_string(BF_CUDA_MAX_CHANNELS));
+    }
+
+    if (inputTensor.dim() - 2 > BF_CUDA_MAX_SPATIAL_DIMENSION) {
+      throw std::runtime_error(
+          "Bilateral filtering not implemented for spatial dimension > " +
+          std::to_string(BF_CUDA_MAX_SPATIAL_DIMENSION));
+    }
+
+    filterFunction = &JointBilateralFilterCudaForward;
+  } else {
+    filterFunction = &JointBilateralFilterCpuForward;
+  }
+#else
+  filterFunction = &JointBilateralFilterCpuForward;
+#endif
+
+  return filterFunction(inputTensor, guidanceTensor, sigma_x, sigma_y, sigma_z, colorSigma);
+}
+
+std::tuple<torch::Tensor, torch::Tensor> TrainableJointBilateralFilterBackward(
+    torch::Tensor gradientInputTensor,
+    torch::Tensor inputTensor,
+    torch::Tensor guidanceTensor,
+    torch::Tensor outputTensor,
+    torch::Tensor outputWeightsTensor,
+    torch::Tensor dO_dx_ki,
+    float sigma_x,
+    float sigma_y,
+    float sigma_z,
+    float colorSigma) {
+  std::tuple<torch::Tensor, torch::Tensor> (*filterFunction)(
+      torch::Tensor,
+      torch::Tensor,
+      torch::Tensor,
+      torch::Tensor,
+      torch::Tensor,
+      torch::Tensor,
+      float,
+      float,
+      float,
+      float);
+
+#ifdef WITH_CUDA
+
+  if (torch::cuda::is_available() && gradientInputTensor.is_cuda()) {
+    CHECK_CONTIGUOUS_CUDA(gradientInputTensor);
+
+    if (gradientInputTensor.size(1) > BF_CUDA_MAX_CHANNELS) {
+      throw std::runtime_error(
+          "Bilateral filtering not implemented for channel count > " + std::to_string(BF_CUDA_MAX_CHANNELS));
+    }
+
+    if (gradientInputTensor.dim() - 2 > BF_CUDA_MAX_SPATIAL_DIMENSION) {
+      throw std::runtime_error(
+          "Bilateral filtering not implemented for spatial dimension > " +
+          std::to_string(BF_CUDA_MAX_SPATIAL_DIMENSION));
+    }
+
+    filterFunction = &JointBilateralFilterCudaBackward;
+  } else {
+    filterFunction = &JointBilateralFilterCpuBackward;
+  }
+#else
+  filterFunction = &JointBilateralFilterCpuBackward;
+#endif
+
+  return filterFunction(
+      gradientInputTensor,
+      inputTensor,
+      guidanceTensor,
+      outputTensor,
+      outputWeightsTensor,
+      dO_dx_ki,
+      sigma_x,
+      sigma_y,
+      sigma_z,
+      colorSigma);
+}

source_code/SegMamba/monai/csrc/lltm/lltm_cpu.cpp

@@ -0,0 +1,90 @@
+/*
+Copyright (c) MONAI Consortium
+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.
+*/
+
+#include <torch/extension.h>
+#include <vector>
+
+// s'(z) = (1 - s(z)) * s(z)
+torch::Tensor d_sigmoid(torch::Tensor z) {
+  auto s = torch::sigmoid(z);
+  return (1 - s) * s;
+}
+
+// tanh'(z) = 1 - tanh^2(z)
+torch::Tensor d_tanh(torch::Tensor z) {
+  return 1 - z.tanh().pow(2);
+}
+
+// elu'(z) = relu'(z) + { alpha * exp(z) if (alpha * (exp(z) - 1)) < 0, else 0}
+torch::Tensor d_elu(torch::Tensor z, torch::Scalar alpha = 1.0) {
+  auto e = z.exp();
+  auto mask = (alpha * (e - 1)) < 0;
+  return (z > 0).type_as(z) + mask.type_as(z) * (alpha * e);
+}
+
+std::vector<torch::Tensor> lltm_cpu_forward(
+    torch::Tensor input,
+    torch::Tensor weights,
+    torch::Tensor bias,
+    torch::Tensor old_h,
+    torch::Tensor old_cell) {
+  auto X = torch::cat({old_h, input}, /*dim=*/1);
+
+  auto gate_weights = torch::addmm(bias, X, weights.transpose(0, 1));
+  auto gates = gate_weights.chunk(3, /*dim=*/1);
+
+  auto input_gate = torch::sigmoid(gates[0]);
+  auto output_gate = torch::sigmoid(gates[1]);
+  auto candidate_cell = torch::elu(gates[2], /*alpha=*/1.0);
+
+  auto new_cell = old_cell + candidate_cell * input_gate;
+  auto new_h = torch::tanh(new_cell) * output_gate;
+
+  return {new_h, new_cell, input_gate, output_gate, candidate_cell, X, gate_weights};
+}
+
+std::vector<torch::Tensor> lltm_cpu_backward(
+    torch::Tensor grad_h,
+    torch::Tensor grad_cell,
+    torch::Tensor new_cell,
+    torch::Tensor input_gate,
+    torch::Tensor output_gate,
+    torch::Tensor candidate_cell,
+    torch::Tensor X,
+    torch::Tensor gate_weights,
+    torch::Tensor weights) {
+  auto d_output_gate = torch::tanh(new_cell) * grad_h;
+  auto d_tanh_new_cell = output_gate * grad_h;
+  auto d_new_cell = d_tanh(new_cell) * d_tanh_new_cell + grad_cell;
+
+  auto d_old_cell = d_new_cell;
+  auto d_candidate_cell = input_gate * d_new_cell;
+  auto d_input_gate = candidate_cell * d_new_cell;
+
+  auto gates = gate_weights.chunk(3, /*dim=*/1);
+  d_input_gate *= d_sigmoid(gates[0]);
+  d_output_gate *= d_sigmoid(gates[1]);
+  d_candidate_cell *= d_elu(gates[2]);
+
+  auto d_gates = torch::cat({d_input_gate, d_output_gate, d_candidate_cell}, /*dim=*/1);
+
+  auto d_weights = d_gates.t().mm(X);
+  auto d_bias = d_gates.sum(/*dim=*/0, /*keepdim=*/true);
+
+  auto d_X = d_gates.mm(weights);
+  const auto state_size = grad_h.size(1);
+  auto d_old_h = d_X.slice(/*dim=*/1, 0, state_size);
+  auto d_input = d_X.slice(/*dim=*/1, state_size);
+
+  return {d_old_h, d_input, d_weights, d_bias, d_old_cell};
+}

source_code/SegMamba/monai/csrc/resample/pushpull_cpu.cpp

@@ -0,0 +1,2270 @@
+/*
+Copyright (c) MONAI Consortium
+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.
+*/
+
+// adapted from https://github.com/balbasty/nitorch
+
+// This file implements spline interpolation / sampling and its adjoint
+// operations. It corresponds loosely to torch's `GridSampler`.
+// It handles boundary conditions and interpolation orders defined in
+// `utils/resample_utils.h` and `utils/resample_utils.h`.
+// These parameters can be specified per dimension.
+// Isotropic 0-th and 1-st order interpolation have their own (faster)
+// implementations. Sliding boundary conditions are also implemented
+// separately.
+
+// TODO:
+// . [DONE] generic 3d
+// . [DONE] generic 2d
+// . [DONE] generic 1d
+// . sliding nearest 3d
+// . sliding nearest 2d
+// . sliding linear 3d
+// . sliding linear 2d
+// . sliding generic 3d
+// . sliding generic 2d
+// . [DONE] spatial gradient mode (without multiplication with output gradient)
+// . [DONE] second order gradients (backward pass for spatial gradients)
+// . performance tests
+// . input bound/inter are always vectors -> clean unused constructors
+
+#include <ATen/ATen.h>
+#include <limits>
+#include <tuple>
+#include "bounds_common.h"
+#include "interpolation_common.h"
+#include "utils/resample_utils.h"
+//#include <cstdio>
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+// CPU-specific parameters
+#include <ATen/Parallel.h>
+namespace {
+// This parameter specifies the minimum number of voxels that should be
+// processed on a single processor in the parallel for loop .
+int64_t GRAIN_SIZE = static_cast<int64_t>(at::internal::GRAIN_SIZE);
+} // namespace
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+// maximum number of channels
+// > not used in mode isotropic nearest/linear
+#ifndef MONAI_MAX_NUM_CHANNELS
+#define MONAI_MAX_NUM_CHANNELS 1024
+#endif
+
+// This parameter allows for a little bit of tolerance when considering
+// a coordinate as "out-of-bound" (if !extrapolate)
+#define TINY 5e-2
+
+using at::Tensor;
+using at::TensorOptions;
+using c10::IntArrayRef;
+
+namespace monai {
+MONAI_NAMESPACE_DEVICE { // cpu
+
+  namespace { // anonymous namespace > everything inside has internal linkage
+
+  // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+  //                        INDEXING UTILS
+  // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+  // This class reads and sets all the parameters that will later be used
+  // by the algorithm in PushPullImpl. All of this is done outside of the
+  // implementation class so that we do not depend on generic types. The
+  // point is to pre-allocate all necessary tensors so that we can check
+  // if they're all compatible with 32 bit math. If it's the case, we can
+  // dispatch to a 32b cuda implementation, which might increase
+  // performance. Else, we use 64 bit math to compute offsets.
+  // (On CPU, we always use 64 bit offsets because it doesn't make a huge
+  // difference. It would be different if we had a vectorized
+  // implementation as in PyTorch).
+  class PushPullAllocator {
+   public:
+    static constexpr int64_t max_int32 = std::numeric_limits<int32_t>::max();
+
+    // ~~~ CONSTRUCTORS ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    MONAI_HOST
+    PushPullAllocator(
+        int dim,
+        BoundVectorRef bound,
+        InterpolationVectorRef interpolation,
+        bool extrapolate,
+        bool do_pull,
+        bool do_push,
+        bool do_count,
+        bool do_grad,
+        bool do_sgrad)
+        : dim(dim),
+          bound0(bound.size() > 0 ? bound[0] : BoundType::Replicate),
+          bound1(
+              bound.size() > 1       ? bound[1]
+                  : bound.size() > 0 ? bound[0]
+                                     : BoundType::Replicate),
+          bound2(
+              bound.size() > 2       ? bound[2]
+                  : bound.size() > 1 ? bound[1]
+                  : bound.size() > 0 ? bound[0]
+                                     : BoundType::Replicate),
+          interpolation0(interpolation.size() > 0 ? interpolation[0] : InterpolationType::Linear),
+          interpolation1(
+              interpolation.size() > 1       ? interpolation[1]
+                  : interpolation.size() > 0 ? interpolation[0]
+                                             : InterpolationType::Linear),
+          interpolation2(
+              interpolation.size() > 2       ? interpolation[2]
+                  : interpolation.size() > 1 ? interpolation[1]
+                  : interpolation.size() > 0 ? interpolation[0]
+                                             : InterpolationType::Linear),
+          extrapolate(extrapolate),
+          do_pull(do_pull),
+          do_push(do_push),
+          do_count(do_count),
+          do_grad(do_grad),
+          do_sgrad(do_sgrad) {
+      iso = interpolation0 == interpolation1 && interpolation0 == interpolation2;
+    }
+
+    // ~~~ FUNCTORS ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    // Usually used for pull:
+    // - do_pull  -> return source[grid]
+    // - do_push  -> fails
+    // - do_grad  -> return J(source)[grid]
+    // - do_sgrad -> return H(source)[grid]
+    MONAI_HOST void ioset(const Tensor& source, const Tensor& grid) {
+      init_all();
+      init_source(source);
+      init_grid(grid);
+      init_output();
+    }
+
+    // Usually used for pull_backward:
+    // - do_pull  -> return source[grid]
+    // - do_push  -> return push(target, grid, source.shape)
+    // - do_grad  -> return J(source)[grid]
+    // - do_sgrad -> return H(source)[grid]
+    MONAI_HOST void ioset(const Tensor& source, const Tensor& grid, const Tensor& target) {
+      init_all();
+      init_source(source);
+      init_grid(grid);
+      init_target(target);
+      init_output();
+    }
+
+    // Usually used for push:
+    // - do_pull  -> fails
+    // - do_push  -> return push(target, grid, source_size)
+    // - do_grad  -> fails
+    // - do_sgrad -> fails
+    MONAI_HOST void ioset(IntArrayRef source_size, const Tensor& grid, const Tensor& target) {
+      init_all();
+      init_source(source_size);
+      init_grid(grid);
+      init_target(target);
+      init_output();
+    }
+
+    // Usually used for count:
+    // - do_pull  -> fails
+    // - do_push  -> return push(ones, grid, source_size)
+    // - do_grad  -> fails
+    // - do_sgrad -> fails
+    MONAI_HOST void ioset(IntArrayRef source_size, const Tensor& grid) {
+      init_all();
+      init_source(source_size);
+      init_grid(grid);
+      init_output();
+    }
+
+    // We just check that all tensors that we own are compatible with 32b math
+    bool canUse32BitIndexMath(int64_t max_elem = max_int32) const {
+      return src_32b_ok && trgt_32b_ok && grid_32b_ok && grad_32b_ok && out_32b_ok;
+    }
+
+   private:
+    // Copied from aten/src/ATen/native/IndexingUtils.cpp in PyTorch 1.6.
+    // It is used to decide to which pointer type we should dispatch to.
+    // Basically, we need to make sure that the "furthest" element we need
+    // to reach is less than max_elem away.
+    static bool tensorCanUse32BitIndexMath(const Tensor& t, int64_t max_elem = max_int32) {
+      int64_t elements = t.numel();
+      if (elements >= max_elem) {
+        return false;
+      }
+      if (elements == 0) {
+        return max_elem > 0;
+      }
+
+      int64_t offset = 0;
+      int64_t linearId = elements - 1;
+
+      // NOTE: Assumes all strides are positive, which is true for now
+      for (int i = t.dim() - 1; i >= 0; --i) {
+        int64_t curDimIndex = linearId % t.size(i);
+        int64_t curDimOffset = curDimIndex * t.stride(i);
+        offset += curDimOffset;
+        linearId /= t.size(i);
+      }
+
+      if (offset >= max_elem) {
+        return false;
+      }
+
+      return true;
+    }
+
+    // ~~~ COMPONENTS ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    MONAI_HOST void init_all();
+    MONAI_HOST void init_source(const Tensor& source);
+    MONAI_HOST void init_source(IntArrayRef source_size);
+    MONAI_HOST void init_grid(const Tensor& grid);
+    MONAI_HOST void init_target(const Tensor& target);
+    MONAI_HOST void init_output();
+
+    // ~~~ OPTIONS ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    int dim; // dimensionality (2 or 3)
+    BoundType bound0; // boundary condition  // x|W
+    BoundType bound1; // boundary condition  // y|H
+    BoundType bound2; // boundary condition  // z|D
+    InterpolationType interpolation0; // interpolation order // x|W
+    InterpolationType interpolation1; // interpolation order // y|H
+    InterpolationType interpolation2; // interpolation order // z|D
+    bool iso; // isotropic interpolation?
+    bool extrapolate; // compute out-of-bound values
+    bool do_pull; // sample a volume
+    bool do_push; // splat a volume
+    bool do_count; // splatting weights (= jacobian determinant)
+    bool do_grad; // backprop: gradient of grid // pull
+    bool do_sgrad; // sample spatial gradients
+
+    // ~~~ NAVIGATORS ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    std::deque<Tensor> output;
+    TensorOptions src_opt;
+    TensorOptions grid_opt;
+    TensorOptions trgt_opt;
+    int64_t N;
+    int64_t C;
+    int64_t src_X;
+    int64_t src_Y;
+    int64_t src_Z;
+    int64_t trgt_X;
+    int64_t trgt_Y;
+    int64_t trgt_Z;
+    int64_t trgt_K;
+    int64_t src_sN;
+    int64_t src_sC;
+    int64_t src_sX;
+    int64_t src_sY;
+    int64_t src_sZ;
+    bool src_32b_ok;
+    void* src_ptr;
+    int64_t trgt_sN;
+    int64_t trgt_sC;
+    int64_t trgt_sX;
+    int64_t trgt_sY;
+    int64_t trgt_sZ;
+    int64_t trgt_sK;
+    bool trgt_32b_ok;
+    void* trgt_ptr;
+    int64_t grid_sN;
+    int64_t grid_sC;
+    int64_t grid_sX;
+    int64_t grid_sY;
+    int64_t grid_sZ;
+    bool grid_32b_ok;
+    void* grid_ptr;
+    int64_t out_sN;
+    int64_t out_sC;
+    int64_t out_sX;
+    int64_t out_sY;
+    int64_t out_sZ;
+    int64_t out_sK; // gradient dimension
+    bool out_32b_ok;
+    void* out_ptr;
+    int64_t grad_sN;
+    int64_t grad_sC;
+    int64_t grad_sX;
+    int64_t grad_sY;
+    int64_t grad_sZ;
+    bool grad_32b_ok;
+    void* grad_ptr;
+
+    // Allow PushPullImpl's constructor to access PushPullAllocator's
+    // private members.
+    template <typename scalar_t, typename offset_t>
+    friend class PushPullImpl;
+  };
+
+  // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+  //                          INITIALISATION
+  // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+  MONAI_HOST
+  void PushPullAllocator::init_all() {
+    src_opt = grid_opt = trgt_opt = TensorOptions();
+    N = C = 1L;
+    src_X = src_Y = src_Z = 1L;
+    trgt_X = trgt_Y = trgt_Z = 1L;
+    trgt_K = 0L;
+    src_sN = src_sC = src_sX = src_sY = src_sZ = 0L;
+    grid_sN = grid_sC = grid_sX = grid_sY = grid_sZ = 0L;
+    grad_sN = grad_sC = grad_sX = grad_sY = grad_sZ = 0L;
+    trgt_sN = trgt_sC = trgt_sX = trgt_sY = trgt_sZ = trgt_sK = 0L;
+    out_sN = out_sC = out_sX = out_sY = out_sZ = out_sK = 0L;
+    src_ptr = trgt_ptr = grid_ptr = out_ptr = grad_ptr = static_cast<float*>(0);
+    src_32b_ok = trgt_32b_ok = grid_32b_ok = out_32b_ok = grad_32b_ok = true;
+  }
+
+  MONAI_HOST
+  void PushPullAllocator::init_source(const Tensor& source) {
+    N = source.size(0);
+    C = source.size(1);
+    src_X = source.size(2);
+    src_Y = dim < 2 ? 1L : source.size(3);
+    src_Z = dim < 3 ? 1L : source.size(4);
+    src_sN = source.stride(0);
+    src_sC = source.stride(1);
+    src_sX = source.stride(2);
+    src_sY = dim < 2 ? 0L : source.stride(3);
+    src_sZ = dim < 3 ? 0L : source.stride(4);
+    src_ptr = source.data_ptr();
+    src_opt = source.options();
+    src_32b_ok = tensorCanUse32BitIndexMath(source);
+  }
+
+  MONAI_HOST
+  void PushPullAllocator::init_source(IntArrayRef source_size) {
+    src_X = source_size[0];
+    src_Y = dim < 2 ? 1L : source_size[1];
+    src_Z = dim < 3 ? 1L : source_size[2];
+  }
+
+  MONAI_HOST
+  void PushPullAllocator::init_grid(const Tensor& grid) {
+    N = grid.size(0);
+    trgt_X = grid.size(1);
+    trgt_Y = dim < 2 ? 1L : grid.size(2);
+    trgt_Z = dim < 3 ? 1L : grid.size(3);
+    grid_sN = grid.stride(0);
+    grid_sX = grid.stride(1);
+    grid_sY = dim < 2 ? 0L : grid.stride(2);
+    grid_sZ = dim < 3 ? 0L : grid.stride(3);
+    grid_sC = grid.stride(dim == 1 ? 2 : dim == 2 ? 3 : 4);
+    grid_ptr = grid.data_ptr();
+    grid_opt = grid.options();
+    grid_32b_ok = tensorCanUse32BitIndexMath(grid);
+  }
+
+  MONAI_HOST
+  void PushPullAllocator::init_target(const Tensor& target) {
+    N = target.size(0);
+    C = target.size(1);
+    trgt_X = target.size(2);
+    trgt_Y = dim < 2 ? 1L : target.size(3);
+    trgt_Z = dim < 3 ? 1L : target.size(4);
+    trgt_K = target.dim() == dim + 3 ? target.size(dim == 1 ? 3 : dim == 2 ? 4 : 5) : 0L;
+    trgt_sN = target.stride(0);
+    trgt_sC = target.stride(1);
+    trgt_sX = target.stride(2);
+    trgt_sY = dim < 2 ? 0L : target.stride(3);
+    trgt_sZ = dim < 3 ? 0L : target.stride(4);
+    trgt_sK = target.dim() == dim + 3 ? target.stride(dim == 1 ? 3 : dim == 2 ? 4 : 5) : 0L;
+    trgt_ptr = target.data_ptr();
+    trgt_opt = target.options();
+    trgt_32b_ok = tensorCanUse32BitIndexMath(target);
+  }
+
+  MONAI_HOST
+  void PushPullAllocator::init_output() {
+    output.clear();
+    if (do_pull) {
+      if (dim == 1)
+        output.push_back(at::empty({N, C, trgt_X}, src_opt));
+      else if (dim == 2)
+        output.push_back(at::empty({N, C, trgt_X, trgt_Y}, src_opt));
+      else
+        output.push_back(at::empty({N, C, trgt_X, trgt_Y, trgt_Z}, src_opt));
+      auto pull = output.back();
+      out_sN = pull.stride(0);
+      out_sC = pull.stride(1);
+      out_sX = pull.stride(2);
+      out_sY = dim < 2 ? 0L : pull.stride(3);
+      out_sZ = dim < 3 ? 0L : pull.stride(4);
+      out_sK = 0L;
+      out_ptr = pull.data_ptr();
+      out_32b_ok = tensorCanUse32BitIndexMath(pull);
+    } else if (do_sgrad) {
+      if (dim == 1)
+        output.push_back(at::empty({N, C, trgt_X, 1}, src_opt));
+      else if (dim == 2)
+        output.push_back(at::empty({N, C, trgt_X, trgt_Y, 2}, src_opt));
+      else
+        output.push_back(at::empty({N, C, trgt_X, trgt_Y, trgt_Z, 3}, src_opt));
+      auto sgrad = output.back();
+      out_sN = sgrad.stride(0);
+      out_sC = sgrad.stride(1);
+      out_sX = sgrad.stride(2);
+      out_sY = dim < 2 ? 0L : sgrad.stride(3);
+      out_sZ = dim < 3 ? 0L : sgrad.stride(4);
+      out_sK = sgrad.stride(dim == 1 ? 3 : dim == 2 ? 4 : 5);
+      out_ptr = sgrad.data_ptr();
+      out_32b_ok = tensorCanUse32BitIndexMath(sgrad);
+
+      if (iso && interpolation0 == InterpolationType::Nearest)
+        sgrad.zero_();
+      if (iso && interpolation0 == InterpolationType::Linear && dim == 1)
+        sgrad.zero_();
+    } else if (do_push) {
+      if (dim == 1)
+        output.push_back(at::zeros({N, C, src_X}, trgt_opt));
+      else if (dim == 2)
+        output.push_back(at::zeros({N, C, src_X, src_Y}, trgt_opt));
+      else
+        output.push_back(at::zeros({N, C, src_X, src_Y, src_Z}, trgt_opt));
+      auto push = output.back();
+      out_sN = push.stride(0);
+      out_sC = push.stride(1);
+      out_sX = push.stride(2);
+      out_sY = dim < 2 ? 0L : push.stride(3);
+      out_sZ = dim < 3 ? 0L : push.stride(4);
+      out_sK = 0L;
+      out_ptr = push.data_ptr();
+      out_32b_ok = tensorCanUse32BitIndexMath(push);
+    } else if (do_count) {
+      if (dim == 1)
+        output.push_back(at::zeros({N, 1, src_X}, grid_opt));
+      else if (dim == 2)
+        output.push_back(at::zeros({N, 1, src_X, src_Y}, grid_opt));
+      else
+        output.push_back(at::zeros({N, 1, src_X, src_Y, src_Z}, grid_opt));
+      auto count = output.back();
+      out_sN = count.stride(0);
+      out_sC = count.stride(1);
+      out_sX = count.stride(2);
+      out_sY = dim < 2 ? 0L : count.stride(3);
+      out_sZ = dim < 3 ? 0L : count.stride(4);
+      out_sK = 0L;
+      out_ptr = count.data_ptr();
+      out_32b_ok = tensorCanUse32BitIndexMath(count);
+    }
+    if (do_grad) {
+      if (dim == 1)
+        output.push_back(at::zeros({N, trgt_X, 1}, grid_opt));
+      else if (dim == 2)
+        output.push_back(at::zeros({N, trgt_X, trgt_Y, 2}, grid_opt));
+      else
+        output.push_back(at::zeros({N, trgt_X, trgt_Y, trgt_Z, 3}, grid_opt));
+      auto grad = output.back();
+      grad_sN = grad.stride(0);
+      grad_sX = grad.stride(1);
+      grad_sY = dim < 2 ? 0L : grad.stride(2);
+      grad_sZ = dim < 3 ? 0L : grad.stride(3);
+      grad_sC = grad.stride(dim == 1 ? 2 : dim == 2 ? 3 : 4);
+      grad_ptr = grad.data_ptr();
+      out_32b_ok = tensorCanUse32BitIndexMath(grad);
+
+      if (iso && interpolation0 == InterpolationType::Nearest)
+        grad.zero_();
+    }
+  }
+
+  // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+  //                        GENERIC PUSHPULL CLASS
+  // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+  // This class implements the bulk of the code.
+  // /!\ No type and shape checking is performed here.
+
+  template <typename scalar_t, typename offset_t>
+  class PushPullImpl {
+   public:
+    // ~~~ CONSTRUCTOR ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    PushPullImpl(const PushPullAllocator& info)
+        : output(info.output),
+          dim(info.dim),
+          bound0(info.bound0),
+          bound1(info.bound1),
+          bound2(info.bound2),
+          interpolation0(info.interpolation0),
+          interpolation1(info.interpolation1),
+          interpolation2(info.interpolation1),
+          iso(info.iso),
+          extrapolate(info.extrapolate),
+          do_pull(info.do_pull),
+          do_push(info.do_push),
+          do_count(info.do_count),
+          do_grad(info.do_grad),
+          do_sgrad(info.do_sgrad),
+          N(static_cast<offset_t>(info.N)),
+          C(static_cast<offset_t>(info.C)),
+          src_X(static_cast<offset_t>(info.src_X)),
+          src_Y(static_cast<offset_t>(info.src_Y)),
+          src_Z(static_cast<offset_t>(info.src_Z)),
+          trgt_X(static_cast<offset_t>(info.trgt_X)),
+          trgt_Y(static_cast<offset_t>(info.trgt_Y)),
+          trgt_Z(static_cast<offset_t>(info.trgt_Z)),
+          trgt_K(static_cast<offset_t>(info.trgt_K)),
+          src_sN(static_cast<offset_t>(info.src_sN)),
+          src_sC(static_cast<offset_t>(info.src_sC)),
+          src_sX(static_cast<offset_t>(info.src_sX)),
+          src_sY(static_cast<offset_t>(info.src_sY)),
+          src_sZ(static_cast<offset_t>(info.src_sZ)),
+          src_ptr(static_cast<scalar_t*>(info.src_ptr)),
+          trgt_sN(static_cast<offset_t>(info.trgt_sN)),
+          trgt_sC(static_cast<offset_t>(info.trgt_sC)),
+          trgt_sX(static_cast<offset_t>(info.trgt_sX)),
+          trgt_sY(static_cast<offset_t>(info.trgt_sY)),
+          trgt_sZ(static_cast<offset_t>(info.trgt_sZ)),
+          trgt_sK(static_cast<offset_t>(info.trgt_sK)),
+          trgt_ptr(static_cast<scalar_t*>(info.trgt_ptr)),
+          grid_sN(static_cast<offset_t>(info.grid_sN)),
+          grid_sC(static_cast<offset_t>(info.grid_sC)),
+          grid_sX(static_cast<offset_t>(info.grid_sX)),
+          grid_sY(static_cast<offset_t>(info.grid_sY)),
+          grid_sZ(static_cast<offset_t>(info.grid_sZ)),
+          grid_ptr(static_cast<scalar_t*>(info.grid_ptr)),
+          out_sN(static_cast<offset_t>(info.out_sN)),
+          out_sC(static_cast<offset_t>(info.out_sC)),
+          out_sX(static_cast<offset_t>(info.out_sX)),
+          out_sY(static_cast<offset_t>(info.out_sY)),
+          out_sZ(static_cast<offset_t>(info.out_sZ)),
+          out_sK(static_cast<offset_t>(info.out_sK)),
+          out_ptr(static_cast<scalar_t*>(info.out_ptr)),
+          grad_sN(static_cast<offset_t>(info.grad_sN)),
+          grad_sC(static_cast<offset_t>(info.grad_sC)),
+          grad_sX(static_cast<offset_t>(info.grad_sX)),
+          grad_sY(static_cast<offset_t>(info.grad_sY)),
+          grad_sZ(static_cast<offset_t>(info.grad_sZ)),
+          grad_ptr(static_cast<scalar_t*>(info.grad_ptr)) {}
+
+    // ~~~ PUBLIC VALUE ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    std::deque<Tensor> output;
+
+    // MONAI_HOST MONAI_DEVICE void printInfo() const {
+    //   printf("dim: %d\n", dim);
+    //   printf("do_pull:  %d\n", do_pull);
+    //   printf("do_push:  %d\n", do_push);
+    //   printf("do_count: %d\n", do_count);
+    //   printf("do_sgrad: %d\n", do_sgrad);
+    //   printf("do_grad:  %d\n", do_grad);
+    //   printf("bound:         [%d %d %d]\n", static_cast<int>(bound0),
+    //     static_cast<int>(bound1), static_cast<int>(bound2));
+    //   printf("interpolation: [%d %d %d]\n", static_cast<int>(interpolation0),
+    //     static_cast<int>(interpolation1), static_cast<int>(interpolation2));
+    //   printf("src:  [%d %d %d]\n", src_Z, src_Y, src_X);
+    //   printf("trgt: [%d %d %d (%d)]\n", trgt_Z, trgt_Y, trgt_X, trgt_K);
+    //   printf("N: %d\n", N);
+    //   printf("C: %d\n", C);
+    //   printf("src  -> %lu\n", reinterpret_cast<std::uintptr_t>(src_ptr));
+    //   printf("trgt -> %lu\n", reinterpret_cast<std::uintptr_t>(trgt_ptr));
+    //   printf("grid -> %lu\n", reinterpret_cast<std::uintptr_t>(grid_ptr));
+    //   printf("out  -> %lu\n", reinterpret_cast<std::uintptr_t>(out_ptr));
+    //   printf("grad -> %lu\n", reinterpret_cast<std::uintptr_t>(grad_ptr));
+    // }
+
+    // ~~~ FUNCTORS ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    // Loop over all voxels
+    void loop() const;
+
+    MONAI_HOST MONAI_DEVICE int64_t voxcount() const {
+      return N * trgt_X * trgt_Y * trgt_Z;
+    }
+
+   private:
+    // ~~~ COMPONENTS ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    MONAI_DEVICE void check1d(offset_t w, offset_t n) const;
+    MONAI_DEVICE void check2d(offset_t w, offset_t h, offset_t n) const;
+    MONAI_DEVICE void check3d(offset_t w, offset_t h, offset_t d, offset_t n) const;
+    MONAI_DEVICE void interpolate1d(scalar_t x, offset_t w, offset_t n) const;
+    MONAI_DEVICE void interpolate1d_nearest(scalar_t x, offset_t w, offset_t n) const;
+    MONAI_DEVICE void interpolate1d_linear(scalar_t x, offset_t w, offset_t n) const;
+    MONAI_DEVICE void interpolate1d_sliding(scalar_t x, offset_t w, offset_t n) const { /*TODO*/
+    }
+    MONAI_DEVICE void interpolate1d_sliding_nearest(scalar_t x, offset_t w, offset_t n) const { /*TODO*/
+    }
+    MONAI_DEVICE void interpolate1d_sliding_linear(scalar_t x, offset_t w, offset_t n) const { /*TODO*/
+    }
+    MONAI_DEVICE void interpolate2d(scalar_t x, scalar_t y, offset_t w, offset_t h, offset_t n) const;
+    MONAI_DEVICE void interpolate2d_nearest(scalar_t x, scalar_t y, offset_t w, offset_t h, offset_t n) const;
+    MONAI_DEVICE void interpolate2d_bilinear(scalar_t x, scalar_t y, offset_t w, offset_t h, offset_t n) const;
+    MONAI_DEVICE void interpolate2d_sliding(scalar_t x, scalar_t y, offset_t w, offset_t h, offset_t n) const { /*TODO*/
+    }
+    MONAI_DEVICE void interpolate2d_sliding_nearest(scalar_t x, scalar_t y, offset_t w, offset_t h, offset_t n)
+        const { /*TODO*/
+    }
+    MONAI_DEVICE void interpolate2d_sliding_bilinear(scalar_t x, scalar_t y, offset_t w, offset_t h, offset_t n)
+        const { /*TODO*/
+    }
+    MONAI_DEVICE void interpolate3d(scalar_t x, scalar_t y, scalar_t z, offset_t w, offset_t h, offset_t d, offset_t n)
+        const;
+    MONAI_DEVICE void interpolate3d_nearest(
+        scalar_t x,
+        scalar_t y,
+        scalar_t z,
+        offset_t w,
+        offset_t h,
+        offset_t d,
+        offset_t n) const;
+    MONAI_DEVICE void interpolate3d_trilinear(
+        scalar_t x,
+        scalar_t y,
+        scalar_t z,
+        offset_t w,
+        offset_t h,
+        offset_t d,
+        offset_t n) const;
+    MONAI_DEVICE void interpolate3d_sliding(
+        scalar_t x,
+        scalar_t y,
+        scalar_t z,
+        offset_t w,
+        offset_t h,
+        offset_t d,
+        offset_t n) const { /*TODO*/
+    }
+    MONAI_DEVICE void interpolate3d_sliding_nearest(
+        scalar_t x,
+        scalar_t y,
+        scalar_t z,
+        offset_t w,
+        offset_t h,
+        offset_t d,
+        offset_t n) const { /*TODO*/
+    }
+    MONAI_DEVICE void interpolate3d_sliding_trilinear(
+        scalar_t x,
+        scalar_t y,
+        scalar_t z,
+        offset_t w,
+        offset_t h,
+        offset_t d,
+        offset_t n) const { /*TODO*/
+    }
+
+    // ~~~ OPTIONS ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    int dim; // dimensionality (2 or 3)
+    BoundType bound0; // boundary condition  // x|W
+    BoundType bound1; // boundary condition  // y|H
+    BoundType bound2; // boundary condition  // z|D
+    InterpolationType interpolation0; // interpolation order // x|W
+    InterpolationType interpolation1; // interpolation order // y|H
+    InterpolationType interpolation2; // interpolation order // z|D
+    bool iso; // isotropic interpolation?
+    bool extrapolate; // compute out-of-bound values
+    bool do_pull; // sample a volume
+    bool do_push; // splat a volume
+    bool do_count; // splatting weights (= jacobian determinant)
+    bool do_grad; // backprop: gradient of grid // pull
+    bool do_sgrad; // sample spatial gradients
+
+    // ~~~ NAVIGATORS ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    offset_t N;
+    offset_t C;
+    offset_t src_X;
+    offset_t src_Y;
+    offset_t src_Z;
+    offset_t trgt_X;
+    offset_t trgt_Y;
+    offset_t trgt_Z;
+    offset_t trgt_K;
+    offset_t src_sN;
+    offset_t src_sC;
+    offset_t src_sX;
+    offset_t src_sY;
+    offset_t src_sZ;
+    scalar_t* src_ptr;
+    offset_t trgt_sN;
+    offset_t trgt_sC;
+    offset_t trgt_sX;
+    offset_t trgt_sY;
+    offset_t trgt_sZ;
+    offset_t trgt_sK;
+    scalar_t* trgt_ptr;
+    offset_t grid_sN;
+    offset_t grid_sC;
+    offset_t grid_sX;
+    offset_t grid_sY;
+    offset_t grid_sZ;
+    scalar_t* grid_ptr;
+    offset_t out_sN;
+    offset_t out_sC;
+    offset_t out_sX;
+    offset_t out_sY;
+    offset_t out_sZ;
+    offset_t out_sK; // gradient dimension
+    scalar_t* out_ptr;
+    offset_t grad_sN;
+    offset_t grad_sC;
+    offset_t grad_sX;
+    offset_t grad_sY;
+    offset_t grad_sZ;
+    scalar_t* grad_ptr;
+  };
+
+  // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+  //                             LOOP
+  // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+  // This bit loops over all target voxels. We therefore need to
+  // convert linear indices to multivariate indices. The way I do it
+  // might not be optimal.
+  // Note that I parallelize across all voxels (whereas ATen's grid
+  // sampler is only parallelized across batches).
+  //
+  // TODO: check that the default grain size is optimal. We do quite a lot
+  // of compute per voxel, so a smaller value might be better suited.
+  template <typename scalar_t, typename offset_t>
+  MONAI_HOST void PushPullImpl<scalar_t, offset_t>::loop() const {
+#if !(AT_PARALLEL_OPENMP)
+    if (do_push) {
+      // I do not have access to atomic operations so I cannot
+      // parallelize across voxels.
+      at::parallel_for(0, N, 0, [&](offset_t start, offset_t end) {
+        for (offset_t n = start; n < end; ++n) {
+          if (dim == 1) {
+            for (offset_t w = 0; w < trgt_X; ++w)
+              check1d(w, n);
+          } else if (dim == 2) {
+            for (offset_t h = 0; h < trgt_Y; ++h)
+              for (offset_t w = 0; w < trgt_X; ++w)
+                check2d(w, h, n);
+          } else {
+            for (offset_t d = 0; d < trgt_Z; ++d)
+              for (offset_t h = 0; h < trgt_Y; ++h)
+                for (offset_t w = 0; w < trgt_X; ++w)
+                  check3d(w, h, d, n);
+          }
+        }
+      });
+      return;
+    }
+
+#endif
+    // Parallelize across voxels
+    offset_t trgt_NXYZ = trgt_Z * trgt_Y * trgt_X * N;
+    offset_t trgt_XYZ = trgt_Z * trgt_Y * trgt_X;
+    offset_t trgt_YZ = trgt_Z * trgt_Y;
+    at::parallel_for(0, trgt_NXYZ, GRAIN_SIZE, [&](offset_t start, offset_t end) {
+      offset_t n, w, h, d;
+      for (offset_t i = start; i < end; ++i) {
+        // Convert index: linear to sub
+        n = (i / trgt_XYZ);
+        w = (i / trgt_YZ) % trgt_X;
+        h = (i / trgt_Z) % trgt_Y;
+        d = i % trgt_Z;
+
+        if (dim == 1)
+          check1d(w, n);
+        else if (dim == 2)
+          check2d(w, h, n);
+        else
+          check3d(w, h, d, n);
+      }
+    });
+  }
+
+  // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+  //                        CHECK OUT-OF-BOUND
+  // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+  // Here, we:
+  // 1) read the [x,y,z] source coordinate for the current target voxel
+  // 3) check if the source coordinate is in bounds
+
+  template <typename scalar_t, typename offset_t>
+  MONAI_DEVICE void PushPullImpl<scalar_t, offset_t>::check3d(offset_t w, offset_t h, offset_t d, offset_t n) const {
+    // get the corresponding input x, y, z co-ordinates from grid
+    scalar_t* grid_ptr_NXYZ = grid_ptr + n * grid_sN + w * grid_sX + h * grid_sY + d * grid_sZ;
+    scalar_t x = *grid_ptr_NXYZ;
+    scalar_t y = grid_ptr_NXYZ[grid_sC];
+    scalar_t z = grid_ptr_NXYZ[grid_sC * 2];
+
+    // Check if out-of-bound
+    if (!(extrapolate ||
+          (inbounds(x, src_X, static_cast<scalar_t>(TINY)) && inbounds(y, src_Y, static_cast<scalar_t>(TINY)) &&
+           inbounds(z, src_Z, static_cast<scalar_t>(TINY))))) {
+      if (do_pull || do_sgrad) {
+        scalar_t* out_ptr_NCXYZ = out_ptr + n * out_sN + w * out_sX + h * out_sY + d * out_sZ;
+        for (offset_t c = 0; c < C; ++c, out_ptr_NCXYZ += out_sC) {
+          *out_ptr_NCXYZ = static_cast<scalar_t>(0);
+          if (do_sgrad) {
+            out_ptr_NCXYZ[out_sK] = static_cast<scalar_t>(0);
+            out_ptr_NCXYZ[out_sK * 2] = static_cast<scalar_t>(0);
+          }
+        }
+      }
+      if (do_grad) {
+        scalar_t* grad_ptr_NXYZ = grad_ptr + n * grad_sN + w * grad_sX + h * grad_sY + d * grad_sZ;
+        (*grad_ptr_NXYZ) = static_cast<scalar_t>(0);
+        grad_ptr_NXYZ[grad_sC] = static_cast<scalar_t>(0);
+        grad_ptr_NXYZ[grad_sC * 2] = static_cast<scalar_t>(0);
+      }
+      return;
+    }
+
+    // Next step
+    if (bound0 == BoundType::Sliding) {
+      if (iso)
+        switch (static_cast<int>(interpolation0)) {
+          case 0:
+            return interpolate3d_sliding_nearest(x, y, z, w, h, d, n);
+          case 1:
+            return interpolate3d_sliding_trilinear(x, y, z, w, h, d, n);
+        }
+      return interpolate3d_sliding(x, y, z, w, h, d, n);
+    } else {
+      if (iso)
+        switch (static_cast<int>(interpolation0)) {
+          case 0:
+            return interpolate3d_nearest(x, y, z, w, h, d, n);
+          case 1:
+            return interpolate3d_trilinear(x, y, z, w, h, d, n);
+        }
+      return interpolate3d(x, y, z, w, h, d, n);
+    }
+  }
+
+  template <typename scalar_t, typename offset_t>
+  MONAI_DEVICE void PushPullImpl<scalar_t, offset_t>::check2d(offset_t w, offset_t h, offset_t n) const {
+    // get the corresponding input x, y, z co-ordinates from grid
+    scalar_t* grid_ptr_NXY = grid_ptr + n * grid_sN + w * grid_sX + h * grid_sY;
+    scalar_t x = *grid_ptr_NXY;
+    scalar_t y = grid_ptr_NXY[grid_sC];
+
+    // Check if out-of-bound
+    if (!(extrapolate ||
+          (inbounds(x, src_X, static_cast<scalar_t>(TINY)) && inbounds(y, src_Y, static_cast<scalar_t>(TINY))))) {
+      if (do_pull || do_sgrad) {
+        scalar_t* out_ptr_NCXY = out_ptr + n * out_sN + w * out_sX + h * out_sY;
+        for (offset_t c = 0; c < C; ++c, out_ptr_NCXY += out_sC) {
+          *out_ptr_NCXY = static_cast<scalar_t>(0);
+          if (do_sgrad)
+            out_ptr_NCXY[out_sK] = static_cast<scalar_t>(0);
+        }
+      }
+      if (do_grad) {
+        scalar_t* grad_ptr_NXY = grad_ptr + n * grad_sN + w * grad_sX + h * grad_sY;
+        (*grad_ptr_NXY) = static_cast<scalar_t>(0);
+        grad_ptr_NXY[grad_sC] = static_cast<scalar_t>(0);
+      }
+      return;
+    }
+
+    // Next step
+    if (bound0 == BoundType::Sliding) {
+      if (iso)
+        switch (static_cast<int>(interpolation0)) {
+          case 0:
+            return interpolate2d_sliding_nearest(x, y, w, h, n);
+          case 1:
+            return interpolate2d_sliding_bilinear(x, y, w, h, n);
+        }
+      return interpolate2d_sliding(x, y, w, h, n);
+    } else {
+      if (iso)
+        switch (static_cast<int>(interpolation0)) {
+          case 0:
+            return interpolate2d_nearest(x, y, w, h, n);
+          case 1:
+            return interpolate2d_bilinear(x, y, w, h, n);
+        }
+      return interpolate2d(x, y, w, h, n);
+    }
+  }
+
+  template <typename scalar_t, typename offset_t>
+  MONAI_DEVICE void PushPullImpl<scalar_t, offset_t>::check1d(offset_t w, offset_t n) const {
+    // get the corresponding input x, y, z co-ordinates from grid
+    scalar_t* grid_ptr_NX = grid_ptr + n * grid_sN + w * grid_sX;
+    scalar_t x = *grid_ptr_NX;
+
+    // Check if out-of-bound
+    if (!(extrapolate || inbounds(x, src_X, static_cast<scalar_t>(TINY)))) {
+      if (do_pull || do_sgrad) {
+        scalar_t* out_ptr_NCX = out_ptr + n * out_sN + w * out_sX;
+        for (offset_t c = 0; c < C; ++c, out_ptr_NCX += out_sC) {
+          *out_ptr_NCX = static_cast<scalar_t>(0);
+          if (do_sgrad)
+            out_ptr_NCX[out_sK] = static_cast<scalar_t>(0);
+        }
+      }
+      if (do_grad) {
+        scalar_t* grad_ptr_NX = grad_ptr + n * grad_sN + w * grad_sX;
+        (*grad_ptr_NX) = static_cast<scalar_t>(0);
+        grad_ptr_NX[grad_sC] = static_cast<scalar_t>(0);
+      }
+      return;
+    }
+
+    // Next step
+    if (bound0 == BoundType::Sliding) {
+      if (iso)
+        switch (static_cast<int>(interpolation0)) {
+          case 0:
+            return interpolate1d_sliding_nearest(x, w, n);
+          case 1:
+            return interpolate1d_sliding_linear(x, w, n);
+        }
+      return interpolate1d_sliding(x, w, n);
+    } else {
+      if (iso)
+        switch (static_cast<int>(interpolation0)) {
+          case 0:
+            return interpolate1d_nearest(x, w, n);
+          case 1:
+            return interpolate1d_linear(x, w, n);
+        }
+      return interpolate1d(x, w, n);
+    }
+  }
+
+  // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+  //                     GENERIC INTERPOLATION 3D
+  // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+  template <typename scalar_t, typename offset_t>
+  MONAI_DEVICE void PushPullImpl<scalar_t, offset_t>::interpolate3d(
+      scalar_t x,
+      scalar_t y,
+      scalar_t z,
+      offset_t w,
+      offset_t h,
+      offset_t d,
+      offset_t n) const {
+    // Get corner pixel values from (x, y, z)
+    offset_t bx0, bx1, by0, by1, bz0, bz1;
+    interpolation::bounds(interpolation0, x, bx0, bx1);
+    interpolation::bounds(interpolation1, y, by0, by1);
+    interpolation::bounds(interpolation2, z, bz0, bz1);
+    offset_t dbx = bx1 - bx0;
+    offset_t dby = by1 - by0;
+    offset_t dbz = bz1 - bz0;
+
+    // Pre-compute offsets and target value
+    scalar_t* src_ptr_NC0 = src_ptr + n * src_sN;
+    scalar_t* out_ptr_NC0 = out_ptr + n * out_sN;
+    scalar_t* out_ptr_NCXYZ0 = out_ptr + n * out_sN + w * out_sX + h * out_sY + d * out_sZ;
+    scalar_t* trgt_ptr_NCXYZ = trgt_ptr + n * trgt_sN + w * trgt_sX + h * trgt_sY + d * trgt_sZ;
+    scalar_t target[3 * MONAI_MAX_NUM_CHANNELS];
+    if (trgt_ptr && (do_push || do_grad))
+      for (offset_t c = 0; c < C; ++c, trgt_ptr_NCXYZ += trgt_sC) {
+        target[c] = *trgt_ptr_NCXYZ;
+        if (trgt_K > 0) {
+          target[c + C] = trgt_ptr_NCXYZ[trgt_sK];
+          target[c + C * 2] = trgt_ptr_NCXYZ[trgt_sK * 2];
+        }
+      }
+
+    // Initialize output
+    scalar_t* out_ptr_NCXYZ = out_ptr_NCXYZ0;
+    if (do_pull || do_sgrad) {
+      for (offset_t c = 0; c < C; ++c, out_ptr_NCXYZ += out_sC) {
+        *out_ptr_NCXYZ = static_cast<scalar_t>(0);
+        if (do_sgrad) {
+          out_ptr_NCXYZ[out_sK] = static_cast<scalar_t>(0);
+          out_ptr_NCXYZ[out_sK * 2] = static_cast<scalar_t>(0);
+        }
+      }
+    }
+
+    // Pre-compute indices/weights/grad
+    scalar_t wx[8], wy[8], wz[8]; // B-spline weights
+    scalar_t gx[8], gy[8], gz[8]; // B-spline derivatives
+    scalar_t hx[8], hy[8], hz[8]; // B-spline 2nd derivatives
+    offset_t ix[8], iy[8], iz[8]; // Warped indices
+    uint8_t sx[8], sy[8], sz[8]; // Warped indices
+
+    {
+      scalar_t *owz = static_cast<scalar_t*>(wz), *ogz = static_cast<scalar_t*>(gz), *ohz = static_cast<scalar_t*>(hz);
+      offset_t* oiz = static_cast<offset_t*>(iz);
+      uint8_t* osz = static_cast<uint8_t*>(sz);
+      for (offset_t bz = bz0; bz <= bz1; ++bz) {
+        scalar_t dz = z - bz;
+        *(owz++) = interpolation::fastweight(interpolation2, dz);
+        if (do_grad || do_sgrad)
+          *(ogz++) = interpolation::fastgrad(interpolation2, dz);
+        if (do_grad && trgt_sK > 1)
+          *(ohz++) = interpolation::fasthess(interpolation2, dz);
+        *(osz++) = bound::sign(bound2, bz, src_Z);
+        *(oiz++) = bound::index(bound2, bz, src_Z);
+      }
+    }
+    {
+      scalar_t *owy = static_cast<scalar_t*>(wy), *ogy = static_cast<scalar_t*>(gy), *ohy = static_cast<scalar_t*>(hy);
+      offset_t* oiy = static_cast<offset_t*>(iy);
+      uint8_t* osy = static_cast<uint8_t*>(sy);
+      for (offset_t by = by0; by <= by1; ++by) {
+        scalar_t dy = y - by;
+        *(owy++) = interpolation::fastweight(interpolation1, dy);
+        if (do_grad || do_sgrad)
+          *(ogy++) = interpolation::fastgrad(interpolation1, dy);
+        if (do_grad && trgt_sK > 1)
+          *(ohy++) = interpolation::fasthess(interpolation1, dy);
+        *(osy++) = bound::sign(bound1, by, src_Y);
+        *(oiy++) = bound::index(bound1, by, src_Y);
+      }
+    }
+    {
+      scalar_t *owx = static_cast<scalar_t*>(wx), *ogx = static_cast<scalar_t*>(gx), *ohx = static_cast<scalar_t*>(hx);
+      offset_t* oix = static_cast<offset_t*>(ix);
+      uint8_t* osx = static_cast<uint8_t*>(sx);
+      for (offset_t bx = bx0; bx <= bx1; ++bx) {
+        scalar_t dx = x - bx;
+        *(owx++) = interpolation::fastweight(interpolation0, dx);
+        if (do_grad || do_sgrad)
+          *(ogx++) = interpolation::fastgrad(interpolation0, dx);
+        if (do_grad && trgt_sK > 1)
+          *(ohx++) = interpolation::fasthess(interpolation0, dx);
+        *(osx++) = bound::sign(bound0, bx, src_X);
+        *(oix++) = bound::index(bound0, bx, src_X);
+      }
+    }
+
+    // Convolve coefficients with basis functions
+    scalar_t ogx, ogy, ogz;
+    ogx = ogy = ogz = static_cast<scalar_t>(0);
+    for (offset_t k = 0; k <= dbz; ++k) {
+      offset_t ooz = iz[k] * out_sZ;
+      offset_t osz = iz[k] * src_sZ;
+      uint8_t szz = sz[k];
+      scalar_t wzz = wz[k];
+      scalar_t gzz = gz[k];
+      scalar_t hzz = hz[k];
+      for (offset_t j = 0; j <= dby; ++j) {
+        offset_t ooyz = ooz + iy[j] * out_sY;
+        offset_t osyz = osz + iy[j] * src_sY;
+        uint8_t syz = szz * sy[j];
+        scalar_t wyy = wy[j];
+        scalar_t gyy = gy[j];
+        scalar_t hyy = hy[j];
+        for (offset_t i = 0; i <= dbx; ++i) {
+          offset_t ooxyz = ooyz + ix[i] * out_sX;
+          offset_t osxyz = osyz + ix[i] * src_sX;
+          uint8_t sxyz = syz * sx[i];
+          scalar_t wxx = wx[i];
+          scalar_t gxx = gx[i];
+          scalar_t hxx = hx[i];
+
+          // ~~~~~~~~~~~~~~~~~~~~~~~~~~~ Pull ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+          if (do_pull) {
+            scalar_t* src_ptr_NC = src_ptr_NC0;
+            scalar_t* out_ptr_NCXYZ = out_ptr_NCXYZ0;
+            for (offset_t c = 0; c < C; ++c, out_ptr_NCXYZ += out_sC, src_ptr_NC += src_sC)
+              *out_ptr_NCXYZ += bound::get(src_ptr_NC, osxyz, sxyz) * (wxx * wyy * wzz);
+          }
+
+          // ~~~~~~~~~~~~~~~~~~~~~~~~~~~ SGrad ~~~~~~~~~~~~~~~~~~~~~~~~~~~
+          else if (do_sgrad) {
+            scalar_t* src_ptr_NC = src_ptr_NC0;
+            scalar_t* out_ptr_NCXYZ = out_ptr_NCXYZ0;
+            for (offset_t c = 0; c < C; ++c, out_ptr_NCXYZ += out_sC, src_ptr_NC += src_sC) {
+              scalar_t src = bound::get(src_ptr_NC, osxyz, sxyz);
+              *out_ptr_NCXYZ += src * (gxx * wyy * wzz);
+              out_ptr_NCXYZ[out_sK] += src * (wxx * gyy * wzz);
+              out_ptr_NCXYZ[2 * out_sK] += src * (wxx * wyy * gzz);
+            }
+          }
+
+          // ~~~~~~~~~~~~~~~~~~~~~~~~~~~ Push ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+          else if (do_push) {
+            if (trgt_K == 0) {
+              // Diff w.r.t. push/pull
+              scalar_t* out_ptr_NC = out_ptr_NC0;
+              for (offset_t c = 0; c < C; ++c, out_ptr_NC += out_sC)
+                bound::add(out_ptr_NC, ooxyz, (wxx * wyy * wzz) * target[c], sxyz);
+            } else {
+              // Diff w.r.t. sgrad
+              scalar_t* out_ptr_NC = out_ptr_NC0;
+              for (offset_t c = 0; c < C; ++c, out_ptr_NC += out_sC) {
+                scalar_t val = (gxx * wyy * wzz) * target[c] + (wxx * gyy * wzz) * target[c + C] +
+                    (wxx * wyy * gzz) * target[c + C * 2];
+                bound::add(out_ptr_NC, ooxyz, val, sxyz);
+              }
+            }
+          }
+
+          // ~~~~~~~~~~~~~~~~~~~~~~~~~~~ Count ~~~~~~~~~~~~~~~~~~~~~~~~~~~
+          else if (do_count) {
+            bound::add(out_ptr_NC0, ooxyz, (wxx * wyy * wzz), sxyz);
+          }
+
+          // ~~~~~~~~~~~~~~~~~~~~~~~~~~~ Grad ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+          if (do_grad) {
+            if (trgt_K == 0) {
+              // Diff w.r.t. pull/push
+              scalar_t* src_ptr_NC = src_ptr_NC0;
+              scalar_t dot = static_cast<scalar_t>(0);
+              for (offset_t c = 0; c < C; ++c, src_ptr_NC += src_sC) {
+                scalar_t src = bound::get(src_ptr_NC, osxyz, sxyz);
+                dot += (trgt_ptr ? src * target[c] : src);
+                // trgt_ptr == 0 in the backward pass of 'count'
+              }
+              ogx += (gxx * wyy * wzz) * dot;
+              ogy += (wxx * gyy * wzz) * dot;
+              ogz += (wxx * wyy * gzz) * dot;
+            } else {
+              // Diff w.r.t. sgrad
+              scalar_t* src_ptr_NC = src_ptr_NC0;
+              scalar_t dot0, dot1, dot2;
+              dot0 = dot1 = dot2 = static_cast<scalar_t>(0);
+              for (offset_t c = 0; c < C; ++c, src_ptr_NC += src_sC) {
+                scalar_t src = bound::get(src_ptr_NC, osxyz, sxyz);
+                dot0 += src * target[c];
+                dot1 += src * target[c + C];
+                dot2 += src * target[c + C * 2];
+              }
+              ogx += (hxx * wyy * wzz) * dot0 + (gxx * gyy * wzz) * dot1 + (gxx * wyy * gzz) * dot2;
+              ogy += (gxx * gyy * wzz) * dot0 + (wxx * hyy * wzz) * dot1 + (wxx * gyy * gzz) * dot2;
+              ogz += (gxx * wyy * gzz) * dot0 + (wxx * gyy * gzz) * dot1 + (wxx * wyy * hzz) * dot2;
+            }
+          }
+
+        } // x
+      } // y
+    } // z
+
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Grad ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    if (do_grad) {
+      scalar_t* grad_ptr_NXYZ = grad_ptr + n * grad_sN + w * grad_sX + h * grad_sY + d * grad_sZ;
+      (*grad_ptr_NXYZ) = ogx;
+      grad_ptr_NXYZ[grad_sC] = ogy;
+      grad_ptr_NXYZ[grad_sC * 2] = ogz;
+    }
+  }
+
+  // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+  //                     GENERIC INTERPOLATION 2D
+  // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+  template <typename scalar_t, typename offset_t>
+  MONAI_DEVICE void PushPullImpl<scalar_t, offset_t>::interpolate2d(
+      scalar_t x,
+      scalar_t y,
+      offset_t w,
+      offset_t h,
+      offset_t n) const {
+    // Get corner pixel values from (x, y)
+    offset_t bx0, bx1, by0, by1;
+    interpolation::bounds(interpolation0, x, bx0, bx1);
+    interpolation::bounds(interpolation1, y, by0, by1);
+    offset_t dbx = bx1 - bx0;
+    offset_t dby = by1 - by0;
+
+    // Pre-compute offsets and target value
+    scalar_t* src_ptr_NC0 = src_ptr + n * src_sN;
+    scalar_t* out_ptr_NC0 = out_ptr + n * out_sN;
+    scalar_t* out_ptr_NCXY0 = out_ptr + n * out_sN + w * out_sX + h * out_sY;
+    scalar_t* trgt_ptr_NCXY = trgt_ptr + n * trgt_sN + w * trgt_sX + h * trgt_sY;
+    scalar_t target[2 * MONAI_MAX_NUM_CHANNELS];
+    if (trgt_ptr && (do_push || do_grad))
+      for (offset_t c = 0; c < C; ++c, trgt_ptr_NCXY += trgt_sC) {
+        target[c] = *trgt_ptr_NCXY;
+        if (trgt_K > 0) {
+          target[c + C] = trgt_ptr_NCXY[trgt_sK];
+        }
+      }
+
+    // Initialize output
+    scalar_t* out_ptr_NCXY = out_ptr_NCXY0;
+    if (do_pull || do_sgrad) {
+      for (offset_t c = 0; c < C; ++c, out_ptr_NCXY += out_sC) {
+        *out_ptr_NCXY = static_cast<scalar_t>(0);
+        if (do_sgrad) {
+          out_ptr_NCXY[out_sK] = static_cast<scalar_t>(0);
+        }
+      }
+    }
+
+    // Pre-compute indices/weights/grad
+    scalar_t wx[8], wy[8]; // B-spline weights
+    scalar_t gx[8], gy[8]; // B-spline derivatives
+    scalar_t hx[8], hy[8]; // B-spline 2nd derivatives
+    offset_t ix[8], iy[8]; // Warped indices
+    uint8_t sx[8], sy[8]; // Warped indices
+
+    {
+      scalar_t *owy = static_cast<scalar_t*>(wy), *ogy = static_cast<scalar_t*>(gy), *ohy = static_cast<scalar_t*>(hy);
+      offset_t* oiy = static_cast<offset_t*>(iy);
+      uint8_t* osy = static_cast<uint8_t*>(sy);
+      for (offset_t by = by0; by <= by1; ++by) {
+        scalar_t dy = y - by;
+        *(owy++) = interpolation::fastweight(interpolation1, dy);
+        if (do_grad || do_sgrad)
+          *(ogy++) = interpolation::fastgrad(interpolation1, dy);
+        if (do_grad && trgt_sK > 1)
+          *(ohy++) = interpolation::fasthess(interpolation1, dy);
+        *(osy++) = bound::sign(bound1, by, src_Y);
+        *(oiy++) = bound::index(bound1, by, src_Y);
+      }
+    }
+    {
+      scalar_t *owx = static_cast<scalar_t*>(wx), *ogx = static_cast<scalar_t*>(gx), *ohx = static_cast<scalar_t*>(hx);
+      offset_t* oix = static_cast<offset_t*>(ix);
+      uint8_t* osx = static_cast<uint8_t*>(sx);
+      for (offset_t bx = bx0; bx <= bx1; ++bx) {
+        scalar_t dx = x - bx;
+        *(owx++) = interpolation::fastweight(interpolation0, dx);
+        if (do_grad || do_sgrad)
+          *(ogx++) = interpolation::fastgrad(interpolation0, dx);
+        if (do_grad && trgt_sK > 1)
+          *(ohx++) = interpolation::fasthess(interpolation0, dx);
+        *(osx++) = bound::sign(bound0, bx, src_X);
+        *(oix++) = bound::index(bound0, bx, src_X);
+      }
+    }
+
+    // Convolve coefficients with basis functions
+    scalar_t ogx, ogy;
+    ogx = ogy = static_cast<scalar_t>(0);
+    for (offset_t j = 0; j <= dby; ++j) {
+      offset_t ooy = iy[j] * out_sY;
+      offset_t osy = iy[j] * src_sY;
+      uint8_t syy = sy[j];
+      scalar_t wyy = wy[j];
+      scalar_t gyy = gy[j];
+      scalar_t hyy = hy[j];
+      for (offset_t i = 0; i <= dbx; ++i) {
+        offset_t ooxy = ooy + ix[i] * out_sX;
+        offset_t osxy = osy + ix[i] * src_sX;
+        uint8_t sxy = syy * sx[i];
+        scalar_t wxx = wx[i];
+        scalar_t gxx = gx[i];
+        scalar_t hxx = hx[i];
+
+        // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Pull ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+        if (do_pull) {
+          scalar_t* src_ptr_NC = src_ptr_NC0;
+          scalar_t* out_ptr_NCXY = out_ptr_NCXY0;
+          for (offset_t c = 0; c < C; ++c, out_ptr_NCXY += out_sC, src_ptr_NC += src_sC)
+            *out_ptr_NCXY += bound::get(src_ptr_NC, osxy, sxy) * (wxx * wyy);
+        }
+
+        // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ SGrad ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+        else if (do_sgrad) {
+          scalar_t* src_ptr_NC = src_ptr_NC0;
+          scalar_t* out_ptr_NCXY = out_ptr_NCXY0;
+          for (offset_t c = 0; c < C; ++c, out_ptr_NCXY += out_sC, src_ptr_NC += src_sC) {
+            scalar_t src = bound::get(src_ptr_NC, osxy, sxy);
+            *out_ptr_NCXY += src * (gxx * wyy);
+            out_ptr_NCXY[out_sK] += src * (wxx * gyy);
+          }
+        }
+
+        // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Push ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+        else if (do_push) {
+          if (trgt_K == 0) {
+            // Diff w.r.t. push/pull
+            scalar_t* out_ptr_NC = out_ptr_NC0;
+            for (offset_t c = 0; c < C; ++c, out_ptr_NC += out_sC)
+              bound::add(out_ptr_NC, ooxy, (wxx * wyy) * target[c], sxy);
+          } else {
+            // Diff w.r.t. sgrad
+            scalar_t* out_ptr_NC = out_ptr_NC0;
+            for (offset_t c = 0; c < C; ++c, out_ptr_NC += out_sC) {
+              scalar_t val = (gxx * wyy) * target[c] + (wxx * gyy) * target[c + C];
+              bound::add(out_ptr_NC, ooxy, val, sxy);
+            }
+          }
+        }
+
+        // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Count ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+        else if (do_count) {
+          bound::add(out_ptr_NC0, ooxy, (wxx * wyy), sxy);
+        }
+
+        // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Grad ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+        if (do_grad) {
+          if (trgt_K == 0) {
+            // Diff w.r.t. pull/push
+            scalar_t* src_ptr_NC = src_ptr_NC0;
+            scalar_t dot = static_cast<scalar_t>(0);
+            for (offset_t c = 0; c < C; ++c, src_ptr_NC += src_sC) {
+              scalar_t src = bound::get(src_ptr_NC, osxy, sxy);
+              dot += (trgt_ptr ? src * target[c] : src);
+              // trgt_ptr == 0 in the backward pass of 'count'
+            }
+            ogx += (gxx * wyy) * dot;
+            ogy += (wxx * gyy) * dot;
+          } else {
+            // Diff w.r.t. sgrad
+            scalar_t* src_ptr_NC = src_ptr_NC0;
+            scalar_t dot0, dot1;
+            dot0 = dot1 = static_cast<scalar_t>(0);
+            for (offset_t c = 0; c < C; ++c, src_ptr_NC += src_sC) {
+              scalar_t src = bound::get(src_ptr_NC, osxy, sxy);
+              dot0 += src * target[c];
+              dot1 += src * target[c + C];
+            }
+            ogx += (hxx * wyy) * dot0 + (gxx * gyy) * dot1;
+            ogy += (gxx * gyy) * dot0 + (wxx * hyy) * dot1;
+          }
+        }
+
+      } // x
+    } // y
+
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Grad ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    if (do_grad) {
+      scalar_t* grad_ptr_NXY = grad_ptr + n * grad_sN + w * grad_sX + h * grad_sY;
+      (*grad_ptr_NXY) = ogx;
+      grad_ptr_NXY[grad_sC] = ogy;
+    }
+  }
+
+  // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+  //                     GENERIC INTERPOLATION 1D
+  // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+  template <typename scalar_t, typename offset_t>
+  MONAI_DEVICE void PushPullImpl<scalar_t, offset_t>::interpolate1d(scalar_t x, offset_t w, offset_t n) const {
+    // Get corner pixel values from (x, y)
+    offset_t bx0, bx1;
+    interpolation::bounds(interpolation0, x, bx0, bx1);
+    offset_t dbx = bx1 - bx0;
+
+    // Pre-compute offsets and target value
+    scalar_t* src_ptr_NC0 = src_ptr + n * src_sN;
+    scalar_t* out_ptr_NC0 = out_ptr + n * out_sN;
+    scalar_t* out_ptr_NCX0 = out_ptr + n * out_sN + w * out_sX;
+    scalar_t* trgt_ptr_NCX = trgt_ptr + n * trgt_sN + w * trgt_sX;
+    scalar_t target[2 * MONAI_MAX_NUM_CHANNELS];
+    if (trgt_ptr && (do_push || do_grad))
+      for (offset_t c = 0; c < C; ++c, trgt_ptr_NCX += trgt_sC) {
+        target[c] = *trgt_ptr_NCX;
+        if (trgt_K > 0) {
+          target[c + C] = trgt_ptr_NCX[trgt_sK];
+        }
+      }
+
+    // Initialize output
+    scalar_t* out_ptr_NCX = out_ptr_NCX0;
+    if (do_pull || do_sgrad) {
+      for (offset_t c = 0; c < C; ++c, out_ptr_NCX += out_sC) {
+        *out_ptr_NCX = static_cast<scalar_t>(0);
+        if (do_sgrad) {
+          out_ptr_NCX[out_sK] = static_cast<scalar_t>(0);
+        }
+      }
+    }
+
+    // Pre-compute indices/weights/grad
+    scalar_t wx[8]; // B-spline weights
+    scalar_t gx[8]; // B-spline derivatives
+    scalar_t hx[8]; // B-spline 2nd derivatives
+    offset_t ix[8]; // Warped indices
+    uint8_t sx[8]; // Warped indices
+
+    {
+      scalar_t *owx = static_cast<scalar_t*>(wx), *ogx = static_cast<scalar_t*>(gx), *ohx = static_cast<scalar_t*>(hx);
+      offset_t* oix = static_cast<offset_t*>(ix);
+      uint8_t* osx = static_cast<uint8_t*>(sx);
+      for (offset_t bx = bx0; bx <= bx1; ++bx) {
+        scalar_t dx = x - bx;
+        *(owx++) = interpolation::fastweight(interpolation0, dx);
+        if (do_grad || do_sgrad)
+          *(ogx++) = interpolation::fastgrad(interpolation0, dx);
+        if (do_grad && trgt_sK > 1)
+          *(ohx++) = interpolation::fasthess(interpolation0, dx);
+        *(osx++) = bound::sign(bound0, bx, src_X);
+        *(oix++) = bound::index(bound0, bx, src_X);
+      }
+    }
+
+    // Convolve coefficients with basis functions
+    scalar_t ogx;
+    ogx = static_cast<scalar_t>(0);
+    for (offset_t i = 0; i <= dbx; ++i) {
+      offset_t oox = ix[i] * out_sX;
+      offset_t osx = ix[i] * src_sX;
+      uint8_t sxx = sx[i];
+      scalar_t wxx = wx[i];
+      scalar_t gxx = gx[i];
+      scalar_t hxx = hx[i];
+
+      // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Pull ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+      if (do_pull) {
+        scalar_t* src_ptr_NC = src_ptr_NC0;
+        scalar_t* out_ptr_NCX = out_ptr_NCX0;
+        for (offset_t c = 0; c < C; ++c, out_ptr_NCX += out_sC, src_ptr_NC += src_sC)
+          *out_ptr_NCX += bound::get(src_ptr_NC, osx, sxx) * wxx;
+      }
+
+      // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ SGrad ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+      else if (do_sgrad) {
+        scalar_t* src_ptr_NC = src_ptr_NC0;
+        scalar_t* out_ptr_NCX = out_ptr_NCX0;
+        for (offset_t c = 0; c < C; ++c, out_ptr_NCX += out_sC, src_ptr_NC += src_sC) {
+          scalar_t src = bound::get(src_ptr_NC, osx, sxx);
+          *out_ptr_NCX += src * gxx;
+        }
+      }
+
+      // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Push ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+      else if (do_push) {
+        if (trgt_K == 0) {
+          // Diff w.r.t. push/pull
+          scalar_t* out_ptr_NC = out_ptr_NC0;
+          for (offset_t c = 0; c < C; ++c, out_ptr_NC += out_sC)
+            bound::add(out_ptr_NC, oox, wxx * target[c], sxx);
+        } else {
+          // Diff w.r.t. sgrad
+          scalar_t* out_ptr_NC = out_ptr_NC0;
+          for (offset_t c = 0; c < C; ++c, out_ptr_NC += out_sC) {
+            scalar_t val = gxx * target[c];
+            bound::add(out_ptr_NC, oox, val, sxx);
+          }
+        }
+      }
+
+      // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Count ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+      else if (do_count) {
+        bound::add(out_ptr_NC0, oox, wxx, sxx);
+      }
+
+      // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Grad ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+      if (do_grad) {
+        if (trgt_K == 0) {
+          // Diff w.r.t. pull/push
+          scalar_t* src_ptr_NC = src_ptr_NC0;
+          scalar_t dot = static_cast<scalar_t>(0);
+          for (offset_t c = 0; c < C; ++c, src_ptr_NC += src_sC) {
+            scalar_t src = bound::get(src_ptr_NC, osx, sxx);
+            dot += (trgt_ptr ? src * target[c] : src);
+            // trgt_ptr == 0 in the backward pass of 'count'
+          }
+          ogx += gxx * dot;
+        } else {
+          // Diff w.r.t. sgrad
+          scalar_t* src_ptr_NC = src_ptr_NC0;
+          scalar_t dot;
+          dot = static_cast<scalar_t>(0);
+          for (offset_t c = 0; c < C; ++c, src_ptr_NC += src_sC) {
+            scalar_t src = bound::get(src_ptr_NC, osx, sxx);
+            dot += src * target[c];
+          }
+          ogx += hxx * dot;
+        }
+      }
+
+    } // x
+
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Grad ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    if (do_grad) {
+      scalar_t* grad_ptr_NX = grad_ptr + n * grad_sN + w * grad_sX;
+      (*grad_ptr_NX) = ogx;
+    }
+  }
+
+  // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+  //                     LINEAR INTERPOLATION 3D
+  // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+  template <typename scalar_t, typename offset_t>
+  MONAI_DEVICE void PushPullImpl<scalar_t, offset_t>::interpolate3d_trilinear(
+      scalar_t x,
+      scalar_t y,
+      scalar_t z,
+      offset_t w,
+      offset_t h,
+      offset_t d,
+      offset_t n) const {
+    // Get corner pixel values from (x, y, z)
+    offset_t ix0 = static_cast<offset_t>(std::floor(x));
+    offset_t iy0 = static_cast<offset_t>(std::floor(y));
+    offset_t iz0 = static_cast<offset_t>(std::floor(z));
+
+    // Interpolation weights (inversely proportional to distance)
+    scalar_t dx1 = x - ix0;
+    scalar_t dy1 = y - iy0;
+    scalar_t dz1 = z - iz0;
+    scalar_t dx0 = 1. - dx1;
+    scalar_t dy0 = 1. - dy1;
+    scalar_t dz0 = 1. - dz1;
+    scalar_t w000 = dx0 * dy0 * dz0;
+    scalar_t w100 = dx1 * dy0 * dz0;
+    scalar_t w010 = dx0 * dy1 * dz0;
+    scalar_t w001 = dx0 * dy0 * dz1;
+    scalar_t w110 = dx1 * dy1 * dz0;
+    scalar_t w011 = dx0 * dy1 * dz1;
+    scalar_t w101 = dx1 * dy0 * dz1;
+    scalar_t w111 = dx1 * dy1 * dz1;
+
+    // Sign (/!\ compute sign before warping indices)
+    int8_t sx1 = bound::sign(bound0, ix0 + 1, src_X);
+    int8_t sy1 = bound::sign(bound1, iy0 + 1, src_Y);
+    int8_t sz1 = bound::sign(bound2, iz0 + 1, src_Z);
+    int8_t sx0 = bound::sign(bound0, ix0, src_X);
+    int8_t sy0 = bound::sign(bound1, iy0, src_Y);
+    int8_t sz0 = bound::sign(bound2, iz0, src_Z);
+    int8_t s000 = sx0 * sy0 * sz0;
+    int8_t s100 = sx1 * sy0 * sz0;
+    int8_t s010 = sx0 * sy1 * sz0;
+    int8_t s001 = sx0 * sy0 * sz1;
+    int8_t s110 = sx1 * sy1 * sz0;
+    int8_t s011 = sx0 * sy1 * sz1;
+    int8_t s101 = sx1 * sy0 * sz1;
+    int8_t s111 = sx1 * sy1 * sz1;
+
+    // Warp indices
+    offset_t ix1, iy1, iz1;
+    ix1 = bound::index(bound0, ix0 + 1, src_X);
+    iy1 = bound::index(bound1, iy0 + 1, src_Y);
+    iz1 = bound::index(bound2, iz0 + 1, src_Z);
+    ix0 = bound::index(bound0, ix0, src_X);
+    iy0 = bound::index(bound1, iy0, src_Y);
+    iz0 = bound::index(bound2, iz0, src_Z);
+
+    offset_t o000, o100, o010, o001, o110, o011, o101, o111;
+
+    if (do_pull || do_grad || do_sgrad) {
+      // Offsets into source volume
+      o000 = ix0 * src_sX + iy0 * src_sY + iz0 * src_sZ;
+      o100 = ix1 * src_sX + iy0 * src_sY + iz0 * src_sZ;
+      o010 = ix0 * src_sX + iy1 * src_sY + iz0 * src_sZ;
+      o001 = ix0 * src_sX + iy0 * src_sY + iz1 * src_sZ;
+      o110 = ix1 * src_sX + iy1 * src_sY + iz0 * src_sZ;
+      o011 = ix0 * src_sX + iy1 * src_sY + iz1 * src_sZ;
+      o101 = ix1 * src_sX + iy0 * src_sY + iz1 * src_sZ;
+      o111 = ix1 * src_sX + iy1 * src_sY + iz1 * src_sZ;
+    } else if (!(do_push || do_count)) {
+      o000 = o100 = o010 = o001 = o110 = o011 = o101 = o111 = 0;
+    }
+
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~ Grid gradient ~~~~~~~~~~~~~~~~~~~~~~~~~~
+    if (do_grad) {
+      scalar_t gx = static_cast<scalar_t>(0);
+      scalar_t gy = static_cast<scalar_t>(0);
+      scalar_t gz = static_cast<scalar_t>(0);
+      scalar_t* trgt_ptr_NCXYZ = trgt_ptr + n * trgt_sN + w * trgt_sX + h * trgt_sY + d * trgt_sZ;
+      scalar_t* src_ptr_NC = src_ptr + n * src_sN;
+
+      if (trgt_K == 0) {
+        // backward w.r.t. push/pull
+        for (offset_t c = 0; c < C; ++c, trgt_ptr_NCXYZ += trgt_sC, src_ptr_NC += src_sC) {
+          scalar_t src;
+          scalar_t trgt = trgt_ptr ? *trgt_ptr_NCXYZ : static_cast<scalar_t>(1);
+          // ^ trgt_ptr == 0 during the backward pass of count
+          src = bound::get(src_ptr_NC, o000, s000);
+          if (trgt_ptr)
+            src *= trgt;
+          gx -= dy0 * dz0 * src;
+          gy -= dx0 * dz0 * src;
+          gz -= dx0 * dy0 * src;
+          src = bound::get(src_ptr_NC, o100, s100);
+          if (trgt_ptr)
+            src *= trgt;
+          gx += dy0 * dz0 * src;
+          gy -= dx1 * dz0 * src;
+          gz -= dx1 * dy0 * src;
+          src = bound::get(src_ptr_NC, o010, s010);
+          if (trgt_ptr)
+            src *= trgt;
+          gx -= dy1 * dz0 * src;
+          gy += dx0 * dz0 * src;
+          gz -= dx0 * dy1 * src;
+          src = bound::get(src_ptr_NC, o110, s110);
+          if (trgt_ptr)
+            src *= trgt;
+          gx += dy1 * dz0 * src;
+          gy += dx1 * dz0 * src;
+          gz -= dx1 * dy1 * src;
+          src = bound::get(src_ptr_NC, o001, s001);
+          if (trgt_ptr)
+            src *= trgt;
+          gx -= dy0 * dz1 * src;
+          gy -= dx0 * dz1 * src;
+          gz += dx0 * dy0 * src;
+          src = bound::get(src_ptr_NC, o101, s101);
+          if (trgt_ptr)
+            src *= trgt;
+          gx += dy0 * dz1 * src;
+          gy -= dx1 * dz1 * src;
+          gz += dx1 * dy0 * src;
+          src = bound::get(src_ptr_NC, o011, s011);
+          if (trgt_ptr)
+            src *= trgt;
+          gx -= dy1 * dz1 * src;
+          gy += dx0 * dz1 * src;
+          gz += dx0 * dy1 * src;
+          src = bound::get(src_ptr_NC, o111, s111);
+          if (trgt_ptr)
+            src *= trgt;
+          gx += dy1 * dz1 * src;
+          gy += dx1 * dz1 * src;
+          gz += dx1 * dy1 * src;
+        }
+      } else {
+        // backward w.r.t. sgrad
+        for (offset_t c = 0; c < C; ++c, trgt_ptr_NCXYZ += trgt_sC, src_ptr_NC += src_sC) {
+          scalar_t src;
+          scalar_t trgt0 = *trgt_ptr_NCXYZ, trgt1 = trgt_ptr_NCXYZ[trgt_sK], trgt2 = trgt_ptr_NCXYZ[trgt_sK * 2];
+          src = bound::get(src_ptr_NC, o000, s000);
+          gx += (dz0 * trgt1 + dy0 * trgt2) * src;
+          gy += (dz0 * trgt0 + dx0 * trgt2) * src;
+          gz += (dy0 * trgt0 + dx0 * trgt1) * src;
+          src = bound::get(src_ptr_NC, o100, s100);
+          gx += (-dz0 * trgt1 - dy0 * trgt2) * src;
+          gy += (-dz0 * trgt0 + dx1 * trgt2) * src;
+          gz += (-dy0 * trgt0 + dx1 * trgt1) * src;
+          src = bound::get(src_ptr_NC, o010, s010);
+          gx += (-dz0 * trgt1 + dy1 * trgt2) * src;
+          gy += (-dz0 * trgt0 - dx0 * trgt2) * src;
+          gz += (dy1 * trgt0 - dx0 * trgt1) * src;
+          src = bound::get(src_ptr_NC, o110, s110);
+          gx += (dz0 * trgt1 - dy1 * trgt2) * src;
+          gy += (dz0 * trgt0 - dx1 * trgt2) * src;
+          gz += (-dy1 * trgt0 - dx1 * trgt1) * src;
+          src = bound::get(src_ptr_NC, o001, s001);
+          gx += (dz1 * trgt1 - dy0 * trgt2) * src;
+          gy += (dz1 * trgt0 - dx0 * trgt2) * src;
+          gz += (-dy0 * trgt0 - dx0 * trgt1) * src;
+          src = bound::get(src_ptr_NC, o101, s101);
+          gx += (-dz1 * trgt1 + dy0 * trgt2) * src;
+          gy += (-dz1 * trgt0 - dx1 * trgt2) * src;
+          gz += (dy0 * trgt0 - dx1 * trgt1) * src;
+          src = bound::get(src_ptr_NC, o011, s011);
+          gx += (-dz1 * trgt1 - dy1 * trgt2) * src;
+          gy += (-dz1 * trgt0 + dx0 * trgt2) * src;
+          gz += (-dy1 * trgt0 + dx0 * trgt1) * src;
+          src = bound::get(src_ptr_NC, o111, s111);
+          gx += (dz1 * trgt1 + dy1 * trgt2) * src;
+          gy += (dz1 * trgt0 + dx1 * trgt2) * src;
+          gz += (dy1 * trgt0 + dx1 * trgt1) * src;
+        }
+      }
+
+      scalar_t* grad_ptr_NXYZ = grad_ptr + n * grad_sN + w * grad_sX + h * grad_sY + d * grad_sZ;
+      (*grad_ptr_NXYZ) = gx;
+      grad_ptr_NXYZ[grad_sC] = gy;
+      grad_ptr_NXYZ[grad_sC * 2] = gz;
+    }
+    if (do_push || do_count) {
+      // Offsets into 'push' volume
+      o000 = ix0 * out_sX + iy0 * out_sY + iz0 * out_sZ;
+      o100 = ix1 * out_sX + iy0 * out_sY + iz0 * out_sZ;
+      o010 = ix0 * out_sX + iy1 * out_sY + iz0 * out_sZ;
+      o001 = ix0 * out_sX + iy0 * out_sY + iz1 * out_sZ;
+      o110 = ix1 * out_sX + iy1 * out_sY + iz0 * out_sZ;
+      o011 = ix0 * out_sX + iy1 * out_sY + iz1 * out_sZ;
+      o101 = ix1 * out_sX + iy0 * out_sY + iz1 * out_sZ;
+      o111 = ix1 * out_sX + iy1 * out_sY + iz1 * out_sZ;
+    }
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Pull ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    if (do_pull) {
+      scalar_t* out_ptr_NCXYZ = out_ptr + n * out_sN + w * out_sX + h * out_sY + d * out_sZ;
+      scalar_t* src_ptr_NC = src_ptr + n * src_sN;
+      for (offset_t c = 0; c < C; ++c, out_ptr_NCXYZ += out_sC, src_ptr_NC += src_sC) {
+        *out_ptr_NCXYZ = bound::get(src_ptr_NC, o000, s000) * w000 + bound::get(src_ptr_NC, o100, s100) * w100 +
+            bound::get(src_ptr_NC, o010, s010) * w010 + bound::get(src_ptr_NC, o110, s110) * w110 +
+            bound::get(src_ptr_NC, o001, s001) * w001 + bound::get(src_ptr_NC, o101, s101) * w101 +
+            bound::get(src_ptr_NC, o011, s011) * w011 + bound::get(src_ptr_NC, o111, s111) * w111;
+      }
+    }
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ SGrad ~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~
+    else if (do_sgrad) {
+      scalar_t* out_ptr_NCXYZ = out_ptr + n * out_sN + w * out_sX + h * out_sY + d * out_sZ;
+      scalar_t* src_ptr_NC = src_ptr + n * src_sN;
+
+      for (offset_t c = 0; c < C; ++c, out_ptr_NCXYZ += out_sC, src_ptr_NC += src_sC) {
+        scalar_t src000 = bound::get(src_ptr_NC, o000, s000);
+        scalar_t src100 = bound::get(src_ptr_NC, o100, s100);
+        scalar_t src010 = bound::get(src_ptr_NC, o010, s010);
+        scalar_t src110 = bound::get(src_ptr_NC, o110, s110);
+        scalar_t src001 = bound::get(src_ptr_NC, o001, s001);
+        scalar_t src101 = bound::get(src_ptr_NC, o101, s101);
+        scalar_t src011 = bound::get(src_ptr_NC, o011, s011);
+        scalar_t src111 = bound::get(src_ptr_NC, o111, s111);
+        *out_ptr_NCXYZ = -dy0 * dz0 * src000 + dy0 * dz0 * src100 - dy1 * dz0 * src010 + dy1 * dz0 * src110 -
+            dy0 * dz1 * src001 + dy0 * dz1 * src101 - dy1 * dz1 * src011 + dy1 * dz1 * src111;
+        out_ptr_NCXYZ[out_sK] = -dx0 * dz0 * src000 - dx1 * dz0 * src100 + dx0 * dz0 * src010 + dx1 * dz0 * src110 -
+            dx0 * dz1 * src001 - dx1 * dz1 * src101 + dx0 * dz1 * src011 + dx1 * dz1 * src111;
+        out_ptr_NCXYZ[out_sK * 2] = -dx0 * dy0 * src000 - dx1 * dy0 * src100 - dx0 * dy1 * src010 - dx1 * dy1 * src110 +
+            dx0 * dy0 * src001 + dx1 * dy0 * src101 + dx0 * dy1 * src011 + dx1 * dy1 * src111;
+      }
+    }
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Push ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    else if (do_push) {
+      // Offsets into 'push' volume
+      o000 = ix0 * out_sX + iy0 * out_sY + iz0 * out_sZ;
+      o100 = ix1 * out_sX + iy0 * out_sY + iz0 * out_sZ;
+      o010 = ix0 * out_sX + iy1 * out_sY + iz0 * out_sZ;
+      o001 = ix0 * out_sX + iy0 * out_sY + iz1 * out_sZ;
+      o110 = ix1 * out_sX + iy1 * out_sY + iz0 * out_sZ;
+      o011 = ix0 * out_sX + iy1 * out_sY + iz1 * out_sZ;
+      o101 = ix1 * out_sX + iy0 * out_sY + iz1 * out_sZ;
+      o111 = ix1 * out_sX + iy1 * out_sY + iz1 * out_sZ;
+      scalar_t* trgt_ptr_NCXYZ = trgt_ptr + n * trgt_sN + w * trgt_sX + h * trgt_sY + d * trgt_sZ;
+      scalar_t* out_ptr_NC = out_ptr + n * out_sN;
+      if (trgt_K == 0) {
+        // Diff w.r.t. push/pull
+        for (offset_t c = 0; c < C; ++c, trgt_ptr_NCXYZ += trgt_sC, out_ptr_NC += out_sC) {
+          scalar_t trgt = *trgt_ptr_NCXYZ;
+          bound::add(out_ptr_NC, o000, w000 * trgt, s000);
+          bound::add(out_ptr_NC, o100, w100 * trgt, s100);
+          bound::add(out_ptr_NC, o010, w010 * trgt, s010);
+          bound::add(out_ptr_NC, o110, w110 * trgt, s110);
+          bound::add(out_ptr_NC, o001, w001 * trgt, s001);
+          bound::add(out_ptr_NC, o101, w101 * trgt, s101);
+          bound::add(out_ptr_NC, o011, w011 * trgt, s011);
+          bound::add(out_ptr_NC, o111, w111 * trgt, s111);
+        }
+      } else {
+        // Diff w.r.t. sgrad
+        scalar_t val;
+        for (offset_t c = 0; c < C; ++c, trgt_ptr_NCXYZ += trgt_sC, out_ptr_NC += out_sC) {
+          scalar_t trgt0 = *trgt_ptr_NCXYZ, trgt1 = trgt_ptr_NCXYZ[trgt_sK], trgt2 = trgt_ptr_NCXYZ[trgt_sK * 2];
+          val = -dy0 * dz0 * trgt0 - dx0 * dz0 * trgt1 - dx0 * dy0 * trgt2;
+          bound::add(out_ptr_NC, o000, val, s000);
+          val = dy0 * dz0 * trgt0 - dx1 * dz0 * trgt1 - dx1 * dy0 * trgt2;
+          bound::add(out_ptr_NC, o100, val, s100);
+          val = -dy1 * dz0 * trgt0 + dx0 * dz0 * trgt1 - dx0 * dy1 * trgt2;
+          bound::add(out_ptr_NC, o010, val, s010);
+          val = dy1 * dz0 * trgt0 + dx1 * dz0 * trgt1 - dx1 * dy1 * trgt2;
+          bound::add(out_ptr_NC, o110, val, s110);
+          val = -dy0 * dz1 * trgt0 - dx0 * dz1 * trgt1 + dx0 * dy0 * trgt2;
+          bound::add(out_ptr_NC, o001, val, s001);
+          val = dy0 * dz1 * trgt0 - dx1 * dz1 * trgt1 + dx1 * dy0 * trgt2;
+          bound::add(out_ptr_NC, o101, val, s101);
+          val = -dy1 * dz1 * trgt0 + dx0 * dz1 * trgt1 + dx0 * dy1 * trgt2;
+          bound::add(out_ptr_NC, o011, val, s011);
+          val = dy1 * dz1 * trgt0 + dx1 * dz1 * trgt1 + dx1 * dy1 * trgt2;
+          bound::add(out_ptr_NC, o111, val, s111);
+        }
+      }
+    }
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Push ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    else if (do_count) {
+      scalar_t* out_ptr_N = out_ptr + n * out_sN;
+      bound::add(out_ptr_N, o000, w000, s000);
+      bound::add(out_ptr_N, o100, w100, s100);
+      bound::add(out_ptr_N, o010, w010, s010);
+      bound::add(out_ptr_N, o110, w110, s110);
+      bound::add(out_ptr_N, o001, w001, s001);
+      bound::add(out_ptr_N, o101, w101, s101);
+      bound::add(out_ptr_N, o011, w011, s011);
+      bound::add(out_ptr_N, o111, w111, s111);
+    }
+  }
+
+  // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+  //                     LINEAR INTERPOLATION 2D
+  // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+  template <typename scalar_t, typename offset_t>
+  MONAI_DEVICE void PushPullImpl<scalar_t, offset_t>::interpolate2d_bilinear(
+      scalar_t x,
+      scalar_t y,
+      offset_t w,
+      offset_t h,
+      offset_t n) const {
+    // Get corner pixel values from (x, y, z)
+    offset_t ix0 = static_cast<offset_t>(std::floor(x));
+    offset_t iy0 = static_cast<offset_t>(std::floor(y));
+
+    // Interpolation weights (inversely proportional to distance)
+    scalar_t dx1 = x - ix0;
+    scalar_t dy1 = y - iy0;
+    scalar_t dx0 = 1. - dx1;
+    scalar_t dy0 = 1. - dy1;
+    scalar_t w00 = dx0 * dy0;
+    scalar_t w10 = dx1 * dy0;
+    scalar_t w01 = dx0 * dy1;
+    scalar_t w11 = dx1 * dy1;
+
+    // Sign (/!\ compute sign before warping indices)
+    int8_t sx1 = bound::sign(bound0, ix0 + 1, src_X);
+    int8_t sy1 = bound::sign(bound1, iy0 + 1, src_Y);
+    int8_t sx0 = bound::sign(bound0, ix0, src_X);
+    int8_t sy0 = bound::sign(bound1, iy0, src_Y);
+    int8_t s00 = sx0 * sy0;
+    int8_t s10 = sx1 * sy0;
+    int8_t s01 = sx0 * sy1;
+    int8_t s11 = sx1 * sy1;
+
+    // Warp indices
+    offset_t ix1, iy1;
+    ix1 = bound::index(bound0, ix0 + 1, src_X);
+    iy1 = bound::index(bound1, iy0 + 1, src_Y);
+    ix0 = bound::index(bound0, ix0, src_X);
+    iy0 = bound::index(bound1, iy0, src_Y);
+
+    offset_t o00, o10, o01, o11;
+    if (do_pull || do_grad || do_sgrad) {
+      // Offsets into source volume
+      o00 = ix0 * src_sX + iy0 * src_sY;
+      o10 = ix1 * src_sX + iy0 * src_sY;
+      o01 = ix0 * src_sX + iy1 * src_sY;
+      o11 = ix1 * src_sX + iy1 * src_sY;
+    } else if (!(do_push || do_count)) {
+      o00 = o10 = o01 = o11 = 0;
+    }
+
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~ Grid gradient ~~~~~~~~~~~~~~~~~~~~~~~~~~
+    if (do_grad) {
+      scalar_t gx = static_cast<scalar_t>(0);
+      scalar_t gy = static_cast<scalar_t>(0);
+      scalar_t* trgt_ptr_NCXY = trgt_ptr + n * trgt_sN + w * trgt_sX + h * trgt_sY;
+      scalar_t* src_ptr_NC = src_ptr + n * src_sN;
+
+      if (trgt_K == 0) {
+        // backward w.r.t. push/pull
+        for (offset_t c = 0; c < C; ++c, trgt_ptr_NCXY += trgt_sC, src_ptr_NC += src_sC) {
+          scalar_t src;
+          scalar_t trgt = trgt_ptr ? *trgt_ptr_NCXY : static_cast<scalar_t>(1);
+          // ^ trgt_ptr == 0 during the backward pass of count
+          src = bound::get(src_ptr_NC, o00, s00);
+          if (trgt_ptr)
+            src *= trgt;
+          gx -= dy0 * src;
+          gy -= dx0 * src;
+          src = bound::get(src_ptr_NC, o10, s10);
+          if (trgt_ptr)
+            src *= trgt;
+          gx += dy0 * src;
+          gy -= dx1 * src;
+          src = bound::get(src_ptr_NC, o01, s01);
+          if (trgt_ptr)
+            src *= trgt;
+          gx -= dy1 * src;
+          gy += dx0 * src;
+          src = bound::get(src_ptr_NC, o11, s11);
+          if (trgt_ptr)
+            src *= trgt;
+          gx += dy1 * src;
+          gy += dx1 * src;
+        }
+      } else {
+        // backward w.r.t. sgrad
+        for (offset_t c = 0; c < C; ++c, trgt_ptr_NCXY += trgt_sC, src_ptr_NC += src_sC) {
+          scalar_t src;
+          scalar_t trgt0 = *trgt_ptr_NCXY, trgt1 = trgt_ptr_NCXY[trgt_sK];
+          src = bound::get(src_ptr_NC, o00, s00);
+          gx += trgt1 * src;
+          gy += trgt0 * src;
+          src = bound::get(src_ptr_NC, o10, s10);
+          gx -= trgt1 * src;
+          gy -= trgt0 * src;
+          src = bound::get(src_ptr_NC, o01, s01);
+          gx -= trgt1 * src;
+          gy -= trgt0 * src;
+          src = bound::get(src_ptr_NC, o11, s11);
+          gx += trgt1 * src;
+          gy += trgt0 * src;
+        }
+      }
+
+      scalar_t* grad_ptr_NXY = grad_ptr + n * grad_sN + w * grad_sX + h * grad_sY;
+      (*grad_ptr_NXY) = gx;
+      grad_ptr_NXY[grad_sC] = gy;
+    }
+    if (do_push || do_count) {
+      // Offsets into 'push' volume
+      o00 = ix0 * out_sX + iy0 * out_sY;
+      o10 = ix1 * out_sX + iy0 * out_sY;
+      o01 = ix0 * out_sX + iy1 * out_sY;
+      o11 = ix1 * out_sX + iy1 * out_sY;
+    }
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Pull ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    if (do_pull) {
+      scalar_t* out_ptr_NCXY = out_ptr + n * out_sN + w * out_sX + h * out_sY;
+      scalar_t* src_ptr_NC = src_ptr + n * src_sN;
+      for (offset_t c = 0; c < C; ++c, out_ptr_NCXY += out_sC, src_ptr_NC += src_sC) {
+        *out_ptr_NCXY = bound::get(src_ptr_NC, o00, s00) * w00 + bound::get(src_ptr_NC, o10, s10) * w10 +
+            bound::get(src_ptr_NC, o01, s01) * w01 + bound::get(src_ptr_NC, o11, s11) * w11;
+      }
+    }
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ SGrad ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    else if (do_sgrad) {
+      scalar_t* out_ptr_NCXY = out_ptr + n * out_sN + w * out_sX + h * out_sY;
+      scalar_t* src_ptr_NC = src_ptr + n * src_sN;
+
+      for (offset_t c = 0; c < C; ++c, out_ptr_NCXY += out_sC, src_ptr_NC += src_sC) {
+        scalar_t src00 = bound::get(src_ptr_NC, o00, s00);
+        scalar_t src10 = bound::get(src_ptr_NC, o10, s10);
+        scalar_t src01 = bound::get(src_ptr_NC, o01, s01);
+        scalar_t src11 = bound::get(src_ptr_NC, o11, s11);
+        *out_ptr_NCXY = -dy0 * src00 + dy0 * src10 - dy1 * src01 + dy1 * src11;
+        out_ptr_NCXY[out_sK] = -dx0 * src00 - dx1 * src10 + dx0 * src01 + dx1 * src11;
+      }
+    }
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Push ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    else if (do_push) {
+      scalar_t* trgt_ptr_NCXY = trgt_ptr + n * trgt_sN + w * trgt_sX + h * trgt_sY;
+      scalar_t* out_ptr_NC = out_ptr + n * out_sN;
+      if (trgt_K == 0) {
+        // Diff w.r.t. push/pull
+        for (offset_t c = 0; c < C; ++c, trgt_ptr_NCXY += trgt_sC, out_ptr_NC += out_sC) {
+          scalar_t trgt = *trgt_ptr_NCXY;
+          bound::add(out_ptr_NC, o00, w00 * trgt, s00);
+          bound::add(out_ptr_NC, o10, w10 * trgt, s10);
+          bound::add(out_ptr_NC, o01, w01 * trgt, s01);
+          bound::add(out_ptr_NC, o11, w11 * trgt, s11);
+        }
+      } else {
+        // Diff w.r.t. sgrad
+        scalar_t val;
+        for (offset_t c = 0; c < C; ++c, trgt_ptr_NCXY += trgt_sC, out_ptr_NC += out_sC) {
+          scalar_t trgt0 = *trgt_ptr_NCXY, trgt1 = trgt_ptr_NCXY[trgt_sK];
+          val = -dy0 * trgt0 - dx0 * trgt1;
+          bound::add(out_ptr_NC, o00, val, s00);
+          val = dy0 * trgt0 - dx1 * trgt1;
+          bound::add(out_ptr_NC, o10, val, s10);
+          val = -dy1 * trgt0 + dx0 * trgt1;
+          bound::add(out_ptr_NC, o01, val, s01);
+          val = dy1 * trgt0 + dx1 * trgt1;
+          bound::add(out_ptr_NC, o11, val, s11);
+        }
+      }
+    }
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Push ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    else if (do_count) {
+      scalar_t* out_ptr_N = out_ptr + n * out_sN;
+      bound::add(out_ptr_N, o00, w00, s00);
+      bound::add(out_ptr_N, o10, w10, s10);
+      bound::add(out_ptr_N, o01, w01, s01);
+      bound::add(out_ptr_N, o11, w11, s11);
+    }
+  }
+
+  // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+  //                     LINEAR INTERPOLATION 1D
+  // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+  template <typename scalar_t, typename offset_t>
+  MONAI_DEVICE void PushPullImpl<scalar_t, offset_t>::interpolate1d_linear(scalar_t x, offset_t w, offset_t n) const {
+    // Get corner pixel values from (x)
+    offset_t ix0 = static_cast<offset_t>(std::floor(x));
+
+    // Interpolation weights (inversely proportional to distance)
+    scalar_t w1 = x - ix0;
+    scalar_t w0 = 1. - w1;
+
+    // Sign (/!\ compute sign before warping indices)
+    int8_t s1 = bound::sign(bound0, ix0 + 1, src_X);
+    int8_t s0 = bound::sign(bound0, ix0, src_X);
+
+    // Warp indices
+    offset_t ix1;
+    ix1 = bound::index(bound0, ix0 + 1, src_X);
+    ix0 = bound::index(bound0, ix0, src_X);
+
+    offset_t o0, o1;
+    if (do_pull || do_grad || do_sgrad) {
+      // Offsets into source volume
+      o0 = ix0 * src_sX;
+      o1 = ix1 * src_sX;
+    } else if (!(do_push || do_count)) {
+      o0 = o1 = 0;
+    }
+
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~ Grid gradient ~~~~~~~~~~~~~~~~~~~~~~~~~~
+    if (do_grad) {
+      if (trgt_K == 0) {
+        // backward w.r.t. push/pull
+        scalar_t gx = static_cast<scalar_t>(0);
+        scalar_t* trgt_ptr_NCX = trgt_ptr + n * trgt_sN + w * trgt_sX;
+        scalar_t* src_ptr_NC = src_ptr + n * src_sN;
+
+        for (offset_t c = 0; c < C; ++c, trgt_ptr_NCX += trgt_sC, src_ptr_NC += src_sC) {
+          scalar_t src;
+          scalar_t trgt = trgt_ptr ? *trgt_ptr_NCX : static_cast<scalar_t>(1);
+          // ^ trgt_ptr == 0 during the backward pass of count
+          src = bound::get(src_ptr_NC, o0, s0);
+          if (trgt_ptr)
+            src *= trgt;
+          gx -= src;
+          src = bound::get(src_ptr_NC, o1, s1);
+          if (trgt_ptr)
+            src *= trgt;
+          gx += src;
+        }
+
+        scalar_t* grad_ptr_NX = grad_ptr + n * grad_sN + w * grad_sX;
+        (*grad_ptr_NX) = gx;
+      } else {
+        // backward w.r.t. sgrad
+        // -> zero (make sure this is done at initialization)
+      }
+    }
+    if (do_push || do_count) {
+      // Offsets into 'push' volume
+      o0 = ix0 * out_sX;
+      o1 = ix1 * out_sX;
+    }
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Pull ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    if (do_pull) {
+      scalar_t* out_ptr_NCX = out_ptr + n * out_sN + w * out_sX;
+      scalar_t* src_ptr_NC = src_ptr + n * src_sN;
+      for (offset_t c = 0; c < C; ++c, out_ptr_NCX += out_sC, src_ptr_NC += src_sC) {
+        *out_ptr_NCX = bound::get(src_ptr_NC, o0, s0) * w0 + bound::get(src_ptr_NC, o1, s1) * w1;
+      }
+    }
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ SGrad ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    else if (do_sgrad) {
+      scalar_t* out_ptr_NCX = out_ptr + n * out_sN + w * out_sX;
+      scalar_t* src_ptr_NC = src_ptr + n * src_sN;
+
+      for (offset_t c = 0; c < C; ++c, out_ptr_NCX += out_sC, src_ptr_NC += src_sC) {
+        *out_ptr_NCX = bound::get(src_ptr_NC, o1, s1) - bound::get(src_ptr_NC, o0, s0);
+      }
+    }
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Push ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    else if (do_push) {
+      scalar_t* trgt_ptr_NCX = trgt_ptr + n * trgt_sN + w * trgt_sX;
+      scalar_t* out_ptr_NC = out_ptr + n * out_sN;
+      if (trgt_K == 0) {
+        // Diff w.r.t. push/pull
+        for (offset_t c = 0; c < C; ++c, trgt_ptr_NCX += trgt_sC, out_ptr_NC += out_sC) {
+          scalar_t trgt = *trgt_ptr_NCX;
+          bound::add(out_ptr_NC, o0, w0 * trgt, s0);
+          bound::add(out_ptr_NC, o1, w1 * trgt, s1);
+        }
+      } else {
+        // Diff w.r.t. sgrad
+        for (offset_t c = 0; c < C; ++c, trgt_ptr_NCX += trgt_sC, out_ptr_NC += out_sC) {
+          scalar_t trgt0 = *trgt_ptr_NCX;
+          bound::add(out_ptr_NC, o0, -trgt0, s0);
+          bound::add(out_ptr_NC, o1, trgt0, s1);
+        }
+      }
+    }
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Push ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    else if (do_count) {
+      scalar_t* out_ptr_N = out_ptr + n * out_sN;
+      bound::add(out_ptr_N, o0, w0, s0);
+      bound::add(out_ptr_N, o1, w1, s1);
+    }
+  }
+
+  // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+  //                  NEAREST NEIGHBOR INTERPOLATION 3D
+  // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+  template <typename scalar_t, typename offset_t>
+  MONAI_DEVICE void PushPullImpl<scalar_t, offset_t>::interpolate3d_nearest(
+      scalar_t x,
+      scalar_t y,
+      scalar_t z,
+      offset_t w,
+      offset_t h,
+      offset_t d,
+      offset_t n) const {
+    offset_t ix = static_cast<offset_t>(std::round(x));
+    offset_t iy = static_cast<offset_t>(std::round(y));
+    offset_t iz = static_cast<offset_t>(std::round(z));
+
+    // Boundary condition (/!\ compute sign before warping indices)
+    int8_t sx = bound::sign(bound0, ix, src_X);
+    int8_t sy = bound::sign(bound1, iy, src_Y);
+    int8_t sz = bound::sign(bound2, iz, src_Z);
+    ix = bound::index(bound0, ix, src_X);
+    iy = bound::index(bound1, iy, src_Y);
+    iz = bound::index(bound2, iz, src_Z);
+
+    // Sign
+    int8_t s = sz * sy * sx;
+
+    if (do_pull) {
+      offset_t o = iz * src_sZ + iy * src_sY + ix * src_sX;
+      scalar_t* out_ptr_NCXYZ = out_ptr + n * out_sN + w * out_sX + h * out_sY + d * out_sZ;
+      scalar_t* src_ptr_NC = src_ptr + n * src_sN;
+      for (offset_t c = 0; c < C; ++c, out_ptr_NCXYZ += out_sC, src_ptr_NC += src_sC)
+        *out_ptr_NCXYZ = bound::get(src_ptr_NC, o, s);
+    } else if (do_push && trgt_K == 0) {
+      offset_t o = iz * out_sZ + iy * out_sY + ix * out_sX;
+      scalar_t* trgt_ptr_NCXYZ = trgt_ptr + n * trgt_sN + w * trgt_sX + h * trgt_sY + d * trgt_sZ;
+      scalar_t* out_ptr_NC = out_ptr + n * out_sN;
+      for (offset_t c = 0; c < C; ++c, trgt_ptr_NCXYZ += trgt_sC, out_ptr_NC += out_sC)
+        bound::add(out_ptr_NC, o, *trgt_ptr_NCXYZ, s);
+    } else if (do_count) {
+      offset_t o = iz * out_sZ + iy * out_sY + ix * out_sX;
+      scalar_t* out_ptr_NC = out_ptr + n * out_sN;
+      for (offset_t c = 0; c < C; ++c, out_ptr_NC += out_sC)
+        bound::add(out_ptr_NC, o, static_cast<scalar_t>(1), s);
+    }
+  }
+
+  // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+  //                  NEAREST NEIGHBOR INTERPOLATION 2D
+  // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+  template <typename scalar_t, typename offset_t>
+  MONAI_DEVICE void PushPullImpl<scalar_t, offset_t>::interpolate2d_nearest(
+      scalar_t x,
+      scalar_t y,
+      offset_t w,
+      offset_t h,
+      offset_t n) const {
+    offset_t ix = static_cast<offset_t>(std::round(x));
+    offset_t iy = static_cast<offset_t>(std::round(y));
+
+    // Boundary condition (/!\ compute sign before warping indices)
+    int8_t sx = bound::sign(bound0, ix, src_X);
+    int8_t sy = bound::sign(bound1, iy, src_Y);
+    ix = bound::index(bound0, ix, src_X);
+    iy = bound::index(bound1, iy, src_Y);
+
+    // Sign
+    int8_t s = sy * sx;
+
+    if (do_pull) {
+      offset_t o = iy * src_sY + ix * src_sX;
+      scalar_t* out_ptr_NCXY = out_ptr + n * out_sN + w * out_sX + h * out_sY;
+      scalar_t* src_ptr_NC = src_ptr + n * src_sN;
+      for (offset_t c = 0; c < C; ++c, out_ptr_NCXY += out_sC, src_ptr_NC += src_sC)
+        *out_ptr_NCXY = bound::get(src_ptr_NC, o, s);
+    } else if (do_push && trgt_K == 0) {
+      offset_t o = iy * out_sY + ix * out_sX;
+      scalar_t* trgt_ptr_NCXY = trgt_ptr + n * trgt_sN + w * trgt_sX + h * trgt_sY;
+      scalar_t* out_ptr_NC = out_ptr + n * out_sN;
+      for (offset_t c = 0; c < C; ++c, trgt_ptr_NCXY += trgt_sC, out_ptr_NC += out_sC)
+        bound::add(out_ptr_NC, o, *trgt_ptr_NCXY, s);
+    } else if (do_count) {
+      offset_t o = iy * out_sY + ix * out_sX;
+      scalar_t* out_ptr_NC = out_ptr + n * out_sN;
+      for (offset_t c = 0; c < C; ++c, out_ptr_NC += out_sC)
+        bound::add(out_ptr_NC, o, static_cast<scalar_t>(1), s);
+    }
+  }
+
+  // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+  //                  NEAREST NEIGHBOR INTERPOLATION 1D
+  // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+  template <typename scalar_t, typename offset_t>
+  MONAI_DEVICE void PushPullImpl<scalar_t, offset_t>::interpolate1d_nearest(scalar_t x, offset_t w, offset_t n) const {
+    offset_t i = static_cast<offset_t>(std::round(x));
+
+    // Boundary condition (/!\ compute sign before warping indices)
+    int8_t s = bound::sign(bound0, i, src_X);
+    i = bound::index(bound0, i, src_X);
+
+    if (do_pull) {
+      offset_t o = i * src_sX;
+      scalar_t* out_ptr_NCX = out_ptr + n * out_sN + w * out_sX;
+      scalar_t* src_ptr_NC = src_ptr + n * src_sN;
+      for (offset_t c = 0; c < C; ++c, out_ptr_NCX += out_sC, src_ptr_NC += src_sC)
+        *out_ptr_NCX = bound::get(src_ptr_NC, o, s);
+    } else if (do_push && trgt_K == 0) {
+      offset_t o = i * out_sX;
+      scalar_t* trgt_ptr_NCX = trgt_ptr + n * trgt_sN + w * trgt_sX;
+      scalar_t* out_ptr_NC = out_ptr + n * out_sN;
+      for (offset_t c = 0; c < C; ++c, trgt_ptr_NCX += trgt_sC, out_ptr_NC += out_sC)
+        bound::add(out_ptr_NC, o, *trgt_ptr_NCX, s);
+    } else if (do_count) {
+      offset_t o = i * out_sX;
+      scalar_t* out_ptr_NC = out_ptr + n * out_sN;
+      for (offset_t c = 0; c < C; ++c, out_ptr_NC += out_sC)
+        bound::add(out_ptr_NC, o, static_cast<scalar_t>(1), s);
+    }
+  }
+
+  // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+  //            LINEAR INTERPOLATION 3D + SLIDING BOUNDARY
+  // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+  // TODO
+
+  // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+  //                  CUDA KERNEL (MUST BE OUT OF CLASS)
+  // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+  } // namespace
+
+  // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+  //                    FUNCTIONAL FORM WITH DISPATCH
+  // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+#define PUSHPULL_INSTANTIATE3(BoundType0, InterpolationType0, SourceType0) \
+  template std::deque<Tensor> pushpull(                                    \
+      const SourceType0&,                                                  \
+      const Tensor&,                                                       \
+      const Tensor&,                                                       \
+      BoundType0,                                                          \
+      InterpolationType0,                                                  \
+      bool,                                                                \
+      bool,                                                                \
+      bool,                                                                \
+      bool,                                                                \
+      bool,                                                                \
+      bool);                                                               \
+  template std::deque<Tensor> pushpull(                                    \
+      const SourceType0&, const Tensor&, BoundType0, InterpolationType0, bool, bool, bool, bool, bool, bool)
+#define PUSHPULL_INSTANTIATE2(BoundType0, InterpolationType0)         \
+  PUSHPULL_INSTANTIATE3(BoundType0, InterpolationType0, IntArrayRef); \
+  PUSHPULL_INSTANTIATE3(BoundType0, InterpolationType0, Tensor)
+#define PUSHPULL_INSTANTIATE1(BoundType0)               \
+  PUSHPULL_INSTANTIATE2(BoundType0, InterpolationType); \
+  PUSHPULL_INSTANTIATE2(BoundType0, InterpolationVectorRef)
+#define PUSHPULL_INSTANTIATE        \
+  PUSHPULL_INSTANTIATE1(BoundType); \
+  PUSHPULL_INSTANTIATE1(BoundVectorRef)
+
+  // Two arguments (source, grid)
+  // > `bound` and `interpolation` can be single arguments or vectors.
+  template <typename BoundType, typename InterpolationType, typename SourceType>
+  MONAI_HOST std::deque<Tensor> pushpull(
+      const SourceType& source,
+      const Tensor& grid,
+      BoundType bound,
+      InterpolationType interpolation,
+      bool extrapolate,
+      bool do_pull,
+      bool do_push,
+      bool do_count,
+      bool do_grad,
+      bool do_sgrad) {
+    PushPullAllocator info(
+        grid.dim() - 2, bound, interpolation, extrapolate, do_pull, do_push, do_count, do_grad, do_sgrad);
+    info.ioset(source, grid);
+
+    return AT_DISPATCH_FLOATING_TYPES(grid.scalar_type(), "pushpull", [&] {
+      PushPullImpl<scalar_t, int64_t> algo(info);
+      algo.loop();
+      return algo.output;
+    });
+  }
+
+  // Three arguments (source, grid, target)
+  // > `bound` and `interpolation` can be single arguments or vectors.
+  // > `source` can be a tensor or a vector of dimensions.
+  template <typename BoundType, typename InterpolationType, typename SourceType>
+  MONAI_HOST std::deque<Tensor> pushpull(
+      const SourceType& source,
+      const Tensor& grid,
+      const Tensor& target,
+      BoundType bound,
+      InterpolationType interpolation,
+      bool extrapolate,
+      bool do_pull,
+      bool do_push,
+      bool do_count,
+      bool do_grad,
+      bool do_sgrad) {
+    PushPullAllocator info(
+        grid.dim() - 2, bound, interpolation, extrapolate, do_pull, do_push, do_count, do_grad, do_sgrad);
+    info.ioset(source, grid, target);
+
+    return AT_DISPATCH_FLOATING_TYPES(grid.scalar_type(), "pushpull", [&] {
+      PushPullImpl<scalar_t, int64_t> algo(info);
+      algo.loop();
+      return algo.output;
+    });
+  }
+
+  PUSHPULL_INSTANTIATE;
+
+} // namespace cpu
+} // namespace monai

source_code/SegMamba/monai/csrc/resample/pushpull_cuda.cu

@@ -0,0 +1,2244 @@
+/*
+Copyright (c) MONAI Consortium
+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.
+*/
+
+// adapted from https://github.com/balbasty/nitorch
+
+// This file implements spline interpolation / sampling and its adjoint
+// operations. It corresponds loosely to torch's `GridSampler`.
+// It handles boundary conditions and interpolation orders defined in
+// `utils/resample_utils.h` and `utils/resample_utils.h`.
+// These parameters can be specified per dimension.
+// Isotropic 0-th and 1-st order interpolation have their own (faster)
+// implementations. Sliding boundary conditions are also implemented
+// separately.
+
+// TODO:
+// . [DONE] generic 3d
+// . [DONE] generic 2d
+// . [DONE] generic 1d
+// . sliding nearest 3d
+// . sliding nearest 2d
+// . sliding linear 3d
+// . sliding linear 2d
+// . sliding generic 3d
+// . sliding generic 2d
+// . [DONE] spatial gradient mode (without multiplication with output gradient)
+// . [DONE] second order gradients (backward pass for spatial gradients)
+// . performance tests
+// . input bound/inter are always vectors -> clean unused constructors
+
+#include <ATen/ATen.h>
+#include <limits>
+#include <tuple>
+#include "bounds_common.h"
+#include "interpolation_common.h"
+#include "utils/resample_utils.h"
+//#include <cstdio>
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+// GPU-specific parameters
+#include <ATen/cuda/CUDAContext.h>
+#include <ATen/cuda/detail/KernelUtils.h>
+#include <c10/macros/Macros.h>
+using namespace at::cuda::detail;
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+// maximum number of channels
+// > not used in mode isotropic nearest/linear
+#ifndef MONAI_MAX_NUM_CHANNELS
+#define MONAI_MAX_NUM_CHANNELS 1024
+#endif
+
+// This parameter allows for a little bit of tolerance when considering
+// a coordinate as "out-of-bound" (if !extrapolate)
+#define TINY 5e-2
+
+using at::Tensor;
+using at::TensorOptions;
+using c10::IntArrayRef;
+
+namespace monai {
+MONAI_NAMESPACE_DEVICE { // cuda
+
+  namespace { // anonymous namespace > everything inside has internal linkage
+
+  // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+  //                        INDEXING UTILS
+  // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+  // This class reads and sets all the parameters that will later be used
+  // by the algorithm in PushPullImpl. All of this is done outside of the
+  // implementation class so that we do not depend on generic types. The
+  // point is to pre-allocate all necessary tensors so that we can check
+  // if they're all compatible with 32 bit math. If it's the case, we can
+  // dispatch to a 32b cuda implementation, which might increase
+  // performance. Else, we use 64 bit math to compute offsets.
+  // (On CPU, we always use 64 bit offsets because it doesn't make a huge
+  // difference. It would be different if we had a vectorized
+  // implementation as in PyTorch).
+  class PushPullAllocator {
+   public:
+    static constexpr int64_t max_int32 = std::numeric_limits<int32_t>::max();
+
+    // ~~~ CONSTRUCTORS ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    MONAI_HOST
+    PushPullAllocator(
+        int dim,
+        BoundVectorRef bound,
+        InterpolationVectorRef interpolation,
+        bool extrapolate,
+        bool do_pull,
+        bool do_push,
+        bool do_count,
+        bool do_grad,
+        bool do_sgrad)
+        : dim(dim),
+          bound0(bound.size() > 0 ? bound[0] : BoundType::Replicate),
+          bound1(
+              bound.size() > 1       ? bound[1]
+                  : bound.size() > 0 ? bound[0]
+                                     : BoundType::Replicate),
+          bound2(
+              bound.size() > 2       ? bound[2]
+                  : bound.size() > 1 ? bound[1]
+                  : bound.size() > 0 ? bound[0]
+                                     : BoundType::Replicate),
+          interpolation0(interpolation.size() > 0 ? interpolation[0] : InterpolationType::Linear),
+          interpolation1(
+              interpolation.size() > 1       ? interpolation[1]
+                  : interpolation.size() > 0 ? interpolation[0]
+                                             : InterpolationType::Linear),
+          interpolation2(
+              interpolation.size() > 2       ? interpolation[2]
+                  : interpolation.size() > 1 ? interpolation[1]
+                  : interpolation.size() > 0 ? interpolation[0]
+                                             : InterpolationType::Linear),
+          extrapolate(extrapolate),
+          do_pull(do_pull),
+          do_push(do_push),
+          do_count(do_count),
+          do_grad(do_grad),
+          do_sgrad(do_sgrad) {
+      iso = interpolation0 == interpolation1 && interpolation0 == interpolation2;
+    }
+
+    // ~~~ FUNCTORS ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    // Usually used for pull:
+    // - do_pull  -> return source[grid]
+    // - do_push  -> fails
+    // - do_grad  -> return J(source)[grid]
+    // - do_sgrad -> return H(source)[grid]
+    MONAI_HOST void ioset(const Tensor& source, const Tensor& grid) {
+      init_all();
+      init_source(source);
+      init_grid(grid);
+      init_output();
+    }
+
+    // Usually used for pull_backward:
+    // - do_pull  -> return source[grid]
+    // - do_push  -> return push(target, grid, source.shape)
+    // - do_grad  -> return J(source)[grid]
+    // - do_sgrad -> return H(source)[grid]
+    MONAI_HOST void ioset(const Tensor& source, const Tensor& grid, const Tensor& target) {
+      init_all();
+      init_source(source);
+      init_grid(grid);
+      init_target(target);
+      init_output();
+    }
+
+    // Usually used for push:
+    // - do_pull  -> fails
+    // - do_push  -> return push(target, grid, source_size)
+    // - do_grad  -> fails
+    // - do_sgrad -> fails
+    MONAI_HOST void ioset(IntArrayRef source_size, const Tensor& grid, const Tensor& target) {
+      init_all();
+      init_source(source_size);
+      init_grid(grid);
+      init_target(target);
+      init_output();
+    }
+
+    // Usually used for count:
+    // - do_pull  -> fails
+    // - do_push  -> return push(ones, grid, source_size)
+    // - do_grad  -> fails
+    // - do_sgrad -> fails
+    MONAI_HOST void ioset(IntArrayRef source_size, const Tensor& grid) {
+      init_all();
+      init_source(source_size);
+      init_grid(grid);
+      init_output();
+    }
+
+    // We just check that all tensors that we own are compatible with 32b math
+    bool canUse32BitIndexMath(int64_t max_elem = max_int32) const {
+      return src_32b_ok && trgt_32b_ok && grid_32b_ok && grad_32b_ok && out_32b_ok;
+    }
+
+   private:
+    // Copied from aten/src/ATen/native/IndexingUtils.cpp in PyTorch 1.6.
+    // It is used to decide to which pointer type we should dispatch to.
+    // Basically, we need to make sure that the "furthest" element we need
+    // to reach is less than max_elem away.
+    static bool tensorCanUse32BitIndexMath(const Tensor& t, int64_t max_elem = max_int32) {
+      int64_t elements = t.numel();
+      if (elements >= max_elem) {
+        return false;
+      }
+      if (elements == 0) {
+        return max_elem > 0;
+      }
+
+      int64_t offset = 0;
+      int64_t linearId = elements - 1;
+
+      // NOTE: Assumes all strides are positive, which is true for now
+      for (int i = t.dim() - 1; i >= 0; --i) {
+        int64_t curDimIndex = linearId % t.size(i);
+        int64_t curDimOffset = curDimIndex * t.stride(i);
+        offset += curDimOffset;
+        linearId /= t.size(i);
+      }
+
+      if (offset >= max_elem) {
+        return false;
+      }
+
+      return true;
+    }
+
+    // ~~~ COMPONENTS ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    MONAI_HOST void init_all();
+    MONAI_HOST void init_source(const Tensor& source);
+    MONAI_HOST void init_source(IntArrayRef source_size);
+    MONAI_HOST void init_grid(const Tensor& grid);
+    MONAI_HOST void init_target(const Tensor& target);
+    MONAI_HOST void init_output();
+
+    // ~~~ OPTIONS ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    int dim; // dimensionality (2 or 3)
+    BoundType bound0; // boundary condition  // x|W
+    BoundType bound1; // boundary condition  // y|H
+    BoundType bound2; // boundary condition  // z|D
+    InterpolationType interpolation0; // interpolation order // x|W
+    InterpolationType interpolation1; // interpolation order // y|H
+    InterpolationType interpolation2; // interpolation order // z|D
+    bool iso; // isotropic interpolation?
+    bool extrapolate; // compute out-of-bound values
+    bool do_pull; // sample a volume
+    bool do_push; // splat a volume
+    bool do_count; // splatting weights (= jacobian determinant)
+    bool do_grad; // backprop: gradient of grid // pull
+    bool do_sgrad; // sample spatial gradients
+
+    // ~~~ NAVIGATORS ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    std::deque<Tensor> output;
+    TensorOptions src_opt;
+    TensorOptions grid_opt;
+    TensorOptions trgt_opt;
+    int64_t N;
+    int64_t C;
+    int64_t src_X;
+    int64_t src_Y;
+    int64_t src_Z;
+    int64_t trgt_X;
+    int64_t trgt_Y;
+    int64_t trgt_Z;
+    int64_t trgt_K;
+    int64_t src_sN;
+    int64_t src_sC;
+    int64_t src_sX;
+    int64_t src_sY;
+    int64_t src_sZ;
+    bool src_32b_ok;
+    void* src_ptr;
+    int64_t trgt_sN;
+    int64_t trgt_sC;
+    int64_t trgt_sX;
+    int64_t trgt_sY;
+    int64_t trgt_sZ;
+    int64_t trgt_sK;
+    bool trgt_32b_ok;
+    void* trgt_ptr;
+    int64_t grid_sN;
+    int64_t grid_sC;
+    int64_t grid_sX;
+    int64_t grid_sY;
+    int64_t grid_sZ;
+    bool grid_32b_ok;
+    void* grid_ptr;
+    int64_t out_sN;
+    int64_t out_sC;
+    int64_t out_sX;
+    int64_t out_sY;
+    int64_t out_sZ;
+    int64_t out_sK; // gradient dimension
+    bool out_32b_ok;
+    void* out_ptr;
+    int64_t grad_sN;
+    int64_t grad_sC;
+    int64_t grad_sX;
+    int64_t grad_sY;
+    int64_t grad_sZ;
+    bool grad_32b_ok;
+    void* grad_ptr;
+
+    // Allow PushPullImpl's constructor to access PushPullAllocator's
+    // private members.
+    template <typename scalar_t, typename offset_t>
+    friend class PushPullImpl;
+  };
+
+  // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+  //                          INITIALISATION
+  // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+  MONAI_HOST
+  void PushPullAllocator::init_all() {
+    src_opt = grid_opt = trgt_opt = TensorOptions();
+    N = C = 1L;
+    src_X = src_Y = src_Z = 1L;
+    trgt_X = trgt_Y = trgt_Z = 1L;
+    trgt_K = 0L;
+    src_sN = src_sC = src_sX = src_sY = src_sZ = 0L;
+    grid_sN = grid_sC = grid_sX = grid_sY = grid_sZ = 0L;
+    grad_sN = grad_sC = grad_sX = grad_sY = grad_sZ = 0L;
+    trgt_sN = trgt_sC = trgt_sX = trgt_sY = trgt_sZ = trgt_sK = 0L;
+    out_sN = out_sC = out_sX = out_sY = out_sZ = out_sK = 0L;
+    src_ptr = trgt_ptr = grid_ptr = out_ptr = grad_ptr = static_cast<float*>(0);
+    src_32b_ok = trgt_32b_ok = grid_32b_ok = out_32b_ok = grad_32b_ok = true;
+  }
+
+  MONAI_HOST
+  void PushPullAllocator::init_source(const Tensor& source) {
+    N = source.size(0);
+    C = source.size(1);
+    src_X = source.size(2);
+    src_Y = dim < 2 ? 1L : source.size(3);
+    src_Z = dim < 3 ? 1L : source.size(4);
+    src_sN = source.stride(0);
+    src_sC = source.stride(1);
+    src_sX = source.stride(2);
+    src_sY = dim < 2 ? 0L : source.stride(3);
+    src_sZ = dim < 3 ? 0L : source.stride(4);
+    src_ptr = source.data_ptr();
+    src_opt = source.options();
+    src_32b_ok = tensorCanUse32BitIndexMath(source);
+  }
+
+  MONAI_HOST
+  void PushPullAllocator::init_source(IntArrayRef source_size) {
+    src_X = source_size[0];
+    src_Y = dim < 2 ? 1L : source_size[1];
+    src_Z = dim < 3 ? 1L : source_size[2];
+  }
+
+  MONAI_HOST
+  void PushPullAllocator::init_grid(const Tensor& grid) {
+    N = grid.size(0);
+    trgt_X = grid.size(1);
+    trgt_Y = dim < 2 ? 1L : grid.size(2);
+    trgt_Z = dim < 3 ? 1L : grid.size(3);
+    grid_sN = grid.stride(0);
+    grid_sX = grid.stride(1);
+    grid_sY = dim < 2 ? 0L : grid.stride(2);
+    grid_sZ = dim < 3 ? 0L : grid.stride(3);
+    grid_sC = grid.stride(dim == 1 ? 2 : dim == 2 ? 3 : 4);
+    grid_ptr = grid.data_ptr();
+    grid_opt = grid.options();
+    grid_32b_ok = tensorCanUse32BitIndexMath(grid);
+  }
+
+  MONAI_HOST
+  void PushPullAllocator::init_target(const Tensor& target) {
+    N = target.size(0);
+    C = target.size(1);
+    trgt_X = target.size(2);
+    trgt_Y = dim < 2 ? 1L : target.size(3);
+    trgt_Z = dim < 3 ? 1L : target.size(4);
+    trgt_K = target.dim() == dim + 3 ? target.size(dim == 1 ? 3 : dim == 2 ? 4 : 5) : 0L;
+    trgt_sN = target.stride(0);
+    trgt_sC = target.stride(1);
+    trgt_sX = target.stride(2);
+    trgt_sY = dim < 2 ? 0L : target.stride(3);
+    trgt_sZ = dim < 3 ? 0L : target.stride(4);
+    trgt_sK = target.dim() == dim + 3 ? target.stride(dim == 1 ? 3 : dim == 2 ? 4 : 5) : 0L;
+    trgt_ptr = target.data_ptr();
+    trgt_opt = target.options();
+    trgt_32b_ok = tensorCanUse32BitIndexMath(target);
+  }
+
+  MONAI_HOST
+  void PushPullAllocator::init_output() {
+    output.clear();
+    if (do_pull) {
+      if (dim == 1)
+        output.push_back(at::empty({N, C, trgt_X}, src_opt));
+      else if (dim == 2)
+        output.push_back(at::empty({N, C, trgt_X, trgt_Y}, src_opt));
+      else
+        output.push_back(at::empty({N, C, trgt_X, trgt_Y, trgt_Z}, src_opt));
+      auto pull = output.back();
+      out_sN = pull.stride(0);
+      out_sC = pull.stride(1);
+      out_sX = pull.stride(2);
+      out_sY = dim < 2 ? 0L : pull.stride(3);
+      out_sZ = dim < 3 ? 0L : pull.stride(4);
+      out_sK = 0L;
+      out_ptr = pull.data_ptr();
+      out_32b_ok = tensorCanUse32BitIndexMath(pull);
+    } else if (do_sgrad) {
+      if (dim == 1)
+        output.push_back(at::empty({N, C, trgt_X, 1}, src_opt));
+      else if (dim == 2)
+        output.push_back(at::empty({N, C, trgt_X, trgt_Y, 2}, src_opt));
+      else
+        output.push_back(at::empty({N, C, trgt_X, trgt_Y, trgt_Z, 3}, src_opt));
+      auto sgrad = output.back();
+      out_sN = sgrad.stride(0);
+      out_sC = sgrad.stride(1);
+      out_sX = sgrad.stride(2);
+      out_sY = dim < 2 ? 0L : sgrad.stride(3);
+      out_sZ = dim < 3 ? 0L : sgrad.stride(4);
+      out_sK = sgrad.stride(dim == 1 ? 3 : dim == 2 ? 4 : 5);
+      out_ptr = sgrad.data_ptr();
+      out_32b_ok = tensorCanUse32BitIndexMath(sgrad);
+
+      if (iso && interpolation0 == InterpolationType::Nearest)
+        sgrad.zero_();
+      if (iso && interpolation0 == InterpolationType::Linear && dim == 1)
+        sgrad.zero_();
+    } else if (do_push) {
+      if (dim == 1)
+        output.push_back(at::zeros({N, C, src_X}, trgt_opt));
+      else if (dim == 2)
+        output.push_back(at::zeros({N, C, src_X, src_Y}, trgt_opt));
+      else
+        output.push_back(at::zeros({N, C, src_X, src_Y, src_Z}, trgt_opt));
+      auto push = output.back();
+      out_sN = push.stride(0);
+      out_sC = push.stride(1);
+      out_sX = push.stride(2);
+      out_sY = dim < 2 ? 0L : push.stride(3);
+      out_sZ = dim < 3 ? 0L : push.stride(4);
+      out_sK = 0L;
+      out_ptr = push.data_ptr();
+      out_32b_ok = tensorCanUse32BitIndexMath(push);
+    } else if (do_count) {
+      if (dim == 1)
+        output.push_back(at::zeros({N, 1, src_X}, grid_opt));
+      else if (dim == 2)
+        output.push_back(at::zeros({N, 1, src_X, src_Y}, grid_opt));
+      else
+        output.push_back(at::zeros({N, 1, src_X, src_Y, src_Z}, grid_opt));
+      auto count = output.back();
+      out_sN = count.stride(0);
+      out_sC = count.stride(1);
+      out_sX = count.stride(2);
+      out_sY = dim < 2 ? 0L : count.stride(3);
+      out_sZ = dim < 3 ? 0L : count.stride(4);
+      out_sK = 0L;
+      out_ptr = count.data_ptr();
+      out_32b_ok = tensorCanUse32BitIndexMath(count);
+    }
+    if (do_grad) {
+      if (dim == 1)
+        output.push_back(at::zeros({N, trgt_X, 1}, grid_opt));
+      else if (dim == 2)
+        output.push_back(at::zeros({N, trgt_X, trgt_Y, 2}, grid_opt));
+      else
+        output.push_back(at::zeros({N, trgt_X, trgt_Y, trgt_Z, 3}, grid_opt));
+      auto grad = output.back();
+      grad_sN = grad.stride(0);
+      grad_sX = grad.stride(1);
+      grad_sY = dim < 2 ? 0L : grad.stride(2);
+      grad_sZ = dim < 3 ? 0L : grad.stride(3);
+      grad_sC = grad.stride(dim == 1 ? 2 : dim == 2 ? 3 : 4);
+      grad_ptr = grad.data_ptr();
+      out_32b_ok = tensorCanUse32BitIndexMath(grad);
+
+      if (iso && interpolation0 == InterpolationType::Nearest)
+        grad.zero_();
+    }
+  }
+
+  // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+  //                        GENERIC PUSHPULL CLASS
+  // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+  // This class implements the bulk of the code.
+  // /!\ No type and shape checking is performed here.
+
+  template <typename scalar_t, typename offset_t>
+  class PushPullImpl {
+   public:
+    // ~~~ CONSTRUCTOR ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    PushPullImpl(const PushPullAllocator& info)
+        : output(info.output),
+          dim(info.dim),
+          bound0(info.bound0),
+          bound1(info.bound1),
+          bound2(info.bound2),
+          interpolation0(info.interpolation0),
+          interpolation1(info.interpolation1),
+          interpolation2(info.interpolation1),
+          iso(info.iso),
+          extrapolate(info.extrapolate),
+          do_pull(info.do_pull),
+          do_push(info.do_push),
+          do_count(info.do_count),
+          do_grad(info.do_grad),
+          do_sgrad(info.do_sgrad),
+          N(static_cast<offset_t>(info.N)),
+          C(static_cast<offset_t>(info.C)),
+          src_X(static_cast<offset_t>(info.src_X)),
+          src_Y(static_cast<offset_t>(info.src_Y)),
+          src_Z(static_cast<offset_t>(info.src_Z)),
+          trgt_X(static_cast<offset_t>(info.trgt_X)),
+          trgt_Y(static_cast<offset_t>(info.trgt_Y)),
+          trgt_Z(static_cast<offset_t>(info.trgt_Z)),
+          trgt_K(static_cast<offset_t>(info.trgt_K)),
+          src_sN(static_cast<offset_t>(info.src_sN)),
+          src_sC(static_cast<offset_t>(info.src_sC)),
+          src_sX(static_cast<offset_t>(info.src_sX)),
+          src_sY(static_cast<offset_t>(info.src_sY)),
+          src_sZ(static_cast<offset_t>(info.src_sZ)),
+          src_ptr(static_cast<scalar_t*>(info.src_ptr)),
+          trgt_sN(static_cast<offset_t>(info.trgt_sN)),
+          trgt_sC(static_cast<offset_t>(info.trgt_sC)),
+          trgt_sX(static_cast<offset_t>(info.trgt_sX)),
+          trgt_sY(static_cast<offset_t>(info.trgt_sY)),
+          trgt_sZ(static_cast<offset_t>(info.trgt_sZ)),
+          trgt_sK(static_cast<offset_t>(info.trgt_sK)),
+          trgt_ptr(static_cast<scalar_t*>(info.trgt_ptr)),
+          grid_sN(static_cast<offset_t>(info.grid_sN)),
+          grid_sC(static_cast<offset_t>(info.grid_sC)),
+          grid_sX(static_cast<offset_t>(info.grid_sX)),
+          grid_sY(static_cast<offset_t>(info.grid_sY)),
+          grid_sZ(static_cast<offset_t>(info.grid_sZ)),
+          grid_ptr(static_cast<scalar_t*>(info.grid_ptr)),
+          out_sN(static_cast<offset_t>(info.out_sN)),
+          out_sC(static_cast<offset_t>(info.out_sC)),
+          out_sX(static_cast<offset_t>(info.out_sX)),
+          out_sY(static_cast<offset_t>(info.out_sY)),
+          out_sZ(static_cast<offset_t>(info.out_sZ)),
+          out_sK(static_cast<offset_t>(info.out_sK)),
+          out_ptr(static_cast<scalar_t*>(info.out_ptr)),
+          grad_sN(static_cast<offset_t>(info.grad_sN)),
+          grad_sC(static_cast<offset_t>(info.grad_sC)),
+          grad_sX(static_cast<offset_t>(info.grad_sX)),
+          grad_sY(static_cast<offset_t>(info.grad_sY)),
+          grad_sZ(static_cast<offset_t>(info.grad_sZ)),
+          grad_ptr(static_cast<scalar_t*>(info.grad_ptr)) {}
+
+    // ~~~ PUBLIC VALUE ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    std::deque<Tensor> output;
+
+    // MONAI_HOST MONAI_DEVICE void printInfo() const {
+    //   printf("dim: %d\n", dim);
+    //   printf("do_pull:  %d\n", do_pull);
+    //   printf("do_push:  %d\n", do_push);
+    //   printf("do_count: %d\n", do_count);
+    //   printf("do_sgrad: %d\n", do_sgrad);
+    //   printf("do_grad:  %d\n", do_grad);
+    //   printf("bound:         [%d %d %d]\n", static_cast<int>(bound0),
+    //     static_cast<int>(bound1), static_cast<int>(bound2));
+    //   printf("interpolation: [%d %d %d]\n", static_cast<int>(interpolation0),
+    //     static_cast<int>(interpolation1), static_cast<int>(interpolation2));
+    //   printf("src:  [%d %d %d]\n", src_Z, src_Y, src_X);
+    //   printf("trgt: [%d %d %d (%d)]\n", trgt_Z, trgt_Y, trgt_X, trgt_K);
+    //   printf("N: %d\n", N);
+    //   printf("C: %d\n", C);
+    //   printf("src  -> %lu\n", reinterpret_cast<std::uintptr_t>(src_ptr));
+    //   printf("trgt -> %lu\n", reinterpret_cast<std::uintptr_t>(trgt_ptr));
+    //   printf("grid -> %lu\n", reinterpret_cast<std::uintptr_t>(grid_ptr));
+    //   printf("out  -> %lu\n", reinterpret_cast<std::uintptr_t>(out_ptr));
+    //   printf("grad -> %lu\n", reinterpret_cast<std::uintptr_t>(grad_ptr));
+    // }
+
+    // ~~~ FUNCTORS ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    // Loop over voxels that belong to one CUDA block
+    // This function is called by the CUDA kernel
+    MONAI_DEVICE void loop(int threadIdx, int blockIdx, int blockDim, int gridDim) const;
+
+    MONAI_HOST MONAI_DEVICE int64_t voxcount() const {
+      return N * trgt_X * trgt_Y * trgt_Z;
+    }
+
+   private:
+    // ~~~ COMPONENTS ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    MONAI_DEVICE void check1d(offset_t w, offset_t n) const;
+    MONAI_DEVICE void check2d(offset_t w, offset_t h, offset_t n) const;
+    MONAI_DEVICE void check3d(offset_t w, offset_t h, offset_t d, offset_t n) const;
+    MONAI_DEVICE void interpolate1d(scalar_t x, offset_t w, offset_t n) const;
+    MONAI_DEVICE void interpolate1d_nearest(scalar_t x, offset_t w, offset_t n) const;
+    MONAI_DEVICE void interpolate1d_linear(scalar_t x, offset_t w, offset_t n) const;
+    MONAI_DEVICE void interpolate1d_sliding(scalar_t x, offset_t w, offset_t n) const { /*TODO*/
+    }
+    MONAI_DEVICE void interpolate1d_sliding_nearest(scalar_t x, offset_t w, offset_t n) const { /*TODO*/
+    }
+    MONAI_DEVICE void interpolate1d_sliding_linear(scalar_t x, offset_t w, offset_t n) const { /*TODO*/
+    }
+    MONAI_DEVICE void interpolate2d(scalar_t x, scalar_t y, offset_t w, offset_t h, offset_t n) const;
+    MONAI_DEVICE void interpolate2d_nearest(scalar_t x, scalar_t y, offset_t w, offset_t h, offset_t n) const;
+    MONAI_DEVICE void interpolate2d_bilinear(scalar_t x, scalar_t y, offset_t w, offset_t h, offset_t n) const;
+    MONAI_DEVICE void interpolate2d_sliding(scalar_t x, scalar_t y, offset_t w, offset_t h, offset_t n) const { /*TODO*/
+    }
+    MONAI_DEVICE void interpolate2d_sliding_nearest(scalar_t x, scalar_t y, offset_t w, offset_t h, offset_t n)
+        const { /*TODO*/
+    }
+    MONAI_DEVICE void interpolate2d_sliding_bilinear(scalar_t x, scalar_t y, offset_t w, offset_t h, offset_t n)
+        const { /*TODO*/
+    }
+    MONAI_DEVICE void interpolate3d(scalar_t x, scalar_t y, scalar_t z, offset_t w, offset_t h, offset_t d, offset_t n)
+        const;
+    MONAI_DEVICE void interpolate3d_nearest(
+        scalar_t x,
+        scalar_t y,
+        scalar_t z,
+        offset_t w,
+        offset_t h,
+        offset_t d,
+        offset_t n) const;
+    MONAI_DEVICE void interpolate3d_trilinear(
+        scalar_t x,
+        scalar_t y,
+        scalar_t z,
+        offset_t w,
+        offset_t h,
+        offset_t d,
+        offset_t n) const;
+    MONAI_DEVICE void interpolate3d_sliding(
+        scalar_t x,
+        scalar_t y,
+        scalar_t z,
+        offset_t w,
+        offset_t h,
+        offset_t d,
+        offset_t n) const { /*TODO*/
+    }
+    MONAI_DEVICE void interpolate3d_sliding_nearest(
+        scalar_t x,
+        scalar_t y,
+        scalar_t z,
+        offset_t w,
+        offset_t h,
+        offset_t d,
+        offset_t n) const { /*TODO*/
+    }
+    MONAI_DEVICE void interpolate3d_sliding_trilinear(
+        scalar_t x,
+        scalar_t y,
+        scalar_t z,
+        offset_t w,
+        offset_t h,
+        offset_t d,
+        offset_t n) const { /*TODO*/
+    }
+
+    // ~~~ OPTIONS ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    int dim; // dimensionality (2 or 3)
+    BoundType bound0; // boundary condition  // x|W
+    BoundType bound1; // boundary condition  // y|H
+    BoundType bound2; // boundary condition  // z|D
+    InterpolationType interpolation0; // interpolation order // x|W
+    InterpolationType interpolation1; // interpolation order // y|H
+    InterpolationType interpolation2; // interpolation order // z|D
+    bool iso; // isotropic interpolation?
+    bool extrapolate; // compute out-of-bound values
+    bool do_pull; // sample a volume
+    bool do_push; // splat a volume
+    bool do_count; // splatting weights (= jacobian determinant)
+    bool do_grad; // backprop: gradient of grid // pull
+    bool do_sgrad; // sample spatial gradients
+
+    // ~~~ NAVIGATORS ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    offset_t N;
+    offset_t C;
+    offset_t src_X;
+    offset_t src_Y;
+    offset_t src_Z;
+    offset_t trgt_X;
+    offset_t trgt_Y;
+    offset_t trgt_Z;
+    offset_t trgt_K;
+    offset_t src_sN;
+    offset_t src_sC;
+    offset_t src_sX;
+    offset_t src_sY;
+    offset_t src_sZ;
+    scalar_t* src_ptr;
+    offset_t trgt_sN;
+    offset_t trgt_sC;
+    offset_t trgt_sX;
+    offset_t trgt_sY;
+    offset_t trgt_sZ;
+    offset_t trgt_sK;
+    scalar_t* trgt_ptr;
+    offset_t grid_sN;
+    offset_t grid_sC;
+    offset_t grid_sX;
+    offset_t grid_sY;
+    offset_t grid_sZ;
+    scalar_t* grid_ptr;
+    offset_t out_sN;
+    offset_t out_sC;
+    offset_t out_sX;
+    offset_t out_sY;
+    offset_t out_sZ;
+    offset_t out_sK; // gradient dimension
+    scalar_t* out_ptr;
+    offset_t grad_sN;
+    offset_t grad_sC;
+    offset_t grad_sX;
+    offset_t grad_sY;
+    offset_t grad_sZ;
+    scalar_t* grad_ptr;
+  };
+
+  // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+  //                             LOOP
+  // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+  template <typename scalar_t, typename offset_t>
+  MONAI_DEVICE void PushPullImpl<scalar_t, offset_t>::loop(int threadIdx, int blockIdx, int blockDim, int gridDim)
+      const {
+    int64_t index = blockIdx * blockDim + threadIdx;
+    int64_t nthreads = voxcount();
+    offset_t trgt_XYZ = trgt_Z * trgt_Y * trgt_X;
+    offset_t trgt_YZ = trgt_Z * trgt_Y;
+    offset_t n, w, h, d;
+    for (offset_t i = index; index < nthreads; index += blockDim * gridDim, i = index) {
+      // Convert index: linear to sub
+      n = (i / trgt_XYZ);
+      w = (i / trgt_YZ) % trgt_X;
+      h = (i / trgt_Z) % trgt_Y;
+      d = i % trgt_Z;
+
+      if (dim == 1)
+        check1d(w, n);
+      else if (dim == 2)
+        check2d(w, h, n);
+      else
+        check3d(w, h, d, n);
+    }
+  }
+
+  // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+  //                        CHECK OUT-OF-BOUND
+  // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+  // Here, we:
+  // 1) read the [x,y,z] source coordinate for the current target voxel
+  // 3) check if the source coordinate is in bounds
+
+  template <typename scalar_t, typename offset_t>
+  MONAI_DEVICE void PushPullImpl<scalar_t, offset_t>::check3d(offset_t w, offset_t h, offset_t d, offset_t n) const {
+    // get the corresponding input x, y, z co-ordinates from grid
+    scalar_t* grid_ptr_NXYZ = grid_ptr + n * grid_sN + w * grid_sX + h * grid_sY + d * grid_sZ;
+    scalar_t x = *grid_ptr_NXYZ;
+    scalar_t y = grid_ptr_NXYZ[grid_sC];
+    scalar_t z = grid_ptr_NXYZ[grid_sC * 2];
+
+    // Check if out-of-bound
+    if (!(extrapolate ||
+          (inbounds(x, src_X, static_cast<scalar_t>(TINY)) && inbounds(y, src_Y, static_cast<scalar_t>(TINY)) &&
+           inbounds(z, src_Z, static_cast<scalar_t>(TINY))))) {
+      if (do_pull || do_sgrad) {
+        scalar_t* out_ptr_NCXYZ = out_ptr + n * out_sN + w * out_sX + h * out_sY + d * out_sZ;
+        for (offset_t c = 0; c < C; ++c, out_ptr_NCXYZ += out_sC) {
+          *out_ptr_NCXYZ = static_cast<scalar_t>(0);
+          if (do_sgrad) {
+            out_ptr_NCXYZ[out_sK] = static_cast<scalar_t>(0);
+            out_ptr_NCXYZ[out_sK * 2] = static_cast<scalar_t>(0);
+          }
+        }
+      }
+      if (do_grad) {
+        scalar_t* grad_ptr_NXYZ = grad_ptr + n * grad_sN + w * grad_sX + h * grad_sY + d * grad_sZ;
+        (*grad_ptr_NXYZ) = static_cast<scalar_t>(0);
+        grad_ptr_NXYZ[grad_sC] = static_cast<scalar_t>(0);
+        grad_ptr_NXYZ[grad_sC * 2] = static_cast<scalar_t>(0);
+      }
+      return;
+    }
+
+    // Next step
+    if (bound0 == BoundType::Sliding) {
+      if (iso)
+        switch (static_cast<int>(interpolation0)) {
+          case 0:
+            return interpolate3d_sliding_nearest(x, y, z, w, h, d, n);
+          case 1:
+            return interpolate3d_sliding_trilinear(x, y, z, w, h, d, n);
+        }
+      return interpolate3d_sliding(x, y, z, w, h, d, n);
+    } else {
+      if (iso)
+        switch (static_cast<int>(interpolation0)) {
+          case 0:
+            return interpolate3d_nearest(x, y, z, w, h, d, n);
+          case 1:
+            return interpolate3d_trilinear(x, y, z, w, h, d, n);
+        }
+      return interpolate3d(x, y, z, w, h, d, n);
+    }
+  }
+
+  template <typename scalar_t, typename offset_t>
+  MONAI_DEVICE void PushPullImpl<scalar_t, offset_t>::check2d(offset_t w, offset_t h, offset_t n) const {
+    // get the corresponding input x, y, z co-ordinates from grid
+    scalar_t* grid_ptr_NXY = grid_ptr + n * grid_sN + w * grid_sX + h * grid_sY;
+    scalar_t x = *grid_ptr_NXY;
+    scalar_t y = grid_ptr_NXY[grid_sC];
+
+    // Check if out-of-bound
+    if (!(extrapolate ||
+          (inbounds(x, src_X, static_cast<scalar_t>(TINY)) && inbounds(y, src_Y, static_cast<scalar_t>(TINY))))) {
+      if (do_pull || do_sgrad) {
+        scalar_t* out_ptr_NCXY = out_ptr + n * out_sN + w * out_sX + h * out_sY;
+        for (offset_t c = 0; c < C; ++c, out_ptr_NCXY += out_sC) {
+          *out_ptr_NCXY = static_cast<scalar_t>(0);
+          if (do_sgrad)
+            out_ptr_NCXY[out_sK] = static_cast<scalar_t>(0);
+        }
+      }
+      if (do_grad) {
+        scalar_t* grad_ptr_NXY = grad_ptr + n * grad_sN + w * grad_sX + h * grad_sY;
+        (*grad_ptr_NXY) = static_cast<scalar_t>(0);
+        grad_ptr_NXY[grad_sC] = static_cast<scalar_t>(0);
+      }
+      return;
+    }
+
+    // Next step
+    if (bound0 == BoundType::Sliding) {
+      if (iso)
+        switch (static_cast<int>(interpolation0)) {
+          case 0:
+            return interpolate2d_sliding_nearest(x, y, w, h, n);
+          case 1:
+            return interpolate2d_sliding_bilinear(x, y, w, h, n);
+        }
+      return interpolate2d_sliding(x, y, w, h, n);
+    } else {
+      if (iso)
+        switch (static_cast<int>(interpolation0)) {
+          case 0:
+            return interpolate2d_nearest(x, y, w, h, n);
+          case 1:
+            return interpolate2d_bilinear(x, y, w, h, n);
+        }
+      return interpolate2d(x, y, w, h, n);
+    }
+  }
+
+  template <typename scalar_t, typename offset_t>
+  MONAI_DEVICE void PushPullImpl<scalar_t, offset_t>::check1d(offset_t w, offset_t n) const {
+    // get the corresponding input x, y, z co-ordinates from grid
+    scalar_t* grid_ptr_NX = grid_ptr + n * grid_sN + w * grid_sX;
+    scalar_t x = *grid_ptr_NX;
+
+    // Check if out-of-bound
+    if (!(extrapolate || inbounds(x, src_X, static_cast<scalar_t>(TINY)))) {
+      if (do_pull || do_sgrad) {
+        scalar_t* out_ptr_NCX = out_ptr + n * out_sN + w * out_sX;
+        for (offset_t c = 0; c < C; ++c, out_ptr_NCX += out_sC) {
+          *out_ptr_NCX = static_cast<scalar_t>(0);
+          if (do_sgrad)
+            out_ptr_NCX[out_sK] = static_cast<scalar_t>(0);
+        }
+      }
+      if (do_grad) {
+        scalar_t* grad_ptr_NX = grad_ptr + n * grad_sN + w * grad_sX;
+        (*grad_ptr_NX) = static_cast<scalar_t>(0);
+        grad_ptr_NX[grad_sC] = static_cast<scalar_t>(0);
+      }
+      return;
+    }
+
+    // Next step
+    if (bound0 == BoundType::Sliding) {
+      if (iso)
+        switch (static_cast<int>(interpolation0)) {
+          case 0:
+            return interpolate1d_sliding_nearest(x, w, n);
+          case 1:
+            return interpolate1d_sliding_linear(x, w, n);
+        }
+      return interpolate1d_sliding(x, w, n);
+    } else {
+      if (iso)
+        switch (static_cast<int>(interpolation0)) {
+          case 0:
+            return interpolate1d_nearest(x, w, n);
+          case 1:
+            return interpolate1d_linear(x, w, n);
+        }
+      return interpolate1d(x, w, n);
+    }
+  }
+
+  // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+  //                     GENERIC INTERPOLATION 3D
+  // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+  template <typename scalar_t, typename offset_t>
+  MONAI_DEVICE void PushPullImpl<scalar_t, offset_t>::interpolate3d(
+      scalar_t x,
+      scalar_t y,
+      scalar_t z,
+      offset_t w,
+      offset_t h,
+      offset_t d,
+      offset_t n) const {
+    // Get corner pixel values from (x, y, z)
+    offset_t bx0, bx1, by0, by1, bz0, bz1;
+    interpolation::bounds(interpolation0, x, bx0, bx1);
+    interpolation::bounds(interpolation1, y, by0, by1);
+    interpolation::bounds(interpolation2, z, bz0, bz1);
+    offset_t dbx = bx1 - bx0;
+    offset_t dby = by1 - by0;
+    offset_t dbz = bz1 - bz0;
+
+    // Pre-compute offsets and target value
+    scalar_t* src_ptr_NC0 = src_ptr + n * src_sN;
+    scalar_t* out_ptr_NC0 = out_ptr + n * out_sN;
+    scalar_t* out_ptr_NCXYZ0 = out_ptr + n * out_sN + w * out_sX + h * out_sY + d * out_sZ;
+    scalar_t* trgt_ptr_NCXYZ = trgt_ptr + n * trgt_sN + w * trgt_sX + h * trgt_sY + d * trgt_sZ;
+    scalar_t target[3 * MONAI_MAX_NUM_CHANNELS];
+    if (trgt_ptr && (do_push || do_grad))
+      for (offset_t c = 0; c < C; ++c, trgt_ptr_NCXYZ += trgt_sC) {
+        target[c] = *trgt_ptr_NCXYZ;
+        if (trgt_K > 0) {
+          target[c + C] = trgt_ptr_NCXYZ[trgt_sK];
+          target[c + C * 2] = trgt_ptr_NCXYZ[trgt_sK * 2];
+        }
+      }
+
+    // Initialize output
+    scalar_t* out_ptr_NCXYZ = out_ptr_NCXYZ0;
+    if (do_pull || do_sgrad) {
+      for (offset_t c = 0; c < C; ++c, out_ptr_NCXYZ += out_sC) {
+        *out_ptr_NCXYZ = static_cast<scalar_t>(0);
+        if (do_sgrad) {
+          out_ptr_NCXYZ[out_sK] = static_cast<scalar_t>(0);
+          out_ptr_NCXYZ[out_sK * 2] = static_cast<scalar_t>(0);
+        }
+      }
+    }
+
+    // Pre-compute indices/weights/grad
+    scalar_t wx[8], wy[8], wz[8]; // B-spline weights
+    scalar_t gx[8], gy[8], gz[8]; // B-spline derivatives
+    scalar_t hx[8], hy[8], hz[8]; // B-spline 2nd derivatives
+    offset_t ix[8], iy[8], iz[8]; // Warped indices
+    uint8_t sx[8], sy[8], sz[8]; // Warped indices
+
+    {
+      scalar_t *owz = static_cast<scalar_t*>(wz), *ogz = static_cast<scalar_t*>(gz), *ohz = static_cast<scalar_t*>(hz);
+      offset_t* oiz = static_cast<offset_t*>(iz);
+      uint8_t* osz = static_cast<uint8_t*>(sz);
+      for (offset_t bz = bz0; bz <= bz1; ++bz) {
+        scalar_t dz = z - bz;
+        *(owz++) = interpolation::fastweight(interpolation2, dz);
+        if (do_grad || do_sgrad)
+          *(ogz++) = interpolation::fastgrad(interpolation2, dz);
+        if (do_grad && trgt_sK > 1)
+          *(ohz++) = interpolation::fasthess(interpolation2, dz);
+        *(osz++) = bound::sign(bound2, bz, src_Z);
+        *(oiz++) = bound::index(bound2, bz, src_Z);
+      }
+    }
+    {
+      scalar_t *owy = static_cast<scalar_t*>(wy), *ogy = static_cast<scalar_t*>(gy), *ohy = static_cast<scalar_t*>(hy);
+      offset_t* oiy = static_cast<offset_t*>(iy);
+      uint8_t* osy = static_cast<uint8_t*>(sy);
+      for (offset_t by = by0; by <= by1; ++by) {
+        scalar_t dy = y - by;
+        *(owy++) = interpolation::fastweight(interpolation1, dy);
+        if (do_grad || do_sgrad)
+          *(ogy++) = interpolation::fastgrad(interpolation1, dy);
+        if (do_grad && trgt_sK > 1)
+          *(ohy++) = interpolation::fasthess(interpolation1, dy);
+        *(osy++) = bound::sign(bound1, by, src_Y);
+        *(oiy++) = bound::index(bound1, by, src_Y);
+      }
+    }
+    {
+      scalar_t *owx = static_cast<scalar_t*>(wx), *ogx = static_cast<scalar_t*>(gx), *ohx = static_cast<scalar_t*>(hx);
+      offset_t* oix = static_cast<offset_t*>(ix);
+      uint8_t* osx = static_cast<uint8_t*>(sx);
+      for (offset_t bx = bx0; bx <= bx1; ++bx) {
+        scalar_t dx = x - bx;
+        *(owx++) = interpolation::fastweight(interpolation0, dx);
+        if (do_grad || do_sgrad)
+          *(ogx++) = interpolation::fastgrad(interpolation0, dx);
+        if (do_grad && trgt_sK > 1)
+          *(ohx++) = interpolation::fasthess(interpolation0, dx);
+        *(osx++) = bound::sign(bound0, bx, src_X);
+        *(oix++) = bound::index(bound0, bx, src_X);
+      }
+    }
+
+    // Convolve coefficients with basis functions
+    scalar_t ogx, ogy, ogz;
+    ogx = ogy = ogz = static_cast<scalar_t>(0);
+    for (offset_t k = 0; k <= dbz; ++k) {
+      offset_t ooz = iz[k] * out_sZ;
+      offset_t osz = iz[k] * src_sZ;
+      uint8_t szz = sz[k];
+      scalar_t wzz = wz[k];
+      scalar_t gzz = gz[k];
+      scalar_t hzz = hz[k];
+      for (offset_t j = 0; j <= dby; ++j) {
+        offset_t ooyz = ooz + iy[j] * out_sY;
+        offset_t osyz = osz + iy[j] * src_sY;
+        uint8_t syz = szz * sy[j];
+        scalar_t wyy = wy[j];
+        scalar_t gyy = gy[j];
+        scalar_t hyy = hy[j];
+        for (offset_t i = 0; i <= dbx; ++i) {
+          offset_t ooxyz = ooyz + ix[i] * out_sX;
+          offset_t osxyz = osyz + ix[i] * src_sX;
+          uint8_t sxyz = syz * sx[i];
+          scalar_t wxx = wx[i];
+          scalar_t gxx = gx[i];
+          scalar_t hxx = hx[i];
+
+          // ~~~~~~~~~~~~~~~~~~~~~~~~~~~ Pull ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+          if (do_pull) {
+            scalar_t* src_ptr_NC = src_ptr_NC0;
+            scalar_t* out_ptr_NCXYZ = out_ptr_NCXYZ0;
+            for (offset_t c = 0; c < C; ++c, out_ptr_NCXYZ += out_sC, src_ptr_NC += src_sC)
+              *out_ptr_NCXYZ += bound::get(src_ptr_NC, osxyz, sxyz) * (wxx * wyy * wzz);
+          }
+
+          // ~~~~~~~~~~~~~~~~~~~~~~~~~~~ SGrad ~~~~~~~~~~~~~~~~~~~~~~~~~~~
+          else if (do_sgrad) {
+            scalar_t* src_ptr_NC = src_ptr_NC0;
+            scalar_t* out_ptr_NCXYZ = out_ptr_NCXYZ0;
+            for (offset_t c = 0; c < C; ++c, out_ptr_NCXYZ += out_sC, src_ptr_NC += src_sC) {
+              scalar_t src = bound::get(src_ptr_NC, osxyz, sxyz);
+              *out_ptr_NCXYZ += src * (gxx * wyy * wzz);
+              out_ptr_NCXYZ[out_sK] += src * (wxx * gyy * wzz);
+              out_ptr_NCXYZ[2 * out_sK] += src * (wxx * wyy * gzz);
+            }
+          }
+
+          // ~~~~~~~~~~~~~~~~~~~~~~~~~~~ Push ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+          else if (do_push) {
+            if (trgt_K == 0) {
+              // Diff w.r.t. push/pull
+              scalar_t* out_ptr_NC = out_ptr_NC0;
+              for (offset_t c = 0; c < C; ++c, out_ptr_NC += out_sC)
+                bound::add(out_ptr_NC, ooxyz, (wxx * wyy * wzz) * target[c], sxyz);
+            } else {
+              // Diff w.r.t. sgrad
+              scalar_t* out_ptr_NC = out_ptr_NC0;
+              for (offset_t c = 0; c < C; ++c, out_ptr_NC += out_sC) {
+                scalar_t val = (gxx * wyy * wzz) * target[c] + (wxx * gyy * wzz) * target[c + C] +
+                    (wxx * wyy * gzz) * target[c + C * 2];
+                bound::add(out_ptr_NC, ooxyz, val, sxyz);
+              }
+            }
+          }
+
+          // ~~~~~~~~~~~~~~~~~~~~~~~~~~~ Count ~~~~~~~~~~~~~~~~~~~~~~~~~~~
+          else if (do_count) {
+            bound::add(out_ptr_NC0, ooxyz, (wxx * wyy * wzz), sxyz);
+          }
+
+          // ~~~~~~~~~~~~~~~~~~~~~~~~~~~ Grad ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+          if (do_grad) {
+            if (trgt_K == 0) {
+              // Diff w.r.t. pull/push
+              scalar_t* src_ptr_NC = src_ptr_NC0;
+              scalar_t dot = static_cast<scalar_t>(0);
+              for (offset_t c = 0; c < C; ++c, src_ptr_NC += src_sC) {
+                scalar_t src = bound::get(src_ptr_NC, osxyz, sxyz);
+                dot += (trgt_ptr ? src * target[c] : src);
+                // trgt_ptr == 0 in the backward pass of 'count'
+              }
+              ogx += (gxx * wyy * wzz) * dot;
+              ogy += (wxx * gyy * wzz) * dot;
+              ogz += (wxx * wyy * gzz) * dot;
+            } else {
+              // Diff w.r.t. sgrad
+              scalar_t* src_ptr_NC = src_ptr_NC0;
+              scalar_t dot0, dot1, dot2;
+              dot0 = dot1 = dot2 = static_cast<scalar_t>(0);
+              for (offset_t c = 0; c < C; ++c, src_ptr_NC += src_sC) {
+                scalar_t src = bound::get(src_ptr_NC, osxyz, sxyz);
+                dot0 += src * target[c];
+                dot1 += src * target[c + C];
+                dot2 += src * target[c + C * 2];
+              }
+              ogx += (hxx * wyy * wzz) * dot0 + (gxx * gyy * wzz) * dot1 + (gxx * wyy * gzz) * dot2;
+              ogy += (gxx * gyy * wzz) * dot0 + (wxx * hyy * wzz) * dot1 + (wxx * gyy * gzz) * dot2;
+              ogz += (gxx * wyy * gzz) * dot0 + (wxx * gyy * gzz) * dot1 + (wxx * wyy * hzz) * dot2;
+            }
+          }
+
+        } // x
+      } // y
+    } // z
+
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Grad ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    if (do_grad) {
+      scalar_t* grad_ptr_NXYZ = grad_ptr + n * grad_sN + w * grad_sX + h * grad_sY + d * grad_sZ;
+      (*grad_ptr_NXYZ) = ogx;
+      grad_ptr_NXYZ[grad_sC] = ogy;
+      grad_ptr_NXYZ[grad_sC * 2] = ogz;
+    }
+  }
+
+  // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+  //                     GENERIC INTERPOLATION 2D
+  // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+  template <typename scalar_t, typename offset_t>
+  MONAI_DEVICE void PushPullImpl<scalar_t, offset_t>::interpolate2d(
+      scalar_t x,
+      scalar_t y,
+      offset_t w,
+      offset_t h,
+      offset_t n) const {
+    // Get corner pixel values from (x, y)
+    offset_t bx0, bx1, by0, by1;
+    interpolation::bounds(interpolation0, x, bx0, bx1);
+    interpolation::bounds(interpolation1, y, by0, by1);
+    offset_t dbx = bx1 - bx0;
+    offset_t dby = by1 - by0;
+
+    // Pre-compute offsets and target value
+    scalar_t* src_ptr_NC0 = src_ptr + n * src_sN;
+    scalar_t* out_ptr_NC0 = out_ptr + n * out_sN;
+    scalar_t* out_ptr_NCXY0 = out_ptr + n * out_sN + w * out_sX + h * out_sY;
+    scalar_t* trgt_ptr_NCXY = trgt_ptr + n * trgt_sN + w * trgt_sX + h * trgt_sY;
+    scalar_t target[2 * MONAI_MAX_NUM_CHANNELS];
+    if (trgt_ptr && (do_push || do_grad))
+      for (offset_t c = 0; c < C; ++c, trgt_ptr_NCXY += trgt_sC) {
+        target[c] = *trgt_ptr_NCXY;
+        if (trgt_K > 0) {
+          target[c + C] = trgt_ptr_NCXY[trgt_sK];
+        }
+      }
+
+    // Initialize output
+    scalar_t* out_ptr_NCXY = out_ptr_NCXY0;
+    if (do_pull || do_sgrad) {
+      for (offset_t c = 0; c < C; ++c, out_ptr_NCXY += out_sC) {
+        *out_ptr_NCXY = static_cast<scalar_t>(0);
+        if (do_sgrad) {
+          out_ptr_NCXY[out_sK] = static_cast<scalar_t>(0);
+        }
+      }
+    }
+
+    // Pre-compute indices/weights/grad
+    scalar_t wx[8], wy[8]; // B-spline weights
+    scalar_t gx[8], gy[8]; // B-spline derivatives
+    scalar_t hx[8], hy[8]; // B-spline 2nd derivatives
+    offset_t ix[8], iy[8]; // Warped indices
+    uint8_t sx[8], sy[8]; // Warped indices
+
+    {
+      scalar_t *owy = static_cast<scalar_t*>(wy), *ogy = static_cast<scalar_t*>(gy), *ohy = static_cast<scalar_t*>(hy);
+      offset_t* oiy = static_cast<offset_t*>(iy);
+      uint8_t* osy = static_cast<uint8_t*>(sy);
+      for (offset_t by = by0; by <= by1; ++by) {
+        scalar_t dy = y - by;
+        *(owy++) = interpolation::fastweight(interpolation1, dy);
+        if (do_grad || do_sgrad)
+          *(ogy++) = interpolation::fastgrad(interpolation1, dy);
+        if (do_grad && trgt_sK > 1)
+          *(ohy++) = interpolation::fasthess(interpolation1, dy);
+        *(osy++) = bound::sign(bound1, by, src_Y);
+        *(oiy++) = bound::index(bound1, by, src_Y);
+      }
+    }
+    {
+      scalar_t *owx = static_cast<scalar_t*>(wx), *ogx = static_cast<scalar_t*>(gx), *ohx = static_cast<scalar_t*>(hx);
+      offset_t* oix = static_cast<offset_t*>(ix);
+      uint8_t* osx = static_cast<uint8_t*>(sx);
+      for (offset_t bx = bx0; bx <= bx1; ++bx) {
+        scalar_t dx = x - bx;
+        *(owx++) = interpolation::fastweight(interpolation0, dx);
+        if (do_grad || do_sgrad)
+          *(ogx++) = interpolation::fastgrad(interpolation0, dx);
+        if (do_grad && trgt_sK > 1)
+          *(ohx++) = interpolation::fasthess(interpolation0, dx);
+        *(osx++) = bound::sign(bound0, bx, src_X);
+        *(oix++) = bound::index(bound0, bx, src_X);
+      }
+    }
+
+    // Convolve coefficients with basis functions
+    scalar_t ogx, ogy;
+    ogx = ogy = static_cast<scalar_t>(0);
+    for (offset_t j = 0; j <= dby; ++j) {
+      offset_t ooy = iy[j] * out_sY;
+      offset_t osy = iy[j] * src_sY;
+      uint8_t syy = sy[j];
+      scalar_t wyy = wy[j];
+      scalar_t gyy = gy[j];
+      scalar_t hyy = hy[j];
+      for (offset_t i = 0; i <= dbx; ++i) {
+        offset_t ooxy = ooy + ix[i] * out_sX;
+        offset_t osxy = osy + ix[i] * src_sX;
+        uint8_t sxy = syy * sx[i];
+        scalar_t wxx = wx[i];
+        scalar_t gxx = gx[i];
+        scalar_t hxx = hx[i];
+
+        // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Pull ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+        if (do_pull) {
+          scalar_t* src_ptr_NC = src_ptr_NC0;
+          scalar_t* out_ptr_NCXY = out_ptr_NCXY0;
+          for (offset_t c = 0; c < C; ++c, out_ptr_NCXY += out_sC, src_ptr_NC += src_sC)
+            *out_ptr_NCXY += bound::get(src_ptr_NC, osxy, sxy) * (wxx * wyy);
+        }
+
+        // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ SGrad ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+        else if (do_sgrad) {
+          scalar_t* src_ptr_NC = src_ptr_NC0;
+          scalar_t* out_ptr_NCXY = out_ptr_NCXY0;
+          for (offset_t c = 0; c < C; ++c, out_ptr_NCXY += out_sC, src_ptr_NC += src_sC) {
+            scalar_t src = bound::get(src_ptr_NC, osxy, sxy);
+            *out_ptr_NCXY += src * (gxx * wyy);
+            out_ptr_NCXY[out_sK] += src * (wxx * gyy);
+          }
+        }
+
+        // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Push ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+        else if (do_push) {
+          if (trgt_K == 0) {
+            // Diff w.r.t. push/pull
+            scalar_t* out_ptr_NC = out_ptr_NC0;
+            for (offset_t c = 0; c < C; ++c, out_ptr_NC += out_sC)
+              bound::add(out_ptr_NC, ooxy, (wxx * wyy) * target[c], sxy);
+          } else {
+            // Diff w.r.t. sgrad
+            scalar_t* out_ptr_NC = out_ptr_NC0;
+            for (offset_t c = 0; c < C; ++c, out_ptr_NC += out_sC) {
+              scalar_t val = (gxx * wyy) * target[c] + (wxx * gyy) * target[c + C];
+              bound::add(out_ptr_NC, ooxy, val, sxy);
+            }
+          }
+        }
+
+        // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Count ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+        else if (do_count) {
+          bound::add(out_ptr_NC0, ooxy, (wxx * wyy), sxy);
+        }
+
+        // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Grad ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+        if (do_grad) {
+          if (trgt_K == 0) {
+            // Diff w.r.t. pull/push
+            scalar_t* src_ptr_NC = src_ptr_NC0;
+            scalar_t dot = static_cast<scalar_t>(0);
+            for (offset_t c = 0; c < C; ++c, src_ptr_NC += src_sC) {
+              scalar_t src = bound::get(src_ptr_NC, osxy, sxy);
+              dot += (trgt_ptr ? src * target[c] : src);
+              // trgt_ptr == 0 in the backward pass of 'count'
+            }
+            ogx += (gxx * wyy) * dot;
+            ogy += (wxx * gyy) * dot;
+          } else {
+            // Diff w.r.t. sgrad
+            scalar_t* src_ptr_NC = src_ptr_NC0;
+            scalar_t dot0, dot1;
+            dot0 = dot1 = static_cast<scalar_t>(0);
+            for (offset_t c = 0; c < C; ++c, src_ptr_NC += src_sC) {
+              scalar_t src = bound::get(src_ptr_NC, osxy, sxy);
+              dot0 += src * target[c];
+              dot1 += src * target[c + C];
+            }
+            ogx += (hxx * wyy) * dot0 + (gxx * gyy) * dot1;
+            ogy += (gxx * gyy) * dot0 + (wxx * hyy) * dot1;
+          }
+        }
+
+      } // x
+    } // y
+
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Grad ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    if (do_grad) {
+      scalar_t* grad_ptr_NXY = grad_ptr + n * grad_sN + w * grad_sX + h * grad_sY;
+      (*grad_ptr_NXY) = ogx;
+      grad_ptr_NXY[grad_sC] = ogy;
+    }
+  }
+
+  // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+  //                     GENERIC INTERPOLATION 1D
+  // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+  template <typename scalar_t, typename offset_t>
+  MONAI_DEVICE void PushPullImpl<scalar_t, offset_t>::interpolate1d(scalar_t x, offset_t w, offset_t n) const {
+    // Get corner pixel values from (x, y)
+    offset_t bx0, bx1;
+    interpolation::bounds(interpolation0, x, bx0, bx1);
+    offset_t dbx = bx1 - bx0;
+
+    // Pre-compute offsets and target value
+    scalar_t* src_ptr_NC0 = src_ptr + n * src_sN;
+    scalar_t* out_ptr_NC0 = out_ptr + n * out_sN;
+    scalar_t* out_ptr_NCX0 = out_ptr + n * out_sN + w * out_sX;
+    scalar_t* trgt_ptr_NCX = trgt_ptr + n * trgt_sN + w * trgt_sX;
+    scalar_t target[2 * MONAI_MAX_NUM_CHANNELS];
+    if (trgt_ptr && (do_push || do_grad))
+      for (offset_t c = 0; c < C; ++c, trgt_ptr_NCX += trgt_sC) {
+        target[c] = *trgt_ptr_NCX;
+        if (trgt_K > 0) {
+          target[c + C] = trgt_ptr_NCX[trgt_sK];
+        }
+      }
+
+    // Initialize output
+    scalar_t* out_ptr_NCX = out_ptr_NCX0;
+    if (do_pull || do_sgrad) {
+      for (offset_t c = 0; c < C; ++c, out_ptr_NCX += out_sC) {
+        *out_ptr_NCX = static_cast<scalar_t>(0);
+        if (do_sgrad) {
+          out_ptr_NCX[out_sK] = static_cast<scalar_t>(0);
+        }
+      }
+    }
+
+    // Pre-compute indices/weights/grad
+    scalar_t wx[8]; // B-spline weights
+    scalar_t gx[8]; // B-spline derivatives
+    scalar_t hx[8]; // B-spline 2nd derivatives
+    offset_t ix[8]; // Warped indices
+    uint8_t sx[8]; // Warped indices
+
+    {
+      scalar_t *owx = static_cast<scalar_t*>(wx), *ogx = static_cast<scalar_t*>(gx), *ohx = static_cast<scalar_t*>(hx);
+      offset_t* oix = static_cast<offset_t*>(ix);
+      uint8_t* osx = static_cast<uint8_t*>(sx);
+      for (offset_t bx = bx0; bx <= bx1; ++bx) {
+        scalar_t dx = x - bx;
+        *(owx++) = interpolation::fastweight(interpolation0, dx);
+        if (do_grad || do_sgrad)
+          *(ogx++) = interpolation::fastgrad(interpolation0, dx);
+        if (do_grad && trgt_sK > 1)
+          *(ohx++) = interpolation::fasthess(interpolation0, dx);
+        *(osx++) = bound::sign(bound0, bx, src_X);
+        *(oix++) = bound::index(bound0, bx, src_X);
+      }
+    }
+
+    // Convolve coefficients with basis functions
+    scalar_t ogx;
+    ogx = static_cast<scalar_t>(0);
+    for (offset_t i = 0; i <= dbx; ++i) {
+      offset_t oox = ix[i] * out_sX;
+      offset_t osx = ix[i] * src_sX;
+      uint8_t sxx = sx[i];
+      scalar_t wxx = wx[i];
+      scalar_t gxx = gx[i];
+      scalar_t hxx = hx[i];
+
+      // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Pull ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+      if (do_pull) {
+        scalar_t* src_ptr_NC = src_ptr_NC0;
+        scalar_t* out_ptr_NCX = out_ptr_NCX0;
+        for (offset_t c = 0; c < C; ++c, out_ptr_NCX += out_sC, src_ptr_NC += src_sC)
+          *out_ptr_NCX += bound::get(src_ptr_NC, osx, sxx) * wxx;
+      }
+
+      // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ SGrad ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+      else if (do_sgrad) {
+        scalar_t* src_ptr_NC = src_ptr_NC0;
+        scalar_t* out_ptr_NCX = out_ptr_NCX0;
+        for (offset_t c = 0; c < C; ++c, out_ptr_NCX += out_sC, src_ptr_NC += src_sC) {
+          scalar_t src = bound::get(src_ptr_NC, osx, sxx);
+          *out_ptr_NCX += src * gxx;
+        }
+      }
+
+      // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Push ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+      else if (do_push) {
+        if (trgt_K == 0) {
+          // Diff w.r.t. push/pull
+          scalar_t* out_ptr_NC = out_ptr_NC0;
+          for (offset_t c = 0; c < C; ++c, out_ptr_NC += out_sC)
+            bound::add(out_ptr_NC, oox, wxx * target[c], sxx);
+        } else {
+          // Diff w.r.t. sgrad
+          scalar_t* out_ptr_NC = out_ptr_NC0;
+          for (offset_t c = 0; c < C; ++c, out_ptr_NC += out_sC) {
+            scalar_t val = gxx * target[c];
+            bound::add(out_ptr_NC, oox, val, sxx);
+          }
+        }
+      }
+
+      // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Count ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+      else if (do_count) {
+        bound::add(out_ptr_NC0, oox, wxx, sxx);
+      }
+
+      // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Grad ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+      if (do_grad) {
+        if (trgt_K == 0) {
+          // Diff w.r.t. pull/push
+          scalar_t* src_ptr_NC = src_ptr_NC0;
+          scalar_t dot = static_cast<scalar_t>(0);
+          for (offset_t c = 0; c < C; ++c, src_ptr_NC += src_sC) {
+            scalar_t src = bound::get(src_ptr_NC, osx, sxx);
+            dot += (trgt_ptr ? src * target[c] : src);
+            // trgt_ptr == 0 in the backward pass of 'count'
+          }
+          ogx += gxx * dot;
+        } else {
+          // Diff w.r.t. sgrad
+          scalar_t* src_ptr_NC = src_ptr_NC0;
+          scalar_t dot;
+          dot = static_cast<scalar_t>(0);
+          for (offset_t c = 0; c < C; ++c, src_ptr_NC += src_sC) {
+            scalar_t src = bound::get(src_ptr_NC, osx, sxx);
+            dot += src * target[c];
+          }
+          ogx += hxx * dot;
+        }
+      }
+
+    } // x
+
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Grad ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    if (do_grad) {
+      scalar_t* grad_ptr_NX = grad_ptr + n * grad_sN + w * grad_sX;
+      (*grad_ptr_NX) = ogx;
+    }
+  }
+
+  // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+  //                     LINEAR INTERPOLATION 3D
+  // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+  template <typename scalar_t, typename offset_t>
+  MONAI_DEVICE void PushPullImpl<scalar_t, offset_t>::interpolate3d_trilinear(
+      scalar_t x,
+      scalar_t y,
+      scalar_t z,
+      offset_t w,
+      offset_t h,
+      offset_t d,
+      offset_t n) const {
+    // Get corner pixel values from (x, y, z)
+    offset_t ix0 = static_cast<offset_t>(std::floor(x));
+    offset_t iy0 = static_cast<offset_t>(std::floor(y));
+    offset_t iz0 = static_cast<offset_t>(std::floor(z));
+
+    // Interpolation weights (inversely proportional to distance)
+    scalar_t dx1 = x - ix0;
+    scalar_t dy1 = y - iy0;
+    scalar_t dz1 = z - iz0;
+    scalar_t dx0 = 1. - dx1;
+    scalar_t dy0 = 1. - dy1;
+    scalar_t dz0 = 1. - dz1;
+    scalar_t w000 = dx0 * dy0 * dz0;
+    scalar_t w100 = dx1 * dy0 * dz0;
+    scalar_t w010 = dx0 * dy1 * dz0;
+    scalar_t w001 = dx0 * dy0 * dz1;
+    scalar_t w110 = dx1 * dy1 * dz0;
+    scalar_t w011 = dx0 * dy1 * dz1;
+    scalar_t w101 = dx1 * dy0 * dz1;
+    scalar_t w111 = dx1 * dy1 * dz1;
+
+    // Sign (/!\ compute sign before warping indices)
+    int8_t sx1 = bound::sign(bound0, ix0 + 1, src_X);
+    int8_t sy1 = bound::sign(bound1, iy0 + 1, src_Y);
+    int8_t sz1 = bound::sign(bound2, iz0 + 1, src_Z);
+    int8_t sx0 = bound::sign(bound0, ix0, src_X);
+    int8_t sy0 = bound::sign(bound1, iy0, src_Y);
+    int8_t sz0 = bound::sign(bound2, iz0, src_Z);
+    int8_t s000 = sx0 * sy0 * sz0;
+    int8_t s100 = sx1 * sy0 * sz0;
+    int8_t s010 = sx0 * sy1 * sz0;
+    int8_t s001 = sx0 * sy0 * sz1;
+    int8_t s110 = sx1 * sy1 * sz0;
+    int8_t s011 = sx0 * sy1 * sz1;
+    int8_t s101 = sx1 * sy0 * sz1;
+    int8_t s111 = sx1 * sy1 * sz1;
+
+    // Warp indices
+    offset_t ix1, iy1, iz1;
+    ix1 = bound::index(bound0, ix0 + 1, src_X);
+    iy1 = bound::index(bound1, iy0 + 1, src_Y);
+    iz1 = bound::index(bound2, iz0 + 1, src_Z);
+    ix0 = bound::index(bound0, ix0, src_X);
+    iy0 = bound::index(bound1, iy0, src_Y);
+    iz0 = bound::index(bound2, iz0, src_Z);
+
+    offset_t o000, o100, o010, o001, o110, o011, o101, o111;
+
+    if (do_pull || do_grad || do_sgrad) {
+      // Offsets into source volume
+      o000 = ix0 * src_sX + iy0 * src_sY + iz0 * src_sZ;
+      o100 = ix1 * src_sX + iy0 * src_sY + iz0 * src_sZ;
+      o010 = ix0 * src_sX + iy1 * src_sY + iz0 * src_sZ;
+      o001 = ix0 * src_sX + iy0 * src_sY + iz1 * src_sZ;
+      o110 = ix1 * src_sX + iy1 * src_sY + iz0 * src_sZ;
+      o011 = ix0 * src_sX + iy1 * src_sY + iz1 * src_sZ;
+      o101 = ix1 * src_sX + iy0 * src_sY + iz1 * src_sZ;
+      o111 = ix1 * src_sX + iy1 * src_sY + iz1 * src_sZ;
+    } else if (!(do_push || do_count)) {
+      o000 = o100 = o010 = o001 = o110 = o011 = o101 = o111 = 0;
+    }
+
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~ Grid gradient ~~~~~~~~~~~~~~~~~~~~~~~~~~
+    if (do_grad) {
+      scalar_t gx = static_cast<scalar_t>(0);
+      scalar_t gy = static_cast<scalar_t>(0);
+      scalar_t gz = static_cast<scalar_t>(0);
+      scalar_t* trgt_ptr_NCXYZ = trgt_ptr + n * trgt_sN + w * trgt_sX + h * trgt_sY + d * trgt_sZ;
+      scalar_t* src_ptr_NC = src_ptr + n * src_sN;
+
+      if (trgt_K == 0) {
+        // backward w.r.t. push/pull
+        for (offset_t c = 0; c < C; ++c, trgt_ptr_NCXYZ += trgt_sC, src_ptr_NC += src_sC) {
+          scalar_t src;
+          scalar_t trgt = trgt_ptr ? *trgt_ptr_NCXYZ : static_cast<scalar_t>(1);
+          // ^ trgt_ptr == 0 during the backward pass of count
+          src = bound::get(src_ptr_NC, o000, s000);
+          if (trgt_ptr)
+            src *= trgt;
+          gx -= dy0 * dz0 * src;
+          gy -= dx0 * dz0 * src;
+          gz -= dx0 * dy0 * src;
+          src = bound::get(src_ptr_NC, o100, s100);
+          if (trgt_ptr)
+            src *= trgt;
+          gx += dy0 * dz0 * src;
+          gy -= dx1 * dz0 * src;
+          gz -= dx1 * dy0 * src;
+          src = bound::get(src_ptr_NC, o010, s010);
+          if (trgt_ptr)
+            src *= trgt;
+          gx -= dy1 * dz0 * src;
+          gy += dx0 * dz0 * src;
+          gz -= dx0 * dy1 * src;
+          src = bound::get(src_ptr_NC, o110, s110);
+          if (trgt_ptr)
+            src *= trgt;
+          gx += dy1 * dz0 * src;
+          gy += dx1 * dz0 * src;
+          gz -= dx1 * dy1 * src;
+          src = bound::get(src_ptr_NC, o001, s001);
+          if (trgt_ptr)
+            src *= trgt;
+          gx -= dy0 * dz1 * src;
+          gy -= dx0 * dz1 * src;
+          gz += dx0 * dy0 * src;
+          src = bound::get(src_ptr_NC, o101, s101);
+          if (trgt_ptr)
+            src *= trgt;
+          gx += dy0 * dz1 * src;
+          gy -= dx1 * dz1 * src;
+          gz += dx1 * dy0 * src;
+          src = bound::get(src_ptr_NC, o011, s011);
+          if (trgt_ptr)
+            src *= trgt;
+          gx -= dy1 * dz1 * src;
+          gy += dx0 * dz1 * src;
+          gz += dx0 * dy1 * src;
+          src = bound::get(src_ptr_NC, o111, s111);
+          if (trgt_ptr)
+            src *= trgt;
+          gx += dy1 * dz1 * src;
+          gy += dx1 * dz1 * src;
+          gz += dx1 * dy1 * src;
+        }
+      } else {
+        // backward w.r.t. sgrad
+        for (offset_t c = 0; c < C; ++c, trgt_ptr_NCXYZ += trgt_sC, src_ptr_NC += src_sC) {
+          scalar_t src;
+          scalar_t trgt0 = *trgt_ptr_NCXYZ, trgt1 = trgt_ptr_NCXYZ[trgt_sK], trgt2 = trgt_ptr_NCXYZ[trgt_sK * 2];
+          src = bound::get(src_ptr_NC, o000, s000);
+          gx += (dz0 * trgt1 + dy0 * trgt2) * src;
+          gy += (dz0 * trgt0 + dx0 * trgt2) * src;
+          gz += (dy0 * trgt0 + dx0 * trgt1) * src;
+          src = bound::get(src_ptr_NC, o100, s100);
+          gx += (-dz0 * trgt1 - dy0 * trgt2) * src;
+          gy += (-dz0 * trgt0 + dx1 * trgt2) * src;
+          gz += (-dy0 * trgt0 + dx1 * trgt1) * src;
+          src = bound::get(src_ptr_NC, o010, s010);
+          gx += (-dz0 * trgt1 + dy1 * trgt2) * src;
+          gy += (-dz0 * trgt0 - dx0 * trgt2) * src;
+          gz += (dy1 * trgt0 - dx0 * trgt1) * src;
+          src = bound::get(src_ptr_NC, o110, s110);
+          gx += (dz0 * trgt1 - dy1 * trgt2) * src;
+          gy += (dz0 * trgt0 - dx1 * trgt2) * src;
+          gz += (-dy1 * trgt0 - dx1 * trgt1) * src;
+          src = bound::get(src_ptr_NC, o001, s001);
+          gx += (dz1 * trgt1 - dy0 * trgt2) * src;
+          gy += (dz1 * trgt0 - dx0 * trgt2) * src;
+          gz += (-dy0 * trgt0 - dx0 * trgt1) * src;
+          src = bound::get(src_ptr_NC, o101, s101);
+          gx += (-dz1 * trgt1 + dy0 * trgt2) * src;
+          gy += (-dz1 * trgt0 - dx1 * trgt2) * src;
+          gz += (dy0 * trgt0 - dx1 * trgt1) * src;
+          src = bound::get(src_ptr_NC, o011, s011);
+          gx += (-dz1 * trgt1 - dy1 * trgt2) * src;
+          gy += (-dz1 * trgt0 + dx0 * trgt2) * src;
+          gz += (-dy1 * trgt0 + dx0 * trgt1) * src;
+          src = bound::get(src_ptr_NC, o111, s111);
+          gx += (dz1 * trgt1 + dy1 * trgt2) * src;
+          gy += (dz1 * trgt0 + dx1 * trgt2) * src;
+          gz += (dy1 * trgt0 + dx1 * trgt1) * src;
+        }
+      }
+
+      scalar_t* grad_ptr_NXYZ = grad_ptr + n * grad_sN + w * grad_sX + h * grad_sY + d * grad_sZ;
+      (*grad_ptr_NXYZ) = gx;
+      grad_ptr_NXYZ[grad_sC] = gy;
+      grad_ptr_NXYZ[grad_sC * 2] = gz;
+    }
+    if (do_push || do_count) {
+      // Offsets into 'push' volume
+      o000 = ix0 * out_sX + iy0 * out_sY + iz0 * out_sZ;
+      o100 = ix1 * out_sX + iy0 * out_sY + iz0 * out_sZ;
+      o010 = ix0 * out_sX + iy1 * out_sY + iz0 * out_sZ;
+      o001 = ix0 * out_sX + iy0 * out_sY + iz1 * out_sZ;
+      o110 = ix1 * out_sX + iy1 * out_sY + iz0 * out_sZ;
+      o011 = ix0 * out_sX + iy1 * out_sY + iz1 * out_sZ;
+      o101 = ix1 * out_sX + iy0 * out_sY + iz1 * out_sZ;
+      o111 = ix1 * out_sX + iy1 * out_sY + iz1 * out_sZ;
+    }
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Pull ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    if (do_pull) {
+      scalar_t* out_ptr_NCXYZ = out_ptr + n * out_sN + w * out_sX + h * out_sY + d * out_sZ;
+      scalar_t* src_ptr_NC = src_ptr + n * src_sN;
+      for (offset_t c = 0; c < C; ++c, out_ptr_NCXYZ += out_sC, src_ptr_NC += src_sC) {
+        *out_ptr_NCXYZ = bound::get(src_ptr_NC, o000, s000) * w000 + bound::get(src_ptr_NC, o100, s100) * w100 +
+            bound::get(src_ptr_NC, o010, s010) * w010 + bound::get(src_ptr_NC, o110, s110) * w110 +
+            bound::get(src_ptr_NC, o001, s001) * w001 + bound::get(src_ptr_NC, o101, s101) * w101 +
+            bound::get(src_ptr_NC, o011, s011) * w011 + bound::get(src_ptr_NC, o111, s111) * w111;
+      }
+    }
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ SGrad ~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~
+    else if (do_sgrad) {
+      scalar_t* out_ptr_NCXYZ = out_ptr + n * out_sN + w * out_sX + h * out_sY + d * out_sZ;
+      scalar_t* src_ptr_NC = src_ptr + n * src_sN;
+
+      for (offset_t c = 0; c < C; ++c, out_ptr_NCXYZ += out_sC, src_ptr_NC += src_sC) {
+        scalar_t src000 = bound::get(src_ptr_NC, o000, s000);
+        scalar_t src100 = bound::get(src_ptr_NC, o100, s100);
+        scalar_t src010 = bound::get(src_ptr_NC, o010, s010);
+        scalar_t src110 = bound::get(src_ptr_NC, o110, s110);
+        scalar_t src001 = bound::get(src_ptr_NC, o001, s001);
+        scalar_t src101 = bound::get(src_ptr_NC, o101, s101);
+        scalar_t src011 = bound::get(src_ptr_NC, o011, s011);
+        scalar_t src111 = bound::get(src_ptr_NC, o111, s111);
+        *out_ptr_NCXYZ = -dy0 * dz0 * src000 + dy0 * dz0 * src100 - dy1 * dz0 * src010 + dy1 * dz0 * src110 -
+            dy0 * dz1 * src001 + dy0 * dz1 * src101 - dy1 * dz1 * src011 + dy1 * dz1 * src111;
+        out_ptr_NCXYZ[out_sK] = -dx0 * dz0 * src000 - dx1 * dz0 * src100 + dx0 * dz0 * src010 + dx1 * dz0 * src110 -
+            dx0 * dz1 * src001 - dx1 * dz1 * src101 + dx0 * dz1 * src011 + dx1 * dz1 * src111;
+        out_ptr_NCXYZ[out_sK * 2] = -dx0 * dy0 * src000 - dx1 * dy0 * src100 - dx0 * dy1 * src010 - dx1 * dy1 * src110 +
+            dx0 * dy0 * src001 + dx1 * dy0 * src101 + dx0 * dy1 * src011 + dx1 * dy1 * src111;
+      }
+    }
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Push ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    else if (do_push) {
+      scalar_t* trgt_ptr_NCXYZ = trgt_ptr + n * trgt_sN + w * trgt_sX + h * trgt_sY + d * trgt_sZ;
+      scalar_t* out_ptr_NC = out_ptr + n * out_sN;
+      if (trgt_K == 0) {
+        // Diff w.r.t. push/pull
+        for (offset_t c = 0; c < C; ++c, trgt_ptr_NCXYZ += trgt_sC, out_ptr_NC += out_sC) {
+          scalar_t trgt = *trgt_ptr_NCXYZ;
+          bound::add(out_ptr_NC, o000, w000 * trgt, s000);
+          bound::add(out_ptr_NC, o100, w100 * trgt, s100);
+          bound::add(out_ptr_NC, o010, w010 * trgt, s010);
+          bound::add(out_ptr_NC, o110, w110 * trgt, s110);
+          bound::add(out_ptr_NC, o001, w001 * trgt, s001);
+          bound::add(out_ptr_NC, o101, w101 * trgt, s101);
+          bound::add(out_ptr_NC, o011, w011 * trgt, s011);
+          bound::add(out_ptr_NC, o111, w111 * trgt, s111);
+        }
+      } else {
+        // Diff w.r.t. sgrad
+        scalar_t val;
+        for (offset_t c = 0; c < C; ++c, trgt_ptr_NCXYZ += trgt_sC, out_ptr_NC += out_sC) {
+          scalar_t trgt0 = *trgt_ptr_NCXYZ, trgt1 = trgt_ptr_NCXYZ[trgt_sK], trgt2 = trgt_ptr_NCXYZ[trgt_sK * 2];
+          val = -dy0 * dz0 * trgt0 - dx0 * dz0 * trgt1 - dx0 * dy0 * trgt2;
+          bound::add(out_ptr_NC, o000, val, s000);
+          val = dy0 * dz0 * trgt0 - dx1 * dz0 * trgt1 - dx1 * dy0 * trgt2;
+          bound::add(out_ptr_NC, o100, val, s100);
+          val = -dy1 * dz0 * trgt0 + dx0 * dz0 * trgt1 - dx0 * dy1 * trgt2;
+          bound::add(out_ptr_NC, o010, val, s010);
+          val = dy1 * dz0 * trgt0 + dx1 * dz0 * trgt1 - dx1 * dy1 * trgt2;
+          bound::add(out_ptr_NC, o110, val, s110);
+          val = -dy0 * dz1 * trgt0 - dx0 * dz1 * trgt1 + dx0 * dy0 * trgt2;
+          bound::add(out_ptr_NC, o001, val, s001);
+          val = dy0 * dz1 * trgt0 - dx1 * dz1 * trgt1 + dx1 * dy0 * trgt2;
+          bound::add(out_ptr_NC, o101, val, s101);
+          val = -dy1 * dz1 * trgt0 + dx0 * dz1 * trgt1 + dx0 * dy1 * trgt2;
+          bound::add(out_ptr_NC, o011, val, s011);
+          val = dy1 * dz1 * trgt0 + dx1 * dz1 * trgt1 + dx1 * dy1 * trgt2;
+          bound::add(out_ptr_NC, o111, val, s111);
+        }
+      }
+    }
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Push ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    else if (do_count) {
+      scalar_t* out_ptr_N = out_ptr + n * out_sN;
+      bound::add(out_ptr_N, o000, w000, s000);
+      bound::add(out_ptr_N, o100, w100, s100);
+      bound::add(out_ptr_N, o010, w010, s010);
+      bound::add(out_ptr_N, o110, w110, s110);
+      bound::add(out_ptr_N, o001, w001, s001);
+      bound::add(out_ptr_N, o101, w101, s101);
+      bound::add(out_ptr_N, o011, w011, s011);
+      bound::add(out_ptr_N, o111, w111, s111);
+    }
+  }
+
+  // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+  //                     LINEAR INTERPOLATION 2D
+  // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+  template <typename scalar_t, typename offset_t>
+  MONAI_DEVICE void PushPullImpl<scalar_t, offset_t>::interpolate2d_bilinear(
+      scalar_t x,
+      scalar_t y,
+      offset_t w,
+      offset_t h,
+      offset_t n) const {
+    // Get corner pixel values from (x, y, z)
+    offset_t ix0 = static_cast<offset_t>(std::floor(x));
+    offset_t iy0 = static_cast<offset_t>(std::floor(y));
+
+    // Interpolation weights (inversely proportional to distance)
+    scalar_t dx1 = x - ix0;
+    scalar_t dy1 = y - iy0;
+    scalar_t dx0 = 1. - dx1;
+    scalar_t dy0 = 1. - dy1;
+    scalar_t w00 = dx0 * dy0;
+    scalar_t w10 = dx1 * dy0;
+    scalar_t w01 = dx0 * dy1;
+    scalar_t w11 = dx1 * dy1;
+
+    // Sign (/!\ compute sign before warping indices)
+    int8_t sx1 = bound::sign(bound0, ix0 + 1, src_X);
+    int8_t sy1 = bound::sign(bound1, iy0 + 1, src_Y);
+    int8_t sx0 = bound::sign(bound0, ix0, src_X);
+    int8_t sy0 = bound::sign(bound1, iy0, src_Y);
+    int8_t s00 = sx0 * sy0;
+    int8_t s10 = sx1 * sy0;
+    int8_t s01 = sx0 * sy1;
+    int8_t s11 = sx1 * sy1;
+
+    // Warp indices
+    offset_t ix1, iy1;
+    ix1 = bound::index(bound0, ix0 + 1, src_X);
+    iy1 = bound::index(bound1, iy0 + 1, src_Y);
+    ix0 = bound::index(bound0, ix0, src_X);
+    iy0 = bound::index(bound1, iy0, src_Y);
+
+    offset_t o00, o10, o01, o11;
+    if (do_pull || do_grad || do_sgrad) {
+      // Offsets into source volume
+      o00 = ix0 * src_sX + iy0 * src_sY;
+      o10 = ix1 * src_sX + iy0 * src_sY;
+      o01 = ix0 * src_sX + iy1 * src_sY;
+      o11 = ix1 * src_sX + iy1 * src_sY;
+    } else if (!(do_push || do_count)) {
+      o00 = o10 = o01 = o11 = 0;
+    }
+
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~ Grid gradient ~~~~~~~~~~~~~~~~~~~~~~~~~~
+    if (do_grad) {
+      scalar_t gx = static_cast<scalar_t>(0);
+      scalar_t gy = static_cast<scalar_t>(0);
+      scalar_t* trgt_ptr_NCXY = trgt_ptr + n * trgt_sN + w * trgt_sX + h * trgt_sY;
+      scalar_t* src_ptr_NC = src_ptr + n * src_sN;
+
+      if (trgt_K == 0) {
+        // backward w.r.t. push/pull
+        for (offset_t c = 0; c < C; ++c, trgt_ptr_NCXY += trgt_sC, src_ptr_NC += src_sC) {
+          scalar_t src;
+          scalar_t trgt = trgt_ptr ? *trgt_ptr_NCXY : static_cast<scalar_t>(1);
+          // ^ trgt_ptr == 0 during the backward pass of count
+          src = bound::get(src_ptr_NC, o00, s00);
+          if (trgt_ptr)
+            src *= trgt;
+          gx -= dy0 * src;
+          gy -= dx0 * src;
+          src = bound::get(src_ptr_NC, o10, s10);
+          if (trgt_ptr)
+            src *= trgt;
+          gx += dy0 * src;
+          gy -= dx1 * src;
+          src = bound::get(src_ptr_NC, o01, s01);
+          if (trgt_ptr)
+            src *= trgt;
+          gx -= dy1 * src;
+          gy += dx0 * src;
+          src = bound::get(src_ptr_NC, o11, s11);
+          if (trgt_ptr)
+            src *= trgt;
+          gx += dy1 * src;
+          gy += dx1 * src;
+        }
+      } else {
+        // backward w.r.t. sgrad
+        for (offset_t c = 0; c < C; ++c, trgt_ptr_NCXY += trgt_sC, src_ptr_NC += src_sC) {
+          scalar_t src;
+          scalar_t trgt0 = *trgt_ptr_NCXY, trgt1 = trgt_ptr_NCXY[trgt_sK];
+          src = bound::get(src_ptr_NC, o00, s00);
+          gx += trgt1 * src;
+          gy += trgt0 * src;
+          src = bound::get(src_ptr_NC, o10, s10);
+          gx -= trgt1 * src;
+          gy -= trgt0 * src;
+          src = bound::get(src_ptr_NC, o01, s01);
+          gx -= trgt1 * src;
+          gy -= trgt0 * src;
+          src = bound::get(src_ptr_NC, o11, s11);
+          gx += trgt1 * src;
+          gy += trgt0 * src;
+        }
+      }
+
+      scalar_t* grad_ptr_NXY = grad_ptr + n * grad_sN + w * grad_sX + h * grad_sY;
+      (*grad_ptr_NXY) = gx;
+      grad_ptr_NXY[grad_sC] = gy;
+    }
+    if (do_push || do_count) {
+      // Offsets into 'push' volume
+      o00 = ix0 * out_sX + iy0 * out_sY;
+      o10 = ix1 * out_sX + iy0 * out_sY;
+      o01 = ix0 * out_sX + iy1 * out_sY;
+      o11 = ix1 * out_sX + iy1 * out_sY;
+    }
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Pull ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    if (do_pull) {
+      scalar_t* out_ptr_NCXY = out_ptr + n * out_sN + w * out_sX + h * out_sY;
+      scalar_t* src_ptr_NC = src_ptr + n * src_sN;
+      for (offset_t c = 0; c < C; ++c, out_ptr_NCXY += out_sC, src_ptr_NC += src_sC) {
+        *out_ptr_NCXY = bound::get(src_ptr_NC, o00, s00) * w00 + bound::get(src_ptr_NC, o10, s10) * w10 +
+            bound::get(src_ptr_NC, o01, s01) * w01 + bound::get(src_ptr_NC, o11, s11) * w11;
+      }
+    }
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ SGrad ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    else if (do_sgrad) {
+      scalar_t* out_ptr_NCXY = out_ptr + n * out_sN + w * out_sX + h * out_sY;
+      scalar_t* src_ptr_NC = src_ptr + n * src_sN;
+
+      for (offset_t c = 0; c < C; ++c, out_ptr_NCXY += out_sC, src_ptr_NC += src_sC) {
+        scalar_t src00 = bound::get(src_ptr_NC, o00, s00);
+        scalar_t src10 = bound::get(src_ptr_NC, o10, s10);
+        scalar_t src01 = bound::get(src_ptr_NC, o01, s01);
+        scalar_t src11 = bound::get(src_ptr_NC, o11, s11);
+        *out_ptr_NCXY = -dy0 * src00 + dy0 * src10 - dy1 * src01 + dy1 * src11;
+        out_ptr_NCXY[out_sK] = -dx0 * src00 - dx1 * src10 + dx0 * src01 + dx1 * src11;
+      }
+    }
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Push ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    else if (do_push) {
+      scalar_t* trgt_ptr_NCXY = trgt_ptr + n * trgt_sN + w * trgt_sX + h * trgt_sY;
+      scalar_t* out_ptr_NC = out_ptr + n * out_sN;
+      if (trgt_K == 0) {
+        // Diff w.r.t. push/pull
+        for (offset_t c = 0; c < C; ++c, trgt_ptr_NCXY += trgt_sC, out_ptr_NC += out_sC) {
+          scalar_t trgt = *trgt_ptr_NCXY;
+          bound::add(out_ptr_NC, o00, w00 * trgt, s00);
+          bound::add(out_ptr_NC, o10, w10 * trgt, s10);
+          bound::add(out_ptr_NC, o01, w01 * trgt, s01);
+          bound::add(out_ptr_NC, o11, w11 * trgt, s11);
+        }
+      } else {
+        // Diff w.r.t. sgrad
+        scalar_t val;
+        for (offset_t c = 0; c < C; ++c, trgt_ptr_NCXY += trgt_sC, out_ptr_NC += out_sC) {
+          scalar_t trgt0 = *trgt_ptr_NCXY, trgt1 = trgt_ptr_NCXY[trgt_sK];
+          val = -dy0 * trgt0 - dx0 * trgt1;
+          bound::add(out_ptr_NC, o00, val, s00);
+          val = dy0 * trgt0 - dx1 * trgt1;
+          bound::add(out_ptr_NC, o10, val, s10);
+          val = -dy1 * trgt0 + dx0 * trgt1;
+          bound::add(out_ptr_NC, o01, val, s01);
+          val = dy1 * trgt0 + dx1 * trgt1;
+          bound::add(out_ptr_NC, o11, val, s11);
+        }
+      }
+    }
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Push ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    else if (do_count) {
+      scalar_t* out_ptr_N = out_ptr + n * out_sN;
+      bound::add(out_ptr_N, o00, w00, s00);
+      bound::add(out_ptr_N, o10, w10, s10);
+      bound::add(out_ptr_N, o01, w01, s01);
+      bound::add(out_ptr_N, o11, w11, s11);
+    }
+  }
+
+  // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+  //                     LINEAR INTERPOLATION 1D
+  // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+  template <typename scalar_t, typename offset_t>
+  MONAI_DEVICE void PushPullImpl<scalar_t, offset_t>::interpolate1d_linear(scalar_t x, offset_t w, offset_t n) const {
+    // Get corner pixel values from (x)
+    offset_t ix0 = static_cast<offset_t>(std::floor(x));
+
+    // Interpolation weights (inversely proportional to distance)
+    scalar_t w1 = x - ix0;
+    scalar_t w0 = 1. - w1;
+
+    // Sign (/!\ compute sign before warping indices)
+    int8_t s1 = bound::sign(bound0, ix0 + 1, src_X);
+    int8_t s0 = bound::sign(bound0, ix0, src_X);
+
+    // Warp indices
+    offset_t ix1;
+    ix1 = bound::index(bound0, ix0 + 1, src_X);
+    ix0 = bound::index(bound0, ix0, src_X);
+
+    // Offsets into source volume
+    offset_t o0, o1;
+    if (do_pull || do_grad || do_sgrad) {
+      o0 = ix0 * src_sX;
+      o1 = ix1 * src_sX;
+    } else if (!(do_push || do_count)) {
+      o0 = o1 = 0;
+    }
+
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~ Grid gradient ~~~~~~~~~~~~~~~~~~~~~~~~~~
+    if (do_grad) {
+      if (trgt_K == 0) {
+        // backward w.r.t. push/pull
+        scalar_t gx = static_cast<scalar_t>(0);
+        scalar_t* trgt_ptr_NCX = trgt_ptr + n * trgt_sN + w * trgt_sX;
+        scalar_t* src_ptr_NC = src_ptr + n * src_sN;
+
+        for (offset_t c = 0; c < C; ++c, trgt_ptr_NCX += trgt_sC, src_ptr_NC += src_sC) {
+          scalar_t src;
+          scalar_t trgt = trgt_ptr ? *trgt_ptr_NCX : static_cast<scalar_t>(1);
+          // ^ trgt_ptr == 0 during the backward pass of count
+          src = bound::get(src_ptr_NC, o0, s0);
+          if (trgt_ptr)
+            src *= trgt;
+          gx -= src;
+          src = bound::get(src_ptr_NC, o1, s1);
+          if (trgt_ptr)
+            src *= trgt;
+          gx += src;
+        }
+
+        scalar_t* grad_ptr_NX = grad_ptr + n * grad_sN + w * grad_sX;
+        (*grad_ptr_NX) = gx;
+      } else {
+        // backward w.r.t. sgrad
+        // -> zero (make sure this is done at initialization)
+      }
+    }
+    if (do_push || do_count) {
+      // Offsets into 'push' volume
+      o0 = ix0 * out_sX;
+      o1 = ix1 * out_sX;
+    }
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Pull ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    if (do_pull) {
+      scalar_t* out_ptr_NCX = out_ptr + n * out_sN + w * out_sX;
+      scalar_t* src_ptr_NC = src_ptr + n * src_sN;
+      for (offset_t c = 0; c < C; ++c, out_ptr_NCX += out_sC, src_ptr_NC += src_sC) {
+        *out_ptr_NCX = bound::get(src_ptr_NC, o0, s0) * w0 + bound::get(src_ptr_NC, o1, s1) * w1;
+      }
+    }
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ SGrad ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    else if (do_sgrad) {
+      scalar_t* out_ptr_NCX = out_ptr + n * out_sN + w * out_sX;
+      scalar_t* src_ptr_NC = src_ptr + n * src_sN;
+
+      for (offset_t c = 0; c < C; ++c, out_ptr_NCX += out_sC, src_ptr_NC += src_sC) {
+        *out_ptr_NCX = bound::get(src_ptr_NC, o1, s1) - bound::get(src_ptr_NC, o0, s0);
+      }
+    }
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Push ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    else if (do_push) {
+      scalar_t* trgt_ptr_NCX = trgt_ptr + n * trgt_sN + w * trgt_sX;
+      scalar_t* out_ptr_NC = out_ptr + n * out_sN;
+      if (trgt_K == 0) {
+        // Diff w.r.t. push/pull
+        for (offset_t c = 0; c < C; ++c, trgt_ptr_NCX += trgt_sC, out_ptr_NC += out_sC) {
+          scalar_t trgt = *trgt_ptr_NCX;
+          bound::add(out_ptr_NC, o0, w0 * trgt, s0);
+          bound::add(out_ptr_NC, o1, w1 * trgt, s1);
+        }
+      } else {
+        // Diff w.r.t. sgrad
+        for (offset_t c = 0; c < C; ++c, trgt_ptr_NCX += trgt_sC, out_ptr_NC += out_sC) {
+          scalar_t trgt0 = *trgt_ptr_NCX;
+          bound::add(out_ptr_NC, o0, -trgt0, s0);
+          bound::add(out_ptr_NC, o1, trgt0, s1);
+        }
+      }
+    }
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Push ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    else if (do_count) {
+      scalar_t* out_ptr_N = out_ptr + n * out_sN;
+      bound::add(out_ptr_N, o0, w0, s0);
+      bound::add(out_ptr_N, o1, w1, s1);
+    }
+  }
+
+  // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+  //                  NEAREST NEIGHBOR INTERPOLATION 3D
+  // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+  template <typename scalar_t, typename offset_t>
+  MONAI_DEVICE void PushPullImpl<scalar_t, offset_t>::interpolate3d_nearest(
+      scalar_t x,
+      scalar_t y,
+      scalar_t z,
+      offset_t w,
+      offset_t h,
+      offset_t d,
+      offset_t n) const {
+    offset_t ix = static_cast<offset_t>(std::round(x));
+    offset_t iy = static_cast<offset_t>(std::round(y));
+    offset_t iz = static_cast<offset_t>(std::round(z));
+
+    // Boundary condition (/!\ compute sign before warping indices)
+    int8_t sx = bound::sign(bound0, ix, src_X);
+    int8_t sy = bound::sign(bound1, iy, src_Y);
+    int8_t sz = bound::sign(bound2, iz, src_Z);
+    ix = bound::index(bound0, ix, src_X);
+    iy = bound::index(bound1, iy, src_Y);
+    iz = bound::index(bound2, iz, src_Z);
+
+    // Sign
+    int8_t s = sz * sy * sx;
+
+    if (do_pull) {
+      offset_t o = iz * src_sZ + iy * src_sY + ix * src_sX;
+      scalar_t* out_ptr_NCXYZ = out_ptr + n * out_sN + w * out_sX + h * out_sY + d * out_sZ;
+      scalar_t* src_ptr_NC = src_ptr + n * src_sN;
+      for (offset_t c = 0; c < C; ++c, out_ptr_NCXYZ += out_sC, src_ptr_NC += src_sC)
+        *out_ptr_NCXYZ = bound::get(src_ptr_NC, o, s);
+    } else if (do_push && trgt_K == 0) {
+      offset_t o = iz * out_sZ + iy * out_sY + ix * out_sX;
+      scalar_t* trgt_ptr_NCXYZ = trgt_ptr + n * trgt_sN + w * trgt_sX + h * trgt_sY + d * trgt_sZ;
+      scalar_t* out_ptr_NC = out_ptr + n * out_sN;
+      for (offset_t c = 0; c < C; ++c, trgt_ptr_NCXYZ += trgt_sC, out_ptr_NC += out_sC)
+        bound::add(out_ptr_NC, o, *trgt_ptr_NCXYZ, s);
+    } else if (do_count) {
+      offset_t o = iz * out_sZ + iy * out_sY + ix * out_sX;
+      scalar_t* out_ptr_NC = out_ptr + n * out_sN;
+      for (offset_t c = 0; c < C; ++c, out_ptr_NC += out_sC)
+        bound::add(out_ptr_NC, o, static_cast<scalar_t>(1), s);
+    }
+  }
+
+  // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+  //                  NEAREST NEIGHBOR INTERPOLATION 2D
+  // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+  template <typename scalar_t, typename offset_t>
+  MONAI_DEVICE void PushPullImpl<scalar_t, offset_t>::interpolate2d_nearest(
+      scalar_t x,
+      scalar_t y,
+      offset_t w,
+      offset_t h,
+      offset_t n) const {
+    offset_t ix = static_cast<offset_t>(std::round(x));
+    offset_t iy = static_cast<offset_t>(std::round(y));
+
+    // Boundary condition (/!\ compute sign before warping indices)
+    int8_t sx = bound::sign(bound0, ix, src_X);
+    int8_t sy = bound::sign(bound1, iy, src_Y);
+    ix = bound::index(bound0, ix, src_X);
+    iy = bound::index(bound1, iy, src_Y);
+
+    // Sign
+    int8_t s = sy * sx;
+
+    if (do_pull) {
+      offset_t o = iy * src_sY + ix * src_sX;
+      scalar_t* out_ptr_NCXY = out_ptr + n * out_sN + w * out_sX + h * out_sY;
+      scalar_t* src_ptr_NC = src_ptr + n * src_sN;
+      for (offset_t c = 0; c < C; ++c, out_ptr_NCXY += out_sC, src_ptr_NC += src_sC)
+        *out_ptr_NCXY = bound::get(src_ptr_NC, o, s);
+    } else if (do_push && trgt_K == 0) {
+      offset_t o = iy * out_sY + ix * out_sX;
+      scalar_t* trgt_ptr_NCXY = trgt_ptr + n * trgt_sN + w * trgt_sX + h * trgt_sY;
+      scalar_t* out_ptr_NC = out_ptr + n * out_sN;
+      for (offset_t c = 0; c < C; ++c, trgt_ptr_NCXY += trgt_sC, out_ptr_NC += out_sC)
+        bound::add(out_ptr_NC, o, *trgt_ptr_NCXY, s);
+    } else if (do_count) {
+      offset_t o = iy * out_sY + ix * out_sX;
+      scalar_t* out_ptr_NC = out_ptr + n * out_sN;
+      for (offset_t c = 0; c < C; ++c, out_ptr_NC += out_sC)
+        bound::add(out_ptr_NC, o, static_cast<scalar_t>(1), s);
+    }
+  }
+
+  // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+  //                  NEAREST NEIGHBOR INTERPOLATION 1D
+  // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+  template <typename scalar_t, typename offset_t>
+  MONAI_DEVICE void PushPullImpl<scalar_t, offset_t>::interpolate1d_nearest(scalar_t x, offset_t w, offset_t n) const {
+    offset_t i = static_cast<offset_t>(std::round(x));
+
+    // Boundary condition (/!\ compute sign before warping indices)
+    int8_t s = bound::sign(bound0, i, src_X);
+    i = bound::index(bound0, i, src_X);
+
+    if (do_pull) {
+      offset_t o = i * src_sX;
+      scalar_t* out_ptr_NCX = out_ptr + n * out_sN + w * out_sX;
+      scalar_t* src_ptr_NC = src_ptr + n * src_sN;
+      for (offset_t c = 0; c < C; ++c, out_ptr_NCX += out_sC, src_ptr_NC += src_sC)
+        *out_ptr_NCX = bound::get(src_ptr_NC, o, s);
+    } else if (do_push && trgt_K == 0) {
+      offset_t o = i * out_sX;
+      scalar_t* trgt_ptr_NCX = trgt_ptr + n * trgt_sN + w * trgt_sX;
+      scalar_t* out_ptr_NC = out_ptr + n * out_sN;
+      for (offset_t c = 0; c < C; ++c, trgt_ptr_NCX += trgt_sC, out_ptr_NC += out_sC)
+        bound::add(out_ptr_NC, o, *trgt_ptr_NCX, s);
+    } else if (do_count) {
+      offset_t o = i * out_sX;
+      scalar_t* out_ptr_NC = out_ptr + n * out_sN;
+      for (offset_t c = 0; c < C; ++c, out_ptr_NC += out_sC)
+        bound::add(out_ptr_NC, o, static_cast<scalar_t>(1), s);
+    }
+  }
+
+  // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+  //            LINEAR INTERPOLATION 3D + SLIDING BOUNDARY
+  // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+  // TODO
+
+  // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+  //                  CUDA KERNEL (MUST BE OUT OF CLASS)
+  // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+  // CUDA Kernel
+  template <typename scalar_t, typename offset_t>
+  C10_LAUNCH_BOUNDS_1(1024)
+  __global__ void pushpull_kernel(PushPullImpl<scalar_t, offset_t> f) {
+    f.loop(threadIdx.x, blockIdx.x, blockDim.x, gridDim.x);
+  }
+
+  } // namespace
+
+  // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+  //                    FUNCTIONAL FORM WITH DISPATCH
+  // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+#define PUSHPULL_INSTANTIATE3(BoundType0, InterpolationType0, SourceType0) \
+  template std::deque<Tensor> pushpull(                                    \
+      const SourceType0&,                                                  \
+      const Tensor&,                                                       \
+      const Tensor&,                                                       \
+      BoundType0,                                                          \
+      InterpolationType0,                                                  \
+      bool,                                                                \
+      bool,                                                                \
+      bool,                                                                \
+      bool,                                                                \
+      bool,                                                                \
+      bool);                                                               \
+  template std::deque<Tensor> pushpull(                                    \
+      const SourceType0&, const Tensor&, BoundType0, InterpolationType0, bool, bool, bool, bool, bool, bool)
+#define PUSHPULL_INSTANTIATE2(BoundType0, InterpolationType0)         \
+  PUSHPULL_INSTANTIATE3(BoundType0, InterpolationType0, IntArrayRef); \
+  PUSHPULL_INSTANTIATE3(BoundType0, InterpolationType0, Tensor)
+#define PUSHPULL_INSTANTIATE1(BoundType0)               \
+  PUSHPULL_INSTANTIATE2(BoundType0, InterpolationType); \
+  PUSHPULL_INSTANTIATE2(BoundType0, InterpolationVectorRef)
+#define PUSHPULL_INSTANTIATE        \
+  PUSHPULL_INSTANTIATE1(BoundType); \
+  PUSHPULL_INSTANTIATE1(BoundVectorRef)
+
+  // Two arguments (source, grid)
+  // > `bound` and `interpolation` can be single arguments or vectors.
+  template <typename BoundType, typename InterpolationType, typename SourceType>
+  MONAI_HOST std::deque<Tensor> pushpull(
+      const SourceType& source,
+      const Tensor& grid,
+      BoundType bound,
+      InterpolationType interpolation,
+      bool extrapolate,
+      bool do_pull,
+      bool do_push,
+      bool do_count,
+      bool do_grad,
+      bool do_sgrad) {
+    PushPullAllocator info(
+        grid.dim() - 2, bound, interpolation, extrapolate, do_pull, do_push, do_count, do_grad, do_sgrad);
+    info.ioset(source, grid);
+
+    return AT_DISPATCH_FLOATING_TYPES_AND_HALF(grid.scalar_type(), "pushpull", [&] {
+      if (info.canUse32BitIndexMath()) {
+        PushPullImpl<scalar_t, int32_t> algo(info);
+        pushpull_kernel<<<GET_BLOCKS(algo.voxcount()), CUDA_NUM_THREADS, 0, at::cuda::getCurrentCUDAStream()>>>(algo);
+        return algo.output;
+      } else {
+        PushPullImpl<scalar_t, int64_t> algo(info);
+        pushpull_kernel<<<GET_BLOCKS(algo.voxcount()), CUDA_NUM_THREADS, 0, at::cuda::getCurrentCUDAStream()>>>(algo);
+        return algo.output;
+      }
+    });
+  }
+
+  // Three arguments (source, grid, target)
+  // > `bound` and `interpolation` can be single arguments or vectors.
+  // > `source` can be a tensor or a vector of dimensions.
+  template <typename BoundType, typename InterpolationType, typename SourceType>
+  MONAI_HOST std::deque<Tensor> pushpull(
+      const SourceType& source,
+      const Tensor& grid,
+      const Tensor& target,
+      BoundType bound,
+      InterpolationType interpolation,
+      bool extrapolate,
+      bool do_pull,
+      bool do_push,
+      bool do_count,
+      bool do_grad,
+      bool do_sgrad) {
+    PushPullAllocator info(
+        grid.dim() - 2, bound, interpolation, extrapolate, do_pull, do_push, do_count, do_grad, do_sgrad);
+    info.ioset(source, grid, target);
+
+    return AT_DISPATCH_FLOATING_TYPES_AND_HALF(grid.scalar_type(), "pushpull", [&] {
+      if (info.canUse32BitIndexMath()) {
+        PushPullImpl<scalar_t, int32_t> algo(info);
+        pushpull_kernel<<<GET_BLOCKS(algo.voxcount()), CUDA_NUM_THREADS, 0, at::cuda::getCurrentCUDAStream()>>>(algo);
+        return algo.output;
+      } else {
+        PushPullImpl<scalar_t, int64_t> algo(info);
+        pushpull_kernel<<<GET_BLOCKS(algo.voxcount()), CUDA_NUM_THREADS, 0, at::cuda::getCurrentCUDAStream()>>>(algo);
+        return algo.output;
+      }
+    });
+  }
+
+  PUSHPULL_INSTANTIATE;
+
+} // namespace gpu
+} // namespace monai

source_code/SegMamba/monai/csrc/utils/meta_macros.h

@@ -0,0 +1,131 @@
+/*
+Copyright (c) MONAI Consortium
+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.
+*/
+
+#pragma once
+
+// Helper Macros: for internal use (see below)
+#define _DO_1(TARGET) TARGET(1)
+#define _DO_2(TARGET) TARGET(2) _DO_1(TARGET)
+#define _DO_3(TARGET) TARGET(3) _DO_2(TARGET)
+#define _DO_4(TARGET) TARGET(4) _DO_3(TARGET)
+#define _DO_5(TARGET) TARGET(5) _DO_4(TARGET)
+#define _DO_6(TARGET) TARGET(6) _DO_5(TARGET)
+#define _DO_7(TARGET) TARGET(7) _DO_6(TARGET)
+#define _DO_8(TARGET) TARGET(8) _DO_7(TARGET)
+#define _DO_9(TARGET) TARGET(9) _DO_8(TARGET)
+#define _DO_10(TARGET) TARGET(10) _DO_9(TARGET)
+#define _DO_11(TARGET) TARGET(11) _DO_10(TARGET)
+#define _DO_12(TARGET) TARGET(12) _DO_11(TARGET)
+#define _DO_13(TARGET) TARGET(13) _DO_12(TARGET)
+#define _DO_14(TARGET) TARGET(14) _DO_13(TARGET)
+#define _DO_15(TARGET) TARGET(15) _DO_14(TARGET)
+#define _DO_16(TARGET) TARGET(16) _DO_15(TARGET)
+#define _DO_17(TARGET) TARGET(17) _DO_16(TARGET)
+#define _DO_18(TARGET) TARGET(18) _DO_17(TARGET)
+#define _DO_19(TARGET) TARGET(19) _DO_18(TARGET)
+#define _DO_20(TARGET) TARGET(20) _DO_19(TARGET)
+#define _DO_21(TARGET) TARGET(21) _DO_20(TARGET)
+#define _DO_22(TARGET) TARGET(22) _DO_21(TARGET)
+#define _DO_23(TARGET) TARGET(23) _DO_22(TARGET)
+#define _DO_24(TARGET) TARGET(24) _DO_23(TARGET)
+#define _DO_25(TARGET) TARGET(25) _DO_24(TARGET)
+#define _DO_26(TARGET) TARGET(26) _DO_25(TARGET)
+#define _DO_27(TARGET) TARGET(27) _DO_26(TARGET)
+#define _DO_28(TARGET) TARGET(28) _DO_27(TARGET)
+#define _DO_29(TARGET) TARGET(29) _DO_28(TARGET)
+#define _DO_30(TARGET) TARGET(30) _DO_29(TARGET)
+#define _DO_31(TARGET) TARGET(31) _DO_30(TARGET)
+#define _DO_32(TARGET) TARGET(32) _DO_31(TARGET)
+
+#define _DO_A_1(TARGET, A) TARGET(A, 1)
+#define _DO_A_2(TARGET, A) TARGET(A, 2) _DO_A_1(TARGET, A)
+#define _DO_A_3(TARGET, A) TARGET(A, 3) _DO_A_2(TARGET, A)
+#define _DO_A_4(TARGET, A) TARGET(A, 4) _DO_A_3(TARGET, A)
+#define _DO_A_5(TARGET, A) TARGET(A, 5) _DO_A_4(TARGET, A)
+#define _DO_A_6(TARGET, A) TARGET(A, 6) _DO_A_5(TARGET, A)
+#define _DO_A_7(TARGET, A) TARGET(A, 7) _DO_A_6(TARGET, A)
+#define _DO_A_8(TARGET, A) TARGET(A, 8) _DO_A_7(TARGET, A)
+#define _DO_A_9(TARGET, A) TARGET(A, 9) _DO_A_8(TARGET, A)
+#define _DO_A_10(TARGET, A) TARGET(A, 10) _DO_A_9(TARGET, A)
+#define _DO_A_11(TARGET, A) TARGET(A, 11) _DO_A_10(TARGET, A)
+#define _DO_A_12(TARGET, A) TARGET(A, 12) _DO_A_11(TARGET, A)
+#define _DO_A_13(TARGET, A) TARGET(A, 13) _DO_A_12(TARGET, A)
+#define _DO_A_14(TARGET, A) TARGET(A, 14) _DO_A_13(TARGET, A)
+#define _DO_A_15(TARGET, A) TARGET(A, 15) _DO_A_14(TARGET, A)
+#define _DO_A_16(TARGET, A) TARGET(A, 16) _DO_A_15(TARGET, A)
+#define _DO_A_17(TARGET, A) TARGET(A, 17) _DO_A_16(TARGET, A)
+#define _DO_A_18(TARGET, A) TARGET(A, 18) _DO_A_17(TARGET, A)
+#define _DO_A_19(TARGET, A) TARGET(A, 19) _DO_A_18(TARGET, A)
+#define _DO_A_20(TARGET, A) TARGET(A, 20) _DO_A_19(TARGET, A)
+#define _DO_A_21(TARGET, A) TARGET(A, 21) _DO_A_20(TARGET, A)
+#define _DO_A_22(TARGET, A) TARGET(A, 22) _DO_A_21(TARGET, A)
+#define _DO_A_23(TARGET, A) TARGET(A, 23) _DO_A_22(TARGET, A)
+#define _DO_A_24(TARGET, A) TARGET(A, 24) _DO_A_23(TARGET, A)
+#define _DO_A_25(TARGET, A) TARGET(A, 25) _DO_A_24(TARGET, A)
+#define _DO_A_26(TARGET, A) TARGET(A, 26) _DO_A_25(TARGET, A)
+#define _DO_A_27(TARGET, A) TARGET(A, 27) _DO_A_26(TARGET, A)
+#define _DO_A_28(TARGET, A) TARGET(A, 28) _DO_A_27(TARGET, A)
+#define _DO_A_29(TARGET, A) TARGET(A, 29) _DO_A_28(TARGET, A)
+#define _DO_A_30(TARGET, A) TARGET(A, 30) _DO_A_29(TARGET, A)
+#define _DO_A_31(TARGET, A) TARGET(A, 31) _DO_A_30(TARGET, A)
+#define _DO_A_32(TARGET, A) TARGET(A, 32) _DO_A_31(TARGET, A)
+
+#define _DO_1_B(TARGET, B_RANGE) _DO_A_##B_RANGE(TARGET, 1)
+#define _DO_2_B(TARGET, B_RANGE) _DO_A_##B_RANGE(TARGET, 2) _DO_1_B(TARGET, B_RANGE)
+#define _DO_3_B(TARGET, B_RANGE) _DO_A_##B_RANGE(TARGET, 3) _DO_2_B(TARGET, B_RANGE)
+#define _DO_4_B(TARGET, B_RANGE) _DO_A_##B_RANGE(TARGET, 4) _DO_3_B(TARGET, B_RANGE)
+#define _DO_5_B(TARGET, B_RANGE) _DO_A_##B_RANGE(TARGET, 5) _DO_4_B(TARGET, B_RANGE)
+#define _DO_6_B(TARGET, B_RANGE) _DO_A_##B_RANGE(TARGET, 6) _DO_5_B(TARGET, B_RANGE)
+#define _DO_7_B(TARGET, B_RANGE) _DO_A_##B_RANGE(TARGET, 7) _DO_6_B(TARGET, B_RANGE)
+#define _DO_8_B(TARGET, B_RANGE) _DO_A_##B_RANGE(TARGET, 8) _DO_7_B(TARGET, B_RANGE)
+#define _DO_9_B(TARGET, B_RANGE) _DO_A_##B_RANGE(TARGET, 9) _DO_8_B(TARGET, B_RANGE)
+#define _DO_10_B(TARGET, B_RANGE) _DO_A_##B_RANGE(TARGET, 10) _DO_9_B(TARGET, B_RANGE)
+#define _DO_11_B(TARGET, B_RANGE) _DO_A_##B_RANGE(TARGET, 11) _DO_10_B(TARGET, B_RANGE)
+#define _DO_12_B(TARGET, B_RANGE) _DO_A_##B_RANGE(TARGET, 12) _DO_11_B(TARGET, B_RANGE)
+#define _DO_13_B(TARGET, B_RANGE) _DO_A_##B_RANGE(TARGET, 13) _DO_12_B(TARGET, B_RANGE)
+#define _DO_14_B(TARGET, B_RANGE) _DO_A_##B_RANGE(TARGET, 14) _DO_13_B(TARGET, B_RANGE)
+#define _DO_15_B(TARGET, B_RANGE) _DO_A_##B_RANGE(TARGET, 15) _DO_14_B(TARGET, B_RANGE)
+#define _DO_16_B(TARGET, B_RANGE) _DO_A_##B_RANGE(TARGET, 16) _DO_15_B(TARGET, B_RANGE)
+#define _DO_17_B(TARGET, B_RANGE) _DO_A_##B_RANGE(TARGET, 17) _DO_16_B(TARGET, B_RANGE)
+#define _DO_18_B(TARGET, B_RANGE) _DO_A_##B_RANGE(TARGET, 18) _DO_17_B(TARGET, B_RANGE)
+#define _DO_19_B(TARGET, B_RANGE) _DO_A_##B_RANGE(TARGET, 19) _DO_18_B(TARGET, B_RANGE)
+#define _DO_20_B(TARGET, B_RANGE) _DO_A_##B_RANGE(TARGET, 20) _DO_19_B(TARGET, B_RANGE)
+#define _DO_21_B(TARGET, B_RANGE) _DO_A_##B_RANGE(TARGET, 21) _DO_20_B(TARGET, B_RANGE)
+#define _DO_22_B(TARGET, B_RANGE) _DO_A_##B_RANGE(TARGET, 22) _DO_21_B(TARGET, B_RANGE)
+#define _DO_23_B(TARGET, B_RANGE) _DO_A_##B_RANGE(TARGET, 23) _DO_22_B(TARGET, B_RANGE)
+#define _DO_24_B(TARGET, B_RANGE) _DO_A_##B_RANGE(TARGET, 24) _DO_23_B(TARGET, B_RANGE)
+#define _DO_25_B(TARGET, B_RANGE) _DO_A_##B_RANGE(TARGET, 25) _DO_24_B(TARGET, B_RANGE)
+#define _DO_26_B(TARGET, B_RANGE) _DO_A_##B_RANGE(TARGET, 26) _DO_25_B(TARGET, B_RANGE)
+#define _DO_27_B(TARGET, B_RANGE) _DO_A_##B_RANGE(TARGET, 27) _DO_26_B(TARGET, B_RANGE)
+#define _DO_28_B(TARGET, B_RANGE) _DO_A_##B_RANGE(TARGET, 28) _DO_27_B(TARGET, B_RANGE)
+#define _DO_29_B(TARGET, B_RANGE) _DO_A_##B_RANGE(TARGET, 29) _DO_28_B(TARGET, B_RANGE)
+#define _DO_30_B(TARGET, B_RANGE) _DO_A_##B_RANGE(TARGET, 30) _DO_29_B(TARGET, B_RANGE)
+#define _DO_31_B(TARGET, B_RANGE) _DO_A_##B_RANGE(TARGET, 31) _DO_30_B(TARGET, B_RANGE)
+#define _DO_32_B(TARGET, B_RANGE) _DO_A_##B_RANGE(TARGET, 32) _DO_31_B(TARGET, B_RANGE)
+
+#define _CASE_A(A) \
+  case (A):        \
+    CASE(A) break;
+#define _CASE_AB(A, B) \
+  case (A * 100 + B):  \
+    CASE(A, B) break;
+
+// Preproccessor For Loops
+#define DO_FOR_A(TARGET, A_RANGE) _DO_##A_RANGE(TARGET)
+#define DO_FOR_AB(TARGET, A_RANGE, B_RANGE) _DO_##A_RANGE##_B(TARGET, B_RANGE)
+
+// Preproccessor Switch Statement Generators
+#define SWITCH_A(CASE, A_RANGE, A) \
+  switch (A) { DO_FOR_A(_CASE_A, A_RANGE) }
+#define SWITCH_AB(CALL, A_RANGE, B_RANGE, A, B) \
+  switch (A * 100 + B) { DO_FOR_AB(_CASE_AB, A_RANGE, B_RANGE) }

source_code/SegMamba/monai/fl/client/__init__.py

@@ -0,0 +1,15 @@
+# Copyright (c) MONAI Consortium
+# 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.
+
+from __future__ import annotations
+
+from .client_algo import BaseClient, ClientAlgo, ClientAlgoStats
+from .monai_algo import MonaiAlgo, MonaiAlgoStats

source_code/SegMamba/monai/fl/utils/constants.py

@@ -0,0 +1,59 @@
+# Copyright (c) MONAI Consortium
+# 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.
+
+from __future__ import annotations
+
+from monai.utils.enums import StrEnum
+
+
+class WeightType(StrEnum):
+    WEIGHTS = "fl_weights_full"
+    WEIGHT_DIFF = "fl_weight_diff"
+
+
+class ModelType(StrEnum):
+    BEST_MODEL = "fl_best_model"
+    FINAL_MODEL = "fl_final_model"
+
+
+class ExtraItems(StrEnum):
+    ABORT = "fl_abort"
+    MODEL_TYPE = "fl_model_type"
+    CLIENT_NAME = "fl_client_name"
+    APP_ROOT = "fl_app_root"
+    STATS_SENDER = "fl_stats_sender"
+
+
+class FlPhase(StrEnum):
+    IDLE = "fl_idle"
+    TRAIN = "fl_train"
+    EVALUATE = "fl_evaluate"
+    GET_WEIGHTS = "fl_get_weights"
+    GET_DATA_STATS = "fl_get_data_stats"
+
+
+class FlStatistics(StrEnum):
+    NUM_EXECUTED_ITERATIONS = "num_executed_iterations"
+    STATISTICS = "statistics"
+    HIST_BINS = "hist_bins"
+    HIST_RANGE = "hist_range"
+    DATA_STATS = "data_stats"
+    DATA_COUNT = "data_count"
+    FAIL_COUNT = "fail_count"
+    TOTAL_DATA = "total_data"
+    FEATURE_NAMES = "feature_names"
+
+
+class FiltersType(StrEnum):
+    PRE_FILTERS = "pre_filters"
+    POST_WEIGHT_FILTERS = "post_weight_filters"
+    POST_EVALUATE_FILTERS = "post_evaluate_filters"
+    POST_STATISTICS_FILTERS = "post_statistics_filters"

source_code/SegMamba/monai/fl/utils/exchange_object.py

@@ -0,0 +1,107 @@
+# Copyright (c) MONAI Consortium
+# 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.
+
+from __future__ import annotations
+
+from monai.fl.utils.constants import WeightType
+
+
+class ExchangeObject(dict):
+    """
+    Contains the information shared between client and server.
+
+    Args:
+        weights: model weights.
+        optim: optimizer weights.
+        metrics: evaluation metrics.
+        weight_type: type of weights (see monai.fl.utils.constants.WeightType).
+        statistics: training statistics, i.e. number executed iterations.
+    """
+
+    def __init__(
+        self,
+        weights: dict | None = None,
+        optim: dict | None = None,
+        metrics: dict | None = None,
+        weight_type: WeightType | None = None,
+        statistics: dict | None = None,
+    ):
+        super().__init__()
+        self.weights = weights
+        self.optim = optim
+        self.metrics = metrics
+        self.weight_type = weight_type
+        self.statistics = statistics
+        self._summary: dict = {}
+
+    @property
+    def metrics(self):
+        return self._metrics
+
+    @metrics.setter
+    def metrics(self, metrics):
+        if metrics is not None:
+            if not isinstance(metrics, dict):
+                raise ValueError(f"Expected metrics to be of type dict but received {type(metrics)}")
+        self._metrics = metrics
+
+    @property
+    def statistics(self):
+        return self._statistics
+
+    @statistics.setter
+    def statistics(self, statistics):
+        if statistics is not None:
+            if not isinstance(statistics, dict):
+                raise ValueError(f"Expected statistics to be of type dict but received {type(statistics)}")
+        self._statistics = statistics
+
+    @property
+    def weight_type(self):
+        return self._weight_type
+
+    @weight_type.setter
+    def weight_type(self, weight_type):
+        if weight_type is not None:
+            if weight_type not in [WeightType.WEIGHTS, WeightType.WEIGHT_DIFF]:
+                raise ValueError(f"Expected weight type to be either {WeightType.WEIGHTS} or {WeightType.WEIGHT_DIFF}")
+        self._weight_type = weight_type
+
+    def is_valid_weights(self):
+        if not self.weights:
+            return False
+        if not self.weight_type:
+            return False
+        return True
+
+    def _add_to_summary(self, key, value):
+        if value:
+            if isinstance(value, dict):
+                self._summary[key] = len(value)
+            elif isinstance(value, WeightType):
+                self._summary[key] = value
+            else:
+                self._summary[key] = type(value)
+
+    def summary(self):
+        self._summary.update(self)
+        for k, v in zip(
+            ["weights", "optim", "metrics", "weight_type", "statistics"],
+            [self.weights, self.optim, self.metrics, self.weight_type, self.statistics],
+        ):
+            self._add_to_summary(k, v)
+        return self._summary
+
+    def __repr__(self):
+        return str(self.summary())
+
+    def __str__(self):
+        return str(self.summary())

source_code/SegMamba/monai/handlers/hausdorff_distance.py

@@ -0,0 +1,67 @@
+# Copyright (c) MONAI Consortium
+# 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.
+
+from __future__ import annotations
+
+from collections.abc import Callable
+
+from monai.handlers.ignite_metric import IgniteMetricHandler
+from monai.metrics import HausdorffDistanceMetric
+from monai.utils import MetricReduction
+
+
+class HausdorffDistance(IgniteMetricHandler):
+    """
+    Computes Hausdorff distance from full size Tensor and collects average over batch, class-channels, iterations.
+    """
+
+    def __init__(
+        self,
+        include_background: bool = False,
+        distance_metric: str = "euclidean",
+        percentile: float | None = None,
+        directed: bool = False,
+        reduction: MetricReduction | str = MetricReduction.MEAN,
+        output_transform: Callable = lambda x: x,
+        save_details: bool = True,
+    ) -> None:
+        """
+
+        Args:
+            include_background: whether to include distance computation on the first channel of the predicted output.
+                Defaults to ``False``.
+            distance_metric: : [``"euclidean"``, ``"chessboard"``, ``"taxicab"``]
+                the metric used to compute surface distance. Defaults to ``"euclidean"``.
+            percentile: an optional float number between 0 and 100. If specified, the corresponding
+                percentile of the Hausdorff Distance rather than the maximum result will be achieved.
+                Defaults to ``None``.
+            directed: whether to calculate directed Hausdorff distance. Defaults to ``False``.
+            reduction: define the mode to reduce metrics, will only execute reduction on `not-nan` values,
+                available reduction modes: {``"none"``, ``"mean"``, ``"sum"``, ``"mean_batch"``, ``"sum_batch"``,
+                ``"mean_channel"``, ``"sum_channel"``}, default to ``"mean"``. if "none", will not do reduction.
+            output_transform: callable to extract `y_pred` and `y` from `ignite.engine.state.output` then
+                construct `(y_pred, y)` pair, where `y_pred` and `y` can be `batch-first` Tensors or
+                lists of `channel-first` Tensors. the form of `(y_pred, y)` is required by the `update()`.
+                `engine.state` and `output_transform` inherit from the ignite concept:
+                https://pytorch.org/ignite/concepts.html#state, explanation and usage example are in the tutorial:
+                https://github.com/Project-MONAI/tutorials/blob/master/modules/batch_output_transform.ipynb.
+            save_details: whether to save metric computation details per image, for example: hausdorff distance
+                of every image. default to True, will save to `engine.state.metric_details` dict with the metric name as key.
+
+        """
+        metric_fn = HausdorffDistanceMetric(
+            include_background=include_background,
+            distance_metric=distance_metric,
+            percentile=percentile,
+            directed=directed,
+            reduction=reduction,
+        )
+        super().__init__(metric_fn=metric_fn, output_transform=output_transform, save_details=save_details)

source_code/SegMamba/monai/handlers/tensorboard_handlers.py

@@ -0,0 +1,454 @@
+# Copyright (c) MONAI Consortium
+# 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.
+
+from __future__ import annotations
+
+import warnings
+from collections.abc import Callable, Sequence
+from typing import TYPE_CHECKING, Any
+
+import numpy as np
+import torch
+
+from monai.config import IgniteInfo
+from monai.utils import is_scalar, min_version, optional_import
+from monai.visualize import plot_2d_or_3d_image
+
+Events, _ = optional_import("ignite.engine", IgniteInfo.OPT_IMPORT_VERSION, min_version, "Events")
+
+if TYPE_CHECKING:
+    from ignite.engine import Engine
+    from tensorboardX import SummaryWriter as SummaryWriterX
+    from torch.utils.tensorboard import SummaryWriter
+else:
+    Engine, _ = optional_import(
+        "ignite.engine", IgniteInfo.OPT_IMPORT_VERSION, min_version, "Engine", as_type="decorator"
+    )
+    SummaryWriter, _ = optional_import("torch.utils.tensorboard", name="SummaryWriter")
+    SummaryWriterX, _ = optional_import("tensorboardX", name="SummaryWriter")
+
+DEFAULT_TAG = "Loss"
+
+
+class TensorBoardHandler:
+    """
+    Base class for the handlers to write data into TensorBoard.
+
+    Args:
+        summary_writer: user can specify TensorBoard or TensorBoardX SummaryWriter,
+            default to create a new TensorBoard writer.
+        log_dir: if using default SummaryWriter, write logs to this directory, default is `./runs`.
+
+    """
+
+    def __init__(self, summary_writer: SummaryWriter | SummaryWriterX | None = None, log_dir: str = "./runs"):
+        if summary_writer is None:
+            self._writer = SummaryWriter(log_dir=log_dir)
+            self.internal_writer = True
+        else:
+            self._writer = summary_writer
+            self.internal_writer = False
+
+    def attach(self, engine: Engine) -> None:
+        raise NotImplementedError(f"Subclass {self.__class__.__name__} must implement this method.")
+
+    def close(self):
+        """
+        Close the summary writer if created in this TensorBoard handler.
+
+        """
+        if self.internal_writer:
+            self._writer.close()
+
+
+class TensorBoardStatsHandler(TensorBoardHandler):
+    """
+    TensorBoardStatsHandler defines a set of Ignite Event-handlers for all the TensorBoard logics.
+    It can be used for any Ignite Engine(trainer, validator and evaluator).
+    And it can support both epoch level and iteration level with pre-defined TensorBoard event writer.
+    The expected data source is Ignite ``engine.state.output`` and ``engine.state.metrics``.
+
+    Default behaviors:
+        - When EPOCH_COMPLETED, write each dictionary item in
+          ``engine.state.metrics`` to TensorBoard.
+        - When ITERATION_COMPLETED, write each dictionary item in
+          ``self.output_transform(engine.state.output)`` to TensorBoard.
+
+    Usage example is available in the tutorial:
+    https://github.com/Project-MONAI/tutorials/blob/master/3d_segmentation/unet_segmentation_3d_ignite.ipynb.
+
+    """
+
+    def __init__(
+        self,
+        summary_writer: SummaryWriter | SummaryWriterX | None = None,
+        log_dir: str = "./runs",
+        iteration_log: bool | Callable[[Engine, int], bool] | int = True,
+        epoch_log: bool | Callable[[Engine, int], bool] | int = True,
+        epoch_event_writer: Callable[[Engine, Any], Any] | None = None,
+        iteration_event_writer: Callable[[Engine, Any], Any] | None = None,
+        output_transform: Callable = lambda x: x[0],
+        global_epoch_transform: Callable = lambda x: x,
+        state_attributes: Sequence[str] | None = None,
+        tag_name: str = DEFAULT_TAG,
+    ) -> None:
+        """
+        Args:
+            summary_writer: user can specify TensorBoard or TensorBoardX SummaryWriter,
+                default to create a new TensorBoard writer.
+            log_dir: if using default SummaryWriter, write logs to this directory, default is `./runs`.
+            iteration_log: whether to write data to TensorBoard when iteration completed, default to `True`.
+                ``iteration_log`` can be also a function or int. If it is an int, it will be interpreted as the iteration interval
+                at which the iteration_event_writer is called. If it is a function, it will be interpreted as an event filter
+                (see https://pytorch.org/ignite/generated/ignite.engine.events.Events.html for details).
+                Event filter function accepts as input engine and event value (iteration) and should return True/False.
+            epoch_log: whether to write data to TensorBoard when epoch completed, default to `True`.
+                ``epoch_log`` can be also a function or int. If it is an int, it will be interpreted as the epoch interval
+                at which the epoch_event_writer is called. If it is a function, it will be interpreted as an event filter.
+                See ``iteration_log`` argument for more details.
+            epoch_event_writer: customized callable TensorBoard writer for epoch level.
+                Must accept parameter "engine" and "summary_writer", use default event writer if None.
+            iteration_event_writer: customized callable TensorBoard writer for iteration level.
+                Must accept parameter "engine" and "summary_writer", use default event writer if None.
+            output_transform: a callable that is used to transform the
+                ``ignite.engine.state.output`` into a scalar to plot, or a dictionary of {key: scalar}.
+                In the latter case, the output string will be formatted as key: value.
+                By default this value plotting happens when every iteration completed.
+                The default behavior is to print loss from output[0] as output is a decollated list
+                and we replicated loss value for every item of the decollated list.
+                `engine.state` and `output_transform` inherit from the ignite concept:
+                https://pytorch.org/ignite/concepts.html#state, explanation and usage example are in the tutorial:
+                https://github.com/Project-MONAI/tutorials/blob/master/modules/batch_output_transform.ipynb.
+            global_epoch_transform: a callable that is used to customize global epoch number.
+                For example, in evaluation, the evaluator engine might want to use trainer engines epoch number
+                when plotting epoch vs metric curves.
+            state_attributes: expected attributes from `engine.state`, if provided, will extract them
+                when epoch completed.
+            tag_name: when iteration output is a scalar, tag_name is used to plot, defaults to ``'Loss'``.
+        """
+
+        super().__init__(summary_writer=summary_writer, log_dir=log_dir)
+        self.iteration_log = iteration_log
+        self.epoch_log = epoch_log
+        self.epoch_event_writer = epoch_event_writer
+        self.iteration_event_writer = iteration_event_writer
+        self.output_transform = output_transform
+        self.global_epoch_transform = global_epoch_transform
+        self.state_attributes = state_attributes
+        self.tag_name = tag_name
+
+    def attach(self, engine: Engine) -> None:
+        """
+        Register a set of Ignite Event-Handlers to a specified Ignite engine.
+
+        Args:
+            engine: Ignite Engine, it can be a trainer, validator or evaluator.
+
+        """
+        if self.iteration_log and not engine.has_event_handler(self.iteration_completed, Events.ITERATION_COMPLETED):
+            event = Events.ITERATION_COMPLETED
+            if callable(self.iteration_log):  # substitute event with new one using filter callable
+                event = event(event_filter=self.iteration_log)
+            elif self.iteration_log > 1:
+                event = event(every=self.iteration_log)
+            engine.add_event_handler(event, self.iteration_completed)
+        if self.epoch_log and not engine.has_event_handler(self.epoch_completed, Events.EPOCH_COMPLETED):
+            event = Events.EPOCH_COMPLETED
+            if callable(self.epoch_log):  # substitute event with new one using filter callable
+                event = event(event_filter=self.epoch_log)
+            elif self.epoch_log > 1:
+                event = event(every=self.epoch_log)
+            engine.add_event_handler(event, self.epoch_completed)
+
+    def epoch_completed(self, engine: Engine) -> None:
+        """
+        Handler for train or validation/evaluation epoch completed Event.
+        Write epoch level events, default values are from Ignite `engine.state.metrics` dict.
+
+        Args:
+            engine: Ignite Engine, it can be a trainer, validator or evaluator.
+
+        """
+        if self.epoch_event_writer is not None:
+            self.epoch_event_writer(engine, self._writer)
+        else:
+            self._default_epoch_writer(engine, self._writer)
+
+    def iteration_completed(self, engine: Engine) -> None:
+        """
+        Handler for train or validation/evaluation iteration completed Event.
+        Write iteration level events, default values are from Ignite `engine.state.output`.
+
+        Args:
+            engine: Ignite Engine, it can be a trainer, validator or evaluator.
+
+        """
+        if self.iteration_event_writer is not None:
+            self.iteration_event_writer(engine, self._writer)
+        else:
+            self._default_iteration_writer(engine, self._writer)
+
+    def _write_scalar(
+        self, _engine: Engine, writer: SummaryWriter | SummaryWriterX, tag: str, value: Any, step: int
+    ) -> None:
+        """
+        Write scale value into TensorBoard.
+        Default to call `SummaryWriter.add_scalar()`.
+
+        Args:
+            _engine: Ignite Engine, unused argument.
+            writer: TensorBoard or TensorBoardX writer, passed or created in TensorBoardHandler.
+            tag: tag name in the TensorBoard.
+            value: value of the scalar data for current step.
+            step: index of current step.
+
+        """
+        writer.add_scalar(tag, value, step)
+
+    def _default_epoch_writer(self, engine: Engine, writer: SummaryWriter | SummaryWriterX) -> None:
+        """
+        Execute epoch level event write operation.
+        Default to write the values from Ignite `engine.state.metrics` dict and
+        write the values of specified attributes of `engine.state`.
+
+        Args:
+            engine: Ignite Engine, it can be a trainer, validator or evaluator.
+            writer: TensorBoard or TensorBoardX writer, passed or created in TensorBoardHandler.
+
+        """
+        current_epoch = self.global_epoch_transform(engine.state.epoch)
+        summary_dict = engine.state.metrics
+        for name, value in summary_dict.items():
+            if is_scalar(value):
+                self._write_scalar(engine, writer, name, value, current_epoch)
+
+        if self.state_attributes is not None:
+            for attr in self.state_attributes:
+                self._write_scalar(engine, writer, attr, getattr(engine.state, attr, None), current_epoch)
+        writer.flush()
+
+    def _default_iteration_writer(self, engine: Engine, writer: SummaryWriter | SummaryWriterX) -> None:
+        """
+        Execute iteration level event write operation based on Ignite `engine.state.output` data.
+        Extract the values from `self.output_transform(engine.state.output)`.
+        Since `engine.state.output` is a decollated list and we replicated the loss value for every item
+        of the decollated list, the default behavior is to track the loss from `output[0]`.
+
+        Args:
+            engine: Ignite Engine, it can be a trainer, validator or evaluator.
+            writer: TensorBoard  or TensorBoardX writer, passed or created in TensorBoardHandler.
+
+        """
+        loss = self.output_transform(engine.state.output)
+        if loss is None:
+            return  # do nothing if output is empty
+        if isinstance(loss, dict):
+            for name in sorted(loss):
+                value = loss[name]
+                if not is_scalar(value):
+                    warnings.warn(
+                        "ignoring non-scalar output in TensorBoardStatsHandler,"
+                        " make sure `output_transform(engine.state.output)` returns"
+                        " a scalar or dictionary of key and scalar pairs to avoid this warning."
+                        " {}:{}".format(name, type(value))
+                    )
+                    continue  # not plot multi dimensional output
+                self._write_scalar(
+                    _engine=engine,
+                    writer=writer,
+                    tag=name,
+                    value=value.item() if isinstance(value, torch.Tensor) else value,
+                    step=engine.state.iteration,
+                )
+        elif is_scalar(loss):  # not printing multi dimensional output
+            self._write_scalar(
+                _engine=engine,
+                writer=writer,
+                tag=self.tag_name,
+                value=loss.item() if isinstance(loss, torch.Tensor) else loss,
+                step=engine.state.iteration,
+            )
+        else:
+            warnings.warn(
+                "ignoring non-scalar output in TensorBoardStatsHandler,"
+                " make sure `output_transform(engine.state.output)` returns"
+                " a scalar or a dictionary of key and scalar pairs to avoid this warning."
+                " {}".format(type(loss))
+            )
+        writer.flush()
+
+
+class TensorBoardImageHandler(TensorBoardHandler):
+    """
+    TensorBoardImageHandler is an Ignite Event handler that can visualize images, labels and outputs as 2D/3D images.
+    2D output (shape in Batch, channel, H, W) will be shown as simple image using the first element in the batch,
+    for 3D to ND output (shape in Batch, channel, H, W, D) input, each of ``self.max_channels`` number of images'
+    last three dimensions will be shown as animated GIF along the last axis (typically Depth).
+    And if writer is from TensorBoardX, data has 3 channels and `max_channels=3`, will plot as RGB video.
+
+    It can be used for any Ignite Engine (trainer, validator and evaluator).
+    User can easily add it to engine for any expected Event, for example: ``EPOCH_COMPLETED``,
+    ``ITERATION_COMPLETED``. The expected data source is ignite's ``engine.state.batch`` and ``engine.state.output``.
+
+    Default behavior:
+        - Show y_pred as images (GIF for 3D) on TensorBoard when Event triggered,
+        - Need to use ``batch_transform`` and ``output_transform`` to specify
+          how many images to show and show which channel.
+        - Expects ``batch_transform(engine.state.batch)`` to return data
+          format: (image[N, channel, ...], label[N, channel, ...]).
+        - Expects ``output_transform(engine.state.output)`` to return a torch
+          tensor in format (y_pred[N, channel, ...], loss).
+
+    Usage example is available in the tutorial:
+    https://github.com/Project-MONAI/tutorials/blob/master/3d_segmentation/unet_segmentation_3d_ignite.ipynb.
+
+    """
+
+    def __init__(
+        self,
+        summary_writer: SummaryWriter | SummaryWriterX | None = None,
+        log_dir: str = "./runs",
+        interval: int = 1,
+        epoch_level: bool = True,
+        batch_transform: Callable = lambda x: x,
+        output_transform: Callable = lambda x: x,
+        global_iter_transform: Callable = lambda x: x,
+        index: int = 0,
+        max_channels: int = 1,
+        frame_dim: int = -3,
+        max_frames: int = 64,
+    ) -> None:
+        """
+        Args:
+            summary_writer: user can specify TensorBoard or TensorBoardX SummaryWriter,
+                default to create a new TensorBoard writer.
+            log_dir: if using default SummaryWriter, write logs to this directory, default is `./runs`.
+            interval: plot content from engine.state every N epochs or every N iterations, default is 1.
+            epoch_level: plot content from engine.state every N epochs or N iterations. `True` is epoch level,
+                `False` is iteration level.
+            batch_transform: a callable that is used to extract `image` and `label` from `ignite.engine.state.batch`,
+                then construct `(image, label)` pair. for example: if `ignite.engine.state.batch` is `{"image": xxx,
+                "label": xxx, "other": xxx}`, `batch_transform` can be `lambda x: (x["image"], x["label"])`.
+                will use the result to plot image from `result[0][index]` and plot label from `result[1][index]`.
+                `engine.state` and `batch_transform` inherit from the ignite concept:
+                https://pytorch.org/ignite/concepts.html#state, explanation and usage example are in the tutorial:
+                https://github.com/Project-MONAI/tutorials/blob/master/modules/batch_output_transform.ipynb.
+            output_transform: a callable that is used to extract the `predictions` data from
+                `ignite.engine.state.output`, will use the result to plot output from `result[index]`.
+                `engine.state` and `output_transform` inherit from the ignite concept:
+                https://pytorch.org/ignite/concepts.html#state, explanation and usage example are in the tutorial:
+                https://github.com/Project-MONAI/tutorials/blob/master/modules/batch_output_transform.ipynb.
+            global_iter_transform: a callable that is used to customize global step number for TensorBoard.
+                For example, in evaluation, the evaluator engine needs to know current epoch from trainer.
+            index: plot which element in a data batch, default is the first element.
+            max_channels: number of channels to plot.
+            frame_dim: if plotting 3D image as GIF, specify the dimension used as frames,
+                expect input data shape as `NCHWD`, default to `-3` (the first spatial dim)
+            max_frames: if plot 3D RGB image as video in TensorBoardX, set the FPS to `max_frames`.
+        """
+        super().__init__(summary_writer=summary_writer, log_dir=log_dir)
+        self.interval = interval
+        self.epoch_level = epoch_level
+        self.batch_transform = batch_transform
+        self.output_transform = output_transform
+        self.global_iter_transform = global_iter_transform
+        self.index = index
+        self.frame_dim = frame_dim
+        self.max_frames = max_frames
+        self.max_channels = max_channels
+
+    def attach(self, engine: Engine) -> None:
+        """
+        Args:
+            engine: Ignite Engine, it can be a trainer, validator or evaluator.
+        """
+        if self.epoch_level:
+            engine.add_event_handler(Events.EPOCH_COMPLETED(every=self.interval), self)
+        else:
+            engine.add_event_handler(Events.ITERATION_COMPLETED(every=self.interval), self)
+
+    def __call__(self, engine: Engine) -> None:
+        """
+        Args:
+            engine: Ignite Engine, it can be a trainer, validator or evaluator.
+
+        Raises:
+            TypeError: When ``output_transform(engine.state.output)[0]`` type is not in
+                ``Optional[Union[numpy.ndarray, torch.Tensor]]``.
+            TypeError: When ``batch_transform(engine.state.batch)[1]`` type is not in
+                ``Optional[Union[numpy.ndarray, torch.Tensor]]``.
+            TypeError: When ``output_transform(engine.state.output)`` type is not in
+                ``Optional[Union[numpy.ndarray, torch.Tensor]]``.
+
+        """
+        step = self.global_iter_transform(engine.state.epoch if self.epoch_level else engine.state.iteration)
+        show_images = self.batch_transform(engine.state.batch)[0][self.index]
+        if isinstance(show_images, torch.Tensor):
+            show_images = show_images.detach().cpu().numpy()
+        if show_images is not None:
+            if not isinstance(show_images, np.ndarray):
+                raise TypeError(
+                    "output_transform(engine.state.output)[0] must be None or one of "
+                    f"(numpy.ndarray, torch.Tensor) but is {type(show_images).__name__}."
+                )
+            plot_2d_or_3d_image(
+                # add batch dim and plot the first item
+                data=show_images[None],
+                step=step,
+                writer=self._writer,
+                index=0,
+                max_channels=self.max_channels,
+                frame_dim=self.frame_dim,
+                max_frames=self.max_frames,
+                tag="input_0",
+            )
+
+        show_labels = self.batch_transform(engine.state.batch)[1][self.index]
+        if isinstance(show_labels, torch.Tensor):
+            show_labels = show_labels.detach().cpu().numpy()
+        if show_labels is not None:
+            if not isinstance(show_labels, np.ndarray):
+                raise TypeError(
+                    "batch_transform(engine.state.batch)[1] must be None or one of "
+                    f"(numpy.ndarray, torch.Tensor) but is {type(show_labels).__name__}."
+                )
+            plot_2d_or_3d_image(
+                data=show_labels[None],
+                step=step,
+                writer=self._writer,
+                index=0,
+                max_channels=self.max_channels,
+                frame_dim=self.frame_dim,
+                max_frames=self.max_frames,
+                tag="input_1",
+            )
+
+        show_outputs = self.output_transform(engine.state.output)[self.index]
+        if isinstance(show_outputs, torch.Tensor):
+            show_outputs = show_outputs.detach().cpu().numpy()
+        if show_outputs is not None:
+            if not isinstance(show_outputs, np.ndarray):
+                raise TypeError(
+                    "output_transform(engine.state.output) must be None or one of "
+                    f"(numpy.ndarray, torch.Tensor) but is {type(show_outputs).__name__}."
+                )
+            plot_2d_or_3d_image(
+                data=show_outputs[None],
+                step=step,
+                writer=self._writer,
+                index=0,
+                max_channels=self.max_channels,
+                frame_dim=self.frame_dim,
+                max_frames=self.max_frames,
+                tag="output",
+            )
+
+        self._writer.flush()

source_code/SegMamba/monai/inferers/inferer.py

@@ -0,0 +1,754 @@
+# Copyright (c) MONAI Consortium
+# 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.
+
+from __future__ import annotations
+
+import warnings
+from abc import ABC, abstractmethod
+from collections.abc import Callable, Iterable, Iterator, Mapping, Sequence
+from pydoc import locate
+from typing import Any
+
+import torch
+import torch.nn as nn
+
+from monai.apps.utils import get_logger
+from monai.data.meta_tensor import MetaTensor
+from monai.data.thread_buffer import ThreadBuffer
+from monai.inferers.merger import AvgMerger, Merger
+from monai.inferers.splitter import Splitter
+from monai.inferers.utils import compute_importance_map, sliding_window_inference
+from monai.utils import BlendMode, PatchKeys, PytorchPadMode, ensure_tuple, optional_import
+from monai.visualize import CAM, GradCAM, GradCAMpp
+
+logger = get_logger(__name__)
+
+__all__ = [
+    "Inferer",
+    "PatchInferer",
+    "SimpleInferer",
+    "SlidingWindowInferer",
+    "SaliencyInferer",
+    "SliceInferer",
+    "SlidingWindowInfererAdapt",
+]
+
+
+class Inferer(ABC):
+    """
+    A base class for model inference.
+    Extend this class to support operations during inference, e.g. a sliding window method.
+
+    Example code::
+
+        device = torch.device("cuda:0")
+        transform = Compose([ToTensor(), LoadImage(image_only=True)])
+        data = transform(img_path).to(device)
+        model = UNet(...).to(device)
+        inferer = SlidingWindowInferer(...)
+
+        model.eval()
+        with torch.no_grad():
+            pred = inferer(inputs=data, network=model)
+        ...
+
+    """
+
+    @abstractmethod
+    def __call__(self, inputs: torch.Tensor, network: Callable, *args: Any, **kwargs: Any) -> Any:
+        """
+        Run inference on `inputs` with the `network` model.
+
+        Args:
+            inputs: input of the model inference.
+            network: model for inference.
+            args: optional args to be passed to ``network``.
+            kwargs: optional keyword args to be passed to ``network``.
+
+        Raises:
+            NotImplementedError: When the subclass does not override this method.
+
+        """
+        raise NotImplementedError(f"Subclass {self.__class__.__name__} must implement this method.")
+
+
+class PatchInferer(Inferer):
+    """
+    Inference on patches instead of the whole image based on Splitter and Merger.
+    This splits the input image into patches and then merge the resulted patches.
+
+    Args:
+        splitter: a `Splitter` object that split the inputs into patches. Defaults to None.
+            If not provided or None, the inputs are considered to be already split into patches.
+            In this case, the output `merged_shape` and the optional `cropped_shape` cannot be inferred
+            and should be explicitly provided.
+        merger_cls: a `Merger` subclass that can be instantiated to merges patch outputs.
+            It can also be a string that matches the name of a class inherited from `Merger` class.
+            Defaults to `AvgMerger`.
+        batch_size: batch size for patches. If the input tensor is already batched [BxCxWxH],
+            this adds additional batching [(Bp*B)xCxWpxHp] for inference on patches.
+            Defaults to 1.
+        preprocessing: a callable that process patches before the being fed to the network.
+            Defaults to None.
+        postprocessing: a callable that process the output of the network.
+            Defaults to None.
+        output_keys: if the network output is a dictionary, this defines the keys of
+            the output dictionary to be used for merging.
+            Defaults to None, where all the keys are used.
+        match_spatial_shape: whether to crop the output to match the input shape. Defaults to True.
+        buffer_size: number of patches to be held in the buffer with a separate thread for batch sampling. Defaults to 0.
+        merger_kwargs: arguments to be passed to `merger_cls` for instantiation.
+            `merged_shape` is calculated automatically based on the input shape and
+            the output patch shape unless it is passed here.
+    """
+
+    def __init__(
+        self,
+        splitter: Splitter | None = None,
+        merger_cls: type[Merger] | str = AvgMerger,
+        batch_size: int = 1,
+        preprocessing: Callable | None = None,
+        postprocessing: Callable | None = None,
+        output_keys: Sequence | None = None,
+        match_spatial_shape: bool = True,
+        buffer_size: int = 0,
+        **merger_kwargs: Any,
+    ) -> None:
+        Inferer.__init__(self)
+        # splitter
+        if not isinstance(splitter, (Splitter, type(None))):
+            if not isinstance(splitter, Splitter):
+                raise TypeError(
+                    f"'splitter' should be a `Splitter` object that returns: "
+                    "an iterable of pairs of (patch, location) or a MetaTensor that has `PatchKeys.LOCATION` metadata)."
+                    f"{type(splitter)} is given."
+                )
+        self.splitter = splitter
+
+        # merger
+        if isinstance(merger_cls, str):
+            valid_merger_cls: type[Merger]
+            # search amongst implemented mergers in MONAI
+            valid_merger_cls, merger_found = optional_import("monai.inferers.merger", name=merger_cls)
+            if not merger_found:
+                # try to locate the requested merger class (with dotted path)
+                valid_merger_cls = locate(merger_cls)  # type: ignore
+            if valid_merger_cls is None:
+                raise ValueError(f"The requested `merger_cls` ['{merger_cls}'] does not exist.")
+            merger_cls = valid_merger_cls
+        if not issubclass(merger_cls, Merger):
+            raise TypeError(f"'merger' should be a subclass of `Merger`, {merger_cls} is given.")
+        self.merger_cls = merger_cls
+        self.merger_kwargs = merger_kwargs
+
+        # pre-processor (process patch before the network)
+        if preprocessing is not None and not callable(preprocessing):
+            raise TypeError(f"'preprocessing' should be a callable object, {type(preprocessing)} is given.")
+        self.preprocessing = preprocessing
+
+        # post-processor (process the output of the network)
+        if postprocessing is not None and not callable(postprocessing):
+            raise TypeError(f"'postprocessing' should be a callable object, {type(postprocessing)} is given.")
+        self.postprocessing = postprocessing
+
+        # batch size for patches
+        if batch_size < 1:
+            raise ValueError(f"`batch_size` must be a positive number, {batch_size} is given.")
+        self.batch_size = batch_size
+
+        # model output keys
+        self.output_keys = output_keys
+
+        # whether to crop the output to match the input shape
+        self.match_spatial_shape = match_spatial_shape
+
+        # buffer size for multithreaded batch sampling
+        self.buffer_size = buffer_size
+
+    def _batch_sampler(
+        self, patches: Iterable[tuple[torch.Tensor, Sequence[int]]] | MetaTensor
+    ) -> Iterator[tuple[torch.Tensor, Sequence, int]]:
+        """Generate batch of patches and locations
+
+        Args:
+            patches: a tensor or list of tensors
+
+        Yields:
+            A batch of patches (torch.Tensor or MetaTensor), a sequence of location tuples, and the batch size
+        """
+        if isinstance(patches, MetaTensor):
+            total_size = len(patches)
+            for i in range(0, total_size, self.batch_size):
+                batch_size = min(self.batch_size, total_size - i)
+                yield patches[i : i + batch_size], patches[i : i + batch_size].meta[PatchKeys.LOCATION], batch_size  # type: ignore
+        else:
+            buffer: Iterable | ThreadBuffer
+            if self.buffer_size > 0:
+                # Use multi-threading to sample patches with a buffer
+                buffer = ThreadBuffer(patches, buffer_size=self.buffer_size, timeout=0.1)
+            else:
+                buffer = patches
+            patch_batch: list[Any] = [None] * self.batch_size
+            location_batch: list[Any] = [None] * self.batch_size
+            idx_in_batch = 0
+            for sample in buffer:
+                patch_batch[idx_in_batch] = sample[0]
+                location_batch[idx_in_batch] = sample[1]
+                idx_in_batch += 1
+                if idx_in_batch == self.batch_size:
+                    # concatenate batch of patches to create a tensor
+                    yield torch.cat(patch_batch), location_batch, idx_in_batch
+                    patch_batch = [None] * self.batch_size
+                    location_batch = [None] * self.batch_size
+                    idx_in_batch = 0
+            if idx_in_batch > 0:
+                # concatenate batch of patches to create a tensor
+                yield torch.cat(patch_batch[:idx_in_batch]), location_batch, idx_in_batch
+
+    def _ensure_tuple_outputs(self, outputs: Any) -> tuple:
+        if isinstance(outputs, dict):
+            if self.output_keys is None:
+                self.output_keys = list(outputs.keys())  # model's output keys
+            return tuple(outputs[k] for k in self.output_keys)
+        return ensure_tuple(outputs, wrap_array=True)
+
+    def _run_inference(self, network: Callable, patch: torch.Tensor, *args: Any, **kwargs: Any) -> tuple:
+        # pre-process
+        if self.preprocessing:
+            patch = self.preprocessing(patch)
+        # inference
+        outputs = network(patch, *args, **kwargs)
+        # post-process
+        if self.postprocessing:
+            outputs = self.postprocessing(outputs)
+        # ensure we have a tuple of model outputs to support multiple outputs
+        return self._ensure_tuple_outputs(outputs)
+
+    def _initialize_mergers(self, inputs, outputs, patches, batch_size):
+        in_patch = torch.chunk(patches, batch_size)[0]
+        mergers = []
+        ratios = []
+        for out_patch_batch in outputs:
+            out_patch = torch.chunk(out_patch_batch, batch_size)[0]
+            # calculate the ratio of input and output patch sizes
+            ratio = tuple(op / ip for ip, op in zip(in_patch.shape[2:], out_patch.shape[2:]))
+
+            # calculate merged_shape and cropped_shape
+            merger_kwargs = self.merger_kwargs.copy()
+            cropped_shape, merged_shape = self._get_merged_shapes(inputs, out_patch, ratio)
+            if "merged_shape" not in merger_kwargs:
+                merger_kwargs["merged_shape"] = merged_shape
+                if merger_kwargs["merged_shape"] is None:
+                    raise ValueError("`merged_shape` cannot be `None`.")
+            if "cropped_shape" not in merger_kwargs:
+                merger_kwargs["cropped_shape"] = cropped_shape
+
+            # initialize the merger
+            merger = self.merger_cls(**merger_kwargs)
+
+            # store mergers and input/output ratios
+            mergers.append(merger)
+            ratios.append(ratio)
+
+        return mergers, ratios
+
+    def _aggregate(self, outputs, locations, batch_size, mergers, ratios):
+        for output_patches, merger, ratio in zip(outputs, mergers, ratios):
+            # split batched output into individual patches and then aggregate
+            for in_loc, out_patch in zip(locations, torch.chunk(output_patches, batch_size)):
+                out_loc = [round(l * r) for l, r in zip(in_loc, ratio)]
+                merger.aggregate(out_patch, out_loc)
+
+    def _get_merged_shapes(self, inputs, out_patch, ratio):
+        """Define the shape of merged tensors (non-padded and padded)"""
+        if self.splitter is None:
+            return None, None
+
+        # input spatial shapes
+        original_spatial_shape = self.splitter.get_input_shape(inputs)
+        padded_spatial_shape = self.splitter.get_padded_shape(inputs)
+
+        # output spatial shapes
+        output_spatial_shape = tuple(round(s * r) for s, r in zip(original_spatial_shape, ratio))
+        padded_output_spatial_shape = tuple(round(s * r) for s, r in zip(padded_spatial_shape, ratio))
+
+        # output shapes
+        cropped_shape = out_patch.shape[:2] + output_spatial_shape
+        merged_shape = out_patch.shape[:2] + padded_output_spatial_shape
+
+        if not self.match_spatial_shape:
+            cropped_shape = merged_shape
+
+        return cropped_shape, merged_shape
+
+    def __call__(
+        self,
+        inputs: torch.Tensor,
+        network: Callable[..., torch.Tensor | Sequence[torch.Tensor] | dict[Any, torch.Tensor]],
+        *args: Any,
+        **kwargs: Any,
+    ) -> Any:
+        """
+        Args:
+            inputs: input data for inference, a torch.Tensor, representing an image or batch of images.
+                However if the data is already split, it can be fed by providing a list of tuple (patch, location),
+                or a MetaTensor that has metadata for `PatchKeys.LOCATION`. In both cases no splitter should be provided.
+            network: target model to execute inference.
+                supports callables such as ``lambda x: my_torch_model(x, additional_config)``
+            args: optional args to be passed to ``network``.
+            kwargs: optional keyword args to be passed to ``network``.
+
+        """
+        patches_locations: Iterable[tuple[torch.Tensor, Sequence[int]]] | MetaTensor
+        if self.splitter is None:
+            # handle situations where the splitter is not provided
+            if isinstance(inputs, torch.Tensor):
+                if isinstance(inputs, MetaTensor):
+                    if PatchKeys.LOCATION not in inputs.meta:
+                        raise ValueError(
+                            "`PatchKey.LOCATION` does not exists in `inputs.meta`. "
+                            "If the inputs are already split into patches, the location of patches needs to be "
+                            "provided as `PatchKey.LOCATION` metadata in a MetaTensor. "
+                            "If the input is not already split, please provide `splitter`."
+                        )
+                else:
+                    raise ValueError(
+                        "`splitter` should be set if the input is not already split into patches. "
+                        "For inputs that are split, the location of patches needs to be provided as "
+                        "(image, location) pairs, or as `PatchKey.LOCATION` metadata in a MetaTensor. "
+                        f"The provided inputs type is {type(inputs)}."
+                    )
+            patches_locations = inputs
+        else:
+            # apply splitter
+            patches_locations = self.splitter(inputs)
+
+        ratios: list[float] = []
+        mergers: list[Merger] = []
+        for patches, locations, batch_size in self._batch_sampler(patches_locations):
+            # run inference
+            outputs = self._run_inference(network, patches, *args, **kwargs)
+            # initialize the mergers
+            if not mergers:
+                mergers, ratios = self._initialize_mergers(inputs, outputs, patches, batch_size)
+            # aggregate outputs
+            self._aggregate(outputs, locations, batch_size, mergers, ratios)
+
+        # finalize the mergers and get the results
+        merged_outputs = [merger.finalize() for merger in mergers]
+
+        # return according to the model output
+        if self.output_keys:
+            return dict(zip(self.output_keys, merged_outputs))
+        if len(merged_outputs) == 1:
+            return merged_outputs[0]
+        return merged_outputs
+
+
+class SimpleInferer(Inferer):
+    """
+    SimpleInferer is the normal inference method that run model forward() directly.
+    Usage example can be found in the :py:class:`monai.inferers.Inferer` base class.
+
+    """
+
+    def __init__(self) -> None:
+        Inferer.__init__(self)
+
+    def __call__(
+        self, inputs: torch.Tensor, network: Callable[..., torch.Tensor], *args: Any, **kwargs: Any
+    ) -> torch.Tensor:
+        """Unified callable function API of Inferers.
+
+        Args:
+            inputs: model input data for inference.
+            network: target model to execute inference.
+                supports callables such as ``lambda x: my_torch_model(x, additional_config)``
+            args: optional args to be passed to ``network``.
+            kwargs: optional keyword args to be passed to ``network``.
+
+        """
+        return network(inputs, *args, **kwargs)
+
+
+class SlidingWindowInferer(Inferer):
+    """
+    Sliding window method for model inference,
+    with `sw_batch_size` windows for every model.forward().
+    Usage example can be found in the :py:class:`monai.inferers.Inferer` base class.
+
+    Args:
+        roi_size: the window size to execute SlidingWindow evaluation.
+            If it has non-positive components, the corresponding `inputs` size will be used.
+            if the components of the `roi_size` are non-positive values, the transform will use the
+            corresponding components of img size. For example, `roi_size=(32, -1)` will be adapted
+            to `(32, 64)` if the second spatial dimension size of img is `64`.
+        sw_batch_size: the batch size to run window slices.
+        overlap: Amount of overlap between scans along each spatial dimension, defaults to ``0.25``.
+        mode: {``"constant"``, ``"gaussian"``}
+            How to blend output of overlapping windows. Defaults to ``"constant"``.
+
+            - ``"constant``": gives equal weight to all predictions.
+            - ``"gaussian``": gives less weight to predictions on edges of windows.
+
+        sigma_scale: the standard deviation coefficient of the Gaussian window when `mode` is ``"gaussian"``.
+            Default: 0.125. Actual window sigma is ``sigma_scale`` * ``dim_size``.
+            When sigma_scale is a sequence of floats, the values denote sigma_scale at the corresponding
+            spatial dimensions.
+        padding_mode: {``"constant"``, ``"reflect"``, ``"replicate"``, ``"circular"``}
+            Padding mode when ``roi_size`` is larger than inputs. Defaults to ``"constant"``
+            See also: https://pytorch.org/docs/stable/generated/torch.nn.functional.pad.html
+        cval: fill value for 'constant' padding mode. Default: 0
+        sw_device: device for the window data.
+            By default the device (and accordingly the memory) of the `inputs` is used.
+            Normally `sw_device` should be consistent with the device where `predictor` is defined.
+        device: device for the stitched output prediction.
+            By default the device (and accordingly the memory) of the `inputs` is used. If for example
+            set to device=torch.device('cpu') the gpu memory consumption is less and independent of the
+            `inputs` and `roi_size`. Output is on the `device`.
+        progress: whether to print a tqdm progress bar.
+        cache_roi_weight_map: whether to precompute the ROI weight map.
+        cpu_thresh: when provided, dynamically switch to stitching on cpu (to save gpu memory)
+            when input image volume is larger than this threshold (in pixels/voxels).
+            Otherwise use ``"device"``. Thus, the output may end-up on either cpu or gpu.
+        buffer_steps: the number of sliding window iterations along the ``buffer_dim``
+            to be buffered on ``sw_device`` before writing to ``device``.
+            (Typically, ``sw_device`` is ``cuda`` and ``device`` is ``cpu``.)
+            default is None, no buffering. For the buffer dim, when spatial size is divisible by buffer_steps*roi_size,
+            (i.e. no overlapping among the buffers) non_blocking copy may be automatically enabled for efficiency.
+        buffer_dim: the spatial dimension along which the buffers are created.
+            0 indicates the first spatial dimension. Default is -1, the last spatial dimension.
+        with_coord: whether to pass the window coordinates to ``network``. Defaults to False.
+            If True, the ``network``'s 2nd input argument should accept the window coordinates.
+
+    Note:
+        ``sw_batch_size`` denotes the max number of windows per network inference iteration,
+        not the batch size of inputs.
+
+    """
+
+    def __init__(
+        self,
+        roi_size: Sequence[int] | int,
+        sw_batch_size: int = 1,
+        overlap: Sequence[float] | float = 0.25,
+        mode: BlendMode | str = BlendMode.CONSTANT,
+        sigma_scale: Sequence[float] | float = 0.125,
+        padding_mode: PytorchPadMode | str = PytorchPadMode.CONSTANT,
+        cval: float = 0.0,
+        sw_device: torch.device | str | None = None,
+        device: torch.device | str | None = None,
+        progress: bool = False,
+        cache_roi_weight_map: bool = False,
+        cpu_thresh: int | None = None,
+        buffer_steps: int | None = None,
+        buffer_dim: int = -1,
+        with_coord: bool = False,
+    ) -> None:
+        super().__init__()
+        self.roi_size = roi_size
+        self.sw_batch_size = sw_batch_size
+        self.overlap = overlap
+        self.mode: BlendMode = BlendMode(mode)
+        self.sigma_scale = sigma_scale
+        self.padding_mode = padding_mode
+        self.cval = cval
+        self.sw_device = sw_device
+        self.device = device
+        self.progress = progress
+        self.cpu_thresh = cpu_thresh
+        self.buffer_steps = buffer_steps
+        self.buffer_dim = buffer_dim
+        self.with_coord = with_coord
+
+        # compute_importance_map takes long time when computing on cpu. We thus
+        # compute it once if it's static and then save it for future usage
+        self.roi_weight_map = None
+        try:
+            if cache_roi_weight_map and isinstance(roi_size, Sequence) and min(roi_size) > 0:  # non-dynamic roi size
+                if device is None:
+                    device = "cpu"
+                self.roi_weight_map = compute_importance_map(
+                    ensure_tuple(self.roi_size), mode=mode, sigma_scale=sigma_scale, device=device
+                )
+            if cache_roi_weight_map and self.roi_weight_map is None:
+                warnings.warn("cache_roi_weight_map=True, but cache is not created. (dynamic roi_size?)")
+        except BaseException as e:
+            raise RuntimeError(
+                f"roi size {self.roi_size}, mode={mode}, sigma_scale={sigma_scale}, device={device}\n"
+                "Seems to be OOM. Please try smaller patch size or mode='constant' instead of mode='gaussian'."
+            ) from e
+
+    def __call__(
+        self,
+        inputs: torch.Tensor,
+        network: Callable[..., torch.Tensor | Sequence[torch.Tensor] | dict[Any, torch.Tensor]],
+        *args: Any,
+        **kwargs: Any,
+    ) -> torch.Tensor | tuple[torch.Tensor, ...] | dict[Any, torch.Tensor]:
+        """
+
+        Args:
+            inputs: model input data for inference.
+            network: target model to execute inference.
+                supports callables such as ``lambda x: my_torch_model(x, additional_config)``
+            args: optional args to be passed to ``network``.
+            kwargs: optional keyword args to be passed to ``network``.
+
+        """
+
+        device = kwargs.pop("device", self.device)
+        buffer_steps = kwargs.pop("buffer_steps", self.buffer_steps)
+        buffer_dim = kwargs.pop("buffer_dim", self.buffer_dim)
+
+        if device is None and self.cpu_thresh is not None and inputs.shape[2:].numel() > self.cpu_thresh:
+            device = "cpu"  # stitch in cpu memory if image is too large
+
+        return sliding_window_inference(
+            inputs,
+            self.roi_size,
+            self.sw_batch_size,
+            network,
+            self.overlap,
+            self.mode,
+            self.sigma_scale,
+            self.padding_mode,
+            self.cval,
+            self.sw_device,
+            device,
+            self.progress,
+            self.roi_weight_map,
+            None,
+            buffer_steps,
+            buffer_dim,
+            self.with_coord,
+            *args,
+            **kwargs,
+        )
+
+
+class SlidingWindowInfererAdapt(SlidingWindowInferer):
+    """
+    SlidingWindowInfererAdapt extends SlidingWindowInferer to automatically switch to buffered and then to CPU stitching,
+    when OOM on GPU. It also records a size of such large images to automatically
+    try CPU stitching for the next large image of a similar size.  If the stitching 'device' input parameter is provided,
+    automatic adaptation won't be attempted, please keep the default option device = None for adaptive behavior.
+    Note: the output might be on CPU (even if the input was on GPU), if the GPU memory was not sufficient.
+
+    """
+
+    def __call__(
+        self,
+        inputs: torch.Tensor,
+        network: Callable[..., torch.Tensor | Sequence[torch.Tensor] | dict[Any, torch.Tensor]],
+        *args: Any,
+        **kwargs: Any,
+    ) -> torch.Tensor | tuple[torch.Tensor, ...] | dict[Any, torch.Tensor]:
+        """
+
+        Args:
+            inputs: model input data for inference.
+            network: target model to execute inference.
+                supports callables such as ``lambda x: my_torch_model(x, additional_config)``
+            args: optional args to be passed to ``network``.
+            kwargs: optional keyword args to be passed to ``network``.
+
+        """
+
+        # if device is provided, use without any adaptations
+        if self.device is not None:
+            return super().__call__(inputs, network, *args, **kwargs)
+
+        skip_buffer = self.buffer_steps is not None and self.buffer_steps <= 0
+        cpu_cond = self.cpu_thresh is not None and inputs.shape[2:].numel() > self.cpu_thresh
+        gpu_stitching = inputs.is_cuda and not cpu_cond
+        buffered_stitching = inputs.is_cuda and cpu_cond and not skip_buffer
+        buffer_steps = max(1, self.buffer_steps) if self.buffer_steps is not None else 1
+        buffer_dim = -1
+
+        sh = list(inputs.shape[2:])
+        max_dim = sh.index(max(sh))
+        if inputs.shape[max_dim + 2] / inputs.shape[-1] >= 2:
+            buffer_dim = max_dim
+
+        for _ in range(10):  # at most 10 trials
+            try:
+                return super().__call__(
+                    inputs,
+                    network,
+                    *args,
+                    device=inputs.device if gpu_stitching else torch.device("cpu"),
+                    buffer_steps=buffer_steps if buffered_stitching else None,
+                    buffer_dim=buffer_dim,
+                    **kwargs,
+                )
+            except RuntimeError as e:
+                if not gpu_stitching and not buffered_stitching or "OutOfMemoryError" not in str(type(e).__name__):
+                    raise e
+
+                logger.info(e)
+
+                if gpu_stitching:  # if failed on gpu
+                    gpu_stitching = False
+                    self.cpu_thresh = inputs.shape[2:].numel() - 1  # update thresh
+
+                    if skip_buffer:
+                        buffered_stitching = False
+                        logger.warning(f"GPU stitching failed, attempting on CPU, image dim {inputs.shape}.")
+
+                    else:
+                        buffered_stitching = True
+                        self.buffer_steps = buffer_steps
+                        logger.warning(
+                            f"GPU stitching failed, buffer {buffer_steps} dim {buffer_dim}, image dim {inputs.shape}."
+                        )
+                elif buffer_steps > 1:
+                    buffer_steps = max(1, buffer_steps // 2)
+                    self.buffer_steps = buffer_steps
+                    logger.warning(
+                        f"GPU buffered stitching failed, image dim {inputs.shape} reducing buffer to {buffer_steps}."
+                    )
+                else:
+                    buffered_stitching = False
+                    logger.warning(f"GPU buffered stitching failed, attempting on CPU, image dim {inputs.shape}.")
+        raise RuntimeError(  # not possible to finish after the trials
+            f"SlidingWindowInfererAdapt {skip_buffer} {cpu_cond} {gpu_stitching} {buffered_stitching} {buffer_steps}"
+        )
+
+
+class SaliencyInferer(Inferer):
+    """
+    SaliencyInferer is inference with activation maps.
+
+    Args:
+        cam_name: expected CAM method name, should be: "CAM", "GradCAM" or "GradCAMpp".
+        target_layers: name of the model layer to generate the feature map.
+        class_idx: index of the class to be visualized. if None, default to argmax(logits).
+        args: other optional args to be passed to the `__init__` of cam.
+        kwargs: other optional keyword args to be passed to `__init__` of cam.
+
+    """
+
+    def __init__(
+        self, cam_name: str, target_layers: str, class_idx: int | None = None, *args: Any, **kwargs: Any
+    ) -> None:
+        Inferer.__init__(self)
+        if cam_name.lower() not in ("cam", "gradcam", "gradcampp"):
+            raise ValueError("cam_name should be: 'CAM', 'GradCAM' or 'GradCAMpp'.")
+        self.cam_name = cam_name.lower()
+        self.target_layers = target_layers
+        self.class_idx = class_idx
+        self.args = args
+        self.kwargs = kwargs
+
+    def __call__(self, inputs: torch.Tensor, network: nn.Module, *args: Any, **kwargs: Any):  # type: ignore
+        """Unified callable function API of Inferers.
+
+        Args:
+            inputs: model input data for inference.
+            network: target model to execute inference.
+                supports callables such as ``lambda x: my_torch_model(x, additional_config)``
+            args: other optional args to be passed to the `__call__` of cam.
+            kwargs: other optional keyword args to be passed to `__call__` of cam.
+
+        """
+        cam: CAM | GradCAM | GradCAMpp
+        if self.cam_name == "cam":
+            cam = CAM(network, self.target_layers, *self.args, **self.kwargs)
+        elif self.cam_name == "gradcam":
+            cam = GradCAM(network, self.target_layers, *self.args, **self.kwargs)
+        else:
+            cam = GradCAMpp(network, self.target_layers, *self.args, **self.kwargs)
+
+        return cam(inputs, self.class_idx, *args, **kwargs)
+
+
+class SliceInferer(SlidingWindowInferer):
+    """
+    SliceInferer extends SlidingWindowInferer to provide slice-by-slice (2D) inference when provided a 3D volume.
+    A typical use case could be a 2D model (like 2D segmentation UNet) operates on the slices from a 3D volume,
+    and the output is a 3D volume with 2D slices aggregated. Example::
+
+        # sliding over the `spatial_dim`
+        inferer = SliceInferer(roi_size=(64, 256), sw_batch_size=1, spatial_dim=1)
+        output = inferer(input_volume, net)
+
+    Args:
+        spatial_dim: Spatial dimension over which the slice-by-slice inference runs on the 3D volume.
+            For example ``0`` could slide over axial slices. ``1`` over coronal slices and ``2`` over sagittal slices.
+        args: other optional args to be passed to the `__init__` of base class SlidingWindowInferer.
+        kwargs: other optional keyword args to be passed to `__init__` of base class SlidingWindowInferer.
+
+    Note:
+        ``roi_size`` in SliceInferer is expected to be a 2D tuple when a 3D volume is provided. This allows
+        sliding across slices along the 3D volume using a selected ``spatial_dim``.
+
+    """
+
+    def __init__(self, spatial_dim: int = 0, *args: Any, **kwargs: Any) -> None:
+        self.spatial_dim = spatial_dim
+        super().__init__(*args, **kwargs)
+        self.orig_roi_size = ensure_tuple(self.roi_size)
+
+    def __call__(
+        self,
+        inputs: torch.Tensor,
+        network: Callable[..., torch.Tensor | Sequence[torch.Tensor] | dict[Any, torch.Tensor]],
+        *args: Any,
+        **kwargs: Any,
+    ) -> torch.Tensor | tuple[torch.Tensor, ...] | dict[Any, torch.Tensor]:
+        """
+        Args:
+            inputs: 3D input for inference
+            network: 2D model to execute inference on slices in the 3D input
+            args: optional args to be passed to ``network``.
+            kwargs: optional keyword args to be passed to ``network``.
+        """
+        if self.spatial_dim > 2:
+            raise ValueError("`spatial_dim` can only be `0, 1, 2` with `[H, W, D]` respectively.")
+
+        # Check if ``roi_size`` tuple is 2D and ``inputs`` tensor is 3D
+        self.roi_size = ensure_tuple(self.roi_size)
+        if len(self.orig_roi_size) == 2 and len(inputs.shape[2:]) == 3:
+            self.roi_size = list(self.orig_roi_size)
+            self.roi_size.insert(self.spatial_dim, 1)
+        else:
+            raise RuntimeError(
+                f"Currently, only 2D `roi_size` ({self.orig_roi_size}) with 3D `inputs` tensor (shape={inputs.shape}) is supported."
+            )
+
+        return super().__call__(inputs=inputs, network=lambda x: self.network_wrapper(network, x, *args, **kwargs))
+
+    def network_wrapper(
+        self,
+        network: Callable[..., torch.Tensor | Sequence[torch.Tensor] | dict[Any, torch.Tensor]],
+        x: torch.Tensor,
+        *args: Any,
+        **kwargs: Any,
+    ) -> torch.Tensor | tuple[torch.Tensor, ...] | dict[Any, torch.Tensor]:
+        """
+        Wrapper handles inference for 2D models over 3D volume inputs.
+        """
+        #  Pass 4D input [N, C, H, W]/[N, C, D, W]/[N, C, D, H] to the model as it is 2D.
+        x = x.squeeze(dim=self.spatial_dim + 2)
+        out = network(x, *args, **kwargs)
+
+        #  Unsqueeze the network output so it is [N, C, D, H, W] as expected by
+        # the default SlidingWindowInferer class
+        if isinstance(out, torch.Tensor):
+            return out.unsqueeze(dim=self.spatial_dim + 2)
+
+        if isinstance(out, Mapping):
+            for k in out.keys():
+                out[k] = out[k].unsqueeze(dim=self.spatial_dim + 2)
+            return out
+
+        return tuple(out_i.unsqueeze(dim=self.spatial_dim + 2) for out_i in out)

source_code/SegMamba/monai/losses/adversarial_loss.py

@@ -0,0 +1,173 @@
+# Copyright (c) MONAI Consortium
+# 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.
+
+from __future__ import annotations
+
+import warnings
+
+import torch
+from torch.nn.modules.loss import _Loss
+
+from monai.networks.layers.utils import get_act_layer
+from monai.utils import LossReduction
+from monai.utils.enums import StrEnum
+
+
+class AdversarialCriterions(StrEnum):
+    BCE = "bce"
+    HINGE = "hinge"
+    LEAST_SQUARE = "least_squares"
+
+
+class PatchAdversarialLoss(_Loss):
+    """
+    Calculates an adversarial loss on a Patch Discriminator or a Multi-scale Patch Discriminator.
+    Warning: due to the possibility of using different criterions, the output of the discrimination
+    mustn't be passed to a final activation layer. That is taken care of internally within the loss.
+
+    Args:
+        reduction: {``"none"``, ``"mean"``, ``"sum"``}
+            Specifies the reduction to apply to the output. Defaults to ``"mean"``.
+
+            - ``"none"``: no reduction will be applied.
+            - ``"mean"``: the sum of the output will be divided by the number of elements in the output.
+            - ``"sum"``: the output will be summed.
+
+        criterion: which criterion (hinge, least_squares or bce) you want to use on the discriminators outputs.
+            Depending on the criterion, a different activation layer will be used. Make sure you don't run the outputs
+            through an activation layer prior to calling the loss.
+        no_activation_leastsq: if True, the activation layer in the case of least-squares is removed.
+    """
+
+    def __init__(
+        self,
+        reduction: LossReduction | str = LossReduction.MEAN,
+        criterion: str = AdversarialCriterions.LEAST_SQUARE,
+        no_activation_leastsq: bool = False,
+    ) -> None:
+        super().__init__(reduction=LossReduction(reduction))
+
+        if criterion.lower() not in list(AdversarialCriterions):
+            raise ValueError(
+                "Unrecognised criterion entered for Adversarial Loss. Must be one in: %s"
+                % ", ".join(AdversarialCriterions)
+            )
+
+        # Depending on the criterion, a different activation layer is used.
+        self.real_label = 1.0
+        self.fake_label = 0.0
+        self.loss_fct: _Loss
+        if criterion == AdversarialCriterions.BCE:
+            self.activation = get_act_layer("SIGMOID")
+            self.loss_fct = torch.nn.BCELoss(reduction=reduction)
+        elif criterion == AdversarialCriterions.HINGE:
+            self.activation = get_act_layer("TANH")
+            self.fake_label = -1.0
+        elif criterion == AdversarialCriterions.LEAST_SQUARE:
+            if no_activation_leastsq:
+                self.activation = None
+            else:
+                self.activation = get_act_layer(name=("LEAKYRELU", {"negative_slope": 0.05}))
+            self.loss_fct = torch.nn.MSELoss(reduction=reduction)
+
+        self.criterion = criterion
+        self.reduction = reduction
+
+    def get_target_tensor(self, input: torch.Tensor, target_is_real: bool) -> torch.Tensor:
+        """
+        Gets the ground truth tensor for the discriminator depending on whether the input is real or fake.
+
+        Args:
+            input: input tensor from the discriminator (output of discriminator, or output of one of the multi-scale
+            discriminator). This is used to match the shape.
+            target_is_real: whether the input is real or wannabe-real (1s) or fake (0s).
+        Returns:
+        """
+        filling_label = self.real_label if target_is_real else self.fake_label
+        label_tensor = torch.tensor(1).fill_(filling_label).type(input.type()).to(input[0].device)
+        label_tensor.requires_grad_(False)
+        return label_tensor.expand_as(input)
+
+    def get_zero_tensor(self, input: torch.Tensor) -> torch.Tensor:
+        """
+        Gets a zero tensor.
+
+        Args:
+            input: tensor which shape you want the zeros tensor to correspond to.
+        Returns:
+        """
+
+        zero_label_tensor = torch.tensor(0).type(input[0].type()).to(input[0].device)
+        zero_label_tensor.requires_grad_(False)
+        return zero_label_tensor.expand_as(input)
+
+    def forward(
+        self, input: torch.Tensor | list, target_is_real: bool, for_discriminator: bool
+    ) -> torch.Tensor | list[torch.Tensor]:
+        """
+
+        Args:
+            input: output of Multi-Scale Patch Discriminator or Patch Discriminator; being a list of tensors
+                or a tensor; they shouldn't have gone through an activation layer.
+            target_is_real: whereas the input corresponds to discriminator output for real or fake images
+            for_discriminator: whereas this is being calculated for discriminator or generator loss. In the last
+                case, target_is_real is set to True, as the generator wants the input to be dimmed as real.
+        Returns: if reduction is None, returns a list with the loss tensors of each discriminator if multi-scale
+            discriminator is active, or the loss tensor if there is just one discriminator. Otherwise, it returns the
+            summed or mean loss over the tensor and discriminator/s.
+
+        """
+
+        if not for_discriminator and not target_is_real:
+            target_is_real = True  # With generator, we always want this to be true!
+            warnings.warn(
+                "Variable target_is_real has been set to False, but for_discriminator is set"
+                "to False. To optimise a generator, target_is_real must be set to True."
+            )
+
+        if not isinstance(input, list):
+            input = [input]
+        target_ = []
+        for _, disc_out in enumerate(input):
+            if self.criterion != AdversarialCriterions.HINGE:
+                target_.append(self.get_target_tensor(disc_out, target_is_real))
+            else:
+                target_.append(self.get_zero_tensor(disc_out))
+
+        # Loss calculation
+        loss_list = []
+        for disc_ind, disc_out in enumerate(input):
+            if self.activation is not None:
+                disc_out = self.activation(disc_out)
+            if self.criterion == AdversarialCriterions.HINGE and not target_is_real:
+                loss_ = self._forward_single(-disc_out, target_[disc_ind])
+            else:
+                loss_ = self._forward_single(disc_out, target_[disc_ind])
+            loss_list.append(loss_)
+
+        loss: torch.Tensor | list[torch.Tensor]
+        if loss_list is not None:
+            if self.reduction == LossReduction.MEAN:
+                loss = torch.mean(torch.stack(loss_list))
+            elif self.reduction == LossReduction.SUM:
+                loss = torch.sum(torch.stack(loss_list))
+            else:
+                loss = loss_list
+        return loss
+
+    def _forward_single(self, input: torch.Tensor, target: torch.Tensor) -> torch.Tensor:
+        forward: torch.Tensor
+        if self.criterion == AdversarialCriterions.BCE or self.criterion == AdversarialCriterions.LEAST_SQUARE:
+            forward = self.loss_fct(input, target)
+        elif self.criterion == AdversarialCriterions.HINGE:
+            minval = torch.min(input - 1, self.get_zero_tensor(input))
+            forward = -torch.mean(minval)
+        return forward

source_code/SegMamba/monai/losses/contrastive.py

@@ -0,0 +1,81 @@
+# Copyright (c) MONAI Consortium
+# 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.
+
+from __future__ import annotations
+
+from warnings import warn
+
+import torch
+from torch.nn import functional as F
+from torch.nn.modules.loss import _Loss
+
+
+class ContrastiveLoss(_Loss):
+    """
+    Compute the Contrastive loss defined in:
+
+        Chen, Ting, et al. "A simple framework for contrastive learning of visual representations." International
+        conference on machine learning. PMLR, 2020. (http://proceedings.mlr.press/v119/chen20j.html)
+
+    Adapted from:
+        https://github.com/Sara-Ahmed/SiT/blob/1aacd6adcd39b71efc903d16b4e9095b97dda76f/losses.py#L5
+
+    """
+
+    def __init__(self, temperature: float = 0.5, batch_size: int = -1) -> None:
+        """
+        Args:
+            temperature: Can be scaled between 0 and 1 for learning from negative samples, ideally set to 0.5.
+
+        Raises:
+            ValueError: When an input of dimension length > 2 is passed
+            ValueError: When input and target are of different shapes
+
+        """
+        super().__init__()
+        self.temperature = temperature
+
+        if batch_size != -1:
+            warn("batch_size is no longer required to be set. It will be estimated dynamically in the forward call")
+
+    def forward(self, input: torch.Tensor, target: torch.Tensor) -> torch.Tensor:
+        """
+        Args:
+            input: the shape should be B[F].
+            target: the shape should be B[F].
+        """
+        if len(target.shape) > 2 or len(input.shape) > 2:
+            raise ValueError(
+                f"Either target or input has dimensions greater than 2 where target "
+                f"shape is ({target.shape}) and input shape is ({input.shape})"
+            )
+
+        if target.shape != input.shape:
+            raise ValueError(f"ground truth has differing shape ({target.shape}) from input ({input.shape})")
+
+        temperature_tensor = torch.as_tensor(self.temperature).to(input.device)
+        batch_size = input.shape[0]
+
+        negatives_mask = ~torch.eye(batch_size * 2, batch_size * 2, dtype=torch.bool)
+        negatives_mask = torch.clone(negatives_mask.type(torch.float)).to(input.device)
+
+        repr = torch.cat([input, target], dim=0)
+        sim_matrix = F.cosine_similarity(repr.unsqueeze(1), repr.unsqueeze(0), dim=2)
+        sim_ij = torch.diag(sim_matrix, batch_size)
+        sim_ji = torch.diag(sim_matrix, -batch_size)
+
+        positives = torch.cat([sim_ij, sim_ji], dim=0)
+        nominator = torch.exp(positives / temperature_tensor)
+        denominator = negatives_mask * torch.exp(sim_matrix / temperature_tensor)
+
+        loss_partial = -torch.log(nominator / torch.sum(denominator, dim=1))
+
+        return torch.sum(loss_partial) / (2 * batch_size)

source_code/SegMamba/monai/losses/deform.py

@@ -0,0 +1,210 @@
+# Copyright (c) MONAI Consortium
+# 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.
+
+from __future__ import annotations
+
+import torch
+from torch.nn.modules.loss import _Loss
+
+from monai.utils import LossReduction
+
+
+def spatial_gradient(x: torch.Tensor, dim: int) -> torch.Tensor:
+    """
+    Calculate gradients on single dimension of a tensor using central finite difference.
+    It moves the tensor along the dimension to calculate the approximate gradient
+    dx[i] = (x[i+1] - x[i-1]) / 2.
+    Adapted from:
+        DeepReg (https://github.com/DeepRegNet/DeepReg)
+
+    Args:
+        x: the shape should be BCH(WD).
+        dim: dimension to calculate gradient along.
+    Returns:
+        gradient_dx: the shape should be BCH(WD)
+    """
+    slice_1 = slice(1, -1)
+    slice_2_s = slice(2, None)
+    slice_2_e = slice(None, -2)
+    slice_all = slice(None)
+    slicing_s, slicing_e = [slice_all, slice_all], [slice_all, slice_all]
+    while len(slicing_s) < x.ndim:
+        slicing_s = slicing_s + [slice_1]
+        slicing_e = slicing_e + [slice_1]
+    slicing_s[dim] = slice_2_s
+    slicing_e[dim] = slice_2_e
+    return (x[slicing_s] - x[slicing_e]) / 2.0
+
+
+class BendingEnergyLoss(_Loss):
+    """
+    Calculate the bending energy based on second-order differentiation of ``pred`` using central finite difference.
+
+    For more information,
+    see https://github.com/Project-MONAI/tutorials/blob/main/modules/bending_energy_diffusion_loss_notes.ipynb.
+
+    Adapted from:
+        DeepReg (https://github.com/DeepRegNet/DeepReg)
+    """
+
+    def __init__(self, normalize: bool = False, reduction: LossReduction | str = LossReduction.MEAN) -> None:
+        """
+        Args:
+            normalize:
+                Whether to divide out spatial sizes in order to make the computation roughly
+                invariant to image scale (i.e. vector field sampling resolution). Defaults to False.
+            reduction: {``"none"``, ``"mean"``, ``"sum"``}
+                Specifies the reduction to apply to the output. Defaults to ``"mean"``.
+
+                - ``"none"``: no reduction will be applied.
+                - ``"mean"``: the sum of the output will be divided by the number of elements in the output.
+                - ``"sum"``: the output will be summed.
+        """
+        super().__init__(reduction=LossReduction(reduction).value)
+        self.normalize = normalize
+
+    def forward(self, pred: torch.Tensor) -> torch.Tensor:
+        """
+        Args:
+            pred: the shape should be BCH(WD)
+
+        Raises:
+            ValueError: When ``self.reduction`` is not one of ["mean", "sum", "none"].
+            ValueError: When ``pred`` is not 3-d, 4-d or 5-d.
+            ValueError: When any spatial dimension of ``pred`` has size less than or equal to 4.
+            ValueError: When the number of channels of ``pred`` does not match the number of spatial dimensions.
+
+        """
+        if pred.ndim not in [3, 4, 5]:
+            raise ValueError(f"Expecting 3-d, 4-d or 5-d pred, instead got pred of shape {pred.shape}")
+        for i in range(pred.ndim - 2):
+            if pred.shape[-i - 1] <= 4:
+                raise ValueError(f"All spatial dimensions must be > 4, got spatial dimensions {pred.shape[2:]}")
+        if pred.shape[1] != pred.ndim - 2:
+            raise ValueError(
+                f"Number of vector components, i.e. number of channels of the input DDF, {pred.shape[1]}, "
+                f"does not match number of spatial dimensions, {pred.ndim - 2}"
+            )
+
+        # first order gradient
+        first_order_gradient = [spatial_gradient(pred, dim) for dim in range(2, pred.ndim)]
+
+        # spatial dimensions in a shape suited for broadcasting below
+        if self.normalize:
+            spatial_dims = torch.tensor(pred.shape, device=pred.device)[2:].reshape((1, -1) + (pred.ndim - 2) * (1,))
+
+        energy = torch.tensor(0)
+        for dim_1, g in enumerate(first_order_gradient):
+            dim_1 += 2
+            if self.normalize:
+                g *= pred.shape[dim_1] / spatial_dims
+                energy = energy + (spatial_gradient(g, dim_1) * pred.shape[dim_1]) ** 2
+            else:
+                energy = energy + spatial_gradient(g, dim_1) ** 2
+            for dim_2 in range(dim_1 + 1, pred.ndim):
+                if self.normalize:
+                    energy = energy + 2 * (spatial_gradient(g, dim_2) * pred.shape[dim_2]) ** 2
+                else:
+                    energy = energy + 2 * spatial_gradient(g, dim_2) ** 2
+
+        if self.reduction == LossReduction.MEAN.value:
+            energy = torch.mean(energy)  # the batch and channel average
+        elif self.reduction == LossReduction.SUM.value:
+            energy = torch.sum(energy)  # sum over the batch and channel dims
+        elif self.reduction != LossReduction.NONE.value:
+            raise ValueError(f'Unsupported reduction: {self.reduction}, available options are ["mean", "sum", "none"].')
+
+        return energy
+
+
+class DiffusionLoss(_Loss):
+    """
+    Calculate the diffusion based on first-order differentiation of ``pred`` using central finite difference.
+    For the original paper, please refer to
+    VoxelMorph: A Learning Framework for Deformable Medical Image Registration,
+    Guha Balakrishnan, Amy Zhao, Mert R. Sabuncu, John Guttag, Adrian V. Dalca
+    IEEE TMI: Transactions on Medical Imaging. 2019. eprint arXiv:1809.05231.
+
+    For more information,
+    see https://github.com/Project-MONAI/tutorials/blob/main/modules/bending_energy_diffusion_loss_notes.ipynb.
+
+    Adapted from:
+        VoxelMorph (https://github.com/voxelmorph/voxelmorph)
+    """
+
+    def __init__(self, normalize: bool = False, reduction: LossReduction | str = LossReduction.MEAN) -> None:
+        """
+        Args:
+            normalize:
+                Whether to divide out spatial sizes in order to make the computation roughly
+                invariant to image scale (i.e. vector field sampling resolution). Defaults to False.
+            reduction: {``"none"``, ``"mean"``, ``"sum"``}
+                Specifies the reduction to apply to the output. Defaults to ``"mean"``.
+
+                - ``"none"``: no reduction will be applied.
+                - ``"mean"``: the sum of the output will be divided by the number of elements in the output.
+                - ``"sum"``: the output will be summed.
+        """
+        super().__init__(reduction=LossReduction(reduction).value)
+        self.normalize = normalize
+
+    def forward(self, pred: torch.Tensor) -> torch.Tensor:
+        """
+        Args:
+            pred:
+                Predicted dense displacement field (DDF) with shape BCH[WD],
+                where C is the number of spatial dimensions.
+                Note that diffusion loss can only be calculated
+                when the sizes of the DDF along all spatial dimensions are greater than 2.
+
+        Raises:
+            ValueError: When ``self.reduction`` is not one of ["mean", "sum", "none"].
+            ValueError: When ``pred`` is not 3-d, 4-d or 5-d.
+            ValueError: When any spatial dimension of ``pred`` has size less than or equal to 2.
+            ValueError: When the number of channels of ``pred`` does not match the number of spatial dimensions.
+
+        """
+        if pred.ndim not in [3, 4, 5]:
+            raise ValueError(f"Expecting 3-d, 4-d or 5-d pred, instead got pred of shape {pred.shape}")
+        for i in range(pred.ndim - 2):
+            if pred.shape[-i - 1] <= 2:
+                raise ValueError(f"All spatial dimensions must be > 2, got spatial dimensions {pred.shape[2:]}")
+        if pred.shape[1] != pred.ndim - 2:
+            raise ValueError(
+                f"Number of vector components, i.e. number of channels of the input DDF, {pred.shape[1]}, "
+                f"does not match number of spatial dimensions, {pred.ndim - 2}"
+            )
+
+        # first order gradient
+        first_order_gradient = [spatial_gradient(pred, dim) for dim in range(2, pred.ndim)]
+
+        # spatial dimensions in a shape suited for broadcasting below
+        if self.normalize:
+            spatial_dims = torch.tensor(pred.shape, device=pred.device)[2:].reshape((1, -1) + (pred.ndim - 2) * (1,))
+
+        diffusion = torch.tensor(0)
+        for dim_1, g in enumerate(first_order_gradient):
+            dim_1 += 2
+            if self.normalize:
+                # We divide the partial derivative for each vector component at each voxel by the spatial size
+                # corresponding to that component relative to the spatial size of the vector component with respect
+                # to which the partial derivative is taken.
+                g *= pred.shape[dim_1] / spatial_dims
+            diffusion = diffusion + g**2
+
+        if self.reduction == LossReduction.MEAN.value:
+            diffusion = torch.mean(diffusion)  # the batch and channel average
+        elif self.reduction == LossReduction.SUM.value:
+            diffusion = torch.sum(diffusion)  # sum over the batch and channel dims
+        elif self.reduction != LossReduction.NONE.value:
+            raise ValueError(f'Unsupported reduction: {self.reduction}, available options are ["mean", "sum", "none"].')
+
+        return diffusion

source_code/SegMamba/monai/losses/giou_loss.py

@@ -0,0 +1,67 @@
+# Copyright (c) MONAI Consortium
+# 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.
+
+from __future__ import annotations
+
+import torch
+from torch.nn.modules.loss import _Loss
+
+from monai.data.box_utils import COMPUTE_DTYPE, box_pair_giou
+from monai.utils import LossReduction
+
+
+class BoxGIoULoss(_Loss):
+    """
+    Compute the generalized intersection over union (GIoU) loss of a pair of boxes.
+    The two inputs should have the same shape. giou_loss = 1.0 - giou
+
+    The range of GIoU is (-1.0, 1.0]. Thus the range of GIoU loss is [0.0, 2.0).
+
+    Args:
+        reduction: {``"none"``, ``"mean"``, ``"sum"``}
+            Specifies the reduction to apply to the output. Defaults to ``"mean"``.
+            - ``"none"``: no reduction will be applied.
+            - ``"mean"``: the sum of the output will be divided by the number of elements in the output.
+            - ``"sum"``: the output will be summed.
+    """
+
+    def __init__(self, reduction: LossReduction | str = LossReduction.MEAN) -> None:
+        super().__init__(reduction=LossReduction(reduction).value)
+
+    def forward(self, input: torch.Tensor, target: torch.Tensor) -> torch.Tensor:
+        """
+        Args:
+            input: predicted bounding boxes, Nx4 or Nx6 torch tensor. The box mode is assumed to be ``StandardMode``
+            target: GT bounding boxes, Nx4 or Nx6 torch tensor. The box mode is assumed to be ``StandardMode``
+
+        Raises:
+            ValueError: When the two inputs have different shape.
+        """
+        if target.shape != input.shape:
+            raise ValueError(f"ground truth has different shape ({target.shape}) from input ({input.shape})")
+
+        box_dtype = input.dtype
+        giou: torch.Tensor = box_pair_giou(  # type: ignore
+            target.to(dtype=COMPUTE_DTYPE), input.to(dtype=COMPUTE_DTYPE)
+        )
+        loss: torch.Tensor = 1.0 - giou
+        if self.reduction == LossReduction.MEAN.value:
+            loss = loss.mean()
+        elif self.reduction == LossReduction.SUM.value:
+            loss = loss.sum()
+        elif self.reduction == LossReduction.NONE.value:
+            pass
+        else:
+            raise ValueError(f'Unsupported reduction: {self.reduction}, available options are ["mean", "sum", "none"].')
+        return loss.to(box_dtype)
+
+
+giou = BoxGIoULoss

source_code/SegMamba/monai/losses/tversky.py

@@ -0,0 +1,162 @@
+# Copyright (c) MONAI Consortium
+# 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.
+
+from __future__ import annotations
+
+import warnings
+from collections.abc import Callable
+
+import torch
+from torch.nn.modules.loss import _Loss
+
+from monai.networks import one_hot
+from monai.utils import LossReduction
+
+
+class TverskyLoss(_Loss):
+    """
+    Compute the Tversky loss defined in:
+
+        Sadegh et al. (2017) Tversky loss function for image segmentation
+        using 3D fully convolutional deep networks. (https://arxiv.org/abs/1706.05721)
+
+    Adapted from:
+        https://github.com/NifTK/NiftyNet/blob/v0.6.0/niftynet/layer/loss_segmentation.py#L631
+
+    """
+
+    def __init__(
+        self,
+        include_background: bool = True,
+        to_onehot_y: bool = False,
+        sigmoid: bool = False,
+        softmax: bool = False,
+        other_act: Callable | None = None,
+        alpha: float = 0.5,
+        beta: float = 0.5,
+        reduction: LossReduction | str = LossReduction.MEAN,
+        smooth_nr: float = 1e-5,
+        smooth_dr: float = 1e-5,
+        batch: bool = False,
+    ) -> None:
+        """
+        Args:
+            include_background: If False channel index 0 (background category) is excluded from the calculation.
+            to_onehot_y: whether to convert `y` into the one-hot format. Defaults to False.
+            sigmoid: If True, apply a sigmoid function to the prediction.
+            softmax: If True, apply a softmax function to the prediction.
+            other_act: if don't want to use `sigmoid` or `softmax`, use other callable function to execute
+                other activation layers, Defaults to ``None``. for example:
+                `other_act = torch.tanh`.
+            alpha: weight of false positives
+            beta: weight of false negatives
+            reduction: {``"none"``, ``"mean"``, ``"sum"``}
+                Specifies the reduction to apply to the output. Defaults to ``"mean"``.
+
+                - ``"none"``: no reduction will be applied.
+                - ``"mean"``: the sum of the output will be divided by the number of elements in the output.
+                - ``"sum"``: the output will be summed.
+
+            smooth_nr: a small constant added to the numerator to avoid zero.
+            smooth_dr: a small constant added to the denominator to avoid nan.
+            batch: whether to sum the intersection and union areas over the batch dimension before the dividing.
+                Defaults to False, a Dice loss value is computed independently from each item in the batch
+                before any `reduction`.
+
+        Raises:
+            TypeError: When ``other_act`` is not an ``Optional[Callable]``.
+            ValueError: When more than 1 of [``sigmoid=True``, ``softmax=True``, ``other_act is not None``].
+                Incompatible values.
+
+        """
+
+        super().__init__(reduction=LossReduction(reduction).value)
+        if other_act is not None and not callable(other_act):
+            raise TypeError(f"other_act must be None or callable but is {type(other_act).__name__}.")
+        if int(sigmoid) + int(softmax) + int(other_act is not None) > 1:
+            raise ValueError("Incompatible values: more than 1 of [sigmoid=True, softmax=True, other_act is not None].")
+        self.include_background = include_background
+        self.to_onehot_y = to_onehot_y
+        self.sigmoid = sigmoid
+        self.softmax = softmax
+        self.other_act = other_act
+        self.alpha = alpha
+        self.beta = beta
+        self.smooth_nr = float(smooth_nr)
+        self.smooth_dr = float(smooth_dr)
+        self.batch = batch
+
+    def forward(self, input: torch.Tensor, target: torch.Tensor) -> torch.Tensor:
+        """
+        Args:
+            input: the shape should be BNH[WD].
+            target: the shape should be BNH[WD].
+
+        Raises:
+            ValueError: When ``self.reduction`` is not one of ["mean", "sum", "none"].
+
+        """
+        if self.sigmoid:
+            input = torch.sigmoid(input)
+
+        n_pred_ch = input.shape[1]
+        if self.softmax:
+            if n_pred_ch == 1:
+                warnings.warn("single channel prediction, `softmax=True` ignored.")
+            else:
+                input = torch.softmax(input, 1)
+
+        if self.other_act is not None:
+            input = self.other_act(input)
+
+        if self.to_onehot_y:
+            if n_pred_ch == 1:
+                warnings.warn("single channel prediction, `to_onehot_y=True` ignored.")
+            else:
+                target = one_hot(target, num_classes=n_pred_ch)
+
+        if not self.include_background:
+            if n_pred_ch == 1:
+                warnings.warn("single channel prediction, `include_background=False` ignored.")
+            else:
+                # if skipping background, removing first channel
+                target = target[:, 1:]
+                input = input[:, 1:]
+
+        if target.shape != input.shape:
+            raise AssertionError(f"ground truth has differing shape ({target.shape}) from input ({input.shape})")
+
+        p0 = input
+        p1 = 1 - p0
+        g0 = target
+        g1 = 1 - g0
+
+        # reducing only spatial dimensions (not batch nor channels)
+        reduce_axis: list[int] = torch.arange(2, len(input.shape)).tolist()
+        if self.batch:
+            # reducing spatial dimensions and batch
+            reduce_axis = [0] + reduce_axis
+
+        tp = torch.sum(p0 * g0, reduce_axis)
+        fp = self.alpha * torch.sum(p0 * g1, reduce_axis)
+        fn = self.beta * torch.sum(p1 * g0, reduce_axis)
+        numerator = tp + self.smooth_nr
+        denominator = tp + fp + fn + self.smooth_dr
+
+        score: torch.Tensor = 1.0 - numerator / denominator
+
+        if self.reduction == LossReduction.SUM.value:
+            return torch.sum(score)  # sum over the batch and channel dims
+        if self.reduction == LossReduction.NONE.value:
+            return score  # returns [N, num_classes] losses
+        if self.reduction == LossReduction.MEAN.value:
+            return torch.mean(score)
+        raise ValueError(f'Unsupported reduction: {self.reduction}, available options are ["mean", "sum", "none"].')