text: import argparse
  import torch
  import cv2
  import os
  import time
  
  from utils.utils import get_config, do_detect
  from utils.draw import draw_boxes
  from utils import build_detector, build_deepsort
  
  class VideoTracker(object):
      def __init__(self,cfg,args):
          self.args=args
          use_cuda = args.use_cuda and torch.cuda.is_available()
          if not use_cuda:
              raise UserWarning("Running in cpu mode!")
          if args.display:
              cv2.namedWindow("test", cv2.WINDOW_NORMAL)
              cv2.resizeWindow("test", args.display_width, args.display_height)
  
          self.vdo = cv2.VideoCapture()
  
          self.detector=build_detector(cfg,use_cuda=use_cuda)
          self.deepsort = build_deepsort(cfg, use_cuda=use_cuda)
  
      def __enter__(self):
          assert os.path.isfile(self.args.VIDEO_PATH), "Error: path error"
          self.vdo.open(self.args.VIDEO_PATH)
          self.im_width = int(self.vdo.get(cv2.CAP_PROP_FRAME_WIDTH))
          self.im_height = int(self.vdo.get(cv2.CAP_PROP_FRAME_HEIGHT))
  
          if self.args.save_path:
              fourcc = cv2.VideoWriter_fourcc(*'MJPG')
              self.writer = cv2.VideoWriter(self.args.save_path, fourcc, 20, (self.im_width, self.im_height))
  
          assert self.vdo.isOpened()
          return self
  
      def __exit__(self, exc_type, exc_value, exc_traceback):
          if exc_type:
              print(exc_type, exc_value, exc_traceback)
      def run(self):
          idx_frame = 0
          while self.vdo.grab():
              idx_frame += 1
              if idx_frame % self.args.frame_interval:
                  continue
  
              start = time.time()
              _, ori_im = self.vdo.retrieve()
              im = cv2.cvtColor(ori_im, cv2.COLOR_BGR2RGB)
              # print(im)
  
              # do detection
              # im=Image.fromarray(im)
              height, width = im.shape[:2]
              sized=cv2.resize(im,(self.detector.width,self.detector.height))
              # sized = im.resize((self.m.width, self.m.height))
              # print(sized)
  
              boxes = do_detect(self.detector, sized, 0.5, 0.4, 1)
              boxes = torch.tensor(boxes)
              bbox = boxes[:, :4]
              bbox_xywh = bbox * torch.FloatTensor([[width, height, width, height]])
              cls_conf = boxes[:, 5]
  
              # bbox_xywh, cls_conf, cls_ids = self.detector(im)
  
              if bbox_xywh is not None:
                  # select person class
                  # mask = cls_ids==0
  
                  # bbox_xywh = bbox_xywh[mask]
                  bbox_xywh[:, 3:] *= 1.2  # bbox dilation just in case bbox too small
                  # cls_conf = cls_conf[mask]
  
                  # do tracking
                  outputs = self.deepsort.update(bbox_xywh, cls_conf, im)
                  # outputs=[]
                  # draw boxes for visualization
                  if len(outputs) > 0:
                      bbox_xyxy = outputs[:, :4]
                      identities = outputs[:, -1]
                      ori_im = draw_boxes(ori_im, bbox_xyxy, identities)
  
              end = time.time()
              print("time: {:.03f}s, fps: {:.03f}".format(end - start, 1 / (end - start)))
  
              if self.args.display:
                  cv2.imshow("test", ori_im)
                  cv2.waitKey(1)
  
              if self.args.save_path:
                  self.writer.write(ori_im)
  
  def parse_args():
      parser = argparse.ArgumentParser()
      parser.add_argument("VIDEO_PATH", type=str)
      parser.add_argument("--config_detection", type=str, default="./configs/yolov4.yaml")
      parser.add_argument("--config_deepsort", type=str, default="./configs/deep_sort.yaml")
      parser.add_argument("--ignore_display", dest="display", action="store_false", default=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="./demo/demo.avi")
      parser.add_argument("--cpu", dest="use_cuda", action="store_false", default=True)
      return parser.parse_args()
  
  if __name__ == '__main__':
      args=parse_args()
      cfg=get_config()
      cfg.merge_from_file(args.config_detection)
      cfg.merge_from_file(args.config_deepsort)
      with VideoTracker(cfg, args) as vdo_trk:
          vdo_trk.run()