Upload 3 files

ecm.py

@@ -0,0 +1,207 @@
+# Author(s): Jiaqi Xu
+# Created on: 2020-11
+
+"""
+PSM wrapper
+Refer to:
+https://github.com/jhu-dvrk/dvrk-ros/blob/master/dvrk_python/src/dvrk/ecm.py
+https://github.com/jhu-dvrk/dvrk-ros/blob/7b3d48ca164755ccfc88028e15baa9fbf7aa1360/dvrk_python/src/dvrk/ecm.py
+https://github.com/jhu-dvrk/sawIntuitiveResearchKit/blob/master/share/kinematic/ecm.json
+https://github.com/jhu-dvrk/sawIntuitiveResearchKit/blob/4a8b4817ee7404b3183dfba269c0efe5885b41c2/share/arm/ecm-straight.json
+"""
+import os
+import numpy as np
+import pybullet as p
+
+from surrol.robots.arm import Arm
+from surrol.const import ASSET_DIR_PATH
+from surrol.utils.pybullet_utils import (
+    get_joint_positions,
+    get_link_pose,
+    render_image
+)
+
+# Rendering width and height
+RENDER_HEIGHT = 256
+RENDER_WIDTH = 256
+FoV = 60
+
+LINKS = (
+    'ecm_base_link', 'ecm_yaw_link', 'ecm_pitch_end_link',  # -1, 0, 1
+    'ecm_main_insertion_link', 'ecm_tool_link',  # 2, 3
+    'ecm_end_link',  # 4
+    'ecm_tip_link',  # 5
+    'ecm_pitch_front_link',  # 6
+    'ecm_pitch_bottom_link', 'ecm_pitch_top_link',  # 7, 8
+    'ecm_pitch_back_link',  # 9
+    'ecm_remote_center_link',  # 10
+)
+
+# tooltip-offset; refer to .json
+tool_T_tip = np.array([[0.0, 1.0, 0.0, 0.0],
+                       [-1.0, 0.0, 0.0, 0.0],
+                       [0.0, 0.0, 1.0, 0.0],
+                       [0.0, 0.0, 0.0, 1.0]])
+
+# Joint limits. No limits in the .json. TODO: dVRK config modified
+TOOL_JOINT_LIMIT = {
+    'lower': np.deg2rad([-90.0, -45.0,   0.0, -np.inf]),  # not sure about the last joint
+    'upper': np.deg2rad([ 90.0,  66.4, 254.0,  np.inf]),
+}
+TOOL_JOINT_LIMIT['lower'][2] = -0.01  # allow small tolerance
+TOOL_JOINT_LIMIT['upper'][2] = 0.254  # prismatic joint (m); not sure, from ambf
+# [-1.57079633, -0.78539816, 0.   , -1.57079633]
+# [ 1.57079633,  1.15889862, 0.254,  1.57079633]
+
+
+class Ecm(Arm):
+    NAME = 'ECM'
+    URDF_PATH = os.path.join(ASSET_DIR_PATH, 'ecm/ecm.urdf')
+    DoF = 4  # 4-dof arm
+    JOINT_TYPES = ('R', 'R', 'P', 'R')
+    EEF_LINK_INDEX = 4   # EEF link index, one redundant joint for inverse kinematics
+    TIP_LINK_INDEX = 5   # redundant joint for easier camera matrix computation
+    RCM_LINK_INDEX = 10  # RCM link index
+    # D-H parameters
+    A     = np.array([0.0, 0.0, 0.0, 0.0])
+    ALPHA = np.array([np.pi / 2, -np.pi / 2, np.pi / 2, 0.0])
+    D     = np.array([0.0, 0.0, -0.3822, 0.3829])
+    THETA = np.array([np.pi / 2, -np.pi / 2, 0.0, 0.0])
+
+    def __init__(self, pos=(0., 0., 1.), orn=(0., 0., 0., 1.),
+                 scaling=1.):
+        super(Ecm, self).__init__(self.URDF_PATH, pos, orn,
+                                  TOOL_JOINT_LIMIT, tool_T_tip, scaling)
+
+        # camera control related parameters
+        self.view_matrix = None
+        self.proj_matrix = None
+        self._homo_delta = np.zeros((2, 1))
+        self._wz = 0
+
+        # b: rcm, e: eef, c: camera
+        pos_eef, orn_eef = get_link_pose(self.body, self.EEF_LINK_INDEX)
+        pos_cam, orn_cam = get_link_pose(self.body, self.TIP_LINK_INDEX)
+        self._tip_offset = np.linalg.norm(np.array(pos_eef) - np.array(pos_cam))  # TODO
+        wRe = np.array(p.getMatrixFromQuaternion(orn_eef)).reshape((3, 3))
+        wRc = np.array(p.getMatrixFromQuaternion(orn_cam)).reshape((3, 3))
+        self._wRc0 = wRc.copy()  # initial rotation matrix
+        self._eRc = np.matmul(wRe.T, wRc)
+
+    def _get_joint_positions_all(self, abs_input):
+        """ With the consideration of parallel mechanism constraints and other redundant joints.
+        """
+        positions = get_joint_positions(self.body, self.joints)
+        joint_positions = [
+            abs_input[0], abs_input[1],  # 0, 1
+            abs_input[2] * self.scaling, abs_input[3],  # 2, 3
+            positions[4], positions[5],  # 4 (0.0), 5 (0.0)
+            abs_input[1],  # 6
+            -abs_input[1], -abs_input[1],  # 7, 8
+            abs_input[1],  # 9
+            positions[10],  # 10 (0.0)
+        ]
+        return joint_positions
+
+    def cVc_to_dq(self, cVc: np.ndarray) -> np.ndarray:
+        """
+        convert the camera velocity in its own frame (cVc) into the joint velocity q_dot
+        """
+        cVc = cVc.reshape((3, 1))
+
+        # restrict the step size, need tune
+        if np.abs(cVc).max() > 0.01:
+            cVc = cVc / np.abs(cVc).max() * 0.01
+
+        # Forward kinematics
+        q = self.get_current_joint_position()
+        bRe = self.robot.fkine(q).R  # use rtb instead of PyBullet, no tool_tip_offset
+        _, orn_cam = get_link_pose(self.body, self.TIP_LINK_INDEX)
+        wRc = np.array(p.getMatrixFromQuaternion(orn_cam)).reshape((3, 3))
+
+        # Rotation
+        R1, R2 = self._wRc0, wRc
+        x = R1[0, 0] * R2[1, 0] - R1[1, 0] * R2[0, 0] + R1[0, 1] * R2[1, 1] - R1[1, 1] * R2[0, 1]
+        y = R1[0, 0] * R2[1, 1] - R1[1, 0] * R2[0, 1] - R1[0, 1] * R2[1, 0] + R1[1, 1] * R2[0, 0]
+        dz = np.arctan(x / y)
+        k1, k2 = 25.0, 0.1
+        self._wz = k1 * dz * np.exp(-k2 * np.linalg.norm(self._homo_delta))
+        # print(' -> x: {:.4f}, y: {:.4f}, dz: {:.4f}, wz: {:.4f}'.format(x, y, dz, self._wz))
+
+        # Pseudo Solution
+        d = self._tip_offset
+        Jd = np.matmul(self._eRc,
+                       np.array([[0,  0, d, 0],
+                                 [0, -d, 0, 0],
+                                 [1,  0, 0, 0]]))
+        Je = np.matmul(self._eRc,
+                       np.array([[0, 1, 0, 0],
+                                 [0, 0, 1, 0],
+                                 [0, 0, 0, 1]]))
+
+        eVe4 = np.dot(np.linalg.pinv(Jd), cVc) \
+               + np.dot(np.dot((np.eye(4) - np.dot(np.linalg.pinv(Jd), Jd)), np.linalg.pinv(Je)),
+                        np.array([[0], [0], [self._wz]]))
+        eVe = np.zeros((6, 1))
+        eVe[2: 6] = eVe4[0: 4]
+        Q = np.zeros((6, 6))
+        Q[0: 3, 0: 3] = - bRe
+        Q[3: 6, 3: 6] = - bRe
+        bVe = np.dot(Q, eVe)
+
+        # Compute the Jacobian matrix
+        bJe = self.get_jacobian_spatial()
+        dq = np.dot(np.linalg.pinv(bJe), bVe)
+        # print(" -> cVc: {}, q: {}, dq: {}".format(list(np.round(cVc.flatten(), 4)), q, list(dq.flatten())))
+        return dq.flatten()
+
+    def render_image(self, width=RENDER_WIDTH, height=RENDER_HEIGHT):
+        pos_eef, orn_eef = get_link_pose(self.body, self.EEF_LINK_INDEX)
+        pos_tip = get_link_pose(self.body, self.TIP_LINK_INDEX)[0]
+        mat_eef = np.array(p.getMatrixFromQuaternion(orn_eef)).reshape((3, 3))
+
+        # TODO: need to check the up vector
+        self.view_matrix = p.computeViewMatrix(cameraEyePosition=pos_eef,
+                                               cameraTargetPosition=pos_tip,
+                                               cameraUpVector=mat_eef[:, 0])
+        self.proj_matrix = p.computeProjectionMatrixFOV(fov=FoV,
+                                                        aspect=float(width) / height,
+                                                        nearVal=0.01,
+                                                        farVal=10.0)
+
+        rgb_array, mask, depth = render_image(width, height,
+                                       self.view_matrix, self.proj_matrix)
+        return rgb_array, mask, depth
+
+    def get_centroid_proj(self, pos) -> np.ndarray:
+        """
+        Compute the object position in the camera NDC space.
+        Refer to OpenGL.
+        :param pos: object position in the world frame.
+        """
+        assert len(pos) in (3, 4)
+        if len(pos) == 3:
+            # homogeneous coordinates: (x, y, z) -> (x, y, z, w)
+            pos_obj = np.ones((4, 1))
+            pos_obj[: 3, 0] = pos
+        else:
+            pos_obj = np.array(pos).reshape((4, 1))
+
+        view_matrix = np.array(self.view_matrix).reshape(4, 4).T
+        proj_matrix = np.array(self.proj_matrix).reshape(4, 4).T
+        # pos in the camera frame
+        pos_cam = np.dot(proj_matrix, np.dot(view_matrix, pos_obj))
+        pos_cam /= pos_cam[3, 0]
+        return np.array([pos_cam[0][0], - pos_cam[1][0]])  # be consistent with get_centroid
+
+    @property
+    def homo_delta(self):
+        return self._homo_delta
+
+    @homo_delta.setter
+    def homo_delta(self, val: np.ndarray):
+        self._homo_delta = val
+
+    @property
+    def wz(self):
+        return self._wz

