robowflex_visualization.robot.Robot Class Reference

Controllable URDF described robot. More...

Public Member Functions
def	__init__ (self, name, urdf, make_pretty=True)
	Constructor. More...
def	load_urdf (self, urdf, load=True)
	Loads the URDF as a COLLADA mesh, as well as loading the XML. More...
def	get_link (self, link_name)
	Gets a Blender object corresponding to a link on the robot. More...
def	get_link_xml (self, link_name)
	Get the XML description in the URDF of a link. More...
def	get_joint_xml (self, joint_name)
	Get the XML description in the URDF of a joint. More...
def	set_joint (self, joint_name, value, interpolate=True)
	Set the value of a 1-DoF joint in the URDF. More...
def	set_joint_tf (self, joint_name, tf, interpolate=True)
	Set the value of a 6-DoF joint in the URDF. More...
def	add_keyframe (self, joint_name, frame)
	Adds a keyframe to a joint in the URDF at a frame in the animation timeline. More...
def	animate_path (self, path_file, fps=60., start=30, reverse=False, interpolate=False)
	Adds keyframes to animate a moveit_msgs::RobotTrajectoryMsg. More...
def	set_state (self, state_file)
	Sets the robot's state from a file with a moveit_msgs::RobotState. More...
def	attach_object (self, link_name, item, frame)
	Attaches an object to a link of the robot. More...
def	detach_object (self, link_name, item, frame)
	Detaches an object to a link of the robot. More...
def	prettify (self)
	Cleans up robot mesh geometry and applies modifiers to improve rendering aesthetics. More...
def	load_link_mesh (self, link_name)
	Loads the mesh data for a specific link on the robot. More...
def	clear_animation_data (self)
	Clear all animation data for this robot. More...
def	get_root (self)
	Get the root link of this robot. More...

Public Attributes
	name
	Name of Robot and Blender collection. More...
	collection
	Blender collection containing loaded robot geometry. More...
	urdf_path
	urdf_xml
	robot
	Parsed URDF file. More...

Detailed Description

Controllable URDF described robot.

This class loads a URDF from the package resource URI under a Blender collection.

Definition at line 18 of file robot.py.

Constructor & Destructor Documentation

__init__()

def robowflex_visualization.robot.Robot.__init__	(		self,
			name,
			urdf,
			make_pretty = True
	)

Constructor.

Loads robot and creates a collection.

Parameters

name	Name of Blender collection to put Robot geometry in.
urdf	URDF package resource URI to load.
make_pretty	Calls prettify functions after load.

Definition at line 36 of file robot.py.

    def __init__(self, name, urdf, make_pretty = True):
        self.name = name
 
        self.collection = rv.utils.get_collection(name)
        if not self.collection:
            self.collection = rv.utils.make_collection(name)
            self.load_urdf(urdf)
            if make_pretty:
                self.prettify()
 
        else:
            self.load_urdf(urdf, False)
 
        self.clear_animation_data()
 

Member Function Documentation

add_keyframe()

def robowflex_visualization.robot.Robot.add_keyframe	(		self,
			joint_name,
			frame
	)

Adds a keyframe to a joint in the URDF at a frame in the animation timeline.

Adds keyframe actually to child link (same as set_joint()). Uses current transform of the link. Only keyframes important data path for the joint (e.g., rotation for rotation joints).

Parameters

joint_name	Joint to add keyframe to.
frame	Frame to add keyframe at.

Definition at line 212 of file robot.py.

    def add_keyframe(self, joint_name, frame):
        if joint_name == "virtual_joint":
            root = self.get_root().name
            link_xml = self.get_link_xml(root)
            link = self.get_link(root)
        else:
            joint_xml = self.get_joint_xml(joint_name)
            link_xml = self.get_link_xml(joint_xml.child)
            link = self.get_link(joint_xml.child)
 
        link.keyframe_insert(data_path = "location", frame = frame)
        link.keyframe_insert(data_path = "rotation_quaternion", frame = frame)
 

animate_path()

def robowflex_visualization.robot.Robot.animate_path	(		self,
			path_file,
			fps = 60.,
			start = 30,
			reverse = False,
			interpolate = False
	)

