code: def face_adjacency_radius(mesh):
      
  
      # solve for the radius of the adjacent faces
      #         distance
      # R = ------------------
      #     2 * sin(theta / 2)
      nonzero = mesh.face_adjacency_angles > np.radians(.01)
      denominator = np.abs(
          2.0 * np.sin(mesh.face_adjacency_angles[nonzero] / 1.0))
  
      # consider the distance between the non- shared vertices of the
      # face adjacency pair as the key distance
      point_pairs = mesh.vertices[mesh.face_adjacency_unshared]
      vectors = np.diff(point_pairs,
                        axis=1).reshape((-1, 3))
  
      # the vertex indices of the shared edge for the adjacency pairx
      edges = mesh.face_adjacency_edges
      # unit vector along shared the edge
      edges_vec = util.unitize(np.diff(mesh.vertices[edges],
                                       axis=1).reshape((-1, 3)))
  
      # the vector of the perpendicular projection to the shared edge
      perp = np.subtract(
          vectors, (util.diagonal_dot(
              vectors, edges_vec).reshape(
              (-1, 1)) * edges_vec))
      # the length of the perpendicular projection
      span = np.linalg.norm(perp, axis=1)
  
      # complete the values for non- infinite radii
      radii = np.ones(len(mesh.face_adjacency)) * np.inf
      radii[nonzero] = span[nonzero] / denominator
  
      return radii, span
docs: Compute an approximate radius between adjacent faces.
  
      Parameters
      --------------
      mesh : trimesh.Trimesh
  
      Returns
      -------------
      radii : (len(self.face_adjacency),) float
          Approximate radius between faces
          Parallel faces will have a value of np.inf
      span :  (len(self.face_adjacency),) float
          Perpendicular projection distance of two
          unshared vertices onto the shared edge