Upload task files

data/files/put_block_back.py

@@ -0,0 +1,130 @@
+import itertools
+import math
+from typing import Dict, List
+
+from pyrep.objects.dummy import Dummy
+from pyrep.objects.joint import Joint
+from pyrep.objects.object import Object
+from pyrep.objects.shape import Shape
+from pyrep.objects.proximity_sensor import ProximitySensor
+from rlbench.backend.spawn_boundary import SpawnBoundary
+from rlbench.backend.task import Task
+from rlbench.backend.conditions import Condition, ConditionSet, DetectedCondition, NothingGrasped
+
+NUM_TARGETS = 4
+
+class JointTriggerCondition(Condition):
+    def __init__(self, joint: Joint, position: float):
+        """in radians if revoloute, or meters if prismatic"""
+        self._joint = joint
+        self._original_pos = joint.get_joint_position()
+        self._pos = position
+        self._done = False
+
+    def condition_met(self):
+        met = math.fabs(
+            self._joint.get_joint_position() - self._original_pos) > self._pos
+        if met:
+            self._done = True
+        return self._done, False
+
+class DetectedTriggerCondition(Condition):
+    def __init__(self, obj: Object, detector: ProximitySensor,
+                 negated: bool = False):
+        self._obj = obj
+        self._detector = detector
+        self._negated = negated
+        self._done = False
+
+    def condition_met(self):
+        met = self._detector.is_detected(self._obj)
+        if self._negated:
+            met = not met
+        if met:
+            self._done = True
+        return self._done, False
+
+
+
+class PutBlockBack(Task):
+    def init_task(self) -> None:
+        self._block = Shape("block")
+        self._detectors = [ProximitySensor(f"success{i+1}") for i in range(NUM_TARGETS)]
+        self._targets = [Shape(f"target{i+1}") for i in range(NUM_TARGETS)]
+
+        self._button = Shape("push_buttons_target1")
+        self._button_joint = Joint("target_button_joint1")
+        self._center_detector = ProximitySensor("success0")
+
+        self.spawn_boundary = SpawnBoundary([Shape("boundary")])
+
+        self.register_graspable_objects([self._block])
+
+        self.goal_conditions = []
+
+    def init_episode(self, index: int) -> List[str]:
+        target_patch = self._targets[index]
+        target_detector = self._detectors[index]
+
+        self.spawn_boundary.clear()
+        self.spawn_boundary.sample(self._button, min_distance=0.05)
+
+        # Set the position of the block to be the initial target XY ------------
+        x, y, _ = target_patch.get_position()
+        _, _, z = self._block.get_position()
+        self._block.set_position([x, y, z])
+
+        waypoint1 = Dummy("waypoint1")
+        _, _, z = waypoint1.get_position()
+        waypoint1.set_position([x, y, z])
+
+        waypoint10 = Dummy("waypoint10")
+        _, _, z = waypoint10.get_position()
+        waypoint10.set_position([x, y, z])
+
+        waypoint11 = Dummy("waypoint11")
+        _, _, z = waypoint11.get_position()
+        waypoint11.set_position([x, y, z])
+        # ----------------------------------------------------------------------
+
+        self.goal_conditions = [
+            # Checks that the block was lifted from the table
+            DetectedTriggerCondition(self._block, target_detector, negated=True),
+            # Checks that the cube was placed at the center of the table
+            DetectedTriggerCondition(self._block, self._center_detector),
+            # Checks that the button was pressed
+            JointTriggerCondition(self._button_joint, 0.003),
+            # Checks that the block was returned back to its original position
+            DetectedCondition(self._block, target_detector),
+            # Checks that nothing is still grasped
+            NothingGrasped(self.robot.gripper),
+        ]
+        condition_set = ConditionSet(self.goal_conditions, False) # type: ignore
+        self.register_success_conditions([condition_set])
+
+        return ['move the block on the color patch to the center, then press the button, and finally move the block back to where it was placed']
+
+    def step(self) -> None:
+        if len(self.goal_conditions) < 1:
+            return
+
+        met1, _ = self.goal_conditions[0].condition_met()
+        #print(f"first condition met: {met1}")
+
+        met2, _ = self.goal_conditions[1].condition_met()
+        #print(f"second condition met: {met2}")
+
+        met3, _ = self.goal_conditions[2].condition_met()
+        #print(f"third condition met: {met3}")
+
+        met4, _ = self.goal_conditions[3].condition_met()
+        #print(f"fourth condition met: {met4}")
+
+        met5, _ = self.goal_conditions[4].condition_met()
+        #print(f"fifth condition met: {met5}")
+
+    def variation_count(self) -> int:
+        return 4
+
+    def is_static_workspace(self) -> bool:
+        return True

data/files/rearrange_block.py

