SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 2407.05680 · AAAI · 2024

Fine-Grained Multi-View Hand Reconstruction Using Inverse Rendering

Wentong Li, Qijun Gan, Jianke Zhu, Jinwei Ren

arXiv · PDF · Open in the Atlas

Code that ran

25 of 25 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, 0 violated it and 0 have no contract verdict; 22 failures of our instrument; 0 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/2407.05680.json · badge: /api/ran/2407.05680.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
agnjason/fmhr canonical (classifier label)
classifier basis: census
23 ran · 0 no recorded run
agnJason/FMHR community
Papers with Code archive
2 ran · 0 no recorded run
FunctionStatusWhere it lives
NCC Ran
ran; our contract draft was wrong, not the code
agnjason/fmhr/models/ncc_utils.py
code served (permissive licence) · get_code("28a53e0f276bbbc8")
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 Tensor, ndim 2, dtype family float, shape (2, 4) 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)

# Based on the function signature and usage:
# ref: shape (1, npoints, npixels)
# src: shape (nviews, npoints, npixels)
# ref_valid_mask: shape (1, npoints, npixels)
# src_valid_mask: shape (nviews, npoints, npixels)

nviews = 2
npoints = 4
npixels = 3

ref = torch.randn(1, npoints, npixels)
src = torch.randn(nviews, npoints, npixels)
ref_valid_mask = torch.randint(0, 2, (1, npoints, npixels)).float()
src_valid_mask = torch.randint(0, 2, (nviews, npoints, npixels)).float()

