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: Return a new path resampled to length N x *steps*.
  
  Codes other than `LINETO` are not handled correctly.
docstr_tok: ["Return","a","new","path","resampled","to","length","N","x","*","steps","*",".","Codes","other","than","`","LINETO","`","are","not","handled","correctly","."]
code: def interpolated(self, steps):
      """
      Return a new path resampled to length N x *steps*.
  
      Codes other than `LINETO` are not handled correctly.
      """
      if steps == 1:
          return self
  
      vertices = simple_linear_interpolation(self.vertices, steps)
      codes = self.codes
      if codes is not None:
          new_codes = np.full(
              (len(codes) - 1) * steps + 1,
              Path.LINETO,
              dtype=self.code_type,
          )
          new_codes[0::steps] = codes
      else:
          new_codes = None
      return Path(vertices, new_codes)
  
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 31 for calling the Path obj's underlying member method code with example usage: obj.interpolated(steps) and returns: Path, self