code: def mean_vertex_normals(vertex_count,
                          faces,
                          face_normals,
                          **kwargs):
      
      def summed_sparse():
          # use a sparse matrix of which face contains each vertex to
          # figure out the summed normal at each vertex
          # allow cached sparse matrix to be passed
          if 'sparse' in kwargs:
              sparse = kwargs['sparse']
          else:
              sparse = index_sparse(vertex_count, faces)
          summed = sparse.dot(face_normals)
          return summed
  
      def summed_loop():
          # loop through every face, in tests was ~50x slower than
          # doing this with a sparse matrix
          summed = np.zeros((vertex_count, 3))
          for face, normal in zip(faces, face_normals):
              summed[face] += normal
          return summed
  
      try:
          summed = summed_sparse()
      except BaseException:
          log.warning(
              'unable to generate sparse matrix! Falling back!',
              exc_info=True)
          summed = summed_loop()
  
      # invalid normals will be returned as zero
      vertex_normals = util.unitize(summed)
  
      return vertex_normals
docs: Find vertex normals from the mean of the faces that contain
      that vertex.
  
      Parameters
      -----------
      vertex_count : int
        The number of vertices faces refer to
      faces : (n, 3) int
        List of vertex indices
      face_normals : (n, 3) float
        Normal vector for each face
  
      Returns
      -----------
      vertex_normals : (vertex_count, 3) float
        Normals for every vertex
        Vertices unreferenced by faces will be zero.