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 whether the area enclosed by the path contains the given point.
  
  The path is always treated as closed; i.e. if the last code is not
  `CLOSEPOLY` an implicit segment connecting the last vertex to the first
  vertex is assumed.
  
  Parameters
  ----------
  point : (float, float)
      The point (x, y) to check.
  transform : `~matplotlib.transforms.Transform`, optional
      If not ``None``, *point* will be compared to ``self`` transformed
      by *transform*; i.e. for a correct check, *transform* should
      transform the path into the coordinate system of *point*.
  radius : float, default: 0
      Additional margin on the path in coordinates of *point*.
      The path is extended tangentially by *radius/2*; i.e. if you would
      draw the path with a linewidth of *radius*, all points on the line
      would still be considered to be contained in the area. Conversely,
      negative values shrink the area: Points on the imaginary line
      will be considered outside the area.
  
  Returns
  -------
  bool
  
  Notes
  -----
  The current algorithm has some limitations:
  
  - The result is undefined for points exactly at the boundary
    (i.e. at the path shifted by *radius/2*).
  - The result is undefined if there is no enclosed area, i.e. all
    vertices are on a straight line.
  - If bounding lines start to cross each other due to *radius* shift,
    the result is not guaranteed to be correct.
docstr_tok: ["Return","whether","the","area","enclosed","by","the","path","contains","the","given","point",".","The","path","is","always","treated","as","closed",";","i.e",".","if","the","last","code","is","not","`","CLOSEPOLY","`","an","implicit","segment","connecting","the","last","vertex","to","the","first","vertex","is","assumed",".","Parameters","--","--","--","--","--","point",":","(","float",",","float",")","The","point","(","x",",","y",")","to","check",".","transform",":","`","~matplotlib.transforms.Transform","`",",","optional","If","not","``","None","``",",","*","point","*","will","be","compared","to","``","self","``","transformed","by","*","transform","*",";","i.e",".","for","a","correct","check",",","*","transform","*","should","transform","the","path","into","the","coordinate","system","of","*","point","*",".","radius",":","float",",","default",":","0","Additional","margin","on","the","path","in","coordinates","of","*","point","*",".","The","path","is","extended","tangentially","by","*","radius\/2","*",";","i.e",".","if","you","would","draw","the","path","with","a","linewidth","of","*","radius","*",",","all","points","on","the","line","would","still","be","considered","to","be","contained","in","the","area",".","Conversely",",","negative","values","shrink","the","area",":","Points","on","the","imaginary","line","will","be","considered","outside","the","area",".","Returns","--","--","--","-","bool","Notes","--","--","-","The","current","algorithm","has","some","limitations",":","-","The","result","is","undefined","for","points","exactly","at","the","boundary","(","i.e",".","at","the","path","shifted","by","*","radius\/2","*",")",".","-","The","result","is","undefined","if","there","is","no","enclosed","area",",","i.e",".","all","vertices","are","on","a","straight","line",".","-","If","bounding","lines","start","to","cross","each","other","due","to","*","radius","*","shift",",","the","result","is","not","guaranteed","to","be","correct","."]
code: def contains_point(self, point, transform=None, radius=0.0):
      """
      Return whether the area enclosed by the path contains the given point.
  
      The path is always treated as closed; i.e. if the last code is not
      `CLOSEPOLY` an implicit segment connecting the last vertex to the first
      vertex is assumed.
  
      Parameters
      ----------
      point : (float, float)
          The point (x, y) to check.
      transform : `~matplotlib.transforms.Transform`, optional
          If not ``None``, *point* will be compared to ``self`` transformed
          by *transform*; i.e. for a correct check, *transform* should
          transform the path into the coordinate system of *point*.
      radius : float, default: 0
          Additional margin on the path in coordinates of *point*.
          The path is extended tangentially by *radius/2*; i.e. if you would
          draw the path with a linewidth of *radius*, all points on the line
          would still be considered to be contained in the area. Conversely,
          negative values shrink the area: Points on the imaginary line
          will be considered outside the area.
  
      Returns
      -------
      bool
  
      Notes
      -----
      The current algorithm has some limitations:
  
      - The result is undefined for points exactly at the boundary
        (i.e. at the path shifted by *radius/2*).
      - The result is undefined if there is no enclosed area, i.e. all
        vertices are on a straight line.
      - If bounding lines start to cross each other due to *radius* shift,
        the result is not guaranteed to be correct.
      """
      if transform is not None:
          transform = transform.frozen()
      # `point_in_path` does not handle nonlinear transforms, so we
      # transform the path ourselves.  If *transform* is affine, letting
      # `point_in_path` handle the transform avoids allocating an extra
      # buffer.
      if transform and not transform.is_affine:
          self = transform.transform_path(self)
          transform = None
      return _path.point_in_path(
          point[0], point[1], radius, self, transform
      )
  
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 25 for calling the Path obj's underlying member method code with example usage: obj.contains_point(point, transform, radius) and returns: _path