### Install COCOAPI

Source: https://github.com/xingyizhou/centertrack/blob/master/readme/INSTALL.md

Installs cython and the COCOAPI library from the official repository.

```bash
pip install cython; pip install -U 'git+https://github.com/cocodataset/cocoapi.git#subdirectory=PythonAPI'
```

--------------------------------

### Verify Installation

Source: https://context7.com/xingyizhou/centertrack/llms.txt

Runs the CenterTrack demo script to verify the installation by performing tracking on a webcam feed.

```bash
# Verify installation
cd src
python demo.py tracking --load_model ../models/coco_tracking.pth --demo webcam
```

--------------------------------

### Install requirements

Source: https://github.com/xingyizhou/centertrack/blob/master/readme/INSTALL.md

Installs all necessary Python dependencies listed in the requirements file.

```bash
pip install -r requirements.txt
```

--------------------------------

### Install PyTorch

Source: https://github.com/xingyizhou/centertrack/blob/master/readme/INSTALL.md

Installs PyTorch and torchvision using the conda package manager.

```bash
conda install pytorch torchvision -c pytorch
```

--------------------------------

### Create, Load, and Save CenterTrack Model

Source: https://context7.com/xingyizhou/centertrack/llms.txt

Demonstrates creating a DLA-34 model, loading pretrained weights, and saving a model checkpoint. Includes a forward pass example with dummy data.

```python
from model.model import create_model, load_model, save_model
import torch

# Define model configuration
heads = {
    'hm': 1,           # Heatmap for 1 class (pedestrian)
    'reg': 2,          # Local offset regression
    'wh': 2,           # Width/height prediction
    'tracking': 2      # Tracking offset to previous frame
}
head_conv = {'hm': [256], 'reg': [256], 'wh': [256], 'tracking': [256]}

# Create DLA-34 model
model = create_model('dla_34', heads, head_conv, opt=None)
print(f"Model parameters: {sum(p.numel() for p in model.parameters()):,}")

# Load pretrained weights
class LoadOpt:
    reset_hm = False
    reuse_hm = False
    resume = False

model = load_model(model, '../models/mot17_half.pth', LoadOpt())
model = model.cuda()
model.eval()

# Save model checkpoint
save_model('checkpoint.pth', epoch=70, model=model, optimizer=None)

# Forward pass example
with torch.no_grad():
    # Inputs: current image, previous image, previous heatmap
    current_img = torch.randn(1, 3, 544, 960).cuda()
    prev_img = torch.randn(1, 3, 544, 960).cuda()
    prev_hm = torch.zeros(1, 1, 136, 240).cuda()

    outputs = model(current_img, prev_img, prev_hm)
    output = outputs[-1]  # Get final output
    print(f"Heatmap shape: {output['hm'].shape}")
    print(f"Tracking offset shape: {output['tracking'].shape}")
```

--------------------------------

### Install COCOAPI

Source: https://context7.com/xingyizhou/centertrack/llms.txt

Installs the COCOAPI Python package, which is required for handling COCO-formatted datasets.

```bash
# Install COCOAPI
pip install cython
pip install -U 'git+https://github.com/cocodataset/cocoapi.git#subdirectory=PythonAPI'
```

--------------------------------

### COCO Annotation Format Example

Source: https://context7.com/xingyizhou/centertrack/llms.txt

Illustrates the expected COCO annotation format for CenterTrack, including image metadata, bounding boxes, and optional tracking information.

```json
{
    "images": [
        {
            "id": 1,
            "file_name": "video1/000001.jpg",
            "height": 1080,
            "width": 1920,
            "video_id": 1,
            "frame_id": 1,
            "calib": [[fx, 0, cx, 0], [0, fy, cy, 0], [0, 0, 1, 0]]  # Optional 3D
        }
    ],
    "annotations": [
        {
            "id": 1,
            "image_id": 1,
            "category_id": 1,
            "bbox": [x, y, width, height],  # COCO format
            "area": 12345,
            "iscrowd": 0,
            "track_id": 1  # For evaluation
        }
    ],
    "categories": [
        {"id": 1, "name": "pedestrian"}
    ],
    "videos": [
        {"id": 1, "name": "video1"}
    ]
}
```

