### Basic Norfair Tracking Workflow

Source: https://github.com/tryolabs/norfair/blob/master/docs/getting_started.md

This Python code demonstrates a fundamental tracking loop using Norfair. It initializes a detector and video source, creates a Tracker, and processes frames by updating the tracker with new detections and drawing the results. This illustrates 'online tracking' suitable for real-time applications.

```python
from norfair import Detection, Tracker, Video, draw_tracked_objects

detector = MyDetector()  # Set up a detector
video = Video(input_path="video.mp4")
tracker = Tracker(distance_function="euclidean", distance_threshold=100)

for frame in video:
   detections = detector(frame)
   norfair_detections = [Detection(points) for points in detections]
   tracked_objects = tracker.update(detections=norfair_detections)
   draw_tracked_objects(frame, tracked_objects)
   video.write(frame)
```

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

### Install Norfair Minimal Version (Python)

Source: https://github.com/tryolabs/norfair/blob/master/README.md

Installs the basic Norfair library for Python. This is the minimal installation and does not include extra features requiring additional dependencies.

```bash
pip install norfair
```

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

### Run YOLOv4 Tracking Demo

Source: https://github.com/tryolabs/norfair/blob/master/demos/yolov4/README.md

Executes the YOLOv4 object tracking demo with specified video input. This command-line interface allows for basic tracking functionality and provides help for additional configuration options.

```bash
python demo.py <video>.mp4
python demo.py --help
```

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

### Display Detectron2 Tracking Help

Source: https://github.com/tryolabs/norfair/blob/master/demos/detectron2/README.md

Displays the help message for the object tracking demo script, listing all available configuration options and parameters. Use this to understand additional settings for customization.

```bash
python demo.py --help
```

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

### Install Norfair with All Features (Python)

Source: https://github.com/tryolabs/norfair/blob/master/README.md

Installs Norfair with all available features, including video helper functionalities and MOT metrics evaluation. This provides the most comprehensive set of capabilities for Norfair.

```bash
pip install norfair[metrics,video]
```

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

### Serve Documentation Locally (Debug)

Source: https://github.com/tryolabs/norfair/blob/master/CONTRIBUTING.md

Command to start a local development server for mkdocs to debug documentation changes. It provides live reloading.

```shell
poetry run mkdocs serve
```

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

### Install Norfair with Metrics Features (Python)

Source: https://github.com/tryolabs/norfair/blob/master/README.md

Installs Norfair with support for running Multiple Object Tracking (MOT) metrics evaluation. This is useful for benchmarking and assessing tracking performance.

```bash
pip install norfair[metrics]
```

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

### Run 3D Object Tracking Demo (Bash)

Source: https://github.com/tryolabs/norfair/blob/master/demos/3d_track/README.md

Executes the 3D object tracking demonstration script. It takes a video file as input and processes it to track objects using 3D bounding boxes. Additional configurations can be accessed via the --help flag.

```bash
python demo.py video.mp4
```

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

### Install Documentation Dependencies

Source: https://github.com/tryolabs/norfair/blob/master/CONTRIBUTING.md

Command to install Python dependencies required for building and serving the documentation using pip.

```shell
poetry run pip install -r docs/requirements.txt
```

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

### Install Norfair with Video Features (Python)

Source: https://github.com/tryolabs/norfair/blob/master/README.md

Installs Norfair along with dependencies for video-related features, which typically rely on OpenCV. This installation is suitable for projects involving video processing.

```bash
pip install norfair[video]
```

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

### Install Norfair Dependencies with Pip

Source: https://github.com/tryolabs/norfair/blob/master/demos/colab/colab_demo.ipynb

This code snippet downloads the requirements.txt file and installs the necessary Python packages for the Norfair library using pip. Ensure you have internet connectivity to download the file and install packages.

```shell
! wget "https://raw.githubusercontent.com/tryolabs/norfair/master/demos/colab/requirements.txt" -O requirements.txt
! pip install -r requirements.txt
```

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

### Install Norfair Dependencies with Poetry

