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'