From 782b2ef54c7681b9ef255329f9377e9561852d07 Mon Sep 17 00:00:00 2001 From: builder Date: Tue, 6 Aug 2024 15:31:19 +0000 Subject: [PATCH] Nail down transformation matrix convention This commit modifies variable names of transformation matrices. The naming is based on the convention explained at: https://support.zivid.com/en/latest/reference-articles/position-orientation-coordinate-transform.html --- .../get_checkerboard_pose_from_zdf.py | 10 ++--- .../robodk_hand_eye_calibration.py | 8 ++-- ...sal_robots_perform_hand_eye_calibration.py | 8 ++-- .../utilize_hand_eye_calibration.py | 12 ++--- .../applications/advanced/reproject_points.py | 24 +++++----- .../robot_guidance/robodk_robot_guidance.py | 44 +++++++++---------- .../advanced/roi_box_via_aruco_marker.py | 6 +-- .../advanced/roi_box_via_checkerboard.py | 6 +-- .../transform_point_cloud_via_checkerboard.py | 16 +++---- .../robodk_verify_hand_eye_calibration.py | 38 ++++++++-------- source/applications/point_cloud_tutorial.md | 2 +- source/sample_utils/save_load_matrix.py | 4 +- 12 files changed, 89 insertions(+), 89 deletions(-) diff --git a/source/applications/advanced/get_checkerboard_pose_from_zdf.py b/source/applications/advanced/get_checkerboard_pose_from_zdf.py index 67c4a44d..f979d6e5 100644 --- a/source/applications/advanced/get_checkerboard_pose_from_zdf.py +++ b/source/applications/advanced/get_checkerboard_pose_from_zdf.py @@ -50,7 +50,7 @@ def _visualize_checkerboard_point_cloud_with_coordinate_system( Args: point_cloud_open3d: An Open3d point cloud of a checkerboard - transform: Transformation matrix + transform: Transformation matrix (4x4) """ coord_system_mesh = o3d.geometry.TriangleMesh.create_coordinate_frame(size=30) @@ -72,18 +72,18 @@ def _main() -> None: point_cloud = frame.point_cloud() print("Detecting checkerboard and estimating its pose in camera frame") - transform_camera_to_checkerboard = zivid.calibration.detect_calibration_board(frame).pose().to_matrix() - print(f"Camera pose in checkerboard frame:\n{transform_camera_to_checkerboard}") + camera_to_checkerboard_transform = zivid.calibration.detect_calibration_board(frame).pose().to_matrix() + print(f"Camera pose in checkerboard frame:\n{camera_to_checkerboard_transform}") transform_file_name = "CameraToCheckerboardTransform.yaml" print(f"Saving detected checkerboard pose to YAML file: {transform_file_name}") transform_file_path = Path(__file__).parent / transform_file_name - assert_affine_matrix_and_save(transform_camera_to_checkerboard, transform_file_path) + assert_affine_matrix_and_save(camera_to_checkerboard_transform, transform_file_path) print("Visualizing checkerboard with coordinate system") checkerboard_point_cloud = _create_open3d_point_cloud(point_cloud) _visualize_checkerboard_point_cloud_with_coordinate_system( - checkerboard_point_cloud, transform_camera_to_checkerboard + checkerboard_point_cloud, camera_to_checkerboard_transform ) diff --git a/source/applications/advanced/hand_eye_calibration/robodk_hand_eye_calibration/robodk_hand_eye_calibration.py b/source/applications/advanced/hand_eye_calibration/robodk_hand_eye_calibration/robodk_hand_eye_calibration.py index 60e416ba..45b3072c 100644 --- a/source/applications/advanced/hand_eye_calibration/robodk_hand_eye_calibration/robodk_hand_eye_calibration.py +++ b/source/applications/advanced/hand_eye_calibration/robodk_hand_eye_calibration/robodk_hand_eye_calibration.py @@ -57,7 +57,7 @@ def _get_frame_and_transform(robot: Item, camera: zivid.Camera) -> Tuple[zivid.F Returns: Zivid frame - 4x4 transformation matrix + Transformation matrix (4x4) """ frame = _assisted_capture(camera) @@ -77,7 +77,7 @@ def _save_point_cloud_and_pose( save_directory: Path to where data will be saved image_and_pose_iterator: Image number frame: Point cloud stored as ZDF - transform: 4x4 transformation matrix + transform: Transformation matrix (4x4) """ frame.save(save_directory / f"img{image_and_pose_iterator:02d}.zdf") @@ -143,7 +143,7 @@ def _save_hand_eye_results(save_directory: Path, transform: np.ndarray, residual Args: save_directory: Path to where data will be saved - transform: 4x4 transformation matrix + transform: Transformation matrix (4x4) residuals: List of residuals """ @@ -232,7 +232,7 @@ def perform_hand_eye_calibration( user_options: Input arguments Returns: - transform: 4x4 transformation matrix + transform: Transformation matrix (4x4) residuals: List of residuals Raises: diff --git a/source/applications/advanced/hand_eye_calibration/ur_hand_eye_calibration/universal_robots_perform_hand_eye_calibration.py b/source/applications/advanced/hand_eye_calibration/ur_hand_eye_calibration/universal_robots_perform_hand_eye_calibration.py index 6add2c60..4a3ea52e 100644 --- a/source/applications/advanced/hand_eye_calibration/ur_hand_eye_calibration/universal_robots_perform_hand_eye_calibration.py +++ b/source/applications/advanced/hand_eye_calibration/ur_hand_eye_calibration/universal_robots_perform_hand_eye_calibration.py @@ -127,7 +127,7 @@ def _save_zdf_and_pose(save_dir: Path, image_num: int, frame: zivid.Frame, trans save_dir: Directory to save data image_num: Image number frame: Point cloud stored as ZDF - transform: 4x4 transformation matrix + transform: Transformation matrix (4x4) """ frame.save(save_dir / f"img{image_num:02d}.zdf") @@ -164,7 +164,7 @@ def _get_frame_and_transform_matrix( Returns: frame: Zivid frame - transform: 4x4 transformation matrix + transform: Transformation matrix (4x4) """ frame = camera.capture(settings) @@ -222,7 +222,7 @@ def _save_hand_eye_results(save_dir: Path, transform: np.ndarray, residuals: Lis Args: save_dir: Path to where data will be saved - transform: 4x4 transformation matrix + transform: Transformation matrix (4x4) residuals: List of residuals """ @@ -392,7 +392,7 @@ def perform_hand_eye_calibration( data_dir: Path to dataset Returns: - transform: 4x4 transformation matrix + transform: Transformation matrix (4x4) residuals: List of residuals Raises: diff --git a/source/applications/advanced/hand_eye_calibration/utilize_hand_eye_calibration.py b/source/applications/advanced/hand_eye_calibration/utilize_hand_eye_calibration.py index 6ef85913..d7092c12 100644 --- a/source/applications/advanced/hand_eye_calibration/utilize_hand_eye_calibration.py +++ b/source/applications/advanced/hand_eye_calibration/utilize_hand_eye_calibration.py @@ -53,7 +53,7 @@ def _main() -> None: eye_to_hand_transform_file_path = get_sample_data_path() / "EyeToHandTransform.yaml" print("Reading camera pose in robot base reference frame (result of eye-to-hand calibration)") - transform_base_to_camera = load_and_assert_affine_matrix(eye_to_hand_transform_file_path) + base_to_camera_transform = load_and_assert_affine_matrix(eye_to_hand_transform_file_path) break @@ -71,13 +71,13 @@ def _main() -> None: print( "Reading camera pose in flange (end-effector) reference frame (result of eye-in-hand calibration)" ) - transform_flange_to_camera = load_and_assert_affine_matrix(eye_in_hand_transform_file_path) + flange_to_camera_transform = load_and_assert_affine_matrix(eye_in_hand_transform_file_path) print("Reading flange (end-effector) pose in robot base reference frame") - transform_base_to_flange = load_and_assert_affine_matrix(robot_transform_file_path) + base_to_flange_transform = load_and_assert_affine_matrix(robot_transform_file_path) print("Computing camera pose in robot base reference frame") - transform_base_to_camera = np.matmul(transform_base_to_flange, transform_flange_to_camera) + base_to_camera_transform = np.matmul(base_to_flange_transform, flange_to_camera_transform) break @@ -107,7 +107,7 @@ def _main() -> None: print(f"Point coordinates in camera reference frame: {point_in_camera_frame[0:3]}") print("Transforming (picking) point from camera to robot base reference frame") - point_in_base_frame = np.matmul(transform_base_to_camera, point_in_camera_frame) + point_in_base_frame = np.matmul(base_to_camera_transform, point_in_camera_frame) print(f"Point coordinates in robot base reference frame: {point_in_base_frame[0:3]}") @@ -116,7 +116,7 @@ def _main() -> None: if command.lower() == "p": print("Transforming point cloud") - point_cloud.transform(transform_base_to_camera) + point_cloud.transform(base_to_camera_transform) save_file = "ZividGemTransformed.zdf" print(f"Saving point cloud to file: {save_file}") diff --git a/source/applications/advanced/reproject_points.py b/source/applications/advanced/reproject_points.py index 21e19249..35895e73 100644 --- a/source/applications/advanced/reproject_points.py +++ b/source/applications/advanced/reproject_points.py @@ -36,23 +36,23 @@ def _checkerboard_grid() -> List[np.ndarray]: return list(points) -def _transform_grid_to_calibration_board( - grid: List[np.ndarray], transform_camera_to_checkerboard: np.ndarray +def _transform_grid_to_camera_frame( + grid: List[np.ndarray], camera_to_checkerboard_transform: np.ndarray ) -> List[np.ndarray]: """Transform a list of grid points to the camera frame. Args: grid: List of 4D points (X,Y,Z,W) for each corner in the checkerboard, in the checkerboard frame - transform_camera_to_checkerboard: 4x4 transformation matrix + camera_to_checkerboard_transform: 4x4 transformation matrix Returns: List of 3D grid points in the camera frame """ points_in_camera_frame = [] - for point in grid: - transformed_point = transform_camera_to_checkerboard @ point - points_in_camera_frame.append(transformed_point[:3]) + for point_in_checkerboard_frame in grid: + point_in_camera_frame = camera_to_checkerboard_transform @ point_in_checkerboard_frame + points_in_camera_frame.append(point_in_camera_frame[:3]) return points_in_camera_frame @@ -87,17 +87,19 @@ def _main() -> None: raise RuntimeError("Calibration board not detected!") print("Estimating checkerboard pose") - transform_camera_to_checkerboard = detection_result.pose().to_matrix() - print(transform_camera_to_checkerboard) + camera_to_checkerboard_transform = detection_result.pose().to_matrix() + print(camera_to_checkerboard_transform) print("Creating a grid of 7 x 6 points (3D) with 30 mm spacing to match checkerboard corners") - grid = _checkerboard_grid() + grid_points_in_checkerboard_frame = _checkerboard_grid() print("Transforming the grid to the camera frame") - points_in_camera_frame = _transform_grid_to_calibration_board(grid, transform_camera_to_checkerboard) + grid_points_in_camera_frame = _transform_grid_to_camera_frame( + grid_points_in_checkerboard_frame, camera_to_checkerboard_transform + ) print("Getting projector pixels (2D) corresponding to points (3D) in the camera frame") - projector_pixels = zivid.projection.pixels_from_3d_points(camera, points_in_camera_frame) + projector_pixels = zivid.projection.pixels_from_3d_points(camera, grid_points_in_camera_frame) print("Retrieving the projector resolution that the camera supports") projector_resolution = zivid.projection.projector_resolution(camera) diff --git a/source/applications/advanced/robot_guidance/robodk_robot_guidance.py b/source/applications/advanced/robot_guidance/robodk_robot_guidance.py index e5e53c36..9b329fdc 100644 --- a/source/applications/advanced/robot_guidance/robodk_robot_guidance.py +++ b/source/applications/advanced/robot_guidance/robodk_robot_guidance.py @@ -44,7 +44,7 @@ def _options() -> argparse.Namespace: parser.add_argument( "--tool-yaml", required=True, - help="Path to YAML file that contains the tool tip to robot flange transformation matrix", + help="Path to YAML file that contains the tool tip transformation matrix (tool tip in robot flange frame)", ) parser.add_argument( "--hand-eye-yaml", @@ -78,7 +78,7 @@ def _transform_points(points: List[np.ndarray], transform: np.ndarray) -> List[n Args: points: List of 3D points to be transformed - transform: Homogenous transform (4x4) + transform: Transformation matrix (4x4) Returns: List of transformed 3D points @@ -127,13 +127,13 @@ def _zivid_logo_from_grid() -> List[int]: def _generate_tool_poses_from_checkerboard( - camera: zivid.Camera, camera_to_base_transform: np.ndarray + camera: zivid.Camera, base_to_camera_transform: np.ndarray ) -> List[np.ndarray]: """Generate a tool path as a list of poses in the camera frame using the checkerboard. Args: camera: Zivid camera - camera_to_base_transform: Homogenous transform (4x4) from the camera frame to the robot base + base_to_camera_transform: Camera pose in robot base frame (4x4) Raises: RuntimeError: If the calibration board is not detected @@ -146,12 +146,12 @@ def _generate_tool_poses_from_checkerboard( if not detection_result.valid(): raise RuntimeError("Calibration board not detected!") - checkerboard_to_camera_transform = detection_result.pose().to_matrix() - checkerboard_to_base_transform = camera_to_base_transform @ checkerboard_to_camera_transform + camera_to_checkerboard_transform = detection_result.pose().to_matrix() + base_to_checkerboard_transform = base_to_camera_transform @ camera_to_checkerboard_transform - grid_points = _checkerboard_grid() - grid_points_in_base_frame = _transform_points(grid_points, checkerboard_to_base_transform) - grid_poses_in_base_frame = _points_to_poses(grid_points_in_base_frame, checkerboard_to_base_transform[:3, :3]) + grid_points_in_checkerboard_frame = _checkerboard_grid() + grid_points_in_base_frame = _transform_points(grid_points_in_checkerboard_frame, base_to_checkerboard_transform) + grid_poses_in_base_frame = _points_to_poses(grid_points_in_base_frame, base_to_checkerboard_transform[:3, :3]) tool_poses_in_base_frame = [grid_poses_in_base_frame[idx] for idx in _zivid_logo_from_grid()] @@ -242,25 +242,25 @@ def _main() -> None: camera = app.connect_camera() print("Generating tool path from the checkerboard") - tool_to_flange_transform = load_and_assert_affine_matrix(user_options.tool_yaml) - flange_to_base_transform = np.array(robot.Pose()).T + flange_to_tcp_transform = load_and_assert_affine_matrix(user_options.tool_yaml) + base_to_flange_transform = np.array(robot.Pose()).T if user_options.eih: - camera_to_flange_transform = load_and_assert_affine_matrix(user_options.hand_eye_yaml) - camera_to_base_transform = flange_to_base_transform @ camera_to_flange_transform + flange_to_camera_transform = load_and_assert_affine_matrix(user_options.hand_eye_yaml) + base_to_camera_transform = base_to_flange_transform @ flange_to_camera_transform else: - camera_to_base_transform = load_and_assert_affine_matrix(user_options.hand_eye_yaml) + base_to_camera_transform = load_and_assert_affine_matrix(user_options.hand_eye_yaml) - tool_poses_in_robot_base = _generate_tool_poses_from_checkerboard(camera, camera_to_base_transform) - flange_poses_in_robot_base = [ - tool_pose_in_robot_base @ np.linalg.inv(tool_to_flange_transform) - for tool_pose_in_robot_base in tool_poses_in_robot_base + tool_poses_in_base_frame = _generate_tool_poses_from_checkerboard(camera, base_to_camera_transform) + flange_poses_in_base_frame = [ + tool_pose_in_base_frame @ np.linalg.inv(flange_to_tcp_transform) + for tool_pose_in_base_frame in tool_poses_in_base_frame ] print("Displaying the tool path on the checkerboard") tool_poses_in_camera_frame = [ - np.linalg.inv(camera_to_base_transform) @ tool_pose_in_robot_base - for tool_pose_in_robot_base in tool_poses_in_robot_base + np.linalg.inv(base_to_camera_transform) @ tool_pose_in_base_frame + for tool_pose_in_base_frame in tool_poses_in_base_frame ] projector_image = _projected_tool_path(camera, tool_poses_in_camera_frame) @@ -270,9 +270,9 @@ def _main() -> None: if user_options.eih: projected_image_handle.stop() - _approach_target_pose(robot, flange_poses_in_robot_base[0], offset=np.array([0, 0, -100])) + _approach_target_pose(robot, flange_poses_in_base_frame[0], offset=np.array([0, 0, -100])) - _follow_linear_path(robot, flange_poses_in_robot_base) + _follow_linear_path(robot, flange_poses_in_base_frame) robot.MoveJ(robot.JointsHome()) diff --git a/source/applications/advanced/roi_box_via_aruco_marker.py b/source/applications/advanced/roi_box_via_aruco_marker.py index da20958a..bccf4198 100644 --- a/source/applications/advanced/roi_box_via_aruco_marker.py +++ b/source/applications/advanced/roi_box_via_aruco_marker.py @@ -18,7 +18,7 @@ def _transform_points(points: List[np.ndarray], transform: np.ndarray) -> List[n Args: points: list of 3D points to be transformed - transform: homogenous transform (4x4) + transform: homogenous transformation matrix (4x4) Returns: transformed_points: list of transformed 3D points @@ -88,12 +88,12 @@ def _main() -> None: raise RuntimeError("No ArUco markers detected") print("Estimating pose of detected ArUco marker") - transform_camera_to_marker = detection_result.detected_markers()[0].pose.to_matrix() + camera_to_marker_transform = detection_result.detected_markers()[0].pose.to_matrix() print("Transforming the ROI base frame points to the camera frame") roi_points_in_camera_frame = _transform_points( [point_o_in_aruco_frame, point_a_in_aruco_frame, point_b_in_aruco_frame], - transform_camera_to_marker, + camera_to_marker_transform, ) print("Setting the ROI") diff --git a/source/applications/advanced/roi_box_via_checkerboard.py b/source/applications/advanced/roi_box_via_checkerboard.py index 1c4f2dab..5b9f0028 100644 --- a/source/applications/advanced/roi_box_via_checkerboard.py +++ b/source/applications/advanced/roi_box_via_checkerboard.py @@ -18,7 +18,7 @@ def _transform_points(points: List[np.ndarray], transform: np.ndarray) -> List[n Args: points: list of 3D points to be transformed - transform: homogenous transform (4x4) + transform: homogenous transformation matrix (4x4) Returns: transformed_points: list of transformed 3D points @@ -79,12 +79,12 @@ def _main() -> None: print("Detecting and estimating pose of the Zivid checkerboard in the camera frame") detection_result = zivid.calibration.detect_feature_points(original_frame) - transform_camera_to_checkerboard = detection_result.pose().to_matrix() + camera_to_checkerboard_transform = detection_result.pose().to_matrix() print("Transforming the ROI base frame points to the camera frame") roi_points_in_camera_frame = _transform_points( [point_o_in_checkerboard_frame, point_a_in_checkerboard_frame, point_b_in_checkerboard_frame], - transform_camera_to_checkerboard, + camera_to_checkerboard_transform, ) print("Setting the ROI") diff --git a/source/applications/advanced/transform_point_cloud_via_checkerboard.py b/source/applications/advanced/transform_point_cloud_via_checkerboard.py index b561740a..5e374599 100644 --- a/source/applications/advanced/transform_point_cloud_via_checkerboard.py +++ b/source/applications/advanced/transform_point_cloud_via_checkerboard.py @@ -125,7 +125,7 @@ def _get_coordinate_system_points( } -def _draw_coordinae_system(frame: zivid.Frame, checkerboard_pose: np.ndarray, bgra_image: np.ndarray) -> None: +def _draw_coordinate_system(frame: zivid.Frame, checkerboard_pose: np.ndarray, bgra_image: np.ndarray) -> None: """Draw a coordinate system on a BGRA image. Args: @@ -164,24 +164,24 @@ def _main() -> None: print("Detecting and estimating pose of the Zivid checkerboard in the camera frame") detection_result = zivid.calibration.detect_calibration_board(frame) - transform_camera_to_checkerboard = detection_result.pose().to_matrix() - print(transform_camera_to_checkerboard) + camera_to_checkerboard_transform = detection_result.pose().to_matrix() + print(camera_to_checkerboard_transform) print("Camera pose in checkerboard frame:") - transform_checkerboard_to_camera = np.linalg.inv(transform_camera_to_checkerboard) - print(transform_checkerboard_to_camera) + checkerboard_to_camera_transform = np.linalg.inv(camera_to_checkerboard_transform) + print(checkerboard_to_camera_transform) transform_file = Path("CheckerboardToCameraTransform.yaml") print("Saving a YAML file with Inverted checkerboard pose to file: ") - assert_affine_matrix_and_save(transform_checkerboard_to_camera, transform_file) + assert_affine_matrix_and_save(checkerboard_to_camera_transform, transform_file) print("Transforming point cloud from camera frame to Checkerboard frame") - point_cloud.transform(transform_checkerboard_to_camera) + point_cloud.transform(checkerboard_to_camera_transform) print("Converting to OpenCV image format") bgra_image = point_cloud.copy_data("bgra") print("Visualizing checkerboard with coordinate system") - _draw_coordinae_system(frame, transform_camera_to_checkerboard, bgra_image) + _draw_coordinate_system(frame, camera_to_checkerboard_transform, bgra_image) display_bgr(bgra_image, "Checkerboard transformation frame") checkerboard_transformed_file = "CalibrationBoardInCheckerboardOrigin.zdf" diff --git a/source/applications/advanced/verify_hand_eye_calibration/robodk_verify_hand_eye_calibration.py b/source/applications/advanced/verify_hand_eye_calibration/robodk_verify_hand_eye_calibration.py index cc8fa3e6..928a0d26 100644 --- a/source/applications/advanced/verify_hand_eye_calibration/robodk_verify_hand_eye_calibration.py +++ b/source/applications/advanced/verify_hand_eye_calibration/robodk_verify_hand_eye_calibration.py @@ -5,8 +5,8 @@ The robot touches the Zivid calibration object to verify hand-eye calibration. The sample requires as follows: - Type of calibration used (eye-in-hand or eye-to-hand) -- YAML file with Hand-Eye transformation -- YAML file with Pointed Hand-Eye Verification Tool transformation +- YAML file with Hand-Eye transformation matrix +- YAML file with Pointed Hand-Eye Verification Tool transformation matrix - Capture pose target name used in RoboDK - Calibration object used (Zivid calibration board or ArUco marker) @@ -84,20 +84,20 @@ def _estimate_calibration_object_pose(frame: zivid.Frame, user_options: argparse return calibration_object_pose -def _get_robot_base_to_calibration_object_transform( +def _get_base_to_calibration_object_transform( user_options: argparse.Namespace, camera_to_calibration_object_transform: np.ndarray, robot: Item, ) -> np.ndarray: - """Calculating the robot base to the calibration object transform matrix. + """Calculating the robot base to the calibration object transformation matrix. Args: - user_options: Arguments from user that contain the type of hand-eye calibration done and the path to the matrix that resulted from that calibration + user_options: Arguments from user that contain the type of hand-eye calibration done and the path to the transformation matrix that resulted from that calibration camera_to_calibration_object_transform: A 4x4 numpy array containing the calibration object pose in the camera frame robot: Robot item in open RoboDK rdk file Returns: - robot_base_to_calibration_object_transform: A 4x4 numpy array containing the calibration object pose in the robot base frame + base_to_calibration_object_transform: A 4x4 numpy array containing the calibration object pose in the robot base frame Raises: ValueError: If an invalid calibration type is selected @@ -105,22 +105,20 @@ def _get_robot_base_to_calibration_object_transform( """ if user_options.eih: print("Loading current robot pose") - robot_base_to_flange_transform = np.array(robot.Pose()).T + base_to_flange_transform = np.array(robot.Pose()).T flange_to_camera_transform = load_and_assert_affine_matrix(user_options.hand_eye_yaml) - robot_base_to_calibration_object_transform = ( - robot_base_to_flange_transform @ flange_to_camera_transform @ camera_to_calibration_object_transform + base_to_calibration_object_transform = ( + base_to_flange_transform @ flange_to_camera_transform @ camera_to_calibration_object_transform ) elif user_options.eth: - robot_base_to_camera_transform = load_and_assert_affine_matrix(user_options.hand_eye_yaml) + base_to_camera_transform = load_and_assert_affine_matrix(user_options.hand_eye_yaml) - robot_base_to_calibration_object_transform = ( - robot_base_to_camera_transform @ camera_to_calibration_object_transform - ) + base_to_calibration_object_transform = base_to_camera_transform @ camera_to_calibration_object_transform else: raise ValueError("Invalid calibration type. Please choose either eye-in-hand or eye-to-hand.") - return robot_base_to_calibration_object_transform + return base_to_calibration_object_transform def _yes_no_prompt(question: str) -> str: @@ -342,15 +340,15 @@ def _main() -> None: set_robot_speed_and_acceleration(robot, speed=100, joint_speed=100, acceleration=50, joint_acceleration=50) print("Loading the Pointed Hand-Eye Verification Tool transformation matrix from a YAML file") - pointed_hand_eye_verification_tool_matrix = load_and_assert_affine_matrix(user_options.tool_yaml) + tool_base_to_tool_tip_transform = load_and_assert_affine_matrix(user_options.tool_yaml) if user_options.mounts_yaml: print("Loading the on-arm mounts transformation matrix from a YAML file") - flange_to_on_arm_mounts_transform = load_and_assert_affine_matrix(user_options.mounts_yaml) + flange_to_tool_base_transform = load_and_assert_affine_matrix(user_options.mounts_yaml) - tcp = flange_to_on_arm_mounts_transform @ pointed_hand_eye_verification_tool_matrix + flange_to_tcp_transform = flange_to_tool_base_transform @ tool_base_to_tool_tip_transform else: - tcp = pointed_hand_eye_verification_tool_matrix + flange_to_tcp_transform = tool_base_to_tool_tip_transform capture_pose = get_robot_targets(rdk, target_keyword=user_options.target_keyword) if not capture_pose: @@ -368,14 +366,14 @@ def _main() -> None: camera_to_calibration_object_transform = _estimate_calibration_object_pose(frame, user_options) print("Calculating the calibration object pose in robot base frame") - robot_base_to_calibration_object_transform = _get_robot_base_to_calibration_object_transform( + base_to_calibration_object_transform = _get_base_to_calibration_object_transform( user_options, camera_to_calibration_object_transform, robot, ) print("Calculating pose for robot to touch the calibration object") - touch_pose = robot_base_to_calibration_object_transform @ np.linalg.inv(tcp) + touch_pose = base_to_calibration_object_transform @ np.linalg.inv(flange_to_tcp_transform) print("Calculating pose for the robot to approach the calibration object") touch_pose_offset = np.identity(4) diff --git a/source/applications/point_cloud_tutorial.md b/source/applications/point_cloud_tutorial.md index 55bdd945..941ba4d4 100644 --- a/source/applications/point_cloud_tutorial.md +++ b/source/applications/point_cloud_tutorial.md @@ -159,7 +159,7 @@ m](https://support.zivid.com/latest//academy/applications/transform/transform-mi source](https://github.com/zivid/zivid-python-samples/tree/master//source/applications/advanced/hand_eye_calibration/utilize_hand_eye_calibration.py#L119)) ``` sourceCode python -point_cloud.transform(transform_base_to_camera) +point_cloud.transform(base_to_camera_transform) ``` ## Downsample diff --git a/source/sample_utils/save_load_matrix.py b/source/sample_utils/save_load_matrix.py index b73a5c41..66e2a4c7 100644 --- a/source/sample_utils/save_load_matrix.py +++ b/source/sample_utils/save_load_matrix.py @@ -14,7 +14,7 @@ def assert_affine(matrix: Union[np.ndarray, zivid.Matrix4x4]) -> None: """Ensures that the matrix is affine. Args: - matrix: 4x4 transformation matrix, np.ndarray or zivid.Matrix4x4 + matrix: Transformation matrix (4x4), np.ndarray or zivid.Matrix4x4 Raises: RuntimeError: If matrix is not affine @@ -30,7 +30,7 @@ def assert_affine_matrix_and_save(matrix: Union[np.ndarray, zivid.Matrix4x4], ya """Save transformation matrix to YAML. Args: - matrix: 4x4 transformation matrix, np.ndarray or zivid.Matrix4x4 + matrix: Transformation matrix (4x4), np.ndarray or zivid.Matrix4x4 yaml_path: Path to the YAML file """