Source: https://github.com/tryolabs/norfair/blob/master/CONTRIBUTING.md

Command to install all project dependencies, including extras, using Poetry. This ensures the project environment is correctly set up.

```shell
poetry install --all-extras
```

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

### Run Demo Script (Bash)

Source: https://github.com/tryolabs/norfair/blob/master/demos/openpose/README.md

This command executes the Norfair demo script. It takes a video file as input and utilizes Norfair to extrapolate detections across skipped frames for faster processing. Use `--help` for additional configuration options.

```bash
python demo.py <video>.mp4
```

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

### Track Multiple Object Classes Simultaneously with Norfair

Source: https://context7.com/tryolabs/norfair/llms.txt

This example shows how to track objects belonging to different classes concurrently using Norfair. The `Tracker` can handle multiple classes by using the `label` attribute of `Detection` objects. The tracker automatically ensures that objects only match with other objects of the same class during the update process.

```python
from norfair import Tracker, Detection
import numpy as np

# Tracker automatically handles multiple classes
tracker = Tracker(
    distance_function="euclidean",
    distance_threshold=30
)

# Create detections with different labels
detections = [
    Detection(
        points=np.array([[100, 200]]),
        label=0  # person
    ),
    Detection(
        points=np.array([[300, 150]]),
        label=2  # car
    ),
    Detection(
        points=np.array([[500, 400]]),
        label=0  # another person
    )
]

# Update tracker - objects only match within same class
tracked_objects = tracker.update(detections=detections)

# Filter by class
people = [obj for obj in tracked_objects if obj.label == 0]
cars = [obj for obj in tracked_objects if obj.label == 2]

print(f"Tracking {len(people)} people and {len(cars)} cars")
```

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

### Track with Camera Motion Compensation using Norfair

Source: https://context7.com/tryolabs/norfair/llms.txt

Handles moving cameras by estimating camera motion between frames using homography or translation transformations. It initializes a MotionEstimator and a Tracker, then processes video frames to get detections, estimate motion, and update the tracker with coordinate transformations. Objects are tracked in absolute coordinates.

```python
from norfair import Tracker, Detection, Video
from norfair.camera_motion import MotionEstimator, HomographyTransformationGetter
import numpy as np

# Initialize motion estimator with homography
motion_estimator = MotionEstimator(
    max_points=200,
    min_distance=15,
    transformations_getter=HomographyTransformationGetter(
        proportion_points_used_threshold=0.9
    )
)

# Initialize tracker
tracker = Tracker(
    distance_function="euclidean",
    distance_threshold=30
)

video = Video(input_path="moving_camera.mp4", output_path="tracked.mp4")

for frame in video:
    # Estimate camera motion for this frame
    coord_transformations = motion_estimator.update(frame)

    # Get detections
    detections = get_detections(frame)
    norfair_detections = [
        Detection(points=np.array([[d['x'], d['y']]]))
        for d in detections
    ]

    # Update tracker with coordinate transformations
    tracked_objects = tracker.update(
        detections=norfair_detections,
        coord_transformations=coord_transformations
    )

    # Objects are now tracked in absolute coordinates
    for obj in tracked_objects:
        # Get position in current frame (relative)
        rel_pos = obj.get_estimate(absolute=False)
        # Get position in absolute coordinate system
        abs_pos = obj.get_estimate(absolute=True)

    video.write(frame)
```

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

### Deploy and Serve Documentation (Production)

Source: https://github.com/tryolabs/norfair/blob/master/CONTRIBUTING.md

Commands to deploy the documentation to a 'dev' version and serve it locally using mike. This shows the final rendered documentation.

```shell
poetry run mike deploy dev
poetry run mike serve
```

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

### Download and Preprocess Video with FFmpeg

Source: https://github.com/tryolabs/norfair/blob/master/demos/colab/colab_demo.ipynb

This snippet downloads a sample MP4 video and then uses FFmpeg to trim it to a 10-second segment. This is useful for creating shorter, manageable video clips for demos or testing, especially in environments with limited playback capabilities.