--------------------------------

### Run Webcam Demo

Source: https://github.com/xingyizhou/centertrack/blob/master/README.md

This command initiates the tracking demo using a live webcam feed. It utilizes the specified pre-trained model.

```bash
python demo.py tracking --load_model ../models/coco_tracking.pth --demo webcam
```

--------------------------------

### Initialize and Use Tracker Class

Source: https://context7.com/xingyizhou/centertrack/llms.txt

Demonstrates initializing the Tracker with custom options, initializing tracks from first frame detections, processing subsequent frames, and resetting the tracker.

```python
from utils.tracker import Tracker

class MockOpt:
    def __init__(self):
        self.new_thresh = 0.3      # Threshold for creating new tracks
        self.track_thresh = 0.4    # Threshold for tracking detections
        self.hungarian = False     # Use greedy assignment (faster)
        self.public_det = False    # Use private detection mode
        self.max_age = 3           # Max frames to keep lost tracks

opt = MockOpt()
tracker = Tracker(opt)

# Initialize tracks from first frame detections
frame1_dets = [
    {'score': 0.9, 'bbox': [100, 100, 200, 300], 'class': 1,
     'ct': [150, 200], 'tracking': [0, 0]},
    {'score': 0.8, 'bbox': [400, 150, 500, 350], 'class': 1,
     'ct': [450, 250], 'tracking': [0, 0]}
]
tracker.init_track(frame1_dets)

# Process subsequent frames
frame2_dets = [
    {'score': 0.85, 'bbox': [110, 105, 210, 305], 'class': 1,
     'ct': [160, 205], 'tracking': [-10, -5]},
    {'score': 0.75, 'bbox': [420, 160, 520, 360], 'class': 1,
     'ct': [470, 260], 'tracking': [-20, -10]}
]
results = tracker.step(frame2_dets)

for r in results:
    print(f"Track ID: {r['tracking_id']}, BBox: {r['bbox']}, "
          f"Active: {r['active']}, Age: {r['age']}")

# Reset tracker for new video
tracker.reset()
```

--------------------------------

### Run Pose Tracking Demo

Source: https://github.com/xingyizhou/centertrack/blob/master/README.md

Use this command to run the pose tracking demo. It requires the pose tracking model and can process video files, image folders, or webcam input.

```bash
python demo.py tracking,multi_pose --load_model ../models/coco_pose.pth --demo /path/to/image/or/folder/or/webcam
```

--------------------------------

### Run 80-Category Tracking Demo

Source: https://github.com/xingyizhou/centertrack/blob/master/README.md

Execute this command for general 80-category object tracking on images, folders, or videos. Ensure the correct model path is provided.

```bash
python demo.py tracking --load_model ../models/coco_tracking.pth --demo /path/to/image/or/folder/or/video
```

--------------------------------

### Run Demo Scripts for Video Processing

Source: https://context7.com/xingyizhou/centertrack/llms.txt

Execute demo.py to process videos, webcams, or image folders. Various flags allow for task-specific configurations like 3D tracking, pose estimation, or debug visualization.

```bash
# Run monocular 3D tracking on a video
python demo.py tracking,ddd \
    --load_model ../models/nuScenes_3Dtracking.pth \
    --dataset nuscenes \
    --pre_hm \
    --track_thresh 0.1 \
    --demo ../videos/nuscenes_mini.mp4 \
    --test_focal_length 633

# Run 80-category tracking on images or video
python demo.py tracking \
    --load_model ../models/coco_tracking.pth \
    --demo /path/to/image/or/folder/or/video

# Run person tracking with single-class model
python demo.py tracking \
    --load_model ../models/mot17_half.pth \
    --num_class 1 \
    --demo /path/to/video.mp4

# Webcam demo for real-time tracking
python demo.py tracking \
    --load_model ../models/coco_tracking.pth \
    --demo webcam

# Pose tracking demo
python demo.py tracking,multi_pose \
    --load_model ../models/coco_pose.pth \
    --demo /path/to/video.mp4

# Save output video and debug visualizations
python demo.py tracking \
    --load_model ../models/coco_tracking.pth \
    --demo input_video.mp4 \
    --save_video \
    --debug 2
```

