SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 1602.00763 · 2016

Simple Online and Realtime Tracking

arXiv · PDF · Open in the Atlas

Code that ran

33 of 40 samples (functions and classes) lifted from this paper's linked repositories executed on a synthesized input in Syntology's jail (0 of them constructed an object rather than computing a result; 3 honoured the contract we drafted, 2 violated it and 16 have no contract verdict; 12 failures of our instrument; 7 no recorded run), measured 2026-11-22; repository links from the Papers with Code archive attributed under CC BY-SA, no affiliation; bodies inline only under a permissive licence as GitHub detects it. Not a reproduction of the paper's results.

"Ran" means the function executed on a synthesized input and returned a value. It is not a reproduction of the paper's results. This record, dated, as JSON: /api/ran/1602.00763.json · badge: /api/ran/1602.00763.svg

Each repository's role is a label: a classifier's output recorded on the link, or, where no role is recorded, what the Papers with Code archive marked. The line under it names its basis. Neither says who wrote the code.

RepositoryRoleRan
noahcao/OC_SORT canonical (classifier label)
classifier basis: classifier_2025
4 ran · 0 no recorded run
cdulhanty/syde672 canonical (classifier label)
classifier basis: classifier_2025
2 ran · 0 no recorded run
choiwb/Computer_Vision_for_Smart_Factory community (classifier label)
classifier basis not recorded on the link
11 ran · 0 no recorded run
tryolabs/norfair community (classifier label)
classifier basis not recorded on the link
7 ran · 4 no recorded run
chetanchawla/Sort-Tracker reimplementation (classifier label)
classifier basis: classifier_2025
2 ran · 0 no recorded run
nilesh0109/PedestrianTracking reimplementation (classifier label)
classifier basis: classifier_2025
2 ran · 0 no recorded run
twairball/pyTracking reimplementation (classifier label)
classifier basis: classifier_2025
1 ran · 1 no recorded run
nakul-shahdadpuri/narknet community (classifier label)
classifier basis not recorded on the link
1 ran · 1 no recorded run
lyqcom/deepsort reimplementation (classifier label)
classifier basis: classifier_2025
1 ran · 0 no recorded run
XiwangLi/object-tracking-SORT-Pytorch reimplementation (classifier label)
classifier basis: classifier_2025
1 ran · 0 no recorded run
wmuron/motpy reimplementation (classifier label)
classifier basis: classifier_2025
1 ran · 0 no recorded run
LKLQQ/Deepsort reimplementation (classifier label)
classifier basis: classifier_2025
0 ran · 1 no recorded run
FunctionStatusWhere it lives
bbox_iou Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
choiwb/Computer_Vision_for_Smart_Factory/utils/utils.py
code served (permissive licence) · get_code("359c906d4db69e92")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1) and returned Tensor, ndim 1, dtype family float, shape (2,) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch

torch.manual_seed(0)

# Create two small bounding box tensors
# Format: [x1, y1, x2, y2] for x1y1x2y2=True format
# Shape: (batch_size, 4)
box1 = torch.tensor([
    [10.0, 20.0, 50.0, 60.0],
    [15.0, 25.0, 55.0, 65.0]
], dtype=torch.float32)

box2 = torch.tensor([
    [30.0, 40.0, 70.0, 80.0],
    [20.0, 30.0, 60.0, 70.0]
], dtype=torch.float32)

ARGS = {
    "box1": box1,
    "box2": box2,
    "x1y1x2y2": True
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 1, dtype family float, shape (2,) — shape (2,) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
bool_string Ran
ran, violated the contract we drafted
lyqcom/deepsort/deep_sort_app.py
code served (permissive licence) · get_code("42bbfbed664eb9d5")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Sonnet 4.5, prompt python_fixture_v1) and returned bool, ndim 0, dtype family float, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

ARGS = {
    'input_string': 'True'
}
Setup block drafted by
a language model, Claude Sonnet 4.5, prompt python_fixture_v1
Imports
none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type bool, ndim 0, dtype family float, shape () — shape () as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
ccw Ran
ran on a synthesized input
choiwb/Computer_Vision_for_Smart_Factory/object_tracke_v1.0.py
code served (permissive licence) · get_code("9bcf47e29390b205")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned bool, ndim 0, dtype family float, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import numpy as np

torch.manual_seed(0)

# The function ccw computes a counter-clockwise test using three points
# Each point needs to be indexable with [0] and [1] to get x and y coordinates
# A, B, C should be tuple-like or list-like with at least 2 elements