```shell
! wget "https://drive.google.com/u/0/uc?id=1Jc5TAiwOZ-yUO6R_tG0zSW9Niv_HKTPV&export=download" -O sample.mp4
! ffmpeg -i sample.mp4 -ss 7 -t 10 sample_10s.mp4
```

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

### Create Norfair Detection Objects (Python)

Source: https://context7.com/tryolabs/norfair/llms.txt

Demonstrates creating Norfair Detection objects from various data formats including centroid, bounding box, and keypoints. Includes scores, labels, and optional custom data. Dependencies: numpy.

```python
from norfair import Detection
import numpy as np

# Centroid detection with confidence score
detections = []
centroid = np.array([[320.5, 240.8]])
score = np.array([0.95])
detection = Detection(
    points=centroid,
    scores=score,
    label=0  # class label (e.g., 0=person, 2=car)
)
detections.append(detection)

# Bounding box detection (two corner points)
bbox = np.array([
    [100, 150],  # top-left corner
    [250, 350]   # bottom-right corner
])
scores = np.array([0.87, 0.87])
bbox_detection = Detection(
    points=bbox,
    scores=scores,
    label=2
)

# Keypoint detection with scores and custom data
keypoints = np.array([
    [120, 100],  # nose
    [115, 110],  # left eye
    [125, 110],  # right eye
    [110, 130],  # left shoulder
    [130, 130]   # right shoulder
])
keypoint_scores = np.array([0.9, 0.85, 0.88, 0.92, 0.91])
pose_detection = Detection(
    points=keypoints,
    scores=keypoint_scores,
    label=0,
    data={'person_id': 'A', 'height': 180}  # custom metadata
)
```

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

### Download Norfair Demo Scripts and Run Tracking

Source: https://github.com/tryolabs/norfair/blob/master/demos/colab/colab_demo.ipynb

This section downloads the necessary Python scripts (demo.py, draw.py, yolo.py) for the Norfair demo and then executes the main demo script using 'python demo.py'. It specifies the input video ('sample_10s.mp4') and filters for objects with class ID 0 (typically 'person' in COCO dataset).

```shell
! wget "https://raw.githubusercontent.com/tryolabs/norfair/master/demos/colab/demo.py"
! wget "https://raw.githubusercontent.com/tryolabs/norfair/master/demos/colab/draw.py"
! wget "https://raw.githubusercontent.com/tryolabs/norfair/master/demos/colab/yolo.py"

! python demo.py sample_10s.mp4 --classes 0
```

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

### Integrate Norfair with Detectron2 for Video Object Tracking

Source: https://github.com/tryolabs/norfair/blob/master/README.md

This Python code snippet demonstrates how to set up Detectron2 as an object detector and use Norfair for tracking objects in a video. It initializes the detector, Norfair tracker, and a video processing loop. Detections from Detectron2 are converted to Norfair's Detection format, tracked, and visualized on the video frames.

```python
import cv2
import numpy as np
from detectron2.config import get_cfg
from detectron2.engine import DefaultPredictor

from norfair import Detection, Tracker, Video, draw_tracked_objects

# Set up Detectron2 object detector
cfg = get_cfg()
cfg.merge_from_file("demos/faster_rcnn_R_50_FPN_3x.yaml")
cfg.MODEL.ROI_HEADS.SCORE_THRESH_TEST = 0.5
cfg.MODEL.WEIGHTS = "detectron2://COCO-InstanceSegmentation/mask_rcnn_R_50_FPN_3x/137849600/model_final_f10217.pkl"
detector = DefaultPredictor(cfg)

# Norfair
video = Video(input_path="video.mp4")
tracker = Tracker(distance_function="euclidean", distance_threshold=20)

for frame in video:
    detections = detector(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB))
    detections = [Detection(p) for p in detections['instances'].pred_boxes.get_centers().cpu().numpy()]
    tracked_objects = tracker.update(detections=detections)
    draw_tracked_objects(frame, tracked_objects)
    video.write(frame)
```

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

### Initialize Norfair Tracker with Distance Functions (Python)

