robowflex::darts Namespace Reference

DART-based robot modeling and planning. More...

Namespaces
	IO
	magic

Classes
class	ACM
	Allowable collision matrix for robowflex::darts::Structure. More...
class	Viewer
	Viewer class. More...
class	Window
	Open Scene Graph GUI for DART visualization. More...
class	Widget
	Abstract class for IMGUI Widget. More...
class	ImGuiElement
	Abstract GUI element. More...
class	TextElement
	A basic text element. More...
class	CheckboxElement
	A checkbox element that modifies a boolean. More...
class	ButtonElement
	A basic push-button element. More...
class	RenderElement
	Generic rendered element. Use callback to display whatever GUI elements needed. More...
class	LinePlotElement
	Line plot element. Displays an updated line graph of data. More...
class	WindowWidget
	IMGUI widget to add interactive GUI elements programmatically. More...
class	TSREditWidget
	IMGUI widget to design TSRs. More...
class	TSRSolveWidget
	Class for solving a set of TSRs. More...
class	Joint
	Abstract controllable joint for robowflex::darts::StateSpace. More...
class	RnJoint
	A real vector joint of n dimensions. More...
class	SO2Joint
	A SO(2) joint. Bounds are from -pi to pi, and wraps. More...
class	SO3Joint
	A SO(3) joint modeled with quaternions. More...
class	DARTPlanner
	Wrapper for easy access to DART planning tools via standard Robowflex interface. More...
class	ConstraintExtractor
	Helper class to manage extracting states from a possibly constrained state space. More...
class	TSRGoal
	A sampleable goal region for OMPL for a set of TSRs. Samples goals in a separate thread using a clone of the world. More...
class	JointRegionGoal
	A joint space goal volume. More...
class	PlanBuilder
	A helper class to setup common OMPL structures for planning. More...
class	Robot
	A sampleable goal region for OMPL for a set of TSRs. Samples goals in a separate thread using a clone of the world. More...
class	StateSpace
	An OMPL state space for robowflex::darts::World. Can do motion planning for any of the robots or structures in the world. More...
class	Structure
	Wrapper class for a dart::dynamics::Skeleton. More...
class	TSR
	A Task Space Region (TSR). TSRs are workspace regions that impose a constraints on a robot. They are composed of a pose (in some reference frame) and tolerances on position and rotation. initialize() must be called once all parameters are set. More...
class	TSRSet
	Manager for a set of TSR constraints. Attempts to reduce redundancy and combines errors and Jacobians together. More...
class	TSRConstraint
	An OMPL constraint for TSRs. Under the hood, creates a TSRSet that is used for all computation. Make sure that the robot state space has all groups setup before creation of this constraint. More...
class	DistanceCollisionWrapper
	A wrapper for the ACM to pass into signed distance computation. Returns based on if the objects would collide. More...
class	World
	Wrapper for a dart::simulation::World, which contains a set of skeletons (i.e., Robots and Structures). The World is the main object that is used by motion planning as it contains a holistic view of the scene. More...

Typedefs
using	ButtonCallback = std::function< void()>
	Callback function upon a button press. More...
using	RenderCallback = std::function< void()>
	Callback upon a render call. More...

Functions
std::string	generateUUID ()
	Generate a unique identifier. More...
RobotPtr	loadMoveItRobot (const std::string &name, const std::string &urdf, const std::string &srdf)
	Load a robot from a URDF and SRDF (i.e., a MoveIt enabled robot). More...
dart::dynamics::ShapePtr	makeGeometry (const GeometryPtr &geometry)
	Convert a robowflex::Geometry to a Dart Shape. More...
std::shared_ptr< dart::dynamics::BoxShape >	makeBox (const Eigen::Ref< const Eigen::Vector3d > &v)
	Create a box. More...
std::shared_ptr< dart::dynamics::BoxShape >	makeBox (double x, double y, double z)
	Create a box. More...
std::shared_ptr< dart::dynamics::CylinderShape >	makeCylinder (double radius, double height)
	Create a cylinder. More...
std::shared_ptr< dart::dynamics::SphereShape >	makeSphere (double radius)
	Create a sphere. More...
std::shared_ptr< dart::dynamics::MeshShape >	makeMesh (const GeometryPtr &geometry)
	Create a mesh from a robowflex::Geometry that contains a mesh. More...
std::shared_ptr< dart::dynamics::MeshShape >	makeArcsegment (double low, double high, double inner_radius, double outer_radius, std::size_t resolution=32)
	Create a circle's arcsector from one angle to another, with a specified radius. More...
void	setColor (dart::dynamics::BodyNode *node, const Eigen::Vector4d &color)
	Sets the color of the shapes on a body node. More...

Detailed Description

DART-based robot modeling and planning.

Typedef Documentation

ButtonCallback

using robowflex::darts::ButtonCallback = typedef std::function<void()>

Callback function upon a button press.

Definition at line 285 of file gui.h.

RenderCallback

using robowflex::darts::RenderCallback = typedef std::function<void()>

Callback upon a render call.

Definition at line 306 of file gui.h.

Function Documentation

generateUUID()

std::string robowflex::darts::generateUUID

