openrave.org

 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
Classes | Namespaces | Macros | Typedefs | Enumerations | Functions | Variables
openrave.h File Reference

Defines the public headers that every plugin must include in order to use openrave properly. More...

#include <cstdio>
#include <stdarg.h>
#include <cstring>
#include <cstdlib>
#include <stdint.h>
#include <string>
#include <vector>
#include <list>
#include <map>
#include <set>
#include <exception>
#include <iomanip>
#include <fstream>
#include <sstream>
#include <boost/function.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/weak_ptr.hpp>
#include <boost/tuple/tuple.hpp>
#include <boost/enable_shared_from_this.hpp>
#include <boost/thread/mutex.hpp>
#include <boost/thread/thread.hpp>
#include <boost/thread/recursive_mutex.hpp>
#include <boost/static_assert.hpp>
#include <boost/format.hpp>
#include <boost/array.hpp>
#include <boost/multi_array.hpp>
#include <openrave/config.h>
#include <openrave/interfacehashes.h>
#include <openrave/geometry.h>
#include <openrave/mathextra.h>
#include <openrave/plugininfo.h>
#include <openrave/interface.h>
#include <openrave/spacesampler.h>
#include <openrave/kinbody.h>
#include <openrave/trajectory.h>
#include <openrave/module.h>
#include <openrave/collisionchecker.h>
#include <openrave/sensor.h>
#include <openrave/robot.h>
#include <openrave/iksolver.h>
#include <openrave/planner.h>
#include <openrave/controller.h>
#include <openrave/physicsengine.h>
#include <openrave/sensorsystem.h>
#include <openrave/viewer.h>
#include <openrave/environment.h>
Include dependency graph for openrave.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes

class  OpenRAVE::openrave_exception
 Exception that all OpenRAVE internal methods throw; the error codes are held in OpenRAVEErrorCode. More...
 
class  OpenRAVE::CaseInsensitiveCompare
 
class  OpenRAVE::UserData
 base class for all user data More...
 
class  OpenRAVE::SerializableData
 user data that can serialize/deserialize itself More...
 
class  OpenRAVE::XMLReadable
 base class for readable interfaces More...
 
class  OpenRAVE::BaseXMLReader
 base class for all xml readers. XMLReaders are used to process data from xml files. More...
 
class  OpenRAVE::DummyXMLReader
 reads until the tag ends More...
 
class  OpenRAVE::BaseXMLWriter
 base class for writing to XML files. More...
 
class  OpenRAVE::ConfigurationSpecification
 A configuration specification references values in the environment that then define a configuration-space which can be searched for. More...
 
class  OpenRAVE::ConfigurationSpecification::Group
 A group referencing the values of one body in the environment. More...
 
class  OpenRAVE::ConfigurationSpecification::Reader
 
class  OpenRAVE::IkParameterization
 Parameterization of basic primitives for querying inverse-kinematics solutions. More...
 

Namespaces

namespace  OpenRAVE
 The entire OpenRAVE library.
 
namespace  boost
 Modifications controlling boost library behavior.
 

Macros

#define BOOST_ENABLE_ASSERT_HANDLER
 
#define RAVE_DEPRECATED
 
#define g_fEpsilon   2e-7f
 
#define OPENRAVECOLOR_FATALLEVEL   5
 
#define OPENRAVECOLOR_ERRORLEVEL   1
 
#define OPENRAVECOLOR_WARNLEVEL   3
 
#define OPENRAVECOLOR_INFOLEVEL   0
 
#define OPENRAVECOLOR_DEBUGLEVEL   2
 
#define OPENRAVECOLOR_VERBOSELEVEL   4
 
#define DefineRavePrintfW(LEVEL)
 
#define DefineRavePrintfA(LEVEL)
 
#define RAVEPRINTHEADER(LEVEL)   OpenRAVE::RavePrintfA ## LEVEL("[%s:%d] ", OpenRAVE::RaveGetSourceFilename(__FILE__), __LINE__)
 
#define RAVELOG_LEVELW(LEVEL, level)   int(OpenRAVE::RaveGetDebugLevel()&OpenRAVE::Level_OutputMask)>=int(level)&&(RAVEPRINTHEADER(LEVEL)>0)&&OpenRAVE::RavePrintfW ## LEVEL
 
#define RAVELOG_LEVELA(LEVEL, level)   int(OpenRAVE::RaveGetDebugLevel()&OpenRAVE::Level_OutputMask)>=int(level)&&(RAVEPRINTHEADER(LEVEL)>0)&&OpenRAVE::RavePrintfA ## LEVEL
 
#define RAVELOG_FATALW   RAVELOG_LEVELW(_FATALLEVEL,OpenRAVE::Level_Fatal)
 
#define RAVELOG_FATALA   RAVELOG_LEVELA(_FATALLEVEL,OpenRAVE::Level_Fatal)
 
#define RAVELOG_FATAL   RAVELOG_FATALA
 
#define RAVELOG_ERRORW   RAVELOG_LEVELW(_ERRORLEVEL,OpenRAVE::Level_Error)
 
#define RAVELOG_ERRORA   RAVELOG_LEVELA(_ERRORLEVEL,OpenRAVE::Level_Error)
 
#define RAVELOG_ERROR   RAVELOG_ERRORA
 
#define RAVELOG_WARNW   RAVELOG_LEVELW(_WARNLEVEL,OpenRAVE::Level_Warn)
 
#define RAVELOG_WARNA   RAVELOG_LEVELA(_WARNLEVEL,OpenRAVE::Level_Warn)
 
#define RAVELOG_WARN   RAVELOG_WARNA
 
#define RAVELOG_INFOW   RAVELOG_LEVELW(_INFOLEVEL,OpenRAVE::Level_Info)
 
#define RAVELOG_INFOA   RAVELOG_LEVELA(_INFOLEVEL,OpenRAVE::Level_Info)
 
#define RAVELOG_INFO   RAVELOG_INFOA
 
#define RAVELOG_DEBUGW   RAVELOG_LEVELW(_DEBUGLEVEL,OpenRAVE::Level_Debug)
 
#define RAVELOG_DEBUGA   RAVELOG_LEVELA(_DEBUGLEVEL,OpenRAVE::Level_Debug)
 
#define RAVELOG_DEBUG   RAVELOG_DEBUGA
 
#define RAVELOG_VERBOSEW   RAVELOG_LEVELW(_VERBOSELEVEL,OpenRAVE::Level_Verbose)
 
#define RAVELOG_VERBOSEA   RAVELOG_LEVELA(_VERBOSELEVEL,OpenRAVE::Level_Verbose)
 
