class TrackableObject:
    def __init__(self, objectID, centroid):
        # store the object ID, then initialize a list of centroids
        # using the current centroid
        self.objectID = objectID
        self.centroids = [centroid]
        # initialize a boolean used to indicate if the object has
        # already been counted or not
        self.counted = False

# import the necessary packages
from pyimagesearch.centroidtracker import CentroidTracker
from pyimagesearch.trackableobject import TrackableObject
from imutils.video import VideoStream
from imutils.video import FPS
import numpy as np
import argparse
import imutils
import time
import dlib
import cv2

# construct the argument parse and parse the arguments
ap = argparse.ArgumentParser()
ap.add_argument("-p", "--prototxt", required=True,
    help="path to Caffe 'deploy' prototxt file")
ap.add_argument("-m", "--model", required=True,
    help="path to Caffe pre-trained model")
ap.add_argument("-i", "--input", type=str,
    help="path to optional input video file")
ap.add_argument("-o", "--output", type=str,
    help="path to optional output video file")
ap.add_argument("-c", "--confidence", type=float, default=0.4,
    help="minimum probability to filter weak detections")
ap.add_argument("-s", "--skip-frames", type=int, default=30,
    help="# of skip frames between detections")
args = vars(ap.parse_args())

# initialize the list of class labels MobileNet SSD was trained to detect
CLASSES = ["background", "aeroplane", "bicycle", "bird", "boat",
    "bottle", "bus", "car", "cat", "chair", "cow", "diningtable",
    "dog", "horse", "motorbike", "person", "pottedplant", "sheep",
    "sofa", "train", "tvmonitor"]
# load our serialized model from disk
print("[INFO] loading model...")
net = cv2.dnn.readNetFromCaffe(args["prototxt"], args["model"])

# if a video path was not supplied, grab a reference to the webcam
if not args.get("input", False):
    print("[INFO] starting video stream...")
    vs = VideoStream(src=0).start()
    time.sleep(2.0)
# otherwise, grab a reference to the video file
else:
    print("[INFO] opening video file...")
    vs = cv2.VideoCapture(args["input"])

# initialize the video writer (we'll instantiate later if need be)
writer = None
# initialize the frame dimensions (we'll set them as soon as we read
# the first frame from the video)
W = None
H = None
# instantiate our centroid tracker, then initialize a list to store
# each of our dlib correlation trackers, followed by a dictionary to
# map each unique object ID to a TrackableObject
ct = CentroidTracker(maxDisappeared=40, maxDistance=50)
trackers = []
trackableObjects = {}
# initialize the total number of frames processed thus far, along
# with the total number of objects that have moved either up or down
totalFrames = 0
totalDown = 0
totalUp = 0
# start the frames per second throughput estimator
fps = FPS().start()

