SPBench — Gemma4-31B — sample MV_142

# Inspecting frames where the telephone is likely visible
show([InputImages[0], InputImages[4], InputImages[7]])

# Confirming the telephone's presence and location
confirmation = vlm.ask_with_thinking(InputImages[6:], "Is there a telephone in these images? If so, which frame shows it most clearly and where is it located (e.g., on the wall, on a table)?")
print(confirmation)

 [image: show_0001] 
[VLM Q | thinking] Is there a telephone in these images? If so, which frame shows it most clearly and where is it located (e.g., on the wall, on a table)?
[VLM A | thinking] Yes, there is a telephone. It is most clearly visible in frame 1, where it is located on the wall.
Yes, there is a telephone. It is most clearly visible in frame 1, where it is located on the wall.

# 1. Perform 3D reconstruction
recon = tools.Reconstruct.Reconstruct(InputImages)

# 2. Segment the telephone in the best frame (InputImages[7])
# Using text-based segmentation first
best_frame = InputImages[7]
seg = tools.SAM3.segment_image_by_text(best_frame, "telephone")

# 3. Programmatic check of the mask
fi = seg.frame_indices[0]
for i, label in enumerate(seg.labels):
    mask = seg.get_mask(frame=fi, object=i)
    area = mask.sum()
    print(f"Object {i} ({label}) area: {area} pixels")

# Visual verification
vis = seg.visualize(fi)
show([best_frame, vis])

Object 0 (telephone) area: 3150 pixels
 [image: show_0002] 

import numpy as np
from scipy.spatial.distance import pdist

# 1. Get the mask and the local index of the frame
fi = seg.frame_indices[0]
local_idx = recon.frame_indices.index(fi)
mask = seg.get_mask(frame=fi, object=0)

# 2. Extract 3D points and confidence for the frame
points_all = recon.points[fi]  # (H, W, 3)
conf_all = recon.points.confidence[local_idx]  # (H, W)

# 3. Filter points by mask and confidence
# Use a confidence threshold to remove noise (e.g., 0.5)
valid_mask = mask & (conf_all > 0.5)
points_filtered = points_all[valid_mask]

print(f"Number of filtered points: {len(points_filtered)}")

if len(points_filtered) < 2:
    # Fallback: use all points in the mask if confidence filter is too aggressive
    points_filtered = points_all[mask]
    print(f"Fallback: using all masked points. Count: {len(points_filtered)}")

# 4. Compute the maximum distance between any two points (Diameter)
if len(points_filtered) > 0:
    # pdist computes pairwise distances between observations in n-dimensional space.
    # For 3150 points, pdist is efficient.
    distances = pdist(points_filtered)
    max_dist_m = np.max(distances)
    max_dist_cm = max_dist_m * 100
    print(f"Longest dimension: {max_dist_m:.4f} m = {max_dist_cm:.2f} cm")
else:
    max_dist_cm = None
    print("No points found for the telephone.")

# Sanity check: A typical wall phone handset is 20-30cm.
# If the result is wildly different, I'll investigate.

Number of filtered points: 3150
Longest dimension: 1.1690 m = 116.90 cm

# 1. Parse the bounding box from the previous VLM response
# handset_box_norm = '567 10 630 165'
box_coords = [int(x) for x in handset_box_norm.split()]
px1, py1, px2, py2 = tools.Geometry.normalized_to_pixel(box_coords, W, H)
print(f"Pixel box: {px1, py1, px2, py2}")

# 2. Segment the handset using the box
seg_handset = tools.SAM3.segment_image_by_box(InputImages[7], [px1, py1, px2, py2], "handset")

# 3. Verify the mask
fi_h = seg_handset.frame_indices[0]
vis_h = seg_handset.visualize(fi_h)
show([InputImages[7], vis_h])

# 4. Calculate the longest dimension of the handset
local_idx_h = recon.frame_indices.index(fi_h)
mask_h = seg_handset.get_mask(frame=fi_h, object=0)
points_all_h = recon.points[fi_h]
conf_all_h = recon.points.confidence[local_idx_h]

# Filter by mask and confidence
valid_mask_h = mask_h & (conf_all_h > 0.5)
points_filtered_h = points_all_h[valid_mask_h]

if len(points_filtered_h) < 2:
    points_filtered_h = points_all_h[mask_h]

if len(points_filtered_h) > 1:
    distances_h = pdist(points_filtered_h)
    max_dist_m_h = np.max(distances_h)
    max_dist_cm_h = max_dist_m_h * 100
    print(f"Refined longest dimension: {max_dist_m_h:.4f} m = {max_dist_cm_h:.2f} cm")
