code: def _extract_hemispheric_difference(
      image,
      mask=slice(None),
      sigma_active=7,
      sigma_reference=7,
      cut_plane=0,
      voxelspacing=None,
  ):
      """
      Internal, single-image version of `hemispheric_difference`.
      """
      # constants
      INTERPOLATION_RANGE = int(
          10
      )  # how many neighbouring values to take into account when interpolating the medial longitudinal fissure slice
  
      # check arguments
      if cut_plane >= image.ndim:
          raise ArgumentError(
              "The suppliedc cut-plane ({}) is invalid, the image has only {} dimensions.".format(
                  cut_plane, image.ndim
              )
          )
  
      # set voxel spacing
      if voxelspacing is None:
          voxelspacing = [1.0] * image.ndim
  
      # compute the (presumed) location of the medial longitudinal fissure, treating also the special of an odd number of slices, in which case a cut into two equal halves is not possible
      medial_longitudinal_fissure = int(image.shape[cut_plane] / 2)
      medial_longitudinal_fissure_excluded = image.shape[cut_plane] % 2
  
      # split the head into a dexter and sinister half along the saggital plane
      # this is assumed to be consistent with a cut of the brain along the medial longitudinal fissure, thus separating it into its hemispheres
      slicer = [slice(None)] * image.ndim
      slicer[cut_plane] = slice(None, medial_longitudinal_fissure)
      left_hemisphere = image[slicer]
  
      slicer[cut_plane] = slice(
          medial_longitudinal_fissure
          + medial_longitudinal_fissure_excluded,
          None,
      )
      right_hemisphere = image[slicer]
  
      # flip right hemisphere image along cut plane
      slicer[cut_plane] = slice(None, None, -1)
      right_hemisphere = right_hemisphere[slicer]
  
      # substract once left from right and once right from left hemisphere, including smoothing steps
      right_hemisphere_difference = _substract_hemispheres(
          right_hemisphere,
          left_hemisphere,
          sigma_active,
          sigma_reference,
          voxelspacing,
      )
      left_hemisphere_difference = _substract_hemispheres(
          left_hemisphere,
          right_hemisphere,
          sigma_active,
          sigma_reference,
          voxelspacing,
      )
  
      # re-flip right hemisphere image to original orientation
      right_hemisphere_difference = right_hemisphere_difference[slicer]
  
      # estimate the medial longitudinal fissure if required
      if 1 == medial_longitudinal_fissure_excluded:
          left_slicer = [slice(None)] * image.ndim
          right_slicer = [slice(None)] * image.ndim
          left_slicer[cut_plane] = slice(-1 * INTERPOLATION_RANGE, None)
          right_slicer[cut_plane] = slice(None, INTERPOLATION_RANGE)
          interp_data_left = left_hemisphere_difference[left_slicer]
          interp_data_right = right_hemisphere_difference[right_slicer]
          interp_indices_left = list(
              range(-1 * interp_data_left.shape[cut_plane], 0)
          )
          interp_indices_right = list(
              range(1, interp_data_right.shape[cut_plane] + 1)
          )
          interp_data = numpy.concatenate(
              (
                  left_hemisphere_difference[left_slicer],
                  right_hemisphere_difference[right_slicer],
              ),
              cut_plane,
          )
          interp_indices = numpy.concatenate(
              (interp_indices_left, interp_indices_right), 0
          )
          medial_longitudinal_fissure_estimated = interp1d(
              interp_indices, interp_data, kind="cubic", axis=cut_plane
          )(0)
          # add singleton dimension
          slicer[cut_plane] = numpy.newaxis
          medial_longitudinal_fissure_estimated = (
              medial_longitudinal_fissure_estimated[slicer]
          )
  
      # stich images back together
      if 1 == medial_longitudinal_fissure_excluded:
          hemisphere_difference = numpy.concatenate(
              (
                  left_hemisphere_difference,
                  medial_longitudinal_fissure_estimated,
                  right_hemisphere_difference,
              ),
              cut_plane,
          )
      else:
          hemisphere_difference = numpy.concatenate(
              (left_hemisphere_difference, right_hemisphere_difference),
              cut_plane,
          )
  
      # extract intensities and return
      return _extract_intensities(hemisphere_difference, mask)
  
imports: import numpy
  from scipy.ndimage import gaussian_filter, median_filter
  from scipy.ndimage import gaussian_gradient_magnitude
  from scipy.interpolate.interpolate import interp1d
  from scipy.ndimage import distance_transform_edt
  from scipy.ndimage._ni_support import _get_output
  from .utilities import join
  from ..core import ArgumentError
  from ..filter import sum_filter
label_desc: Use image node_id 12 for calling a global function with example usage: _extract_hemispheric_difference(image, mask, sigma_active, sigma_reference, cut_plane, voxelspacing) and returns: _extract_intensities