Source: https://context7.com/tryolabs/norfair/llms.txt

Initializes the Norfair Tracker with various distance functions, including predefined Euclidean and IoU, and a custom function. The distance threshold controls match validity. Dependencies: numpy.

```python
from norfair import Tracker, Detection
import numpy as np

# Using predefined Euclidean distance for centroid tracking
tracker = Tracker(
    distance_function="euclidean",
    distance_threshold=30,
    hit_counter_max=15,
    initialization_delay=3
)

# Using IoU distance for bounding box tracking
bbox_tracker = Tracker(
    distance_function="iou",
    distance_threshold=0.7,
    hit_counter_max=20
)

# Using custom distance function
def custom_distance(detection, tracked_object):
    """Custom weighted distance combining position and size"""
    pos_diff = np.linalg.norm(detection.points - tracked_object.estimate)
    size_diff = abs(detection.data['size'] - tracked_object.last_detection.data['size'])
    return pos_diff + 0.3 * size_diff

custom_tracker = Tracker(
    distance_function=custom_distance,
    distance_threshold=50
)
```

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

### Initialize Norfair Tracker with Custom Kalman Filters (Python)

Source: https://context7.com/tryolabs/norfair/llms.txt

Initializes Norfair trackers using different Kalman filter factories: OptimizedKalmanFilterFactory, FilterPyKalmanFilterFactory with custom noise parameters, and NoFilterFactory to disable filtering. This allows tailoring the tracking behavior to specific motion models and noise characteristics.

```python
from norfair import Tracker, FilterPyKalmanFilterFactory, OptimizedKalmanFilterFactory, NoFilterFactory

# Default optimized Kalman filter
tracker_default = Tracker(
    distance_function="euclidean",
    distance_threshold=30,
    filter_factory=OptimizedKalmanFilterFactory()
)

# Use FilterPy implementation with custom parameters
filterpy_factory = FilterPyKalmanFilterFactory(
    R=4.0,  # Measurement noise
    Q=0.1   # Process noise
)
tracker_filterpy = Tracker(
    distance_function="euclidean",
    distance_threshold=30,
    filter_factory=filterpy_factory
)

# Disable filtering (use raw detections)
no_filter_factory = NoFilterFactory()
tracker_no_filter = Tracker(
    distance_function="euclidean",
    distance_threshold=30,
    filter_factory=no_filter_factory
)
```

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

### Clone Norfair Repository

Source: https://github.com/tryolabs/norfair/blob/master/CONTRIBUTING.md

Command to clone the Norfair project repository using Git. This is the first step in setting up the project locally for development.

```shell
git clone git@github.com:tryolabs/norfair.git
```

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

### Display WebM Video in Jupyter Notebook

Source: https://github.com/tryolabs/norfair/blob/master/demos/colab/colab_demo.ipynb

This Python code snippet reads a WebM video file, encodes it in base64, and then generates an HTML <video> tag to display the video within a Jupyter Notebook or similar environment. This allows for inline playback of the processed video.

```python
import io
from base64 import b64encode
from IPython.display import HTML

with  io.open('sample.webm','r+b') as f:
    mp4 = f.read()
data_url = "data:video/webm;base64," + b64encode(mp4).decode()
HTML("""
<video width=800 controls>
      <source src=\"%s\" type=\"video/webm">
</video>
""" % data_url)
```

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

### Configure Video Input and Output with Norfair's Video Class

Source: https://context7.com/tryolabs/norfair/llms.txt

This Python code utilizes the `norfair.Video` class for streamlined video processing. It allows easy iteration over video frames from files or webcams, handles automatic output encoding, and provides progress tracking. The `Video` class simplifies reading frames and writing processed frames back to a file or displaying them.