#define RAVELOG_VERBOSE   RAVELOG_VERBOSEA
 
#define IS_DEBUGLEVEL(level)   ((OpenRAVE::RaveGetDebugLevel()&OpenRAVE::Level_OutputMask)>=(level))
 
#define OPENRAVE_EXCEPTION_FORMAT0(s, errorcode)   OpenRAVE::openrave_exception(boost::str(boost::format("[%s:%d] " s)%(__PRETTY_FUNCTION__)%(__LINE__)),errorcode)
 
#define OPENRAVE_EXCEPTION_FORMAT(s, args, errorcode)   OpenRAVE::openrave_exception(boost::str(boost::format("[%s:%d] " s)%(__PRETTY_FUNCTION__)%(__LINE__)%args),errorcode)
 
#define OPENRAVE_ASSERT_FORMAT(testexpr, s, args, errorcode)   { if( !(testexpr) ) { throw OpenRAVE::openrave_exception(boost::str(boost::format("[%s:%d] (%s) failed " s)%(__PRETTY_FUNCTION__)%(__LINE__)%(# testexpr)%args),errorcode); } }
 
#define OPENRAVE_ASSERT_FORMAT0(testexpr, s, errorcode)   { if( !(testexpr) ) { throw OpenRAVE::openrave_exception(boost::str(boost::format("[%s:%d] (%s) failed " s)%(__PRETTY_FUNCTION__)%(__LINE__)%(# testexpr)),errorcode); } }
 
#define OPENRAVE_ASSERT_OP_FORMAT(expr1, op, expr2, s, args, errorcode)   { if( !((expr1) op (expr2)) ) { throw OpenRAVE::openrave_exception(boost::str(boost::format("[%s:%d] %s %s %s, (eval %s %s %s) " s)%(__PRETTY_FUNCTION__)%(__LINE__)%(# expr1)%(# op)%(# expr2)%(expr1)%(# op)%(expr2)%args),errorcode); } }
 
#define OPENRAVE_ASSERT_OP_FORMAT0(expr1, op, expr2, s, errorcode)   { if( !((expr1) op (expr2)) ) { throw OpenRAVE::openrave_exception(boost::str(boost::format("[%s:%d] %s %s %s, (eval %s %s %s) " s)%(__PRETTY_FUNCTION__)%(__LINE__)%(# expr1)%(# op)%(# expr2)%(expr1)%(# op)%(expr2)),errorcode); } }
 
#define OPENRAVE_ASSERT_OP(expr1, op, expr2)   { if( !((expr1) op (expr2)) ) { throw OpenRAVE::openrave_exception(boost::str(boost::format("[%s:%d] %s %s %s, (eval %s %s %s) ")%(__PRETTY_FUNCTION__)%(__LINE__)%(# expr1)%(# op)%(# expr2)%(expr1)%(# op)%(expr2)),ORE_Assert); } }
 
#define OPENRAVE_DUMMY_IMPLEMENTATION   { throw OPENRAVE_EXCEPTION_FORMAT0("not implemented",ORE_NotImplemented); }
 
#define OPENRAVE_MATH_EXP_FLOAT   RaveExp
 
#define OPENRAVE_MATH_LOG_FLOAT   RaveLog
 
#define OPENRAVE_MATH_COS_FLOAT   RaveCos
 
#define OPENRAVE_MATH_SIN_FLOAT   RaveSin
 
#define OPENRAVE_MATH_TAN_FLOAT   RaveTan
 
#define OPENRAVE_MATH_LOG2_FLOAT   RaveLog2
 
#define OPENRAVE_MATH_LOG10_FLOAT   RaveLog10
 
#define OPENRAVE_MATH_ACOS_FLOAT   RaveAcos
 
#define OPENRAVE_MATH_ASIN_FLOAT   RaveAsin
 
#define OPENRAVE_MATH_ATAN2_FLOAT   RaveAtan2
 
#define OPENRAVE_MATH_POW_FLOAT   RavePow
 
#define OPENRAVE_MATH_SQRT_FLOAT   RaveSqrt
 
#define OPENRAVE_MATH_FABS_FLOAT   RaveFabs
 

Typedefs

typedef float OpenRAVE::dReal
 
typedef boost::shared_ptr
< UserData > 
OpenRAVE::UserDataPtr
 
typedef boost::weak_ptr< UserData > OpenRAVE::UserDataWeakPtr
 
typedef boost::shared_ptr
< SerializableData > 
OpenRAVE::SerializableDataPtr
 
typedef boost::weak_ptr
< SerializableData > 
OpenRAVE::SerializableDataWeakPtr
 
typedef boost::shared_ptr
< CollisionReport > 
OpenRAVE::CollisionReportPtr
 
typedef boost::shared_ptr
< CollisionReport const > 
OpenRAVE::CollisionReportConstPtr
 
typedef boost::shared_ptr
< InterfaceBase > 
OpenRAVE::InterfaceBasePtr
 
typedef boost::shared_ptr
< InterfaceBase const > 
OpenRAVE::InterfaceBaseConstPtr
 
typedef boost::weak_ptr
< InterfaceBase > 
OpenRAVE::InterfaceBaseWeakPtr
 
typedef boost::shared_ptr
< KinBody > 
OpenRAVE::KinBodyPtr
 
typedef boost::shared_ptr
< KinBody const > 
OpenRAVE::KinBodyConstPtr
 
typedef boost::weak_ptr< KinBody > OpenRAVE::KinBodyWeakPtr
 
typedef boost::shared_ptr
< RobotBase > 
OpenRAVE::RobotBasePtr
 
typedef boost::shared_ptr
< RobotBase const > 
OpenRAVE::RobotBaseConstPtr
 
typedef boost::weak_ptr
< RobotBase > 
OpenRAVE::RobotBaseWeakPtr
 
typedef boost::shared_ptr
< CollisionCheckerBase > 
OpenRAVE::CollisionCheckerBasePtr
 
typedef boost::shared_ptr
< CollisionCheckerBase const > 
OpenRAVE::CollisionCheckerBaseConstPtr
 
typedef boost::weak_ptr
< CollisionCheckerBase > 
OpenRAVE::CollisionCheckerBaseWeakPtr
 
typedef boost::shared_ptr
< ControllerBase > 
OpenRAVE::ControllerBasePtr
 
typedef boost::shared_ptr
< ControllerBase const > 
OpenRAVE::ControllerBaseConstPtr
 
typedef boost::weak_ptr
< ControllerBase > 
OpenRAVE::ControllerBaseWeakPtr
 
