docs: def cortex_plot_colors(the_map,
                         color=None, cmap=None, vmin=None, vmax=None, alpha=None,
                         underlay='curvature', mask=None):
      '''
      cortex_plot_colors(mesh, opts...) yields the cortex colors as a matrix of RGBA rows for the
        given mesh and options. 
  
      The following options are accepted:
        * color (default: None) specifies the color to plot for each vertex; this argument may take a
          number of forms:
            * None, do not plot a color over the underlay (the default)
            * a matrix of RGB or RGBA values, one per vertex
            * a property vector or a string naming a property, in which case the cmap, vmin, and vmax
              arguments are used to generate colors
            * a function that, when passed a single argument, a dict of the properties of a single
              vertex, yields an RGB or RGBA list for that vertex.
        * cmap (default: 'log_eccentricity') specifies the colormap to use in plotting if the color
          argument provided is a property.
        * vmin (default: None) specifies the minimum value for scaling the property when one is passed
          as the color option. None means to use the min value of the property.
        * vmax (default: None) specifies the maximum value for scaling the property when one is passed
          as the color option. None means to use the max value of the property.
        * underlay (default: 'curvature') specifies the default underlay color to plot for the
          cortical surface; it may be None, 'curvature', or a color.
        * alpha (default None) specifies the alpha values to use for the color plot. If None, then
          leaves the alpha values from color unchanged. If a single number, then all alpha values in
          color are multiplied by that value. If a list of values, one per vertex, then this vector
          is multiplied by the alpha values. Finally, any negative value is set instead of multiplied.
          So, for example, if there were 3 vertices with:
            * color = ((0,0,0,1), (0,0,1,0.5), (0,0,0.75,0,8))
            * alpha = (-0.5, 1, 0.5)
          then the resulting colors plotted will be ((0,0,0,0.5), (0,0,1,0.5), (0,0,0.75,0,4)).
        * mask (default: None) specifies a mask to use for the mesh; this is passed through to_mask()
          to figure out the masking. Those vertices not in the mask are not plotted (but they will be
          plotted in the underlay if it is not None).
      '''
      # okay, let's interpret the color
      if color is None:
          color = np.full((the_map.vertex_count, 4), 0.5)
          color[:,3] = 0
      try:
          clr = matplotlib.colors.to_rgba(color)
          # This is an rgb color to plot...
          color = np.ones((the_map.vertex_count,4)) * matplotlib.colors.to_rgba(clr)
      except Exception: pass
      if pimms.is_vector(color) or pimms.is_str(color):
          # it's a property that gets interpreted via the colormap
          p = the_map.property(color)
          # if the colormap is none, we can try to guess it
          if cmap is None:
              (cmap,(vmn,vmx)) = guess_cortex_cmap(color)
              if vmin is None: vmin = vmn
              if vmax is None: vmax = vmx
          color = apply_cmap(p, cmap, vmin=vmin, vmax=vmax)
      if not pimms.is_matrix(color):
          # must be a function; let's try it...
          color = to_rgba(the_map.map(color))
      color = np.array(color)
      if color.shape[1] != 4: color = np.hstack([color, np.ones([color.shape[0], 1])])
      # okay, and the underlay...
      if underlay is not None:
          if pimms.is_str(underlay) and underlay.lower() in ['curvature', 'curv']:
              underlay = apply_cmap(the_map.prop('curvature'), cmap_curvature, vmin=-1, vmax=1)
          else:
              try: underlay = np.ones((the_map.vertex_count, 4)) * to_rgba(underlay)
              except Exception: raise ValueError('plot underlay failed: must be a color or curvature')
      # okay, let's check on alpha...
      if alpha is not None:
          if pimms.is_number(alpha): alpha = np.full(color.shape[0], alpha)
          else: alpha = the_map.property(alpha)
          color[:,3] *= alpha
          neg = (alpha < 0)
          color[neg,3] = -alpha[neg]
      alpha = color[:,3]
      # and the mask...
      if mask is not None:
          ii = the_map.mask(mask, indices=True)
          tmp = np.zeros(len(color))
          tmp[ii] = color[ii,3]
          color[:,3] = tmp
      # then, blend with the underlay if need be
      if underlay is not None:
          color = color_overlap(underlay, color)
      return color