@@ -0,0 +1,151 @@
+import itertools
+import math
+from typing import Dict, List
+
+from pyrep.objects.dummy import Dummy
+from pyrep.objects.joint import Joint
+from pyrep.objects.object import Object
+from pyrep.objects.shape import Shape
+from pyrep.objects.proximity_sensor import ProximitySensor
+from rlbench.backend.spawn_boundary import SpawnBoundary
+from rlbench.backend.task import Task
+from rlbench.backend.conditions import Condition, ConditionSet, DetectedCondition, NothingGrasped
+
+NUM_TARGETS = 2
+
+class JointTriggerCondition(Condition):
+    def __init__(self, joint: Joint, position: float):
+        """in radians if revoloute, or meters if prismatic"""
+        self._joint = joint
+        self._original_pos = joint.get_joint_position()
+        self._pos = position
+        self._done = False
+
+    def condition_met(self):
+        met = math.fabs(
+            self._joint.get_joint_position() - self._original_pos) > self._pos
+        if met:
+            self._done = True
+        return self._done, False
+
+class DetectedTriggerCondition(Condition):
+    def __init__(self, obj: Object, detector: ProximitySensor,
+                 negated: bool = False):
+        self._obj = obj
+        self._detector = detector
+        self._negated = negated
+        self._done = False
+
+    def condition_met(self):
+        met = self._detector.is_detected(self._obj)
+        if self._negated:
+            met = not met
+        if met:
+            self._done = True
+        return self._done, False
+
+
+
+class RearrangeBlock(Task):
+    def init_task(self) -> None:
+        self._detectors = [ProximitySensor(f"success{i+1}") for i in range(NUM_TARGETS)]
+        self._targets = [Shape(f"target{i+1}") for i in range(NUM_TARGETS)]
+
+        self._patch_block = Shape("block1")
+        self._center_block = Shape("block2")
+        self._center_detector = ProximitySensor("success0")
+
+        self._button = Shape("push_buttons_target1")
+        self._button_joint = Joint("target_button_joint1")
+
+        self.spawn_boundary = SpawnBoundary([Shape("boundary")])
+
+        self.register_graspable_objects([self._patch_block, self._center_block])
+
+        self.goal_conditions = []
+
+    def init_episode(self, index: int) -> List[str]:
+        target_patch = self._targets[index]
+        dual_index = NUM_TARGETS - index - 1
+        dual_patch = self._targets[dual_index]
+
+        self.spawn_boundary.clear()
+        self.spawn_boundary.sample(self._button, min_distance=0.05)
+
+        # Set the position of the patch block to be the initial target XY ------
+        x, y, _ = target_patch.get_position()
+        _, _, z = self._patch_block.get_position()
+        self._patch_block.set_position([x, y, z])
+
+        waypoint6 = Dummy("waypoint6")
+        _, _, z = waypoint6.get_position()
+        waypoint6.set_position([x, y, z])
+
+        waypoint7 = Dummy("waypoint7")
+        _, _, z = waypoint7.get_position()
+        waypoint7.set_position([x, y, z])
+
+        waypoint8 = Dummy("waypoint8")
+        _, _, z = waypoint8.get_position()
+        waypoint8.set_position([x, y, z])
+
+        # ----------------------------------------------------------------------
+
+        # Place the waypoints associated with the dual patch correctly ---------
+        waypoint2 = Dummy("waypoint2")
+        x, y, _ = dual_patch.get_position()
+        _, _, z = waypoint2.get_position()
+        waypoint2.set_position([x, y, z])
+
+        waypoint3 = Dummy("waypoint3")
+        _, _, z = waypoint3.get_position()
+        waypoint3.set_position([x, y, z])
+
+        # ----------------------------------------------------------------------
+
+        self.goal_conditions = [
+            # Checks that the center block was lifted up
+            DetectedTriggerCondition(self._center_block, self._center_detector, negated=True),
+            # Checks that the center block was placed in the empty patch
+            DetectedCondition(self._center_block, self._detectors[dual_index]),
+            # Checks that the button was pressed
+            JointTriggerCondition(self._button_joint, 0.003),
+            # Checks that the patch block was lifted up
+            DetectedTriggerCondition(self._patch_block, self._detectors[index], negated=True),
+            # Checks that the patch block was placed in the center
+            DetectedCondition(self._patch_block, self._center_detector),
+            # Checks that nothing is still grasped
+            NothingGrasped(self.robot.gripper),
+        ]
+        condition_set = ConditionSet(self.goal_conditions, False) # type: ignore
+        self.register_success_conditions([condition_set])
+
+        return ['Move the block not on the patch to the empty patch, then press the button, then move the block that has not been moved off the patch']
+
+    def step(self) -> None:
+        if len(self.goal_conditions) < 1:
+            return
+
+        met1, _ = self.goal_conditions[0].condition_met()
+        #print(f"first condition met: {met1}")
+
+        met2, _ = self.goal_conditions[1].condition_met()
+        #print(f"second condition met: {met2}")
+
+        met3, _ = self.goal_conditions[2].condition_met()
+        #print(f"third condition met: {met3}")
+
+        met4, _ = self.goal_conditions[3].condition_met()
+        #print(f"fourth condition met: {met4}")
+
+        met5, _ = self.goal_conditions[4].condition_met()
+        #print(f"fifth condition met: {met5}")
+
+        met6, _ = self.goal_conditions[5].condition_met()
+        #print(f"sixth condition met: {met6}")
+
+    def variation_count(self) -> int:
+        return 2
+
+    def is_static_workspace(self) -> bool:
+        return True