typedef boost::shared_ptr
< IkSolverBase > 
OpenRAVE::IkSolverBasePtr
 
typedef boost::shared_ptr
< IkSolverBase const > 
OpenRAVE::IkSolverBaseConstPtr
 
typedef boost::weak_ptr
< IkSolverBase > 
OpenRAVE::IkSolverBaseWeakPtr
 
typedef boost::shared_ptr
< PhysicsEngineBase > 
OpenRAVE::PhysicsEngineBasePtr
 
typedef boost::shared_ptr
< PhysicsEngineBase const > 
OpenRAVE::PhysicsEngineBaseConstPtr
 
typedef boost::weak_ptr
< PhysicsEngineBase > 
OpenRAVE::PhysicsEngineBaseWeakPtr
 
typedef boost::shared_ptr
< PlannerBase > 
OpenRAVE::PlannerBasePtr
 
typedef boost::shared_ptr
< PlannerBase const > 
OpenRAVE::PlannerBaseConstPtr
 
typedef boost::weak_ptr
< PlannerBase > 
OpenRAVE::PlannerBaseWeakPtr
 
typedef boost::shared_ptr
< ModuleBase > 
OpenRAVE::ModuleBasePtr
 
typedef boost::shared_ptr
< ModuleBase const > 
OpenRAVE::ModuleBaseConstPtr
 
typedef boost::weak_ptr
< ModuleBase > 
OpenRAVE::ModuleBaseWeakPtr
 
typedef boost::shared_ptr
< SensorBase > 
OpenRAVE::SensorBasePtr
 
typedef boost::shared_ptr
< SensorBase const > 
OpenRAVE::SensorBaseConstPtr
 
typedef boost::weak_ptr
< SensorBase > 
OpenRAVE::SensorBaseWeakPtr
 
typedef boost::shared_ptr
< SensorSystemBase > 
OpenRAVE::SensorSystemBasePtr
 
typedef boost::shared_ptr
< SensorSystemBase const > 
OpenRAVE::SensorSystemBaseConstPtr
 
typedef boost::weak_ptr
< SensorSystemBase > 
OpenRAVE::SensorSystemBaseWeakPtr
 
typedef boost::shared_ptr
< TrajectoryBase > 
OpenRAVE::TrajectoryBasePtr
 
typedef boost::shared_ptr
< TrajectoryBase const > 
OpenRAVE::TrajectoryBaseConstPtr
 
typedef boost::weak_ptr
< TrajectoryBase > 
OpenRAVE::TrajectoryBaseWeakPtr
 
typedef boost::shared_ptr
< ViewerBase > 
OpenRAVE::ViewerBasePtr
 
typedef boost::shared_ptr
< ViewerBase const > 
OpenRAVE::ViewerBaseConstPtr
 
typedef boost::weak_ptr
< ViewerBase > 
OpenRAVE::ViewerBaseWeakPtr
 
typedef boost::shared_ptr
< SpaceSamplerBase > 
OpenRAVE::SpaceSamplerBasePtr
 
typedef boost::shared_ptr
< SpaceSamplerBase const > 
OpenRAVE::SpaceSamplerBaseConstPtr
 
typedef boost::weak_ptr
< SpaceSamplerBase > 
OpenRAVE::SpaceSamplerBaseWeakPtr
 
typedef boost::shared_ptr
< EnvironmentBase > 
OpenRAVE::EnvironmentBasePtr
 
typedef boost::shared_ptr
< EnvironmentBase const > 
OpenRAVE::EnvironmentBaseConstPtr
 
typedef boost::weak_ptr
< EnvironmentBase > 
OpenRAVE::EnvironmentBaseWeakPtr
 
typedef boost::shared_ptr
< IkReturn > 
OpenRAVE::IkReturnPtr
 
typedef boost::weak_ptr< IkReturn > OpenRAVE::IkReturnWeakPtr
 
typedef boost::shared_ptr
< BaseXMLReader > 
OpenRAVE::BaseXMLReaderPtr
 
typedef boost::shared_ptr
< BaseXMLReader const > 
OpenRAVE::BaseXMLReaderConstPtr
 
typedef boost::shared_ptr
< BaseXMLWriter > 
OpenRAVE::BaseXMLWriterPtr
 
typedef boost::shared_ptr
< BaseXMLWriter const > 
OpenRAVE::BaseXMLWriterConstPtr
 Cloning Options for interfaces and environments.
 
typedef boost::shared_ptr
< XMLReadable > 
OpenRAVE::XMLReadablePtr
 
typedef boost::shared_ptr
< XMLReadable const > 
OpenRAVE::XMLReadableConstPtr
 
typedef std::list< std::pair
< std::string, std::string > > 
OpenRAVE::AttributesList
 a list of key-value pairs. It is possible for keys to repeat.
 
typedef boost::function
< BaseXMLReaderPtr(InterfaceBasePtr,
const AttributesList &)> 
OpenRAVE::CreateXMLReaderFn
 
typedef RaveVector< dReal > OpenRAVE::Vector
 
typedef RaveTransform< dReal > OpenRAVE::Transform
 
typedef boost::shared_ptr
< RaveTransform< dReal > > 
OpenRAVE::TransformPtr
 
typedef boost::shared_ptr
< RaveTransform< dReal > const > 
OpenRAVE::TransformConstPtr
 
typedef RaveTransformMatrix
< dReal > 
OpenRAVE::TransformMatrix
 
typedef boost::shared_ptr
< RaveTransformMatrix< dReal > > 
OpenRAVE::TransformMatrixPtr
 
typedef boost::shared_ptr
< RaveTransformMatrix< dReal >
const > 
OpenRAVE::TransformMatrixConstPtr
 
typedef geometry::obb< dReal > OpenRAVE::OBB
 
typedef geometry::aabb< dReal > OpenRAVE::AABB
 
typedef geometry::ray< dReal > OpenRAVE::RAY
 
typedef boost::shared_ptr
< ConfigurationSpecification > 
OpenRAVE::ConfigurationSpecificationPtr
 
typedef boost::shared_ptr
< ConfigurationSpecification
const > 
OpenRAVE::ConfigurationSpecificationConstPtr
 
typedef InterfaceBasePtr(* OpenRAVE::PluginExportFn_OpenRAVECreateInterface )(InterfaceType type, const std::string &name, const char *pluginhash, const char *envhash, EnvironmentBasePtr penv)
 Create the interfaces, see CreateInterfaceValidated.
 
typedef bool(* OpenRAVE::PluginExportFn_OpenRAVEGetPluginAttributes )(PLUGININFO *pinfo, int size, const char *infohash)
 Called to fill information about the plugin, see GetPluginAttributesValidated.
 
