class_docstr: Class for storing and operating on 3D mesh data.
  
  Parameters
  ----------
  vertices : ndarray, shape (Nv, 3)
      Vertex coordinates. If faces is not specified, then this will
      instead be interpreted as (Nf, 3, 3) array of coordinates.
  faces : ndarray, shape (Nf, 3)
      Indices into the vertex array.
  edges : None
      [not available yet]
  vertex_colors : ndarray, shape (Nv, 4)
      Vertex colors. If faces is not specified, this will be
      interpreted as (Nf, 3, 4) array of colors.
  face_colors : ndarray, shape (Nf, 4)
      Face colors.
  vertex_values : ndarray, shape (Nv,)
      Vertex values.
  
  Notes
  -----
  All arguments are optional.
  
  The object may contain:
  
  - list of vertex locations
  - list of edges
  - list of triangles
  - colors per vertex, edge, or tri
  - normals per vertex or tri
  
  This class handles conversion between the standard
  [list of vertices, list of faces] format (suitable for use with
  glDrawElements) and 'indexed' [list of vertices] format (suitable
  for use with glDrawArrays). It will automatically compute face normal
  vectors as well as averaged vertex normal vectors.
  
  The class attempts to be as efficient as possible in caching conversion
  results and avoiding unnecessary conversions.
code: def __init__(
      self,
      vertices=None,
      faces=None,
      edges=None,
      vertex_colors=None,
      face_colors=None,
      vertex_values=None,
  ):
      self._vertices = None  # (Nv,3) array of vertex coordinates
      self._vertices_indexed_by_faces = (
          None  # (Nf, 3, 3) vertex coordinates
      )
      self._vertices_indexed_by_edges = (
          None  # (Ne, 2, 3) vertex coordinates
      )
  
      # mappings between vertices, faces, and edges
      self._faces = (
          None  # Nx3 indices into self._vertices, 3 verts/face
      )
      self._edges = (
          None  # Nx2 indices into self._vertices, 2 verts/edge
      )
      self._edges_indexed_by_faces = None  # (Ne, 3, 2) indices into
      # self._vertices, 3 edge / face and 2 verts/edge
      # inverse mappings
      self._vertex_faces = None  # maps vertex ID to a list of face IDs
      self._vertex_edges = None  # maps vertex ID to a list of edge IDs
  
      # Per-vertex data
      self._vertex_normals = None  # (Nv, 3) normals
      self._vertex_normals_indexed_by_faces = None  # (Nf, 3, 3) normals
      self._vertex_colors = None  # (Nv, 4) colors
      self._vertex_colors_indexed_by_faces = None  # (Nf, 3, 4) colors
      self._vertex_colors_indexed_by_edges = None  # (Nf, 2, 4) colors
      self._vertex_values = None  # (Nv,) values
      self._vertex_values_indexed_by_faces = None  # (Nv, 3) values
      self._vertex_values_indexed_by_edges = None  # (Nv, 2) values
  
      # Per-face data
      self._face_normals = None  # (Nf, 3) face normals
      self._face_normals_indexed_by_faces = (
          None  # (Nf, 3, 3) face normals
      )
      self._face_colors = None  # (Nf, 4) face colors
      self._face_colors_indexed_by_faces = (
          None  # (Nf, 3, 4) face colors
      )
      self._face_colors_indexed_by_edges = (
          None  # (Ne, 2, 4) face colors
      )
  
      # Per-edge data
      self._edge_colors = None  # (Ne, 4) edge colors
      self._edge_colors_indexed_by_edges = (
          None  # (Ne, 2, 4) edge colors
      )
      if vertices is not None:
          indexed = "faces" if faces is None else None
          self.set_vertices(vertices, indexed=indexed)
          if faces is not None:
              self.set_faces(faces)
          if vertex_colors is not None:
              self.set_vertex_colors(vertex_colors, indexed=indexed)
          if face_colors is not None:
              self.set_face_colors(face_colors, indexed=indexed)
          if vertex_values is not None:
              self.set_vertex_values(vertex_values, indexed=indexed)
  
imports: import numpy
label_desc: Use image node_id 1 to create a new MeshData object from inherited base classes: object with example: obj = MeshData(vertices, faces, edges, vertex_colors, face_colors, vertex_values)