code: def generate_random(
      featureType,
      numberVertices=3,
      boundingBox=[-180.0, -90.0, 180.0, 90.0],
  ):
      """
      Generates random geojson features depending on the parameters
      passed through.
      The bounding box defaults to the world - [-180.0, -90.0, 180.0, 90.0].
      The number of vertices defaults to 3.
  
      :param featureType: A geometry type
      :type featureType: Point, LineString, Polygon
      :param numberVertices: The number vertices that a linestring or polygon
      will have
      :type numberVertices: int
      :param boundingBox: A bounding box in which features will be restricted to
      :type boundingBox: list
      :return: The resulting random geojson object or geometry collection.
      :rtype: object
      :raises ValueError: if there is no featureType provided.
      """
  
      from geojson import Point, LineString, Polygon
      import random
      import math
  
      lonMin = boundingBox[0]
      lonMax = boundingBox[2]
  
      def randomLon():
          return random.uniform(lonMin, lonMax)
  
      latMin = boundingBox[1]
      latMax = boundingBox[3]
  
      def randomLat():
          return random.uniform(latMin, latMax)
  
      def createPoint():
          return Point((randomLon(), randomLat()))
  
      def createLine():
          return LineString(
              [createPoint() for unused in range(numberVertices)]
          )
  
      def createPoly():
          aveRadius = 60
          ctrX = 0.1
          ctrY = 0.2
          irregularity = clip(0.1, 0, 1) * 2 * math.pi / numberVertices
          spikeyness = clip(0.5, 0, 1) * aveRadius
  
          angleSteps = []
          lower = (2 * math.pi / numberVertices) - irregularity
          upper = (2 * math.pi / numberVertices) + irregularity
          sum = 0
          for i in range(numberVertices):
              tmp = random.uniform(lower, upper)
              angleSteps.append(tmp)
              sum = sum + tmp
  
          k = sum / (2 * math.pi)
          for i in range(numberVertices):
              angleSteps[i] = angleSteps[i] / k
  
          points = []
          angle = random.uniform(0, 2 * math.pi)
  
          for i in range(numberVertices):
              r_i = clip(
                  random.gauss(aveRadius, spikeyness), 0, 2 * aveRadius
              )
              x = ctrX + r_i * math.cos(angle)
              y = ctrY + r_i * math.sin(angle)
              x = (x + 180.0) * (abs(lonMin - lonMax) / 360.0) + lonMin
              y = (y + 90.0) * (abs(latMin - latMax) / 180.0) + latMin
              x = clip(x, lonMin, lonMax)
              y = clip(y, latMin, latMax)
              points.append((x, y))
              angle = angle + angleSteps[i]
  
          firstVal = points[0]
          points.append(firstVal)
          return Polygon([points])
  
      def clip(x, min, max):
          if min > max:
              return x
          elif x < min:
              return min
          elif x > max:
              return max
          else:
              return x
  
      if featureType == "Point":
          return createPoint()
  
      if featureType == "LineString":
          return createLine()
  
      if featureType == "Polygon":
          return createPoly()
  
      raise ValueError(f"featureType: {featureType} is not supported.")
  
label_desc: Use image node_id 5 for calling a global function with example usage: generate_random(featureType, numberVertices, boundingBox) and returns: random, random, Point, LineString, Polygon, createPoint, createLine, createPoly, x, min, max, x