typedef void(* OpenRAVE::PluginExportFn_DestroyPlugin )()
 Called before plugin is unloaded from openrave. See DestroyPlugin.
 
typedef InterfaceBasePtr(* OpenRAVE::PluginExportFn_CreateInterface )(InterfaceType type, const std::string &name, const char *pluginhash, EnvironmentBasePtr penv) RAVE_DEPRECATED
 
typedef bool(* OpenRAVE::PluginExportFn_GetPluginAttributes )(PLUGININFO *pinfo, int size) RAVE_DEPRECATED
 

Enumerations

enum  OpenRAVE::OpenRAVEErrorCode {
  OpenRAVE::ORE_Failed =0, OpenRAVE::ORE_InvalidArguments =1, OpenRAVE::ORE_EnvironmentNotLocked =2, OpenRAVE::ORE_CommandNotSupported =3,
  OpenRAVE::ORE_Assert =4, OpenRAVE::ORE_InvalidPlugin =5, OpenRAVE::ORE_InvalidInterfaceHash =6, OpenRAVE::ORE_NotImplemented =7,
  OpenRAVE::ORE_InconsistentConstraints =8, OpenRAVE::ORE_NotInitialized =9, OpenRAVE::ORE_InvalidState =10, OpenRAVE::ORE_Timeout =11
}
 OpenRAVE error codes More...
 
enum  OpenRAVE::DebugLevel {
  OpenRAVE::Level_Fatal =0, OpenRAVE::Level_Error =1, OpenRAVE::Level_Warn =2, OpenRAVE::Level_Info =3,
  OpenRAVE::Level_Debug =4, OpenRAVE::Level_Verbose =5, OpenRAVE::Level_OutputMask =0xf, OpenRAVE::Level_VerifyPlans =0x80000000
}
 
enum  OpenRAVE::CloningOptions {
  OpenRAVE::Clone_Bodies = 1, OpenRAVE::Clone_Viewer = 2, OpenRAVE::Clone_Simulation = 4, OpenRAVE::Clone_RealControllers = 8,
  OpenRAVE::Clone_Sensors = 16
}
 
enum  OpenRAVE::IkParameterizationType {
  OpenRAVE::IKP_None =0, OpenRAVE::IKP_Transform6D =0x67000001, OpenRAVE::IKP_Rotation3D =0x34000002, OpenRAVE::IKP_Translation3D =0x33000003,
  OpenRAVE::IKP_Direction3D =0x23000004, OpenRAVE::IKP_Ray4D =0x46000005, OpenRAVE::IKP_Lookat3D =0x23000006, OpenRAVE::IKP_TranslationDirection5D =0x56000007,
  OpenRAVE::IKP_TranslationXY2D =0x22000008, OpenRAVE::IKP_TranslationXYOrientation3D =0x33000009, OpenRAVE::IKP_TranslationLocalGlobal6D =0x3600000a, OpenRAVE::IKP_TranslationXAxisAngle4D =0x4400000b,
  OpenRAVE::IKP_TranslationYAxisAngle4D =0x4400000c, OpenRAVE::IKP_TranslationZAxisAngle4D =0x4400000d, OpenRAVE::IKP_TranslationXAxisAngleZNorm4D =0x4400000e, OpenRAVE::IKP_TranslationYAxisAngleXNorm4D =0x4400000f,
  OpenRAVE::IKP_TranslationZAxisAngleYNorm4D =0x44000010, OpenRAVE::IKP_NumberOfParameterizations =16, OpenRAVE::IKP_VelocityDataBit = 0x00008000, OpenRAVE::IKP_Transform6DVelocity = IKP_Transform6D|IKP_VelocityDataBit,
  OpenRAVE::IKP_Rotation3DVelocity = IKP_Rotation3D|IKP_VelocityDataBit, OpenRAVE::IKP_Translation3DVelocity = IKP_Translation3D|IKP_VelocityDataBit, OpenRAVE::IKP_Direction3DVelocity = IKP_Direction3D|IKP_VelocityDataBit, OpenRAVE::IKP_Ray4DVelocity = IKP_Ray4D|IKP_VelocityDataBit,
  OpenRAVE::IKP_Lookat3DVelocity = IKP_Lookat3D|IKP_VelocityDataBit, OpenRAVE::IKP_TranslationDirection5DVelocity = IKP_TranslationDirection5D|IKP_VelocityDataBit, OpenRAVE::IKP_TranslationXY2DVelocity = IKP_TranslationXY2D|IKP_VelocityDataBit, OpenRAVE::IKP_TranslationXYOrientation3DVelocity = IKP_TranslationXYOrientation3D|IKP_VelocityDataBit,
  OpenRAVE::IKP_TranslationLocalGlobal6DVelocity = IKP_TranslationLocalGlobal6D|IKP_VelocityDataBit, OpenRAVE::IKP_TranslationXAxisAngle4DVelocity = IKP_TranslationXAxisAngle4D|IKP_VelocityDataBit, OpenRAVE::IKP_TranslationYAxisAngle4DVelocity = IKP_TranslationYAxisAngle4D|IKP_VelocityDataBit, OpenRAVE::IKP_TranslationZAxisAngle4DVelocity = IKP_TranslationZAxisAngle4D|IKP_VelocityDataBit,
  OpenRAVE::IKP_TranslationXAxisAngleZNorm4DVelocity = IKP_TranslationXAxisAngleZNorm4D|IKP_VelocityDataBit, OpenRAVE::IKP_TranslationYAxisAngleXNorm4DVelocity = IKP_TranslationYAxisAngleXNorm4D|IKP_VelocityDataBit, OpenRAVE::IKP_TranslationZAxisAngleYNorm4DVelocity = IKP_TranslationZAxisAngleYNorm4D|IKP_VelocityDataBit, OpenRAVE::IKP_UniqueIdMask = 0x0000ffff,
  OpenRAVE::IKP_CustomDataBit = 0x00010000
}
 The types of inverse kinematics parameterizations supported. More...
 
enum  OpenRAVE::DOFAffine {
  OpenRAVE::DOF_NoTransform = 0, OpenRAVE::DOF_X = 1, OpenRAVE::DOF_Y = 2, OpenRAVE::DOF_Z = 4,
  OpenRAVE::DOF_XYZ =DOF_X|DOF_Y|DOF_Z, OpenRAVE::DOF_RotationAxis = 8, OpenRAVE::DOF_Rotation3D = 16, OpenRAVE::DOF_RotationQuat = 32,
  OpenRAVE::DOF_RotationMask =(DOF_RotationAxis|DOF_Rotation3D|DOF_RotationQuat), OpenRAVE::DOF_Transform = (DOF_XYZ|DOF_RotationQuat)
}
 Selects which DOFs of the affine transformation to include in the active configuration. More...
 

