code: def requires_interp(matrix, atol=AFFINE_TOL):
      """
      Check whether the transformation matrix suggests voxel-wise interpolation.
  
      Returns None if the affine matrix suggests interpolation.
      Otherwise, the matrix suggests that the resampling could be achieved by simple array operations
      such as flip/permute/pad_nd/slice; in this case this function returns axes information about simple axes
      operations.
  
      Args:
          matrix: the affine matrix to check.
          atol: absolute tolerance for checking if the matrix is close to an integer.
      """
      matrix = convert_to_numpy(matrix, wrap_sequence=True)
      s = matrix[:, -1]
      if not np.allclose(s, np.round(s), atol=atol):
          return None
  
      ndim = len(matrix) - 1
      ox, oy = [], [0]
      for x, r in enumerate(matrix[:ndim, :ndim]):
          for y, c in enumerate(r):
              if np.isclose(c, -1, atol=atol) or np.isclose(
                  c, 1, atol=atol
              ):
                  y_channel = (
                      y + 1
                  )  # the returned axis index starting with channel dim
                  if x in ox or y_channel in oy:
                      return None
                  ox.append(x)
                  oy.append(y_channel)
              elif not np.isclose(c, 0.0, atol=atol):
                  return None
      return oy
  
imports: from __future__ import annotations
  import warnings
  import numpy
  import torch
  import monai
  from monai.config import NdarrayOrTensor
  from monai.data.utils import AFFINE_TOL
  from monai.transforms.utils_pytorch_numpy_unification import allclose
  from monai.utils import LazyAttr, convert_to_numpy, convert_to_tensor, look_up_option
label_desc: Use image node_id 5 for calling a global function with example usage: requires_interp(matrix, atol) and returns: oy, None, None, None