Datasets:
File size: 6,105 Bytes
d9596c0 d6e1abc d9596c0 d6e1abc d9596c0 d6e1abc d9596c0 d6e1abc d9596c0 d6e1abc d9596c0 d6e1abc d9596c0 d6e1abc d9596c0 d6e1abc d9596c0 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 | """
Visualize 6D pose annotations by projecting local frame axes onto RGB images.
Coordinate conventions
----------------------
- All matrices are **row-major** (Isaac Sim / USD convention).
Transforms are applied as: p_out = p_in @ M (row vector on the left)
- World / object space uses a **right-handed, Y-up** frame (OpenGL convention).
+X : right
+Y : up
-Z : into the scene (camera looks toward -Z in camera space)
- Camera space also follows **OpenGL**:
+X : right, +Y : up, -Z : into the scene
- Screen space follows **OpenCV / image** convention:
+u : right, +v : down, origin at top-left
Conversion from OpenGL camera space -> OpenCV screen space:
x_cv = x_gl
y_cv = -y_gl (flip Y)
z_cv = -z_gl (flip Z; positive depth is in front)
Expects a single-sample JSON shaped like one row of a Straw6D metadata.jsonl,
wrapped as {"camera_data": {...}, "objects": [{...}, ...]}:
camera_data.camera_view_matrix (4x4, row-major) : world -> camera
camera_data.intrinsics : {fx, fy, cx, cy} in pixels
camera_data.resolution : [width, height]
objects[i].local_to_world_transform (4x4, row-major) : object-local -> world
objects[i].size_local : [x, y, z] in meters
objects[i].center_local : [x, y, z], object-local frame origin
"""
import json
import numpy as np
from PIL import Image, ImageDraw
import argparse
def project_world_point_to_screen(world_point, view_matrix, intrinsics):
"""Project a homogeneous world-space point to pixel coordinates.
Uses row-major convention: cam = world_point @ view_matrix.
Converts OpenGL camera space (y-up, -z forward) to OpenCV screen space (y-down, +z forward).
Returns None if the point is behind the camera (z_cv <= 0).
"""
p = np.array([*world_point[:3], 1.0]) if len(world_point) == 3 else np.array(world_point)
cam = p @ view_matrix # row-major: point on the left
x, y, z = cam[0], -cam[1], -cam[2] # OpenGL -> OpenCV axis flip
if z <= 0:
return None
u = intrinsics['fx'] * x / z + intrinsics['cx']
v = intrinsics['fy'] * y / z + intrinsics['cy']
return round(u), round(v)
def draw_local_frame_axes(draw, local_to_world_transform, camera_view_matrix, intrinsics, size_local, origin_local, axes_length_perc=1.5):
"""Draw X/Y/Z axes of the object's local frame onto the image.
Axis length is scaled by the mean object size * axes_length_perc.
Pipeline: local -> world (@ L), world -> screen (project_world_point_to_screen).
"""
L = np.array(local_to_world_transform) # row-major local->world (4x4)
V = np.array(camera_view_matrix) # row-major world->camera (4x4)
ax_len = np.mean(size_local) * axes_length_perc
ox, oy, oz = origin_local
points_local = {
'origin': [ox, oy, oz, 1],
'x': [ox + ax_len, oy, oz, 1],
'y': [ox, oy + ax_len, oz, 1],
'z': [ox, oy, oz + ax_len, 1],
}
pts2d = {k: project_world_point_to_screen(np.array(v) @ L, V, intrinsics)
for k, v in points_local.items()}
o = pts2d['origin']
for key, color in [('x', 'red'), ('y', 'green'), ('z', 'blue')]:
if o is not None and pts2d[key] is not None:
draw.line([o, pts2d[key]], fill=color, width=5)
def draw_world_frame_axes_bottom_left(draw, camera_view_matrix, intrinsics, screen_size, axes_scale=0.1, margin_percentage=0.05):
"""Draw world-frame X/Y/Z axes in the bottom-left corner as a reference gizmo.
Places a virtual origin 1 unit in front of the camera (OpenGL: z=-1 in camera space),
converts it to world space via the inverse view matrix, then re-projects to screen.
The axes are offset so they appear anchored to the bottom-left corner.
"""
V = np.array(camera_view_matrix)
V_inv = np.linalg.inv(V)
# z=-1 in OpenGL camera space = 1 unit in front of the camera
origin_world = np.array([0, 0, -1.0, 1]) @ V_inv # camera -> world
pts2d = {}
pts2d['origin'] = project_world_point_to_screen(origin_world, V, intrinsics)
for key, delta in [('x', [axes_scale, 0, 0, 0]), ('y', [0, axes_scale, 0, 0]), ('z', [0, 0, axes_scale, 0])]:
pts2d[key] = project_world_point_to_screen(origin_world + np.array(delta), V, intrinsics)
if any(v is None for v in pts2d.values()):
return
# Shift projected axes to bottom-left corner
margin = int(margin_percentage * min(screen_size))
all_x = [pts2d[k][0] for k in pts2d]
all_y = [pts2d[k][1] for k in pts2d]
ox = margin - min(all_x)
oy = screen_size[1] - margin - max(all_y)
o = (pts2d['origin'][0] + ox, pts2d['origin'][1] + oy)
for key, color in [('x', 'red'), ('y', 'green'), ('z', 'blue')]:
end = (pts2d[key][0] + ox, pts2d[key][1] + oy)
draw.line([o, end], fill=color, width=3)
def main(image_path, json_path, output_path):
rgb_img = Image.open(image_path)
draw = ImageDraw.Draw(rgb_img)
with open(json_path, 'r') as f:
data = json.load(f)
camera_data = data["camera_data"]
V = camera_data["camera_view_matrix"] # row-major world->camera (4x4)
intrinsics = camera_data["intrinsics"] # {fx, fy, cx, cy} in pixels
screen_size = tuple(camera_data["resolution"]) # (width, height)
for obj in data["objects"]:
draw_local_frame_axes(draw, obj["local_to_world_transform"], V, intrinsics,
obj["size_local"], obj["center_local"])
draw_world_frame_axes_bottom_left(draw, V, intrinsics, screen_size)
rgb_img.save(output_path)
print(f"Overlay image saved to: {output_path}")
if __name__ == "__main__":
parser = argparse.ArgumentParser()
parser.add_argument("--image", type=str, required=True)
parser.add_argument("--json", type=str, required=True)
parser.add_argument("--output", type=str, required=True)
args = parser.parse_args()
main(args.image, args.json, args.output)
|