def upsert_collision(model: Models,
pose: Pose,
mesh_parameters: Optional[MeshParameters] = None) -> None:
"""Adds arbitrary collision model to the collision scene.
:param model: Box, Sphere, Cylinder, Mesh
:param pose: Pose of the collision object.
:param mesh_parameters: Some additional parameters might be specified for mesh collision model.
:return:
Example usage:
>>> from arcor2.data.object_type import Box
>>> from arcor2.data.common import Pose, Position, Orientation
>>> box = Box("UniqueBoxId", 0.1, 0.1, 0.1)
>>> scene_service.upsert_collision(box, Pose(Position(1, 0, 0), Orientation(0, 0, 0, 1)))
"""
model_id = model.id
params = model.to_dict()
del params["id"]
params[model.__class__.__name__.lower() + "Id"] = model_id
if model.type() == Model3dType.MESH and mesh_parameters:
params.update(mesh_parameters.to_dict())
rest.call(rest.Method.PUT,
f"{URL}/collisions/{model.type().value.lower()}",
body=pose,
params=params)
def delete_notifications(self, *, an: Optional[str] = None) -> None:
"""Clears all notifications.
:return:
"""
rest.call(rest.Method.DELETE, f"{self.settings.url}/notifications")
def set_distance(
self,
velocity: float = 0.5,
distance: float = 0.55,
direction: Direction = Direction.FORWARD,
*,
an: Optional[str] = None,
) -> None:
"""Belt will move by given distance.
:param velocity:
:param distance:
:param direction:
:param an:
:return:
"""
assert 0.0 <= velocity <= 1.0
assert 0.0 <= distance <= 9999.0
rest.call(
rest.Method.PUT,
f"{self.settings.url}/conveyor/distance",
params={
"velocity": velocity * 100,
"distance": distance,
"direction": direction
},
)
def upload_file(file_id: str, file_content: bytes) -> None:
"""Uploads a file."""
rest.call(rest.Method.PUT,
f"{URL}/files/{file_id}",
files={"file": file_content})
assert file_id in files_ids()
def set_joints(
self,
joints: ProjectRobotJoints,
move_type: MoveTypeEnum,
speed: float = 0.5,
acceleration: float = 0.5,
safe: bool = True,
*,
an: Optional[str] = None,
) -> None:
assert 0.0 <= speed <= 1.0
assert 0.0 <= acceleration <= 1.0
url = f"{self.settings.url}/joints"
params = {
"moveType": move_type.value,
"speed": speed,
"acceleration": acceleration,
"safe": safe
}
with self._move_lock:
rest.call(rest.Method.PUT,
url,
body=joints.joints,
params=params,
timeout=self.move_timeout)
def move(
self,
pose: Pose,
move_type: MoveType,
velocity: float = 50.0,
acceleration: float = 50.0,
*,
an: Optional[str] = None,
) -> None:
"""Moves the robot's end-effector to a specific pose.
:param pose: Target pose.
:move_type: Move type.
:param velocity: Speed of move (percent).
:param acceleration: Acceleration of move (percent).
:return:
"""
assert 0.0 <= velocity <= 100.0
assert 0.0 <= acceleration <= 100.0
with self._move_lock:
rest.call(
rest.Method.PUT,
f"{self.settings.url}/eef/pose",
body=pose,
params={
"move_type": move_type,
"velocity": velocity,
"acceleration": acceleration
},
)
def delete_group(self, group_id: str, *, an: Optional[str] = None) -> None:
"""Deletes all tracked values stored in given group.
:param group_id:
:return:
"""
rest.call(rest.Method.DELETE, f"{self.settings.url}/values/{group_id}")
def upsert_transform(transform_id: str, parent: str, pose: Pose) -> None:
"""Add or updates transform."""
rest.call(rest.Method.PUT,
f"{URL}/transforms",
body=pose,
params={
"transformId": transform_id,
"parent": parent
})
def resolve_dialog(self, option: str, *, an: Optional[str] = None) -> None:
"""Resolves current dialog using one of the options.
:param option:
:return:
"""
rest.call(rest.Method.PUT,
f"{self.settings.url}/dialog/resolve",
params={"option": option})
def set_output(self,
output_id: str,
value: float,
*,
an: Optional[str] = None) -> None:
assert 0.0 <= value <= 1.0
rest.call(rest.Method.PUT,
f"{self.settings.url}/outputs/{output_id}",
params={"value": value})
def unlink(self, end_effector_id: str) -> None:
"""Unlinks collision object from end effector.
:param end_effector_id: Unique end-effector id.
:return:
"""
rest.call(
rest.Method.PUT,
f"{self.settings.url}/endEffectors/{end_effector_id}/unlink")
def _start(self, model: str) -> None:
if self._started():
self._stop()
rest.call(
rest.Method.PUT,
f"{self.settings.url}/state/start",
params={"model": model, "port": self.settings.port},
body=self.pose,
)
def link(self, end_effector_id: str, collision_id: str) -> None:
"""Links collision object to end effector.
:param end_effector_id: Unique end-effector id.
:param collision_id: Unique id of collision
:return:
"""
rest.call(
rest.Method.PUT,
f"{self.settings.url}/endEffectors/{end_effector_id}/link",
params={"collisionId": collision_id},
)
def set_search_parameters(self,
parameters: SearchEngineParameters,
*,
an: Optional[str] = None) -> None:
"""Sets the search parameters.
:param parameters:
:return:
"""
rest.call(rest.Method.PUT,
f"{self.settings.url}/search",
body=parameters)
def __init__(self, obj_id: str, name: str, pose: Pose,
settings: Settings) -> None:
super(AbstractRobot, self).__init__(obj_id, name, pose, settings)
rest.call(
rest.Method.PUT,
f"{self.settings.url}/system/set",
body=pose,
params={
"configId": self.settings.configuration_id,
"id": self.id
},
)
self.move_timeout = rest.Timeout(read=5 * 60)
def __init__(
self,
obj_id: str,
name: str,
pose: Pose,
collision_model: Optional[Models] = None,
settings: Optional[Settings] = None,
) -> None:
super(AbstractWithPose, self).__init__(obj_id, name, pose, collision_model, settings)
rest.call(
rest.Method.PUT,
f"{self.settings.url}/system/set",
body=pose,
params={"configId": self.settings.configuration_id, "id": self.id},
)
def is_item_attached(self,
suction_id: str,
*,
an: Optional[str] = None) -> bool:
return rest.call(rest.Method.GET,
f"{self.settings.url}/suctions/{suction_id}/attached",
return_type=bool)
def inverse_kinematics(
self,
end_effector_id: str,
pose: Pose,
start_joints: Optional[List[Joint]] = None,
avoid_collisions: bool = True,
) -> List[Joint]:
"""Computes inverse kinematics.
:param end_effector_id: IK target pose end-effector
:param pose: IK target pose
:param start_joints: IK start joints (if not provided, current joint values will be used)
:param avoid_collisions: Return non-collision IK result if true
:return: Inverse kinematics
"""
if start_joints is None:
start_joints = self.robot_joints()
body = IKPoseJointsParameters(pose, start_joints)
return rest.call(
rest.Method.PUT,
f"{self.settings.url}/endEffectors/{end_effector_id}/inverseKinematics",
params={"avoidCollisions": avoid_collisions},
body=body,
list_return_type=Joint,
)
def is_item_gripped(self,
gripper_id: str,
*,
an: Optional[str] = None) -> bool:
return rest.call(rest.Method.GET,
f"{self.settings.url}/grippers/{gripper_id}/gripped",
return_type=bool)
def estimate_camera_pose(camera: CameraParameters,
image: Image,
inverse: bool = False) -> EstimatedPose:
"""Returns camera pose with respect to the origin.
:param camera: Camera parameters.
:param image: Image.
:param inverse: When set, the method returns pose of the origin wrt. the camera.
:return:
"""
with BytesIO() as buff:
image.save(buff, format="PNG")
params = camera.to_dict()
params["inverse"] = inverse
try:
return rest.call(
rest.Method.PUT,
f"{CALIBRATION_URL}/calibrate/camera",
params=params,
return_type=EstimatedPose,
files={"image": buff.getvalue()},
)
except rest.RestException as e:
if isinstance(e, rest.RestHttpException) and e.error_code == 404:
raise MarkerNotFound(str(e)) from e
raise CalibrationException(str(e)) from e
def estimate_camera_pose(camera: CameraParameters,
image: Image,
inverse: bool = False) -> Pose:
"""Returns camera pose with respect to the origin.
:param camera: Camera parameters.
:param image: Image.
:param inverse: When set, the method returns pose of the origin wrt. the camera.
:return:
"""
with BytesIO() as buff:
image.save(buff, format="PNG")
params = camera.to_dict()
params["inverse"] = inverse
return rest.call(
rest.Method.PUT,
f"{CALIBRATION_URL}/calibrate/camera",
params=params,
return_type=Pose,
files={"image": buff.getvalue()},
)
def update_project_parameters(project_id: str,
parameters: List[ProjectParameter]) -> datetime:
return datetime.fromisoformat(
rest.call(rest.Method.GET,
f"{URL}/projects/{project_id}/parameters",
body=parameters,
return_type=str))
def add_dialog(self,
title: str,
content: str,
options: List[str],
*,
an: Optional[str] = None) -> str:
"""Creates dialog, block until operator selects one of the options.
:param title: Dialog title
:param content: Dialog content
:param options: Dialog options.
:return:
"""
return rest.call(
rest.Method.PUT,
f"{self.settings.url}/dialogs",
return_type=str,
params={
"title": title,
"content": content
},
body=options,
timeout=rest.Timeout(read=8 * 60 * 60),
)
def get_gripper_opening(self,
gripper_id: str,
*,
an: Optional[str] = None) -> float:
return rest.call(rest.Method.GET,
f"{self.settings.url}/grippers/{gripper_id}/opening",
return_type=float)
def update_project(project: Project) -> datetime:
assert project.id
return datetime.fromisoformat(
rest.call(rest.Method.PUT,
f"{URL}/project",
return_type=str,
body=project))
def update_object_type(object_type: ObjectType) -> datetime:
assert object_type.id
return datetime.fromisoformat(
rest.call(rest.Method.PUT,
f"{URL}/object_type",
body=object_type,
return_type=str))
def ready(self, *, an: Optional[str] = None) -> bool:
"""Determines whether the ICT Tester is open and ready to start
testing.
:return: True if ICT tester is ready; otherwise, false.
"""
return rest.call(rest.Method.GET, f"{self.settings.url}/tester/ready", return_type=bool)
def get_pose(self, *, an: Optional[str] = None) -> Pose:
"""Gets capture device pose in actual initialized spatial system space.
:return:
"""
return rest.call(rest.Method.GET,
f"{self.settings.url}/capture/pose",
return_type=Pose)
def files_ids() -> set[str]:
"""Gets IDs of stored files."""
ret_list = rest.call(rest.Method.GET, f"{URL}/files", list_return_type=str)
ret_set = set(ret_list)
assert len(ret_list) == len(
ret_set), f"There is a duplicate file ID in {ret_list}."
return ret_set
def move_relative_joints(
self,
end_effector_id: str,
joints: ProjectRobotJoints,
rel_pose: RelativePose,
move_type: MoveTypeEnum,
speed: float = 0.5,
acceleration: float = 0.5,
safe: bool = True,
*,
an: Optional[str] = None,
) -> None:
"""Moves the robot's end-effector relatively to specific joint values.
:param robot_id: Unique robot id.
:param end_effector_id: Unique end-effector id.
:param joints: Target joints.
:param rel_pose: Relative pose.
:param move_type: Type of move.
:param speed: Speed of move.
:param acceleration: Acceleration of move.
:param safe: When true, robot will consider its environment and avoid collisions.
:return:
"""
assert 0.0 <= speed <= 1.0
assert 0.0 <= acceleration <= 1.0
url = f"{self.settings.url}/endEffectors/{end_effector_id}/moveJointsRelative"
body = MoveRelativeJointsParameters(joints.joints, rel_pose.position,
rel_pose.orientation)
params = {
"moveType": move_type.value,
"speed": speed,
"acceleration": acceleration,
"safe": safe
}
with self._move_lock:
rest.call(rest.Method.PUT,
url,
body=body,
params=params,
timeout=self.move_timeout)
