| clean_segmentation |
Ran ran on a synthesized input |
oppo-us-research/planemvs/data_preparation/clean_seg.py code served (permissive licence) · get_code("c511045350c22381") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple, ndim 1, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import numpy as np
import cv2
# Set seed for reproducibility
np.random.seed(0)
# Image: (h, w, 3) RGB image
h, w = 480, 640
image = np.random.randint(30, 255, size=(h, w, 3)).astype(np.float32)
# Grids: (3, h, w) - coordinate grids for x, y, 1
grids = np.ones((3, h, w), dtype=np.float32)
grids[0] = np.tile(np.arange(w, dtype=np.float32), (h, 1))
grids[1] = np.tile(np.arange(h, dtype=np.float32)[:, None], (1, w))
# Planes: (num_planes, 4) - plane parameters [nx, ny, nz, d]
# Each plane is defined by normal (nx, ny, nz) and offset d
num_planes = 3
planes = np.array([
[0.1, 0.2, 0.9, 5.0],
[0.05, 0.15, 0.95, 6.0],
[0.2, 0.1, 0.85, 4.0]
], dtype=np.float32)
# Masks: (num_planes, h, w) - binary masks for each plane
masks = np.zeros((num_planes, h, w), dtype=np.float32)
masks[0, 50:150, 100:300] = 1.0
masks[1, 200:350, 200:450] = 1.0
masks[2, 100:250, 350:550] = 1.0
# Plane IDs: (num_planes,) - unique identifiers for planes
plane_ids = np.array([1, 2, 3], dtype=np.int32)
# Ground truth depth: (h, w) - depth map
gt_depth = np.random.uniform(0.5, 10.0, size=(h, w)).astype(np.float32)
gt_depth[:30, :] = 0.0 # Mark some areas as invalid
ARGS = {
'image': image,
'grids': grids,
'planes': planes,
'masks': masks,
'plane_ids': plane_ids,
'gt_depth': gt_depth,
'planeAreaThreshold': 200,
'planeWidthThreshold': 10,
'depthDiffThreshold': 0.1,
'validAreaThreshold': 0.5,
'brightThreshold': 20
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- cv2, numpy — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type tuple, ndim 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
|
| cluster |
Ran ran on a synthesized input |
oppo-us-research/planemvs/data_preparation/cluster.py code served (permissive licence) · get_code("e69c3883b85c1033") How it ranRan 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 (2, 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 torch
from sklearn.cluster import KMeans
torch.manual_seed(0)
# The function expects:
# - camera_planes: array-like with shape (N, 3+) where first 3 columns are normals
# - cluster_anchor_num: int specifying number of clusters
# Create a small numpy array of camera planes
# Shape: (batch_size=4, features=4) where first 3 are normals
camera_planes = np.array([
[0.1, 0.2, 0.3, 1.0],
[0.4, 0.5, 0.6, 2.0],
[0.7, 0.8, 0.9, 3.0],
[0.2, 0.3, 0.4, 4.0],
], dtype=np.float32)
ARGS = {
"camera_planes": camera_planes,
"cluster_anchor_num": 2
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, sklearn, torch — 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 (2, 3) — shape (2, 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_all_7scenes_path |
Ran ran on a synthesized input |
oppo-us-research/planemvs/data_preparation/generate_7scenes_data.py code served (permissive licence) · get_code("e389daf1368730ee") How it ranRan 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 os
import tempfile
import shutil
# Create a minimal mock directory structure for the 7scenes dataset
temp_dir = tempfile.mkdtemp()
# Create directory structure with some color.png files
scenes_seqs = [
('chess', 'seq-01'),
('chess', 'seq-02'),
('chess', 'seq-04'),
('fire', 'seq-01'),
('office', 'seq-01'),
('office', 'seq-03'),
('pumpkin', 'seq-02'),
('stairs', 'seq-02'),
('stairs', 'seq-05'),
]
for scene, seq in scenes_seqs:
scene_dir = os.path.join(temp_dir, scene, seq)
os.makedirs(scene_dir, exist_ok=True)
# Create dummy color.png files
for i in range(2):
color_file = os.path.join(scene_dir, f'frame_{i:05d}_color.png')
with open(color_file, 'w') as f:
f.write('dummy')
# Also add a test sequence that's not in train_seqs
test_scene_dir = os.path.join(temp_dir, 'chess', 'seq-03')
os.makedirs(test_scene_dir, exist_ok=True)
test_color_file = os.path.join(test_scene_dir, 'frame_00000_color.png')
with open(test_color_file, 'w') as f:
f.write('dummy')
ARGS = {
'data_root': temp_dir,
'sample': -1,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- tqdm — 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_all_tum_path |
Ran ran on a synthesized input |
oppo-us-research/planemvs/data_preparation/generate_tum_data.py code served (permissive licence) · get_code("9729d599ce2b3570") How it ranRan 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 os
import tempfile
import numpy as np
# Create a temporary directory structure that mimics TUM dataset layout
tmpdir = tempfile.mkdtemp()
# Create scene directories and files
scene_exts = ['freiburg1_desk', 'freiburg1_room', 'freiburg1_desk2', 'freiburg2_desk', 'freiburg3_long_office_household', 'freiburg3_long_office_household_validation']
for scene_ext in scene_exts:
scene_name = 'rgbd_dataset_' + scene_ext
scene_path = os.path.join(tmpdir, scene_name)
os.makedirs(scene_path, exist_ok=True)
# Create rgb directory and dummy png files
rgb_dir = os.path.join(scene_path, 'rgb')
os.makedirs(rgb_dir, exist_ok=True)
for i in range(3):
with open(os.path.join(rgb_dir, f'{i:010d}.png'), 'w') as f:
f.write('dummy')
# Create depth directory and dummy png files
depth_dir = os.path.join(scene_path, 'depth')
os.makedirs(depth_dir, exist_ok=True)
for i in range(3):
with open(os.path.join(depth_dir, f'{i:010d}.png'), 'w') as f:
f.write('dummy')
# Create rgb.txt with timestamps
rgb_txt_path = os.path.join(scene_path, 'rgb.txt')
rgb_timestamps = np.array([1.0, 2.0, 3.0])
np.savetxt(rgb_txt_path, rgb_timestamps)
# Create depth.txt with timestamps
depth_txt_path = os.path.join(scene_path, 'depth.txt')
depth_timestamps = np.array([1.1, 2.1, 3.1])
np.savetxt(depth_txt_path, depth_timestamps)
# Create groundtruth.txt with poses (timestamp + 7 values for position/quaternion)
gt_txt_path = os.path.join(scene_path, 'groundtruth.txt')
pose_data = np.column_stack([
np.array([1.0, 2.0, 3.0]), # timestamps
np.random.randn(3, 7) # 7 values per pose (3 position + 4 quaternion)
])
np.savetxt(gt_txt_path, pose_data)
ARGS = {
'data_root': tmpdir,
'sample': -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 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_grid |
Ran ran on a synthesized input |
oppo-us-research/planemvs/data_preparation/clean_seg.py code served (permissive licence) · get_code("a81a95d6d05862d4") How it ranRan 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 (3, 480, 640) 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
ARGS = {
"h": 480,
"w": 640,
}
- 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 (3, 480, 640) — shape (3, 480, 640) 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_rel_trans |
Ran ran on a synthesized input |
oppo-us-research/planemvs/data_preparation/generate_7scenes_data.py code served (permissive licence) · get_code("458c1ecc42ef30e6") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned float64, ndim 0, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import numpy as np
# Create two valid 4x4 homogeneous transformation matrices
# ref_pose: reference pose matrix
ref_pose = np.array([
[1.0, 0.0, 0.0, 1.5],
[0.0, 1.0, 0.0, 2.0],
[0.0, 0.0, 1.0, 0.5],
[0.0, 0.0, 0.0, 1.0]
], dtype=np.float64)
# src_pose: source pose matrix (must be invertible)
src_pose = np.array([
[1.0, 0.0, 0.0, 0.8],
[0.0, 1.0, 0.0, 1.2],
[0.0, 0.0, 1.0, 0.3],
[0.0, 0.0, 0.0, 1.0]
], dtype=np.float64)
ARGS = {
"ref_pose": ref_pose,
"src_pose": src_pose
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type float64, ndim 0, dtype family float — no output shape is stated: observe_signature.py recorded float ndim 0, which disagrees with the fixture run
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| kmeans_cluster |
Ran ran on a synthesized input |
oppo-us-research/planemvs/data_preparation/stereo_cluters.py code served (permissive licence) · get_code("0704f949c1a27579") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned ndarray, ndim 2, dtype family float, shape (3, 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
from sklearn.cluster import KMeans
torch.manual_seed(0)
# Create small sample vectors for clustering
# Using shape (6, 4) - 6 samples, 4 dimensions
vectors = np.random.randn(6, 4).astype(np.float32)
# Number of clusters to find
cluster_anchor_num = 3
ARGS = {
"vectors": vectors,
"cluster_anchor_num": cluster_anchor_num,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, sklearn, torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type ndarray, ndim 2, dtype family float, shape (3, 4) — shape (3, 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_color |
Ran ran on a synthesized input |
oppo-us-research/planemvs/data_preparation/generate_pixel_planar.py code served (permissive licence) · get_code("2015b55a787e9714") How it ranRan 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 (480, 640, 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 cv2
import numpy as np
import tempfile
import os
# Create a temporary directory and a dummy image file
temp_dir = tempfile.mkdtemp()
color_path = os.path.join(temp_dir, "test_image.jpg")
# Create a small dummy image (100x100 RGB)
dummy_image = np.random.randint(0, 256, (100, 100, 3), dtype=np.uint8)
cv2.imwrite(color_path, dummy_image)
ARGS = {
"color_path": color_path,
"h": 480,
"w": 640,
}
- 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 (480, 640, 3) — shape (480, 640, 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
|
| load_depth |
Ran ran on a synthesized input |
oppo-us-research/planemvs/data_preparation/generate_pixel_planar.py code served (permissive licence) · get_code("5a25f72413bb176b") How it ranRan 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 (480, 640) 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 cv2
import numpy as np
import tempfile
import os
# Create a temporary depth image file
temp_dir = tempfile.mkdtemp()
depth_path = os.path.join(temp_dir, "depth.png")
# Create a small depth image (16-bit grayscale) and save it
depth_image = np.random.randint(0, 65535, size=(480, 640), dtype=np.uint16)
cv2.imwrite(depth_path, depth_image)
ARGS = {
"depth_path": depth_path,
"divisor": 1000.0,
"h": 480,
"w": 640,
}
- 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 2, dtype family float, shape (480, 640) — shape (480, 640) 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_image |
Ran ran on a synthesized input |
oppo-us-research/planemvs/data_preparation/pre_process.py code served (permissive licence) · get_code("fafa963ecd5d41cf") How it ranRan 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 (480, 640, 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 cv2
import numpy as np
import tempfile
import os
# Create a temporary image file for testing
temp_dir = tempfile.mkdtemp()
temp_image_path = os.path.join(temp_dir, "test_image.png")
# Create a simple test image (300x200 BGR image with some content)
test_image = np.random.randint(0, 256, (200, 300, 3), dtype=np.uint8)
cv2.imwrite(temp_image_path, test_image)
ARGS = {
"image_path": temp_image_path,
"resize": (640, 480)
}
- 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 (480, 640, 3) — shape (480, 640, 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
|
| load_intrinsic |
Ran ran on a synthesized input |
oppo-us-research/planemvs/data_preparation/generate_pixel_planar.py code served (permissive licence) · get_code("b2225dd1ab5fd8a7") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned ndarray, ndim 2, dtype family float, shape (3, 3) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import numpy as np
import tempfile
import os
# Create a temporary intrinsic matrix file
temp_dir = tempfile.mkdtemp()
intrinsic_path = os.path.join(temp_dir, "intrinsic.txt")
# Create a sample 4x4 intrinsic matrix (will be read as 3x3)
# Typical camera intrinsic matrix format
sample_intrinsic = np.array([
[1296.0, 0.0, 648.0, 0.0],
[0.0, 968.0, 484.0, 0.0],
[0.0, 0.0, 1.0, 0.0],
[0.0, 0.0, 0.0, 1.0]
])
np.savetxt(intrinsic_path, sample_intrinsic)
ARGS = {
"intrinsic_path": intrinsic_path,
"h": 480,
"w": 640,
"ori_h": 968,
"ori_w": 1296
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type ndarray, ndim 2, dtype family float, shape (3, 3) — shape (3, 3) as a later run recorded it
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| load_valid_ids |
Ran ran on a synthesized input |
oppo-us-research/planemvs/data_preparation/stereo_cluters.py code served (permissive licence) · get_code("21c717dcb6058d30") How it ranRan 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 int, shape (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 cv2
import numpy as np
import tempfile
import os
# Create a temporary segmentation image for testing
# The function uses cv2.imread to read the file, so we need a real file
temp_dir = tempfile.mkdtemp()
seg_path = os.path.join(temp_dir, "test_seg.png")
# Create a simple segmentation map with some valid IDs and the invalid ID 65535
seg_data = np.array([
[1, 2, 65535],
[3, 4, 65535],
[1, 2, 3]
], dtype=np.uint16)
# Write as PNG (cv2.imread with -1 flag reads all channels including alpha)
cv2.imwrite(seg_path, seg_data)
ARGS = {
"seg_path": seg_path
}
- 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 1, dtype family int, shape (4,) — shape (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
|
| plane_to_depth |
Ran ran on a synthesized input |
oppo-us-research/planemvs/data_preparation/clean_seg.py code served (permissive licence) · get_code("5ecc4b1ee40f1b3c") How it ranRan 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, 480, 640) 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)
# Analyze the function:
# - grids: reshaped to (3, -1), used in matrix multiplication with normals
# normals @ grids means normals is (plane_num, 3) and grids is (3, h*w)
# - planes: indexed with [:, -1] and [:, :3], so shape (plane_num, 4+)
# - masks: multiplied with piece_depths which has shape (plane_num, h, w)
# - h, w: default 480, 640; used to reshape piece_depths
h = 480
w = 640
plane_num = 2
# grids should be (3, h, w) initially, then reshaped to (3, h*w)
grids = torch.randn(3, h, w)
# planes should be (plane_num, 4+) where last column is offset and first 3 are normals
# Using shape (plane_num, 4) for minimal valid planes
planes = torch.randn(plane_num, 4)
# masks should be (plane_num, h, w) to multiply element-wise with piece_depths
masks = torch.ones(plane_num, h, w)
ARGS = {
'grids': grids,
'planes': planes,
'masks': masks,
'h': h,
'w': w
}
- 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 (2, 480, 640) — shape (2, 480, 640) 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
|
| read_files |
Ran ran on a synthesized input |
oppo-us-research/planemvs/data_preparation/split_tumrgbd.py code served (permissive licence) · get_code("0ec4eab464808505") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned list, ndim 1, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import tempfile
import os
# Create a temporary file with some test data
temp_file = tempfile.NamedTemporaryFile(mode='w', delete=False, suffix='.txt')
temp_file.write("line 1\n")
temp_file.write("line 2\n")
temp_file.write("line 3\n")
temp_file.close()
stereo_file_path = temp_file.name
ARGS = {
'stereo_file': stereo_file_path
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type list, ndim 1, dtype family float — a list output has no array shape of its own; none is stated
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| read_pose |
Ran ran on a synthesized input |
oppo-us-research/planemvs/data_preparation/generate_7scenes_data.py code served (permissive licence) · get_code("58c3e75c2c18326e") How it ranRan 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 (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 pose file with sample data
temp_dir = tempfile.mkdtemp()
pose_file = os.path.join(temp_dir, "pose.txt")
# Write sample pose data (e.g., a 4x3 matrix representing poses)
sample_pose_data = np.array([
[1.0, 0.0, 0.0, 5.0],
[0.0, 1.0, 0.0, 6.0],
[0.0, 0.0, 1.0, 7.0],
[0.0, 0.0, 0.0, 1.0]
])
np.savetxt(pose_file, sample_pose_data)
ARGS = {
"pose_path": pose_file
}
- 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 (4, 4) — shape (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
|
| read_rgb_mapping |
Ran ran on a synthesized input |
oppo-us-research/planemvs/data_preparation/generate_tum_data.py code served (permissive licence) · get_code("f6157f7dfc05252f") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple, ndim 2, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import os
import tempfile
import numpy as np
from pathlib import Path
# Create a temporary directory structure to simulate the data
temp_dir = tempfile.mkdtemp()
data_root = temp_dir
scene = "test_scene"
# Create the scene directory and subdirectories
scene_dir = os.path.join(data_root, scene)
os.makedirs(scene_dir, exist_ok=True)
rgb_dir = os.path.join(scene_dir, 'rgb')
os.makedirs(rgb_dir, exist_ok=True)
# Create a mock rgb.txt file with timestamps
rgb_txt_path = os.path.join(scene_dir, 'rgb.txt')
timestamps = np.array([1.0, 2.0, 3.0, 4.0])
np.savetxt(rgb_txt_path, timestamps)
# Create mock RGB image files
for i in range(4):
img_path = os.path.join(rgb_dir, f'frame_{i:06d}.png')
Path(img_path).touch()
ARGS = {
'data_root': data_root,
'scene': scene
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type tuple, ndim 2, dtype family float — a tuple output has no array shape of its own; none is stated
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| cluster_vis_3d_scatters |
Not yet run unverified (harvested, no recorded run) |
oppo-us-research/planemvs/data_preparation/stereo_cluters.py code served (permissive licence) · get_code("4f1c557276c4cff2") How it ran |
| load_pose |
Not yet run unverified (harvested, no recorded run) |
oppo-us-research/planemvs/data_preparation/pre_process.py code served (permissive licence) · get_code("85fd58a1c4771f86") How it ran |
| load_raw_seg |
Not yet run unverified (harvested, no recorded run) |
oppo-us-research/planemvs/data_preparation/pre_process.py code served (permissive licence) · get_code("95474bdf353f674f") How it ran |