--------------------------------

### Run Monocular 3D Tracking Demo

Source: https://github.com/xingyizhou/centertrack/blob/master/README.md

Use this command to run the monocular 3D tracking demo on a video. Specify the model path, dataset, and focal length if needed for coordinate system conversion.

```bash
python demo.py tracking,ddd --load_model ../models/nuScenes_3Dtracking.pth --dataset nuscenes --pre_hm --track_thresh 0.1 --demo ../videos/nuscenes_mini.mp4 --test_focal_length 633
```

--------------------------------

### Initialize Tracking Options

Source: https://context7.com/xingyizhou/centertrack/llms.txt

Initializes tracking options for demo or inference, specifying the model path.

```python
# Initialize for demo/inference
opt = opts().init('tracking --load_model ../models/coco_tracking.pth'.split())
```

--------------------------------

### Download Pretrained Models

Source: https://context7.com/xingyizhou/centertrack/llms.txt

Creates a 'models' directory and provides a link to download pretrained models. These models are essential for running CenterTrack inference.

```bash
# Download pretrained models
mkdir -p models
# Download from: https://drive.google.com/drive/folders/1y_CWlbboW_dfOx6zT9MU4ugLaLc6FEE8
```

--------------------------------

### Create and activate conda environment

Source: https://github.com/xingyizhou/centertrack/blob/master/readme/INSTALL.md

Sets up a dedicated Python 3.6 environment for the project.

```bash
conda create --name CenterTrack python=3.6
```

```bash
conda activate CenterTrack
```

--------------------------------

### Evaluate Models on Benchmarks

Source: https://context7.com/xingyizhou/centertrack/llms.txt

Use test.py to compute metrics on standard datasets like MOT17, KITTI, and nuScenes. Ensure appropriate model paths and dataset versions are specified.

```bash
# Evaluate on MOT17 validation set (half-half split)
python test.py tracking \
    --exp_id mot17_half \
    --dataset mot \
    --dataset_version 17halfval \
    --pre_hm \
    --ltrb_amodal \
    --track_thresh 0.4 \
    --pre_thresh 0.5 \
    --load_model ../models/mot17_half.pth
# Expected MOTA: 66.1

# Evaluate with public detection (MOT challenge mode)
python test.py tracking \
    --exp_id mot17_half_public \
    --dataset mot \
    --dataset_version 17halfval \
    --pre_hm \
    --ltrb_amodal \
    --track_thresh 0.4 \
    --pre_thresh 0.5 \
    --load_model ../models/mot17_half.pth \
    --public_det \
    --load_results ../data/mot17/results/val_half_det.json
# Expected MOTA: 63.1

# Evaluate on KITTI tracking validation
python test.py tracking \
    --exp_id kitti_half \
    --dataset kitti_tracking \
    --dataset_version val_half \
    --pre_hm \
    --track_thresh 0.4 \
    --load_model ../models/kitti_half.pth
# Expected MOTA: 88.7

# Evaluate 3D tracking on nuScenes
python test.py tracking,ddd \
    --exp_id nuScenes_3Dtracking \
    --load_model ../models/nuScenes_3Dtracking.pth \
    --dataset nuscenes \
    --track_thresh 0.1 \
    --pre_hm
```

--------------------------------

### Access Training Settings

Source: https://context7.com/xingyizhou/centertrack/llms.txt

Prints training-related hyperparameters including learning rate, batch size, number of epochs, and learning rate steps.