(

)

Generate a unique identifier.

Returns

A random unique ID.

Definition at line 17 of file gui.cpp.

{
    boost::uuids::random_generator gen;
    boost::uuids::uuid u = gen();
    return boost::lexical_cast<std::string>(u);
}

loadMoveItRobot()

RobotPtr robowflex::darts::loadMoveItRobot	(	const std::string &	name,
		const std::string &	urdf,
		const std::string &	srdf
	)

Load a robot from a URDF and SRDF (i.e., a MoveIt enabled robot).

Parameters

[in]	name	Name of the robot.
[in]	urdf	URDF URI.
[in]	srdf	SRDF URI.

Returns

The loaded robot.

Definition at line 586 of file robowflex_dart/src/robot.cpp.

{
    auto robot = std::make_shared<Robot>(name);
    robot->loadURDF(urdf);
    robot->loadSRDF(srdf);
 
    return robot;
}

makeArcsegment()

std::shared_ptr< dart::dynamics::MeshShape > robowflex::darts::makeArcsegment	(	double	low,
		double	high,
		double	inner_radius,
		double	outer_radius,
		std::size_t	resolution = 32
	)

Create a circle's arcsector from one angle to another, with a specified radius.

Parameters

[in]	low	Lower bound, in radians.
[in]	high	Upper bound, in radians.
[in]	inner_radius	Inner segment radius.
[in]	outer_radius	Outer segment radius.
[in]	resolution	Number of segments.

Returns

The mesh shape.

Definition at line 419 of file structure.cpp.

{
    if (resolution < 1)
        throw std::runtime_error("Invalid resolution.");
 
    if (inner_radius > outer_radius)
        throw std::runtime_error("Invalid radii.");
 
    if (low > high)
        low = high;
 
    const double interval = high - low;
    const double step = interval / resolution;
 
    auto *mesh = new aiMesh;
    mesh->mMaterialIndex = (unsigned int)(-1);
 
    // number of segments, *2 for inner & outer, *2 for front & back
    const std::size_t n_seg = resolution + 1;
    const std::size_t n_v_face = n_seg * 2;
    const std::size_t n_vert = n_v_face * 2;
 
    const std::size_t n_face = resolution * 2;
 
    mesh->mNumVertices = n_vert;
    mesh->mVertices = new aiVector3D[n_vert];
    mesh->mNormals = new aiVector3D[n_vert];
    mesh->mColors[0] = new aiColor4D[n_vert];
 
    const double vx = 0;
    aiVector3D vertex;
 
    const aiVector3D fnormal(1.0f, 0.0f, 0.0f);
    const aiVector3D bnormal(-1.0f, 0.0f, 0.0f);
    const aiColor4D color(0.0f, 0.0f, 0.0f, 1.0f);
 
    // Vertices
    for (std::size_t i = 0; i <= resolution; ++i)
    {
        const double theta = low + step * i;
 
        // Inner Radius
        const double yi = inner_radius * std::cos(theta);
        const double zi = inner_radius * std::sin(theta);
        vertex.Set(vx, yi, zi);
 
        // front
        const std::size_t ifv = 2 * i;
        mesh->mVertices[ifv] = vertex;
        mesh->mNormals[ifv] = fnormal;
        mesh->mColors[0][ifv] = color;
 
        // back
        const std::size_t ibv = ifv + n_v_face;
        mesh->mVertices[ibv] = vertex;
        mesh->mNormals[ibv] = bnormal;
        mesh->mColors[0][ibv] = color;
 
        // Outer Radius
        const double yo = outer_radius * std::cos(theta);
        const double zo = outer_radius * std::sin(theta);
        vertex.Set(vx, yo, zo);
 
        // front
        const std::size_t ofv = ifv + 1;
        mesh->mVertices[ofv] = vertex;
        mesh->mNormals[ofv] = fnormal;
        mesh->mColors[0][ofv] = color;
 
        // back
        const std::size_t obv = ofv + n_v_face;
        mesh->mVertices[obv] = vertex;
        mesh->mNormals[obv] = bnormal;
        mesh->mColors[0][obv] = color;
    }
 
    mesh->mNumFaces = n_face;
    mesh->mFaces = new aiFace[n_face];
 
    // Faces
    for (std::size_t i = 1; i <= resolution; ++i)
    {
        // front
        const std::size_t ifv = 2 * i;
        const std::size_t ifvp = 2 * (i - 1);
        const std::size_t ofv = ifv + 1;
        const std::size_t ofvp = ifvp + 1;
 
        aiFace *fface = &mesh->mFaces[i - 1];
        fface->mNumIndices = 4;
        fface->mIndices = new unsigned int[4];
        fface->mIndices[0] = ifv;
        fface->mIndices[1] = ifvp;
        fface->mIndices[2] = ofvp;
        fface->mIndices[3] = ofv;
 
        // back
        const std::size_t ibv = ifv + n_v_face;
        const std::size_t ibvp = ifvp + n_v_face;
        const std::size_t obv = ofv + n_v_face;
        const std::size_t obvp = ofvp + n_v_face;
 
        aiFace *bface = &mesh->mFaces[i + resolution - 1];
        bface->mNumIndices = 4;
        bface->mIndices = new unsigned int[4];
        bface->mIndices[0] = obv;
        bface->mIndices[1] = obvp;
        bface->mIndices[2] = ibvp;
        bface->mIndices[3] = ibv;
    }
 
    auto *node = new aiNode;
    node->mNumMeshes = 1;
    node->mMeshes = new unsigned int[1];
    node->mMeshes[0] = 0;
 
    auto *scene = new aiScene;
    scene->mNumMeshes = 1;
    scene->mMeshes = new aiMesh *[1];
    scene->mMeshes[0] = mesh;
    scene->mRootNode = node;
 
    auto shape = std::make_shared<dart::dynamics::MeshShape>(Eigen::Vector3d::Ones(), scene);
    shape->setColorMode(dart::dynamics::MeshShape::SHAPE_COLOR);
 
    return shape;
}