Functions

const char * OpenRAVE::GetErrorCodeString (OpenRAVEErrorCode error)
 
std::string OpenRAVE::ChangeTextColor (int attribute, int fg, int bg)
 Change the text color (on either stdout or stderr) with an attr:fg:bg (thanks to Radu Rusu for the code)
 
std::string OpenRAVE::ChangeTextColor (int attribute, int fg)
 Change the text color (on either stdout or stderr) with an attr:fg (thanks to Radu Rusu for the code)
 
std::string OpenRAVE::ResetTextColor ()
 Reset the text color (on either stdout or stderr) to its original state (thanks to Radu Rusu for the code)
 
std::wstring OpenRAVE::ChangeTextColorW (int attribute, int fg)
 
std::wstring OpenRAVE::RavePrintTransformString (const wchar_t *fmt)
 
OPENRAVE_API void OpenRAVE::RaveSetDebugLevel (int level)
 Sets the global openrave debug level. A combination of DebugLevel.
 
OPENRAVE_API int OpenRAVE::RaveGetDebugLevel ()
 Returns the openrave debug level.
 
const char * OpenRAVE::RaveGetSourceFilename (const char *pfilename)
 extracts only the filename
 
int OpenRAVE::RavePrintfA_INFOLEVEL (const std::string &s)
 
int OpenRAVE::RavePrintfA_INFOLEVEL (const char *fmt,...)
 
int OpenRAVE::RavePrintfA (const std::string &s, uint32_t level)
 
 OpenRAVE::DefineRavePrintfW (_FATALLEVEL) DefineRavePrintfW(_ERRORLEVEL) DefineRavePrintfW(_WARNLEVEL) DefineRavePrintfW(_DEBUGLEVEL) DefineRavePrintfW(_VERBOSELEVEL) DefineRavePrintfA(_FATALLEVEL) DefineRavePrintfA(_ERRORLEVEL) DefineRavePrintfA(_WARNLEVEL) DefineRavePrintfA(_DEBUGLEVEL) DefineRavePrintfA(_VERBOSELEVEL) enum InterfaceType
 adds the function name and line number to an openrave exception
 
OPENRAVE_API const std::map
< IkParameterizationType,
std::string > & 
OpenRAVE::RaveGetIkParameterizationMap (int alllowercase=0)
 returns a string of the ik parameterization type names
 
OPENRAVE_API IkParameterizationType OpenRAVE::RaveGetIkTypeFromUniqueId (int uniqueid)
 returns the IkParameterizationType given the unique id detmerined b IKP_UniqueIdMask
 
OPENRAVE_API std::ostream & OpenRAVE::operator<< (std::ostream &O, const ConfigurationSpecification &spec)
 
OPENRAVE_API std::istream & OpenRAVE::operator>> (std::istream &I, ConfigurationSpecification &spec)
 
template<typename T >
OpenRAVE::NormalizeCircularAnglePrivate (T theta, T min, T max)
 
IkParameterization OpenRAVE::operator* (const Transform &t, const IkParameterization &ikparam)
 
OPENRAVE_API std::ostream & OpenRAVE::operator<< (std::ostream &O, const IkParameterization &ikparam)
 
OPENRAVE_API std::istream & OpenRAVE::operator>> (std::istream &I, IkParameterization &ikparam)
 
OPENRAVE_API int OpenRAVE::RaveGetIndexFromAffineDOF (int affinedofs, DOFAffine dof)
 Given a mask of affine dofs and a dof inside that mask, returns the index where the value could be found.
 
OPENRAVE_API DOFAffine OpenRAVE::RaveGetAffineDOFFromIndex (int affinedofs, int index)
 Given a mask of affine dofs and an index into the array, returns the affine dof that is being referenced.
 
OPENRAVE_API int OpenRAVE::RaveGetAffineDOF (int affinedofs)
 Returns the degrees of freedom needed to represent all the values in the affine dof mask.
 
OPENRAVE_API void OpenRAVE::RaveGetAffineDOFValuesFromTransform (std::vector< dReal >::iterator itvalues, const Transform &t, int affinedofs, const Vector &vActvAffineRotationAxis=Vector(0, 0, 1))
 Converts the transformation matrix into the specified affine values format.
 
OPENRAVE_API void OpenRAVE::RaveGetTransformFromAffineDOFValues (Transform &t, std::vector< dReal >::const_iterator itvalues, int affinedofs, const Vector &vActvAffineRotationAxis=Vector(0, 0, 1), bool normalize=true)
 Converts affine dof values into a transform.
 
OPENRAVE_API
ConfigurationSpecification 
OpenRAVE::RaveGetAffineConfigurationSpecification (int affinedofs, KinBodyConstPtr pbody=KinBodyConstPtr(), const std::string &interpolation="")
 
OPENRAVE_API void OpenRAVE::RaveInitRandomGeneration (uint32_t seed)
 
OPENRAVE_API uint32_t OpenRAVE::RaveRandomInt ()
 
OPENRAVE_API float OpenRAVE::RaveRandomFloat (IntervalType interval=IT_Closed)
 
OPENRAVE_API double OpenRAVE::RaveRandomDouble (IntervalType interval=IT_Closed)
 
bool OpenRAVE::RaveParseDirectories (const char *pdirs, std::vector< std::string > &vdirs) RAVE_DEPRECATED
 
void boost::assertion_failed (char const *expr, char const *function, char const *file, long line)
 
 BOOST_STATIC_ASSERT (OPENRAVE_VERSION_MAJOR >=0 &&OPENRAVE_VERSION_MAJOR<=255)
 
 BOOST_STATIC_ASSERT (OPENRAVE_VERSION_MINOR >=0 &&OPENRAVE_VERSION_MINOR<=255)
 
 BOOST_STATIC_ASSERT (OPENRAVE_VERSION_PATCH >=0 &&OPENRAVE_VERSION_PATCH<=255)
 
OPENRAVE_API dReal OpenRAVE::RaveExp (dReal f)
 exponential
 
OPENRAVE_API dReal OpenRAVE::RaveLog (dReal f)
 logarithm
 
OPENRAVE_API dReal OpenRAVE::RaveCos (dReal f)
 cosine
 
OPENRAVE_API dReal OpenRAVE::RaveSin (dReal f)
 sine
 