ecm_active_track_v1.py

@@ -0,0 +1,379 @@
+import os
+import time
+
+import pybullet as p
+from surrol.tasks.ecm_env import EcmEnv, goal_distance
+from surrol.utils.pybullet_utils import (
+    get_body_pose,
+)
+import random
+import cv2
+import pickle
+from surrol.utils.robotics import (
+    get_euler_from_matrix,
+    get_matrix_from_euler
+)
+import torch
+from surrol.utils.utils import RGB_COLOR_255, Boundary, Trajectory, get_centroid
+from surrol.robots.ecm import RENDER_HEIGHT, RENDER_WIDTH, FoV
+from surrol.const import ASSET_DIR_PATH
+import numpy as np
+from surrol.robots.psm import Psm1, Psm2
+import sys
+sys.path.append('/home/kejianshi/Desktop/Surgical_Robot/science_robotics/stateregress_back')
+sys.path.append('/home/kejianshi/Desktop/Surgical_Robot/science_robotics/stateregress_back/utils')
+from general_utils import AttrDict
+sys.path.append('/home/kejianshi/Desktop/Surgical_Robot/science_robotics/ar_surrol/surrol_datagen/tasks')
+from depth_anything.dpt import DepthAnything
+from depth_anything.util.transform import Resize, NormalizeImage, PrepareForNet
+
+from vmodel import vismodel
+from config import opts
+
+class ActiveTrack(EcmEnv):
+    """
+    Active track is not a GoalEnv since the environment changes internally.
+    The reward is shaped.
+    """
+    ACTION_MODE = 'cVc'
+    # RCM_ACTION_MODE = 'yaw'
+    QPOS_ECM = (0, 0, 0.02, 0)
+    WORKSPACE_LIMITS = ((-0.3, 0.6), (-0.4, 0.4), (0.05, 0.05))
+
+    CUBE_NUMBER = 18
+
+    def __init__(self, render_mode=None):
+        # to control the step
+        self._step = 0
+        self.counter=0
+        self.img_list={}
+        super(ActiveTrack, self).__init__(render_mode)
+
+    def step(self, action: np.ndarray):
+        obs, reward, done, info = super().step(action)
+        centroid = obs['observation'][-3: -1]
+        if not (-1.2 < centroid[0] < 1.1 and -1.1 < centroid[1] < 1.1):
+            # early stop if out of view
+            done = True
+        info['achieved_goal'] = centroid
+        return obs, reward, done, info
+
+    def compute_reward(self, achieved_goal: np.ndarray, desired_goal: np.ndarray, info):
+        """ Dense reward."""
+        centroid, wz = achieved_goal, self.ecm.wz
+        d = goal_distance(centroid, desired_goal) / 2
+        reward = 1 - (d + np.linalg.norm(wz) * 0.1)  # maximum reward is 1, important for baseline DDPG
+        return reward
+
+    def _env_setup(self):
+        super(ActiveTrack, self)._env_setup()
+        opts.device='cuda:0'
+        self.v_model=vismodel(opts)
+        ckpt=torch.load(opts.ckpt_dir, map_location=opts.device)
+        self.v_model.load_state_dict(ckpt['state_dict'])
+        self.v_model.to(opts.device)
+        self.v_model.eval()
+
+        self.use_camera = True
+
+        # robot
+        self.ecm.reset_joint(self.QPOS_ECM)
+        pos_x = random.uniform(0.18, 0.24)
+        pos_y = random.uniform(0.21, 0.24)
+        pos_z = random.uniform(0.5, 0.6)
+        left_right = random.choice([-1, 1])
+
+        self.POSE_PSM1 = ((pos_x, left_right*pos_y, pos_z), (0, 0, -(90+ left_right*20 ) / 180 * np.pi)) #(x:0.18-0.25, y:0.21-0.24, z:0.5)
+        self.QPOS_PSM1 = (0, 0, 0.10, 0, 0, 0)
+        self.PSM_WORLSPACE_LIMITS = ((0.18+0.45,0.18+0.55), (0.24-0.29,0.24-0.19), (0.5-0.1774,0.5-0.1074))
+        self.PSM_WORLSPACE_LIMITS = np.asarray(self.PSM_WORLSPACE_LIMITS) \
+                           + np.array([0., 0., 0.0102]).reshape((3, 1))
+        # trajectory
+        traj = Trajectory(self.PSM_WORLSPACE_LIMITS, seed=None)
+        self.traj = traj
+        self.traj.set_step(self._step)
+        self.psm1 = Psm1(self.POSE_PSM1[0], p.getQuaternionFromEuler(self.POSE_PSM1[1]),
+                         scaling=self.SCALING)
+        if left_right == 1:
+            self.psm1.move_joint([0.4516922970194888, -0.11590085534517788, 0.1920614431341014, -0.275713630305575, -0.025332969748983816, -0.44957632598600145])
+        else:
+            self.psm1.move_joint([0.4516922970194888, -0.11590085534517788, 0.1920614431341014, -0.275713630305575, -0.025332969748983816, -0.44957632598600145])
+        # target cube
+        init_psm_Pose  = self.psm1.get_current_position(frame='world')
+        # print(init_psm_Pose[:3, 3])
+        # exit()
+        b = Boundary(self.PSM_WORLSPACE_LIMITS)
+        x, y = self.traj.step()
+        obj_id = p.loadURDF(os.path.join(ASSET_DIR_PATH, 'cube/cube.urdf'),
+                            (init_psm_Pose[0, 3], init_psm_Pose[1, 3], init_psm_Pose[2, 3]),
+                            p.getQuaternionFromEuler(np.random.uniform(np.deg2rad([0, 0, -90]),
+                                                                       np.deg2rad([0, 0, 90]))),
+                            globalScaling=0.001 * self.SCALING)
+        # print('psm_eef:', self.psm1.get_joint_number())
+        color = RGB_COLOR_255[0]
+        p.changeVisualShape(obj_id, -1,
+                            rgbaColor=(color[0] / 255, color[1] / 255, color[2] / 255, 0),
+                            specularColor=(0.1, 0.1, 0.1))
+        self.obj_ids['fixed'].append(obj_id)  # 0 (target)
+        self.obj_id = obj_id
+        b.add(obj_id, sample=False, min_distance=0.12)
+        # self._cid = p.createConstraint(obj_id, -1, -1, -1,
+        #                                p.JOINT_FIXED, [0, 0, 0], [0, 0, 0], [x, y, 0.05 * self.SCALING])
+        self._cid = p.createConstraint(
+            parentBodyUniqueId=self.psm1.body,
+            parentLinkIndex=5,
+            childBodyUniqueId=self.obj_id,
+            childLinkIndex=-1,
+            jointType=p.JOINT_FIXED,
+            jointAxis=[0, 0, 0],
+            parentFramePosition=[0, 0, 0],
+            childFramePosition=[0, 0, 0]
+        )
+        
+
+        # '''
+        # Set up initial env
+        # '''
+        # self.psm1_eul = np.array(p.getEulerFromQuaternion(
+        #     self.psm1.pose_rcm2world(self.psm1.get_current_position(), 'tuple')[1]))  # in the world frame
+        
+        # # robot 
+        # #self.psm1_eul = np.array(p.getEulerFromQuaternion(
+        # #    self.psm1.pose_rcm2world(self.psm1.get_current_position(), 'tuple')[1]))  # in the world frame
+        
+        # if self.RCM_ACTION_MODE == 'yaw':
+        #     #self.psm1_eul = np.array([np.deg2rad(-90), 0., self.psm1_eul[2]])
+        #     '''
+        #     # RCM init
+        #     #eul=np.array([np.deg2rad(-90), 0., 0.])
+        #     print(self.psm1.wTr)
+        #     print(self.psm1.tool_T_tip)
+        #     init_pose=self.psm1.get_current_position()
+            
+        #     eul=np.array([0, 0.,np.deg2rad(-50)])
+        #     rcm_eul=get_matrix_from_euler(eul)
+        #     init_pose[:3,:3]=rcm_eul
+            
+        #     rcm_pose=self.psm1.pose_world2rcm(init_pose)
+        #     rcm_eul=get_euler_from_matrix(rcm_pose[:3,:3])
+        #     print('from [0, 0.,np.deg2rad(-50)] to ',rcm_eul)
+        #     #exit()
+        #     eul=np.array([0, 0.,np.deg2rad(-90)])
+        #     rcm_eul=get_matrix_from_euler(eul)
+        #     init_pose[:3,:3]=rcm_eul
+            
+        #     rcm_pose=self.psm1.pose_world2rcm(init_pose)
+        #     rcm_eul=get_euler_from_matrix(rcm_pose[:3,:3])
+        #     print('from [0, 0.,np.deg2rad(-90)] to ',rcm_eul)
+            
+        #     m=np.array([[ 0.93969262 ,-0.34202014 , 0.         , 1.21313615],
+        #                 [ 0.34202014 , 0.93969262 , 0.         ,-2.25649898],
+        #                 [ 0.         , 0.         , 1.         ,-4.25550013],
+        #                 [ 0.         , 0.         , 0.         , 1.        ]])
+        #     #print(m.shape)
+        
+        #     m=get_euler_from_matrix(m[:3,:3])
+        #     print('m1: ',m)
+            
+        #     m=np.array([[ 0.         ,-0.93969262 ,-0.34202014 , 1.21313615],
+        #                 [ 0.         ,-0.34202014 , 0.93969262 ,-2.25649898],
+        #                 [-1.         , 0.         , 0.         ,-4.25550013],
+        #                 [ 0.         , 0.         , 0.         , 1.        ],])
+        #     m=get_euler_from_matrix(m[:3,:3])
+        #     print('m2: ',m)
+        #     exit()
+        #     '''
+        #     # RCM init
+        #     eul=np.array([np.deg2rad(-90), 0., 0.])
+        #     eul= get_matrix_from_euler(eul)
+        #     init_pose=self.psm1.get_current_position()
+        #     self.rcm_init_eul=np.array(get_euler_from_matrix(init_pose[:3, :3]))
+        #     init_pose[:3,:3]=eul
+        #     rcm_pose=self.psm1.pose_world2rcm_no_tip(init_pose)
+        #     rcm_eul=get_euler_from_matrix(rcm_pose[:3,:3])
+        #     #print('rcm eul: ',rcm_eul)
+        #     #exit()
+        #     self.rcm_init_eul[0]=rcm_eul[0]
+        #     self.rcm_init_eul[1]=rcm_eul[1]
+        #     print(self.rcm_init_eul)
+        #     #exit()
+            
+            
+
+            
+            
+        # elif self.RCM_ACTION_MODE == 'pitch':
+        #     self.psm1_eul = np.array([np.deg2rad(0), self.psm1_eul[1], np.deg2rad(-90)])
+        # else:
+        #     raise NotImplementedError
+        # self.psm2 = None
+        # self._contact_constraint = None
+        # self._contact_approx = False
+        # other cubes
+        # b.set_boundary(self.workspace_limits + np.array([[-0.2, 0], [0, 0], [0, 0]]))
+        # for i in range(self.CUBE_NUMBER):
+        #     obj_id = p.loadURDF(os.path.join(ASSET_DIR_PATH, 'cube/cube.urdf'),
+        #                         (0, 0, 0.05), (0, 0, 0, 1),
+        #                         globalScaling=0.8 * self.SCALING)
+        #     color = RGB_COLOR_255[1 + i // 2]
+        #     p.changeVisualShape(obj_id, -1,
+        #                         rgbaColor=(color[0] / 255, color[1] / 255, color[2] / 255, 1),
+        #                         specularColor=(0.1, 0.1, 0.1))
+        #     # p.changeDynamics(obj_id, -1, mass=0.01)
+        #     b.add(obj_id, min_distance=0.12)
+
+    # def _get_obs(self) -> np.ndarray:
+    #     robot_state = self._get_robot_state()
+    #     # may need to modify
+    #     rgb_array, mask, depth = self.ecm.render_image()
+    #     in_view, centroids = get_centroid(mask, self.obj_id)
+
+    #     if not in_view:
+    #         # out of view; differ when the object is on the boundary.
+    #         pos, _ = get_body_pose(self.obj_id)
+    #         centroids = self.ecm.get_centroid_proj(pos)
+    #         # print(" -> Out of view! {}".format(np.round(centroids, 4)))
+
+    #     observation = np.concatenate([
+    #         robot_state, np.array(in_view).astype(np.float).ravel(),
+    #         centroids.ravel(), np.array(self.ecm.wz).ravel()  # achieved_goal.copy(),
+    #     ])
+    #     return observation
+    def _get_obs(self) -> dict:
+        robot_state = self._get_robot_state()
+        
+        render_obs,seg, depth=self.ecm.render_image()
+        #cv2.imwrite('/research/d1/rshr/arlin/data/debug/depth_noise_debug/img.png',cv2.cvtColor(render_obs, cv2.COLOR_BGR2RGB))
+        #plt.imsave('/research/d1/rshr/arlin/data/debug/depth_noise_debug/img2.png',render_obs)
+        #print('depth max: ',np.max(depth))
+        #exit()
+        render_obs=cv2.resize(render_obs,(320,240))
+        
+        self.counter+=1
+        #print(render_obs[0][0])
+        #exit()
+        #seg=np.array(seg==6).astype(int)
+        
+        seg=np.array((seg==6 )| (seg==1)).astype(int)
+        #seg=np.array(seg==1).astype(int)
+        #seg=np.resize(seg,(320,240))
+        
+        #plt.imsave('/research/d1/rshr/arlin/data/debug/depth_noise_debug/depth.png',depth)
+        #exit()
+        seg = cv2.resize(seg, (320,240), interpolation =cv2.INTER_NEAREST)
+        #plt.imsave('/research/d1/rshr/arlin/data/debug/seg_debug/noise_{}/seg.png'.format(self.curr_intensity),seg)
+        #exit()
+        depth = cv2.resize(depth, (320,240), interpolation =cv2.INTER_NEAREST)
+        #print(np.max(depth))
+        #depth = cv2.resize(depth, (320,240),interpolation=cv2.INTER_LANCZOS4)
+
+        
+        #image=cv2.cvtColor(render_obs, cv2.COLOR_BGR2RGB) / 255.0
+        #plt.imsave('/home/student/code/regress_data7/seg/seg_{}.png'.format(self.counter),seg)
+        #image = self.transform({'image': image})['image']
+        #image=torch.from_numpy(image).to("cuda:0").float()
+
+         # test depth noise
+        
+        #if np.random.randn()<0.5:
+        #    instensity=np.random.randint(3,15)/100
+        #instensity=0.1
+        #    depth = add_gaussian_noise(depth, instensity)
+        '''
+        if self.counter==10:
+            cv2.imwrite('/research/d1/rshr/arlin/data/debug/depth_noise_debug/gaussian/img.png',cv2.cvtColor(render_obs, cv2.COLOR_BGR2RGB))
+            plt.imsave('/research/d1/rshr/arlin/data/debug/depth_noise_debug/gaussian/depth.png',depth)
+            for i in [0.01,0.05,0.1,0.15,0.2]:
+                noisy_depth_map = add_random_noise(depth, i)
+                plt.imsave('/research/d1/rshr/arlin/data/debug/depth_noise_debug/gaussian/noise_{}.png'.format(i),noisy_depth_map)
+
+            exit()
+        '''
+
+        #noisy_segmentation_map = add_noise_to_segmentation(seg, self.seg_noise_intensity)
+        #noisy_depth_map = add_gaussian_noise(depth, self.curr_intensity)
+        #if self.counter==10:
+        #    plt.imsave('/research/d1/rshr/arlin/data/debug/seg_debug/noise_{}/img.png'.format(self.curr_intensity),render_obs)
+        #    plt.imsave('/research/d1/rshr/arlin/data/debug/seg_debug/noise_{}/seg.png'.format(self.curr_intensity),seg)
+        #    plt.imsave('/research/d1/rshr/arlin/data/debug/seg_debug/noise_{}/noise_seg.png'.format(self.curr_intensity),noisy_segmentation_map)
+
+        seg=torch.from_numpy(seg).to("cuda:0").float()
+        depth=torch.from_numpy(depth).to("cuda:0").float()
+
+        
+        with torch.no_grad():
+            v_output=self.v_model.get_obs(seg.unsqueeze(0), depth.unsqueeze(0))[0]#.cpu().data().numpy()
+        #print(v_output.shape)
+        v_output=v_output.cpu().numpy()
+
+        achieved_goal = np.array([
+            v_output[0], v_output[1], self.ecm.wz
+        ])
+
+        observation = np.concatenate([
+            robot_state, np.array([0.0]).astype(np.float).ravel(),
+            v_output.ravel(), np.array(self.ecm.wz).ravel()  # achieved_goal.copy(),
+        ])
+        obs = {
+            'observation': observation.copy(),
+            'achieved_goal': achieved_goal.copy(),
+            'desired_goal': np.array([0., 0., 0.]).copy()
+        }
+        return obs
+    
+
+    def _sample_goal(self) -> np.ndarray:
+        """ Samples a new goal and returns it.
+        """
+        goal = np.array([0., 0.])
+        return goal.copy()
+
+    def _step_callback(self):
+        """ Move the target along the trajectory
+        """
+        for _ in range(10):
+            x, y = self.traj.step()
+            self._step = self.traj.get_step()
+            current_PSM_position = self.psm1.get_current_position(frame='world')
+            new_PSM_position = current_PSM_position.copy()
+
+            new_PSM_position[0, 3] =x
+            new_PSM_position[1, 3] =y
+            new_PSM_position = self.psm1.pose_world2rcm(new_PSM_position)
+            self.psm1.move(new_PSM_position)
+            # pivot = [x, y, 0.05 * self.SCALING]
+            # p.changeConstraint(self._cid, pivot, maxForce=50)
+            p.stepSimulation()
+
+    def get_oracle_action(self, obs) -> np.ndarray:
+        """
+        Define a human expert strategy
+        """
+        centroid = obs['observation'][-3: -1]
+        cam_u = centroid[0] * RENDER_WIDTH
+        cam_v = centroid[1] * RENDER_HEIGHT
+        self.ecm.homo_delta = np.array([cam_u, cam_v]).reshape((2, 1))
+        if np.linalg.norm(self.ecm.homo_delta) < 8 and np.linalg.norm(self.ecm.wz) < 0.1:
+            # e difference is small enough
+            action = np.zeros(3)
+        else:
+            # print("Pixel error: {:.4f}".format(np.linalg.norm(self.ecm.homo_delta)))
+            # controller
+            fov = np.deg2rad(FoV)
+            fx = (RENDER_WIDTH / 2) / np.tan(fov / 2)
+            fy = (RENDER_HEIGHT / 2) / np.tan(fov / 2)  # TODO: not sure
+            cz = 1.0
+            Lmatrix = np.array([[-fx / cz, 0., cam_u / cz],
+                                [0., -fy / cz, cam_v / cz]])
+            action = 0.5 * np.dot(np.linalg.pinv(Lmatrix), self.ecm.homo_delta).flatten() / 0.01
+            if np.abs(action).max() > 1:
+                action /= np.abs(action).max()
+        return action
+
+
+if __name__ == "__main__":
+    env = ActiveTrack(render_mode='human')  # create one process and corresponding env
+
+    env.test(horizon=200)
+    env.close()
+    time.sleep(2)