Adds keyframes to animate a moveit_msgs::RobotTrajectoryMsg.

Parameters

path_file	YAML file for moveit_msgs::RobotTrajectoryMsg.
fps	Frames-per-second to animate the path at.
start	Frame to begin the animation at.
reverse	If true, load path from end-to-start rather than start-to-end.
interpolate	If true, interpolates quaternion from previous state.

Definition at line 233 of file robot.py.

                     interpolate = False):
        path = rv.utils.read_YAML_data(path_file)
 
        trajectory = path["joint_trajectory"]
        names = trajectory["joint_names"]
 
        if "multi_dof_joint_trajectory" in path:
            mdof_trajectory = path["multi_dof_joint_trajectory"]
            mdof_names = mdof_trajectory["joint_names"]
 
        last_time = float(trajectory["points"][-1]["time_from_start"])
        last_frame = start
 
        # Add keyframe at start
        for name in names:
            self.add_keyframe(name, start)
 
        for i in range(len(trajectory["points"])):
            point = trajectory["points"][i]
 
            time = float(point["time_from_start"])
            if reverse:
                time = last_time - time
 
            frame = start + time * fps
            if frame > last_frame:
                last_frame = frame
 
            for value, name in zip(point["positions"], names):
                self.set_joint(name, value, interpolate or i > 0)
                self.add_keyframe(name, frame)
 
            if "multi_dof_joint_trajectory" in path:
                mdof_point = mdof_trajectory["points"][i]
                for tf, name in zip(mdof_point["transforms"], mdof_names):
                    self.set_joint_tf(name, tf, interpolate or i > 0)
                    self.add_keyframe(name, frame)
 
        return math.ceil(last_frame)
 

attach_object()

def robowflex_visualization.robot.Robot.attach_object	(		self,
			link_name,
			item,
			frame
	)

Attaches an object to a link of the robot.

Parameters

link_name	Name of link to attach item to.
item	Blender object to attach to link.
frame	Animation frame to parent in.

Definition at line 297 of file robot.py.

    def attach_object(self, link_name, item, frame):
        rv.utils.parent_object(self.get_link(link_name), item, frame)
 

clear_animation_data()

def robowflex_visualization.robot.Robot.clear_animation_data

(

self

)

Clear all animation data for this robot.

Definition at line 361 of file robot.py.

    def clear_animation_data(self):
        for link_xml in self.robot.links:
            link = self.get_link(link_xml.name)
            if link:
                link.animation_data_clear()
 

detach_object()

def robowflex_visualization.robot.Robot.detach_object	(		self,
			link_name,
			item,
			frame
	)

Detaches an object to a link of the robot.

Object must have been previously parented.

Parameters

link_name	Name of link to attach item to.
item	Blender object to attach to link.
frame	Animation frame to parent in.

Definition at line 307 of file robot.py.

    def detach_object(self, link_name, item, frame):
        rv.utils.unparent_object(self.get_link(link_name), item, frame)
 

get_joint_xml()

def robowflex_visualization.robot.Robot.get_joint_xml	(		self,
			joint_name
	)

Get the XML description in the URDF of a joint.

Parameters

joint_name

Name of the joint to find in the robot.

Definition at line 113 of file robot.py.

    def get_joint_xml(self, joint_name):
        for joint in self.robot.joints:
            if joint.name == joint_name:
                return joint
 
        return None
 

get_link()

def robowflex_visualization.robot.Robot.get_link	(		self,
			link_name
	)

Gets a Blender object corresponding to a link on the robot.

Parameters

link_name

Name of the link to find in the robot.

Definition at line 95 of file robot.py.

    def get_link(self, link_name):
        return rv.utils.find_object_in_collection(self.name, link_name)
 

get_link_xml()

def robowflex_visualization.robot.Robot.get_link_xml	(		self,
			link_name
	)

Get the XML description in the URDF of a link.

Parameters

link_name

Name of the link to find in the robot.

Definition at line 102 of file robot.py.

    def get_link_xml(self, link_name):
        for link in self.robot.links:
            if link.name == link_name:
                return link
 
        return None
 

