code: def _clip_poly(poly, plane, normal, axis):
      """Clips the polygon with the plane using the Sutherland-Hodgman algorithm.
  
      See https://en.wikipedia.org/wiki/Sutherland%E2%80%93Hodgman_algorithm for
      an overview of the Sutherland-Hodgman algorithm. Here we adopted a robust
      implementation from "Real-Time Collision Detection", by Christer Ericson,
      page 370.
  
      Args:
          poly: list of 3D vertices defining the polygon
          plane: the 3D vertices of the (2D) axis-aligned plane
          normal: normal
          axis: a tuple defining a 2D axis
  
      Returns:
          the list of 3D vertices of the clipped polygon
      """
      result = []
  
      if len(poly) <= 1:
          return result
  
      # polygon is fully located on clipping plane
      poly_in_plane = True
  
      # Test all the edges in the polygon against the clipping plane.
      for i, current_poly_point in enumerate(poly):
          prev_poly_point = poly[(i + len(poly) - 1) % len(poly)]
          d1 = _classify_point_to_plane(
              prev_poly_point, plane, normal, axis
          )
          d2 = _classify_point_to_plane(
              current_poly_point, plane, normal, axis
          )
          if d2 == _POINT_BEHIND_PLANE:
              poly_in_plane = False
              if d1 == _POINT_IN_FRONT_OF_PLANE:
                  intersection = _intersect(
                      plane, prev_poly_point, current_poly_point, axis
                  )
                  result.append(intersection)
              elif d1 == _POINT_ON_PLANE:
                  if not result or (
                      not np.array_equal(result[-1], prev_poly_point)
                  ):
                      result.append(prev_poly_point)
          elif d2 == _POINT_IN_FRONT_OF_PLANE:
              poly_in_plane = False
              if d1 == _POINT_BEHIND_PLANE:
                  intersection = _intersect(
                      plane, prev_poly_point, current_poly_point, axis
                  )
                  result.append(intersection)
              elif d1 == _POINT_ON_PLANE:
                  if not result or (
                      not np.array_equal(result[-1], prev_poly_point)
                  ):
                      result.append(prev_poly_point)
  
              result.append(current_poly_point)
          else:
              if d1 != _POINT_ON_PLANE:
                  result.append(current_poly_point)
  
      if poly_in_plane:
          return poly
  
      return result
  
imports: import itertools
  import logging
  import warnings
  import numpy
  import scipy.spatial
  import eta.core.numutils
  import fiftyone.core.fields
  import fiftyone.core.labels
  import fiftyone.core.media
  from fiftyone.core.sample import Sample
  import fiftyone.core.utils
  import fiftyone.core.validation
  from fiftyone.core.odm import DynamicEmbeddedDocument
  import fiftyone.utils.image
label_desc: Use image node_id 4 for calling a global function with example usage: _clip_poly(poly, plane, normal, axis) and returns: result, result, poly