def data(self, data):
self.frame = Frame.from_data(data['frame'])
if 'gripping_frame' in data:
self.gripping_frame = Frame.from_data(data['gripping_frame'])
if '_source' in data:
self._source = _deserialize_from_data(data['_source'])
if 'trajectory' in data:
self.trajectory = [
JointTrajectoryPoint.from_data(d) for d in data['trajectory']
]
def trajectory_from_data(traj_data):
try:
return JointTrajectory.from_data(traj_data)
except AttributeError:
return [
Frame.from_data(frame_data) for frame_data in traj_data
]
def from_data(cls, data):
"""Construct a PrintPoint from its data representation.
Parameters
----------
data: dict
The data dictionary.
Returns
-------
layer
The constructed PrintPoint.
"""
pp = cls(pt=Point.from_data(data['point']),
layer_height=data['layer_height'],
mesh_normal=Vector.from_data(data['mesh_normal']))
pp.up_vector = Vector.from_data(data['up_vector'])
pp.frame = Frame.from_data(data['frame'])
pp.extruder_toggle = data['extruder_toggle']
pp.velocity = data['velocity']
pp.wait_time = data['wait_time']
pp.blend_radius = data['blend_radius']
pp.closest_support_pt = Point.from_data(data['closest_support_pt'])
pp.distance_to_support = data['distance_to_support']
pp.is_feasible = data['is_feasible']
pp.attributes = data['attributes']
return pp
def load_printpoints(path, folder_name, json_name):
""" Loads a dict of compas_slicer printpoints. """
data = load_json_file(path, folder_name, json_name)
# geometry data
points = []
frames = []
layer_heights = []
up_vectors = []
mesh_normals = []
closest_support = []
# fabrication related data
velocities = []
wait_times = []
blend_radiuses = []
extruder_toggles = []
if data:
for i in range(len(data)):
data_point = data[str(i)]
# geometry related data
point = rg.Point3d(data_point["point"][0], data_point["point"][1],
data_point["point"][2])
points.append(point)
compas_frame = Frame.from_data(data_point["frame"])
pt, x_axis, y_axis = compas_frame.point, compas_frame.xaxis, compas_frame.yaxis
frame = rs.PlaneFromFrame(pt, x_axis, y_axis)
frames.append(frame)
layer_heights.append(data_point["layer_height"])
v = data_point["up_vector"]
up_vector = rg.Vector3d(v[0], v[1], v[2])
up_vectors.append(up_vector)
v = data_point["mesh_normal"]
mesh_normal = rg.Vector3d(v[0], v[1], v[2])
mesh_normals.append(mesh_normal)
cp = data_point["closest_support_pt"]
if cp:
cp_pt = rg.Point3d(cp[0], cp[1], cp[2])
closest_support.append(cp_pt)
else:
closest_support.append(
point
) # in order to have the same number of points everywhere
# fabrication related data
velocities.append(data_point["velocity"])
wait_times.append(data_point["wait_time"])
blend_radiuses.append(data_point["blend_radius"])
extruder_toggles.append(data_point["extruder_toggle"])
return points, frames, layer_heights, up_vectors, mesh_normals, closest_support, velocities, wait_times, \
blend_radiuses, extruder_toggles
def data(self, data):
self.frame = Frame.from_data(data['frame'])
if '_tool_frame' in data:
self.tool_frame = Frame.from_data(data['_tool_frame'])
if '_source' in data:
self._source = _deserialize_from_data(data['_source'])
if '_mesh' in data:
#self._mesh = _deserialize_from_data(data['_mesh'])
self._mesh = Mesh.from_data(data['_mesh'])
if 'trajectory' in data:
from compas_fab.robots import JointTrajectory
self.trajectory = [
JointTrajectory.from_data(d) for d in data['trajectory']
]
#self.trajectory = _deserialize_from_data(data['trajectory'])
if 'path' in data:
self.path = [Frame.from_data(d) for d in data['path']]
def data(self, data):
self.frame = Frame.from_data(data['frame'])
self.radius = data['radius']
self.robot_vel = data['robot_vel']
self.is_constructed = data['is_constructed']
self.ext_state = data['ext_state']
self.ext_speed = data['ext_speed']
self.material_supply = data['material_supply']
def from_data(cls, data):
"""Construct a :class:`ClayBullet` instance from its data representation.
Parameters
----------
data : :obj:`dict`
The data dictionary.
Returns
-------
:class:`ClayBullet`
The constructed ClayBullet instance
"""
location = Frame.from_data(data.pop("_location"))
trajectory_to = []
for frame_data in data.pop("_trajectory_to"):
trajectory_to.append(Frame.from_data(frame_data))
trajectory_from = []
for frame_data in data.pop("_trajectory_from"):
trajectory_from.append(Frame.from_data(frame_data))
# To check for old attr name for id
if "bullet_id" in data.keys():
bullet_id = data.pop("bullet_id")
elif "id" in data.keys():
bullet_id = data.pop("id")
else:
bullet_id = None
# Take the rest of the dictionary
kwargs = data
return cls(
location,
trajectory_to=trajectory_to,
trajectory_from=trajectory_from,
bullet_id=bullet_id,
**kwargs
)
def data(self, data):
self.geometry = Geometry.from_data(data['geometry'])
self.origin = Frame.from_data(
data['origin']) if data['origin'] else None
self.name = data['name']
self.attr = _attr_from_data(data['attr'])
self.init_transformation = Transformation.from_data(
data['init_transformation']
) if data['init_transformation'] else None
self.current_transformation = Transformation.from_data(
data['current_transformation']
) if data['current_transformation'] else None
def data(self, data):
for _vkey, vdata in data['data']['node'].items():
vdata['node'] = Node.from_data(vdata['node'])
if 'is_constructed' in data:
self.is_constructed = _deserialize_from_data(data['data']['attributes']['is_constructed'])
if 'trajectory' in data:
self.trajectory = _deserialize_from_data(data['data']['attributes']['trajectory'])
if 'path' in data:
self.path = [Frame.from_data(d) for d in data['data']['attributes']['path']]
self.network = Network.from_data(data)
def from_data(cls, data):
"""TODO: Docstring for function.
Parameters
----------
data : :obj:`dict`
Returns
-------
:class:`PickStation`
"""
frames = [Frame.from_data(frame_data) for frame_data in data]
return cls(frames)
def from_data(cls, data):
"""TODO: Docstring for function.
Parameters
----------
arg1 : TODO
Returns
-------
TODO
"""
frames = [Frame.from_data(frame_data) for frame_data in data]
return cls(frames)
def from_data(cls, data):
"""Construct a :class:`ClayBullet` instance from its data representation.
Parameters
----------
data : :obj:`dict`
The data dictionary.
Returns
-------
:class:`ClayBullet`
The constructed ClayBullet instance
"""
def trajectory_from_data(traj_data):
try:
return JointTrajectory.from_data(traj_data)
except AttributeError:
return [
Frame.from_data(frame_data) for frame_data in traj_data
]
kwargs = {}
location = Frame.from_data(data.pop("location"))
trajectory_attributes = ("travel_trajectories", "place_trajectories",
"return_travel_trajectories_",
"return_place_trajectories_")
for key in trajectory_attributes:
trajectories_data = data.pop(key, None)
if trajectories_data:
keyword = re.sub(r"_$", "",
key) # Strip underscore from end of key
trajectories = []
for traj_data in trajectories_data:
trajectories.append(trajectory_from_data(traj_data))
kwargs[keyword] = trajectories
# merge kwargs with data
kwargs.update(data)
return cls(location, **kwargs)
def data(self, data):
self.name = data['name']
self.type = Joint.SUPPORTED_TYPES.index(data['type'])
self.parent = ParentLink.from_data(data['parent'])
self.child = ChildLink.from_data(data['child'])
self.origin = Frame.from_data(
data['origin']) if data['origin'] else None
self.axis = Axis.from_data(data['axis']) if data['axis'] else None
self.calibration = Calibration.from_data(
data['calibration']) if data['calibration'] else None
self.dynamics = Dynamics.from_data(
data['dynamics']) if data['dynamics'] else None
self.limit = Limit.from_data(data['limit']) if data['limit'] else None
self.safety_controller = SafetyController.from_data(
data['safety_controller']) if data['safety_controller'] else None
self.mimic = Mimic.from_data(data['mimic']) if data['mimic'] else None
self.attr = _attr_from_data(data['attr'])
self.position = data['position']
def from_data(cls, data):
"""Construct a box from its data representation.
Parameters
----------
data : :obj:`dict`
The data dictionary.
Returns
-------
Box
The constructed box.
Examples
--------
>>> data = {'frame': Frame.worldXY().data, 'xsize': 1.0, 'ysize': 1.0, 'zsize': 1.0}
>>> box = Box.from_data(data)
"""
return cls(Frame.from_data(data['frame']), data['xsize'], data['ysize'], data['zsize'])
def from_data(cls, data):
"""Construct a :class:`MinimalTrajectory` from a dictionary representation.
Parameters
----------
data : :obj:`dict`
The data dictionary.
Returns
-------
:class:`MinimalTrajectory`
"""
if data[0].get("xaxis"): # check if data is of frame.data
return cls([Frame.from_data(d) for d in data])
# check if first elem is JointTrajectoryPoint dict
if data[0].get("types"):
return cls([JointTrajectoryPoint.from_data(d) for d in data])
raise NotImplementedError(
"from_data method not implemented for {}".format(type(data[0])))
def data(self, data):
self.frame = Frame.from_data(data['frame'])
self.xsize = data['xsize']
self.ysize = data['ysize']
self.zsize = data['zsize']
def _set_data(self, data):
super(ToolModel, self)._set_data(data)
self.frame = Frame.from_data(data['frame'])
self.name = self.name or 'attached_tool'
self.link_name = data['link_name'] if 'link_name' in data else None
# create Assembly with element at target_frame
assembly = Assembly()
T = Transformation.from_frame_to_frame(element.frame, target_frame)
assembly.add_element(element.transformed(T))
# Bring the element's mesh into the robot's tool0 frame
element_tool0 = element.copy()
T = Transformation.from_frame_to_frame(element_tool0.gripping_frame,
tool.frame)
element_tool0.transform(T)
# define picking_configuration
picking_configuration = Configuration.from_data(data['picking_configuration'])
# define picking frame
picking_frame = Frame.from_data(data['picking_frame'])
picking_frame.point += tolerance_vector
# define savelevel frames 'above' the picking- and target frames
savelevel_picking_frame = picking_frame.copy()
savelevel_picking_frame.point += savelevel_vector
savelevel_target_frame = target_frame.copy()
savelevel_target_frame.point += savelevel_vector
# settings for plan_motion
tolerance_position = 0.001
tolerance_axes = [math.radians(1)] * 3
with RosClient('localhost') as client:
robot = client.load_robot()
scene = PlanningScene(robot)
def data(self, data_obj):
self.id = data_obj['id']
self.mesh = Mesh.from_data(data_obj['mesh'])
self.frame = Frame.from_data(data_obj['frame'])
self.root_name = data_obj['root_name']
def local_executor(cls, options, host='127.0.0.1', port=19997):
with VrepClient(debug=options.get('debug', True), host=host, port=port) as client:
active_robot_options = None
# Setup all robots' start state
for r in options['robots']:
robot = Robot(r['robot'], client)
if 'start' in r:
if r['start'].get('joint_values'):
start = Configuration.from_data(r['start'])
elif r['start'].get('values'):
start = Frame.from_data(r['start'])
try:
reachable_state = client.inverse_kinematics(robot, start, metric_values=[0.] * robot.dof, max_trials=1, max_results=1)
start = reachable_state[-1]
LOG.info('Robot state found for start pose. External axes=%s, Joint values=%s', str(start.external_axes), str(start.joint_values))
except VrepError:
raise ValueError('Start plane is not reachable: %s' % str(r['start']))
client.set_robot_config(robot, start)
if 'building_member' in r:
client.add_building_member(robot, Mesh.from_data(r['building_member']))
if 'goal' in r:
active_robot_options = r
# Set global scene options
if 'collision_meshes' in options:
client.add_meshes(map(Mesh.from_data, options['collision_meshes']))
# Check if there's at least one active robot (i.e. one with a goal defined)
if active_robot_options:
robot = Robot(active_robot_options['robot'], client)
if active_robot_options['goal'].get('values'):
goal = Pose.from_data(active_robot_options['goal'])
else:
raise ValueError('Unsupported goal type: %s' % str(active_robot_options['goal']))
kwargs = {}
kwargs['metric_values'] = active_robot_options.get('metric_values')
kwargs['planner_id'] = options.get('planner_id')
kwargs['resolution'] = options.get('resolution')
if 'joint_limits' in active_robot_options:
joint_limits = active_robot_options['joint_limits']
if joint_limits.get('gantry'):
kwargs['gantry_joint_limits'] = [item for sublist in joint_limits.get('gantry') for item in sublist]
if joint_limits.get('arm'):
kwargs['arm_joint_limits'] = [item for sublist in joint_limits.get('arm') for item in sublist]
kwargs['trials'] = options.get('trials')
kwargs['shallow_state_search'] = options.get('shallow_state_search')
kwargs['optimize_path_length'] = options.get('optimize_path_length')
# Filter None values
kwargs = {k: v for k, v in kwargs.iteritems() if v is not None}
path = client.plan_motion(robot, goal, **kwargs)
LOG.info('Found path of %d steps', len(path))
else:
robot = Robot(options['robots'][0]['robot'], client)
path = [client.get_robot_config(robot)]
return path
def data(self, data):
self.origin = Frame.from_data(
data['origin']) if data['origin'] else None
self.mass = Mass.from_data(data['mass']) if data['mass'] else None
self.inertia = Inertia.from_data(
data['inertia']) if data['inertia'] else None
def data(self, data):
self.visual = Mesh.from_data(data['visual'])
self.frame = Frame.from_data(data['frame'])
self.collision = Mesh.from_data(
data['collision']) if 'collision' in data else None
self.name = data['name'] if 'name' in data else 'attached_tool'
