code: def normalize_bounding_boxes(inputs, shapes=None):
      # TODO get rid of this deferred import
      from imgaug.augmentables.bbs import (
          BoundingBox,
          BoundingBoxesOnImage,
      )
  
      shapes = _preprocess_shapes(shapes)
      ntype = estimate_bounding_boxes_norm_type(inputs)
      _assert_exactly_n_shapes_partial = functools.partial(
          _assert_exactly_n_shapes,
          from_ntype=ntype,
          to_ntype="List[BoundingBoxesOnImage]",
          shapes=shapes,
      )
  
      if ntype == "None":
          return None
      if ntype in ["array[float]", "array[int]", "array[uint]"]:
          _assert_single_array_ndim(
              inputs, 3, "(N,B,4)", "BoundingBoxesOnImage"
          )
          _assert_single_array_last_dim_exactly(
              inputs, 4, "BoundingBoxesOnImage"
          )
          _assert_exactly_n_shapes_partial(n=len(inputs))
          return [
              BoundingBoxesOnImage.from_xyxy_array(attr_i, shape=shape)
              for attr_i, shape in zip(inputs, shapes)
          ]
      if ntype == "tuple[number,size=4]":
          _assert_exactly_n_shapes_partial(n=1)
          return [
              BoundingBoxesOnImage(
                  [
                      BoundingBox(
                          x1=inputs[0],
                          y1=inputs[1],
                          x2=inputs[2],
                          y2=inputs[3],
                      )
                  ],
                  shape=shapes[0],
              )
          ]
      if ntype == "BoundingBox":
          _assert_exactly_n_shapes_partial(n=1)
          return [BoundingBoxesOnImage([inputs], shape=shapes[0])]
      if ntype == "BoundingBoxesOnImage":
          return [inputs]
      if ntype == "iterable[empty]":
          return None
      if ntype in [
          "iterable-array[float]",
          "iterable-array[int]",
          "iterable-array[uint]",
      ]:
          _assert_many_arrays_ndim(
              inputs, 2, "(B,4)", "BoundingBoxesOnImage"
          )
          _assert_many_arrays_last_dim_exactly(
              inputs, 4, "BoundingBoxesOnImage"
          )
          _assert_exactly_n_shapes_partial(n=len(inputs))
          return [
              BoundingBoxesOnImage.from_xyxy_array(attr_i, shape=shape)
              for attr_i, shape in zip(inputs, shapes)
          ]
      if ntype == "iterable-tuple[number,size=4]":
          _assert_exactly_n_shapes_partial(n=1)
          return [
              BoundingBoxesOnImage(
                  [
                      BoundingBox(x1=x1, y1=y1, x2=x2, y2=y2)
                      for x1, y1, x2, y2 in inputs
                  ],
                  shape=shapes[0],
              )
          ]
      if ntype == "iterable-BoundingBox":
          _assert_exactly_n_shapes_partial(n=1)
          return [BoundingBoxesOnImage(inputs, shape=shapes[0])]
      if ntype == "iterable-BoundingBoxesOnImage":
          return inputs
      if ntype == "iterable-iterable[empty]":
          return None
      if ntype == "iterable-iterable-tuple[number,size=4]":
          _assert_exactly_n_shapes_partial(n=len(inputs))
          return [
              BoundingBoxesOnImage.from_xyxy_array(
                  np.array(attr_i, dtype=np.float32), shape=shape
              )
              for attr_i, shape in zip(inputs, shapes)
          ]
  
      assert (
          ntype == "iterable-iterable-BoundingBox"
      ), "Got unknown normalization type '%s'." % (ntype,)
      _assert_exactly_n_shapes_partial(n=len(inputs))
      return [
          BoundingBoxesOnImage(attr_i, shape=shape)
          for attr_i, shape in zip(inputs, shapes)
      ]
  
imports: from __future__ import print_function, division, absolute_import
  import functools
  import numpy
  from ..None import imgaug
  from ..None import dtypes
  from .base import IAugmentable
label_desc: Use image node_id 11 for calling a global function with example usage: normalize_bounding_boxes(inputs, shapes) and returns: unknown, None, unknown, list, list, list, None, unknown, list, list, inputs, None, unknown