```python
from norfair import Video

# Process video file
video = Video(
    input_path="input.mp4",
    output_path="output.mp4",
    output_fps=30,
    label="Processing",
    output_fourcc="H264",  # Smaller file size
    output_extension="mp4"
)

for frame in video:
    # Process frame
    processed_frame = process(frame) # Replace 'process' with your frame processing function
    video.write(processed_frame)

# Use webcam as input
camera_video = Video(
    camera=0,  # Device ID
    output_path="camera_output.mp4",
    output_fps=30
)

for frame in camera_video:
    processed_frame = process(frame) # Replace 'process' with your frame processing function
    camera_video.write(processed_frame)

    # Display in GUI window
    key = camera_video.show(frame, downsample_ratio=1.0)
    if key == ord('q'):
        break

# Get output file path
output_file = video.get_output_file_path()
print(f"Video saved to: {output_file}")
```

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

### Convert MP4 to WebM with FFmpeg

Source: https://github.com/tryolabs/norfair/blob/master/demos/colab/colab_demo.ipynb

This command uses FFmpeg to convert an MP4 video file ('./sample_10s_out.mp4') into the WebM format ('./sample.webm') using the VP9 video codec. WebM is a web-friendly format suitable for playback in browsers.

```shell
! ffmpeg -i ./sample_10s_out.mp4 -vcodec vp9 ./sample.webm
```

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

### Use Built-in Distance Functions for Norfair Tracking

Source: https://context7.com/tryolabs/norfair/llms.txt

Enables selection from predefined distance functions optimized for different tracking scenarios, including IoU for boxes and various point distances. It demonstrates initializing Trackers with 'iou', 'frobenius', custom keypoint voting, and normalized Euclidean distances.

```python
from norfair import Tracker
from norfair.distances import (
    frobenius,
    mean_euclidean,
    mean_manhattan,
    iou,
    create_keypoints_voting_distance,
    create_normalized_mean_euclidean_distance
)

# IoU distance for bounding boxes
bbox_tracker = Tracker(
    distance_function="iou",  # Returns 1 - IoU
    distance_threshold=0.7
)

# Frobenius norm distance
tracker = Tracker(
    distance_function="frobenius",
    distance_threshold=100
)

# Keypoint voting distance for pose tracking
keypoint_distance = create_keypoints_voting_distance(
    keypoint_distance_threshold=30,
    detection_threshold=0.5
)
pose_tracker = Tracker(
    distance_function=keypoint_distance,
    distance_threshold=0.5
)

# Normalized Euclidean distance for different resolutions
normalized_distance = create_normalized_mean_euclidean_distance(
    height=1080,
    width=1920
)
resolution_tracker = Tracker(
    distance_function=normalized_distance,
    distance_threshold=0.1  # 0-1 range
)

# Using scipy distances
tracker_cosine = Tracker(
    distance_function="cosine",
    distance_threshold=0.3
)
```

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

### Run Tox Tests

Source: https://github.com/tryolabs/norfair/blob/master/CONTRIBUTING.md

Command to run all tests using Tox. Tox will execute tests across different Python versions and an integration performance test.

```shell
poetry run tox
```

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

### Run ISort Formatter

Source: https://github.com/tryolabs/norfair/blob/master/CONTRIBUTING.md

Command to sort Python imports using ISort. This helps maintain organized and consistent import statements.

```shell
poetry run isort .
```

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

### Run Black Formatter

Source: https://github.com/tryolabs/norfair/blob/master/CONTRIBUTING.md

Command to format Python code using the Black code formatter. This ensures code adheres to project style guidelines.

```shell
poetry run black .
```

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

### Draw Tracking Visualizations with Norfair

Source: https://context7.com/tryolabs/norfair/llms.txt

Visualizes tracked objects with customizable colors, labels, and drawing styles for points and bounding boxes. It supports drawing points, bounding boxes, and paths with various styling options like coloring by ID or label, and drawing labels, IDs, and scores.

