class_docstr: A series of possibly disconnected, possibly closed, line and curve
  segments.
  
  The underlying storage is made up of two parallel numpy arrays:
  
  - *vertices*: an (N, 2) float array of vertices
  - *codes*: an N-length `numpy.uint8` array of path codes, or None
  
  These two arrays always have the same length in the first
  dimension.  For example, to represent a cubic curve, you must
  provide three vertices and three `CURVE4` codes.
  
  The code types are:
  
  - `STOP`   :  1 vertex (ignored)
      A marker for the end of the entire path (currently not required and
      ignored)
  
  - `MOVETO` :  1 vertex
      Pick up the pen and move to the given vertex.
  
  - `LINETO` :  1 vertex
      Draw a line from the current position to the given vertex.
  
  - `CURVE3` :  1 control point, 1 endpoint
      Draw a quadratic Bézier curve from the current position, with the given
      control point, to the given end point.
  
  - `CURVE4` :  2 control points, 1 endpoint
      Draw a cubic Bézier curve from the current position, with the given
      control points, to the given end point.
  
  - `CLOSEPOLY` : 1 vertex (ignored)
      Draw a line segment to the start point of the current polyline.
  
  If *codes* is None, it is interpreted as a `MOVETO` followed by a series
  of `LINETO`.
  
  Users of Path objects should not access the vertices and codes arrays
  directly.  Instead, they should use `iter_segments` or `cleaned` to get the
  vertex/code pairs.  This helps, in particular, to consistently handle the
  case of *codes* being None.
  
  Some behavior of Path objects can be controlled by rcParams. See the
  rcParams whose keys start with 'path.'.
  
  .. note::
  
      The vertices and codes arrays should be treated as
      immutable -- there are a number of optimizations and assumptions
      made up front in the constructor that will not change when the
      data changes.
docstr: Get Bbox of the path.
  
  Parameters
  ----------
  transform : `~matplotlib.transforms.Transform`, optional
      Transform to apply to path before computing extents, if any.
  **kwargs
      Forwarded to `.iter_bezier`.
  
  Returns
  -------
  matplotlib.transforms.Bbox
      The extents of the path Bbox([[xmin, ymin], [xmax, ymax]])
docstr_tok: ["Get","Bbox","of","the","path",".","Parameters","--","--","--","--","--","transform",":","`","~matplotlib.transforms.Transform","`",",","optional","Transform","to","apply","to","path","before","computing","extents",",","if","any",".","*","*","kwargs","Forwarded","to","`",".iter_bezier","`",".","Returns","--","--","--","-","matplotlib.transforms.Bbox","The","extents","of","the","path","Bbox","(","[","[","xmin",",","ymin","]",",","[","xmax",",","ymax","]","]",")"]
code: def get_extents(self, transform=None, **kwargs):
      """
      Get Bbox of the path.
  
      Parameters
      ----------
      transform : `~matplotlib.transforms.Transform`, optional
          Transform to apply to path before computing extents, if any.
      **kwargs
          Forwarded to `.iter_bezier`.
  
      Returns
      -------
      matplotlib.transforms.Bbox
          The extents of the path Bbox([[xmin, ymin], [xmax, ymax]])
      """
      from .transforms import Bbox
  
      if transform is not None:
          self = transform.transform_path(self)
      if self.codes is None:
          xys = self.vertices
      elif (
          len(np.intersect1d(self.codes, [Path.CURVE3, Path.CURVE4]))
          == 0
      ):
          # Optimization for the straight line case.
          # Instead of iterating through each curve, consider
          # each line segment's end-points
          # (recall that STOP and CLOSEPOLY vertices are ignored)
          xys = self.vertices[
              np.isin(self.codes, [Path.MOVETO, Path.LINETO])
          ]
      else:
          xys = []
          for curve, code in self.iter_bezier(**kwargs):
              # places where the derivative is zero can be extrema
              _, dzeros = curve.axis_aligned_extrema()
              # as can the ends of the curve
              xys.append(curve([0, *dzeros, 1]))
          xys = np.concatenate(xys)
      if len(xys):
          return Bbox([xys.min(axis=0), xys.max(axis=0)])
      else:
          return Bbox.null()
  
imports: import copy
  from functools import lru_cache
  from weakref import WeakValueDictionary
  import numpy
  import matplotlib
  from .None import _api, _path
  from .cbook import _to_unmasked_float_array, simple_linear_interpolation
  from .bezier import BezierSegment
label_desc: Use image node_id 28 for calling the Path obj's underlying member method code with example usage: obj.get_extents(transform) and returns: Bbox, Bbox