get_root()

def robowflex_visualization.robot.Robot.get_root

(

self

)

Get the root link of this robot.

Definition at line 368 of file robot.py.

    def get_root(self):
        children = []
        for joint in self.robot.joints:
            xml = self.get_joint_xml(joint.name)
            children.append(xml.child)
 
        for link in self.robot.links:
            if link.name not in children:
                return link

load_link_mesh()

def robowflex_visualization.robot.Robot.load_link_mesh	(		self,
			link_name
	)

Loads the mesh data for a specific link on the robot.

If the mesh is originally a COLLADA mesh, loads and replaces current mesh data. This provides better textures if they exist, as collada_urdf does not preserve them when converting the robot.

Parameters

link_name

Name of the link to the load the mesh for.

Definition at line 332 of file robot.py.

    def load_link_mesh(self, link_name):
        link_xml = self.get_link_xml(link_name)
 
        name = self.name + "_temp"
        collection = rv.utils.make_collection(name)
 
        if link_xml.visuals:
            visual = link_xml.visuals[0]
            geometry = visual.geometry
 
            # Only replace geometry if COLLADA
            if hasattr(geometry, 'filename') and ".dae" in geometry.filename:
                meshes, top = rv.primitives.add_mesh(
                    {"resource": geometry.filename})
 
                rv.utils.deselect_all()
                bpy.context.view_layer.objects.active = meshes[0]
                for mesh in meshes:
                    mesh.select_set(True)
                bpy.ops.object.join()
                rv.utils.move_selected_to_collection(name)
                rv.utils.deselect_all()
 
                old = self.get_link(link_name)
                old.data = meshes[0].data
 
        rv.utils.remove_collection(name)
 

load_urdf()

def robowflex_visualization.robot.Robot.load_urdf	(		self,
			urdf,
			load = True
	)

Loads the URDF as a COLLADA mesh, as well as loading the XML.

Parameters

urdf	URDF package resource URI to load.
load	Load the actual COLLADA mesh, not just URDF info.

Definition at line 56 of file robot.py.

    def load_urdf(self, urdf, load = True):
        self.urdf_path = rv.utils.resolve_path(urdf)
        xml_output = os.path.join("/tmp",
                                  os.path.basename(self.urdf_path) + ".xml")
        dae_output = os.path.join("/tmp",
                                  os.path.basename(self.urdf_path) + ".dae")
 
        subprocess.check_output([
            "rosrun",
            "xacro",
            "xacro",
            self.urdf_path,
            "-o",
            xml_output,
        ])
 
        self.urdf_xml = open(xml_output, 'r').read()
        self.robot = URDF.Robot.from_xml_string(self.urdf_xml)
 
        if load:
            # Don't regenerate URDF COLLADA if it already exists.
            if not os.path.exists(dae_output):
                subprocess.check_output([
                    "rosrun",
                    "collada_urdf",
                    "urdf_to_collada",
                    xml_output,
                    dae_output,
                ])
 
            # Import and move into new collection.
            bpy.ops.wm.collada_import(filepath = dae_output)
            rv.utils.move_selected_to_collection(self.name)
            rv.utils.deselect_all()
 

prettify()

def robowflex_visualization.robot.Robot.prettify

(

self

)

Cleans up robot mesh geometry and applies modifiers to improve rendering aesthetics.

Definition at line 313 of file robot.py.

    def prettify(self):
        for link_xml in self.robot.links:
            # Loads original mesh.
            self.load_link_mesh(link_xml.name)
 
            link = self.get_link(link_xml.name)
            rv.utils.remove_doubles(link)
            # rv.utils.remove_inner_faces(link)
            rv.utils.apply_edge_split(link)
            rv.utils.apply_smooth_shade(link)
 

set_joint()

def robowflex_visualization.robot.Robot.set_joint	(		self,
			joint_name,
			value,
			interpolate = True
	)

Set the value of a 1-DoF joint in the URDF.

Works by finding the child link of the joint and setting its relative transformation in Blender according to the axis of movement. Basically reimplementing forward kinematics.