```python
from norfair import draw_points, draw_boxes, Paths
import numpy as np

# Draw points with custom styling
frame = np.zeros((480, 640, 3), dtype=np.uint8)
draw_points(
    frame,
    drawables=tracked_objects,
    radius=5,
    thickness=2,
    color="by_id",  # Colors by object ID
    draw_labels=True,
    draw_ids=True,
    text_size=0.5,
    text_color=(255, 255, 255)
)

# Draw bounding boxes
draw_boxes(
    frame,
    drawables=tracked_objects,
    line_width=2,
    color="by_label",  # Colors by class label
    draw_labels=True,
    draw_ids=True,
    text_size=0.6
)

# Draw paths showing object trajectories
paths_drawer = Paths(center_distance=50, thickness=2)
paths_drawer.draw(frame, tracked_objects)

# Use specific colors
draw_points(
    frame,
    drawables=tracked_objects,
    color=(0, 255, 0),  # BGR green
    radius=8
)

# Color by label with custom palette
draw_points(
    frame,
    drawables=tracked_objects,
    color="by_label",
    draw_labels=True,
    draw_scores=True
)
```

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

### Update Norfair Tracker and Process Video Frames (Python)

Source: https://context7.com/tryolabs/norfair/llms.txt

Updates the Norfair tracker with detections from each frame and processes video input/output. Displays tracked object information and draws results on frames. Dependencies: norfair, numpy.

```python
from norfair import Tracker, Detection, Video, draw_tracked_objects
import numpy as np

# Initialize tracker
tracker = Tracker(
    distance_function="euclidean",
    distance_threshold=30
)

# Video processing loop
video = Video(input_path="input.mp4", output_path="output.mp4")

for frame in video:
    # Get detections from your detector
    detections = get_detections_from_detector(frame)

    # Convert to Norfair detections
    norfair_detections = [
        Detection(points=np.array([[det['x'], det['y']]]),
                 scores=np.array([det['conf']]),
                 label=det['class'])
        for det in detections
    ]

    # Update tracker with current frame detections
    tracked_objects = tracker.update(detections=norfair_detections)

    # Access tracked object properties
    for obj in tracked_objects:
        print(f"Object ID: {obj.id}")
        print(f"Position estimate: {obj.estimate}")
        print(f"Age: {obj.age} frames")
        print(f"Velocity: {obj.estimate_velocity}")
        print(f"Label: {obj.label}")
        print(f"Last detection: {obj.last_detection.points}")

    # Draw tracking results
    draw_tracked_objects(frame, tracked_objects)
    video.write(frame)
```

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

### Handle Frame Skipping and Variable FPS for Efficient Tracking in Norfair

Source: https://context7.com/tryolabs/norfair/llms.txt

This code illustrates how to efficiently track objects by processing only a subset of frames, thereby handling frame skipping and variable FPS. The `tracker.update` method is called with `period` argument to inform the tracker about the frame skipping interval. When frames are skipped, the tracker relies on Kalman prediction; otherwise, it updates with new detections.

```python
from norfair import Tracker, Detection

tracker = Tracker(
    distance_function="euclidean",
    distance_threshold=30
)

frame_count = 0
skip_frames = 3  # Process every 3rd frame

# Assuming 'video' is an iterable of frames, 'detector' detects objects, and 'convert_to_norfair' converts detections
# Assuming 'draw_tracked_objects' draws on the frame and 'video.write' writes the frame

for frame in video:
    frame_count += 1

    if frame_count % skip_frames == 0:
        # Run detector only on selected frames
        detections = detector(frame)
        norfair_detections = convert_to_norfair(detections)

        # Tell tracker about frame skipping period
        tracked_objects = tracker.update(
            detections=norfair_detections,
            period=skip_frames
        )
    else:
        # Update tracker without detections (Kalman prediction only)
        tracked_objects = tracker.update(
            detections=None,
            period=1
        )

    # Draw and write every frame
    draw_tracked_objects(frame, tracked_objects)
    video.write(frame)
```

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

### Create Detections with Embeddings for Norfair Tracker

Source: https://context7.com/tryolabs/norfair/llms.txt

This snippet demonstrates how to create Norfair `Detection` objects, extracting appearance embeddings from detected regions in video frames. These embeddings are crucial for ReID (Re-Identification) to handle occluded objects. The `tracker.update` method then uses these detections for tracking.

