docs: def first_blip(self, squash_axis, origin, initial_direction):
          '''
          Flatten the mesh to the plane, dropping the dimension identified by
          `squash_axis`: 0 for x, 1 for y, 2 for z. Cast a ray from `origin`,
          pointing along `initial_direction`. Sweep the ray, like a radar, until
          encountering the mesh, and return that vertex: like the first blip of
          the radar. The radar works as if on a point cloud: it sees sees only
          vertices, not edges.
  
          The ray sweeps clockwise and counterclockwise at the same time, and
          returns the first point it hits.
  
          If no intersection occurs within 90 degrees, return None.
  
          `initial_direction` need not be normalized.
  
          '''
          from blmath.numerics import as_numeric_array
  
          origin = vx.reject_axis(as_numeric_array(origin, (3,)), axis=squash_axis, squash=True)
          initial_direction = vx.reject_axis(as_numeric_array(initial_direction, (3,)), axis=squash_axis, squash=True)
          vertices = vx.reject_axis(self.v, axis=squash_axis, squash=True)
  
          origin_to_mesh = vx.normalize(vertices - origin)
          cosines = vx.normalize(initial_direction).dot(origin_to_mesh.T).T
          index_of_first_blip = np.argmax(cosines)
  
          return self.v[index_of_first_blip]