code: def invert_normalize_keypoints(keypoints, keypoints_old):
      ntype = estimate_keypoints_norm_type(keypoints_old)
      if ntype == "None":
          assert keypoints is None, (
              "Expected (normalized) 'keypoints' to be None due (unnormalized) "
              "'keypoints_old' being None. Got type %s instead."
              % (type(keypoints),)
          )
          return keypoints
      if ntype in ["array[float]", "array[int]", "array[uint]"]:
          assert len(keypoints) == 1, (
              "Expected a single KeypointsOnImage instance after normalization "
              "due to getting a single ndarray before normalization. "
              "Got %d instances instead." % (len(keypoints),)
          )
          input_dtype = keypoints_old.dtype
          return restore_dtype_and_merge(
              [kpsoi.to_xy_array() for kpsoi in keypoints], input_dtype
          )
      if ntype == "tuple[number,size=2]":
          assert len(keypoints) == 1, (
              "Expected a single KeypointsOnImage instance after normalization "
              "due to getting a single (x,y) tuple before normalization. "
              "Got %d instances instead." % (len(keypoints),)
          )
          assert len(keypoints[0].keypoints) == 1, (
              "Expected a KeypointsOnImage instance containing a single "
              "Keypoint after normalization due to getting a single (x,y) tuple "
              "before normalization. Got %d keypoints instead."
              % (len(keypoints[0].keypoints))
          )
          return (
              keypoints[0].keypoints[0].x,
              keypoints[0].keypoints[0].y,
          )
      if ntype == "Keypoint":
          assert len(keypoints) == 1, (
              "Expected a single KeypointsOnImage instance after normalization "
              "due to getting a single Keypoint before normalization. "
              "Got %d instances instead." % (len(keypoints),)
          )
          assert len(keypoints[0].keypoints) == 1, (
              "Expected a KeypointsOnImage instance containing a single "
              "Keypoint after normalization due to getting a single Keypoint "
              "before normalization. Got %d keypoints instead."
              % (len(keypoints[0].keypoints))
          )
          return keypoints[0].keypoints[0]
      if ntype == "KeypointsOnImage":
          assert len(keypoints) == 1, (
              "Expected a single KeypointsOnImage instance after normalization "
              "due to getting a single KeypointsOnImage before normalization. "
              "Got %d instances instead." % (len(keypoints),)
          )
          return keypoints[0]
      if ntype == "iterable[empty]":
          assert keypoints is None, (
              "Expected keypoints after normalization to be None, due "
              "to the keypoints before normalization being an empty "
              "iterable. Got type %s instead." % (type(keypoints),)
          )
          return []
      if ntype in [
          "iterable-array[float]",
          "iterable-array[int]",
          "iterable-array[uint]",
      ]:
          nonempty, _, _ = find_first_nonempty(keypoints_old)
          input_dtype = nonempty.dtype
          return [
              restore_dtype_and_merge(kps_i.to_xy_array(), input_dtype)
              for kps_i in keypoints
          ]
      if ntype == "iterable-tuple[number,size=2]":
          assert len(keypoints) == 1, (
              "Expected a single KeypointsOnImage instance after normalization "
              "due to getting an iterable of (x,y) tuples before "
              "normalization. Got %d instances instead."
              % (len(keypoints),)
          )
          return [(kp.x, kp.y) for kp in keypoints[0].keypoints]
      if ntype == "iterable-Keypoint":
          assert len(keypoints) == 1, (
              "Expected a single KeypointsOnImage instance after normalization "
              "due to getting an iterable of Keypoint before "
              "normalization. Got %d instances instead."
              % (len(keypoints),)
          )
          return keypoints[0].keypoints
      if ntype == "iterable-KeypointsOnImage":
          return keypoints
      if ntype == "iterable-iterable[empty]":
          assert keypoints is None, (
              "Expected keypoints after normalization to be None, due "
              "to the keypoints before normalization being an empty "
              "iterable of iterables. Got type %s instead."
              % (type(keypoints),)
          )
          return keypoints_old[:]
      if ntype == "iterable-iterable-tuple[number,size=2]":
          return [
              [(kp.x, kp.y) for kp in kpsoi.keypoints]
              for kpsoi in keypoints
          ]
  
      assert (
          ntype == "iterable-iterable-Keypoint"
      ), "Got unknown normalization type '%s'." % (ntype,)
      return [kpsoi.keypoints[:] for kpsoi in keypoints]
  
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 18 for calling a global function with example usage: invert_normalize_keypoints(keypoints, keypoints_old) and returns: unknown, keypoints, restore_dtype_and_merge, keypoints,  keypoints, keypoints, keypoints, list, unknown, unknown, keypoints, keypoints, keypoints_old, unknown