ecm_env.py

@@ -0,0 +1,179 @@
+import numpy as np
+import pybullet as p
+from surrol.gym.surrol_env import SurRoLEnv, RENDER_HEIGHT
+from surrol.robots.ecm import Ecm
+from surrol.utils.pybullet_utils import (
+    get_link_pose,
+    reset_camera
+)
+from surrol.utils.robotics import get_pose_2d_from_matrix
+
+
+def goal_distance(goal_a, goal_b):
+    assert goal_a.shape == goal_b.shape
+    return np.linalg.norm(goal_a - goal_b, axis=-1)
+
+
+class EcmEnv(SurRoLEnv):
+    """
+    Single arm env using ECM (active_track is not a GoalEnv)
+    Refer to Gym fetch
+    https://github.com/openai/gym/blob/master/gym/envs/robotics/fetch_env.py
+    ravens
+    https://github.com/google-research/ravens/blob/master/ravens/environments/environment.py
+    """
+    ACTION_SIZE = 3  # (dx, dy, dz) or cVc or droll (1)
+    ACTION_MODE = 'cVc'
+    DISTANCE_THRESHOLD = 0.005
+    POSE_ECM = ((0.15, 0.0, 0.7524), (0, 30 / 180 * np.pi, 0))
+    QPOS_ECM = (0, 0.6, 0.04, 0)
+    WORKSPACE_LIMITS = ((0.45, 0.55), (-0.05, 0.05), (0.60, 0.70))
+    SCALING = 1.
+
+    def __init__(self, render_mode: str = None, cid = -1):
+        # workspace
+        self.workspace_limits = np.asarray(self.WORKSPACE_LIMITS)
+        self.workspace_limits *= self.SCALING
+
+        # camera
+        self.use_camera = False
+
+        # has_object
+        self.has_object = False
+        self.obj_id = None
+
+        super(EcmEnv, self).__init__(render_mode, cid)
+
+        # change duration
+        self._duration = 0.1
+
+        # distance_threshold
+        self.distance_threshold = self.DISTANCE_THRESHOLD * self.SCALING
+
+        # render related setting
+        self._view_matrix = p.computeViewMatrixFromYawPitchRoll(
+            cameraTargetPosition=(0.27 * self.SCALING, -0.20 * self.SCALING, 0.55 * self.SCALING),
+            distance=1.80 * self.SCALING,
+            yaw=150,
+            pitch=-30,
+            roll=0,
+            upAxisIndex=2
+        )
+
+    def render(self, mode='rgb_array'):
+        # TODO: check how to disable specular color when using EGL renderer
+        if mode != "rgb_array":
+            return np.array([])
+        rgb_array = super().render(mode)
+        if self.use_camera:
+            rgb_cam, _ = self.ecm.render_image(RENDER_HEIGHT, RENDER_HEIGHT)
+            rgb_array = np.concatenate((rgb_array, rgb_cam), axis=1)
+        return rgb_array
+
+    def compute_reward(self, achieved_goal: np.ndarray, desired_goal: np.ndarray, info):
+        """ Sparse reward. """
+        # d = goal_distance(achieved_goal, desired_goal)
+        # return - (d > self.distance_threshold).astype(np.float32)
+        return self._is_success(achieved_goal, desired_goal).astype(np.float32) - 1.
+
+    def _env_setup(self):
+        assert self.ACTION_MODE in ('cVc', 'dmove', 'droll')
+        # camera
+        if self._render_mode == 'human':
+            reset_camera(yaw=150.0, pitch=-30.0, dist=1.50 * self.SCALING,
+                         target=(0.27 * self.SCALING, -0.20 * self.SCALING, 0.55 * self.SCALING))
+
+        # robot
+        self.ecm = Ecm(self.POSE_ECM[0], p.getQuaternionFromEuler(self.POSE_ECM[1]),
+                       scaling=self.SCALING)
+
+        pass  # need to implement based on every task
+        # self.obj_ids
+
+    def _get_robot_state(self) -> np.ndarray:
+        # TODO
+        # robot state: eef pose in the ECM coordinate
+        pose_rcm = get_pose_2d_from_matrix(self.ecm.get_current_position())
+        return np.concatenate([
+            np.array(pose_rcm[0]), np.array(p.getEulerFromQuaternion(pose_rcm[1]))
+        ])
+
+    def _get_obs(self) -> dict:
+        robot_state = self._get_robot_state()
+        # may need to modify
+        if self.has_object:
+            pos, _ = get_link_pose(self.obj_id, -1)
+            object_pos = np.array(pos)
+        else:
+            object_pos = np.zeros(0)
+
+        if self.has_object:
+            achieved_goal = object_pos.copy()
+        else:
+            achieved_goal = np.array(get_link_pose(self.ecm.body, self.ecm.EEF_LINK_INDEX)[0])  # eef position
+
+        observation = np.concatenate([
+            robot_state, object_pos.ravel(),  # achieved_goal.copy(),
+        ])
+        obs = {
+            'observation': observation.copy(),
+            'achieved_goal': achieved_goal.copy(),
+            'desired_goal': self.goal.copy()
+        }
+        return obs
+
+    def _set_action(self, action: np.ndarray):
+        """
+        delta_position (3) and delta_theta (1); in world coordinate
+        """
+        # print('action: ', action)
+        assert len(action) == self.ACTION_SIZE
+        action = action.copy()  # ensure that we don't change the action outside of this scope
+        if self.ACTION_MODE == 'cVc':
+            # hyper-parameters are sensitive; need to tune
+            # if np.linalg.norm(action) > 1:
+            #     action /= np.linalg.norm(action)
+            action *= 0.01 * self.SCALING  # velocity (HeadPitch, HeadYaw), limit maximum change in velocity
+            dq = 0.05 * self.ecm.cVc_to_dq(action)  # scaled
+            result = self.ecm.dmove_joint(dq)
+            if result is False:
+                return False
+            else:
+                return True
+        elif self.ACTION_MODE == 'dmove':
+            # Incremental motion in cartesian space in the base frame
+            action *= 0.01 * self.SCALING
+            pose_rcm = self.ecm.get_current_position()
+            pose_rcm[:3, 3] += action
+            pos, _ = self.ecm.pose_rcm2world(pose_rcm, 'tuple')
+            joint_positions = self.ecm.inverse_kinematics((pos, None), self.ecm.EEF_LINK_INDEX)  # do not consider orn
+            self.ecm.move_joint(joint_positions[:self.ecm.DoF])
+        elif self.ACTION_MODE == 'droll':
+            # change the roll angle
+            action *= np.deg2rad(3)
+            self.ecm.dmove_joint_one(action[0], 3)
+        else:
+            raise NotImplementedError
+
+    def _is_success(self, achieved_goal, desired_goal):
+        """ Indicates whether or not the achieved goal successfully achieved the desired goal.
+        """
+        d = goal_distance(achieved_goal, desired_goal)
+        return (d < self.distance_threshold).astype(np.float32)
+
+    def _sample_goal(self) -> np.ndarray:
+        """ Samples a new goal and returns it.
+        """
+        raise NotImplementedError
+
+    @property
+    def action_size(self):
+        return self.ACTION_SIZE
+
+    def get_oracle_action(self, obs) -> np.ndarray:
+        """
+        Define a scripted oracle strategy
+        """
+        raise NotImplementedError
+    
+