SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 2109.09628 · 2021

Advancing Self-supervised Monocular Depth Learning with Sparse LiDAR

arXiv · PDF · Open in the Atlas

Code that ran

15 of 15 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, 1 violated it and 10 have no contract verdict; 3 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/2109.09628.json · badge: /api/ran/2109.09628.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
AutoAILab/FusionDepth canonical (classifier label)
classifier basis: census
15 ran · 0 no recorded run
FunctionStatusWhere it lives
batch_post_process_disparity Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
AutoAILab/FusionDepth/evaluate_completion.py
code served (permissive licence) · get_code("a8814cc5c348b987")
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 ndarray, ndim 3, dtype family float, shape (2, 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 numpy as np

# Create small disparity maps
# Shape: (batch, height, width)
batch_size = 2
height = 4
width = 3

l_disp = np.random.rand(batch_size, height, width).astype(np.float32)
r_disp = np.random.rand(batch_size, height, width).astype(np.float32)

ARGS = {
    "l_disp": l_disp,
    "r_disp": r_disp,
}
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 ndarray, ndim 3, dtype family float, shape (2, 4, 3) — shape (2, 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
bottom_crop Ran
ran on a synthesized input
AutoAILab/FusionDepth/gen2cha_completion.py
code served (permissive licence) · get_code("84e9764cfc1ac6b1")
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 (352, 1216, 3) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import numpy as np

torch.manual_seed(0)

# Create a test image tensor with shape (height, width, channels)
# Using distinct dimensions: 400 height, 1300 width, 3 channels
# This ensures the crop operation has room to work
img_3d = torch.randn(400, 1300, 3)

ARGS = {
    "img": img_3d
}
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 3, dtype family float, shape (352, 1216, 3) — shape (352, 1216, 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
compute_errors Ran
ran, honoured the contract we drafted
AutoAILab/FusionDepth/evaluate_depth.py
pointer only (licence: MIT); the stored copy get_code serves, from nianticlabs/depth-hints, is pointer only (licence: NOASSERTION) · get_code("edd4f86e8f02732f")
How it ran

The body of this sample is withheld: this paper's link allows the body inline (MIT), but get_code serves the stored copy, first harvested from nianticlabs/depth-hints, and GitHub could not classify the licence of that repository (NOASSERTION). The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

compute_errors Ran
ran on a synthesized input
AutoAILab/FusionDepth/evaluate_completion.py
code served (permissive licence) · get_code("8e520332ac6e2b25")
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

# Create small numpy arrays for ground truth and predictions
# These represent depth maps in meters
np.random.seed(0)
gt = np.random.uniform(0.5, 10.0, size=(4, 3))
pred = np.random.uniform(0.5, 10.0, size=(4, 3))

ARGS = {
    "gt": gt,
    "pred": pred,
}
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
depth2ptc Ran
ran on a synthesized input
AutoAILab/FusionDepth/evaluate_depth.py
code served (permissive licence) · get_code("726548552574d958")
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 (12, 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

class MockCalib:
    """Mock calibration object with project_image_to_rect method."""
    def project_image_to_rect(self, points):
        """
        Project image points to rectified camera coordinates.
        Args:
            points: (N, 3) array of [x, y, depth] coordinates
        Returns:
            (N, 3) array of rectified coordinates
        """
        # Simple mock: apply a linear transformation
        # points shape is (N, 3), return same shape
        transformation = np.array([
            [0.5, 0.1, 0.0],
            [0.1, 0.5, 0.0],
            [0.0, 0.0, 1.0]
        ])
        return points @ transformation.T

# Create a small depth map (4x3 for distinct dimensions)
depth = np.random.rand(4, 3).astype(np.float32) * 10.0

# Create a mock calibration object
calib = MockCalib()

ARGS = {
    "depth": depth,
    "calib": calib
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ndarray, ndim 2, dtype family float, shape (12, 3) — shape (12, 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
disp_to_depth Ran
ran, violated the contract we drafted
AutoAILab/FusionDepth/layers.py
code served (permissive licence) · get_code("62287188376f0ba0")
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 4, 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 a small disparity tensor
# Shape: (batch_size=2, height=4, width=3)
disp = torch.rand(2, 4, 3)

# Set min_depth and max_depth as scalars
min_depth = 0.1
max_depth = 100.0

ARGS = {
    "disp": disp,
    "min_depth": min_depth,
    "max_depth": max_depth,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple, ndim 4, 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
filter_mask Ran
ran on a synthesized input
AutoAILab/FusionDepth/gdc_old.py
code served (permissive licence) · get_code("e1d7378c4e2e8fce")
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 (6,) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import numpy as np

torch.manual_seed(0)

# Create a small point cloud in rectangular coordinates
# The function expects pc_rect with shape (N, 3) where columns are [x, y, z]
# It filters based on z, x, and y ranges
pc_rect = torch.tensor([
    [0.0, 0.0, 50.0],      # valid point
    [35.0, 1.0, 40.0],     # valid point
    [50.0, 0.0, 50.0],     # invalid: x >= 40
    [-35.0, -0.5, 10.0],   # valid point
    [0.0, 3.0, 50.0],      # invalid: y >= 2.5
    [0.0, 0.0, 0.5],       # invalid: z <= 1
], dtype=torch.float32)

ARGS = {
    "pc_rect": pc_rect
}
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 (6,) — shape (6,) 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
filter_theta_mask Ran
ran on a synthesized input
AutoAILab/FusionDepth/gdc_old.py
code served (permissive licence) · get_code("c2ce62aec738dd30")
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 (2,) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import numpy as np

# Construct a point cloud in rectangular coordinates
# The function expects pc_rect to be an array with shape (N, 3) where N is number of points
# Each row is [x, y, z]

# Create a small point cloud with 2 points
pc_rect = np.array([
    [1.0, 0.5, 1.0],
    [2.0, 1.0, 2.0]
], dtype=np.float32)

# Define angle thresholds for theta filtering
# theta = arcsin(y/d) ranges from -pi/2 to pi/2
low = -0.5  # lower bound for theta in radians
high = 0.5  # upper bound for theta in radians

ARGS = {
    'pc_rect': pc_rect,
    'low': low,
    'high': high
}
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 (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
get_4beam_2channel Ran
ran on a synthesized input
AutoAILab/FusionDepth/gen2cha_completion.py
code served (permissive licence) · get_code("7020a51528198a64")
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)

# Create a small fourbeam tensor with shape [height, width]
# The function iterates over rows 110-350 and columns 2-1214
# We need to create a tensor large enough to contain these indices
# and populate it with some non-zero depth values
fourbeam = torch.zeros([352, 1216], dtype=torch.float32)

# Add some non-zero depth values in the iteration range
# to trigger the expansion logic
fourbeam[150, 500] = 10.0
fourbeam[200, 600] = 20.0
fourbeam[250, 700] = 15.0

ARGS = {
    'fourbeam': fourbeam,
    'height': 352,
    'width': 1216,
    'expand': 2
}
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
get_4beam_2channel Ran
ran on a synthesized input
AutoAILab/FusionDepth/gen2channel.py
code served (permissive licence) · get_code("7069e34106de8ca2")
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)

# Create a small fourbeam tensor with shape [height, width]
# The function expects to access fourbeam[i][j] for i in range(76, 190) and j in range(2, 638)
# So we need at least height >= 190 and width >= 638
fourbeam = torch.zeros([192, 640], dtype=torch.float32)

# Add some non-zero values in the region that will be processed
# to make the function actually do something meaningful
fourbeam[80, 10] = 5.0
fourbeam[85, 20] = 3.0
fourbeam[90, 30] = 7.0
fourbeam[100, 100] = 2.5

ARGS = {
    "fourbeam": fourbeam,
    "height": 192,
    "width": 640,
    "expand": 2,
}
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
get_depth Ran
ran on a synthesized input
AutoAILab/FusionDepth/gen2cha_completion.py
code served (permissive licence) · get_code("13035b58e28992f7")
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 (352, 1216) 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 os
import tempfile
import torch
import numpy as np
import PIL.Image as pil

torch.manual_seed(0)

# Create a temporary directory and a valid depth PNG file
temp_dir = tempfile.mkdtemp()

# Create a valid depth image with values > 255 when treated as int
# depth_png should have max value > 255 to pass the assertion
# The image needs to be large enough to crop (at least 352x1216)
height, width = 400, 1300
depth_array = np.random.randint(256, 4000, size=(height, width), dtype=np.int32)

# Save as PNG
file_path = os.path.join(temp_dir, "depth.png")
img = pil.fromarray(depth_array.astype(np.uint16), mode='I;16')
img.save(file_path)

ARGS = {
    'file_path': file_path
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
PIL, 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 (352, 1216) — shape (352, 1216) 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_detec_calib Ran
ran on a synthesized input
AutoAILab/FusionDepth/export_detection.py
code served (permissive licence) · get_code("57ea01679c8b00e5")
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 str. 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 os
import tempfile
import cv2
import numpy as np

# Create a temporary directory structure with a test image
temp_dir = tempfile.mkdtemp()
image_dir = os.path.join(temp_dir, 'image_02', 'data')
os.makedirs(image_dir, exist_ok=True)

# Create a test image with shape (375, 1242) to match the first condition
test_image = np.zeros((375, 1242, 3), dtype=np.uint8)
img_path = os.path.join(image_dir, '000000.png')
cv2.imwrite(img_path, test_image)

ARGS = {
    'folder': temp_dir,
    'frame_idx': 0
}
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 str — a str output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a str 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
get_translation_matrix Ran
ran; our contract draft was wrong, not the code
AutoAILab/FusionDepth/layers.py
code served (permissive licence) · get_code("955112f5788539a8")
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, 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 torch

torch.manual_seed(0)

# Create a translation vector with shape (batch_size=2, 3)
# The function expects a tensor with shape (N, 3) where N is batch size
translation_vector = torch.randn(2, 3)

ARGS = {
    "translation_vector": translation_vector
}
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, 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
subsample_mask_by_grid Ran
ran on a synthesized input
AutoAILab/FusionDepth/gdc_old.py
code served (permissive licence) · get_code("0bb6694313ca5db7")
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 (10,) 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 point cloud in rectangular coordinates
# Points should have at least 3 columns (x, y, z)
# Some points should pass the filter_mask criteria:
# - z: (1, 80)
# - x: [-40, 40)
# - y: [-1, 2.5)

pc_rect = np.array([
    [0.0, 0.0, 10.0],
    [5.0, 1.0, 20.0],
    [10.0, -0.5, 30.0],
    [-10.0, 0.5, 15.0],
    [-20.0, 2.0, 50.0],
    [100.0, 100.0, 100.0],  # Outside range, should be filtered
    [15.0, 1.5, 25.0],
    [0.0, 0.0, 2.0],
    [-30.0, 1.0, 60.0],
    [25.0, 0.0, 45.0],
], dtype=np.float32)

ARGS = {
    "pc_rect": pc_rect
}
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 (10,) — shape (10,) 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
transformation_from_parameters Ran
ran; our contract draft was wrong, not the code
AutoAILab/FusionDepth/layers.py
code served (permissive licence) · get_code("03d0f03d4f4d3260")
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, 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 torch

torch.manual_seed(0)

# Create small tensors for the function parameters
# axisangle should be Bx1x3 based on rot_from_axisangle docstring
axisangle = torch.randn(2, 1, 3)

# translation should be Bx3 based on get_translation_matrix usage
translation = torch.randn(2, 3)

# invert is a boolean flag
invert = False

ARGS = {
    "axisangle": axisangle,
    "translation": translation,
    "invert": invert,
}
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, 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

Also present in other papers' code

Of 15 samples lifted from this paper's linked repositories, 15 carry a function identity and 0 do not. Of the 15 distinct functions with an identity, 8 are also present in other papers whose code we hold (8 with at least one paper dated earlier, 0 the same month, 5 later) and 7 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
compute_errors 24 other papers
8 dated earlier, 16 later
1609.03677 (2016-09)
Unsupervised Monocular Depth Estimation with Left-Right Consistency
1803.02276 (2018-03)
GeoNet: Unsupervised Learning of Dense Depth, Optical Flow and Camera Pose
1806.01260 (2018-06)
Digging Into Self-Supervised Monocular Depth Estimation
and 21 more not named here
disp_to_depth 18 other papers
4 dated earlier, 13 later, 1 same year, order not determinable
1806.01260 (2018-06)
Digging Into Self-Supervised Monocular Depth Estimation
1809.02627 (2018-09)
Unity: A General Platform for Intelligent Agents
1907.10326 (2019-07)
From Big to Small: Multi-Scale Local Planar Guidance for Monocular Depth Estimation
and 15 more not named here
batch_post_process_disparity 17 other papers
7 dated earlier, 10 later
1806.01260 (2018-06)
Digging Into Self-Supervised Monocular Depth Estimation
1909.09051 (2019-09)
Self-Supervised Monocular Depth Hints
2003.13951 (2020-03)
Self-supervised Monocular Trained Depth Estimation using Self-attention and Discrete Disparity Volume
and 14 more not named here
transformation_from_parameters 17 other papers
4 dated earlier, 12 later, 1 same year, order not determinable
1809.02627 (2018-09)
Unity: A General Platform for Intelligent Agents
1907.10326 (2019-07)
From Big to Small: Multi-Scale Local Planar Guidance for Monocular Depth Estimation
2008.01484 (2020-08)
Learning Stereo from Single Images
and 14 more not named here
get_translation_matrix 14 other papers
4 dated earlier, 9 later, 1 same year, order not determinable
1809.02627 (2018-09)
Unity: A General Platform for Intelligent Agents
1907.10326 (2019-07)
From Big to Small: Multi-Scale Local Planar Guidance for Monocular Depth Estimation
2008.01484 (2020-08)
Learning Stereo from Single Images
and 11 more not named here
filter_mask 1 other paper
1 dated earlier
1906.06310 (2019-06)
Pseudo-LiDAR++: Accurate Depth for 3D Object Detection in Autonomous Driving
filter_theta_mask 1 other paper
1 dated earlier
1906.06310 (2019-06)
Pseudo-LiDAR++: Accurate Depth for 3D Object Detection in Autonomous Driving
subsample_mask_by_grid 1 other paper
1 dated earlier
1906.06310 (2019-06)
Pseudo-LiDAR++: Accurate Depth for 3D Object Detection in Autonomous Driving

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

Self-supervised monocular depth prediction provides a cost-effective solution to obtain the 3D location of each pixel. However, the existing approaches usually lead to unsatisfactory accuracy, which is critical for autonomous robots. In this paper, we propose FusionDepth, a novel two-stage network to advance the self-supervised monocular dense depth learning by leveraging low-cost sparse (e.g. 4-beam) LiDAR. Unlike the existing methods that use sparse LiDAR mainly in a manner of time-consuming iterative post-processing, our model fuses monocular image features and sparse LiDAR features to predict initial depth maps. Then, an efficient feed-forward refine network is further designed to correct the errors in these initial depth maps in pseudo-3D space with real-time performance. Extensive experiments show that our proposed model significantly outperforms all the state-of-the-art self-supervised methods, as well as the sparse-LiDAR-based methods on both self-supervised monocular depth prediction and completion tasks. With the accurate dense depth prediction, our model outperforms the state-of-the-art sparse-LiDAR-based method (Pseudo-LiDAR++) by more than 68% for the downstream task monocular 3D object detection on the KITTI Leaderboard. Code is available at https://github.com/AutoAILab/FusionDepth

For agents

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

get_harvested_code_for_paper("2109.09628")
get_code_for_paper("2109.09628")
have("2109.09628")

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

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

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

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

Connect an agent — have() is free.