```python
# Training settings
print(f"Learning rate: {opt.lr}")                  # Default: 1.25e-4
print(f"Batch size: {opt.batch_size}")             # Default: 32
print(f"Epochs: {opt.num_epochs}")                 # Default: 70
print(f"LR steps: {opt.lr_step}")                  # Default: [60]
```

--------------------------------

### Resume Training from Checkpoint

Source: https://context7.com/xingyizhou/centertrack/llms.txt

Resume training from a previously saved checkpoint. Specify the experiment ID and dataset details.

```bash
python main.py tracking \
    --exp_id mot17_half \
    --dataset mot \
    --dataset_version 17halftrain \
    --resume
```

--------------------------------

### Compile DCNv2

Source: https://github.com/xingyizhou/centertrack/blob/master/readme/INSTALL.md

Navigates to the DCNv2 directory and executes the build script.

```bash
cd $CenterTrack_ROOT/src/lib/model/networks/
# git clone https://github.com/CharlesShang/DCNv2/ # clone if it is not automatically downloaded by `--recursive`.
cd DCNv2
./make.sh
```

--------------------------------

### Initialize and Run Detector API

Source: https://context7.com/xingyizhou/centertrack/llms.txt

Use the Detector class to load models and perform inference on image sequences. Ensure the library path is correctly added to sys.path before importing.

```python
import sys
CENTERTRACK_PATH = '/path/to/CenterTrack/src/lib/'
sys.path.insert(0, CENTERTRACK_PATH)

from detector import Detector
from opts import opts

# Initialize detector for 80-category tracking
MODEL_PATH = '/path/to/models/coco_tracking.pth'
TASK = 'tracking'
opt = opts().init('{} --load_model {}'.format(TASK, MODEL_PATH).split(' '))
detector = Detector(opt)

# Run detection on images
import cv2
images = [cv2.imread('frame1.jpg'), cv2.imread('frame2.jpg'), cv2.imread('frame3.jpg')]
for img in images:
    ret = detector.run(img)
    results = ret['results']
    # Each result: {'bbox': [x1, y1, x2, y2], 'tracking_id': id, 'class': class_id, 'score': conf}
    for det in results:
        print(f"ID: {det['tracking_id']}, Class: {det['class']}, "
              f"BBox: {det['bbox']}, Score: {det['score']:.2f}")

# Reset tracking for new video sequence
detector.reset_tracking()
```

--------------------------------

### Parse Tracking Options

Source: https://context7.com/xingyizhou/centertrack/llms.txt

Parses command-line arguments for tracking configuration. Key parameters like thresholds, architecture, and training settings can be adjusted.

```python
from opts import opts

# Parse command line arguments
opt = opts().parse('tracking --load_model model.pth --gpus 0,1'.split())
```

--------------------------------

### Run Person Tracking Demo

Source: https://github.com/xingyizhou/centertrack/blob/master/README.md

To perform person-specific tracking, use this command and set `--num_class` to 1. This is useful when the model is trained for a single class like pedestrians.

```bash
python demo.py tracking --load_model ../models/mot17_half.pth --num_class 1 --demo /path/to/image/or/folder/or/video
```

--------------------------------

### Access Model Architecture Settings

Source: https://context7.com/xingyizhou/centertrack/llms.txt

Prints model architecture configuration details such as the network architecture, head convolution channels, and downsampling ratio.

```python
# Model architecture settings
print(f"Architecture: {opt.arch}")                 # Default: dla_34
print(f"Head conv channels: {opt.head_conv}")      # Default: 256 for DLA
print(f"Down ratio: {opt.down_ratio}")             # Default: 4
```

--------------------------------

### Run Monocular 3D Tracking on Webcam/Video

Source: https://github.com/xingyizhou/centertrack/blob/master/README.md

This command enables monocular 3D tracking for various input sources including webcam, video files, or image folders. Ensure the correct model and task are specified.

```bash
python demo.py tracking,ddd --demo webcam --load_model ../models/coco_tracking.pth --demo /path/to/image/or/folder/or/webcam
```

--------------------------------

### Visualize Debugging Information

