SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 2007.10986 · 2020

Multi-person 3D Pose Estimation in Crowded Scenes Based on Multi-View Geometry

arXiv · PDF · Open in the Atlas

Code that ran

14 of 19 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; 0 honoured the contract we drafted, 0 violated it and 14 have no contract verdict; 0 failures of our instrument; 5 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/2007.10986.json · badge: /api/ran/2007.10986.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
HeCraneChen/3D-Crowd-Pose-Estimation-Based-on-MVG canonical (classifier label)
classifier basis: census
14 ran · 5 no recorded run
FunctionStatusWhere it lives
ConnectSkeleton Ran
ran on a synthesized input
HeCraneChen/3D-Crowd-Pose-Estimation-Based-on-MVG/optimization/pose_optimize/visualization.py
code served (permissive licence) · get_code("65ddecc8839bc2dd")
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 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 matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D

torch.manual_seed(0)

# Create a 3D matplotlib axis
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')

# Create pts3D with shape (3, 5) - 3 coordinates (x, y, z) and 5 points
pts3D = torch.randn(3, 5)

# Define indices for skeleton connection
i = 0
j = 2

# Define color
co = 'red'

ARGS = {
    'i': i,
    'j': j,
    'co': co,
    'pts3D': pts3D,
    'ax': ax
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
matplotlib, mpl_toolkits, 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 float — 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
Get_P_from_dataset Ran
ran on a synthesized input
HeCraneChen/3D-Crowd-Pose-Estimation-Based-on-MVG/dataset/all_dataset_para.py
code served (permissive licence) · get_code("03c8a21158cf4d57")
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 3, 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
import cv2

# The function Get_P_from_dataset takes a single parameter: dataset_name
# which is a string that selects which dataset configuration to use.
# The function returns projection matrices based on the dataset name.

ARGS = {
    "dataset_name": "ETHZ_dataset2"
}
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, ndim 3, dtype family float — 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
SingularityElimination Ran
ran on a synthesized input
HeCraneChen/3D-Crowd-Pose-Estimation-Based-on-MVG/optimization/pose_optimize/visualization.py
code served (permissive licence) · get_code("a717b2a6a74fbfbd")
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 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

# The function takes 4 points in 3D space (p1, p2, p3, p4)
# Each point is accessed with [0], [1], [2] indices, so they need to be indexable
# They can be tuples, lists, or array-like objects

p1 = (0.0, 0.0, 0.0)
p2 = (1.0, 0.0, 0.0)
p3 = (0.0, 1.0, 0.0)
p4 = (0.0, 0.0, 1.0)

ARGS = {
    "p1": p1,
    "p2": p2,
    "p3": p3,
    "p4": p4,
}
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 tuple, ndim 1, dtype family float — 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
adjustbone Ran
ran on a synthesized input
HeCraneChen/3D-Crowd-Pose-Estimation-Based-on-MVG/matching/CopingWithOutlier.py
code served (permissive licence) · get_code("ca36a642caddd32c")
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 numpy as np

# Define the arguments for adjustbone function
outlier_index = 0  # int for which joint is the outlier

# outlier_coor: a list [x,y,z] - the coordinate of the outlier point
outlier_coor = [0.5, 0.3, 0.2]

# person: a list of 92 coordinates (23 joints × 3 coordinates)
# Format: [nose_x, nose_y, nose_z, Leye_x, Leye_y, Leye_z, ...]
person = [
    # nose (0-2)
    0.1, 0.2, 0.3,
    # Leye (3-5)
    0.15, 0.25, 0.35,
    # Reye (6-8)
    0.25, 0.35, 0.45,
    # Lear (9-11)
    0.05, 0.15, 0.25,
    # Rear (12-14)
    0.35, 0.45, 0.55,
    # Lshoulder (15-17)
    0.0, 0.5, 0.0,
    # Rshoulder (18-20)
    0.4, 0.5, 0.0,
    # Lelbow (21-23)
    -0.1, 0.3, 0.0,
    # Relbow (24-26)
    0.5, 0.3, 0.0,
    # Lwrist (27-29)
    -0.2, 0.1, 0.0,
    # Rwrist (30-32)
    0.6, 0.1, 0.0,
    # Lhip (33-35)
    0.1, 0.0, 0.0,
    # Rhip (36-38)
    0.3, 0.0, 0.0,
    # Lknee (39-41)
    0.1, -0.3, 0.0,
    # Rknee (42-44)
    0.3, -0.3, 0.0,
    # Lankle (45-47)
    0.1, -0.6, 0.0,
    # Rankle (48-50)
    0.3, -0.6, 0.0,
    # Lbigtoe (51-53)
    0.15, -0.7, 0.0,
    # Lsmalltoe (54-56)
    0.05, -0.7, 0.0,
    # Lheel (57-59)
    0.1, -0.65, 0.0,
    # Rbigtoe (60-62)
    0.35, -0.7, 0.0,
    # Rsmalltoe (63-65)
    0.25, -0.7, 0.0,
    # Rheel (66-68)
    0.3, -0.65, 0.0,
]

# median_bones: a list of 16 median bone lengths
median_bones = [
    0.1,   # nose_eye
    0.15,  # eye_ear
    0.4,   # LRshoulder
    0.3,   # upperArm
    0.25,  # lowerArm
    0.3,   # LRhip
    0.4,   # hip_knee
    0.35,  # knee_ankle
    0.1,   # ankle_heel
    0.12,  # heel_bigtoe
    0.08,  # heel_smalltoe
    0.25,  # ear_ear
    0.15,  # wrist_wrist
    0.2,   # ankle_ankle
    0.15,  # heel_heel
    0.2,   # toe_toe
]

ARGS = {
    "outlier_index": outlier_index,
    "outlier_coor": outlier_coor,
    "median_bones": median_bones,
    "person": person,
}
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 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
cal_kpt_3d_error Ran
ran on a synthesized input
HeCraneChen/3D-Crowd-Pose-Estimation-Based-on-MVG/optimization/pose_optimize/shape_3d_info.py
code served (permissive licence) · get_code("6a6178c12275df0f")
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 json
import numpy as np
import tempfile
import os

# Create temporary directory for test files
temp_dir = tempfile.mkdtemp()

# Create json_prior file with required structure
prior_data = {
    "left_list": [[11, 12], [5, 6], [11, 5], [5, 7], [7, 9], [5, 3], [3, 1], [1, 0], [11, 13], [13, 15], [15, 19], [19, 17], [19, 18]],
    "right_list": [[11, 12], [5, 6], [12, 6], [6, 8], [8, 10], [6, 4], [4, 2], [2, 0], [12, 14], [14, 16], [16, 22], [22, 20], [22, 21]],
    "median_bone": {str(i): 1.5 for i in range(13)}
}

json_prior_path = os.path.join(temp_dir, "prior.json")
with open(json_prior_path, 'w') as f:
    json.dump(prior_data, f)

# Create json_fintune file with 3D keypoint data
fintune_data = {
    "3D": {
        "0": {
            "0": np.random.randn(26, 3).tolist()
        },
        "1": {
            "0": np.random.randn(26, 3).tolist()
        }
    }
}

json_fintune_path = os.path.join(temp_dir, "fintune.json")
with open(json_fintune_path, 'w') as f:
    json.dump(fintune_data, f)

json_prior_eval_path = os.path.join(temp_dir, "eval_output.json")

ARGS = {
    "json_prior": json_prior_path,
    "json_fintune": json_fintune_path,
    "json_prior_eval": json_prior_eval_path
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, tqdm — 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
collect_param Ran
ran on a synthesized input
HeCraneChen/3D-Crowd-Pose-Estimation-Based-on-MVG/optimization/pose_optimize/shape_3d_info.py
code served (permissive licence) · get_code("d66ef6d74f8ca776")
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 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 json
import numpy as np
import tempfile
import os

bone_name_global = ['LR Hip', 'LR Shoulder', 'Hip Shoulder', 'Shoulder Elbow', 'Elbow Wrist', 'Shoulder ear', 'Ear Eye', 'Eye Nose', 'Hip knee', 'Knee Ankle', 'Ankle Heel', 'Heel BigToe', 'Heel SmallToe']

left_list_global = np.array([11, 12, 5, 6, 11, 5, 5, 7, 7, 9, 5, 3, 3, 1, 1, 0, 11, 13, 13, 15, 15, 19, 19, 17, 19, 18]).reshape([-1, 2]).tolist()

right_list_global = np.array([11, 12, 5, 6, 12, 6, 6, 8, 8, 10, 6, 4, 4, 2, 2, 0, 12, 14, 14, 16, 16, 22, 22, 20, 22, 21]).reshape([-1, 2]).tolist()

# Create a temporary JSON file with valid 3D pose data
temp_dir = tempfile.mkdtemp()
json_path = os.path.join(temp_dir, "poses_3d.json")

# Create mock 3D pose data matching the expected structure
# The function expects data_dict['3D'] to contain frames, each with persons
# Each person has 23 keypoints (based on the indices used in left_list_global and right_list_global)
pose_data = {
    "3D": {
        "frame_0": {
            "person_0": np.random.rand(23, 3).tolist(),
            "person_1": np.random.rand(23, 3).tolist(),
        },
        "frame_1": {
            "person_0": np.random.rand(23, 3).tolist(),
        },
    }
}

with open(json_path, 'w') as f:
    json.dump(pose_data, f)

out_json_path = os.path.join(temp_dir, "output.json")

ARGS = {
    "json_path_3d": json_path,
    "left_list": left_list_global,
    "right_list": right_list_global,
    "bone_name_list": bone_name_global,
    "out_json_path": out_json_path,
    "ratio": 0.8,
}
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 tuple, ndim 1, dtype family float — 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
fund_mat Ran
ran on a synthesized input
HeCraneChen/3D-Crowd-Pose-Estimation-Based-on-MVG/matching/pose_optimize/multiview_geo.py
code served (permissive licence) · get_code("9fd51fe60dbf7bbd")
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, 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 numpy as np
import scipy
import scipy.linalg

# Create valid projection matrices (3, 4)
# A projection matrix is typically K[R|t] where K is intrinsic, R is rotation, t is translation

# For P1: Create a simple projection matrix
# Start with an identity-like structure and make it valid
np.random.seed(0)

# Create intrinsic matrix K1 (3x3 upper triangular)
K1 = np.array([
    [500.0, 0.0, 320.0],
    [0.0, 500.0, 240.0],
    [0.0, 0.0, 1.0]
])

# Create rotation matrix R1 (identity for simplicity)
R1 = np.eye(3)

# Create translation vector t1
t1 = np.array([0.0, 0.0, 0.0])

# P1 = K1[R1|t1]
P1 = np.hstack([K1 @ R1, (K1 @ t1).reshape(3, 1)])

# For P2: Create another projection matrix with a different rotation and translation
# Create rotation matrix R2 (small rotation)
theta = 0.1
R2 = np.array([
    [np.cos(theta), -np.sin(theta), 0.0],
    [np.sin(theta), np.cos(theta), 0.0],
    [0.0, 0.0, 1.0]
])

# Create intrinsic matrix K2 (similar to K1)
K2 = np.array([
    [500.0, 0.0, 320.0],
    [0.0, 500.0, 240.0],
    [0.0, 0.0, 1.0]
])

# Create translation vector t2
t2 = np.array([1.0, 0.5, 0.0])

# P2 = K2[R2|t2]
P2 = np.hstack([K2 @ R2, (K2 @ t2).reshape(3, 1)])

ARGS = {
    "P1": P1,
    "P2": P2
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, scipy — 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, 3) — shape (3, 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_distance Ran
ran on a synthesized input
HeCraneChen/3D-Crowd-Pose-Estimation-Based-on-MVG/matching/pose_optimize/multiview_geo.py
code served (permissive licence) · get_code("43064f75359849ed")
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 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
import scipy.linalg

np.random.seed(0)

# Create valid projection matrices (3,4)
# A projection matrix is typically K @ [R | t] where K is intrinsic, R is rotation, t is translation
# We'll create simple ones that satisfy the constraints

# Camera 4 projection matrix
P4 = np.array([
    [500, 0, 320, 0],
    [0, 500, 240, 0],
    [0, 0, 1, 0]
], dtype=np.float64)

# Camera 6 projection matrix - slightly different to ensure valid fundamental matrix
P6 = np.array([
    [500, 0, 320, 100],
    [0, 500, 240, 50],
    [0, 0, 1, 0.1]
], dtype=np.float64)

# Create keypoint p4 in homogenous coordinates (3,)
# Typical image point would be around (x, y, 1)
p4 = np.array([320.0, 240.0, 1.0], dtype=np.float64)

# Create keypoint p6 in homogenous coordinates (3,)
p6 = np.array([350.0, 260.0, 1.0], dtype=np.float64)

ARGS = {
    "p4": p4,
    "p6": p6,
    "cam_proj_4": P4,
    "cam_proj_6": P6
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, scipy — 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 float — 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
getdistance Ran
ran on a synthesized input
HeCraneChen/3D-Crowd-Pose-Estimation-Based-on-MVG/matching/CopingWithOutlier.py
code served (permissive licence) · get_code("fccc317b29e93215")
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

# pt: 3 by 1 numpy array
pt = np.array([[1.0], [2.0], [3.0]])

# pts: 3 by n numpy array (using n=4 for distinct size)
pts = np.array([[1.5, 2.5, 3.5, 4.5],
                [2.1, 3.1, 4.1, 5.1],
                [3.2, 4.2, 5.2, 6.2]])

ARGS = {
    "pt": pt,
    "pts": pts
}
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
loss_kpt_3d Ran
ran on a synthesized input
HeCraneChen/3D-Crowd-Pose-Estimation-Based-on-MVG/optimization/pose_optimize/shape_3d_info.py
code served (permissive licence) · get_code("b658b3f10c289cc8")
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 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

# Create a 3D keypoint array with shape (26, 3)
# 26 keypoints, each with x, y, z coordinates
kpt_3d_array = np.random.randn(26, 3).astype(np.float32)

# Create median_bone dictionary with 13 entries (one for each bone pair)
# Since left_list_global and right_list_global have 13 pairs when reshaped
median_bone = {str(i): np.random.rand() * 2 + 0.5 for i in range(13)}

ARGS = {
    "kpt_3d_array": kpt_3d_array,
    "median_bone": median_bone,
}
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 tuple, ndim 2, dtype family float — 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
optimze_loss_2d Ran
ran on a synthesized input
HeCraneChen/3D-Crowd-Pose-Estimation-Based-on-MVG/optimization/pose_optimize/optimize_loss.py
code served (permissive licence) · get_code("a8862831867b8557")
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 1, dtype family float, shape (46,) 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

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

# Number of keypoints
num_kpt = 23

# Create p3d_flatten: flattened 3D points (23 keypoints * 3 coords = 69 values)
p3d_flatten = np.random.randn(num_kpt * 3).astype(np.float32)

# Create p4: 2D keypoints in camera 4 (23, 2)
p4 = np.random.randn(num_kpt, 2).astype(np.float32)

# Create p6: 2D keypoints in camera 6 (23, 2)
p6 = np.random.randn(num_kpt, 2).astype(np.float32)

# Create cam_proj_4: 3x4 camera projection matrix for camera 4
cam_proj_4 = np.random.randn(3, 4).astype(np.float32)

# Create cam_proj_6: 3x4 camera projection matrix for camera 6
cam_proj_6 = np.random.randn(3, 4).astype(np.float32)

# Lambda for reprojection loss weight
lambda_reproj = 1.0

ARGS = {
    "p3d_faltten": p3d_flatten,
    "p4": p4,
    "p6": p6,
    "cam_proj_4": cam_proj_4,
    "cam_proj_6": cam_proj_6,
    "num_kpt": num_kpt,
    "lambda_reproj": lambda_reproj,
}
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 1, dtype family float, shape (46,) — shape (46,) 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
recover_rti Ran
ran on a synthesized input
HeCraneChen/3D-Crowd-Pose-Estimation-Based-on-MVG/matching/pose_optimize/multiview_geo.py
code served (permissive licence) · get_code("875f78c1d38d3649")
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 numpy as np
import scipy.linalg

# Create a valid 3x4 extrinsic matrix
# The first 3x3 part should be decomposable via RQ decomposition
# We'll create a simple example: combine a rotation matrix with a translation vector

# Create a simple rotation matrix (orthogonal)
angle = np.pi / 6
rotation = np.array([
    [np.cos(angle), -np.sin(angle), 0],
    [np.sin(angle), np.cos(angle), 0],
    [0, 0, 1]
])

# Create a simple camera intrinsic matrix (upper triangular)
intrinsic = np.array([
    [500, 0, 320],
    [0, 500, 240],
    [0, 0, 1]
])

# Combine: P = K @ [R | t]
translation = np.array([1, 2, 3])
extrinsic_part = rotation @ np.column_stack([np.eye(3), translation[:, np.newaxis]])[:3, :]

# Create the full 3x4 extrinsic matrix
extrinsic_matrix = intrinsic @ extrinsic_part

ARGS = {
    "extrinsic_matrix": extrinsic_matrix
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, scipy — 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
reproject_error_loss Ran
ran on a synthesized input
HeCraneChen/3D-Crowd-Pose-Estimation-Based-on-MVG/optimization/pose_optimize/optimize_loss.py
code served (permissive licence) · get_code("26c88ce49e08e4a7")
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 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

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

num_kpt = 23

# Create 3D keypoints: (23, 3)
p3d = np.random.randn(num_kpt, 3).astype(np.float32)

# Create 2D keypoints for camera 4: (23, 2)
p4 = np.random.randn(num_kpt, 2).astype(np.float32)

# Create 2D keypoints for camera 6: (23, 2)
p6 = np.random.randn(num_kpt, 2).astype(np.float32)

# Create camera projection matrix for camera 4: (4, 4)
# Structure: [R|t] where R is 3x3 rotation, t is 3x1 translation
cam_proj_4 = np.eye(4, dtype=np.float32)
cam_proj_4[0:3, 0:3] = np.random.randn(3, 3).astype(np.float32)
cam_proj_4[0:3, 3] = np.random.randn(3).astype(np.float32)

# Create camera projection matrix for camera 6: (4, 4)
cam_proj_6 = np.eye(4, dtype=np.float32)
cam_proj_6[0:3, 0:3] = np.random.randn(3, 3).astype(np.float32)
cam_proj_6[0:3, 3] = np.random.randn(3).astype(np.float32)

ARGS = {
    "p3d": p3d,
    "p4": p4,
    "p6": p6,
    "cam_proj_4": cam_proj_4,
    "cam_proj_6": cam_proj_6,
    "num_kpt": num_kpt,
}
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 tuple, ndim 2, dtype family float — 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
reproject_error_loss_score Ran
ran on a synthesized input
HeCraneChen/3D-Crowd-Pose-Estimation-Based-on-MVG/optimization/pose_optimize/optimize_loss.py
code served (permissive licence) · get_code("db121bc5af461574")
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 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

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

# Number of keypoints
num_kpt = 23

# p3d: 3D keypoints, shape (23, 3)
p3d = np.random.randn(num_kpt, 3).astype(np.float32)

# p4: 2D keypoints from camera 4, shape (23, 3) where last column is confidence/visibility
p4 = np.random.rand(num_kpt, 3).astype(np.float32)
p4[:, :2] = np.random.randn(num_kpt, 2)  # x, y coordinates
p4[:, 2] = np.random.rand(num_kpt) + 0.5  # confidence scores between 0.5 and 1.5

# p6: 2D keypoints from camera 6, shape (23, 3) where last column is confidence/visibility
p6 = np.random.rand(num_kpt, 3).astype(np.float32)
p6[:, :2] = np.random.randn(num_kpt, 2)  # x, y coordinates
p6[:, 2] = np.random.rand(num_kpt) + 0.5  # confidence scores between 0.5 and 1.5

# cam_proj_4: camera projection matrix for camera 4, shape (3, 4)
# Structure: [R | t] where R is 3x3 rotation and t is 3x1 translation
cam_proj_4 = np.random.randn(3, 4).astype(np.float32)
cam_proj_4[0:3, 0:3] = np.eye(3) + np.random.randn(3, 3) * 0.1  # Slightly perturbed identity rotation

# cam_proj_6: camera projection matrix for camera 6, shape (3, 4)
cam_proj_6 = np.random.randn(3, 4).astype(np.float32)
cam_proj_6[0:3, 0:3] = np.eye(3) + np.random.randn(3, 3) * 0.1  # Slightly perturbed identity rotation

ARGS = {
    "p3d": p3d,
    "p4": p4,
    "p6": p6,
    "cam_proj_4": cam_proj_4,
    "cam_proj_6": cam_proj_6,
    "num_kpt": num_kpt,
}
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 tuple, ndim 2, dtype family float — 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
CopeOutlier Not yet run
unverified (harvested, no recorded run)
HeCraneChen/3D-Crowd-Pose-Estimation-Based-on-MVG/matching/CopingWithOutlier.py
code served (permissive licence) · get_code("0eaa1b64d88563fa")
How it ran

no invocation recorded.

GetP Not yet run
unverified (harvested, no recorded run)
HeCraneChen/3D-Crowd-Pose-Estimation-Based-on-MVG/matching/pose_optimize/data_io.py
code served (permissive licence) · get_code("691c34e127a346aa")
How it ran

no invocation recorded.

GetP Not yet run
unverified (harvested, no recorded run)
HeCraneChen/3D-Crowd-Pose-Estimation-Based-on-MVG/dataset/all_dataset_para.py
code served (permissive licence) · get_code("b629a5f44308ea9e")
How it ran

no invocation recorded.

GetP Not yet run
unverified (harvested, no recorded run)
HeCraneChen/3D-Crowd-Pose-Estimation-Based-on-MVG/matching/AccomodateAllWildtrack.py
code served (permissive licence) · get_code("c9bf80b00cefad7a")
How it ran

no invocation recorded.

accomoAllWildtrack Not yet run
unverified (harvested, no recorded run)
HeCraneChen/3D-Crowd-Pose-Estimation-Based-on-MVG/matching/AccomodateAllWildtrack.py
code served (permissive licence) · get_code("e089676c68bd7bb3")
How it ran

no invocation recorded.

Also present in other papers' code

Of 19 samples lifted from this paper's linked repositories, 19 carry a function identity and 0 do not. Of the 18 distinct functions with an identity, 0 are also present in other papers whose code we hold (0 with at least one paper dated earlier, 0 the same month, 0 later) and 18 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.

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

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

Abstract

Epipolar constraints are at the core of feature matching and depth estimation in current multi-person multi-camera 3D human pose estimation methods. Despite the satisfactory performance of this formulation in sparser crowd scenes, its effectiveness is frequently challenged under denser crowd circumstances mainly due to two sources of ambiguity. The first is the mismatch of human joints resulting from the simple cues provided by the Euclidean distances between joints and epipolar lines. The second is the lack of robustness from the naive formulation of the problem as a least squares minimization. In this paper, we depart from the multi-person 3D pose estimation formulation, and instead reformulate it as crowd pose estimation. Our method consists of two key components: a graph model for fast cross-view matching, and a maximum a posteriori (MAP) estimator for the reconstruction of the 3D human poses. We demonstrate the effectiveness and superiority of our proposed method on four benchmark datasets.

For agents

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

get_harvested_code_for_paper("2007.10986")
get_code_for_paper("2007.10986")
have("2007.10986")

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

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

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

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

Connect an agent — have() is free.