A = (0, 1)
B = (2, 3)
C = (4, 5)

ARGS = {
    'A': A,
    'B': B,
    'C': C
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type bool, ndim 0, dtype family float, shape () — shape () as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
compute_ap Ran
ran on a synthesized input
choiwb/Computer_Vision_for_Smart_Factory/utils/utils.py
code served (permissive licence) · get_code("2fa13d4d71fd9934")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned float64, ndim 0, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import numpy as np

# Construct valid arguments for compute_ap
recall = [0.1, 0.3, 0.5, 0.7, 0.9]
precision = [0.95, 0.85, 0.75, 0.65, 0.55]

ARGS = {
    "recall": recall,
    "precision": precision,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type float64, ndim 0, dtype family float — no output shape is stated: observe_signature.py recorded float ndim 0, which disagrees with the fixture run
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
convertMillis Ran
ran; our contract draft was wrong, not the code
XiwangLi/object-tracking-SORT-Pytorch/object_tracking_Sort.py
pointer only (licence: NONE) · get_code("3b768bba641ad043")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, XiwangLi/object-tracking-SORT-Pytorch when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

convert_bbox_to_z Ran
ran; our contract draft was wrong, not the code
chetanchawla/Sort-Tracker/sort2.py
pointer only (licence: NONE) · get_code("90a45e51733f1779")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, chetanchawla/Sort-Tracker when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

convert_bbox_to_z Ran
ran; our contract draft was wrong, not the code
cdulhanty/syde672/sort.py
pointer only (licence: GPL-3.0) · get_code("3f4bac716d5b5603")
How it ran

The body of this sample is withheld: GPL-3.0, as GitHub detects it on this paper's repository, cdulhanty/syde672, is not in the permissive set Syntology serves inline. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

convert_bbox_to_z Ran
ran; our contract draft was wrong, not the code
noahcao/OC_SORT/trackers/ocsort_tracker/ocsort.py
code served (permissive licence) · get_code("3137f9cd241030bc")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Sonnet 4.5, prompt python_fixture_v1) and returned ndarray, ndim 2, dtype family float, shape (4, 1) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import numpy as np

# The function expects a bounding box in the form [x1, y1, x2, y2]
# where (x1, y1) is the top-left corner and (x2, y2) is the bottom-right corner
# Let's create a simple bounding box

bbox = np.array([10.0, 20.0, 50.0, 80.0])

ARGS = {
    'bbox': bbox
}
Setup block drafted by
a language model, Claude Sonnet 4.5, prompt python_fixture_v1
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ndarray, ndim 2, dtype family float, shape (4, 1) — shape (4, 1) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
convert_x_to_bbox Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
chetanchawla/Sort-Tracker/sort2.py
pointer only (licence: NONE) · get_code("45940bb4051db020")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, chetanchawla/Sort-Tracker when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

convert_x_to_bbox Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
cdulhanty/syde672/sort.py
pointer only (licence: GPL-3.0) · get_code("ca7003e196760c76")
How it ran

The body of this sample is withheld: GPL-3.0, as GitHub detects it on this paper's repository, cdulhanty/syde672, is not in the permissive set Syntology serves inline. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

convert_x_to_bbox Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
twairball/pyTracking/tracking/sort.py
code served (permissive licence) · get_code("d2f6b8f84565e2dd")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Sonnet 4.5, prompt python_fixture_v1) and returned ndarray, ndim 2, dtype family float, shape (1, 5) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import numpy as np

# The function expects x to be an array-like with at least 4 elements [x, y, s, r]
# where x, y are center coordinates, s is scale (area), and r is aspect ratio
# score is optional

# Create a valid bounding box in center form [x, y, s, r]
# Let's use: center at (100, 150), scale (area) = 400, aspect ratio = 2.0
x = np.array([100.0, 150.0, 400.0, 2.0])

# score is optional, can be None or a float
score = 0.95

ARGS = {
    'x': x,
    'score': score
}
Setup block drafted by
a language model, Claude Sonnet 4.5, prompt python_fixture_v1
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ndarray, ndim 2, dtype family float, shape (1, 5) — shape (1, 5) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
convert_x_to_bbox Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
noahcao/OC_SORT/trackers/ocsort_tracker/ocsort.py
code served (permissive licence) · get_code("8d048ed3edc7034e")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Sonnet 4.5, prompt python_fixture_v1) and returned ndarray, ndim 2, dtype family float, shape (1, 5) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import numpy as np

# The function expects x to be an array-like with at least 4 elements [x, y, s, r]
# where x, y are center coordinates, s is scale (area), and r is aspect ratio
# score is optional