else:
    max_dist_cm_h = None
    print("Insufficient points found for the handset.")

Pixel box: (435.45599999999996, 5.76, 483.84000000000003, 95.04)
 [image: show_0003] 
Refined longest dimension: 1.1544 m = 115.44 cm

# 1. Segment the dresser in InputImages[7]
seg_dresser = tools.SAM3.segment_image_by_text(InputImages[7], "dresser")

# 2. Verify dresser mask
fi_d = seg_dresser.frame_indices[0]
vis_d = seg_dresser.visualize(fi_d)
show([InputImages[7], vis_d])

# 3. Calculate dresser height
local_idx_d = recon.frame_indices.index(fi_d)
mask_d = seg_dresser.get_mask(frame=fi_d, object=0)
points_all_d = recon.points[fi_d]
conf_all_d = recon.points.confidence[local_idx_d]

valid_mask_d = mask_d & (conf_all_d > 0.5)
points_filtered_d = points_all_d[valid_mask_d]

if len(points_filtered_d) > 1:
    # Height is the difference between max and min Y (since +Y is up)
    y_coords = points_filtered_d[:, 1]
    dresser_height_m = np.max(y_coords) - np.min(y_coords)
    dresser_height_cm = dresser_height_m * 100
    print(f"Dresser height: {dresser_height_m:.4f} m = {dresser_height_cm:.2f} cm")
else:
    dresser_height_cm = None
    print("Insufficient points for dresser.")

 [image: show_0004] 
Dresser height: 1.0015 m = 100.15 cm

# 1. Get bounding boxes for both objects in InputImages[7]
dresser_box_norm = vlm.locate(InputImages[7], "Give the bounding box (x1, y1, x2, y2) in 0-1000 normalized scale for the dresser. Reply with ONLY the numbers.")
handset_box_norm = vlm.locate(InputImages[7], "Give the bounding box (x1, y1, x2, y2) in 0-1000 normalized scale for the telephone handset (the part you hold to your ear). Reply with ONLY the numbers.")

print(f"Dresser box (norm): {dresser_box_norm}")
print(f"Handset box (norm): {handset_box_norm}")

# 2. Convert to pixel heights
W, H = InputImages[7].width, InputImages[7].height

def get_pixel_height(norm_box_str):
    coords = [int(x) for x in norm_box_str.split()]
    # normalized_to_pixel returns [x1, y1, x2, y2]
    px_coords = tools.Geometry.normalized_to_pixel(coords, W, H)
    return abs(px_coords[3] - px_coords[1]) # y2 - y1

dresser_px_h = get_pixel_height(dresser_box_norm)
handset_px_h = get_pixel_height(handset_box_norm)

print(f"Dresser pixel height: {dresser_px_h}")
print(f"Handset pixel height: {handset_px_h}")

# 3. Calculate real length using the ratio
# Dresser real height was measured as 100.15 cm
dresser_real_h = 100.15
handset_real_h = (handset_px_h / dresser_px_h) * dresser_real_h

print(f"Estimated handset length: {handset_real_h:.2f} cm")

# Final Answer based on this calculation
ReturnAnswer(round(handset_real_h))

[VLM Q | locate] Before answering, first check whether what the question describes is clearly visible in the provided image(s). If it is absent or ambiguous, reply EXACTLY `Not visible` on its own line (optionally followed by one short line explaining what you saw instead) — do NOT return coordinates in that case. Only if the requested target is clearly and unambiguously present, answer the request below.

Request: Give the bounding box (x1, y1, x2, y2) in 0-1000 normalized scale for the dresser. Reply with ONLY the numbers.
[VLM A | locate] 366 340 886 1000
[VLM Q | locate] Before answering, first check whether what the question describes is clearly visible in the provided image(s). If it is absent or ambiguous, reply EXACTLY `Not visible` on its own line (optionally followed by one short line explaining what you saw instead) — do NOT return coordinates in that case. Only if the requested target is clearly and unambiguously present, answer the request below.

Request: Give the bounding box (x1, y1, x2, y2) in 0-1000 normalized scale for the telephone handset (the part you hold to your ear). Reply with ONLY the numbers.
[VLM A | locate] 566 11 631 341
Dresser box (norm): 366 340 886 1000
Handset box (norm): 566 11 631 341
Dresser pixel height: 380.15999999999997
Handset pixel height: 190.08
Estimated handset length: 50.08 cm
[ReturnAnswer] Answer submitted: 50