OPENRAVE_API dReal OpenRAVE::RaveTan (dReal f)
 tangent
 
OPENRAVE_API dReal OpenRAVE::RaveLog2 (dReal f)
 base 2 logarithm
 
OPENRAVE_API dReal OpenRAVE::RaveLog10 (dReal f)
 base 10 logarithm
 
OPENRAVE_API dReal OpenRAVE::RaveAcos (dReal f)
 arccosine
 
OPENRAVE_API dReal OpenRAVE::RaveAsin (dReal f)
 arcsine
 
OPENRAVE_API dReal OpenRAVE::RaveAtan2 (dReal fy, dReal fx)
 arctangent2 covering entire circle
 
OPENRAVE_API dReal OpenRAVE::RavePow (dReal fx, dReal fy)
 power x^y
 
OPENRAVE_API dReal OpenRAVE::RaveSqrt (dReal f)
 square-root
 
OPENRAVE_API dReal OpenRAVE::RaveFabs (dReal f)
 absolute value
 
Global Functionality - Interface Creation, Plugin Management, Logging

const char * OpenRAVE::RaveGetInterfaceHash (InterfaceType type)
 Returns the a 16 character null-terminated string specifying a hash of the interfaces used for checking changes.
 
template<typename T >
boost::shared_ptr< T > OpenRAVE::RaveInterfaceCast (InterfaceBasePtr pinterface)
 Safely casts from the base interface class to an openrave interface using static_pointer_cast.
 
template<typename T >
boost::shared_ptr< T const > OpenRAVE::RaveInterfaceConstCast (InterfaceBaseConstPtr pinterface)
 Safely casts from the base interface class to an openrave interface using static_pointer_cast.
 
OPENRAVE_API const std::map
< InterfaceType, std::string > & 
OpenRAVE::RaveGetInterfaceNamesMap ()
 returns a lower case string of the interface type
 
OPENRAVE_API const std::string & OpenRAVE::RaveGetInterfaceName (InterfaceType type)
 
OPENRAVE_API std::string OpenRAVE::RaveGetHomeDirectory ()
 Returns the openrave home directory where settings, cache, and other files are stored.
 
OPENRAVE_API std::string OpenRAVE::RaveFindDatabaseFile (const std::string &filename, bool bRead=true)
 Searches for a filename in the database and returns a full path/URL to it.
 
OPENRAVE_API int OpenRAVE::RaveInitialize (bool bLoadAllPlugins=true, int level=Level_Info)
 Explicitly initializes the global OpenRAVE state (optional).
 
OPENRAVE_API void OpenRAVE::RaveInitializeFromState (UserDataPtr globalstate)
 Initializes the global state from an already loaded OpenRAVE environment.
 
OPENRAVE_API UserDataPtr OpenRAVE::RaveGlobalState ()
 A pointer to the global openrave state.
 
OPENRAVE_API void OpenRAVE::RaveDestroy ()
 Destroys the entire OpenRAVE state and all loaded environments.
 
OPENRAVE_API void OpenRAVE::RaveGetPluginInfo (std::list< std::pair< std::string, PLUGININFO > > &plugins)
 Get all the loaded plugins and the interfaces they support.
 
OPENRAVE_API void OpenRAVE::RaveGetLoadedInterfaces (std::map< InterfaceType, std::vector< std::string > > &interfacenames)
 Get a list of all the loaded interfaces.
 
OPENRAVE_API void OpenRAVE::RaveReloadPlugins ()
 Reloads all the plugins.
 
OPENRAVE_API bool OpenRAVE::RaveLoadPlugin (const std::string &libraryname)
 Load a plugin and its interfaces.
 
OPENRAVE_API bool OpenRAVE::RaveHasInterface (InterfaceType type, const std::string &interfacename)
 Returns true if interface can be created, otherwise false.
 
OPENRAVE_API InterfaceBasePtr OpenRAVE::RaveCreateInterface (EnvironmentBasePtr penv, InterfaceType type, const std::string &interfacename)
 
OPENRAVE_API RobotBasePtr OpenRAVE::RaveCreateRobot (EnvironmentBasePtr penv, const std::string &name="")
 
OPENRAVE_API PlannerBasePtr OpenRAVE::RaveCreatePlanner (EnvironmentBasePtr penv, const std::string &name)
 
OPENRAVE_API SensorSystemBasePtr OpenRAVE::RaveCreateSensorSystem (EnvironmentBasePtr penv, const std::string &name)
 
OPENRAVE_API ControllerBasePtr OpenRAVE::RaveCreateController (EnvironmentBasePtr penv, const std::string &name)
 
OPENRAVE_API ModuleBasePtr OpenRAVE::RaveCreateModule (EnvironmentBasePtr penv, const std::string &name)
 
OPENRAVE_API ModuleBasePtr OpenRAVE::RaveCreateProblem (EnvironmentBasePtr penv, const std::string &name)
 
OPENRAVE_API ModuleBasePtr OpenRAVE::RaveCreateProblemInstance (EnvironmentBasePtr penv, const std::string &name)
 
OPENRAVE_API IkSolverBasePtr OpenRAVE::RaveCreateIkSolver (EnvironmentBasePtr penv, const std::string &name)
 
OPENRAVE_API PhysicsEngineBasePtr OpenRAVE::RaveCreatePhysicsEngine (EnvironmentBasePtr penv, const std::string &name)
 
OPENRAVE_API SensorBasePtr OpenRAVE::RaveCreateSensor (EnvironmentBasePtr penv, const std::string &name)
 
OPENRAVE_API
CollisionCheckerBasePtr 
OpenRAVE::RaveCreateCollisionChecker (EnvironmentBasePtr penv, const std::string &name)
 
OPENRAVE_API ViewerBasePtr OpenRAVE::RaveCreateViewer (EnvironmentBasePtr penv, const std::string &name)
 
OPENRAVE_API SpaceSamplerBasePtr OpenRAVE::RaveCreateSpaceSampler (EnvironmentBasePtr penv, const std::string &name)
 
OPENRAVE_API KinBodyPtr OpenRAVE::RaveCreateKinBody (EnvironmentBasePtr penv, const std::string &name="")
 
OPENRAVE_API TrajectoryBasePtr OpenRAVE::RaveCreateTrajectory (EnvironmentBasePtr penv, const std::string &name="")
 Return an empty trajectory instance.
 
OPENRAVE_API TrajectoryBasePtr OpenRAVE::RaveCreateTrajectory (EnvironmentBasePtr penv, int dof) RAVE_DEPRECATED
 