Source: https://github.com/xingyizhou/centertrack/blob/master/README.md

Add the `--debug 2` flag to visualize heatmap and offset predictions during the demo run. This is helpful for understanding model behavior.

```bash
python demo.py tracking --load_model ../models/coco_tracking.pth --demo /path/to/image/or/folder/or/video --debug 2
```

--------------------------------

### Integrate CenterTrack into a Project

Source: https://github.com/xingyizhou/centertrack/blob/master/README.md

This Python code demonstrates how to import and use the CenterTrack detector in your own project. It requires setting up the system path and initializing the detector with specific options.

```python
import sys
CENTERTRACK_PATH = /path/to/CenterTrack/src/lib/
sys.path.insert(0, CENTERTRACK_PATH)

from detector import Detector
from opts import opts

MODEL_PATH = /path/to/model
TASK = 'tracking' # or 'tracking,multi_pose' for pose tracking and 'tracking,ddd' for monocular 3d tracking
opt = opts().init('{} --load_model {}'.format(TASK, MODEL_PATH).split(' '))
detector = Detector(opt)

images = ['''image read from open cv or from a video''']
for img in images:
  ret = detector.run(img)['results']
```

--------------------------------

### Resume Training

Source: https://github.com/xingyizhou/centertrack/blob/master/readme/GETTING_STARTED.md

If training is interrupted, use the same command with the `--resume` flag to continue from the latest saved model. The system automatically finds the model with the matching `exp_id`.

```python
--resume
```

--------------------------------

### Download and Prepare MOT 2017 Dataset

Source: https://github.com/xingyizhou/centertrack/blob/master/readme/DATA.md

Use this script to download, unzip, convert MOT 2017 dataset to COCO format, and create train/validation splits.

```bash
cd $CenterTrack_ROOT/tools/ 
bash get_mot_17.sh
```

--------------------------------

### Evaluate KITTI Tracking Performance

Source: https://github.com/xingyizhou/centertrack/blob/master/readme/GETTING_STARTED.md

Run this command to test tracking performance on the KITTI dataset with a pretrained model. The `--track_thresh` parameter controls the score threshold for predictions.

```python
python test.py tracking --exp_id kitti_half --dataset kitti_tracking --dataset_version val_half --pre_hm --track_thresh 0.4 --load_model ../models/kitti_half.pth
```

--------------------------------

### Train MOT17 Model from CrowdHuman Weights

Source: https://context7.com/xingyizhou/centertrack/llms.txt

Train a MOT17 model using weights pretrained on CrowdHuman. This command configures dataset, augmentation, and GPU usage.

```bash
python main.py tracking \
    --exp_id mot17_half \
    --dataset mot \
    --dataset_version 17halftrain \
    --pre_hm \
    --ltrb_amodal \
    --same_aug \
    --hm_disturb 0.05 \
    --lost_disturb 0.4 \
    --fp_disturb 0.1 \
    --gpus 0,1 \
    --load_model ../models/crowdhuman.pth
```

--------------------------------

### Access Data Augmentation Settings

Source: https://context7.com/xingyizhou/centertrack/llms.txt

Prints settings for data augmentation techniques used during tracking, such as heatmap jittering, simulating lost detections, and adding false positives.

```python
# Data augmentation for tracking
print(f"Heatmap disturb: {opt.hm_disturb}")        # Jitter heatmap centers
print(f"Lost disturb: {opt.lost_disturb}")         # Simulate lost detections
print(f"FP disturb: {opt.fp_disturb}")             # Add false positive heatmaps
```

--------------------------------

### Train CenterTrack on Custom Dataset

Source: https://github.com/xingyizhou/centertrack/blob/master/README.md

This command shows how to train CenterTrack on a custom dataset. You need to specify dataset paths, input resolutions, number of classes, and various training hyperparameters.

