|
|
|
|
|
import os |
|
|
import cv2 |
|
|
import time |
|
|
import argparse |
|
|
import torch |
|
|
import warnings |
|
|
import json |
|
|
import sys |
|
|
import numpy as np |
|
|
|
|
|
sys.path.append(os.path.join(os.path.dirname(__file__), 'thirdparty/fast-reid')) |
|
|
|
|
|
from detector import build_detector |
|
|
from deep_sort import build_tracker |
|
|
from utils.draw import draw_boxes |
|
|
from utils.parser import get_config |
|
|
from utils.log import get_logger |
|
|
from utils.io import write_results |
|
|
|
|
|
|
|
|
def compute_iou(box1, box2): |
|
|
if box1 is None or box2 is None: |
|
|
return 0.0 |
|
|
xi1, yi1 = max(box1[0], box2[0]), max(box1[1], box2[1]) |
|
|
xi2, yi2 = min(box1[2], box2[2]), min(box1[3], box2[3]) |
|
|
inter_area = max(0, xi2 - xi1) * max(0, yi2 - yi1) |
|
|
box1_area = (box1[2] - box1[0]) * (box1[3] - box1[1]) |
|
|
box2_area = (box2[2] - box2[0]) * (box2[3] - box2[1]) |
|
|
union = box1_area + box2_area - inter_area |
|
|
return inter_area / union if union > 0 else 0.0 |
|
|
|
|
|
def get_best_iou_track(outputs, target_bbox, return_iou=False): |
|
|
if target_bbox is None: |
|
|
return (None, 0.0) if return_iou else None |
|
|
best_iou = 0 |
|
|
best_id = None |
|
|
for det in outputs: |
|
|
x1, y1, x2, y2 = det[:4] |
|
|
track_id = int(det[-1]) |
|
|
iou = compute_iou([x1, y1, x2, y2], target_bbox) |
|
|
if iou > best_iou: |
|
|
best_iou = iou |
|
|
best_id = track_id |
|
|
if return_iou: |
|
|
return best_id, best_iou |
|
|
return best_id |
|
|
|
|
|
class VideoTracker: |
|
|
def __init__(self, cfg, args, video_path): |
|
|
self.cfg = cfg |
|
|
self.args = args |
|
|
self.video_path = video_path |
|
|
self.logger = get_logger("root") |
|
|
self.first_frame_flag = True |
|
|
self.target_id = None |
|
|
self.last_known_bbox = None |
|
|
|
|
|
use_cuda = args.use_cuda and torch.cuda.is_available() |
|
|
if not use_cuda: |
|
|
warnings.warn("Running in cpu mode which maybe very slow!", UserWarning) |
|
|
|
|
|
if args.display: |
|
|
cv2.namedWindow("test", cv2.WINDOW_NORMAL) |
|
|
cv2.resizeWindow("test", args.display_width, args.display_height) |
|
|
|
|
|
if args.cam != -1: |
|
|
self.vdo = cv2.VideoCapture(args.cam) |
|
|
else: |
|
|
self.vdo = cv2.VideoCapture(video_path) |
|
|
|
|
|
self.detector = build_detector(cfg, use_cuda=use_cuda, segment=args.segment) |
|
|
self.deepsort = build_tracker(cfg, use_cuda=use_cuda) |
|
|
|
|
|
def run(self): |
|
|
results = [] |
|
|
idx_frame = 0 |
|
|
with open('coco_classes.json', 'r') as f: |
|
|
idx_to_class = json.load(f) |
|
|
|
|
|
if not self.vdo.isOpened(): |
|
|
raise IOError("Failed to open video") |
|
|
|
|
|
im_width = int(self.vdo.get(cv2.CAP_PROP_FRAME_WIDTH)) |
|
|
im_height = int(self.vdo.get(cv2.CAP_PROP_FRAME_HEIGHT)) |
|
|
|
|
|
if self.args.save_path: |
|
|
os.makedirs(self.args.save_path, exist_ok=True) |
|
|
self.writer = cv2.VideoWriter( |
|
|
os.path.join(self.args.save_path, "results.avi"), |
|
|
cv2.VideoWriter_fourcc(*'MJPG'), |
|
|
20, (im_width, im_height)) |
|
|
|
|
|
while self.vdo.grab(): |
|
|
idx_frame += 1 |
|
|
if idx_frame % self.args.frame_interval: |
|
|
continue |
|
|
|
|
|
_, ori_im = self.vdo.retrieve() |
|
|
im = cv2.cvtColor(ori_im, cv2.COLOR_BGR2RGB) |
|
|
|
|
|
if self.args.segment: |
|
|
bbox_xywh, cls_conf, cls_ids, seg_masks = self.detector(im) |
|
|
else: |
|
|
bbox_xywh, cls_conf, cls_ids = self.detector(im) |
|
|
|
|
|
mask = cls_ids == 0 |
|
|
bbox_xywh = bbox_xywh[mask] |
|
|
cls_conf = cls_conf[mask] |
|
|
cls_ids = cls_ids[mask] |
|
|
if bbox_xywh.shape[0] == 0: |
|
|
continue |
|
|
|
|
|
bbox_xywh[:, 2:] *= 1.2 |
|
|
|
|
|
if self.args.segment: |
|
|
seg_masks = seg_masks[mask] |
|
|
outputs, mask_outputs = self.deepsort.update(bbox_xywh, cls_conf, cls_ids, im, seg_masks) |
|
|
else: |
|
|
outputs, _ = self.deepsort.update(bbox_xywh, cls_conf, cls_ids, im) |
|
|
|
|
|
if self.first_frame_flag and len(outputs) > 0: |
|
|
cv2.imshow("Select target", ori_im) |
|
|
cv2.waitKey(1) |
|
|
target_roi = cv2.selectROI("Select target", ori_im, False, False) |
|
|
cv2.destroyWindow("Select target") |
|
|
target_bbox = [target_roi[0], target_roi[1], target_roi[0] + target_roi[2], target_roi[1] + target_roi[3]] |
|
|
self.target_id = get_best_iou_track(outputs, target_bbox) |
|
|
self.last_known_bbox = target_bbox |
|
|
print(f"[INFO] Selected target ID: {self.target_id}") |
|
|
self.first_frame_flag = False |
|
|
continue |
|
|
|
|
|
bbox_tlwh = [] |
|
|
filtered_outputs = [] |
|
|
for det in outputs: |
|
|
if int(det[-1]) == self.target_id: |
|
|
filtered_outputs.append(det) |
|
|
self.last_known_bbox = det[:4] |
|
|
|
|
|
if len(filtered_outputs) == 0 and self.last_known_bbox is not None: |
|
|
new_id, best_iou = get_best_iou_track(outputs, self.last_known_bbox, return_iou=True) |
|
|
if best_iou > 0.4: |
|
|
self.target_id = new_id |
|
|
print(f"[INFO] Target temporarily lost. Reassigned to ID {self.target_id} (IOU={best_iou:.2f})") |
|
|
for det in outputs: |
|
|
if int(det[-1]) == self.target_id: |
|
|
filtered_outputs.append(det) |
|
|
self.last_known_bbox = det[:4] |
|
|
else: |
|
|
print("[INFO] IOU too low to reassign. Skipping reassignment.") |
|
|
|
|
|
if len(filtered_outputs) > 0: |
|
|
def box_center(box): |
|
|
return np.array([(box[0] + box[2]) / 2, (box[1] + box[3]) / 2]) |
|
|
|
|
|
smoothed_outputs = [] |
|
|
for det in filtered_outputs: |
|
|
if self.last_known_bbox is None: |
|
|
smoothed_outputs.append(det) |
|
|
continue |
|
|
dist = np.linalg.norm(box_center(det[:4]) - box_center(self.last_known_bbox)) |
|
|
if dist < 300: |
|
|
smoothed_outputs.append(det) |
|
|
else: |
|
|
print(f"[INFO] Skipped jumpy box with dist={dist:.2f}") |
|
|
|
|
|
if len(smoothed_outputs) > 0: |
|
|
bbox_xyxy = np.array([det[:4] for det in smoothed_outputs]) |
|
|
identities = [int(det[-1]) for det in smoothed_outputs] |
|
|
cls = [int(det[-2]) for det in smoothed_outputs] |
|
|
names = [idx_to_class[str(label)] for label in cls] |
|
|
|
|
|
ori_im = draw_boxes(ori_im, bbox_xyxy, names, identities) |
|
|
|
|
|
for box in bbox_xyxy: |
|
|
bbox_tlwh.append(self.deepsort._xyxy_to_tlwh(box)) |
|
|
|
|
|
results.append((idx_frame - 1, bbox_tlwh, identities, cls)) |
|
|
|
|
|
if self.args.display: |
|
|
cv2.imshow("test", ori_im) |
|
|
if cv2.waitKey(1) & 0xFF == ord('q'): |
|
|
break |
|
|
|
|
|
if self.args.save_path: |
|
|
self.writer.write(ori_im) |
|
|
|
|
|
if self.args.save_path: |
|
|
write_results(os.path.join(self.args.save_path, "results.txt"), results, 'mot') |
|
|
|
|
|
self.vdo.release() |
|
|
if self.args.display: |
|
|
cv2.destroyAllWindows() |
|
|
|
|
|
def parse_args(): |
|
|
parser = argparse.ArgumentParser() |
|
|
parser.add_argument("--VIDEO_PATH", type=str, default="demo.avi") |
|
|
parser.add_argument("--config_mmdetection", type=str, default="./configs/mmdet.yaml") |
|
|
parser.add_argument("--config_detection", type=str, default="./configs/mask_rcnn.yaml") |
|
|
parser.add_argument("--config_deepsort", type=str, default="./configs/deep_sort.yaml") |
|
|
parser.add_argument("--config_fastreid", type=str, default="./configs/fastreid.yaml") |
|
|
parser.add_argument("--fastreid", action="store_true") |
|
|
parser.add_argument("--mmdet", action="store_true") |
|
|
parser.add_argument("--segment", action="store_true") |
|
|
parser.add_argument("--display", action="store_true") |
|
|
parser.add_argument("--frame_interval", type=int, default=1) |
|
|
parser.add_argument("--display_width", type=int, default=800) |
|
|
parser.add_argument("--display_height", type=int, default=600) |
|
|
parser.add_argument("--save_path", type=str, default="./output/") |
|
|
parser.add_argument("--cpu", dest="use_cuda", action="store_false", default=True) |
|
|
parser.add_argument("--camera", action="store", dest="cam", type=int, default="-1") |
|
|
return parser.parse_args() |
|
|
|
|
|
if __name__ == "__main__": |
|
|
args = parse_args() |
|
|
cfg = get_config() |
|
|
|
|
|
cfg.USE_SEGMENT = args.segment |
|
|
cfg.USE_MMDET = args.mmdet |
|
|
cfg.USE_FASTREID = args.fastreid |
|
|
|
|
|
cfg.merge_from_file(args.config_mmdetection if args.mmdet else args.config_detection) |
|
|
cfg.merge_from_file(args.config_deepsort) |
|
|
if args.fastreid: |
|
|
cfg.merge_from_file(args.config_fastreid) |
|
|
|
|
|
tracker = VideoTracker(cfg, args, video_path=args.VIDEO_PATH) |
|
|
tracker.run() |
