SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 2008.07928 · 2020

Visibility-aware Multi-view Stereo Network

arXiv · PDF · Open in the Atlas

Code that ran

12 of 14 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; 1 honoured the contract we drafted, 0 violated it and 7 have no contract verdict; 4 failures of our instrument; 2 no recorded run), measured 2026-11-21; 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/2008.07928.json · badge: /api/ran/2008.07928.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
jzhangbs/Vis-MVSNet canonical (classifier label)
classifier basis: census
12 ran · 2 no recorded run
FunctionStatusWhere it lives
cam_adjust_max_d Ran
ran on a synthesized input
jzhangbs/Vis-MVSNet/utils/io_utils.py
code served (permissive licence) · get_code("83fd8ab4abf3b6b3")
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. 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 numpy as np

# Analyze the function:
# - cam.copy() is called, so cam must be a copyable object (list or numpy array)
# - cam[1][3][2] and cam[1][3][1] are accessed and modified, so cam needs nested indexing
# - cam is a nested structure: cam[1][3] suggests at least 2 levels of nesting
# - cam[1][3][2] / max_d is performed, so elements must be numeric
# - max_d is a numeric value used in division

# Create a nested list structure that represents camera parameters
# cam[1] accesses the second element
# cam[1][3] accesses the 4th element of that
# cam[1][3][1] and cam[1][3][2] are accessed

cam = [
    [0, 0, 0, 0],  # cam[0]
    [                # cam[1]
        [0, 0, 0, 0],
        [0, 0, 0, 0],
        [0, 0, 0, 0],
        [10.0, 20.0, 50.0, 0]  # cam[1][3] - needs numeric values for division
    ]
]

max_d = 25.0