ARGS = {
    "ref": ref,
    "src": src,
    "ref_valid_mask": ref_valid_mask,
    "src_valid_mask": src_valid_mask,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
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 2, dtype family float, shape (2, 4) — shape (2, 4) 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
add_hom Ran
ran; our contract draft was wrong, not the code
agnjason/fmhr/models/ncc_utils.py
code served (permissive licence) · get_code("c27682ba51eb4e6f")
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 Tensor, ndim 2, dtype family float, shape (2, 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 torch
import numpy as np

torch.manual_seed(0)

# Test case 1: PyTorch tensor
pts_torch = torch.randn(2, 4)

# Test case 2: NumPy array
pts_numpy = np.random.randn(2, 4)

# Create ARGS dict with both test cases
# We'll use the torch tensor as the primary test
ARGS = {
    "pts": pts_torch
}
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 Tensor, ndim 2, dtype family float, shape (2, 5) — shape (2, 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
calculate_psnr Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
agnjason/fmhr/train_unet.py
code served (permissive licence) · get_code("e7c54f2a25d9ee14")
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
import math

# Create small distinct-sized arrays for img1 and img2
# The function expects numpy arrays that can be cast to float64
img1 = np.random.randint(0, 256, size=(4, 3), dtype=np.uint8)
img2 = np.random.randint(0, 256, size=(4, 3), dtype=np.uint8)

# Create a mask with some True values
# mask.sum() is used in division, so it must be > 0
mask = np.array([[True, False, True],
                 [True, True, False],
                 [False, True, True],
                 [True, True, True]], dtype=bool)

ARGS = {
    "img1": img1,
    "img2": img2,
    "mask": mask
}
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 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
compute_laplacian Ran
ran; our contract draft was wrong, not the code
agnjason/fmhr/mano_optim.py
code served (permissive licence) · get_code("1725abb601f10ca5")
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 Tensor. 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 torch

torch.manual_seed(0)

# Create a simple mesh with 4 vertices and 2 triangular faces
# verts: (V, 3) - 4 vertices with 3D coordinates
verts = torch.tensor([
    [0.0, 0.0, 0.0],
    [1.0, 0.0, 0.0],
    [0.0, 1.0, 0.0],
    [0.0, 0.0, 1.0]
], dtype=torch.float32)

# faces: (F, 3) - 2 faces, each with 3 vertex indices
faces = torch.tensor([
    [0, 1, 2],
    [0, 1, 3]
], dtype=torch.long)

ARGS = {
    'verts': verts,
    'faces': faces
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, shape (4, 4) — shape (4, 4) as a later run recorded it
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
convert2sparse Ran
ran; our contract draft was wrong, not the code
agnjason/fmhr/models/gcn.py
code served (permissive licence) · get_code("999ef3f8561e7b10")
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 Tensor. 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 torch
from scipy import sparse

torch.manual_seed(0)

# Create a small sparse matrix using scipy
# The function expects a scipy sparse matrix with .tocoo() method
row = np.array([0, 1, 2, 1])
col = np.array([0, 1, 2, 0])
data = np.array([1.0, 2.0, 3.0, 4.0])
scipy_sparse_matrix = sparse.coo_matrix((data, (row, col)), shape=(3, 4))

ARGS = {
    "matrix": scipy_sparse_matrix
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, scipy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, shape (3, 4) — shape (3, 4) as a later run recorded it
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
convmtx2 Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
agnjason/fmhr/models/sfs_utils.py
code served (permissive licence) · get_code("9583f37b904687d4")
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 csc_matrix. 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
from scipy.sparse import csc_matrix

# Create a small kernel (square matrix)
kernel = np.array([[1.0, 2.0],
                   [3.0, 4.0]])

# Create a small shape (height, width)
shape = (3, 4)

ARGS = {
    "kernel": kernel,
    "shape": shape
}
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 csc_matrix — a csc_matrix output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a csc_matrix 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
depth2normal Ran
ran, honoured the contract we drafted
agnjason/fmhr/models/sfs_utils.py
code served (permissive licence) · get_code("08ca1a3c5b8af575")
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 float, shape (4, 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

# Create a small depth map (2D array representing depth values)
# Using distinct dimensions: 4 height x 3 width
depth = np.array([
    [1.0, 2.0, 1.5],
    [1.5, 2.5, 2.0],
    [2.0, 2.2, 1.8],
    [1.8, 2.1, 1.9]
], dtype=np.float32)

ARGS = {
    "depth": depth
}
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 3, dtype family float, shape (4, 3, 3) — shape (4, 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
estimate_shading Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
agnjason/fmhr/models/sfs_utils.py
code served (permissive licence) · get_code("3359d23ac8fc9fd1")
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 cv2

# Create small test data
height, width = 4, 5

# Create a small color image (h, w, 3) with values in range [0, 255]
color_im = np.random.randint(0, 256, size=(height, width, 3), dtype=np.uint8)

# Create normals (h, w, 3) - normalized direction vectors
normals = np.random.randn(height, width, 3).astype(np.float64)
# Normalize each normal vector
for i in range(height):
    for j in range(width):
        norm = np.linalg.norm(normals[i, j])
        if norm > 0:
            normals[i, j] /= norm

# Create a boolean mask (h, w) with some True values
color_mask = np.random.rand(height, width) > 0.5
# Ensure at least 4 valid pixels for the least squares solution
color_mask.flat[np.random.choice(height * width, 4, replace=False)] = True

ARGS = {
    "color_im": color_im,
    "normals": normals,
    "color_mask": color_mask
}
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
fftfreqs Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
agnjason/fmhr/models/sap.py
code served (permissive licence) · get_code("086ad4999b6c210e")
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 Tensor, ndim 4, dtype family float, shape (4, 5, 4, 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)

ARGS = {
    "res": (4, 5, 6),
    "dtype": torch.float32,
    "exact": True
}
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 Tensor, ndim 4, dtype family float, shape (4, 5, 4, 3) — shape (4, 5, 4, 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_edges Ran
ran; our contract draft was wrong, not the code
agnjason/fmhr/mano_optim.py
code served (permissive licence) · get_code("a84f1093efd108a8")
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 torch

torch.manual_seed(0)

# Create small test data
# verts: tensor of vertex positions, shape (V, 3) where V is number of vertices
# faces: tensor of face indices, shape (F, 3) where F is number of faces
# Each face is a triplet of vertex indices [v0, v1, v2]

V = 4  # number of vertices
F = 2  # number of faces

# Create vertices - shape (4, 3)
verts = torch.randn(V, 3)

# Create faces - shape (2, 3)
# Each row contains 3 vertex indices
faces = torch.tensor([
    [0, 1, 2],
    [1, 2, 3]
], dtype=torch.long)

ARGS = {
    "verts": verts,
    "faces": faces,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — 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
get_ray_directions Ran
ran, honoured the contract we drafted
agnjason/fmhr/models/get_rays.py
code served (permissive licence) · get_code("e19803e9ee2c4627")
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 Tensor, ndim 3, dtype family float, shape (4, 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 torch

torch.manual_seed(0)

# These are camera intrinsic parameters
# H: image height
# W: image width
# fx, fy: focal lengths
# cx, cy: principal point (optical center)

ARGS = {
    "H": 4,
    "W": 3,
    "fx": 500.0,
    "fy": 500.0,
    "cx": 1.5,
    "cy": 2.0,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
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 3, dtype family float, shape (4, 3, 3) — shape (4, 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_rays Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
agnjason/fmhr/models/get_rays.py
code served (permissive licence) · get_code("f82ba403be143b44")
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 torch

torch.manual_seed(0)

# directions: used as left operand in matrix multiplication with c2w[:3, :3]
# c2w[:3, :3] has shape (3, 3), so directions should be broadcastable
# The function expects directions to have shape (..., 3) where ... can be any batch dimensions
# After @ operation with (3, 3), result is (..., 3)
# Then it's normalized and viewed to (-1, 3)
# Let's make directions shape (2, 4, 3) - batch of 2, spatial 4, 3D vectors
directions = torch.randn(2, 4, 3)

# c2w: camera-to-world matrix
# Used as: c2w[:3, :3] (3x3 rotation), c2w[:3, 3] (3D translation)
# Standard 4x4 homogeneous transformation matrix
c2w = torch.eye(4)
c2w[:3, :3] = torch.randn(3, 3)
c2w[:3, 3] = torch.randn(3)

ARGS = {
    "directions": directions,
    "c2w": c2w,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — 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
img Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
agnjason/fmhr/models/sap.py
code served (permissive licence) · get_code("d77c3b9fe4c2a271")
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 3, dtype family float, shape (2, 4, 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)

# The function takes a tensor x and multiplies it by i**deg (imaginary unit powers)
# It expects x to have a last dimension of size 2 (representing complex numbers as [real, imag])
# and performs operations like swapping and negating components

x = torch.randn(2, 4, 2)  # batch=2, some_dim=4, complex_dim=2
deg = 1

ARGS = {
    "x": x,
    "deg": deg,
}
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 3, dtype family float, shape (2, 4, 2) — shape (2, 4, 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
img_contrast_bright Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
agnjason/fmhr/get_data.py
code served (permissive licence) · get_code("10908dad0c9e096d")
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 (4, 5, 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 cv2

# Create a small test image with shape (h, w, c)
# Using uint8 dtype which is standard for images
h, w, c = 4, 5, 3
img = np.random.randint(0, 256, size=(h, w, c), dtype=np.uint8)

# Parameters for cv2.addWeighted
# a: weight for the first image
a = 1.2

# b: weight for the blank image (typically 0 for simple contrast adjustment)
b = 0.0

# g: scalar added to each pixel
g = 30

ARGS = {
    'img': img,
    'a': a,
    'b': b,
    'g': g
}
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 ndarray, ndim 3, dtype family int, shape (4, 5, 3) — shape (4, 5, 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
laplacian Ran
ran; our contract draft was wrong, not the code
agnjason/fmhr/models/mesh_sampling.py
code served (permissive licence) · get_code("278d8710708c571f")
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 csr_matrix. 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.sparse as sp

# Create a small sparse adjacency matrix W
# The function expects W to be a scipy sparse matrix with .sum() method
# and to support arithmetic operations
np.random.seed(0)

# Create a small sparse adjacency matrix (4x4)
# Using a symmetric adjacency matrix for a graph
data = np.array([1.0, 1.0, 1.0, 1.0, 1.0, 1.0])
row = np.array([0, 0, 1, 1, 2, 3])
col = np.array([1, 2, 0, 3, 0, 1])
W = sp.csr_matrix((data, (row, col)), shape=(4, 4), dtype=np.float64)

ARGS = {
    "W": W,
    "normalized": True,
}
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 csr_matrix — a csr_matrix output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a csr_matrix 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
laplacian_cot Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
agnjason/fmhr/mano_optim.py
code served (permissive licence) · get_code("635669225b79bf5c")
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 torch

torch.manual_seed(0)

# Create a simple mesh with 4 vertices and 2 triangular faces
verts = torch.tensor([
    [0.0, 0.0, 0.0],
    [1.0, 0.0, 0.0],
    [0.0, 1.0, 0.0],
    [0.0, 0.0, 1.0]
], dtype=torch.float32)

# Define 2 faces, each referencing 3 vertices
faces = torch.tensor([
    [0, 1, 2],
    [0, 1, 3]
], dtype=torch.long)

ARGS = {
    "verts": verts,
    "faces": faces
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — 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
normalize Ran
ran; our contract draft was wrong, not the code
agnjason/fmhr/models/ncc_utils.py
code served (permissive licence) · get_code("ee38789614e9343f")
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 Tensor, ndim 4, dtype family float, shape (2, 3, 4, 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 a flow tensor with shape (2, 3, 4, 2) - batch=2, height=3, width=4, channels=2
# This matches the 4D case in the function
flow = torch.randn(2, 3, 4, 2)

# Height and width parameters
h = 3
w = 4

# Optional clamp parameter
clamp = 1.0

ARGS = {
    "flow": flow,
    "h": h,
    "w": w,
    "clamp": clamp
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
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 4, dtype family float, shape (2, 3, 4, 2) — shape (2, 3, 4, 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
poolwT Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
agnjason/fmhr/models/gcn.py
code served (permissive licence) · get_code("3adcb35add712974")
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 Tensor, ndim 3, dtype family float, shape (2, 5, 4) 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)

# Analyze the function:
# - x: tensor with shape (n, m, fin), used with permute and reshape
# - L: tensor with shape (mp, ...), used with matmul and shape[0]
# The function does:
#   1. x.permute(1, 2, 0) -> (m, fin, n)
#   2. reshape(m, fin*n) -> (m, fin*n)
#   3. matmul(L, x) where L is (mp, fin*n)
#   4. reshape(mp, fin, n) and permute(2, 0, 1) -> (n, mp, fin)

# So L must be shape (mp, fin*n) to multiply with (m, fin*n)
# This means L.shape[0] = mp and L.shape[1] = fin*n

# Let's use distinct sizes:
n = 2      # batch size
m = 3      # spatial dimension
fin = 4    # input features
mp = 5     # output pooling dimension (L.shape[0])

# x shape: (n, m, fin) = (2, 3, 4)
x = torch.randn(n, m, fin)

# L shape: (mp, fin*n) - note that for matmul to work with reshaped x of (m, fin*n),
# L must be (mp, m*fin) or we need to reconsider...
# Looking at the code: x becomes (m, fin*n) after reshape
# Then matmul(L, x) means L @ x where L is (mp, ?) and x is (?, something)
# For this to work: L must be (mp, m*fin) since x is reshaped to (m, fin*n)
# Wait, let me retrace:
# x starts (n, m, fin) = (2, 3, 4)
# x.permute(1, 2, 0) = (m, fin, n) = (3, 4, 2)
# x.reshape(m, fin*n) = (3, 8)
# matmul(L, x) with x being (3, 8): L must be (mp, 3) for valid matmul output (mp, 8)
# So L.shape = (mp, m)

L = torch.randn(mp, m)

ARGS = {
    "x": x,
    "L": L,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
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 3, dtype family float, shape (2, 5, 4) — shape (2, 5, 4) 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
rescale_L Ran
ran; our contract draft was wrong, not the code
agnjason/fmhr/models/mesh_sampling.py
code served (permissive licence) · get_code("e331855d53ef4b5e")
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 csr_matrix. 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 scipy.sparse as sp
import numpy as np

# Create a small sparse Laplacian matrix
# The function expects L to be a sparse matrix with shape (M, M)
M = 4
L = sp.random(M, M, density=0.5, format='csr', dtype=np.float32)
# Make it symmetric to be a valid Laplacian-like matrix
L = (L + L.T) / 2

ARGS = {
    'L': L,
    'lmax': 2
}
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 csr_matrix — a csr_matrix output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a csr_matrix 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
sap_generate Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
agnJason/FMHR/models/sap.py
code served (permissive licence) · get_code("523ed667113feb04")
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 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 torch
import torch.nn as nn

torch.manual_seed(0)

# Build a mock DPSR model
class MockDPSR(nn.Module):
    def __init__(self):
        super().__init__()
        self.linear = nn.Linear(3, 16)
    
    def forward(self, points, normals):
        # points: (batch, num_points, 3)
        # normals: (batch, num_points, 3)
        # Output should be (batch, 1, grid_size, grid_size, grid_size) or similar
        batch_size = points.shape[0]
        # Return a small grid tensor with batch dimension and channel dimension
        return torch.randn(batch_size, 1, 4, 4, 4)

# Build a mock PSR2Mesh model
class MockPSR2Mesh(nn.Module):
    def __init__(self):
        super().__init__()
        self.linear = nn.Linear(64, 32)
    
    def forward(self, psr_grid):
        # psr_grid: (batch, 1, 4, 4, 4) or similar
        batch_size = psr_grid.shape[0]
        # Return vertices (batch, num_verts, 3) and faces (batch, num_faces, 3)
        num_verts = 8
        num_faces = 6
        vertices = torch.randn(batch_size, num_verts, 3)
        faces = torch.randint(0, num_verts, (batch_size, num_faces, 3))
        return vertices, faces

dpsr = MockDPSR()
psr2mesh = MockPSR2Mesh()

# Create inputs: (batch, num_points, 6) where first 3 are points, last 3 are normals
batch_size = 2
num_points = 5
inputs = torch.randn(batch_size, num_points, 6)

# Create center and scale
center = torch.tensor([0.0, 0.0, 0.0])
scale = torch.tensor([1.0, 1.0, 1.0])

ARGS = {
    "dpsr": dpsr,
    "psr2mesh": psr2mesh,
    "inputs": inputs,
    "center": center,
    "scale": scale,
}
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 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
sap_transform Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
agnJason/FMHR/models/sap.py
code served (permissive licence) · get_code("f3a258f73e2c917f")
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 Tensor, 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 numpy as np

torch.manual_seed(0)

# Create small tensors for the function parameters
# verts: vertices tensor, shape (2, 4) - batch of 2, 4D coordinates
verts = torch.randn(2, 4)

# center: center point for translation, shape (4,) - same dimension as verts
center = torch.randn(4)

# scale: scale factor for normalization, shape (4,) - same dimension as verts
scale = torch.randn(4).abs() + 0.1  # ensure non-zero values

# inverse: boolean flag for direction of transformation
inverse = False

ARGS = {
    "verts": verts,
    "center": center,
    "scale": scale,
    "inverse": inverse
}
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 Tensor, ndim 2, dtype family float — no output shape is stated: observe_signature.py could not observe it (no_result)
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
scale_input Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
agnjason/fmhr/models/PostionalEncoding.py
code served (permissive licence) · get_code("ff4a0c727a4528a5")
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 Tensor, ndim 4, dtype family float, shape (2, 4, 5, 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

torch.manual_seed(0)

# Construct a small 3D grid tensor
# Shape: (batch=2, height=4, width=5, channels=3) for a 3D coordinate grid
grid_3d = torch.randn(2, 4, 5, 3)

# Construct a transform matrix
# Shape: (4, 4) - standard homogeneous transformation matrix
# First 3 rows: rotation + translation, last row: perspective (usually [0, 0, 0, 1])
transform = torch.eye(4)
transform[:3, :3] = torch.randn(3, 3)  # Random rotation-like matrix
transform[:3, 3] = torch.randn(3)      # Translation component

# Construct a scale value
scale = 2.5

ARGS = {
    "tensor": grid_3d,
    "transform": transform,
    "scale": scale,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
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 4, dtype family float, shape (2, 4, 5, 3) — shape (2, 4, 5, 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
spec_gaussian_filter Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
agnjason/fmhr/models/sap.py
code served (permissive licence) · get_code("656da6fdcc2cdcbf")
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 Tensor, ndim 5, dtype family float, shape (8, 6, 3, 1, 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 torch
import numpy as np

torch.manual_seed(0)

ARGS = {
    "res": (8, 6, 4),
    "sig": 1.0
}
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 Tensor, ndim 5, dtype family float, shape (8, 6, 3, 1, 1) — shape (8, 6, 3, 1, 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
transform_3D_grid Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
agnjason/fmhr/models/PostionalEncoding.py
code served (permissive licence) · get_code("1773bfa986183e62")
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 Tensor, ndim 4, dtype family float, shape (2, 4, 5, 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

torch.manual_seed(0)

# Create a 3D grid with shape (batch, height, width, channels=3)
grid_3d = torch.randn(2, 4, 5, 3)

# Create a transform matrix with shape (4, 4) - 3x3 rotation + 3x1 translation
# The function expects transform[None, None, None, i, j] indexing
transform = torch.randn(4, 4)

# Scale factor
scale = 2.0

ARGS = {
    "grid_3d": grid_3d,
    "transform": transform,
    "scale": scale,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
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 4, dtype family float, shape (2, 4, 5, 3) — shape (2, 4, 5, 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
vertex_quadrics Ran
ran, honoured the contract we drafted
agnjason/fmhr/models/mesh_sampling.py
code served (permissive licence) · get_code("3129a88f8d186902")
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 float, shape (4, 4, 4) 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 Mesh:
    def __init__(self, v, f):
        self.v = v
        self.f = f

# Create a simple mesh with 4 vertices and 2 triangular faces
# vertices: 4 vertices in 3D space
vertices = np.array([
    [0.0, 0.0, 0.0],
    [1.0, 0.0, 0.0],
    [0.0, 1.0, 0.0],
    [0.0, 0.0, 1.0]
], dtype=np.float64)

# faces: 2 triangles, each defined by 3 vertex indices
faces = np.array([
    [0, 1, 2],
    [0, 1, 3]
], dtype=np.int32)

mesh = Mesh(v=vertices, f=faces)

ARGS = {
    "mesh": mesh
}
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 3, dtype family float, shape (4, 4, 4) — shape (4, 4, 4) 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

Also present in other papers' code

Of 25 samples lifted from this paper's linked repositories, 25 carry a function identity and 0 do not. Of the 25 distinct functions with an identity, 6 are also present in other papers whose code we hold (6 with at least one paper dated earlier, 0 the same month, 0 later) and 19 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
normalize 2 other papers
2 dated earlier
2205.15848 (2022-05)
Geo-Neus: Geometry-Consistent Neural Implicit Surfaces Learning for Multi-view Reconstruction
2206.05737 (2022-06)
SparseNeuS: Fast Generalizable Neural Surface Reconstruction from Sparse Views
vertex_quadrics 2 other papers
2 dated earlier
2111.08176 (2021-11)
Coarse-to-fine Animal Pose and Shape Estimation
2111.14672 (2021-11)
Human Performance Capture from Monocular Video in the Wild
add_hom 1 other paper
1 dated earlier
2206.05737 (2022-06)
SparseNeuS: Fast Generalizable Neural Surface Reconstruction from Sparse Views
fftfreqs 1 other paper
1 dated earlier
2106.03452 (2021-06)
Shape As Points: A Differentiable Poisson Solver
img 1 other paper
1 dated earlier
2106.03452 (2021-06)
Shape As Points: A Differentiable Poisson Solver
spec_gaussian_filter 1 other paper
1 dated earlier
2106.03452 (2021-06)
Shape As Points: A Differentiable Poisson Solver

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

Reconstructing high-fidelity hand models with intricate textures plays a crucial role in enhancing human-object interaction and advancing real-world applications. Despite the stateof-the-art methods excelling in texture generation and image rendering, they often face challenges in accurately capturing geometric details. Learning-based approaches usually offer better robustness and faster inference, which tend to produce smoother results and require substantial amounts of training data. To address these issues, we present a novel fine-grained multi-view hand mesh reconstruction method that leverages inverse rendering to restore hand poses and intricate details. Firstly, our approach predicts a parametric hand mesh model through Graph Convolutional Networks (GCN) based method from multi-view images. We further introduce a novel Hand Albedo and Mesh (HAM) optimization module to refine both the hand mesh and textures, which is capable of preserving the mesh topology. In addition, we suggest an effective mesh-based neural rendering scheme to simultaneously generate photo-realistic image and optimize mesh geometry by fusing the pre-trained rendering network with vertex features. We conduct the comprehensive experiments on Inter-Hand2.6M, DeepHandMesh and dataset collected by ourself, whose promising results show that our proposed approach outperforms the state-of-the-art methods on both reconstruction accuracy and rendering quality. Code and dataset are publicly available at https://github.com/agnJason/FMHR.

For agents

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

get_harvested_code_for_paper("2407.05680")
get_code_for_paper("2407.05680")
have("2407.05680")

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

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

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

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

Connect an agent — have() is free.