data/files/reopen_drawer.py

@@ -0,0 +1,110 @@
+import math
+from typing import List, Tuple
+import numpy as np
+from pyrep.objects.proximity_sensor import ProximitySensor
+from pyrep.objects.dummy import Dummy
+from pyrep.objects.joint import Joint
+from pyrep.objects.shape import Shape
+from rlbench.backend.spawn_boundary import SpawnBoundary
+from rlbench.backend.task import Task
+from rlbench.backend.conditions import Condition, DetectedCondition, JointCondition, NothingGrasped, ConditionSet
+
+DRAWER_NAMES = ['bottom', 'middle', 'top']
+
+class JointConditionEx(Condition):
+    def __init__(self, joint: Joint, position: float):
+        """in radians if revoloute, or meters if prismatic"""
+        self._joint = joint
+        self._original_pos = joint.get_joint_position()
+        self._pos = position
+        self._done = False
+
+    def condition_met(self):
+        met = math.fabs(
+            self._joint.get_joint_position() - self._original_pos) > self._pos
+        if met:
+            self._done = True
+        return self._done, False
+
+
+class ReopenDrawer(Task):
+
+    def init_task(self):
+        self.button = Shape(f"push_buttons_target1")
+        self.drawer_parts = [Shape(f"drawer_{name}") for name in DRAWER_NAMES]
+        self.drawer_joints = [Joint(f"drawer_joint_{name}") for name in DRAWER_NAMES]
+        self.button_joint = Joint("target_button_joint1")
+
+        self.detector = ProximitySensor("success")
+
+        self.spawn_boundary = SpawnBoundary([Shape("boundary")])
+        self.target_drawer_joint = None
+
+        self.goal_conditions = []
+
+    def init_episode(self, index: int) -> List[str]:
+        for i in range(len(DRAWER_NAMES)):
+            if i == index:
+                self.drawer_joints[i].set_joint_position(0.21, disable_dynamics=True)
+            else:
+                self.drawer_joints[i].set_joint_position(0.0, disable_dynamics=True)
+
+        target_anchor = Dummy(f"waypoint_anchor_{DRAWER_NAMES[index]}")
+        waypoint0 = Dummy("waypoint0")
+        waypoint1 = Dummy("waypoint1")
+        waypoint6 = Dummy("waypoint6")
+        waypoint7 = Dummy("waypoint7")
+        waypoint8 = Dummy("waypoint8")
+
+        _, _, z = target_anchor.get_position()
+        x, y, _ = waypoint0.get_position()
+        waypoint0.set_position([x, y, z])
+
+        x, y, _ = waypoint1.get_position()
+        waypoint1.set_position([x, y, z])
+
+        x, y, _ = waypoint6.get_position()
+        waypoint6.set_position([x, y, z])
+
+        x, y, _ = waypoint7.get_position()
+        waypoint7.set_position([x, y, z])
+
+        x, y, _ = waypoint8.get_position()
+        waypoint8.set_position([x, y, z])
+
+        self.spawn_boundary.clear()
+        self.spawn_boundary.sample(self.button, min_distance=0.05)
+
+        self.goal_conditions = [
+            JointConditionEx(self.drawer_joints[index], 0.19),
+            JointConditionEx(self.button_joint, 0.003),
+            DetectedCondition(self.drawer_parts[index], self.detector),
+        ]
+        condition_set = ConditionSet(self.goal_conditions, True) # type: ignore
+        self.register_success_conditions([condition_set])
+
+        self.target_drawer_joint = self.drawer_joints[index]
+
+        return ['Close the opened drawer, push the button, and then open the previous drawer again']
+
+#    def step(self) -> None:
+#        #if self.target_drawer_joint:
+#        #    print(f"drawer_joint: {self.target_drawer_joint.get_joint_position()}")
+#
+#        if len(self.goal_conditions) < 1:
+#            return
+#
+#        met1, _ = self.goal_conditions[0].condition_met()
+#        print(f"first condition met: {met1}")
+#
+#        met2, _ = self.goal_conditions[1].condition_met()
+#        print(f"second condition met: {met2}")
+#
+#        met3, _ = self.goal_conditions[2].condition_met()
+#        print(f"second condition met: {met3}")
+
+    def variation_count(self) -> int:
+        return len(DRAWER_NAMES)
+
+    def is_static_workspace(self) -> bool:
+        return True