makeBox() [1/2]

std::shared_ptr< dart::dynamics::BoxShape > robowflex::darts::makeBox

(

const Eigen::Ref< const Eigen::Vector3d > &

v

)

Create a box.

Parameters

[in]

v

Dimensions of the box.

Returns

The box shape.

Definition at line 370 of file structure.cpp.

{
    return std::make_shared<dart::dynamics::BoxShape>(v);
}

makeBox() [2/2]

std::shared_ptr< dart::dynamics::BoxShape > robowflex::darts::makeBox	(	double	x,
		double	y,
		double	z
	)

Create a box.

Parameters

[in]	x	X dimension of box.
[in]	y	Y dimension of box.
[in]	z	Z dimension of box.

Returns

The box shape.

Definition at line 375 of file structure.cpp.

{
    return makeBox(Eigen::Vector3d{x, y, z});
}

makeCylinder()

std::shared_ptr< dart::dynamics::CylinderShape > robowflex::darts::makeCylinder	(	double	radius,
		double	height
	)

Create a cylinder.

Parameters

[in]	radius	Radius of cylinder.
[in]	height	Height of the cylinder.

Returns

The cylinder shape.

Definition at line 380 of file structure.cpp.

{
    return std::make_shared<dart::dynamics::CylinderShape>(radius, height);
}

makeGeometry()

dart::dynamics::ShapePtr robowflex::darts::makeGeometry

(

const GeometryPtr &

geometry

)

Convert a robowflex::Geometry to a Dart Shape.

Parameters

[in]

geometry

Geometry to convert.

Returns

Shape from geometry.

Definition at line 348 of file structure.cpp.

{
    const auto &dimensions = geometry->getDimensions();
 
    switch (geometry->getType())
    {
        case Geometry::ShapeType::BOX:
            return makeBox(dimensions);
        case Geometry::ShapeType::SPHERE:
            return makeSphere(dimensions[0]);
        case Geometry::ShapeType::CYLINDER:
            return makeCylinder(dimensions[0], dimensions[1]);
        case Geometry::ShapeType::MESH:
            return makeMesh(geometry);
        default:
            break;
    }
 
    return nullptr;
}

makeMesh()

std::shared_ptr< dart::dynamics::MeshShape > robowflex::darts::makeMesh

(

const GeometryPtr &

geometry

)

Create a mesh from a robowflex::Geometry that contains a mesh.

Parameters

[in]

geometry

Geometry with a mesh to convert.

Returns

The mesh shape.

Definition at line 390 of file structure.cpp.

{
    std::string uri = geometry->getResource();
    Eigen::Vector3d dimensions = geometry->getDimensions();
 
    if (uri.empty())
    {
        const auto &temp_file_name = ".robowflex_tmp.stl";
 
        auto shape = std::dynamic_pointer_cast<shapes::Mesh>(geometry->getShape());
 
        std::vector<char> buffer;
        shapes::writeSTLBinary(shape.get(), buffer);
 
        std::ofstream out;
        out.open(temp_file_name, std::ofstream::out | std::ofstream::binary);
        out.write(buffer.data(), buffer.size());
        out.close();
 
        uri = temp_file_name;
    }
 
    const auto &file = robowflex::IO::resolvePackage(uri);
    const auto &aiscene = dart::dynamics::MeshShape::loadMesh(file);
 
    auto mesh = std::make_shared<dart::dynamics::MeshShape>(dimensions, aiscene);
    return mesh;
}

makeSphere()

std::shared_ptr< dart::dynamics::SphereShape > robowflex::darts::makeSphere

(

double

radius

)

Create a sphere.

Parameters

[in]

radius

Radius of sphere.

Returns

The sphere shape.

Definition at line 385 of file structure.cpp.

{
    return std::make_shared<dart::dynamics::SphereShape>(radius);
}

setColor()

void robowflex::darts::setColor	(	dart::dynamics::BodyNode *	node,
		const Eigen::Vector4d &	color
	)

Sets the color of the shapes on a body node.

Parameters

[in]	node	Node to set color of.
[in]	color	Color to set.

Definition at line 550 of file structure.cpp.

{
    for (const auto &shape : node->getShapeNodes())
        shape->getVisualAspect()->setColor(color);
}