Gamma

def forward(self, data: Any) -> Any:
    """Apply the transform.

    The output type always matches the input type.

    Args:
        data: Input data to transform.
    """
    return self._execute(data, params=None, sample_params=True)

def apply_with_params(
    self,
    data: Any,
    params: dict[str, Any],
) -> Any:
    """Apply an exact parameter set without sampling.

    This method bypasses the transform probability and
    [`make_params()`][torchio.Transform.make_params], but otherwise
    follows the normal transform lifecycle: copy handling, input
    wrapping, output-type restoration, and history recording.

    Args:
        data: Input data to transform.
        params: Exact parameters accepted by `apply_transform`.

    Returns:
        Transformed data with the same type as the input.

    Raises:
        TypeError: If `params` is not a dictionary.
        NotImplementedError: If the transform does not expose one
            exact-parameter kernel.
        ValueError: If per-instance parameter dimensions do not
            match the input batch.
    """
    if not self._supports_apply_with_params:
        msg = (
            f"{type(self).__name__}.apply_with_params() is not supported"
            " because this transform does not expose a single"
            " make_params/apply_transform parameter kernel."
        )
        raise NotImplementedError(msg)
    if not isinstance(params, dict):
        msg = f"Expected params to be a dict, got {type(params).__name__}"
        raise TypeError(msg)
    return self._execute(
        data,
        params=_copy.deepcopy(params),
        sample_params=False,
    )

def to_hydra(self) -> dict[str, Any]:
    """Export as a Hydra-compatible config dict.

    Returns a dict with `_target_` set to the fully qualified
    class name and only non-default field values included.

    Returns:
        Dict suitable for `hydra.utils.instantiate()`.
    """
    from .parameter_range import _ParameterRange

    cls = type(self)
    target = f"torchio.{cls.__qualname__}"
    cfg: dict[str, Any] = {"_target_": target}

    for name, default in _collect_init_params(cls).items():
        value = getattr(self, name, default)
        if isinstance(value, _ParameterRange):
            if value._original == default:
                continue
            value = _hydra_value(value._original)
        elif value == default:
            continue
        else:
            value = _hydra_value(value)
        cfg[name] = value
    return cfg

def make_params(self, batch: SubjectsBatch) -> dict[str, Any]:
    """Sample the log-gamma value (per element when per-instance)."""
    n = self._resolve_n(batch)
    keep = self._keep_mask(batch, n)
    log_gamma = self.log_gamma.sample_1d(n)
    log_gamma = self._mask_identity(log_gamma, keep, identity=0.0)
    params = {"log_gamma": self._serialize_param(log_gamma)}
    self._tag_batched(params, batch, n, keep, ["log_gamma"])
    return params

def apply_transform(
    self,
    batch: SubjectsBatch,
    params: dict[str, Any],
) -> SubjectsBatch:
    """Raise each intensity image to the power gamma."""
    log_gamma = params["log_gamma"]
    for _name, img_batch in self._get_images(batch).items():
        gamma = _gamma_from_log(log_gamma, img_batch.data)
        data = img_batch.data
        img_batch.data = data.sign() * data.abs().pow(gamma)
    return batch

def inverse(self, params: dict[str, Any]) -> _GammaInverse:
    """Invert by applying 1/gamma."""
    return _GammaInverse(log_gamma=params["log_gamma"], copy=False)