```bash
python main.py tracking --exp_id mot17_half_sc --dataset custom --custom_dataset_ann_path ../data/mot17/annotations/train_half.json --custom_dataset_img_path ../data/mot17/train/ --input_h 544 --input_w 960 --num_classes 1 --pre_hm --ltrb_amodal --same_aug --hm_disturb 0.05 --lost_disturb 0.4 --fp_disturb 0.1 --gpus 0,1
```

--------------------------------

### Convert KITTI Tracking to COCO Format

Source: https://github.com/xingyizhou/centertrack/blob/master/readme/DATA.md

Run this Python script to convert KITTI Tracking annotations into COCO format. Ensure the dataset is placed in the expected directory structure.

```python
python convert_kitti_to_coco.py
```

--------------------------------

### Access Tracking Parameters

Source: https://context7.com/xingyizhou/centertrack/llms.txt

Accesses and prints various tracking parameters from the parsed options. Defaults are provided for reference.

```python
# Key tracking parameters
print(f"Track threshold: {opt.track_thresh}")      # Default: 0.3
print(f"Pre-threshold: {opt.pre_thresh}")          # For heatmap rendering
print(f"New track threshold: {opt.new_thresh}")    # For creating new tracks
print(f"Max frame distance: {opt.max_frame_dist}") # Default: 3
```

--------------------------------

### Evaluate MOT17 with Public Detections

Source: https://github.com/xingyizhou/centertrack/blob/master/readme/GETTING_STARTED.md

This command evaluates MOT17 tracking performance using public detections. Ensure the path to `val_half_det.json` is correct.

```python
python test.py tracking --exp_id mot17_half_public --dataset mot --dataset_version 17halfval --pre_hm --ltrb_amodal --track_thresh 0.4 --pre_thresh 0.5 --load_model ../models/mot17_half.pth --public_det --load_results ../data/mot17/results/val_half_det.json
```

--------------------------------

### Train on Custom Dataset with COCO Annotations

Source: https://context7.com/xingyizhou/centertrack/llms.txt

Train a tracking model on a custom dataset using COCO-format annotations. Configure dataset paths, input dimensions, number of classes, and augmentation settings.

```bash
python main.py tracking \
    --exp_id custom_tracking \
    --dataset custom \
    --custom_dataset_ann_path ../data/custom/annotations/train.json \
    --custom_dataset_img_path ../data/custom/images/ \
    --input_h 544 \
    --input_w 960 \
    --num_classes 1 \
    --pre_hm \
    --ltrb_amodal \
    --same_aug \
    --hm_disturb 0.05 \
    --lost_disturb 0.4 \
    --fp_disturb 0.1 \
    --gpus 0,1
```

--------------------------------

### Clone repository

Source: https://github.com/xingyizhou/centertrack/blob/master/readme/INSTALL.md

Clones the CenterTrack repository recursively to a specified root directory.

```bash
CenterTrack_ROOT=/path/to/clone/CenterTrack
git clone --recursive https://github.com/xingyizhou/CenterTrack $CenterTrack_ROOT
```

--------------------------------

### Evaluate nuScenes 3D Tracking

Source: https://github.com/xingyizhou/centertrack/blob/master/readme/GETTING_STARTED.md

Command to evaluate 3D tracking performance on the nuScenes dataset. The `--track_thresh` parameter is set to 0.1 for this evaluation.

```python
python test.py tracking,ddd --exp_id nuScenes_3Dtracking --load_model ../models/nuScenes_3Dtracking.pth --dataset nuscenes --track_thresh 0.1 --pre_hm
```

--------------------------------

### Train COCO 80-Category Tracking Model

Source: https://context7.com/xingyizhou/centertrack/llms.txt

Train a COCO-based tracking model, loading weights from a detection model. This command specifies multi-GPU usage, batch size, learning rate, and data augmentation parameters.

```bash
python main.py tracking \
    --exp_id coco_tracking \
    --tracking \
    --load_model ../models/ctdet_coco_dla_2x.pth \
    --gpus 0,1,2,3,4,5,6,7 \
    --batch_size 128 \
    --lr 5e-4 \
    --num_workers 16 \
    --pre_hm \
    --shift 0.05 \
    --scale 0.05 \
    --hm_disturb 0.05 \
    --lost_disturb 0.4 \
    --fp_disturb 0.1
```