ARGS = {
    "cam": cam,
    "max_d": max_d
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type list — a list 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
class2depth Ran
ran on a synthesized input
jzhangbs/Vis-MVSNet/core/homography.py
code served (permissive licence) · get_code("32a49fc76d7e9ea7")
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 1, dtype family float, shape (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)

# Analyzing the function:
# - class_: appears to be numeric (scalar or tensor), used in arithmetic operations
# - depth_start: numeric, used in arithmetic
# - depth_interval: numeric, used in arithmetic
# - depth_num: numeric, used in arithmetic
# - inv: boolean flag

# The function performs depth estimation calculations
# class_ is multiplied by depth_interval and added to depth_start
# When inv=True, it performs inverse depth calculations

# Create test arguments
class_ = torch.tensor([0.0, 1.0, 2.0])  # 1D tensor of class indices
depth_start = torch.tensor(0.5)  # scalar tensor
depth_interval = torch.tensor(0.1)  # scalar tensor
depth_num = 5  # integer for number of depth steps
inv = False  # boolean flag

ARGS = {
    "class_": class_,
    "depth_start": depth_start,
    "depth_interval": depth_interval,
    "depth_num": depth_num,
    "inv": inv
}
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 1, dtype family float, shape (3,) — shape (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
depth2class Ran
ran on a synthesized input
jzhangbs/Vis-MVSNet/core/homography.py
code served (permissive licence) · get_code("fcb4565691bda0d3")
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
import numpy as np

torch.manual_seed(0)

# The function depth2class converts depth values to class indices
# Parameters:
# - depth: depth values (typically a tensor or array)
# - depth_start: starting depth value (scalar)
# - depth_interval: interval between depth classes (scalar)
# - depth_num: number of depth classes (scalar)
# - inv: boolean flag for inverse conversion

depth = torch.tensor([[1.0, 2.0, 3.0, 4.0],
                      [1.5, 2.5, 3.5, 4.5]], dtype=torch.float32)

depth_start = 1.0
depth_interval = 0.5
depth_num = 10
inv = False

ARGS = {
    "depth": depth,
    "depth_start": depth_start,
    "depth_interval": depth_interval,
    "depth_num": depth_num,
    "inv": inv
}
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, 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
entropy Ran
ran on a synthesized input
jzhangbs/Vis-MVSNet/core/nn_utils.py
code served (permissive licence) · get_code("f6699ba2ecb27033")
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 1, dtype family float, shape (2,) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch

torch.manual_seed(0)

# Create a small probability-like tensor (values between 0 and 1)
# Shape: (2, 4) - batch size 2, 4 dimensions
volume = torch.rand(2, 4)

# dim parameter: compute entropy along dimension 1
dim = 1

# keepdim parameter: whether to keep the reduced dimension
keepdim = False

ARGS = {
    "volume": volume,
    "dim": dim,
    "keepdim": keepdim,
}
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 1, dtype family float, shape (2,) — shape (2,) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
idx_cam2world Ran
ran; our contract draft was wrong, not the code
jzhangbs/Vis-MVSNet/fusion.py
code served (permissive licence) · get_code("b3177b6700ce6b03")
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 (2, 2, 3, 4, 1) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn

torch.manual_seed(0)

# Analyze the function:
# - idx_cam_homo: used with unsqueeze(1), indexing [..., -1:, :], division
#   Shape must support these operations. Likely (batch, ..., 4, 1) homogeneous coords
# - cam: indexed as cam[:, 0:1, ...], then .unsqueeze(1), then .inverse()
#   Shape must be (batch, >=1, 4, 4) to support inverse and matrix mult
#   The [:, 0:1, ...] extracts first element along dim 1, keeping dims

# Let's construct:
# cam should be (batch, num_cameras, 4, 4) transformation matrices
# idx_cam_homo should be (batch, num_indices, 4, 1) homogeneous coordinates

batch_size = 2
num_indices = 3
num_cameras = 2

# Create cam: (batch, num_cameras, 4, 4) invertible matrices
cam = torch.zeros(batch_size, num_cameras, 4, 4)
for b in range(batch_size):
    for c in range(num_cameras):
        # Create a valid 4x4 transformation matrix
        mat = torch.eye(4)
        mat[:3, :3] = torch.randn(3, 3)
        mat[:3, 3] = torch.randn(3)
        cam[b, c] = mat

# Create idx_cam_homo: (batch, num_indices, 4, 1) homogeneous coordinates
idx_cam_homo = torch.randn(batch_size, num_indices, 4, 1)
idx_cam_homo[..., -1, :] = 1.0  # Set homogeneous coordinate to 1

ARGS = {
    "idx_cam_homo": idx_cam_homo,
    "cam": cam,
}
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 5, dtype family float, shape (2, 2, 3, 4, 1) — shape (2, 2, 3, 4, 1) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
idx_img2cam Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
jzhangbs/Vis-MVSNet/fusion.py
code served (permissive licence) · get_code("b367d598f840de5a")
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 (2, 4, 3, 4, 1) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch

torch.manual_seed(0)

# idx_img_homo: shape (batch, height, width, 3, 1)
# The function uses it in matrix multiplication with cam inverse
batch_size = 2
height = 4
width = 3
idx_img_homo = torch.randn(batch_size, height, width, 3, 1)

# depth: shape (batch, height, width, 1)
# The function permutes it to (batch, height, width, 1) then unsqueezes
depth = torch.randn(batch_size, 1, height, width)

# cam: shape (batch, 4, 4, 4) based on indexing cam[:, 1:2, :3, :3]
# cam[:, 1:2, :3, :3] extracts shape (batch, 1, 3, 3)
# Then unsqueeze(1) makes it (batch, 1, 1, 3, 3)
# This is used as a matrix to invert and multiply with idx_img_homo
cam = torch.randn(batch_size, 4, 4, 4)

ARGS = {
    "idx_img_homo": idx_img_homo,
    "depth": depth,
    "cam": cam,
}
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 5, dtype family float, shape (2, 4, 3, 4, 1) — shape (2, 4, 3, 4, 1) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
load_cam Ran
ran on a synthesized input
jzhangbs/Vis-MVSNet/utils/io_utils.py
code served (permissive licence) · get_code("e0226ccf167bd1ef")
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 (2, 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
import tempfile
import os

# Create a temporary camera file with 29 words (one valid format)
temp_dir = tempfile.mkdtemp()
cam_file = os.path.join(temp_dir, "camera.txt")

# Format: 1 word header + 16 extrinsic words + 9 intrinsic words + 3 depth-related words = 29 words
cam_content = """header
1.0 0.0 0.0 0.0
0.0 1.0 0.0 0.0
0.0 0.0 1.0 0.0
0.0 0.0 0.0 1.0
320.0 0.0 160.0
0.0 320.0 120.0
0.0 0.0 1.0
0.5 0.1 192"""

with open(cam_file, 'w') as f:
    f.write(cam_content)

ARGS = {
    "file": cam_file,
    "max_d": 192,
    "interval_scale": 1
}
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 (2, 4, 4) — shape (2, 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
load_pair Ran
ran on a synthesized input
jzhangbs/Vis-MVSNet/fusion.py
code served (permissive licence) · get_code("4f921363127792d3")
How it ran

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

import tempfile
import os

# Create a temporary file with valid pair data
temp_file = tempfile.NamedTemporaryFile(mode='w', delete=False, suffix='.txt')
temp_file_path = temp_file.name

# Write valid pair file content
# Format: first line is n_cam, then for each camera: img_id line, then pairs line
content = """3
img_001
3 img_002 0.9 img_003 0.85 img_004 0.75
img_005
2 img_006 0.88 img_007 0.82
img_008
1 img_009 0.91
"""

temp_file.write(content)
temp_file.close()

ARGS = {
    'file': temp_file_path,
    'min_views': None
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type dict — a dict output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a dict output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
read_cameras_binary Ran
ran; our contract draft was wrong, not the code
jzhangbs/Vis-MVSNet/colmap2mvsnet.py
code served (permissive licence) · get_code("0bf4b207ce0d106a")
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 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 collections
import struct
import numpy as np
import tempfile
import os

CameraModel = collections.namedtuple('CameraModel', ['model_id', 'model_name', 'num_params'])

Camera = collections.namedtuple('Camera', ['id', 'model', 'width', 'height', 'params'])

CAMERA_MODELS = {CameraModel(model_id=0, model_name='SIMPLE_PINHOLE', num_params=3), CameraModel(model_id=1, model_name='PINHOLE', num_params=4), CameraModel(model_id=2, model_name='SIMPLE_RADIAL', num_params=4), CameraModel(model_id=3, model_name='RADIAL', num_params=5), CameraModel(model_id=4, model_name='OPENCV', num_params=8), CameraModel(model_id=5, model_name='OPENCV_FISHEYE', num_params=8), CameraModel(model_id=6, model_name='FULL_OPENCV', num_params=12), CameraModel(model_id=7, model_name='FOV', num_params=5), CameraModel(model_id=8, model_name='SIMPLE_RADIAL_FISHEYE', num_params=4), CameraModel(model_id=9, model_name='RADIAL_FISHEYE', num_params=5), CameraModel(model_id=10, model_name='THIN_PRISM_FISHEYE', num_params=12)}

CAMERA_MODEL_IDS = dict([(camera_model.model_id, camera_model) for camera_model in CAMERA_MODELS])

# Create a temporary binary file with valid camera data
temp_file = tempfile.NamedTemporaryFile(delete=False, suffix='.bin')
temp_path = temp_file.name

try:
    # Write number of cameras (2 cameras)
    num_cameras = 2
    temp_file.write(struct.pack('<Q', num_cameras))
    
    # Write first camera
    camera_id_1 = 1
    model_id_1 = 1  # PINHOLE with 4 params
    width_1 = 640
    height_1 = 480
    params_1 = [500.0, 500.0, 320.0, 240.0]  # fx, fy, cx, cy
    temp_file.write(struct.pack('<iiQQ', camera_id_1, model_id_1, width_1, height_1))
    temp_file.write(struct.pack('<' + 'd' * 4, *params_1))
    
    # Write second camera
    camera_id_2 = 2
    model_id_2 = 2  # SIMPLE_RADIAL with 4 params
    width_2 = 800
    height_2 = 600
    params_2 = [600.0, 400.0, 300.0, 0.1]  # fx, fy, cx, cy, k1
    temp_file.write(struct.pack('<iiQQ', camera_id_2, model_id_2, width_2, height_2))
    temp_file.write(struct.pack('<' + 'd' * 4, *params_2))
    
    temp_file.close()
    
    ARGS = {
        'path_to_model_file': temp_path
    }
    
finally:
    pass
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type 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
read_cameras_text Ran
ran; our contract draft was wrong, not the code
jzhangbs/Vis-MVSNet/colmap2mvsnet.py
code served (permissive licence) · get_code("8a38e306ff4c5b42")
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 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 collections
import numpy as np
import tempfile
import os

Camera = collections.namedtuple('Camera', ['id', 'model', 'width', 'height', 'params'])

# Create a temporary file with valid camera data in the expected format
temp_file = tempfile.NamedTemporaryFile(mode='w', delete=False, suffix='.txt')
temp_path = temp_file.name

# Write sample camera data
# Format: camera_id model width height params...
temp_file.write("# Camera list\n")
temp_file.write("1 SIMPLE_PINHOLE 640 480 320.5 240.5 500.0\n")
temp_file.write("2 PINHOLE 800 600 400.0 300.0 600.0 0.1\n")
temp_file.close()

ARGS = {
    'path': temp_path
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type 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
read_next_bytes Ran
ran, honoured the contract we drafted
jzhangbs/Vis-MVSNet/colmap2mvsnet.py
code served (permissive licence) · get_code("56858e04e6fdb2ff")
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, 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 struct
import io

# Create a binary file-like object with test data
# We'll pack some values and then read them back
test_data = struct.pack('<hfi', 42, 3.14, 100)
fid = io.BytesIO(test_data)

ARGS = {
    'fid': fid,
    'num_bytes': 10,  # 2 bytes (h) + 4 bytes (f) + 4 bytes (i) = 10 bytes
    'format_char_sequence': 'hfi',
    'endian_character': '<'
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1
Imports
none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type 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
soft_argmin Ran
ran on a synthesized input
jzhangbs/Vis-MVSNet/core/nn_utils.py
code served (permissive licence) · get_code("3d80472f3900873b")
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
import torch.nn as nn

torch.manual_seed(0)

# Create a small volume tensor with shape (batch=2, channels=4, depth=3)
# The function will apply softmax along one dimension and compute soft argmin
volume = torch.randn(2, 4, 3)

# dim parameter: which dimension to apply softmax and compute argmin over
dim = 1

# keepdim parameter: whether to keep the dimension after reduction
keepdim = False

# window parameter: optional window for masking (None or a float value)
window = None

ARGS = {
    "volume": volume,
    "dim": dim,
    "keepdim": keepdim,
    "window": window,
}
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
load_pair Not yet run
unverified (harvested, no recorded run)
jzhangbs/Vis-MVSNet/utils/io_utils.py
code served (permissive licence) · get_code("4e7b4da89842339f")
How it ran

no invocation recorded.

multi_dims Not yet run
unverified (harvested, no recorded run)
jzhangbs/Vis-MVSNet/core/nn_utils.py
code served (permissive licence) · get_code("e63b03e90bc40e90")
How it ran

no invocation recorded.

Also present in other papers' code

Of 14 samples lifted from this paper's linked repositories, 14 carry a function identity and 0 do not. Of the 14 distinct functions with an identity, 5 are also present in other papers whose code we hold (3 with at least one paper dated earlier, 0 the same month, 5 later) and 9 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
read_next_bytes 70 other papers
5 dated earlier, 65 later
1804.00650 (2018-04)
DeepMVS: Learning Multi-view Stereopsis
1902.10556 (2019-02)
Recurrent MVSNet for High-resolution Multi-view Stereo Depth Inference
1912.06378 (2019-12)
Cascade Cost Volume for High-Resolution Multi-View Stereo and Stereo Matching
and 67 more not named here
read_cameras_text 37 other papers
4 dated earlier, 33 later
1902.10556 (2019-02)
Recurrent MVSNet for High-resolution Multi-view Stereo Depth Inference
1912.06378 (2019-12)
Cascade Cost Volume for High-Resolution Multi-View Stereo and Stereo Matching
1912.11744 (2019-12)
Planar Prior Assisted PatchMatch Multi-View Stereo
and 34 more not named here
read_cameras_binary 21 other papers
4 dated earlier, 17 later
1902.10556 (2019-02)
Recurrent MVSNet for High-resolution Multi-view Stereo Depth Inference
1912.06378 (2019-12)
Cascade Cost Volume for High-Resolution Multi-View Stereo and Stereo Matching
1912.11744 (2019-12)
Planar Prior Assisted PatchMatch Multi-View Stereo
and 18 more not named here
idx_cam2world 1 other paper
1 later
2108.09964 (2021-08)
Learning Signed Distance Field for Multi-view Surface Reconstruction
idx_img2cam 1 other paper
1 later
2108.09964 (2021-08)
Learning Signed Distance Field for Multi-view Surface Reconstruction

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-21.

Repositories linked to this paper

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

Abstract

Learning-based multi-view stereo (MVS) methods have demonstrated promising results. However, very few existing networks explicitly take the pixel-wise visibility into consideration, resulting in erroneous cost aggregation from occluded pixels. In this paper, we explicitly infer and integrate the pixel-wise occlusion information in the MVS network via the matching uncertainty estimation. The pair-wise uncertainty map is jointly inferred with the pair-wise depth map, which is further used as weighting guidance during the multi-view cost volume fusion. As such, the adverse influence of occluded pixels is suppressed in the cost fusion. The proposed framework Vis-MVSNet significantly improves depth accuracies in the scenes with severe occlusion. Extensive experiments are performed on DTU, BlendedMVS, and Tanks and Temples datasets to justify the effectiveness of the proposed framework.

For agents

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

get_harvested_code_for_paper("2008.07928")
get_code_for_paper("2008.07928")
have("2008.07928")

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

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

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

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

Connect an agent — have() is free.