使用TensorFlow物体检测模型、Python和OpenCV的社交距离检测器

class Model:
"""
    Class that contains the model and all its functions
    """
def __init__(self, model_path):
"""
        Initialization function
        @ model_path : path to the model 
        """

# Declare detection graph
        self.detection_graph = tf.Graph()
# Load the model into the tensorflow graph
with self.detection_graph.as_default():
            od_graph_def = tf.compat.v1.GraphDef()
with tf.io.gfile.GFile(model_path, 'rb') as file:
                serialized_graph = file.read()
                od_graph_def.ParseFromString(serialized_graph)
                tf.import_graph_def(od_graph_def, name='')

# Create a session from the detection graph
        self.sess = tf.compat.v1.Session(graph=self.detection_graph)

def predict(self,img):
"""
        Get the predicition results on 1 frame
        @ img : our img vector
        """
# Expand dimensions since the model expects images to have shape: [1, None, None, 3]
        img_exp = np.expand_dims(img, axis=0)
# Pass the inputs and outputs to the session to get the results 
        (boxes, scores, classes) = self.sess.run([self.detection_graph.get_tensor_by_name('detection_boxes:0'), self.detection_graph.get_tensor_by_name('detection_scores:0'), self.detection_graph.get_tensor_by_name('detection_classes:0')],feed_dict={self.detection_graph.get_tensor_by_name('image_tensor:0'): img_exp})
return (boxes, scores, classes)

if int(classes[i]) == 1 and scores[i] > 0.75

width, height, _ = image.shape

def compute_perspective_transform(corner_points,width,height,image):
""" Compute the transformation matrix
  @ corner_points : 4 corner points selected from the image
  @ height, width : size of the image
  return : transformation matrix and the transformed image
  """
# Create an array out of the 4 corner points
  corner_points_array = np.float32(corner_points)
# Create an array with the parameters (the dimensions) required to build the matrix
  img_params = np.float32([[0,0],[width,0],[0,height],[width,height]])
# Compute and return the transformation matrix
  matrix = cv2.getPerspectiveTransform(corner_points_array,img_params) 
  img_transformed = cv2.warpPerspective(image,matrix,(width,height))
return matrix,img_transformed

def compute_point_perspective_transformation(matrix,list_downoids):
""" Apply the perspective transformation to every ground point which have been detected on the main frame.
  @ matrix : the 3x3 matrix 
  @ list_downoids : list that contains the points to transform
  return : list containing all the new points
  """
# Compute the new coordinates of our points
  list_points_to_detect = np.float32(list_downoids).reshape(-1, 1, 2)
  transformed_points = cv2.perspectiveTransform(list_points_to_detect, matrix)
# Loop over the points and add them to the list that will be returned
  transformed_points_list = list()
for i in range(0,transformed_points.shape[0]):
    transformed_points_list.append([transformed_points[i][0][0],transformed_points[i][0][1]])
return transformed_points_list

# Check if 2 or more people have been detected (otherwise no need to detect)
if len(transformed_downoids) >= 2:
    # Iterate over every possible 2 by 2 between the points combinations 
list_indexes = list(itertools.combinations(range(len(transformed_downoids)), 2))
for i,pair in enumerate(itertools.combinations(transformed_downoids, r=2)):
      # Check if the distance between each combination of points is less than the minimum distance chosen
if math.sqrt( (pair[0][0] - pair[1][0])**2 + (pair[0][1] - pair[1][1])**2 ) < int(distance_minimum):
        # Change the colors of the points that are too close from each other to red
change_color_topview(pair)
        # Get the equivalent indexes of these points in the original frame and change the color to red
index_pt1 = list_indexes[i][0]
index_pt2 = list_indexes[i][1]
change_color_originalframe(index_pt1,index_pt2)