THREE.js utility for exporting object trees as a URDF file.
npm install urdf-exporter
Utility for exporting a three.js object hierarchy as a URDF.
Exporting a model constructed from URDF classes like URDFLink and URDFJoint.
``js
import { URDFExporter } from 'urdf-exporter';
import { STLExporter } from 'three/examples/jsm/exporters/STLExporter.js';
let urdfModel;
// ... create a model using the URDF classes for export
const models = {};
const exporter = new URDFExporter();
exporter.processGeometryCallback = ( model, link ) => {
const name = ${ link.name }_mesh.stl;
models[ name ] = new STLExporter().parse( model );
return name;
};
urdfModel.updateMatrixWorld();
const urdf = exporter.parse( urdfModel );
// ... urdf content ready!
`
Converting an existing model to one made with the appropriate classes.
`js
import { URDFConverter, URDFRobot, URDFLink, URDFJoint, URDFVisual } from 'urdf-exporter';
let model;
// ... create or load a model
const convert = new URDFConverter();
converter.generateCallback = child => {
let result;
if ( child.linkData ) {
if ( child === model ) {
result = new URDFRobot();
result.robotName = 'my-robot-urdf';
} else {
result = new URDFLink();
}
result.name = child.linkData.name;
} else if ( child.jointData ) {
result = new URDFJoint();
result.name = child.jointData.name;
result.jointType = 'revolute';
result.limit.lower = - Math.PI / 2;
result.limit.upper = Math.PI / 2;
} else if ( child.isMesh ) {
result = new URDFVisual()
result.add( child.clone() );
} else {
result = new Group();
}
result.position.copy( child.position );
result.quaternion.copy( child.quaternion );
result.scale.copy( child.scale );
};
const urdfModel = converter.generate( model );
// ... urdf class hierarchy!
`
Utility class to enable convenient conversion from three.js objects to URDF classes for export.
`js`
generateCallback : ( object : Object3D ) => Object3D
Callback used for generating URDF class equivalents. The function is expected to return a cloned version of the provided mesh or a URDF class describing the analogous object. The returned object must be the child object that will have children added to it. The generator will then find the root parent to add to the previously processed object.
For example a custom three.js joint type could converted into a joint and link connection which can be run through the URDFExporter.
`js`
postprocessCallback : ( object : URDFRobot ) => void
A function that takes the generated URDF result to enable fixups and other types of postprocessing that might be needed.
`js`
generate( object : Object3D ) : URDFRobot
Traverses the given hierarchy and generates a converted URDF hierarchy.
`js`
indent = '\t' : string
The set of indentation characters to use.
`js`
processGeometryCallback : ( node : Object3D, link : URDFLink ) => string
The callback for to use when processing geometry. Geometry must be processed and cached in order to be exported. A file path is returned from the function.
`js`
parse( root : URDFRobot ) : string
Parses the object into a urdf file. Returns the URDF contents as a string. The hierarchy matrix world must be updated before calling this function.
Class containing values to export for joint limits.
`js`
upper = 0 : Number
`js`
lower = 0 : Number
`js`
velocity = 0 : Number
`js`
effort = 0 : Number
Class containing values for the link inertial frame.
`js`
position : Vector3
`js`
rotation : Euler
`js`
mass = 0 : Number
`js`
inertial : Matrix3
The upper triangular matrix is used to define the xx, yy, zz, xy, yz, and xz fields.
_extends THREE.Object3D_
When this field is encountered a new link is created in the URDF file.
`js`
inertial : URDFInertialFrame
_extends THREE.Object3D_
When this field is encountered a new joint is created in the URDF file.
`js`
jointType = 'fixed' : string
`js`
axis : Vector3
`js`
limit : URDFLimit
_extends URDFLink_
A class describing the root of the URDF Robot.
`js``
robotName = '' : string
_extends THREE.Object3D_
_extends THREE.Object3D_