# Create a valid bounding box in center form [x, y, s, r]
# Let's use: center at (100, 150), scale (area) = 400, aspect ratio = 2.0
x = np.array([100.0, 150.0, 400.0, 2.0])

# Optional score parameter
score = 0.95

ARGS = {
    'x': x,
    'score': score
}
Setup block drafted by
a language model, Claude Sonnet 4.5, prompt python_fixture_v1
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ndarray, ndim 2, dtype family float, shape (1, 5) — shape (1, 5) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
exponential_moving_average_fn Ran
ran; our contract draft was wrong, not the code
wmuron/motpy/motpy/tracker.py
code served (permissive licence) · get_code("0026d845bd5bba43")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Sonnet 4.5, prompt python_fixture_v1) and returned function. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import numpy as np

# The function takes a single parameter: gamma (a float)
# It returns a callable that performs exponential moving average

ARGS = {
    "gamma": 0.9
}
Setup block drafted by
a language model, Claude Sonnet 4.5, prompt python_fixture_v1
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type function — a function output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a function output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
frobenius Ran
ran on a synthesized input
tryolabs/norfair/norfair/distances.py
code served (permissive licence) · get_code("d0388078cd126b16")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned float64, ndim 0, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import numpy as np

class Detection:
    def __init__(self, points):
        self.points = points

class TrackedObject:
    def __init__(self, estimate):
        self.estimate = estimate

# Create small numpy arrays with distinct dimensions
detection_points = np.array([[1.0, 2.0, 3.0, 4.0],
                             [5.0, 6.0, 7.0, 8.0]])

tracked_estimate = np.array([[1.5, 2.5, 3.5, 4.5],
                             [5.5, 6.5, 7.5, 8.5]])

detection = Detection(detection_points)
tracked_object = TrackedObject(tracked_estimate)