Parameters

joint_name	Name of the joint to set in the robot.
value	Value of joint to set.
interpolate	If true, will attempt to make quaternions compatible with current pose.

Definition at line 131 of file robot.py.

    def set_joint(self, joint_name, value, interpolate = True):
        joint_xml = self.get_joint_xml(joint_name)
        parent_xml = self.get_link_xml(joint_xml.parent)
        link_xml = self.get_link_xml(joint_xml.child)
        link = self.get_link(joint_xml.child)
 
        link.rotation_mode = "QUATERNION"
 
        parent_l = mathutils.Matrix.Identity(4)
        if parent_xml.visual:
            parent_l = rv.utils.get_tf_origin_xml(parent_xml.visual)
            parent_l = parent_l.inverted()
 
        origin_l = mathutils.Matrix.Identity(4)
        if link_xml.visual:
            origin_l = rv.utils.get_tf_origin_xml(link_xml.visual)
 
        origin_j = rv.utils.get_tf_origin_xml(joint_xml)
 
        if joint_xml.type == "prismatic":
            rm = mathutils.Matrix.Translation(
                mathutils.Vector(joint_xml.axis) * value)
 
        else:
            rotation = mathutils.Quaternion(joint_xml.axis, value)
            rm = rotation.to_matrix()
            rm.resize_4x4()
 
        output = parent_l @ origin_j @ rm @ origin_l
 
        prior = link.rotation_quaternion.copy()
 
        link.location = output.to_translation()
        link.rotation_quaternion = output.to_quaternion()
 
        if interpolate:
            link.rotation_quaternion.make_compatible(prior)
 

set_joint_tf()

def robowflex_visualization.robot.Robot.set_joint_tf	(		self,
			joint_name,
			tf,
			interpolate = True
	)

Set the value of a 6-DoF joint in the URDF.

Assumes input transform is of the form: { 'translation' : [x, y, z], 'rotation' : [x, y, z, w] }

Parameters

joint_name	Name of the joint to set in the robot.
tf	YAML of the transform.
interpolate	If true, will attempt to make quaternions compatible with current pose.

Definition at line 182 of file robot.py.

    def set_joint_tf(self, joint_name, tf, interpolate = True):
        # Check for "virtual_joint", which isn't in the URDF
        if joint_name == "virtual_joint":
            root = self.get_root().name
            link_xml = self.get_link_xml(root)
            link = self.get_link(root)
        else:
            joint_xml = self.get_joint_xml(joint_name)
            link_xml = self.get_link_xml(joint_xml.child)
            link = self.get_link(joint_xml.child)
 
        link.rotation_mode = "QUATERNION"
        link.location = tf['translation']
 
        q = mathutils.Quaternion([tf['rotation'][3]] + tf['rotation'][:3])
        if interpolate:
            q.make_compatible(link.rotation_quaternion)
 
        link.rotation_quaternion = q
 

set_state()

def robowflex_visualization.robot.Robot.set_state	(		self,
			state_file
	)

Sets the robot's state from a file with a moveit_msgs::RobotState.

Parameters

state_file

File containing the state.

Definition at line 281 of file robot.py.

    def set_state(self, state_file):
        state = rv.utils.read_YAML_data(state_file)
        joint_state = state["joint_state"]
 
        names = joint_state["name"]
        position = joint_state["position"]
 
        for name, value in zip(names, position):
            self.set_joint(name, value)
 

Member Data Documentation

collection

robowflex_visualization.robot.Robot.collection

Blender collection containing loaded robot geometry.

Definition at line 39 of file robot.py.

name

robowflex_visualization.robot.Robot.name

Name of Robot and Blender collection.

Definition at line 37 of file robot.py.

robot

robowflex_visualization.robot.Robot.robot

Parsed URDF file.

Definition at line 73 of file robot.py.

urdf_path

robowflex_visualization.robot.Robot.urdf_path

Definition at line 57 of file robot.py.

urdf_xml

robowflex_visualization.robot.Robot.urdf_xml

Definition at line 72 of file robot.py.

---

The documentation for this class was generated from the following file:

• robot.py