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: Iterate over each Bézier curve (lines included) in a `Path`.
  
  Parameters
  ----------
  **kwargs
      Forwarded to `.iter_segments`.
  
  Yields
  ------
  B : `~matplotlib.bezier.BezierSegment`
      The Bézier curves that make up the current path. Note in particular
      that freestanding points are Bézier curves of order 0, and lines
      are Bézier curves of order 1 (with two control points).
  code : `~matplotlib.path.Path.code_type`
      The code describing what kind of curve is being returned.
      `MOVETO`, `LINETO`, `CURVE3`, and `CURVE4` correspond to
      Bézier curves with 1, 2, 3, and 4 control points (respectively).
      `CLOSEPOLY` is a `LINETO` with the control points correctly
      chosen based on the start/end points of the current stroke.
docstr_tok: ["Iterate","over","each","B\u00e9zier","curve","(","lines","included",")","in","a","`","Path","`",".","Parameters","--","--","--","--","--","*","*","kwargs","Forwarded","to","`",".iter_segments","`",".","Yields","--","--","--","B",":","`","~matplotlib.bezier.BezierSegment","`","The","B\u00e9zier","curves","that","make","up","the","current","path",".","Note","in","particular","that","freestanding","points","are","B\u00e9zier","curves","of","order","0",",","and","lines","are","B\u00e9zier","curves","of","order","1","(","with","two","control","points",")",".","code",":","`","~matplotlib.path.Path.code_type","`","The","code","describing","what","kind","of","curve","is","being","returned",".","`","MOVETO","`",",","`","LINETO","`",",","`","CURVE3","`",",","and","`","CURVE4","`","correspond","to","B\u00e9zier","curves","with","1",",","2",",","3",",","and","4","control","points","(","respectively",")",".","`","CLOSEPOLY","`","is","a","`","LINETO","`","with","the","control","points","correctly","chosen","based","on","the","start\/end","points","of","the","current","stroke","."]
code: def iter_bezier(self, **kwargs):
      """
      Iterate over each Bézier curve (lines included) in a `Path`.
  
      Parameters
      ----------
      **kwargs
          Forwarded to `.iter_segments`.
  
      Yields
      ------
      B : `~matplotlib.bezier.BezierSegment`
          The Bézier curves that make up the current path. Note in particular
          that freestanding points are Bézier curves of order 0, and lines
          are Bézier curves of order 1 (with two control points).
      code : `~matplotlib.path.Path.code_type`
          The code describing what kind of curve is being returned.
          `MOVETO`, `LINETO`, `CURVE3`, and `CURVE4` correspond to
          Bézier curves with 1, 2, 3, and 4 control points (respectively).
          `CLOSEPOLY` is a `LINETO` with the control points correctly
          chosen based on the start/end points of the current stroke.
      """
      first_vert = None
      prev_vert = None
      for verts, code in self.iter_segments(**kwargs):
          if first_vert is None:
              if code != Path.MOVETO:
                  raise ValueError(
                      "Malformed path, must start with MOVETO."
                  )
          if code == Path.MOVETO:  # a point is like "CURVE1"
              first_vert = verts
              yield BezierSegment(np.array([first_vert])), code
          elif code == Path.LINETO:  # "CURVE2"
              yield BezierSegment(np.array([prev_vert, verts])), code
          elif code == Path.CURVE3:
              yield BezierSegment(
                  np.array([prev_vert, verts[:2], verts[2:]])
              ), code
          elif code == Path.CURVE4:
              yield BezierSegment(
                  np.array(
                      [prev_vert, verts[:2], verts[2:4], verts[4:]]
                  )
              ), code
          elif code == Path.CLOSEPOLY:
              yield BezierSegment(
                  np.array([prev_vert, first_vert])
              ), code
          elif code == Path.STOP:
              return
          else:
              raise ValueError(f"Invalid Path.code_type: {code}")
          prev_vert = verts[-2:]
  
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 21 for calling the Path obj's underlying member method code with example usage: obj.iter_bezier() without return types