ARGS = {
    'detection': detection,
    'tracked_object': tracked_object
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type float64, ndim 0, dtype family float — no output shape is stated: observe_signature.py recorded float ndim 0, which disagrees with the fixture run
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
get_cutout Ran
ran on a synthesized input
tryolabs/norfair/norfair/utils.py
code served (permissive licence) · get_code("7687c76621449e1c")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned ndarray, ndim 3, dtype family int, shape (65, 40, 3) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import numpy as np

torch.manual_seed(0)

# Create a set of points (N x 2) with x and y coordinates
points = np.array([
    [10.5, 20.3],
    [50.7, 80.2],
    [30.1, 15.9],
    [45.6, 70.4]
], dtype=np.float32)

# Create a sample image (height x width x channels)
# Using distinct dimensions: 100 height, 80 width, 3 channels
image = np.random.randint(0, 256, size=(100, 80, 3), dtype=np.uint8)

ARGS = {
    "points": points,
    "image": image
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ndarray, ndim 3, dtype family int, shape (65, 40, 3) — shape (65, 40, 3) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
get_image_list Ran
ran; our contract draft was wrong, not the code
noahcao/OC_SORT/tools/demo_track.py
code served (permissive licence) · get_code("6874177200d9a346")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Sonnet 4.5, prompt python_fixture_v1) and returned list, ndim 1, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import os
import tempfile
import shutil

# Create a temporary directory structure with image files
temp_dir = tempfile.mkdtemp()

# Create subdirectories
subdir1 = os.path.join(temp_dir, "subdir1")
subdir2 = os.path.join(temp_dir, "subdir2")
os.makedirs(subdir1, exist_ok=True)
os.makedirs(subdir2, exist_ok=True)

# Create dummy image files (empty files with image extensions)
image_files = [
    os.path.join(temp_dir, "image1.jpg"),
    os.path.join(temp_dir, "image2.png"),
    os.path.join(subdir1, "photo.jpeg"),
    os.path.join(subdir1, "picture.webp"),
    os.path.join(subdir2, "bitmap.bmp"),
    os.path.join(temp_dir, "document.txt"),  # Non-image file
]

for filepath in image_files:
    with open(filepath, 'w') as f:
        f.write("")

ARGS = {
    "path": temp_dir
}
Setup block drafted by
a language model, Claude Sonnet 4.5, prompt python_fixture_v1
Imports
none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type list, ndim 1, dtype family float — a list output has no array shape of its own; none is stated
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
get_terminal_size Ran
ran on a synthesized input
tryolabs/norfair/norfair/utils.py
code served (permissive licence) · get_code("886c59210451e2f0")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple, ndim 1, dtype family int; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import os
from typing import Tuple

def get_terminal_size(default: Tuple[int, int]=(80, 24)) -> Tuple[int, int]:
    columns, lines = default
    for fd in range(0, 3):
        try:
            columns, lines = os.get_terminal_size(fd)
        except OSError:
            continue
        break
    return (columns, lines)

ARGS = {
    "default": (80, 24)
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple, ndim 1, dtype family int — a tuple output has no array shape of its own; none is stated
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
hex_to_bgr Ran
ran on a synthesized input
tryolabs/norfair/norfair/drawing/color.py
code served (permissive licence) · get_code("e11e21042f248d2b")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple, ndim 1, dtype family int; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import re
from typing import Tuple

ColorType = Tuple[int, int, int]

def hex_to_bgr(hex_value: str) -> ColorType:
    """Converts conventional 6 digits hex colors to BGR tuples

    Parameters
    ----------
    hex_value : str
        hex value with leading `#` for instance `"#ff0000"`

    Returns
    -------
    Tuple[int, int, int]
        BGR values

    Raises
    ------
    ValueError
        if the string is invalid
    """
    if re.match('#[a-f0-9]{6}$', hex_value):
        return (int(hex_value[5:7], 16), int(hex_value[3:5], 16), int(hex_value[1:3], 16))
    if re.match('#[a-f0-9]{3}$', hex_value):
        return (int(hex_value[3] * 2, 16), int(hex_value[2] * 2, 16), int(hex_value[1] * 2, 16))
    raise ValueError(f"'{hex_value}' is not a valid color")


ARGS = {
    "hex_value": "#ff0000"
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple, ndim 1, dtype family int — a tuple output has no array shape of its own; none is stated
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
intersect Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
choiwb/Computer_Vision_for_Smart_Factory/object_tracke_v1.0.py
code served (permissive licence) · get_code("9db30d2e732c74f5")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned bool, ndim 0, dtype family float, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import numpy as np

# The function ccw and intersect work with points/coordinates
# They expect 4 points A, B, C, D that can be indexed with [0] and [1]
# to get x and y coordinates

# Create simple 2D points as tuples or lists
A = (0, 0)
B = (1, 0)
C = (1, 1)
D = (0, 1)

ARGS = {
    "A": A,
    "B": B,
    "C": C,
    "D": D
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type bool, ndim 0, dtype family float, shape () — shape () as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
iou Ran
ran, violated the contract we drafted
choiwb/Computer_Vision_for_Smart_Factory/sort.py
code served (permissive licence) · get_code("d84d92dcfe0933de")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned float, ndim 0, dtype family float, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import numpy as np
from numba import jit

@jit
def iou(bb_test, bb_gt):
    """
    Computes IOU between two bboxes in the form [x1,y1,x2,y2]
    """
    xx1 = np.maximum(bb_test[0], bb_gt[0])
    yy1 = np.maximum(bb_test[1], bb_gt[1])
    xx2 = np.minimum(bb_test[2], bb_gt[2])
    yy2 = np.minimum(bb_test[3], bb_gt[3])
    w = np.maximum(0.0, xx2 - xx1)
    h = np.maximum(0.0, yy2 - yy1)
    wh = w * h
    o = wh / ((bb_test[2] - bb_test[0]) * (bb_test[3] - bb_test[1]) + (bb_gt[2] - bb_gt[0]) * (bb_gt[3] - bb_gt[1]) - wh)
    return o

bb_test = np.array([10.0, 20.0, 50.0, 80.0])
bb_gt = np.array([15.0, 25.0, 60.0, 90.0])

ARGS = {
    "bb_test": bb_test,
    "bb_gt": bb_gt,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numba, numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type float, ndim 0, dtype family float, shape () — shape () as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
iou_batch Ran
ran, honoured the contract we drafted
nilesh0109/PedestrianTracking/sort.py
pointer only (licence: NONE) · get_code("255cf6241789d67a")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, nilesh0109/PedestrianTracking when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

k_previous_obs Ran
ran, honoured the contract we drafted
noahcao/OC_SORT/trackers/ocsort_tracker/ocsort.py
code served (permissive licence) · get_code("c700a5eb9de050a3")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Sonnet 4.5, prompt python_fixture_v1) and returned list, ndim 1, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import numpy as np

torch.manual_seed(0)

# The function expects:
# - observations: a dict with integer keys (ages) and values (observation data)
# - cur_age: an integer representing current age
# - k: an integer representing how many steps back to look

# Looking at the function:
# - It accesses observations as a dict with integer keys
# - It returns observations[key] where key is an age
# - The return value appears to be a list (default is [-1, -1, -1, -1, -1])
# - So observations[key] should be a list-like structure

observations = {
    5: [1.0, 2.0, 3.0, 4.0, 5.0],
    7: [2.0, 3.0, 4.0, 5.0, 6.0],
    10: [3.0, 4.0, 5.0, 6.0, 7.0],
    12: [4.0, 5.0, 6.0, 7.0, 8.0]
}

cur_age = 15

k = 3

ARGS = {
    'observations': observations,
    'cur_age': cur_age,
    'k': k
}
Setup block drafted by
a language model, Claude Sonnet 4.5, prompt python_fixture_v1
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type list, ndim 1, dtype family float — a list output has no array shape of its own; none is stated
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
linear_assignment Ran
ran, honoured the contract we drafted
nilesh0109/PedestrianTracking/sort.py
pointer only (licence: NONE) · get_code("6265d3c1647dda9b")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, nilesh0109/PedestrianTracking when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

live_plotter Ran
ran on a synthesized input
choiwb/Computer_Vision_for_Smart_Factory/pylive.py
code served (permissive licence) · get_code("9e8863cd30d5044c")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned Line2D. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import matplotlib.pyplot as plt
import numpy as np

# Set up matplotlib to use non-interactive backend for testing
plt.switch_backend('Agg')

# Create sample data
x_vec = np.array([1, 2, 3, 4, 5])
y1_data = np.array([1.0, 2.5, 2.0, 3.5, 4.0])
line1 = []
identifier = 'test_plot'
pause_time = 0.01

ARGS = {
    'x_vec': x_vec,
    'y1_data': y1_data,
    'line1': line1,
    'identifier': identifier,
    'pause_time': pause_time
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
matplotlib, numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Line2D — a Line2D output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Line2D output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
live_plotter_xy Ran
ran on a synthesized input
choiwb/Computer_Vision_for_Smart_Factory/pylive.py
code served (permissive licence) · get_code("b5fd37ed09a84c3c")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned Line2D. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import matplotlib.pyplot as plt
import numpy as np

# Set random seed for reproducibility
np.random.seed(0)

# Create sample data
x_vec = np.linspace(0, 10, 15)
y1_data = np.sin(x_vec) + np.random.normal(0, 0.1, len(x_vec))

# line1 should be an empty list initially (will be populated by the function)
line1 = []

# identifier string
identifier = 'test_plot'

# pause_time in seconds
pause_time = 0.01

ARGS = {
    'x_vec': x_vec,
    'y1_data': y1_data,
    'line1': line1,
    'identifier': identifier,
    'pause_time': pause_time
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
matplotlib, numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Line2D — a Line2D output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Line2D output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
load_classes Ran
ran on a synthesized input
choiwb/Computer_Vision_for_Smart_Factory/utils/utils.py
code served (permissive licence) · get_code("abd797b107592ebe")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned list, ndim 1, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import tempfile
import os

# Create a temporary file with class labels
temp_dir = tempfile.mkdtemp()
temp_file = os.path.join(temp_dir, "classes.txt")

with open(temp_file, 'w') as f:
    f.write("cat\ndog\nbird\nfish\n")

ARGS = {
    "path": temp_file
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type list, ndim 1, dtype family float — a list output has no array shape of its own; none is stated
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
make_line Ran
ran on a synthesized input
choiwb/Computer_Vision_for_Smart_Factory/object_tracker_v4.0.py
code served (permissive licence) · get_code("05d085ab51086196")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple, ndim 2, dtype family int; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import numpy as np

torch.manual_seed(0)

# Analyze the function:
# make_line takes 4 parameters: shp1_x, shp1_y, shp2_x, shp2_y
# Each is converted to int, so they should be numeric values (int, float, or tensor)
# The function creates two coordinate tuples from these values

ARGS = {
    "shp1_x": 10.5,
    "shp1_y": 20.7,
    "shp2_x": 100,
    "shp2_y": 200
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple, ndim 2, dtype family int — a tuple output has no array shape of its own; none is stated
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
mean_euclidean Ran
ran on a synthesized input
tryolabs/norfair/norfair/distances.py
code served (permissive licence) · get_code("ebe742c4649bd5bc")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned float32, ndim 0, dtype family float, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import numpy as np

class Detection:
    def __init__(self, points):
        self.points = points

class TrackedObject:
    def __init__(self, estimate):
        self.estimate = estimate

# Create small sample data
# points: shape (2, 4) - 2 points with 4 coordinates each
detection_points = np.array([
    [1.0, 2.0, 3.0, 4.0],
    [5.0, 6.0, 7.0, 8.0]
], dtype=np.float32)

# estimate: shape (2, 4) - 2 estimates with 4 coordinates each
tracked_estimate = np.array([
    [1.5, 2.5, 3.5, 4.5],
    [5.5, 6.5, 7.5, 8.5]
], dtype=np.float32)

detection = Detection(points=detection_points)
tracked_object = TrackedObject(estimate=tracked_estimate)

ARGS = {
    "detection": detection,
    "tracked_object": tracked_object
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type float32, ndim 0, dtype family float, shape () — shape () as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
mean_manhattan Ran
ran on a synthesized input
tryolabs/norfair/norfair/distances.py
code served (permissive licence) · get_code("e5930666415a4e4d")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned float64, ndim 0, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import numpy as np

class Detection:
    def __init__(self, points):
        self.points = points

class TrackedObject:
    def __init__(self, estimate):
        self.estimate = estimate

detection = Detection(
    points=np.array([
        [1.0, 2.0, 3.0, 4.0],
        [5.0, 6.0, 7.0, 8.0]
    ])
)

tracked_object = TrackedObject(
    estimate=np.array([
        [1.5, 2.5, 3.5, 4.5],
        [5.5, 6.5, 7.5, 8.5]
    ])
)

ARGS = {
    "detection": detection,
    "tracked_object": tracked_object
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type float64, ndim 0, dtype family float — no output shape is stated: observe_signature.py recorded float ndim 0, which disagrees with the fixture run
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
parse_data_config Ran
ran on a synthesized input
choiwb/Computer_Vision_for_Smart_Factory/utils/parse_config.py
code served (permissive licence) · get_code("89188293ff927150")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned dict. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import tempfile
import os

# Create a temporary configuration file
temp_config = tempfile.NamedTemporaryFile(mode='w', delete=False, suffix='.txt')
temp_config.write("# This is a comment\n")
temp_config.write("batch_size=32\n")
temp_config.write("learning_rate=0.001\n")
temp_config.write("\n")
temp_config.write("# Another comment\n")
temp_config.write("epochs=100\n")
temp_config.close()

ARGS = {
    'path': temp_config.name
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type dict — a dict output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a dict output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
parse_model_config Ran
ran on a synthesized input
choiwb/Computer_Vision_for_Smart_Factory/utils/parse_config.py
code served (permissive licence) · get_code("d86acf9d2e249fb5")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned list, ndim 1, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import tempfile
import os

# Create a temporary config file for YOLO-v3
config_content = """# YOLO-v3 Config File
[net]
batch=1
subdivisions=1
width=416
height=416
channels=3
momentum=0.9
decay=0.0005
angle=0
saturation=1.5
exposure=1.5
hue=.1
learning_rate=0.001
burn_in=1000
max_batches=500200
policy=steps
steps=400000,450000
scales=.1,.1

[convolutional]
batch_normalize=1
filters=32
size=3
stride=1
pad=1
activation=leaky

[convolutional]
batch_normalize=1
filters=64
size=3
stride=2
pad=1
activation=leaky

[maxpool]
size=2
stride=2

[route]
layers = -6

[region]
anchors = 10,13,  16,30,  33,23,  30,61,  62,45,  59,119,  116,90,  156,198,  373,326
bias_match=0
classes=80
coords=4
num=9
softmax=1
jitter=.3
ignore_thresh=.5
truth_thresh=1
random=1
"""

# Create a temporary file
temp_fd, temp_path = tempfile.mkstemp(suffix='.cfg', text=True)
try:
    os.write(temp_fd, config_content.encode('utf-8'))
    os.close(temp_fd)
    
    ARGS = {
        'path': temp_path
    }
except:
    os.close(temp_fd)
    raise
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type list, ndim 1, dtype family float — a list output has no array shape of its own; none is stated
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
predict Ran
ran on a synthesized input
nakul-shahdadpuri/narknet/classify/image.py
code served (permissive licence) · get_code("c3a20ca1df7ba229")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import cv2
import numpy as np
import tempfile
import os

# Create a temporary image file for testing
temp_dir = tempfile.gettempdir()
temp_image_path = os.path.join(temp_dir, 'test_image.jpg')

# Create a simple test image (416x416 to match blob size)
test_image = np.random.randint(0, 256, (416, 416, 3), dtype=np.uint8)
cv2.imwrite(temp_image_path, test_image)

# Create a mock neural network that mimics OpenCV's DNN interface
class MockNet:
    def __init__(self):
        self.input_blob = None
    
    def setInput(self, blob):
        self.input_blob = blob
    
    def forward(self, output_layers):
        # Return mock detections for each output layer
        # Each detection has: center_x, center_y, width, height, confidence, class_scores...
        # We'll create 2 detections per output layer
        detections_per_layer = []
        for _ in output_layers:
            layer_output = []
            # Detection 1: high confidence object
            det1 = np.array([0.5, 0.5, 0.3, 0.2, 0.9, 0.8, 0.1, 0.05, 0.05])  # 80 classes
            layer_output.append(det1)
            # Detection 2: low confidence object (will be filtered)
            det2 = np.array([0.3, 0.3, 0.2, 0.1, 0.3, 0.05, 0.02, 0.01, 0.92])
            layer_output.append(det2)
            detections_per_layer.append(np.array(layer_output))
        return detections_per_layer

# Create mock classes list (80 classes for YOLO)
classes = ['person', 'bicycle', 'car', 'motorbike', 'aeroplane', 'bus', 'train', 'truck',
           'boat', 'traffic light'] + ['class_' + str(i) for i in range(70)]

# Create network instance
net = MockNet()

# Output layer names (typical YOLO setup)
output_layers = ['yolo_82', 'yolo_94', 'yolo_106']

# Layer names (required by the function signature)
layer_names = ['conv_0', 'conv_1', 'yolo_82', 'yolo_94', 'yolo_106']

ARGS = {
    'PATH_TO_OBJECT': temp_image_path,
    'net': net,
    'classes': classes,
    'output_layers': output_layers,
    'layer_names': layer_names
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
cv2, numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple — a tuple output has no array shape of its own; none is stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
validate_points Ran
ran on a synthesized input
tryolabs/norfair/norfair/utils.py
code served (permissive licence) · get_code("c7c9e0f72076fdc7")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned ndarray, ndim 2, dtype family float, shape (3, 2) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import numpy as np

# Test case 1: Valid 2D array with shape (num_points, 2)
points_valid_2d = np.array([[1.0, 2.0], [3.0, 4.0], [5.0, 6.0]])

# Test case 2: Valid 1D array that should be converted to 2D
points_valid_1d = np.array([1.5, 2.5])

# Test case 3: Invalid 3D array that should raise error
points_invalid_3d = np.array([[[1.0, 2.0], [3.0, 4.0]]])

ARGS = {
    "points": points_valid_2d
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ndarray, ndim 2, dtype family float, shape (3, 2) — shape (3, 2) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
associate_detections_to_tracks Not yet run
unverified (harvested, no recorded run)
twairball/pyTracking/tracking/sort.py
code served (permissive licence) · get_code("1481fb819255daae")
How it ran

no invocation recorded.

compare_dataframes Not yet run
unverified (harvested, no recorded run)
tryolabs/norfair/norfair/metrics.py
code served (permissive licence) · get_code("f36bc565f156b43d")
How it ran

no invocation recorded.

eval_motChallenge Not yet run
unverified (harvested, no recorded run)
tryolabs/norfair/norfair/metrics.py
code served (permissive licence) · get_code("a5d97cfb03d6e15d")
How it ran

no invocation recorded.

extract_image_patch Not yet run
unverified (harvested, no recorded run)
LKLQQ/Deepsort/generater-detection.py
code served (permissive licence) · get_code("d5d276bae43729ed")
How it ran

no invocation recorded.

load_model Not yet run
unverified (harvested, no recorded run)
nakul-shahdadpuri/narknet/classify/image.py
code served (permissive licence) · get_code("d72f789555f7a818")
How it ran

no invocation recorded.

load_motchallenge Not yet run
unverified (harvested, no recorded run)
tryolabs/norfair/norfair/metrics.py
code served (permissive licence) · get_code("62946a9ffe0eab8a")
How it ran

no invocation recorded.

parse_color Not yet run
unverified (harvested, no recorded run)
tryolabs/norfair/norfair/drawing/color.py
code served (permissive licence) · get_code("0fe08034134b78ab")
How it ran

no invocation recorded.

Also present in other papers' code

Of 40 samples lifted from this paper's linked repositories, 40 carry a function identity and 0 do not. Of the 37 distinct functions with an identity, 13 are also present in other papers whose code we hold (1 with at least one paper dated earlier, 0 the same month, 12 later) and 24 are only here among the 52,977 papers whose code Syntology holds (as of 2026-09-26).

Only here means: among the 52,977 papers whose code Syntology holds (51,887 with lifted samples, 1,090 through their assemblies only), as of 2026-09-26, no other paper's lifted samples or current assembly bricks contain an identical function body after normalisation.

FunctionAlso present inEarliest-datedOthers named
convert_bbox_to_z 4 other papers
4 later
1612.01465 (2016-12)
ArtTrack: Articulated Multi-person Tracking in the Wild
1906.07155 (2019-06)
MMDetection: Open MMLab Detection Toolbox and Benchmark
and 1 more not named here
convert_x_to_bbox 4 other papers
4 later
1612.01465 (2016-12)
ArtTrack: Articulated Multi-person Tracking in the Wild
1906.07155 (2019-06)
MMDetection: Open MMLab Detection Toolbox and Benchmark
and 1 more not named here
iou 3 other papers
3 later
1612.01465 (2016-12)
ArtTrack: Articulated Multi-person Tracking in the Wild
1906.07155 (2019-06)
MMDetection: Open MMLab Detection Toolbox and Benchmark
convert_x_to_bbox 2 other papers
2 later
1811.10742 (2018-11)
Joint Monocular 3D Vehicle Detection and Tracking
2203.14360 (2022-03)
Observation-Centric SORT: Rethinking SORT for Robust Multi-Object Tracking
get_image_list 2 other papers
2 later
2203.14360 (2022-03)
Observation-Centric SORT: Rethinking SORT for Robust Multi-Object Tracking
2206.14651 (2022-06)
BoT-SORT: Robust Associations Multi-Pedestrian Tracking
bbox_iou 1 other paper
1 dated earlier
1506.02640 (2015-06)
You Only Look Once: Unified, Real-Time Object Detection
compute_ap 1 other paper
1 later
2004.10934 (2020-04)
YOLOv4: Optimal Speed and Accuracy of Object Detection
convert_bbox_to_z 1 other paper
1 later
2203.14360 (2022-03)
Observation-Centric SORT: Rethinking SORT for Robust Multi-Object Tracking
intersect 1 other paper
1 later
2204.05991 (2022-04)
ReCLIP: A Strong Zero-Shot Baseline for Referring Expression Comprehension
iou_batch 1 other paper
1 later
2303.14679 (2023-03)
ZBS: Zero-shot Background Subtraction via Instance-level Background Modeling and Foreground Selection
k_previous_obs 1 other paper
1 later
2203.14360 (2022-03)
Observation-Centric SORT: Rethinking SORT for Robust Multi-Object Tracking
linear_assignment 1 other paper
1 later
2303.14679 (2023-03)
ZBS: Zero-shot Background Subtraction via Instance-level Background Modeling and Foreground Selection
load_classes 1 other paper
1 later
2004.10934 (2020-04)
YOLOv4: Optimal Speed and Accuracy of Object Detection

Presence, not direction: an identical function body in two papers' repositories does not say who wrote it, which came from which, or that either paper's method rests on it. Matching is exact after normalisation, so a renamed or edited function is not matched. Dates are when papers appeared, not when code was written. Only .py files the harvester lifted are covered; notebooks are not read. A new-style arXiv id YYMM.NNNN dates a paper to the month 20YY-MM; otherwise Paper.year dates it to the year; otherwise it is undated. Dates are when the paper appeared, not when the code was written. Read 2026-11-22.

Repositories linked to this paper

More are linked than shown here.

Some links come from the archived Papers with Code dataset (CC BY-SA 4.0): attribution and licence.

Abstract

This paper explores a pragmatic approach to multiple object tracking where the main focus is to associate objects efficiently for online and realtime applications. To this end, detection quality is identified as a key factor influencing tracking performance, where changing the detector can improve tracking by up to 18.9%. Despite only using a rudimentary combination of familiar techniques such as the Kalman Filter and Hungarian algorithm for the tracking components, this approach achieves an accuracy comparable to state-of-the-art online trackers. Furthermore, due to the simplicity of our tracking method, the tracker updates at a rate of 260 Hz which is over 20x faster than other state-of-the-art trackers.

For agents

The same record, over MCP at https://syntology.ai/mcp:

get_harvested_code_for_paper("1602.00763")
get_code_for_paper("1602.00763")
have("1602.00763")

The run record, dated, one paper per request, free:

curl https://syntology.ai/api/ran/1602.00763.json

A badge for a README (the split and the date, never a ratio):

[![Syntology run record](https://syntology.ai/api/ran/1602.00763.svg)](https://syntology.ai/paper/1602.00763)

Connect an agent — have() is free.