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]