code: def blur_gaussian_(
      image, sigma, ksize=None, backend="auto", eps=1e-3
  ):
      """Blur an image using gaussian blurring in-place.
  
      This operation *may* change the input image in-place.
  
      **Supported dtypes**:
  
      if (backend="auto"):
  
          * ``uint8``: yes; fully tested (1)
          * ``uint16``: yes; tested (1)
          * ``uint32``: yes; tested (2)
          * ``uint64``: yes; tested (2)
          * ``int8``: yes; tested (1)
          * ``int16``: yes; tested (1)
          * ``int32``: yes; tested (1)
          * ``int64``: yes; tested (2)
          * ``float16``: yes; tested (1)
          * ``float32``: yes; tested (1)
          * ``float64``: yes; tested (1)
          * ``float128``: no
          * ``bool``: yes; tested (1)
  
          - (1) Handled by ``cv2``. See ``backend="cv2"``.
          - (2) Handled by ``scipy``. See ``backend="scipy"``.
  
      if (backend="cv2"):
  
          * ``uint8``: yes; fully tested
          * ``uint16``: yes; tested
          * ``uint32``: no (2)
          * ``uint64``: no (3)
          * ``int8``: yes; tested (4)
          * ``int16``: yes; tested
          * ``int32``: yes; tested (5)
          * ``int64``: no (6)
          * ``float16``: yes; tested (7)
          * ``float32``: yes; tested
          * ``float64``: yes; tested
          * ``float128``: no (8)
          * ``bool``: yes; tested (1)
  
          - (1) Mapped internally to ``float32``. Otherwise causes
                ``TypeError: src data type = 0 is not supported``.
          - (2) Causes ``TypeError: src data type = 6 is not supported``.
          - (3) Causes ``cv2.error: OpenCV(3.4.5) (...)/filter.cpp:2957:
                error: (-213:The function/feature is not implemented)
                Unsupported combination of source format (=4), and buffer
                format (=5) in function 'getLinearRowFilter'``.
          - (4) Mapped internally to ``int16``. Otherwise causes
                ``cv2.error: OpenCV(3.4.5) (...)/filter.cpp:2957: error:
                (-213:The function/feature is not implemented) Unsupported
                combination of source format (=1), and buffer format (=5)
                in function 'getLinearRowFilter'``.
          - (5) Mapped internally to ``float64``. Otherwise causes
                ``cv2.error: OpenCV(3.4.5) (...)/filter.cpp:2957: error:
                (-213:The function/feature is not implemented) Unsupported
                combination of source format (=4), and buffer format (=5)
                in function 'getLinearRowFilter'``.
          - (6) Causes ``cv2.error: OpenCV(3.4.5) (...)/filter.cpp:2957:
                error: (-213:The function/feature is not implemented)
                Unsupported combination of source format (=4), and buffer
                format (=5) in function 'getLinearRowFilter'``.
          - (7) Mapped internally to ``float32``. Otherwise causes
                ``TypeError: src data type = 23 is not supported``.
          - (8) Causes ``TypeError: src data type = 13 is not supported``.
  
      if (backend="scipy"):
  
          * ``uint8``: yes; fully tested
          * ``uint16``: yes; tested
          * ``uint32``: yes; tested
          * ``uint64``: yes; tested
          * ``int8``: yes; tested
          * ``int16``: yes; tested
          * ``int32``: yes; tested
          * ``int64``: yes; tested
          * ``float16``: yes; tested (1)
          * ``float32``: yes; tested
          * ``float64``: yes; tested
          * ``float128``: no (2)
          * ``bool``: yes; tested (3)
  
          - (1) Mapped internally to ``float32``. Otherwise causes
                ``RuntimeError: array type dtype('float16') not supported``.
          - (2) Causes ``RuntimeError: array type dtype('float128') not
                supported``.
          - (3) Mapped internally to ``float32``. Otherwise too inaccurate.
  
      Parameters
      ----------
      image : numpy.ndarray
          The image to blur. Expected to be of shape ``(H, W)`` or ``(H, W, C)``.
  
      sigma : number
          Standard deviation of the gaussian blur. Larger numbers result in
          more large-scale blurring, which is overall slower than small-scale
          blurring.
  
      ksize : None or int, optional
          Size in height/width of the gaussian kernel. This argument is only
          understood by the ``cv2`` backend. If it is set to ``None``, an
          appropriate value for `ksize` will automatically be derived from
          `sigma`. The value is chosen tighter for larger sigmas to avoid as
          much as possible very large kernel sizes and therey improve
          performance.
  
      backend : {'auto', 'cv2', 'scipy'}, optional
          Backend library to use. If ``auto``, then the likely best library
          will be automatically picked per image. That is usually equivalent
          to ``cv2`` (OpenCV) and it will fall back to ``scipy`` for datatypes
          not supported by OpenCV.
  
      eps : number, optional
          A threshold used to decide whether `sigma` can be considered zero.
  
      Returns
      -------
      numpy.ndarray
          The blurred image. Same shape and dtype as the input.
          (Input image *might* have been altered in-place.)
  
      """
      if image.size == 0:
          return image
  
      if sigma < eps:
          return image
  
      iadt.gate_dtypes_strs(
          {image.dtype},
          allowed="bool uint8 uint16 uint32 "
          "int8 int16 int32 int64 "
          "uint64 "
          "float16 float32 float64",
          disallowed="float128",
          augmenter=None,
      )
  
      dts_not_supported_by_cv2 = iadt._convert_dtype_strs_to_types(
          "uint32 uint64 int64 float128"
      )
      backend_to_use = backend
      if backend == "auto":
          backend_to_use = (
              "cv2"
              if image.dtype not in dts_not_supported_by_cv2
              else "scipy"
          )
      elif backend == "cv2":
          assert image.dtype not in dts_not_supported_by_cv2, (
              "Requested 'cv2' backend, but provided %s input image, which "
              "cannot be handled by that backend. Choose a different "
              "backend or set backend to 'auto' or use a different "
              "datatype." % (image.dtype.name,)
          )
      elif backend == "scipy":
          # can handle all dtypes that were allowed in gate_dtypes()
          pass
  
      if backend_to_use == "scipy":
          image = _blur_gaussian_scipy_(image, sigma, ksize)
      else:
          image = _blur_gaussian_cv2(image, sigma, ksize)
  
      return image
  
imports: from __future__ import print_function, division, absolute_import
  import numpy
  from scipy import ndimage
  import cv2
  import six.moves
  import imgaug
  from imgaug.imgaug import _normalize_cv2_input_arr_
  from .None import meta
  from .None import convolutional
  from ..None import parameters
  from ..None import dtypes
label_desc: Use image node_id 1 for calling a global function with example usage: blur_gaussian_(image, sigma, ksize, backend, eps) and returns: image, image, image