# loop over frames from the video stream
while True:
    # grab the next frame and handle if we are reading from either
    # VideoCapture or VideoStream
    frame = vs.read()
    frame = frame[1] if args.get("input", False) else frame
    # if we are viewing a video and we did not grab a frame then we
    # have reached the end of the video
    if args["input"] is not None and frame is None:
        break
    # resize the frame to have a maximum width of 500 pixels (the
    # less data we have, the faster we can process it), then convert
    # the frame from BGR to RGB for dlib
    frame = imutils.resize(frame, width=500)
    rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
    # if the frame dimensions are empty, set them
    if W is None or H is None:
        (H, W) = frame.shape[:2]
    # if we are supposed to be writing a video to disk, initialize
    # the writer
    if args["output"] is not None and writer is None:
        fourcc = cv2.VideoWriter_fourcc(*"MJPG")
        writer = cv2.VideoWriter(args["output"], fourcc, 30,
            (W, H), True)

    # initialize the current status along with our list of bounding
    # box rectangles returned by either (1) our object detector or
    # (2) the correlation trackers
    status = "Waiting"
    rects = []
    # check to see if we should run a more computationally expensive
    # object detection method to aid our tracker
    if totalFrames % args["skip_frames"] == 0:
        # set the status and initialize our new set of object trackers
        status = "Detecting"
        trackers = []
        # convert the frame to a blob and pass the blob through the
        # network and obtain the detections
        blob = cv2.dnn.blobFromImage(frame, 0.007843, (W, H), 127.5)
        net.setInput(blob)
        detections = net.forward()

        # loop over the detections
        for i in np.arange(0, detections.shape[2]):
            # extract the confidence (i.e., probability) associated
            # with the prediction
            confidence = detections[0, 0, i, 2]
            # filter out weak detections by requiring a minimum
            # confidence
            if confidence > args["confidence"]:
                # extract the index of the class label from the
                # detections list
                idx = int(detections[0, 0, i, 1])
                # if the class label is not a person, ignore it
                if CLASSES[idx] != "person":
                    continue

                # compute the (x, y)-coordinates of the bounding box
                # for the object
                box = detections[0, 0, i, 3:7] * np.array([W, H, W, H])
                (startX, startY, endX, endY) = box.astype("int")
                # construct a dlib rectangle object from the bounding
                # box coordinates and then start the dlib correlation
                # tracker
                tracker = dlib.correlation_tracker()
                rect = dlib.rectangle(startX, startY, endX, endY)
                tracker.start_track(rgb, rect)
                # add the tracker to our list of trackers so we can
                # utilize it during skip frames
                trackers.append(tracker)

    # otherwise, we should utilize our object *trackers* rather than
    # object *detectors* to obtain a higher frame processing throughput
    else:
        # loop over the trackers
        for tracker in trackers:
            # set the status of our system to be 'tracking' rather
            # than 'waiting' or 'detecting'
            status = "Tracking"
            # update the tracker and grab the updated position
            tracker.update(rgb)
            pos = tracker.get_position()
            # unpack the position object
            startX = int(pos.left())
            startY = int(pos.top())
            endX = int(pos.right())
            endY = int(pos.bottom())
            # add the bounding box coordinates to the rectangles list
            rects.append((startX, startY, endX, endY))

    # draw a horizontal line in the center of the frame -- once an
    # object crosses this line we will determine whether they were
    # moving 'up' or 'down'
    cv2.line(frame, (0, H // 2), (W, H // 2), (0, 255, 255), 2)
    # use the centroid tracker to associate the (1) old object
    # centroids with (2) the newly computed object centroids
    objects = ct.update(rects)

    # loop over the tracked objects
    for (objectID, centroid) in objects.items():
        # check to see if a trackable object exists for the current
        # object ID
        to = trackableObjects.get(objectID, None)
        # if there is no existing trackable object, create one
        if to is None:
            to = TrackableObject(objectID, centroid)
        # otherwise, there is a trackable object so we can utilize it
        # to determine direction
        else:
            # the difference between the y-coordinate of the *current*
            # centroid and the mean of *previous* centroids will tell
            # us in which direction the object is moving (negative for
            # 'up' and positive for 'down')
            y = [c[1] for c in to.centroids]
            direction = centroid[1] - np.mean(y)
            to.centroids.append(centroid)
            # check to see if the object has been counted or not
            if not to.counted:
                # if the direction is negative (indicating the object
                # is moving up) AND the centroid is above the center
                # line, count the object
                if direction < 0 and centroid[1] < H // 2:
                    totalUp += 1
                    to.counted = True
                # if the direction is positive (indicating the object
                # is moving down) AND the centroid is below the
                # center line, count the object
                elif direction > 0 and centroid[1] > H // 2:
                    totalDown += 1
                    to.counted = True
        # store the trackable object in our dictionary
        trackableObjects[objectID] = to

        # draw both the ID of the object and the centroid of the
        # object on the output frame
        text = "ID {}".format(objectID)
        cv2.putText(frame, text, (centroid[0] - 10, centroid[1] - 10),
            cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)
        cv2.circle(frame, (centroid[0], centroid[1]), 4, (0, 255, 0), -1)
    # construct a tuple of information we will be displaying on the
    # frame
    info = [
        ("Up", totalUp),
        ("Down", totalDown),
        ("Status", status),
    ]
    # loop over the info tuples and draw them on our frame
    for (i, (k, v)) in enumerate(info):
        text = "{}: {}".format(k, v)
        cv2.putText(frame, text, (10, H - ((i * 20) + 20)),
            cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 0, 255), 2)

    # check to see if we should write the frame to disk
    if writer is not None:
        writer.write(frame)
    # show the output frame
    cv2.imshow("Frame", frame)
    key = cv2.waitKey(1) & 0xFF
    # if the `q` key was pressed, break from the loop
    if key == ord("q"):
        break
    # increment the total number of frames processed thus far and
    # then update the FPS counter
    totalFrames += 1
    fps.update()

# stop the timer and display FPS information
fps.stop()
print("[INFO] elapsed time: {:.2f}".format(fps.elapsed()))
print("[INFO] approx. FPS: {:.2f}".format(fps.fps()))
# check to see if we need to release the video writer pointer
if writer is not None:
    writer.release()
# if we are not using a video file, stop the camera video stream
if not args.get("input", False):
    vs.stop()
# otherwise, release the video file pointer
else:
    vs.release()
# close any open windows
cv2.destroyAllWindows()

from pyimagesearch.centroidtracker import CentroidTracker
from pyimagesearch.trackableobject import TrackableObject
from imutils.video import VideoStream
from imutils.video import FPS
import numpy as np
import argparse
import imutils
import time
import dlib
import cv2


# 構(gòu)造參數(shù)解析并解析參數(shù)
ap = argparse.ArgumentParser()
ap.add_argument("-p", "--prototxt", required=True,
	help="path to Caffe 'deploy' prototxt file")
ap.add_argument("-m", "--model", required=True,
	help="path to Caffe pre-trained model")
ap.add_argument("-i", "--input", type=str,
	help="path to optional input video file")
ap.add_argument("-o", "--output", type=str,
	help="path to optional output video file")
ap.add_argument("-c", "--confidence", type=float, default=0.4,
	help="minimum probability to filter weak detections")
ap.add_argument("-s", "--skip-frames", type=int, default=30,
	help="# of skip frames between detections")
args = vars(ap.parse_args())

# 初始化類標(biāo)簽列表
CLASSES = ["background", "aeroplane", "bicycle", "bird", "boat",
	"bottle", "bus", "car", "cat", "chair", "cow", "diningtable",
	"dog", "horse", "motorbike", "person", "pottedplant", "sheep",
	"sofa", "train", "tvmonitor"]
# 從磁盤加載我們的序列化模型
print("[INFO] loading model...")
net = cv2.dnn.readNetFromCaffe(args["prototxt"], args["model"])

# 如果未提供視頻路徑，請(qǐng)獲取網(wǎng)絡(luò)攝像頭的引用
if not args.get("input", False):
	print("[INFO] starting video stream...")
	vs = VideoStream(src=0).start()
	time.sleep(2.0)
# 否則，獲取對(duì)視頻文件的引用
else:
	print("[INFO] opening video file...")
	vs = cv2.VideoCapture(args["input"])

# 初始化視頻寫入器(如果需要，我們稍后將進(jìn)行實(shí)例化)
writer = None
# 初始化幀尺寸（我們將在從視頻中讀取第一幀后立即設(shè)置它們）
W = None
H = None
# 實(shí)例化我們的質(zhì)心跟蹤器，然后初始化一個(gè)列表來存儲(chǔ)每個(gè)dlib相關(guān)跟蹤器，
# 然后是一個(gè)字典來將每個(gè)唯一的對(duì)象ID映射到TrackableObject
ct = CentroidTracker(maxDisappeared=40, maxDistance=50)
trackers = []
trackableObjects = {}
# 初始化到目前為止處理的幀總數(shù)，以及向上或向下移動(dòng)的對(duì)象總數(shù)
totalFrames = 0
totalDown = 0
totalUp = 0
# 啟動(dòng)FPS評(píng)估器
fps = FPS().start()

# 循環(huán)視頻流中的幀
while True:
	# 如果我們正在從 VideoCapture 或 VideoStream 讀取數(shù)據(jù)，則抓取下一幀并處理
	frame = vs.read()
	frame = frame[1] if args.get("input", False) else frame
	# 如果我們正在觀看視頻并且我們沒有抓取幀，那么我們已經(jīng)到了視頻的結(jié)尾
	if args["input"] is not None and frame is None:
		break
	# 調(diào)整幀的最大寬度為 500 像素（我們擁有的數(shù)據(jù)越少，我們處理它的速度就越快），
	# 然后將幀從 BGR 轉(zhuǎn)換為 RGB 用于 dlib
	frame = imutils.resize(frame, width=500)
	rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
	# 如果幀尺寸為空，則設(shè)置它們
	if W is None or H is None:
		(H, W) = frame.shape[:2]
	# 如果我們應(yīng)該將視頻寫入磁盤，請(qǐng)初始化寫入器
	if args["output"] is not None and writer is None:
		fourcc = cv2.VideoWriter_fourcc(*"MJPG")
		writer = cv2.VideoWriter(args["output"], fourcc, 30,
			(W, H), True)


	# 初始化當(dāng)前狀態(tài)以及由（1）我們的對(duì)象檢測(cè)器或（2）相關(guān)跟蹤器返回的邊界框矩形列表
	status = "Waiting"
	rects = []
	# 檢查我們是否應(yīng)該運(yùn)行計(jì)算量更大的目標(biāo)檢測(cè)方法來幫助我們的跟蹤器
	if totalFrames % args["skip_frames"] == 0:
		# 設(shè)置狀態(tài)并初始化我們的新對(duì)象跟蹤器集
		status = "Detecting"
		trackers = []
		# 將幀轉(zhuǎn)換為 blob 并通過網(wǎng)絡(luò)傳遞 blob 并獲得檢測(cè)結(jié)果
		blob = cv2.dnn.blobFromImage(frame, 0.007843, (W, H), 127.5)
		net.setInput(blob)
		detections = net.forward()

		# 循環(huán)檢測(cè)結(jié)果
		for i in np.arange(0, detections.shape[2]):
			# 提取與預(yù)測(cè)相關(guān)的置信度(即概率)
			confidence = detections[0, 0, i, 2]
			# 通過要求最小置信度過濾掉弱檢測(cè)
			if confidence > args["confidence"]:
				# 從檢測(cè)列表中提取類標(biāo)簽的索引
				idx = int(detections[0, 0, i, 1])
				# 如果類標(biāo)簽不是人，則忽略它
				if CLASSES[idx] != "person":
					continue
				# 計(jì)算對(duì)象邊界框的 (x, y) 坐標(biāo)
				box = detections[0, 0, i, 3:7] * np.array([W, H, W, H])
				(startX, startY, endX, endY) = box.astype("int")
				# 利用邊界框坐標(biāo)構(gòu)造一個(gè) dlib 矩形對(duì)象，然后啟動(dòng) dlib 相關(guān)跟蹤器
				tracker = dlib.correlation_tracker()
				rect = dlib.rectangle(startX, startY, endX, endY)
				tracker.start_track(rgb, rect)
				# 將跟蹤器添加到我們的跟蹤器列表中，以便我們可以在跳幀期間使用它
				trackers.append(tracker)

	# 否則，我們應(yīng)該利用目標(biāo)跟蹤器而不是目標(biāo)檢測(cè)器來獲得更高的FPS
	else:
		# 遍歷跟蹤器
		for tracker in trackers:
			# 將系統(tǒng)的狀態(tài)設(shè)置為“跟蹤”而不是“等待”或“檢測(cè)”
			status = "Tracking"
			# 更新跟蹤器并獲取更新的位置
			tracker.update(rgb)
			pos = tracker.get_position()
			# 解包位置對(duì)象
			startX = int(pos.left())
			startY = int(pos.top())
			endX = int(pos.right())
			endY = int(pos.bottom())
			# 將邊界框坐標(biāo)添加到矩形列表
			rects.append((startX, startY, endX, endY))

	# 在幀中心畫一條水平線——一旦一個(gè)物體穿過這條線，我們將確定他們是在“向上”還是“向下”移動(dòng)。
	cv2.line(frame, (0, H // 2), (W, H // 2), (0, 255, 255), 2)
	# 使用質(zhì)心跟蹤器將 (1) 舊對(duì)象質(zhì)心與 (2) 新計(jì)算的對(duì)象質(zhì)心相關(guān)聯(lián)
	objects = ct.update(rects)

	# 循環(huán)遍歷被跟蹤的對(duì)象
	for (objectID, centroid) in objects.items():
		# 檢查當(dāng)前對(duì)象 ID 是否存在可跟蹤對(duì)象
		to = trackableObjects.get(objectID, None)
		# 如果沒有現(xiàn)有的可跟蹤對(duì)象，則創(chuàng)建一個(gè)
		if to is None:
			to = TrackableObject(objectID, centroid)
		# 否則，有一個(gè)可追蹤的物體，所以我們可以利用它來確定方向
		else:
			# *當(dāng)前*質(zhì)心的 y 坐標(biāo)與 *previous* 質(zhì)心的平均值之間的差異
			# 將告訴我們物體在哪個(gè)方向移動(dòng)（“向上”為負(fù)，“向下”為正）
			y = [c[1] for c in to.centroids]
			direction = centroid[1] - np.mean(y)
			to.centroids.append(centroid)
			# 檢查對(duì)象是否已被計(jì)數(shù)
			if not to.counted:
				# 如果方向?yàn)樨?fù)(表示物體向上移動(dòng))且質(zhì)心在中線以上，則計(jì)算物體
				if direction < 0 and centroid[1] < H // 2:
					totalUp += 1
					to.counted = True
				# 如果方向?yàn)檎ū硎疚矬w正在向下移動(dòng)）并且質(zhì)心低于中心線，則計(jì)算物體
				elif direction > 0 and centroid[1] > H // 2:
					totalDown += 1
					to.counted = True
		# 將可跟蹤對(duì)象存儲(chǔ)在我們的字典中
		trackableObjects[objectID] = to

		# 在輸出幀上繪制對(duì)象的 ID 和對(duì)象的質(zhì)心
		text = "ID {}".format(objectID)
		cv2.putText(frame, text, (centroid[0] - 10, centroid[1] - 10),
			cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)
		cv2.circle(frame, (centroid[0], centroid[1]), 4, (0, 255, 0), -1)
	# 構(gòu)建我們將在幀上顯示的信息元組
	info = [
		("Up", totalUp),
		("Down", totalDown),
		("Status", status),
	]
	# 遍歷信息元組并將它們繪制在我們的幀上
	for (i, (k, v)) in enumerate(info):
		text = "{}: {}".format(k, v)
		cv2.putText(frame, text, (10, H - ((i * 20) + 20)),
			cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 0, 255), 2)



	# 檢查我們是否應(yīng)該將幀寫入磁盤
	if writer is not None:
		writer.write(frame)
	# 顯示輸出幀
	cv2.imshow("Frame", frame)
	key = cv2.waitKey(1) & 0xFF
	# 如果' q '鍵被按下，中斷循環(huán)
	if key == ord("q"):
		break
	# 增加到目前為止處理的幀總數(shù)，然后更新 FPS 計(jì)數(shù)器
	totalFrames += 1
	fps.update()

# 停止定時(shí)器，顯示FPS信息
fps.stop()
print("[INFO] elapsed time: {:.2f}".format(fps.elapsed()))
print("[INFO] approx. FPS: {:.2f}".format(fps.fps()))
# 檢查我們是否需要釋放視頻寫入器指針
if writer is not None:
	writer.release()
# 如果我們不使用視頻文件，請(qǐng)停止攝像頭視頻流
if not args.get("input", False):
	vs.stop()
# 否則，釋放視頻文件指針
else:
	vs.release()
# 關(guān)閉所有打開的窗口
cv2.destroyAllWindows()

from scipy.spatial import distance as dist
from collections import OrderedDict
import numpy as np

class CentroidTracker:
	def __init__(self, maxDisappeared=50, maxDistance=50):
		# 初始化下一個(gè)唯一的對(duì)象ID，并使用兩個(gè)有序字典來跟蹤給定對(duì)象ID到其質(zhì)心的映射，
		# 以及它被標(biāo)記為“消失”的連續(xù)幀數(shù)
		self.nextObjectID = 0
		self.objects = OrderedDict()
		self.disappeared = OrderedDict()

		# 存儲(chǔ)一個(gè)給定對(duì)象允許被標(biāo)記為“消失”的最大連續(xù)幀數(shù)，直到我們需要從跟蹤中注銷該對(duì)象
		self.maxDisappeared = maxDisappeared

		# 存儲(chǔ)質(zhì)心之間的最大距離以關(guān)聯(lián)對(duì)象——如果距離大于這個(gè)最大距離，我們開始將對(duì)象標(biāo)記為“消失”
		self.maxDistance = maxDistance

	def register(self, centroid):
		# 注冊(cè)對(duì)象時(shí)，我們使用下一個(gè)可用的對(duì)象 ID 來存儲(chǔ)質(zhì)心
		self.objects[self.nextObjectID] = centroid
		self.disappeared[self.nextObjectID] = 0
		self.nextObjectID += 1

	def deregister(self, objectID):
		# 要注銷對(duì)象 ID，我們從各自的字典中刪除對(duì)象 ID
		del self.objects[objectID]
		del self.disappeared[objectID]

	def update(self, rects):
		# 檢查輸入邊界框矩形列表是否為空
		if len(rects) == 0:
			# 循環(huán)遍歷任何現(xiàn)有的跟蹤對(duì)象并將它們標(biāo)記為消失
			for objectID in list(self.disappeared.keys()):
				self.disappeared[objectID] += 1

				# 如果我們已經(jīng)達(dá)到給定對(duì)象被標(biāo)記為消失的最大連續(xù)幀數(shù)，則取消注冊(cè)它
				if self.disappeared[objectID] > self.maxDisappeared:
					self.deregister(objectID)

			# 早點(diǎn)返回，因?yàn)闆]有要更新的質(zhì)心或跟蹤信息
			return self.objects

		# 初始化當(dāng)前幀的輸入質(zhì)心數(shù)組
		inputCentroids = np.zeros((len(rects), 2), dtype="int")

		# 循環(huán)邊界框矩形
		for (i, (startX, startY, endX, endY)) in enumerate(rects):
			# 使用邊界框坐標(biāo)推導(dǎo)出質(zhì)心
			cX = int((startX + endX) / 2.0)
			cY = int((startY + endY) / 2.0)
			inputCentroids[i] = (cX, cY)

		# 如果我們當(dāng)前沒有跟蹤任何對(duì)象，則獲取輸入質(zhì)心并注冊(cè)它們中的每一個(gè)
		if len(self.objects) == 0:
			for i in range(0, len(inputCentroids)):
				self.register(inputCentroids[i])

		# 否則，我們目前正在跟蹤對(duì)象，因此我們需要嘗試將輸入質(zhì)心與現(xiàn)有對(duì)象質(zhì)心匹配
		else:
			# 獲取一組對(duì)象 ID 和相應(yīng)的質(zhì)心
			objectIDs = list(self.objects.keys())
			objectCentroids = list(self.objects.values())

			# 分別計(jì)算每對(duì)對(duì)象質(zhì)心和輸入質(zhì)心之間的距離——我們的目標(biāo)是將輸入質(zhì)心與現(xiàn)有對(duì)象質(zhì)心匹配
			D = dist.cdist(np.array(objectCentroids), inputCentroids)

			# 為了執(zhí)行這種匹配，我們必須 (1) 找到每一行中的最小值，
			# 然后 (2) 根據(jù)它們的最小值對(duì)行索引進(jìn)行排序，以便具有最小值的行位于索引列表的 *front*
			rows = D.min(axis=1).argsort()

			# 接下來，我們對(duì)列執(zhí)行類似的處理，方法是在每個(gè)列中找到最小的值，
			# 然后使用之前計(jì)算的行索引列表進(jìn)行排序
			cols = D.argmin(axis=1)[rows]

			# 為了確定我們是否需要更新、注冊(cè)或取消注冊(cè)一個(gè)對(duì)象，我們需要跟蹤我們已經(jīng)檢查過的行和列索引
			usedRows = set()
			usedCols = set()

			# 循環(huán)遍歷（行，列）索引元組的組合
			for (row, col) in zip(rows, cols):
				# 如果我們之前已經(jīng)檢查過行值或列值，請(qǐng)忽略它
				if row in usedRows or col in usedCols:
					continue

				# 如果質(zhì)心之間的距離大于最大距離，則不要將兩個(gè)質(zhì)心關(guān)聯(lián)到同一個(gè)對(duì)象
				if D[row, col] > self.maxDistance:
					continue

				# 否則，獲取當(dāng)前行的對(duì)象 ID，設(shè)置其新質(zhì)心，并重置消失的計(jì)數(shù)器
				objectID = objectIDs[row]
				self.objects[objectID] = inputCentroids[col]
				self.disappeared[objectID] = 0

				# 表明我們已經(jīng)分別檢查了每個(gè)行和列索引
				usedRows.add(row)
				usedCols.add(col)

			# 計(jì)算我們尚未檢查的行和列索引
			unusedRows = set(range(0, D.shape[0])).difference(usedRows)
			unusedCols = set(range(0, D.shape[1])).difference(usedCols)

			# 如果對(duì)象質(zhì)心的數(shù)量等于或大于輸入質(zhì)心的數(shù)量，
			# 我們需要檢查并查看其中一些對(duì)象是否可能已經(jīng)消失
			if D.shape[0] >= D.shape[1]:
				# 循環(huán)未使用的行索引
				for row in unusedRows:
					# 獲取相應(yīng)行索引的對(duì)象 ID 并增加消失的計(jì)數(shù)器
					objectID = objectIDs[row]
					self.disappeared[objectID] += 1

					# 檢查對(duì)象的連續(xù)幀數(shù)是否被標(biāo)記為“消失”，以注銷該對(duì)象
					if self.disappeared[objectID] > self.maxDisappeared:
						self.deregister(objectID)

			# 否則，如果輸入質(zhì)心的數(shù)量大于現(xiàn)有對(duì)象質(zhì)心的數(shù)量，我們需要將每個(gè)新的輸入質(zhì)心注冊(cè)為可跟蹤對(duì)象
			else:
				for col in unusedCols:
					self.register(inputCentroids[col])

		# 返回可跟蹤對(duì)象的集合
		return self.objects

class TrackableObject:
	def __init__(self, objectID, centroid):
		# 存儲(chǔ)對(duì)象 ID，然后使用當(dāng)前質(zhì)心初始化質(zhì)心列表
		self.objectID = objectID
		self.centroids = [centroid]

		# 初始化一個(gè)布爾值，用于指示對(duì)象是否已被計(jì)數(shù)
		self.counted = False

python people_counter.py --prototxt mobilenet_ssd/MobileNetSSD_deploy.prototxt \
    --model mobilenet_ssd/MobileNetSSD_deploy.caffemodel \
    --input videos/example_01.mp4 --output output/output_01.avi