template<typename T >
boost::shared_ptr< T > OpenRAVE::RaveClone (boost::shared_ptr< T const > preference, int cloningoptions)
 returned a fully cloned interface
 
OPENRAVE_API UserDataPtr OpenRAVE::RaveRegisterInterface (InterfaceType type, const std::string &name, const char *interfacehash, const char *envhash, const boost::function< InterfaceBasePtr(EnvironmentBasePtr, std::istream &)> &createfn)
 Registers a function to create an interface, this allows the interface to be created by other modules.
 
OPENRAVE_API UserDataPtr OpenRAVE::RaveRegisterXMLReader (InterfaceType type, const std::string &xmltag, const CreateXMLReaderFn &fn)
 Registers a custom xml reader for a particular interface.
 
OPENRAVE_API int OpenRAVE::RaveGetEnvironmentId (EnvironmentBasePtr penv)
 return the environment's unique id, returns 0 if environment could not be found or not registered
 
OPENRAVE_API EnvironmentBasePtr OpenRAVE::RaveGetEnvironment (int id)
 get the environment from its unique id
 
OPENRAVE_API void OpenRAVE::RaveGetEnvironments (std::list< EnvironmentBasePtr > &listenvironments)
 Return all the created OpenRAVE environments.
 
OPENRAVE_API BaseXMLReaderPtr OpenRAVE::RaveCallXMLReader (InterfaceType type, const std::string &xmltag, InterfaceBasePtr pinterface, const AttributesList &atts)
 Returns the current registered reader for the interface type/xmlid.
 
OPENRAVE_API std::string OpenRAVE::RaveFindLocalFile (const std::string &filename, const std::string &curdir="")
 Returns the absolute path of the filename on the local filesystem resolving relative paths from OpenRAVE paths.
 
OPENRAVE_API void OpenRAVE::RaveSetDataAccess (int accessoptions)
 Sets the default data access options for cad resources/robot files.
 
OPENRAVE_API int OpenRAVE::RaveGetDataAccess ()
 Returns the acess options set.
 

Variables

static const dReal OpenRAVE::PI = dReal(3.14159265358979323846)
 openrave constant for PI, could be replaced by accurate precision number depending on choice of dReal.
 

Detailed Description

Defines the public headers that every plugin must include in order to use openrave properly.

Definition in file openrave.h.

Macro Definition Documentation

#define BOOST_ENABLE_ASSERT_HANDLER

Definition at line 24 of file openrave.h.

