Spaces:
Runtime error
Runtime error
| # some tools developed for the vision class | |
| import numpy as np | |
| from numpy import cross, tan | |
| from numpy.linalg import norm, inv | |
| def normalize(v): | |
| return v / norm(v) | |
| def camera_pose(eye, front, up): | |
| z = normalize(-1 * front) | |
| x = normalize(cross(up, z)) | |
| y = normalize(cross(z, x)) | |
| # convert to col vector | |
| x = x.reshape(-1, 1) | |
| y = y.reshape(-1, 1) | |
| z = z.reshape(-1, 1) | |
| eye = eye.reshape(-1, 1) | |
| pose = np.block([ | |
| [x, y, z, eye], | |
| [0, 0, 0, 1] | |
| ]) | |
| return pose | |
| def compute_extrinsics(eye, front, up): | |
| pose = camera_pose(eye, front, up) | |
| world_2_cam = inv(pose) | |
| return world_2_cam | |
| def compute_intrinsics(aspect_ratio, fov, img_height_in_pix): | |
| # aspect ratio is w / h | |
| ndc = compute_proj_to_normalized(aspect_ratio, fov) | |
| # anything beyond [-1, 1] should be discarded | |
| # this did not mention how to do z-clipping; | |
| ndc_to_img = compute_normalized_to_img_trans(aspect_ratio, img_height_in_pix) | |
| intrinsic = ndc_to_img @ ndc | |
| return intrinsic | |
| def compute_proj_to_normalized(aspect, fov): | |
| # compared to standard OpenGL NDC intrinsic, | |
| # this skips the 3rd row treatment on z. hence the name partial_ndc | |
| fov_in_rad = fov / 180 * np.pi | |
| t = tan(fov_in_rad / 2) # tan half fov | |
| partial_ndc_intrinsic = np.array([ | |
| [1 / (t * aspect), 0, 0, 0], | |
| [0, 1 / t, 0, 0], | |
| [0, 0, -1, 0] # copy the negative distance for division | |
| ]) | |
| return partial_ndc_intrinsic | |
| def compute_normalized_to_img_trans(aspect, img_height_in_pix): | |
| img_h = img_height_in_pix | |
| img_w = img_height_in_pix * aspect | |
| # note the OpenGL convention that (0, 0) sits at the center of the pixel; | |
| # hence the extra -0.5 translation | |
| # this is useful when you shoot rays through a pixel to the scene | |
| ndc_to_img = np.array([ | |
| [img_w / 2, 0, img_w / 2 - 0.5], | |
| [0, img_h / 2, img_h / 2 - 0.5], | |
| [0, 0, 1] | |
| ]) | |
| img_y_coord_flip = np.array([ | |
| [1, 0, 0], | |
| [0, -1, img_h - 1], # note the -1 | |
| [0, 0, 1] | |
| ]) | |
| # the product of the above 2 matrices is equivalent to adding | |
| # - sign to the (1, 1) entry | |
| # you could have simply written | |
| # ndc_to_img = np.array([ | |
| # [img_w / 2, 0, img_w / 2 - 0.5], | |
| # [0, -img_h / 2, img_h / 2 - 0.5], | |
| # [0, 0, 1] | |
| # ]) | |
| ndc_to_img = img_y_coord_flip @ ndc_to_img | |
| return ndc_to_img | |
| def unproject(K, pixel_coords, depth=1.0): | |
| """sometimes also referred to as backproject | |
| pixel_coords: [n, 2] pixel locations | |
| depth: [n,] or [,] depth value. of a shape that is broadcastable with pix coords | |
| """ | |
| K = K[0:3, 0:3] | |
| pixel_coords = as_homogeneous(pixel_coords) | |
| pixel_coords = pixel_coords.T # [2+1, n], so that mat mult is on the left | |
| # this will give points with z = -1, which is exactly what you want since | |
| # your camera is facing the -ve z axis | |
| pts = inv(K) @ pixel_coords | |
| pts = pts * depth # [3, n] * [n,] broadcast | |
| pts = pts.T | |
| pts = as_homogeneous(pts) | |
| return pts | |
| """ | |
| these two functions are changed so that they can handle arbitrary number of | |
| dimensions >=1 | |
| """ | |
| def homogenize(pts): | |
| # pts: [..., d], where last dim of the d is the diviser | |
| *front, d = pts.shape | |
| pts = pts / pts[..., -1].reshape(*front, 1) | |
| return pts | |
| def as_homogeneous(pts, lib=np): | |
| # pts: [..., d] | |
| *front, d = pts.shape | |
| points = lib.ones((*front, d + 1)) | |
| points[..., :d] = pts | |
| return points | |
| def simple_point_render(pts, img_w, img_h, fov, eye, front, up): | |
| """ | |
| pts: [N, 3] | |
| """ | |
| canvas = np.ones((img_h, img_w, 3)) | |
| pts = as_homogeneous(pts) | |
| E = compute_extrinsics(eye, front, up) | |
| world_2_ndc = compute_proj_to_normalized(img_w / img_h, fov) | |
| ndc_to_img = compute_normalized_to_img_trans(img_w / img_h, img_h) | |
| pts = pts @ E.T | |
| pts = pts @ world_2_ndc.T | |
| pts = homogenize(pts) | |
| # now filter out outliers beyond [-1, 1] | |
| outlier_mask = (np.abs(pts) > 1.0).any(axis=1) | |
| pts = pts[~outlier_mask] | |
| pts = pts @ ndc_to_img.T | |
| # now draw each point | |
| pts = np.rint(pts).astype(np.int32) | |
| xs, ys, _ = pts.T | |
| canvas[ys, xs] = (1, 0, 0) | |
| return canvas | |