```python
from norfair import Tracker, Detection
import numpy as np

# Assuming 'detector' is an object detection model and 'embedding_model' extracts features
# Assuming 'video' is an iterable of frames and 'frame' is a numpy array
# Assuming 'tracker' is an initialized Norfair Tracker instance

for frame in video:
    raw_detections = detector(frame)
    norfair_detections = []

    for det in raw_detections:
        # Extract appearance embedding from detection region
        bbox = det['bbox']
        crop = frame[bbox[1]:bbox[3], bbox[0]:bbox[2]]
        embedding = embedding_model.extract(crop)  # Shape: (512,)

        detection = Detection(
            points=np.array([[det['x'], det['y']]]),
            embedding=embedding
        )
        norfair_detections.append(detection)

    # Tracker will use ReID for occluded objects
    tracked_objects = tracker.update(detections=norfair_detections)
```

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

### Track with Re-identification (ReID) using Norfair

Source: https://context7.com/tryolabs/norfair/llms.txt

Enables re-identification to handle occlusions and maintain object identity using appearance embeddings. It initializes a Tracker with a custom `reid_distance_function` and `reid_distance_threshold` to compare appearance embeddings between tracked objects.

```python
from norfair import Tracker, Detection
import numpy as np

def reid_distance(tracked_obj_1, tracked_obj_2):
    """Calculate cosine distance between appearance embeddings"""
    emb1 = tracked_obj_1.last_detection.embedding
    emb2 = tracked_obj_2.last_detection.embedding

    if emb1 is None or emb2 is None:
        return float('inf')

    # Cosine distance
    dot_product = np.dot(emb1, emb2)
    norm_product = np.linalg.norm(emb1) * np.linalg.norm(emb2)
    return 1 - (dot_product / norm_product)

# Initialize tracker with ReID
tracker = Tracker(
    distance_function="euclidean",
    distance_threshold=30,
    reid_distance_function=reid_distance,
    reid_distance_threshold=0.4,
    reid_hit_counter_max=100
)
```

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

### Run AlphaPose inference with custom detector

Source: https://github.com/tryolabs/norfair/blob/master/demos/alphapose/README.md

This bash command executes the AlphaPose inference script with specified detector, configuration, checkpoint, video input, and output directory. It's used to process videos and save the results.

```bash
python3 scripts/demo_inference.py --detector yolo --cfg configs/coco/resnet/256x192_res50_lr1e-3_1x.yaml --checkpoint pretrained_models/fast_res50_256x192.pth --video /demo/video.mp4 --save_video --outdir /demo/
```

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

### Access Past Detections and History for Temporal Analysis in Norfair

Source: https://context7.com/tryolabs/norfair/llms.txt

This snippet demonstrates how to access historical detection data stored by the Norfair tracker. By setting `past_detections_length` during tracker initialization, you can store and analyze past positions, ages, and custom data (like embeddings) of tracked objects. This is useful for calculating metrics like average speed or performing temporal analysis.

```python
from norfair import Tracker, Detection
import numpy as np

# Store past detections
tracker = Tracker(
    distance_function="euclidean",
    distance_threshold=30,
    past_detections_length=10  # Store last 10 detections
)

# Assuming 'detections' is a list of Detection objects and 'tracked_objects' is the result of tracker.update()
# Process frames
tracked_objects = tracker.update(detections=detections)

# Access detection history
for obj in tracked_objects:
    print(f"Object {obj.id} age: {obj.age}")
    print(f"Number of past detections: {len(obj.past_detections)}")

    # Analyze trajectory
    positions = [det.points for det in obj.past_detections]
    ages = [det.age for det in obj.past_detections]

    # Calculate average speed
    if len(positions) >= 2:
        displacement = np.linalg.norm(positions[-1] - positions[0])
        time_span = ages[-1] - ages[0]
        avg_speed = displacement / max(time_span, 1)
        print(f"Average speed: {avg_speed:.2f} pixels/frame")

    # Access custom data from past detections
    if obj.past_detections and hasattr(obj.past_detections[0], 'data'):
        for det in obj.past_detections:
            if det.data and 'embedding' in det.data:
                embedding_history = det.data['embedding']
```