--------------------------------

### Evaluate MOT17 Tracking Performance

Source: https://github.com/xingyizhou/centertrack/blob/master/readme/GETTING_STARTED.md

Use this command to test tracking performance on MOT17 with a pretrained model. The `--pre_hm` flag enables input heatmap, and `--ltrb_amodal` uses a bounding box representation important for MOT datasets. Adjust `--track_thresh` and `--pre_thresh` for score thresholds.

```python
python test.py tracking --exp_id mot17_half --dataset mot --dataset_version 17halfval --pre_hm --ltrb_amodal --track_thresh 0.4 --pre_thresh 0.5 --load_model ../models/mot17_half.pth
```

--------------------------------

### Create Conda Environment

Source: https://context7.com/xingyizhou/centertrack/llms.txt

Creates a new conda environment named 'CenterTrack' with Python 3.6.

```bash
# Create conda environment
conda create --name CenterTrack python=3.6
conda activate CenterTrack
```

--------------------------------

### Evaluate MOT17 on Test Set with Public Detections

Source: https://github.com/xingyizhou/centertrack/blob/master/readme/GETTING_STARTED.md

Command to evaluate MOT17 on the test set using public detections. Note that test set submissions are discouraged to prevent abuse. Append `--debug 2` to visualize predictions.

```python
python test.py tracking --exp_id mot17_fulltrain_public --dataset mot --dataset_version 17test --pre_hm --ltrb_amodal --track_thresh 0.4 --pre_thresh 0.5 --load_model ../models/mot17_fulltrain_sc.pth --public_det --load_results ../data/mot17/results/test_det.json
```

--------------------------------

### Clone CenterTrack Repository

Source: https://context7.com/xingyizhou/centertrack/llms.txt

Clones the CenterTrack repository, including all submodules, and navigates into the directory.

```bash
# Clone repository with submodules
git clone --recursive https://github.com/xingyizhou/CenterTrack
cd CenterTrack
```

--------------------------------

### Compile DCNv2

Source: https://context7.com/xingyizhou/centertrack/llms.txt

Compiles the DCNv2 (Deformable Convolutions) C++ extension, which is necessary for optimal performance. This involves navigating to the DCNv2 directory and running the make script.

```bash
# Compile DCNv2 (Deformable Convolutions)
cd src/lib/model/networks/DCNv2
./make.sh
cd ../../../../..
```

--------------------------------

### Save Tracking Results to JSON

Source: https://context7.com/xingyizhou/centertrack/llms.txt

Use this command to save tracking results in JSON format for submission. Specify experiment ID, dataset details, model path, and enable result saving.

```bash
python test.py tracking \
    --exp_id mot17_test \
    --dataset mot \
    --dataset_version 17test \
    --load_model ../models/mot17_fulltrain.pth \
    --save_results
```

--------------------------------

### Convert Dataset to COCO Format

Source: https://context7.com/xingyizhou/centertrack/llms.txt

A Python function to convert custom dataset annotations into the COCO format required by CenterTrack. It processes image paths and bounding boxes.

```python
# Convert custom dataset to COCO format
import json

def create_coco_annotation(images_dir, output_path):
    annotations = {"images": [], "annotations": [], "categories": [{"id": 1, "name": "person"}]}
    ann_id = 0

    # Process your data...
    for img_id, (img_path, bboxes) in enumerate(your_data):
        annotations["images"].append({
            "id": img_id,
            "file_name": img_path,
            "height": 720,
            "width": 1280
        })
        for bbox in bboxes:
            annotations["annotations"].append({
                "id": ann_id,
                "image_id": img_id,
                "category_id": 1,
                "bbox": bbox,
                "area": bbox[2] * bbox[3],
                "iscrowd": 0
            })
            ann_id += 1

    with open(output_path, 'w') as f:
        json.dump(annotations, f)
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.