#define DefineRavePrintfA (   LEVEL)
Value:
inline int RavePrintfA ## LEVEL(const std::string& s) \
{ \
if((s.size() == 0)||(s[s.size()-1] != '\n')) { \
printf ("%c[0;%d;%dm%s%c[m\n", 0x1B, OPENRAVECOLOR ## LEVEL + 30,8+40,s.c_str(),0x1B); \
} \
else { \
printf ("%c[0;%d;%dm%s%c[m", 0x1B, OPENRAVECOLOR ## LEVEL + 30,8+40,s.c_str(),0x1B); \
} \
return s.size(); \
} \
\
inline int RavePrintfA ## LEVEL(const char *fmt, ...) \
{ \
va_list list; \
va_start(list,fmt); \
int r = vprintf((ChangeTextColor(0, OPENRAVECOLOR ## LEVEL,8) + std::string(fmt) + ResetTextColor()).c_str(), list); \
va_end(list); \
/*if( fmt[0] != '\n' ) { printf("\n"); } */ \
return r; \
} \

Definition at line 466 of file openrave.h.

#define DefineRavePrintfW (   LEVEL)
Value:
inline int RavePrintfW ## LEVEL(const wchar_t *wfmt, ...) \
{ \
va_list list; \
va_start(list,wfmt); \
/* Allocate memory on the stack to avoid heap fragmentation */ \
size_t allocsize = wcstombs(NULL, wfmt, 0)+32; \
char* fmt = (char*)alloca(allocsize); \
strcpy(fmt, ChangeTextColor(0, OPENRAVECOLOR ## LEVEL,8).c_str()); \
snprintf(fmt+strlen(fmt),allocsize-16,"%S",wfmt); \
strcat(fmt, ResetTextColor().c_str()); \
int r = vprintf(fmt, list); \
va_end(list); \
return r; \
}

Definition at line 425 of file openrave.h.

#define g_fEpsilon   2e-7f
Examples:
orplanning_door.cpp.

Definition at line 98 of file openrave.h.

#define IS_DEBUGLEVEL (   level)    ((OpenRAVE::RaveGetDebugLevel()&OpenRAVE::Level_OutputMask)>=(level))
#define OPENRAVE_ASSERT_FORMAT (   testexpr,
  s,
  args,
  errorcode 
)    { if( !(testexpr) ) { throw OpenRAVE::openrave_exception(boost::str(boost::format("[%s:%d] (%s) failed " s)%(__PRETTY_FUNCTION__)%(__LINE__)%(# testexpr)%args),errorcode); } }
#define OPENRAVE_ASSERT_FORMAT0 (   testexpr,
  s,
  errorcode 
)    { if( !(testexpr) ) { throw OpenRAVE::openrave_exception(boost::str(boost::format("[%s:%d] (%s) failed " s)%(__PRETTY_FUNCTION__)%(__LINE__)%(# testexpr)),errorcode); } }
#define OPENRAVE_ASSERT_OP (   expr1,
  op,
  expr2 
)    { if( !((expr1) op (expr2)) ) { throw OpenRAVE::openrave_exception(boost::str(boost::format("[%s:%d] %s %s %s, (eval %s %s %s) ")%(__PRETTY_FUNCTION__)%(__LINE__)%(# expr1)%(# op)%(# expr2)%(expr1)%(# op)%(expr2)),ORE_Assert); } }
#define OPENRAVE_ASSERT_OP_FORMAT (   expr1,
  op,
  expr2,
  s,
  args,
  errorcode 
)    { if( !((expr1) op (expr2)) ) { throw OpenRAVE::openrave_exception(boost::str(boost::format("[%s:%d] %s %s %s, (eval %s %s %s) " s)%(__PRETTY_FUNCTION__)%(__LINE__)%(# expr1)%(# op)%(# expr2)%(expr1)%(# op)%(expr2)%args),errorcode); } }
#define OPENRAVE_ASSERT_OP_FORMAT0 (   expr1,
  op,
  expr2,
  s,
  errorcode 
)    { if( !((expr1) op (expr2)) ) { throw OpenRAVE::openrave_exception(boost::str(boost::format("[%s:%d] %s %s %s, (eval %s %s %s) " s)%(__PRETTY_FUNCTION__)%(__LINE__)%(# expr1)%(# op)%(# expr2)%(expr1)%(# op)%(expr2)),errorcode); } }
#define OPENRAVE_DUMMY_IMPLEMENTATION   { throw OPENRAVE_EXCEPTION_FORMAT0("not implemented",ORE_NotImplemented); }
#define OPENRAVE_EXCEPTION_FORMAT (   s,
  args,
  errorcode 
)    OpenRAVE::openrave_exception(boost::str(boost::format("[%s:%d] " s)%(__PRETTY_FUNCTION__)%(__LINE__)%args),errorcode)
#define OPENRAVE_EXCEPTION_FORMAT0 (   s,
  errorcode 
)    OpenRAVE::openrave_exception(boost::str(boost::format("[%s:%d] " s)%(__PRETTY_FUNCTION__)%(__LINE__)),errorcode)
#define OPENRAVE_MATH_ACOS_FLOAT   RaveAcos

Definition at line 823 of file openrave.h.

#define OPENRAVE_MATH_ASIN_FLOAT   RaveAsin

Definition at line 824 of file openrave.h.

#define OPENRAVE_MATH_ATAN2_FLOAT   RaveAtan2

Definition at line 825 of file openrave.h.

#define OPENRAVE_MATH_COS_FLOAT   RaveCos

Definition at line 818 of file openrave.h.

#define OPENRAVE_MATH_EXP_FLOAT   RaveExp

Definition at line 816 of file openrave.h.

#define OPENRAVE_MATH_FABS_FLOAT   RaveFabs

Definition at line 828 of file openrave.h.

#define OPENRAVE_MATH_LOG10_FLOAT   RaveLog10

Definition at line 822 of file openrave.h.

#define OPENRAVE_MATH_LOG2_FLOAT   RaveLog2

Definition at line 821 of file openrave.h.

#define OPENRAVE_MATH_LOG_FLOAT   RaveLog

Definition at line 817 of file openrave.h.

#define OPENRAVE_MATH_POW_FLOAT   RavePow

Definition at line 826 of file openrave.h.

#define OPENRAVE_MATH_SIN_FLOAT   RaveSin

Definition at line 819 of file openrave.h.

#define OPENRAVE_MATH_SQRT_FLOAT   RaveSqrt

Definition at line 827 of file openrave.h.

#define OPENRAVE_MATH_TAN_FLOAT   RaveTan

Definition at line 820 of file openrave.h.

#define OPENRAVECOLOR_DEBUGLEVEL   2

Definition at line 347 of file openrave.h.

#define OPENRAVECOLOR_ERRORLEVEL   1

Definition at line 344 of file openrave.h.

#define OPENRAVECOLOR_FATALLEVEL   5

Definition at line 343 of file openrave.h.

#define OPENRAVECOLOR_INFOLEVEL   0

Definition at line 346 of file openrave.h.

#define OPENRAVECOLOR_VERBOSELEVEL   4

Definition at line 348 of file openrave.h.

#define OPENRAVECOLOR_WARNLEVEL   3

Definition at line 345 of file openrave.h.

#define RAVE_DEPRECATED

Definition at line 84 of file openrave.h.

#define RAVELOG_DEBUG   RAVELOG_DEBUGA
Examples:
orpythonbinding.cpp.
#define RAVELOG_DEBUGA   RAVELOG_LEVELA(_DEBUGLEVEL,OpenRAVE::Level_Debug)
#define RAVELOG_DEBUGW   RAVELOG_LEVELW(_DEBUGLEVEL,OpenRAVE::Level_Debug)
#define RAVELOG_ERROR   RAVELOG_ERRORA
#define RAVELOG_ERRORA   RAVELOG_LEVELA(_ERRORLEVEL,OpenRAVE::Level_Error)
#define RAVELOG_ERRORW   RAVELOG_LEVELW(_ERRORLEVEL,OpenRAVE::Level_Error)
#define RAVELOG_FATAL   RAVELOG_FATALA
#define RAVELOG_FATALA   RAVELOG_LEVELA(_FATALLEVEL,OpenRAVE::Level_Fatal)
#define RAVELOG_FATALW   RAVELOG_LEVELW(_FATALLEVEL,OpenRAVE::Level_Fatal)
#define RAVELOG_INFO   RAVELOG_INFOA
#define RAVELOG_INFOA   RAVELOG_LEVELA(_INFOLEVEL,OpenRAVE::Level_Info)
#define RAVELOG_INFOW   RAVELOG_LEVELW(_INFOLEVEL,OpenRAVE::Level_Info)
#define RAVELOG_LEVELA (   LEVEL,
  level 
)    int(OpenRAVE::RaveGetDebugLevel()&OpenRAVE::Level_OutputMask)>=int(level)&&(RAVEPRINTHEADER(LEVEL)>0)&&OpenRAVE::RavePrintfA ## LEVEL
#define RAVELOG_LEVELW (   LEVEL,
  level 
)    int(OpenRAVE::RaveGetDebugLevel()&OpenRAVE::Level_OutputMask)>=int(level)&&(RAVEPRINTHEADER(LEVEL)>0)&&OpenRAVE::RavePrintfW ## LEVEL
#define RAVELOG_VERBOSE   RAVELOG_VERBOSEA
Examples:
orplanning_door.cpp.
#define RAVELOG_VERBOSEA   RAVELOG_LEVELA(_VERBOSELEVEL,OpenRAVE::Level_Verbose)
#define RAVELOG_VERBOSEW   RAVELOG_LEVELW(_VERBOSELEVEL,OpenRAVE::Level_Verbose)
#define RAVELOG_WARN   RAVELOG_WARNA
#define RAVELOG_WARNA   RAVELOG_LEVELA(_WARNLEVEL,OpenRAVE::Level_Warn)
#define RAVELOG_WARNW   RAVELOG_LEVELW(_WARNLEVEL,OpenRAVE::Level_Warn)
#define RAVEPRINTHEADER (   LEVEL)    OpenRAVE::RavePrintfA ## LEVEL("[%s:%d] ", OpenRAVE::RaveGetSourceFilename(__FILE__), __LINE__)

Function Documentation

BOOST_STATIC_ASSERT ( OPENRAVE_VERSION_MAJOR >=0 &&OPENRAVE_VERSION_MAJOR<=  255)
BOOST_STATIC_ASSERT ( OPENRAVE_VERSION_MINOR >=0 &&OPENRAVE_VERSION_MINOR<=  255)
BOOST_STATIC_ASSERT ( OPENRAVE_VERSION_PATCH >=0 &&OPENRAVE_VERSION_PATCH<=  255)