Defines the minimum processing for performing pasing file for STL. More...

Namespaces
	signal_private

Classes
class	AbstractBodyLoader

class	AbstractMultiSeq

class	AbstractMultiSeqItem

class	AbstractSceneLoader

class	AbstractSeq

class	AbstractSeqItem

class	AbstractTaskSequencer

class	AbstractTextItem

class	AbstractVRMLGroup

class	AbsTransformInPortHandler

class	AbsTransformOutPortHandler

class	AccelerationSensor

class	AccelerationSensorOutPortHandler

class	Action

class	ActionGroup

class	AISTCollisionDetector

class	AISTSimulatorItem

class	App

class	AppConfig

class	Archive

class	Array2D

class	AudioItem

class	BasicSensorSimulationHelper

class	BindingIterator_impl

class	BindingNode

class	Body

class	BodyBar

struct	BodyCustomizerInterface

struct	BodyInterface

class	BodyItem

class	BodyLinkView

class	BodyLoader

class	BodyMotion

class	BodyMotionControllerItem

class	BodyMotionEngine

class	BodyMotionGenerationBar

class	BodyMotionItem

class	BodyMotionPoseProvider

class	BodyRTCItem

class	BodyState

class	BodyStateView

class	BodyTrackingCameraItem

class	BoundingBox

class	BoundingBoxf

class	BoundingBoxMarker

class	BulletCollisionDetector

class	BulletSimulatorItem

class	ButtonGroup

class	Camera

class	CameraImageOutPortHandler

class	CameraRangeOutPortHandler

class	CaptureBar

class	ChangeProperty

class	ChangeProperty< Selection >

class	CheckBox

class	ChoreonoidExecutionContext

class	ChoreonoidPeriodicExecutionContext

struct	CNOID_SIGNAL_ARGSET

class	CNOID_SIGNAL_SIGNAL

class	ColdetModel

class	ColdetModelInternalModel

class	ColdetModelPair

class	ColladaBodyLoader

struct	Collision

class	collision_data

class	CollisionDetector

struct	CollisionLinkPair

struct	CollisionPair

class	CollisionSeq

class	CollisionSeqEngine

class	CollisionSeqItem

class	ComboBox

class	CompositeIK

class	Connection

class	ConnectionSet

class	ConstraintForceSolver

class	ContactAttribute

class	ControllerItem

class	ControllerItemIO

class	CrossMarker

class	Dae
	This is the base class of the dae parser. (In order to share a pointer for all bjects) More...

class	DaeActuator
	It will hold the information for Kinematics. More...

class	DaeAttachActuator
	It will hold the information for Kinematics. More...

class	DaeAttachSensor
	It will hold the information for Kinematics. More...

class	DaeEffect
	It will hold the information of SgMaterial for 3D shape model. More...

class	DaeGeometry
	It will hold the information of SgGeometry for 3D shape model. More...

class	DaeJoint
	It will hold the information for Kinematics. More...

class	DaeLink
	It will hold the information for Kinematics. More...

class	DaeMassFrame
	It will hold the information of primitive figure for physics. More...

class	DaeMaterial
	It will hold the information of SgMaterial for 3D shape model. More...

class	DaeMesh
	It will hold the information of SgGeometry for 3D shape model. More...

class	DaeNode
	This is the base class of the dae parser. More...

class	DaeParser
	Perform the processing for each node as sax. More...

class	DaeRevolute
	It will hold the information for Kinematics. More...

class	DaeRigid
	It will hold the information of primitive figure for physics. More...

class	DaeSensor
	It will hold the information for Kinematics. More...

class	DaeShape
	It will hold the information of primitive figure for physics. More...

class	DaeTexture
	It will hold the information of SgTexture for 3D shape model. More...

class	DaeTransform
	It will hold the information of SgTransform for 3D shape model and kinematics model. More...

class	DataMap

class	DataMapBase

class	Deque2D

class	DescriptionDialog

class	Device

class	DeviceList

class	DeviceState

class	Dialog

class	DoubleScrollBar

class	DoubleSpinBox

class	DSMediaView

class	DyBody

class	DyLink

class	EasyScanner

class	EditableSceneBody

class	EditableSceneLink

struct	empty_data_error

struct	exception_base

class	ExtCommandItem

class	ExtensionManager

class	ExtJoystick

class	ExtraBodyStateAccessor

struct	file_read_error

class	FileBar

struct	FilePath

class	FloatingNumberBox

class	FloatingNumberString

class	FolderItem

class	ForceSensor

class	ForwardDynamics

class	ForwardDynamicsABM

class	ForwardDynamicsCBM

class	GettextDomainBinder

class	GLSceneRenderer

class	GLVisionSimulatorItem

class	GraphBar

class	GraphDataHandler

class	GraphViewBase

class	GraphWidget

class	GSMediaView

class	GyroSensorOutPortHandler

class	HSeparator

class	HSeparatorBox

class	IdPair

class	Image

class	ImageConverter

class	ImageIO

class	ImageView

class	ImageWidget

class	InfoBar

class	InPortHandler

class	InteractiveCameraTransform

class	InverseKinematics

class	Item

class	ItemCreationPanel

class	ItemList

class	ItemManager

class	ItemPath

class	ItemPropertyView

class	ItemSelectionModel

class	ItemTreeArchiver

class	ItemTreeView

class	JointDataSeqInPortHandler

class	JointGraphView

class	JointPath

class	JointSliderView

class	JointStateView

class	Joystick

class	JoystickCapture

class	KinematicFaultChecker

class	KinematicsBar

class	LazyCaller

class	LazySignal

class	LazySignalBase

class	LeggedBodyBar

class	LeggedBodyHelper

class	Light

class	LightOnInPortHandler

class	LightOnOutPortHandler

class	LineEdit

class	Link

class	LinkDataInPortHandler

class	LinkDataOutPortHandler

class	LinkGraphView

class	LinkGroup

class	LinkPath

class	LinkPropertyView

class	LinkSelectionView

class	LinkTraverse

class	LinkTreeItem

class	LinkTreeWidget

class	LipSyncTranslator

class	Listing

class	LogicalProduct

class	LogicalSum

class	MainWindow

class	Mapping

class	MediaItem

class	Menu

class	MenuManager

class	MeshExtractor

class	MeshGenerator

class	MeshNormalGenerator

class	MessageView

class	MessageView_impl

class	MovieRecorder

class	MultiAffine3Seq

class	MultiDeviceStateSeq

class	MultiDeviceStateSeqItem

class	MultiPointSetItem

class	MultiSE3Seq

class	MultiSE3SeqGraphView

class	MultiSeq

class	MultiSeqItem

class	MultiSeqItemCreationPanel

class	MultiValueSeq

class	MultiValueSeqGraphView

class	MultiVector3Seq

class	NameServerView

class	NamingContext_impl

class	NamingContextHelper

struct	nonexistent_key_error

class	ODECollisionDetector

class	ODESimulatorItem

class	OnlineViewerServer

class	OpenHRPClockGeneratorItem

class	OpenHRPControllerBase

class	OpenHRPControllerFactory_impl

class	OpenHRPControllerItem

class	OpenHRPInterpreterServiceItem

class	OpenHRPOnlineViewerItem

class	OptionManager

class	OutPortHandler

class	ParametricPathProcessor

class	Parser
	It define a base class to parse the 3D model file. This will return SceneGraph in a single file that is specified. And this is the process of "Inline" for VRML. More...

class	PathVariableEditor

class	PenetrationBlocker

class	PinDragIK

class	PlainSeqFileLoader

class	PlainTextEdit

class	Plugin

class	PluginManager

class	PointLight

class	PointSetItem

class	PolygonMeshTriangulator

class	PolyhedralRegion

class	PolymorphicFunctionSet

class	PolymorphicPointerArray

class	PolymorphicPointerArrayBase

class	PolymorphicReferencedArray

class	PolymorphicReferencedArrayBase

class	PortHandler

class	Pose

class	PoseProvider

class	PoseProviderToBodyMotionConverter

class	PoseRef

class	PoseRollView

class	PoseSeq

class	PoseSeqInterpolator

class	PoseSeqItem

class	PoseSeqView

class	PoseSeqViewBase

class	PoseUnit

class	PositionDragger

class	Process

class	ProjectManager

class	PronunSymbol

class	PulseAudioManager

class	PushButton

class	PutPropertyFunction

class	PythonConsoleView

class	PythonExecutor

class	PythonScriptItem

class	PythonScriptItemImpl

class	PythonSimScriptItem

class	QueuedCaller

class	RadioButton

class	RangeCamera

class	RangeLimiter

class	RangeSensor

class	RangeSensorOutPortHandler

class	RateGyroSensor

class	RectRegionMarker

class	ref_ptr

class	Referenced

class	RootItem

class	RotationDragger

class	RTCItem

class	RTComponent

class	RTSNameServerView
	It is a screen of RTC list. More...

class	ScalarNode

class	SceneBar

class	SceneBody

class	SceneCollision

class	SceneCylinderProjector

class	SceneDevice

class	SceneDragger

class	SceneDragProjector

class	SceneItem

class	SceneLink

class	ScenePlaneProjector

class	SceneProjector

class	SceneProvider

class	SceneRenderer

class	SceneView

class	SceneVisitor

class	SceneWidget

class	SceneWidgetEditable

class	SceneWidgetEvent

class	SceneWidgetRoot

class	ScopedConnection

class	ScopedConnectionSet

class	ScriptBar

class	ScriptItem

class	ScrollBar

class	SE3

class	Selection

class	SelectionListEditor

class	SensorDataOutPortHandler

class	SensorStateOutPortHandler

class	SensorVisualizerItem

class	Seq

struct	SFImage

struct	SFTime

class	SgCamera

class	SgCloneMap

class	SgCustomGLNode

class	SgDirectionalLight

class	SgFog

class	SgGroup

class	SgImage

class	SgInvariantGroup

class	SgLight

class	SgLineSet

class	SgMaterial

class	SgMesh

class	SgMeshBase

class	SgNode

class	SgObject

class	SgOrthographicCamera

class	SgOutlineGroup

class	SgOverlay

class	SgPerspectiveCamera

class	SgPlot

class	SgPointLight

class	SgPointSet

class	SgPolygonMesh

class	SgPosTransform

class	SgPreprocessed

class	SgScaleTransform

class	SgShape

class	SgSpotLight

class	SgSwitch

class	SgTexture

class	SgTextureTransform

class	SgTransform

class	SgUnpickableGroup

class	SgUpdate

class	SgVectorArray

class	Signal

struct	signal_traits

struct	signal_traits< Signal< Signature, Combiner > >

class	SignalProxy

class	SimpleControllerItem

class	SimulationBar

class	SimulationBody

class	SimulationScriptItem

class	SimulatorItem

class	Slider

class	SocketNotifier

class	SphereMarker

class	SpinBox

class	Splitter

class	SpotLight

class	STLSceneLoader

class	SubSimulatorItem

class	Task

class	TaskCommand

class	TaskMenu

class	TaskPhase

class	TaskPhaseProxy

class	TaskProc

class	TaskToggleState

class	TaskView

class	TextEdit

class	TextEditView

class	ThreadPool

class	TimeBar

class	TimeMeasure

class	Timer

class	TimeSyncItemEngine

class	TimeSyncItemEngineManager

class	Timeval

struct	TIndent

class	ToggleButton

class	ToggleToolButton

class	ToolBar

class	ToolBarArea

class	ToolButton

class	TranslationDragger

class	TreeView

class	TreeWidget

class	Triangulator

class	TruncatedSVD

struct	type_mismatch_error

class	UniformCubicBSpline

class	UniformCubicBSplineBase

class	UniformCubicBSplineVector

class	ValueNode

class	Vector3Seq

class	Vector3SeqItem

class	View

class	ViewArea

class	ViewClass

class	ViewManager

class	VirtualJoystickView

class	VirtualRobotRTC

class	VRMLAccelerationSensor

class	VRMLAnchor

class	VRMLAnotherFormatFile

class	VRMLAppearance
	VRML Appearance node. More...

class	VRMLBackground
	VRML Background node. More...

class	VRMLBillboard

class	VRMLBodyLoader

class	VRMLBodyWriter

class	VRMLBox
	VRML Box node. More...

class	VRMLCollision

class	VRMLColor
	VRML Color node. More...

class	VRMLCone
	VRML Cone node. More...

class	VRMLCoordinate
	VRML Coordinate node. More...

class	VRMLCylinder
	VRML Cylinder node. More...

class	VRMLCylinderSensor
	VRML CylinderSensor node. More...

class	VRMLDirectionalLight

class	VRMLElevationGrid
	VRML ElevationGrid node. More...

class	VRMLExtrusion
	VRML Extrusion node. More...

class	VRMLFog

class	VRMLFontStyle
	VRML FontStyle node. More...

class	VRMLForceSensor

class	VRMLGeometry
	Base class of VRML geometry nodes. More...

class	VRMLGroup
	VRML Group node. More...

class	VRMLGyro

class	VRMLHumanoid

class	VRMLImageTexture
	VRML ImageTexture node. More...

class	VRMLIndexedFaceSet
	VRML IndexedFaseSet node. More...

class	VRMLIndexedLineSet
	VRML IndexedLineSet node. More...

class	VRMLInline
	VRML Inline node. More...

class	VRMLJoint

class	VRMLLight

class	VRMLLOD

class	VRMLMaterial
	VRML Material node. More...

class	VRMLMovieTexture
	VRML MovieTexture node. More...

class	VRMLNavigationInfo
	VRML NavigationInfo node. More...

class	VRMLNode
	Abstract base class of all vrml nodes. More...

class	VRMLNormal
	VRML Normal node. More...

class	VRMLParser
	Parser for VRML97 format. More...

class	VRMLPixelTexture
	VRML PixelTexture node. More...

class	VRMLPointLight

class	VRMLPointSet
	VRML PointSet node. More...

class	VRMLProto
	VRML Proto definition. More...

class	VRMLProtoInstance
	VRML node which is instance of VRML Prototype. More...

class	VRMLRangeSensor

class	VRMLSegment

class	VRMLShape
	VRML Shape node. More...

class	VRMLSphere
	VRML Sphere node. More...

class	VRMLSpotLight

class	VRMLSurface

class	VRMLSwitch

class	VRMLText
	VRML Text node. More...

class	VRMLTexture
	Base class of VRML Texture nodes. More...

class	VRMLTextureCoordinate
	VRML TextureCoordinate node. More...

class	VRMLTextureTransform
	VRML TextureTransform node. More...

class	VRMLToSGConverter

class	VRMLTransform
	VRML Transform node. More...

class	VRMLUnsupportedNode

class	VRMLViewpoint
	VRML Viewpoint node. More...

class	VRMLVisionSensor

class	VRMLWorldInfo

class	VRMLWriter

class	VSeparator

class	WaistBalancer

class	weak_ref_ptr

class	WeakCounter

class	World

class	WorldBase

class	WorldItem

class	WorldLogFileItem

class	YAMLBodyLoader

class	YAMLReader

class	YAMLWriter

class	ZMPSeq

class	ZMPSeqItem

Typedefs
typedef boost::shared_ptr< AbstractSeq >	AbstractSeqPtr

typedef boost::shared_ptr< AbstractMultiSeq >	AbstractMultiSeqPtr

typedef std::vector< Collision >	CollisionArray

typedef std::vector< Collision >	CollisionList
	obsolete More...

typedef boost::shared_ptr< CollisionPair >	CollisionPairPtr

typedef boost::shared_ptr< CollisionDetector >	CollisionDetectorPtr

typedef std::vector< double >	DaeVectorXArray

typedef boost::shared_ptr< DaeVectorXArray >	DaeVectorXArrayPtr

typedef std::map< std::string, DaeVectorXArrayPtr >	DaeVectorMap

typedef ref_ptr< DaeTexture >	DaeTexturePtr

typedef std::map< std::string, DaeTexturePtr >	DaeTextures

typedef std::vector< Vector3 >	Vector3s

typedef ref_ptr< DaeTransform >	DaeTransformPtr

typedef ref_ptr< DaeEffect >	DaeEffectPtr

typedef std::map< std::string, DaeEffectPtr >	DaeEffects

typedef ref_ptr< DaeMaterial >	DaeMaterialPtr

typedef std::map< std::string, DaeMaterialPtr >	DaeMaterials

typedef std::map< std::string, std::string >	DaeMaterialRef

typedef ref_ptr< DaeMesh >	DaeMeshPtr

typedef std::vector< DaeMeshPtr >	DaeMeshes

typedef ref_ptr< DaeGeometry >	DaeGeometryPtr

typedef std::map< std::string, DaeGeometryPtr >	DaeGeometries

typedef ref_ptr< DaeNode >	DaeNodePtr

typedef std::map< std::string, DaeNodePtr >	DaeNodes

typedef std::vector< std::pair< std::string, DaeNodePtr > >	DaeNodeStack

typedef ref_ptr< DaeShape >	DaeShapePtr

typedef std::vector< DaeShapePtr >	DaeShapes

typedef ref_ptr< DaeMassFrame >	DaeMassFramePtr

typedef ref_ptr< DaeRigid >	DaeRigidPtr

typedef std::map< std::string, DaeRigidPtr >	DaeRigids

typedef std::map< std::string, std::string >	DaeRigidRelations

typedef ref_ptr< DaeRevolute >	DaeRevolutePtr

typedef std::map< std::string, DaeRevolutePtr >	DaeRevolutes

typedef std::vector< DaeRevolutePtr >	DaeRevoluteChildren

typedef std::vector< std::string >	DaeLinkChildren

typedef std::vector< std::string >	DaeJointChildren

typedef ref_ptr< DaeActuator >	DaeActuatorPtr

typedef std::map< std::string, DaeActuatorPtr >	DaeActuators

typedef std::map< std::string, std::string >	DaeActuatorRelations

typedef ref_ptr< DaeSensor >	DaeSensorPtr

typedef std::map< std::string, DaeSensorPtr >	DaeSensors

typedef std::vector< DaeSensor * >	DaeResultSensors

typedef boost::shared_ptr< DaeResultSensors >	DaeResultSensorsPtr

typedef std::vector< std::pair< std::string, std::string > >	DaeSensorRelations

typedef ref_ptr< DaeAttachActuator >	DaeAttachActuatorPtr

typedef ref_ptr< DaeAttachSensor >	DaeAttachSensorPtr

typedef ref_ptr< DaeLink >	DaeLinkPtr

typedef std::map< std::string, DaeLinkPtr >	DaeLinks

typedef ref_ptr< DaeJoint >	DaeJointPtr

typedef std::map< std::string, DaeJointPtr >	DaeJoints

typedef pair< string, DaeGeometryPtr >	GEOMETRY_PAIR

typedef pair< string, DaeNodePtr >	NODES_PAIR

typedef std::vector< std::string >	DaeOrder

typedef std::map< std::string, int >	DaeStrides

typedef std::map< std::string, std::string >	DaeVerticesRef

typedef Eigen::Matrix2d	Matrix2

typedef Eigen::Vector2d	Vector2

typedef Eigen::Matrix3d	Matrix3

typedef Eigen::Vector3d	Vector3

typedef Eigen::Matrix4d	Matrix4

typedef Eigen::Vector4d	Vector4

typedef Eigen::VectorXd	VectorX

typedef Eigen::Matrix< double, 6, 1 >	Vector6

typedef Eigen::Affine3d	Affine3

typedef Eigen::Translation3d	Translation3

typedef Eigen::AngleAxisd	AngleAxis

typedef Eigen::Quaterniond	Quat

typedef Eigen::Quaterniond	Quaternion

typedef Eigen::Transform< double, 3, Eigen::AffineCompact >	Position

typedef Eigen::Isometry3d	Isometry3

typedef boost::error_info< struct tag_error_info_message, std::string >	error_info_message

typedef boost::error_info< struct tag_error_info_key, std::string >	error_info_key

typedef MultiAffine3Seq::Ptr	MultiAffine3SeqPtr

typedef MultiSE3Seq::Ptr	MultiSE3SeqPtr

typedef MultiValueSeq::Ptr	MultiValueSeqPtr

typedef MultiVector3Seq::Ptr	MultiVector3SeqPtr

typedef ref_ptr< Referenced >	ReferencedPtr

typedef ref_ptr< SgCamera >	SgCameraPtr

typedef ref_ptr< SgPerspectiveCamera >	SgPerspectiveCameraPtr

typedef ref_ptr< SgOrthographicCamera >	SgOrthographicCameraPtr

typedef ref_ptr< SgMaterial >	SgMaterialPtr

typedef ref_ptr< SgImage >	SgImagePtr

typedef ref_ptr< SgTextureTransform >	SgTextureTransformPtr

typedef ref_ptr< SgTexture >	SgTexturePtr

typedef SgVectorArray< Vector3f >	SgVertexArray

typedef ref_ptr< SgVertexArray >	SgVertexArrayPtr

typedef SgVectorArray< Vector3f >	SgNormalArray

typedef ref_ptr< SgNormalArray >	SgNormalArrayPtr

typedef SgVectorArray< Vector3f >	SgColorArray

typedef ref_ptr< SgColorArray >	SgColorArrayPtr

typedef SgVectorArray< Vector2f, Eigen::aligned_allocator< Vector2f > >	SgTexCoordArray

typedef ref_ptr< SgTexCoordArray >	SgTexCoordArrayPtr

typedef std::vector< int >	SgIndexArray

typedef ref_ptr< SgMeshBase >	SgMeshBasePtr

typedef ref_ptr< SgMesh >	SgMeshPtr

typedef ref_ptr< SgPolygonMesh >	SgPolygonMeshPtr

typedef ref_ptr< SgShape >	SgShapePtr

typedef ref_ptr< SgPlot >	SgPlotPtr

typedef ref_ptr< SgPointSet >	SgPointSetPtr

typedef ref_ptr< SgLineSet >	SgLineSetPtr

typedef ref_ptr< SgFog >	SgFogPtr

typedef ref_ptr< SgOutlineGroup >	SgOutlineGroupPtr

typedef ref_ptr< SgObject >	SgObjectPtr

typedef ref_ptr< SgNode >	SgNodePtr

typedef std::vector< SgNode * >	SgNodePath

typedef ref_ptr< SgGroup >	SgGroupPtr

typedef ref_ptr< SgInvariantGroup >	SgInvariantGroupPtr

typedef ref_ptr< SgTransform >	SgTransformPtr

typedef ref_ptr< SgPosTransform >	SgPosTransformPtr

typedef ref_ptr< SgScaleTransform >	SgScaleTransformPtr

typedef ref_ptr< SgSwitch >	SgSwitchPtr

typedef ref_ptr< SgUnpickableGroup >	SgUnpickableGroupPtr

typedef ref_ptr< SgLight >	SgLightPtr

typedef ref_ptr< SgDirectionalLight >	SgDirectionalLightPtr

typedef ref_ptr< SgPointLight >	SgPointLightPtr

typedef ref_ptr< SgSpotLight >	SgSpotLightPtr

typedef ref_ptr< CrossMarker >	CrossMarkerPtr

typedef ref_ptr< SphereMarker >	SphereMarkerPtr

typedef ref_ptr< BoundingBoxMarker >	BoundingBoxMarkerPtr

typedef boost::function< void(TaskProc *proc)>	TaskFunc

typedef ref_ptr< TaskToggleState >	TaskToggleStatePtr

typedef ref_ptr< TaskCommand >	TaskCommandPtr

typedef ref_ptr< TaskPhaseProxy >	TaskPhaseProxyPtr

typedef ref_ptr< TaskPhase >	TaskPhasePtr

typedef ref_ptr< Task >	TaskPtr

typedef ref_ptr< ValueNode >	ValueNodePtr

typedef ref_ptr< Mapping >	MappingPtr

typedef ref_ptr< Listing >	ListingPtr

typedef boost::shared_ptr< Vector3Seq >	Vector3SeqPtr

typedef bool	SFBool

typedef int	SFInt32

typedef double	SFFloat

typedef std::string	SFString

typedef Eigen::Vector2d	SFVec2f

typedef Eigen::Vector2f	SFVec2s

typedef Eigen::Vector3d	SFVec3f

typedef Eigen::Vector3f	SFVec3s

typedef Eigen::Vector3f	SFColor

typedef Eigen::AngleAxisd	SFRotation

typedef std::vector< SFInt32 >	MFInt32

typedef std::vector< SFFloat >	MFFloat

typedef std::vector< SFVec2f, Eigen::aligned_allocator< SFVec2f > >	MFVec2f

typedef std::vector< SFVec2s >	MFVec2s

typedef std::vector< SFVec3f >	MFVec3f

typedef std::vector< SFVec3s >	MFVec3s

typedef std::vector< SFRotation >	MFRotation

typedef std::vector< SFTime >	MFTime

typedef std::vector< SFColor >	MFColor

typedef std::vector< SFString >	MFString

typedef boost::intrusive_ptr< VRMLNode >	VRMLNodePtr

typedef VRMLNodePtr	SFNode

typedef std::vector< SFNode >	MFNode

typedef boost::intrusive_ptr< VRMLUnsupportedNode >	VRMLUnsupportedNodePtr

typedef boost::intrusive_ptr< VRMLViewpoint >	VRMLViewpointPtr

typedef boost::intrusive_ptr< VRMLNavigationInfo >	VRMLNavigationInfoPtr

typedef boost::intrusive_ptr< VRMLBackground >	VRMLBackgroundPtr

typedef boost::intrusive_ptr< AbstractVRMLGroup >	AbstractVRMLGroupPtr

typedef boost::intrusive_ptr< VRMLGroup >	VRMLGroupPtr

typedef boost::intrusive_ptr< VRMLTransform >	VRMLTransformPtr

typedef boost::intrusive_ptr< VRMLInline >	VRMLInlinePtr

typedef boost::intrusive_ptr< VRMLAnotherFormatFile >	VRMLAnotherFormatFilePtr

typedef boost::intrusive_ptr< VRMLAppearance >	VRMLAppearancePtr

typedef boost::intrusive_ptr< VRMLGeometry >	VRMLGeometryPtr

typedef boost::intrusive_ptr< VRMLShape >	VRMLShapePtr

typedef boost::intrusive_ptr< VRMLMaterial >	VRMLMaterialPtr

typedef boost::intrusive_ptr< VRMLTexture >	VRMLTexturePtr

typedef boost::intrusive_ptr< VRMLTextureTransform >	VRMLTextureTransformPtr

typedef boost::intrusive_ptr< VRMLImageTexture >	VRMLImageTexturePtr

typedef boost::intrusive_ptr< VRMLBox >	VRMLBoxPtr

typedef boost::intrusive_ptr< VRMLCone >	VRMLConePtr

typedef boost::intrusive_ptr< VRMLCylinder >	VRMLCylinderPtr

typedef boost::intrusive_ptr< VRMLSphere >	VRMLSpherePtr

typedef boost::intrusive_ptr< VRMLFontStyle >	VRMLFontStylePtr

typedef boost::intrusive_ptr< VRMLText >	VRMLTextPtr

typedef boost::intrusive_ptr< VRMLColor >	VRMLColorPtr

typedef boost::intrusive_ptr< VRMLCoordinate >	VRMLCoordinatePtr

typedef boost::intrusive_ptr< VRMLIndexedLineSet >	VRMLIndexedLineSetPtr

typedef boost::intrusive_ptr< VRMLNormal >	VRMLNormalPtr

typedef boost::intrusive_ptr< VRMLTextureCoordinate >	VRMLTextureCoordinatePtr

typedef boost::intrusive_ptr< VRMLIndexedFaceSet >	VRMLIndexedFaceSetPtr

typedef boost::intrusive_ptr< VRMLCylinderSensor >	VRMLCylinderSensorPtr

typedef boost::intrusive_ptr< VRMLPointSet >	VRMLPointSetPtr

typedef boost::intrusive_ptr< VRMLPixelTexture >	VRMLPixelTexturePtr

typedef boost::intrusive_ptr< VRMLMovieTexture >	VRMLMovieTexturePtr

typedef boost::intrusive_ptr< VRMLElevationGrid >	VRMLElevationGridPtr

typedef boost::intrusive_ptr< VRMLExtrusion >	VRMLExtrusionPtr

typedef boost::intrusive_ptr< VRMLSwitch >	VRMLSwitchPtr

typedef boost::intrusive_ptr< VRMLLOD >	VRMLLODPtr

typedef boost::intrusive_ptr< VRMLCollision >	VRMLCollisionPtr

typedef boost::intrusive_ptr< VRMLAnchor >	VRMLAnchorPtr

typedef boost::intrusive_ptr< VRMLBillboard >	VRMLBillboardPtr

typedef boost::intrusive_ptr< VRMLFog >	VRMLFogPtr

typedef boost::intrusive_ptr< VRMLWorldInfo >	VRMLWorldInfoPtr

typedef boost::intrusive_ptr< VRMLLight >	VRMLLightPtr

typedef boost::intrusive_ptr< VRMLPointLight >	VRMLPointLightPtr

typedef boost::intrusive_ptr< VRMLDirectionalLight >	VRMLDirectionalLightPtr

typedef boost::intrusive_ptr< VRMLSpotLight >	VRMLSpotLightPtr

typedef boost::variant< SFBool, SFInt32, SFFloat, SFVec2f, SFVec3f, SFRotation, SFColor, SFTime, SFString, SFNode, SFImage, MFInt32, MFFloat, MFVec2f, MFVec3f, MFRotation, MFColor, MFTime, MFString, MFNode >	VRMLVariantField

typedef std::map< std::string, VRMLVariantField >	VRMLProtoFieldMap

typedef std::pair< std::string, VRMLVariantField >	VRMLProtoFieldPair

typedef boost::intrusive_ptr< VRMLProto >	VRMLProtoPtr

typedef boost::intrusive_ptr< VRMLProtoInstance >	VRMLProtoInstancePtr

typedef void(VRMLWriter::*	VRMLWriterNodeMethod) (VRMLNodePtr node)

typedef ref_ptr< AbstractSeqItem >	AbstractSeqItemPtr

typedef ref_ptr< AbstractMultiSeqItem >	AbstractMultiSeqItemPtr

typedef ref_ptr< AbstractTextItem >	AbstractTextItemPtr

typedef ref_ptr< Archive >	ArchivePtr

typedef ref_ptr< ExtCommandItem >	ExtCommandItemPtr

typedef ref_ptr< FolderItem >	FolderItemPtr

typedef ref_ptr< SgCustomGLNode >	SgCustomGLNodePtr

typedef boost::shared_ptr< GraphDataHandler >	GraphDataHandlerPtr

typedef ref_ptr< InteractiveCameraTransform >	InteractiveCameraTransformPtr

typedef ref_ptr< Item >	ItemPtr

typedef MultiSeqItem< MultiAffine3Seq >	MultiAffine3SeqItem

typedef MultiAffine3SeqItem::Ptr	MultiAffine3SeqItemPtr

typedef ref_ptr< MultiPointSetItem >	MultiPointSetItemPtr

typedef MultiSeqItem< MultiSE3Seq >	MultiSE3SeqItem

typedef MultiSE3SeqItem::Ptr	MultiSE3SeqItemPtr

typedef MultiSeqItem< MultiValueSeq >	MultiValueSeqItem

typedef MultiValueSeqItem::Ptr	MultiValueSeqItemPtr

typedef ref_ptr< PointSetItem >	PointSetItemPtr

typedef ref_ptr< PositionDragger >	PositionDraggerPtr

typedef std::vector< std::string >	FileDialogFilter

typedef ref_ptr< RectRegionMarker >	RectRegionMarkerPtr

typedef ref_ptr< RootItem >	RootItemPtr

typedef ref_ptr< RotationDragger >	RotationDraggerPtr

typedef ref_ptr< SceneDragger >	SceneDraggerPtr

typedef ref_ptr< SceneItem >	SceneItemPtr

typedef ref_ptr< SceneWidgetRoot >	SceneWidgetRootPtr

typedef ref_ptr< ScriptItem >	ScriptItemPtr

typedef ref_ptr< TimeSyncItemEngine >	TimeSyncItemEnginePtr

typedef ref_ptr< TranslationDragger >	TranslationDraggerPtr

typedef ref_ptr< Vector3SeqItem >	Vector3SeqItemPtr

typedef boost::shared_ptr< AbstractBodyLoader >	AbstractBodyLoaderPtr

typedef ref_ptr< AccelerationSensor >	AccelerationSensorPtr

typedef void *	BodyCustomizerHandle

typedef ref_ptr< Body >	BodyPtr

typedef void *	BodyHandle

typedef int(*	BodyGetLinkIndexFromNameFunc) (BodyHandle bodyHandle, const char *linkName)

typedef const char (	BodyGetLinkNameFunc) (BodyHandle bodyHandle, int linkIndex)

typedef double (	BodyGetLinkDoubleValuePtrFunc) (BodyHandle bodyHandle, int linkIndex)

typedef const char *(	BodyCustomizerGetTargetModelNamesFunc) ()

typedef BodyCustomizerHandle(*	BodyCustomizerCreateFunc) (BodyHandle bodyHandle, const char *modelName)

typedef void(*	BodyCustomizerDestroyFunc) (BodyCustomizerHandle customizerHandle)

typedef int(*	BodyCustomizerInitializeAnalyticIkFunc) (BodyCustomizerHandle customizerHandle, int baseLinkIndex, int targetLinkIndex)

typedef bool(*	BodyCustomizerCalcAnalyticIkFunc) (BodyCustomizerHandle customizerHandle, int ikPathId, const Vector3 &p, const Matrix3 &R)

typedef void(*	BodyCustomizerSetVirtualJointForcesFunc) (BodyCustomizerHandle customizerHandle)

typedef BodyCustomizerInterface (	GetBodyCustomizerInterfaceFunc) (BodyInterface *bodyInterface)

typedef boost::shared_ptr< BodyMotion >	BodyMotionPtr

typedef boost::shared_ptr< JointPath >	JointPathPtr

typedef ref_ptr< Camera >	CameraPtr

typedef map< string, Link * >	LoaderLinks

typedef vector< string >	LoaderJoints

typedef boost::shared_ptr< CollisionLinkPair >	CollisionLinkPairPtr

typedef boost::shared_ptr< CompositeIK >	CompositeIKPtr

typedef ref_ptr< DeviceState >	DeviceStatePtr

typedef ref_ptr< Device >	DevicePtr

typedef ref_ptr< DyBody >	DyBodyPtr

typedef ref_ptr< ExtraBodyStateAccessor >	ExtraBodyStateAccessorPtr

typedef ref_ptr< ForceSensor >	ForceSensorPtr

typedef boost::shared_ptr< ForwardDynamics >	ForwardDynamicsPtr

typedef boost::shared_ptr< ForwardDynamicsCBM >	ForwardDynamicsCBMPtr

typedef boost::shared_ptr< InverseKinematics >	InverseKinematicsPtr

typedef ref_ptr< LeggedBodyHelper >	LeggedBodyHelperPtr

typedef ref_ptr< Light >	LightPtr

typedef ref_ptr< Link >	LinkPtr

typedef boost::shared_ptr< LinkGroup >	LinkGroupPtr

typedef MultiDeviceStateSeq::Ptr	MultiDeviceStateSeqPtr

typedef boost::shared_ptr< PenetrationBlocker >	PenetrationBlockerPtr

typedef boost::shared_ptr< PinDragIK >	PinDragIKptr

typedef ref_ptr< PointLight >	PointLightPtr

typedef ref_ptr< RangeCamera >	RangeCameraPtr

typedef ref_ptr< RangeSensor >	RangeSensorPtr

typedef ref_ptr< RateGyroSensor >	RateGyroSensorPtr

typedef ref_ptr< SceneLink >	SceneLinkPtr

typedef ref_ptr< SceneBody >	SceneBodyPtr

typedef ref_ptr< SceneCollision >	SceneCollisionPtr

typedef ref_ptr< SceneDevice >	SceneDevicePtr

typedef ref_ptr< SpotLight >	SpotLightPtr

typedef boost::intrusive_ptr< VRMLHumanoid >	VRMLHumanoidPtr

typedef boost::intrusive_ptr< VRMLJoint >	VRMLJointPtr

typedef boost::intrusive_ptr< VRMLSegment >	VRMLSegmentPtr

typedef boost::intrusive_ptr< VRMLSurface >	VRMLSurfacePtr

typedef boost::intrusive_ptr< VRMLVisionSensor >	VRMLVisionSensorPtr

typedef boost::intrusive_ptr< VRMLForceSensor >	VRMLForceSensorPtr

typedef boost::intrusive_ptr< VRMLGyro >	VRMLGyroPtr

typedef boost::intrusive_ptr< VRMLAccelerationSensor >	VRMLAccelerationSensorPtr

typedef boost::intrusive_ptr< VRMLRangeSensor >	VRMLRangeSensorPtr

typedef boost::shared_ptr< ZMPSeq >	ZMPSeqPtr

typedef boost::shared_ptr< AISTCollisionDetector >	AISTCollisionDetectorPtr

typedef boost::shared_ptr< ColdetModel >	ColdetModelPtr

typedef boost::shared_ptr< ColdetModelPair >	ColdetModelPairPtr

typedef ref_ptr< AISTSimulatorItem >	AISTSimulatorItemPtr

typedef ref_ptr< BodyItem >	BodyItemPtr

typedef ref_ptr< BodyMotionControllerItem >	BodyMotionControllerItemPtr

typedef ref_ptr< BodyMotionEngine >	BodyMotionEnginePtr

typedef ref_ptr< BodyMotionItem >	BodyMotionItemPtr

typedef ref_ptr< BodyTrackingCameraItem >	BodyTrackingCameraItemPtr

typedef std::vector< CollisionLinkPairPtr >	CollisionLinkPairList

typedef boost::shared_ptr< CollisionLinkPairList >	CollisionLinkPairListPtr

typedef boost::shared_ptr< CollisionSeq >	CollisionSeqPtr

typedef ref_ptr< CollisionSeqEngine >	CollisionSeqEnginePtr

typedef ref_ptr< CollisionSeqItem >	CollisionSeqItemPtr

typedef ref_ptr< ControllerItem >	ControllerItemPtr

typedef ref_ptr< EditableSceneLink >	EditableSceneLinkPtr

typedef ref_ptr< EditableSceneBody >	EditableSceneBodyPtr

typedef ref_ptr< GLVisionSimulatorItem >	GLVisionSimulatorItemPtr

typedef ref_ptr< MultiDeviceStateSeqItem >	MultiDeviceStateSeqItemPtr

typedef ref_ptr< SensorVisualizerItem >	SensorVisualizerItemPtr

typedef ref_ptr< SimulationScriptItem >	SimulationScriptItemPtr

typedef ref_ptr< SimulationBody >	SimulationBodyPtr

typedef ref_ptr< SimulatorItem >	SimulatorItemPtr

typedef ref_ptr< SubSimulatorItem >	SubSimulatorItemPtr

typedef ref_ptr< WorldItem >	WorldItemPtr

typedef ref_ptr< WorldLogFileItem >	WorldLogFileItemPtr

typedef ref_ptr< ZMPSeqItem >	ZMPSeqItemPtr

typedef ref_ptr< SimpleControllerItem >	SimpleControllerItemPtr

typedef ref_ptr< PoseUnit >	PoseUnitPtr

typedef ref_ptr< Pose >	PosePtr

typedef ref_ptr< PoseSeq >	PoseSeqPtr

typedef boost::shared_ptr< PoseSeqInterpolator >	PoseSeqInterpolatorPtr

typedef ref_ptr< PoseSeqItem >	PoseSeqItemPtr

typedef ref_ptr< PronunSymbol >	PronunSymbolPtr

typedef boost::shared_ptr< ODECollisionDetector >	ODECollisionDetectorPtr

typedef std::map< dBodyID, Link * >	CrawlerLinkMap

typedef ref_ptr< ODESimulatorItem >	ODESimulatorItemPtr

typedef boost::shared_ptr< BulletCollisionDetector >	BulletCollisionDetectorPtr

typedef ref_ptr< BulletSimulatorItem >	BulletSimulatorItemPtr

typedef ref_ptr< PythonScriptItem >	PythonScriptItemPtr

typedef ref_ptr< PythonSimScriptItem >	PythonSimScriptItemPtr

typedef ref_ptr< AudioItem >	AudioItemPtr

typedef ref_ptr< MediaItem >	MediaItemPtr

typedef ref_ptr< BodyRTCItem >	BodyRTCItemPtr

typedef ref_ptr< OpenHRPClockGeneratorItem >	OpenHRPClockGeneratorItemPtr

typedef map< string, string >	PropertyMap

typedef ref_ptr< RTCItem >	RTCItemPtr

typedef boost::shared_ptr< PortHandler >	PortHandlerPtr

typedef boost::shared_ptr< OutPortHandler >	OutPortHandlerPtr

typedef boost::shared_ptr< InPortHandler >	InPortHandlerPtr

typedef ref_ptr< OpenHRPControllerItem >	OpenHRPControllerItemPtr

typedef OpenHRPInterpreterServiceItemImpl	ItemImpl

typedef ref_ptr< OpenHRPInterpreterServiceItem >	OpenHRPInterpreterServiceItemPtr

typedef ref_ptr< OpenHRPOnlineViewerItem >	OpenHRPOnlineViewerItemPtr

Enumerations
enum	{ EXT_NODE, EXT_UNIT, EXT_TRANSLATE, EXT_ROTATE, EXT_SCALE, EXT_MATRIX, EXT_INSTANCE_NODE, EXT_INSTANCE_GEOMETRY, EXT_INSTANCE_MATERIAL, EXT_INSTANCE_EFFECT, EXT_GEOMETRY, EXT_VERTICES, EXT_SOURCE, EXT_FLOAT_ARRAY, EXT_ACCESSOR, EXT_INPUT, EXT_TRIANGLES, EXT_LINES, EXT_P, EXT_MATERIAL, EXT_EFFECT, EXT_EMISSION, EXT_AMBIENT, EXT_DIFFUSE, EXT_SPECULAR, EXT_SHININESS, EXT_TRANSPARENCY, EXT_INIT_FORM, EXT_IMAGE, EXT_POLYLIST, EXT_VCOUNT, EXT_BOX, EXT_SPHERE, EXT_CYLINDER, EXT_TAPERED_CYLINDER, EXT_KINEMATICS_MODEL, EXT_LINK, EXT_ATTACHMENT_FULL, EXT_JOINT, EXT_REVOLUTE, EXT_PRISMATIC, EXT_AXIS, EXT_MIN, EXT_MAX, EXT_RIGID_BODY, EXT_SHAPE, EXT_INSTANCE_RIGID_BODY, EXT_INSTANCE_PHYSICS_MODEL, EXT_MASS, EXT_MASS_FRAME, EXT_INERTIA, EXT_ACTUATOR, EXT_ASSIGNED_POWER_RATING, EXT_MAX_SPEED, EXT_NO_LOAD_SPEED, EXT_NOMINAL_TORQUE, EXT_NOMINAL_VOLTAGE, EXT_ROTOR_INERTIA, EXT_SPEED_CONSTANT, EXT_SPEED_TORQUE_GRADIENT, EXT_STARTING_CURRENT, EXT_TERMINAL_RESISTANCE, EXT_TORQUE_CONSTANT, EXT_INSTANCE_ACTUATOR, EXT_BIND_ACTUATOR, EXT_INSTANCE_SENSOR, EXT_FRAME_ORIGIN, EXT_SENSOR, EXT_FOCAL_LENGTH, EXT_INTRINSIC, EXT_IMAGE_DIMENSIONS, EXT_MEASUREMENT_TIME, EXT_EXTRA }
	Enumeration type of "TAG" used in Collada. More...

enum	{ EXT_POSITION, EXT_VERTEX, EXT_NORMAL, EXT_COLOR, EXT_TEXCOORD }
	These indexes are defined in polylist tag and triangles. More...

enum	{ EXT_VISUAL_SCENES, EXT_GEOMETRIES, EXT_MATERIALS, EXT_EFFECTS, EXT_NODES, EXT_IMAGES, EXT_PHYSICS_MODELS, EXT_KINEMATICS_MODELS, EXT_PHYSICS_SCENES }
	An enumeration type of the "BASE" node in the Collada. Information("CONCRETE or LIBRARY") of the entity has been stored in these nodes. More...

enum	{ EXT_NODE_NODE, EXT_NODE_JOINT }
	There are two types of joint and node to node of Collada. It will remain at that type when reading the node tags. More...

enum	StringStyle { PLAIN_STRING, SINGLE_QUOTED, DOUBLE_QUOTED, LITERAL_STRING, FOLDED_STRING }

enum	VRMLNodeCategory { ANY_NODE = -1, PROTO_DEF_NODE = 0, PROTO_INSTANCE_NODE, TOP_NODE, BINDABLE_NODE, GROUPING_NODE, CHILD_NODE, APPEARANCE_NODE, MATERIAL_NODE, TEXTURE_NODE, TEXTURE_TRANSFORM_NODE, SHAPE_NODE, GEOMETRY_NODE, COORDINATE_NODE, COLOR_NODE, NORMAL_NODE, TEXTURE_COORDINATE_NODE, LIGHT_NODE, FONT_STYLE_NODE, SENSOR_NODE, INLINE_NODE, NUM_VRML_NODE_CATEGORIES }

enum	VRMLFieldTypeId { SFBOOL, SFINT32, SFFLOAT, SFVEC2F, SFVEC3F, SFROTATION, SFCOLOR, SFTIME, SFSTRING, SFNODE, SFIMAGE, MFINT32, MFFLOAT, MFVEC2F, MFVEC3F, MFROTATION, MFCOLOR, MFTIME, MFSTRING, MFNODE, UNKNOWN_VRML_FIELD_TYPE }

enum	{ IDLE_PRIORITY_HIGH = LazyCaller::PRIORITY_HIGH, IDLE_PRIORITY_NORMAL = LazyCaller::PRIORITY_NORMAL, IDLE_PRIORITY_LOW = LazyCaller::PRIORITY_LOW }
	deprecated More...

Functions
CNOID_EXPORT std::ostream &	operator<< (std::ostream &os, const BoundingBox &bb)

CNOID_EXPORT std::ostream &	operator<< (std::ostream &os, const BoundingBoxf &bb)

CNOID_EXPORT EasyScanner &	operator>> (EasyScanner &scanner, double &value)

CNOID_EXPORT EasyScanner &	operator>> (EasyScanner &scanner, int &value)

CNOID_EXPORT EasyScanner &	operator>> (EasyScanner &scanner, const char *matchString)

CNOID_EXPORT EasyScanner &	operator>> (EasyScanner &scanner, char matchChar)

CNOID_EXPORT EasyScanner &	operator>> (EasyScanner &scanner, std::string &str)

CNOID_EXPORT EasyScanner &	operator>> (EasyScanner &scanner, EasyScanner::Endl endl)

template<typename Derived >
void	read (const Listing &listing, Eigen::MatrixBase< Derived > &x)

template<typename Derived >
bool	read (const Mapping &mapping, const std::string &key, Eigen::MatrixBase< Derived > &x)

template<typename Scalar , int Dim, int Mode>
bool	read (const Mapping &mapping, const std::string &key, Eigen::Transform< Scalar, Dim, Mode > &T)

template<typename Derived >
void	readEx (const Mapping &mapping, const std::string &key, Eigen::MatrixBase< Derived > &x)

template<typename Derived >
Listing &	write (Mapping &mapping, const std::string &key, const Eigen::MatrixBase< Derived > &x)

template<typename Scalar , int Dim, int Mode>
Listing &	write (Mapping &mapping, const std::string &key, const Eigen::Transform< Scalar, Dim, Mode > &T)

template<typename Scalar >
bool	read (const Mapping &mapping, const std::string &key, Eigen::AngleAxis< Scalar > &r)

template<typename Scalar >
Listing &	write (Mapping &mapping, const std::string &key, const Eigen::AngleAxis< Scalar > &r)

bool	read (const Mapping &mapping, const std::string &key, boost::function< void(Vector3 &)> setterFunc)

Matrix3	rotFromRpy (double r, double p, double y)

Vector3	rpyFromRot (const Matrix3 &R)

Vector3	omegaFromRot (const Matrix3 &R)

std::string	str (const Vector3 &v)

bool	toVector3 (const std::string &s, Vector3 &out_v)

void	normalizeRotation (Matrix3 &R)

void	normalizeRotation (Position &T)

void	normalizeRotation (Affine3 &T)

double	degree (double rad)

double	radian (double deg)

float	degree (float rad)

float	radian (float deg)

double	radian (int deg)

Matrix3	rotFromRpy (const Vector3 &rpy)

Matrix3	hat (const Vector3 &x)

template<class T >
boost::shared_ptr< T >	make_shared_aligned ()

template<class T , class P1 >
boost::shared_ptr< T >	make_shared_aligned (const P1 &p1)

template<class T , class P1 , class P2 >
boost::shared_ptr< T >	make_shared_aligned (const P1 &p1, const P2 &p2)

template<class T , class P1 , class P2 , class P3 >
boost::shared_ptr< T >	make_shared_aligned (const P1 &p1, const P2 &p2, const P3 &p3)

template<class T , class P1 , class P2 , class P3 , class P4 >
boost::shared_ptr< T >	make_shared_aligned (const P1 &p1, const P2 &p2, const P3 &p3, const P4 &p4)

void	findExecutablePath ()

const std::string &	executablePath ()

const std::string &	executableDirectory ()

const std::string &	executableTopDirectory ()

const std::string &	shareDirectory ()

const std::string &	executableBasename ()

void	makePathCompact (const filesystem::path &path, filesystem::path &out_compact)

int	findSubDirectory (const filesystem::path &directory, const filesystem::path &path, filesystem::path &out_subdirectory)

bool	findRelativePath (const filesystem::path &from_, const filesystem::path &to, filesystem::path &out_relativePath)

std::string	toActualPathName (const std::string &path)

std::string	getExtension (const boost::filesystem::path &path)

std::string	getGenericPathString (const boost::filesystem::path &path)

bool	checkAbsolute (const boost::filesystem::path &path)

boost::filesystem::path	getAbsolutePath (const boost::filesystem::path &path)

std::string	getAbsolutePathString (const boost::filesystem::path &path)

std::string	getFilename (const boost::filesystem::path &path)

std::string	getFilename (const std::string &pathString)

std::string	getBasename (const boost::filesystem::path &path)

std::string	getPathString (const boost::filesystem::path &path)

std::string	getNativePathString (const boost::filesystem::path &path)

CNOID_EXPORT void	makePathCompact (const boost::filesystem::path &path, boost::filesystem::path &out_compact)

CNOID_EXPORT int	findSubDirectory (const boost::filesystem::path &directory, const boost::filesystem::path &path, boost::filesystem::path &out_subdirectory)

CNOID_EXPORT bool	findRelativePath (const boost::filesystem::path &from, const boost::filesystem::path &to, boost::filesystem::path &out_relativePath)

template<class T >
void	setGaussWindow (T sigma, int range, std::vector< T > &out_window)

template<class RESULTVECTOR , class SRCVECTOR , class ELEMENT , class T >
void	applyGaussianFilter (RESULTVECTOR &result, const SRCVECTOR &src, std::vector< T > &gwin, ELEMENT zero)

template<class RESULTVECTOR , class SRCVECTOR , class ELEMENT , class T >
void	applyGaussianFilter (RESULTVECTOR &result, const SRCVECTOR &src, T sigma, int range, ELEMENT zero)

boost::format	fmt (const char *f_string)

boost::format	fmt (const std::string &f_string)

const char *	getText (const char domainname, const char msgid)

CNOID_EXPORT void	bindGettextDomain (const char *domainname)

std::ostream &	nullout ()

CNOID_EXPORT void	loadPCD (SgPointSet *out_pointSet, const std::string &filename)

CNOID_EXPORT void	savePCD (SgPointSet *pointSet, const std::string &filename, const Affine3d &viewpoint=Affine3d::Identity())

template<class T , class U >
bool	operator== (ref_ptr< T > const &a, ref_ptr< U > const &b)

template<class T , class U >
bool	operator!= (ref_ptr< T > const &a, ref_ptr< U > const &b)

template<class T , class U >
bool	operator== (ref_ptr< T > const &a, U *b)

template<class T , class U >
bool	operator!= (ref_ptr< T > const &a, U *b)

template<class T , class U >
bool	operator== (T *a, ref_ptr< U > const &b)

template<class T , class U >
bool	operator!= (T *a, ref_ptr< U > const &b)

template<class T >
bool	operator< (ref_ptr< T > const &a, ref_ptr< T > const &b)

template<class T >
void	swap (ref_ptr< T > &lhs, ref_ptr< T > &rhs)

template<class T , class U >
ref_ptr< T >	static_pointer_cast (ref_ptr< U > const &p)

template<class T , class U >
ref_ptr< T >	const_pointer_cast (ref_ptr< U > const &p)

template<class T , class U >
ref_ptr< T >	dynamic_pointer_cast (ref_ptr< U > const &p)

template<class Y >
std::ostream &	operator<< (std::ostream &os, ref_ptr< Y > const &p)

template<class T , class U >
bool	operator< (weak_ref_ptr< T > const &a, weak_ref_ptr< U > const &b)

template<class T >
void	swap (weak_ref_ptr< T > &a, weak_ref_ptr< T > &b)

CNOID_EXPORT Affine3	calcTotalTransform (const SgNodePath &path)

CNOID_EXPORT Affine3	calcTotalTransform (const SgNodePath &path, const SgNode *targetNode)

CNOID_EXPORT Affine3	calcTotalTransform (SgNodePath::const_iterator begin, SgNodePath::const_iterator end)

CNOID_EXPORT int	makeTransparent (SgNode *topNode, float transparency, SgCloneMap &cloneMap, bool doKeepOrgTransparency=true)

void	msleep (int msec)

void	usleep (int usec)

const std::string &	toUTF8 (const std::string &text)

const std::string &	fromUTF8 (const std::string &text)

const std::string	toUTF8 (const char *text)

const std::string	fromUTF8 (const char *text)

template<>
std::string	ValueNode::to< std::string > () const

template<class Container >
bool	writeElements (Mapping &mapping, const std::string &key, const Container &elements, bool isFlowStyle=false)

template<class Container >
bool	readElements (const Mapping &mapping, const std::string &key, Container &elements)

void	intrusive_ptr_add_ref (VRMLNode *obj)

void	intrusive_ptr_release (VRMLNode *obj)

CNOID_EXPORT const char *	labelOfVRMLfieldTypeId (const std::type_info &fieldType)

template<typename TValue >
const char *	labelOfVRMLfieldType ()

template<class VRMLNodeType >
boost::intrusive_ptr< VRMLNodeType >	dynamic_node_cast (VRMLNodePtr node)

std::ostream &	operator<< (std::ostream &out, TIndent &indent)

const char *	boolstr (bool v)

std::ostream &	operator<< (std::ostream &out, const SFVec2f &v)

std::ostream &	operator<< (std::ostream &out, const SFVec3f &v)

std::ostream &	operator<< (std::ostream &out, const SFColor &v)

std::ostream &	operator<< (std::ostream &out, const SFRotation &v)

CNOID_EXPORT SignalProxy< void()>	sigAboutToQuit ()

bool	findSubDirectoryOfDirectoryVariable (ArchiveSharedData *shared, const filesystem::path &path, std::string &out_varName, filesystem::path &out_relativePath)

void	replaceDirectoryVariable (ArchiveSharedData *shared, QString &io_pathString, const QString &varname, int pos, int len)

CNOID_EXPORT std::ostream &	mvout (bool doFlush=false)

QString	makeFilterString (const std::string &caption, const std::string &extensions_)

std::string	getOpenFileName (const std::string &caption, const std::string &extensions)

std::vector< std::string >	getOpenFileNames (const std::string &caption, const std::string &extensions)

CNOID_EXPORT void	callLater (const boost::function< void()> &function, int priority=LazyCaller::PRIORITY_NORMAL)

CNOID_EXPORT void	callFromMainThread (const boost::function< void()> &function, int priority=LazyCaller::PRIORITY_NORMAL)

CNOID_EXPORT bool	callSynchronously (const boost::function< void()> &function, int priority=LazyCaller::PRIORITY_NORMAL)

CNOID_EXPORT bool	isRunningInMainThread ()

const char *	LGPLtext ()

CNOID_EXPORT void	showMessageBox (const std::string &message)

CNOID_EXPORT void	showMessageBox (const boost::format &message)

CNOID_EXPORT void	showMessageBox (const char *message)

CNOID_EXPORT void	showMessageBox (const QString &message)

CNOID_EXPORT void	showWarningDialog (const std::string &message)

CNOID_EXPORT void	showWarningDialog (const boost::format &message)

CNOID_EXPORT void	showWarningDialog (const char *message)

CNOID_EXPORT void	showWarningDialog (const QString &message)

CNOID_EXPORT bool	showConfirmDialog (const char caption, const char message)

CNOID_EXPORT bool	showConfirmDialog (const std::string &caption, const std::string &message)

CNOID_EXPORT bool	showConfirmDialog (const QString &caption, const QString &message)

template<class ValueType >
ChangeProperty< ValueType >	changeProperty (ValueType &variable)

CNOID_EXPORT int	addBodyToCollisionDetector (Body &body, CollisionDetector &detector, bool enableSelfCollisions=true)

CNOID_EXPORT int	loadBodyCustomizers (const std::string pathString, BodyInterface *bodyInterface)

CNOID_EXPORT int	loadBodyCustomizers (const std::string pathString)

CNOID_EXPORT int	loadBodyCustomizers (BodyInterface *bodyInterface)

CNOID_EXPORT int	loadBodyCustomizers ()

CNOID_EXPORT BodyCustomizerInterface *	findBodyCustomizer (std::string modelName)

BodyMotion::Frame	operator<< (BodyMotion::Frame frame, const Body &body)

const Body &	operator>> (const Body &body, BodyMotion::Frame frame)

BodyMotion::Frame	operator>> (BodyMotion::Frame frame, Body &body)

BodyMotion::ConstFrame	operator>> (BodyMotion::ConstFrame frame, Body &body)

Body &	operator<< (Body &body, BodyMotion::Frame frame)

Body &	operator<< (Body &body, BodyMotion::ConstFrame frame)

CNOID_EXPORT bool	loadHrpsysSeqFileSet (BodyMotion &motion, const std::string &filename, std::ostream &os)

CNOID_EXPORT bool	saveHrpsysSeqFileSet (BodyMotion &motion, Body *body, const std::string &filename, std::ostream &os)

CNOID_EXPORT void	calcLinkAccSeq (MultiSE3Seq &linkPosSeq, AccelerationSensor *gsens, int frameBegin, int numFrames, Vector3Seq &out_accSeq)

CNOID_EXPORT bool	applyVelocityLimitFilter (MultiValueSeq &seq, Body *body, std::ostream &os=nullout())

CNOID_EXPORT bool	applyVelocityLimitFilter2 (MultiValueSeq &seq, int part, double absLimit)

CNOID_EXPORT bool	applyVelocityLimitFilterDummy ()

CNOID_EXPORT bool	applyPollardVelocityLimitFilter (MultiValueSeq &seq, Body *body, double ks, std::ostream &os=nullout())

CNOID_EXPORT void	applyGaussianFilter (MultiValueSeq &seq, double sigma, int range, std::ostream &os=nullout())

CNOID_EXPORT void	applyRangeLimitFilter (MultiValueSeq &seq, Body *body, double limitGrad, double edgeGradRatio, double margin, std::ostream &os=nullout())

Vector6	calcInverseDynamics (Link *link)

void	calcCMJacobian (Body body, Link base, Eigen::MatrixXd &J)
	compute CoM Jacobian More...

void	calcAngularMomentumJacobian (Body body, Link base, Eigen::MatrixXd &H)
	compute Angular Momentum Jacobian More...

template<int elementMask, int rowOffset, int colOffset, bool useTargetLinkLocalPos>
void	setJacobian (const JointPath &path, Link *targetLink, const Vector3 &targetLinkLocalPos, MatrixXd &out_J)

template<int elementMask, int rowOffset, int colOffset>
void	setJacobian (const JointPath &path, Link *targetLink, MatrixXd &out_J)

CNOID_EXPORT JointPathPtr	getCustomJointPath (Body body, Link baseLink, Link *targetLink)

LeggedBodyHelper *	getLeggedBodyHelper (Body *body)

void	calcMassMatrix (Body *body, const Vector3 &g, Eigen::MatrixXd &out_M)

void	calcMassMatrix (const BodyPtr &body, MatrixXd &out_M)

CNOID_EXPORT void	calcMassMatrix (Body *body, const Vector3 &g, MatrixXd &out_M)

CNOID_EXPORT void	calcMassMatrix (Body *body, MatrixXd &out_M)

CNOID_EXPORT MultiDeviceStateSeqPtr	getMultiDeviceStateSeq (const BodyMotion &motion)

CNOID_EXPORT MultiDeviceStateSeqPtr	getOrCreateMultiDeviceStateSeq (BodyMotion &motion)

CNOID_EXPORT void	clearMultiDeviceStateSeq (BodyMotion &motion)

CNOID_EXPORT ZMPSeqPtr	getZMPSeq (const BodyMotion &motion)

CNOID_EXPORT ZMPSeqPtr	getOrCreateZMPSeq (BodyMotion &motion)

CNOID_EXPORT void	clearZMPSeq (BodyMotion &motion)

CNOID_EXPORT bool	makeRootRelative (ZMPSeq &zmpseq, BodyMotion &motion, bool on)

TimeSyncItemEngine *	createBodyMotionEngine (Item *sourceItem)

void	initializeFilterDialogs (ExtensionManager &ext)

void	initializeHrpsysFileIO (ExtensionManager *ext)

void	initializeFcpFileLoader (ExtensionManager &ext)

CNOID_EXPORT void	adjustStepPositions (PoseSeqPtr seq, const std::vector< int > &footLinkIndices, PoseSeq::iterator origin)

CNOID_EXPORT void	flipPoses (PoseSeqPtr seq, BodyPtr body)

CNOID_EXPORT void	adjustWaistHeight (PosePtr pose, int waistLinkIndex, const std::vector< int > &footLinkIndices, double offset)

CNOID_EXPORT void	rotateYawOrientations (PoseSeqPtr seq, PoseSeq::iterator begin, const Vector3 &center, double angle)

void	initializePoseSeqEngine (ExtensionManager *em)

CNOID_EXPORT void	handlePythonException ()

CNOID_EXPORT boost::python::object	pythonMainModule ()

CNOID_EXPORT boost::python::object	pythonMainNamespace ()

CNOID_EXPORT boost::python::object	pythonSysModule ()

CNOID_EXPORT bool	execPythonCode (const std::string &code)

CNOID_EXPORT bool	playAudioFile (const std::string &filename, double volumeRatio=-1.0)

CNOID_EXPORT void	initializeCorbaUtil (bool activatePOAManager=false, int listeningPort=-1)

CNOID_EXPORT void	initializeCorbaUtil (CORBA::ORB_ptr orb, bool activatePOAManager=false)

CNOID_EXPORT CORBA::ORB_ptr	getORB ()

CNOID_EXPORT NamingContextHelper *	getDefaultNamingContextHelper ()

void	checkOrInvokeCorbaNameServer ()

bool	takeOverCorbaPluginInitialization (CORBA::ORB_ptr orb)

template<>
CORBA::Object::_ptr_type	findRTCService< CORBA::Object > (RTC::RTObject_ptr rtc, const std::string &name)

CNOID_EXPORT RTM::Manager_ptr	getRTCManagerServant ()

CNOID_EXPORT RTC::RTObject_impl *	createManagedRTC (const char *comp_args)

CNOID_EXPORT int	numUnmanagedRTCs ()

CNOID_EXPORT int	deleteUnmanagedRTCs ()

template<class ServiceType >
ServiceType::_ptr_type	findRTCService (RTC::RTObject_ptr rtc, const std::string &name)

template<>
CNOID_EXPORT CORBA::Object::_ptr_type	findRTCService< CORBA::Object > (RTC::RTObject_ptr rtc, const std::string &name)

CNOID_EXPORT bool	deleteRTC (RTC::RtcBase *rtc, bool waitToBeDeleted=true)

Variables
const double	PI = 3.14159265358979323846

const double	PI_2 = 1.57079632679489661923

const double	TO_DEGREE = 180.0 / PI

const double	TO_RADIAN = PI / 180.0

const bool	BODY_SIMULATION_PROFILING = false

const bool	SIMULATION_PROFILING = false

PortableServer::POA_var	nspoa

Detailed Description

Defines the minimum processing for performing pasing file for STL.

Author: Shin'ichiro Nakaoka; Shizuko Hattori; Shin'ichiro Nakaoka; Shin'ichiro NAKAOKA; Shizuko Hattori; Hisashi Ikari; Shin'ichiro Nakaoka

Typedef Documentation

◆ AbstractBodyLoaderPtr

typedef boost::shared_ptr<AbstractBodyLoader> cnoid::AbstractBodyLoaderPtr

◆ AbstractMultiSeqItemPtr

typedef ref_ptr<AbstractMultiSeqItem> cnoid::AbstractMultiSeqItemPtr

◆ AbstractMultiSeqPtr

typedef boost::shared_ptr<AbstractMultiSeq> cnoid::AbstractMultiSeqPtr

◆ AbstractSeqItemPtr

typedef ref_ptr<AbstractSeqItem> cnoid::AbstractSeqItemPtr

◆ AbstractSeqPtr

typedef boost::shared_ptr<AbstractSeq> cnoid::AbstractSeqPtr

◆ AbstractTextItemPtr

typedef ref_ptr<AbstractTextItem> cnoid::AbstractTextItemPtr

◆ AbstractVRMLGroupPtr

typedef boost::intrusive_ptr<AbstractVRMLGroup> cnoid::AbstractVRMLGroupPtr

◆ AccelerationSensorPtr

typedef ref_ptr<AccelerationSensor> cnoid::AccelerationSensorPtr

◆ Affine3

typedef Eigen::Affine3d cnoid::Affine3

◆ AISTCollisionDetectorPtr

typedef boost::shared_ptr<AISTCollisionDetector> cnoid::AISTCollisionDetectorPtr

◆ AISTSimulatorItemPtr

typedef ref_ptr<AISTSimulatorItem> cnoid::AISTSimulatorItemPtr

◆ AngleAxis

typedef Eigen::AngleAxisd cnoid::AngleAxis

◆ ArchivePtr

typedef ref_ptr<Archive> cnoid::ArchivePtr

◆ AudioItemPtr

typedef ref_ptr<AudioItem> cnoid::AudioItemPtr

◆ BodyCustomizerCalcAnalyticIkFunc

typedef bool(* cnoid::BodyCustomizerCalcAnalyticIkFunc) (BodyCustomizerHandle customizerHandle, int ikPathId, const Vector3 &p, const Matrix3 &R)

◆ BodyCustomizerCreateFunc

typedef BodyCustomizerHandle(* cnoid::BodyCustomizerCreateFunc) (BodyHandle bodyHandle, const char *modelName)

◆ BodyCustomizerDestroyFunc

typedef void(* cnoid::BodyCustomizerDestroyFunc) (BodyCustomizerHandle customizerHandle)

◆ BodyCustomizerGetTargetModelNamesFunc

typedef const char**(* cnoid::BodyCustomizerGetTargetModelNamesFunc) ()

◆ BodyCustomizerHandle

typedef void * cnoid::BodyCustomizerHandle

◆ BodyCustomizerInitializeAnalyticIkFunc

typedef int(* cnoid::BodyCustomizerInitializeAnalyticIkFunc) (BodyCustomizerHandle customizerHandle, int baseLinkIndex, int targetLinkIndex)

◆ BodyCustomizerSetVirtualJointForcesFunc

typedef void(* cnoid::BodyCustomizerSetVirtualJointForcesFunc) (BodyCustomizerHandle customizerHandle)

◆ BodyGetLinkDoubleValuePtrFunc

typedef double*(* cnoid::BodyGetLinkDoubleValuePtrFunc) (BodyHandle bodyHandle, int linkIndex)

◆ BodyGetLinkIndexFromNameFunc

typedef int(* cnoid::BodyGetLinkIndexFromNameFunc) (BodyHandle bodyHandle, const char *linkName)

◆ BodyGetLinkNameFunc

typedef const char*(* cnoid::BodyGetLinkNameFunc) (BodyHandle bodyHandle, int linkIndex)

◆ BodyHandle

typedef void* cnoid::BodyHandle

◆ BodyItemPtr

typedef ref_ptr< BodyItem > cnoid::BodyItemPtr

◆ BodyMotionControllerItemPtr

typedef ref_ptr<BodyMotionControllerItem> cnoid::BodyMotionControllerItemPtr

◆ BodyMotionEnginePtr

typedef ref_ptr<BodyMotionEngine> cnoid::BodyMotionEnginePtr

◆ BodyMotionItemPtr

typedef ref_ptr<BodyMotionItem> cnoid::BodyMotionItemPtr

◆ BodyMotionPtr

typedef boost::shared_ptr<BodyMotion> cnoid::BodyMotionPtr

◆ BodyPtr

typedef ref_ptr<Body> cnoid::BodyPtr

◆ BodyRTCItemPtr

typedef ref_ptr<BodyRTCItem> cnoid::BodyRTCItemPtr

◆ BodyTrackingCameraItemPtr

typedef ref_ptr<BodyTrackingCameraItem> cnoid::BodyTrackingCameraItemPtr

◆ BoundingBoxMarkerPtr

typedef ref_ptr<BoundingBoxMarker> cnoid::BoundingBoxMarkerPtr

◆ BulletCollisionDetectorPtr

typedef boost::shared_ptr<BulletCollisionDetector> cnoid::BulletCollisionDetectorPtr

◆ BulletSimulatorItemPtr

typedef ref_ptr<BulletSimulatorItem> cnoid::BulletSimulatorItemPtr

◆ CameraPtr

typedef ref_ptr<Camera> cnoid::CameraPtr

◆ ColdetModelPairPtr

typedef boost::shared_ptr<ColdetModelPair> cnoid::ColdetModelPairPtr

◆ ColdetModelPtr

typedef boost::shared_ptr<ColdetModel> cnoid::ColdetModelPtr

◆ CollisionArray

typedef std::vector<Collision> cnoid::CollisionArray

◆ CollisionDetectorPtr

typedef boost::shared_ptr< CollisionDetector > cnoid::CollisionDetectorPtr

◆ CollisionLinkPairList

typedef std::vector<CollisionLinkPairPtr> cnoid::CollisionLinkPairList

◆ CollisionLinkPairListPtr

typedef boost::shared_ptr<CollisionLinkPairList> cnoid::CollisionLinkPairListPtr

◆ CollisionLinkPairPtr

typedef boost::shared_ptr<CollisionLinkPair> cnoid::CollisionLinkPairPtr

◆ CollisionList

typedef std::vector<Collision> cnoid::CollisionList

obsolete

◆ CollisionPairPtr

typedef boost::shared_ptr<CollisionPair> cnoid::CollisionPairPtr

◆ CollisionSeqEnginePtr

typedef ref_ptr<CollisionSeqEngine> cnoid::CollisionSeqEnginePtr

◆ CollisionSeqItemPtr

typedef ref_ptr<CollisionSeqItem> cnoid::CollisionSeqItemPtr

◆ CollisionSeqPtr

typedef boost::shared_ptr<CollisionSeq> cnoid::CollisionSeqPtr

◆ CompositeIKPtr

typedef boost::shared_ptr<CompositeIK> cnoid::CompositeIKPtr

◆ ControllerItemPtr

typedef ref_ptr<ControllerItem> cnoid::ControllerItemPtr

◆ CrawlerLinkMap

typedef std::map<dBodyID, Link*> cnoid::CrawlerLinkMap

◆ CrossMarkerPtr

typedef ref_ptr<CrossMarker> cnoid::CrossMarkerPtr

◆ DaeActuatorPtr

typedef ref_ptr<DaeActuator> cnoid::DaeActuatorPtr

◆ DaeActuatorRelations

typedef std::map<std::string, std::string> cnoid::DaeActuatorRelations

◆ DaeActuators

typedef std::map<std::string, DaeActuatorPtr> cnoid::DaeActuators

◆ DaeAttachActuatorPtr

typedef ref_ptr<DaeAttachActuator> cnoid::DaeAttachActuatorPtr

◆ DaeAttachSensorPtr

typedef ref_ptr<DaeAttachSensor> cnoid::DaeAttachSensorPtr

◆ DaeEffectPtr

typedef ref_ptr<DaeEffect> cnoid::DaeEffectPtr

◆ DaeEffects

typedef std::map<std::string, DaeEffectPtr> cnoid::DaeEffects

◆ DaeGeometries

typedef std::map<std::string, DaeGeometryPtr> cnoid::DaeGeometries

◆ DaeGeometryPtr

typedef ref_ptr<DaeGeometry> cnoid::DaeGeometryPtr

◆ DaeJointChildren

typedef std::vector<std::string> cnoid::DaeJointChildren

◆ DaeJointPtr

typedef ref_ptr<DaeJoint> cnoid::DaeJointPtr

◆ DaeJoints

typedef std::map<std::string, DaeJointPtr> cnoid::DaeJoints

◆ DaeLinkChildren

typedef std::vector<std::string> cnoid::DaeLinkChildren

◆ DaeLinkPtr

typedef ref_ptr<DaeLink> cnoid::DaeLinkPtr

◆ DaeLinks

typedef std::map<std::string, DaeLinkPtr> cnoid::DaeLinks

◆ DaeMassFramePtr

typedef ref_ptr<DaeMassFrame> cnoid::DaeMassFramePtr

◆ DaeMaterialPtr

typedef ref_ptr<DaeMaterial> cnoid::DaeMaterialPtr

◆ DaeMaterialRef

typedef std::map<std::string, std::string> cnoid::DaeMaterialRef

◆ DaeMaterials

typedef std::map<std::string, DaeMaterialPtr> cnoid::DaeMaterials

◆ DaeMeshes

typedef std::vector<DaeMeshPtr> cnoid::DaeMeshes

◆ DaeMeshPtr

typedef ref_ptr<DaeMesh> cnoid::DaeMeshPtr

◆ DaeNodePtr

typedef ref_ptr<DaeNode> cnoid::DaeNodePtr

◆ DaeNodes

typedef std::map<std::string, DaeNodePtr> cnoid::DaeNodes

◆ DaeNodeStack

typedef std::vector< std::pair<std::string, DaeNodePtr> > cnoid::DaeNodeStack

◆ DaeOrder

typedef std::vector<std::string> cnoid::DaeOrder

◆ DaeResultSensors

typedef std::vector<DaeSensor*> cnoid::DaeResultSensors

◆ DaeResultSensorsPtr

typedef boost::shared_ptr<DaeResultSensors> cnoid::DaeResultSensorsPtr

◆ DaeRevoluteChildren

typedef std::vector<DaeRevolutePtr> cnoid::DaeRevoluteChildren

◆ DaeRevolutePtr

typedef ref_ptr<DaeRevolute> cnoid::DaeRevolutePtr

◆ DaeRevolutes

typedef std::map<std::string, DaeRevolutePtr> cnoid::DaeRevolutes

◆ DaeRigidPtr

typedef ref_ptr<DaeRigid> cnoid::DaeRigidPtr

◆ DaeRigidRelations

typedef std::map<std::string, std::string> cnoid::DaeRigidRelations

◆ DaeRigids

typedef std::map<std::string, DaeRigidPtr> cnoid::DaeRigids

◆ DaeSensorPtr

typedef ref_ptr<DaeSensor> cnoid::DaeSensorPtr

◆ DaeSensorRelations

typedef std::vector< std::pair<std::string, std::string> > cnoid::DaeSensorRelations

◆ DaeSensors

typedef std::map<std::string, DaeSensorPtr> cnoid::DaeSensors

◆ DaeShapePtr

typedef ref_ptr<DaeShape> cnoid::DaeShapePtr

◆ DaeShapes

typedef std::vector<DaeShapePtr> cnoid::DaeShapes

◆ DaeStrides

typedef std::map<std::string, int> cnoid::DaeStrides

◆ DaeTexturePtr

typedef ref_ptr<DaeTexture> cnoid::DaeTexturePtr

◆ DaeTextures

typedef std::map<std::string, DaeTexturePtr> cnoid::DaeTextures

◆ DaeTransformPtr

typedef ref_ptr<DaeTransform> cnoid::DaeTransformPtr

◆ DaeVectorMap

typedef std::map<std::string, DaeVectorXArrayPtr> cnoid::DaeVectorMap

◆ DaeVectorXArray

typedef std::vector<double> cnoid::DaeVectorXArray

◆ DaeVectorXArrayPtr

typedef boost::shared_ptr<DaeVectorXArray> cnoid::DaeVectorXArrayPtr

◆ DaeVerticesRef

typedef std::map<std::string, std::string> cnoid::DaeVerticesRef

◆ DevicePtr

typedef ref_ptr<Device> cnoid::DevicePtr

◆ DeviceStatePtr

typedef ref_ptr<DeviceState> cnoid::DeviceStatePtr

◆ DyBodyPtr

typedef ref_ptr< DyBody > cnoid::DyBodyPtr

◆ EditableSceneBodyPtr

typedef ref_ptr<EditableSceneBody> cnoid::EditableSceneBodyPtr

◆ EditableSceneLinkPtr

typedef ref_ptr<EditableSceneLink> cnoid::EditableSceneLinkPtr

◆ error_info_key

typedef boost::error_info<struct tag_error_info_key, std::string> cnoid::error_info_key

◆ error_info_message

typedef boost::error_info<struct tag_error_info_message, std::string> cnoid::error_info_message

◆ ExtCommandItemPtr

typedef ref_ptr<ExtCommandItem> cnoid::ExtCommandItemPtr

◆ ExtraBodyStateAccessorPtr

typedef ref_ptr<ExtraBodyStateAccessor> cnoid::ExtraBodyStateAccessorPtr

◆ FileDialogFilter

typedef std::vector<std::string> cnoid::FileDialogFilter

◆ FolderItemPtr

typedef ref_ptr<FolderItem> cnoid::FolderItemPtr

◆ ForceSensorPtr

typedef ref_ptr<ForceSensor> cnoid::ForceSensorPtr

◆ ForwardDynamicsCBMPtr

typedef boost::shared_ptr<ForwardDynamicsCBM> cnoid::ForwardDynamicsCBMPtr

◆ ForwardDynamicsPtr

typedef boost::shared_ptr<ForwardDynamics> cnoid::ForwardDynamicsPtr

◆ GEOMETRY_PAIR

typedef pair<string, DaeGeometryPtr> cnoid::GEOMETRY_PAIR

◆ GetBodyCustomizerInterfaceFunc

typedef BodyCustomizerInterface*(* cnoid::GetBodyCustomizerInterfaceFunc) (BodyInterface *bodyInterface)

◆ GLVisionSimulatorItemPtr

typedef ref_ptr<GLVisionSimulatorItem> cnoid::GLVisionSimulatorItemPtr

◆ GraphDataHandlerPtr

typedef boost::shared_ptr<GraphDataHandler> cnoid::GraphDataHandlerPtr

◆ InPortHandlerPtr

typedef boost::shared_ptr<InPortHandler> cnoid::InPortHandlerPtr

◆ InteractiveCameraTransformPtr

typedef ref_ptr<InteractiveCameraTransform> cnoid::InteractiveCameraTransformPtr

◆ InverseKinematicsPtr

typedef boost::shared_ptr< InverseKinematics > cnoid::InverseKinematicsPtr

◆ Isometry3

typedef Eigen::Isometry3d cnoid::Isometry3

◆ ItemImpl

typedef OpenHRPInterpreterServiceItemImpl cnoid::ItemImpl

◆ ItemPtr

typedef ref_ptr< Item > cnoid::ItemPtr

◆ JointPathPtr

typedef boost::shared_ptr< JointPath > cnoid::JointPathPtr

◆ LeggedBodyHelperPtr

typedef ref_ptr<LeggedBodyHelper> cnoid::LeggedBodyHelperPtr

◆ LightPtr

typedef ref_ptr<Light> cnoid::LightPtr

◆ LinkGroupPtr

typedef boost::shared_ptr<LinkGroup> cnoid::LinkGroupPtr

◆ LinkPtr

typedef ref_ptr<Link> cnoid::LinkPtr

◆ ListingPtr

typedef ref_ptr<Listing> cnoid::ListingPtr

◆ LoaderJoints

typedef vector<string> cnoid::LoaderJoints

◆ LoaderLinks

typedef map<string, Link*> cnoid::LoaderLinks

◆ MappingPtr

typedef ref_ptr< Mapping > cnoid::MappingPtr

◆ Matrix2

typedef Eigen::Matrix2d cnoid::Matrix2

◆ Matrix3

typedef Eigen::Matrix3d cnoid::Matrix3

◆ Matrix4

typedef Eigen::Matrix4d cnoid::Matrix4

◆ MediaItemPtr

typedef ref_ptr<MediaItem> cnoid::MediaItemPtr

◆ MFColor

typedef std::vector<SFColor> cnoid::MFColor

◆ MFFloat

typedef std::vector<SFFloat> cnoid::MFFloat

◆ MFInt32

typedef std::vector<SFInt32> cnoid::MFInt32

◆ MFNode

typedef std::vector<SFNode> cnoid::MFNode

◆ MFRotation

typedef std::vector<SFRotation> cnoid::MFRotation

◆ MFString

typedef std::vector<SFString> cnoid::MFString

◆ MFTime

typedef std::vector<SFTime> cnoid::MFTime

◆ MFVec2f

typedef std::vector<SFVec2f, Eigen::aligned_allocator<SFVec2f> > cnoid::MFVec2f

◆ MFVec2s

typedef std::vector<SFVec2s> cnoid::MFVec2s

◆ MFVec3f

typedef std::vector<SFVec3f> cnoid::MFVec3f

◆ MFVec3s

typedef std::vector<SFVec3s> cnoid::MFVec3s

◆ MultiAffine3SeqItem

typedef MultiSeqItem<MultiAffine3Seq> cnoid::MultiAffine3SeqItem

◆ MultiAffine3SeqItemPtr

typedef MultiAffine3SeqItem::Ptr cnoid::MultiAffine3SeqItemPtr

◆ MultiAffine3SeqPtr

typedef MultiAffine3Seq::Ptr cnoid::MultiAffine3SeqPtr

◆ MultiDeviceStateSeqItemPtr

typedef ref_ptr<MultiDeviceStateSeqItem> cnoid::MultiDeviceStateSeqItemPtr

◆ MultiDeviceStateSeqPtr

typedef MultiDeviceStateSeq::Ptr cnoid::MultiDeviceStateSeqPtr

◆ MultiPointSetItemPtr

typedef ref_ptr<MultiPointSetItem> cnoid::MultiPointSetItemPtr

◆ MultiSE3SeqItem

typedef MultiSeqItem<MultiSE3Seq> cnoid::MultiSE3SeqItem

◆ MultiSE3SeqItemPtr

typedef MultiSE3SeqItem::Ptr cnoid::MultiSE3SeqItemPtr

◆ MultiSE3SeqPtr

typedef MultiSE3Seq::Ptr cnoid::MultiSE3SeqPtr

◆ MultiValueSeqItem

typedef MultiSeqItem<MultiValueSeq> cnoid::MultiValueSeqItem

◆ MultiValueSeqItemPtr

typedef MultiValueSeqItem::Ptr cnoid::MultiValueSeqItemPtr

◆ MultiValueSeqPtr

typedef MultiValueSeq::Ptr cnoid::MultiValueSeqPtr

◆ MultiVector3SeqPtr

typedef MultiVector3Seq::Ptr cnoid::MultiVector3SeqPtr

◆ NODES_PAIR

typedef pair<string, DaeNodePtr> cnoid::NODES_PAIR

◆ ODECollisionDetectorPtr

typedef boost::shared_ptr<ODECollisionDetector> cnoid::ODECollisionDetectorPtr

◆ ODESimulatorItemPtr

typedef ref_ptr<ODESimulatorItem> cnoid::ODESimulatorItemPtr

◆ OpenHRPClockGeneratorItemPtr

typedef ref_ptr<OpenHRPClockGeneratorItem> cnoid::OpenHRPClockGeneratorItemPtr

◆ OpenHRPControllerItemPtr

typedef ref_ptr<OpenHRPControllerItem> cnoid::OpenHRPControllerItemPtr

◆ OpenHRPInterpreterServiceItemPtr

typedef ref_ptr<OpenHRPInterpreterServiceItem> cnoid::OpenHRPInterpreterServiceItemPtr

◆ OpenHRPOnlineViewerItemPtr

typedef ref_ptr<OpenHRPOnlineViewerItem> cnoid::OpenHRPOnlineViewerItemPtr

◆ OutPortHandlerPtr

typedef boost::shared_ptr<OutPortHandler> cnoid::OutPortHandlerPtr

◆ PenetrationBlockerPtr

typedef boost::shared_ptr< PenetrationBlocker > cnoid::PenetrationBlockerPtr

◆ PinDragIKptr

typedef boost::shared_ptr< PinDragIK > cnoid::PinDragIKptr

◆ PointLightPtr

typedef ref_ptr<PointLight> cnoid::PointLightPtr

◆ PointSetItemPtr

typedef ref_ptr<PointSetItem> cnoid::PointSetItemPtr

◆ PortHandlerPtr

typedef boost::shared_ptr<PortHandler> cnoid::PortHandlerPtr

◆ PosePtr

typedef ref_ptr<Pose> cnoid::PosePtr

◆ PoseSeqInterpolatorPtr

typedef boost::shared_ptr<PoseSeqInterpolator> cnoid::PoseSeqInterpolatorPtr

◆ PoseSeqItemPtr

typedef ref_ptr<PoseSeqItem> cnoid::PoseSeqItemPtr

◆ PoseSeqPtr

typedef ref_ptr<PoseSeq> cnoid::PoseSeqPtr

◆ PoseUnitPtr

typedef ref_ptr<PoseUnit> cnoid::PoseUnitPtr

◆ Position

typedef Eigen::Transform<double, 3, Eigen::AffineCompact> cnoid::Position

◆ PositionDraggerPtr

typedef ref_ptr<PositionDragger> cnoid::PositionDraggerPtr

◆ PronunSymbolPtr

typedef ref_ptr<PronunSymbol> cnoid::PronunSymbolPtr

◆ PropertyMap

typedef map<string, string> cnoid::PropertyMap

◆ PythonScriptItemPtr

typedef ref_ptr<PythonScriptItem> cnoid::PythonScriptItemPtr

◆ PythonSimScriptItemPtr

typedef ref_ptr<PythonSimScriptItem> cnoid::PythonSimScriptItemPtr

◆ Quat

typedef Eigen::Quaterniond cnoid::Quat

Deprecated:

◆ Quaternion

typedef Eigen::Quaterniond cnoid::Quaternion

◆ RangeCameraPtr

typedef ref_ptr<RangeCamera> cnoid::RangeCameraPtr

◆ RangeSensorPtr

typedef ref_ptr<RangeSensor> cnoid::RangeSensorPtr

◆ RateGyroSensorPtr

typedef ref_ptr<RateGyroSensor> cnoid::RateGyroSensorPtr

◆ RectRegionMarkerPtr

typedef ref_ptr<RectRegionMarker> cnoid::RectRegionMarkerPtr

◆ ReferencedPtr

typedef ref_ptr<Referenced> cnoid::ReferencedPtr

◆ RootItemPtr

typedef ref_ptr<RootItem> cnoid::RootItemPtr

◆ RotationDraggerPtr

typedef ref_ptr<RotationDragger> cnoid::RotationDraggerPtr

◆ RTCItemPtr

typedef ref_ptr<RTCItem> cnoid::RTCItemPtr

◆ SceneBodyPtr

typedef ref_ptr<SceneBody> cnoid::SceneBodyPtr

◆ SceneCollisionPtr

typedef ref_ptr<SceneCollision> cnoid::SceneCollisionPtr

◆ SceneDevicePtr

typedef ref_ptr<SceneDevice> cnoid::SceneDevicePtr

◆ SceneDraggerPtr

typedef ref_ptr<SceneDragger> cnoid::SceneDraggerPtr

◆ SceneItemPtr

typedef ref_ptr<SceneItem> cnoid::SceneItemPtr

◆ SceneLinkPtr

typedef ref_ptr<SceneLink> cnoid::SceneLinkPtr

◆ SceneWidgetRootPtr

typedef ref_ptr<SceneWidgetRoot> cnoid::SceneWidgetRootPtr

◆ ScriptItemPtr

typedef ref_ptr<ScriptItem> cnoid::ScriptItemPtr

◆ SensorVisualizerItemPtr

typedef ref_ptr<SensorVisualizerItem> cnoid::SensorVisualizerItemPtr

◆ SFBool

typedef bool cnoid::SFBool

◆ SFColor

typedef Eigen::Vector3f cnoid::SFColor

◆ SFFloat

typedef double cnoid::SFFloat

◆ SFInt32

typedef int cnoid::SFInt32

◆ SFNode

typedef VRMLNodePtr cnoid::SFNode

◆ SFRotation

typedef Eigen::AngleAxisd cnoid::SFRotation

◆ SFString

typedef std::string cnoid::SFString

◆ SFVec2f

typedef Eigen::Vector2d cnoid::SFVec2f

◆ SFVec2s

typedef Eigen::Vector2f cnoid::SFVec2s

◆ SFVec3f

typedef Eigen::Vector3d cnoid::SFVec3f

◆ SFVec3s

typedef Eigen::Vector3f cnoid::SFVec3s

◆ SgCameraPtr

typedef ref_ptr<SgCamera> cnoid::SgCameraPtr

◆ SgColorArray

typedef SgVectorArray<Vector3f> cnoid::SgColorArray

◆ SgColorArrayPtr

typedef ref_ptr<SgColorArray> cnoid::SgColorArrayPtr

◆ SgCustomGLNodePtr

typedef ref_ptr<SgCustomGLNode> cnoid::SgCustomGLNodePtr

◆ SgDirectionalLightPtr

typedef ref_ptr<SgDirectionalLight> cnoid::SgDirectionalLightPtr

◆ SgFogPtr

typedef ref_ptr<SgFog> cnoid::SgFogPtr

◆ SgGroupPtr

typedef ref_ptr<SgGroup> cnoid::SgGroupPtr

◆ SgImagePtr

typedef ref_ptr<SgImage> cnoid::SgImagePtr

◆ SgIndexArray

typedef std::vector<int> cnoid::SgIndexArray

◆ SgInvariantGroupPtr

typedef ref_ptr<SgInvariantGroup> cnoid::SgInvariantGroupPtr

◆ SgLightPtr

typedef ref_ptr<SgLight> cnoid::SgLightPtr

◆ SgLineSetPtr

typedef ref_ptr<SgLineSet> cnoid::SgLineSetPtr

◆ SgMaterialPtr

typedef ref_ptr<SgMaterial> cnoid::SgMaterialPtr

◆ SgMeshBasePtr

typedef ref_ptr<SgMeshBase> cnoid::SgMeshBasePtr

◆ SgMeshPtr

typedef ref_ptr<SgMesh> cnoid::SgMeshPtr

◆ SgNodePath

typedef std::vector<SgNode*> cnoid::SgNodePath

◆ SgNodePtr

typedef ref_ptr< SgNode > cnoid::SgNodePtr

◆ SgNormalArray

typedef SgVectorArray<Vector3f> cnoid::SgNormalArray

◆ SgNormalArrayPtr

typedef ref_ptr<SgNormalArray> cnoid::SgNormalArrayPtr

◆ SgObjectPtr

typedef ref_ptr<SgObject> cnoid::SgObjectPtr

◆ SgOrthographicCameraPtr

typedef ref_ptr<SgOrthographicCamera> cnoid::SgOrthographicCameraPtr

◆ SgOutlineGroupPtr

typedef ref_ptr<SgOutlineGroup> cnoid::SgOutlineGroupPtr

◆ SgPerspectiveCameraPtr

typedef ref_ptr<SgPerspectiveCamera> cnoid::SgPerspectiveCameraPtr

◆ SgPlotPtr

typedef ref_ptr<SgPlot> cnoid::SgPlotPtr

◆ SgPointLightPtr

typedef ref_ptr<SgPointLight> cnoid::SgPointLightPtr

◆ SgPointSetPtr

typedef ref_ptr<SgPointSet> cnoid::SgPointSetPtr

◆ SgPolygonMeshPtr

typedef ref_ptr<SgPolygonMesh> cnoid::SgPolygonMeshPtr

◆ SgPosTransformPtr

typedef ref_ptr<SgPosTransform> cnoid::SgPosTransformPtr

◆ SgScaleTransformPtr

typedef ref_ptr<SgScaleTransform> cnoid::SgScaleTransformPtr

◆ SgShapePtr

typedef ref_ptr<SgShape> cnoid::SgShapePtr

◆ SgSpotLightPtr

typedef ref_ptr<SgSpotLight> cnoid::SgSpotLightPtr

◆ SgSwitchPtr

typedef ref_ptr<SgSwitch> cnoid::SgSwitchPtr

◆ SgTexCoordArray

typedef SgVectorArray<Vector2f, Eigen::aligned_allocator<Vector2f> > cnoid::SgTexCoordArray

◆ SgTexCoordArrayPtr

typedef ref_ptr<SgTexCoordArray> cnoid::SgTexCoordArrayPtr

◆ SgTexturePtr

typedef ref_ptr<SgTexture> cnoid::SgTexturePtr

◆ SgTextureTransformPtr

typedef ref_ptr<SgTextureTransform> cnoid::SgTextureTransformPtr

◆ SgTransformPtr

typedef ref_ptr<SgTransform> cnoid::SgTransformPtr

◆ SgUnpickableGroupPtr

typedef ref_ptr<SgUnpickableGroup> cnoid::SgUnpickableGroupPtr

◆ SgVertexArray

typedef SgVectorArray<Vector3f> cnoid::SgVertexArray

◆ SgVertexArrayPtr

typedef ref_ptr<SgVertexArray> cnoid::SgVertexArrayPtr

◆ SimpleControllerItemPtr

typedef ref_ptr<SimpleControllerItem> cnoid::SimpleControllerItemPtr

◆ SimulationBodyPtr

typedef ref_ptr<SimulationBody> cnoid::SimulationBodyPtr

◆ SimulationScriptItemPtr

typedef ref_ptr<SimulationScriptItem> cnoid::SimulationScriptItemPtr

◆ SimulatorItemPtr

typedef ref_ptr<SimulatorItem> cnoid::SimulatorItemPtr

◆ SphereMarkerPtr

typedef ref_ptr<SphereMarker> cnoid::SphereMarkerPtr

◆ SpotLightPtr

typedef ref_ptr<SpotLight> cnoid::SpotLightPtr

◆ SubSimulatorItemPtr

typedef ref_ptr<SubSimulatorItem> cnoid::SubSimulatorItemPtr

◆ TaskCommandPtr

typedef ref_ptr<TaskCommand> cnoid::TaskCommandPtr

◆ TaskFunc

typedef boost::function<void(TaskProc* proc)> cnoid::TaskFunc

◆ TaskPhaseProxyPtr

typedef ref_ptr<TaskPhaseProxy> cnoid::TaskPhaseProxyPtr

◆ TaskPhasePtr

typedef ref_ptr<TaskPhase> cnoid::TaskPhasePtr

◆ TaskPtr

typedef ref_ptr<Task> cnoid::TaskPtr

◆ TaskToggleStatePtr

typedef ref_ptr<TaskToggleState> cnoid::TaskToggleStatePtr

◆ TimeSyncItemEnginePtr

typedef ref_ptr<TimeSyncItemEngine> cnoid::TimeSyncItemEnginePtr

◆ Translation3

typedef Eigen::Translation3d cnoid::Translation3

◆ TranslationDraggerPtr

typedef ref_ptr<TranslationDragger> cnoid::TranslationDraggerPtr

◆ ValueNodePtr

typedef ref_ptr<ValueNode> cnoid::ValueNodePtr

◆ Vector2

typedef Eigen::Vector2d cnoid::Vector2

◆ Vector3

typedef Eigen::Vector3d cnoid::Vector3

◆ Vector3s

typedef std::vector<Vector3> cnoid::Vector3s

◆ Vector3SeqItemPtr

typedef ref_ptr<Vector3SeqItem> cnoid::Vector3SeqItemPtr

◆ Vector3SeqPtr

typedef boost::shared_ptr<Vector3Seq> cnoid::Vector3SeqPtr

◆ Vector4

typedef Eigen::Vector4d cnoid::Vector4

◆ Vector6

typedef Eigen::Matrix<double, 6, 1> cnoid::Vector6

◆ VectorX

typedef Eigen::VectorXd cnoid::VectorX

◆ VRMLAccelerationSensorPtr

typedef boost::intrusive_ptr<VRMLAccelerationSensor> cnoid::VRMLAccelerationSensorPtr

◆ VRMLAnchorPtr

typedef boost::intrusive_ptr<VRMLAnchor> cnoid::VRMLAnchorPtr

◆ VRMLAnotherFormatFilePtr

typedef boost::intrusive_ptr<VRMLAnotherFormatFile> cnoid::VRMLAnotherFormatFilePtr

◆ VRMLAppearancePtr

typedef boost::intrusive_ptr<VRMLAppearance> cnoid::VRMLAppearancePtr

◆ VRMLBackgroundPtr

typedef boost::intrusive_ptr<VRMLBackground> cnoid::VRMLBackgroundPtr

◆ VRMLBillboardPtr

typedef boost::intrusive_ptr<VRMLBillboard> cnoid::VRMLBillboardPtr

◆ VRMLBoxPtr

typedef boost::intrusive_ptr<VRMLBox> cnoid::VRMLBoxPtr

◆ VRMLCollisionPtr

typedef boost::intrusive_ptr<VRMLCollision> cnoid::VRMLCollisionPtr

◆ VRMLColorPtr

typedef boost::intrusive_ptr<VRMLColor> cnoid::VRMLColorPtr

◆ VRMLConePtr

typedef boost::intrusive_ptr<VRMLCone> cnoid::VRMLConePtr

◆ VRMLCoordinatePtr

typedef boost::intrusive_ptr<VRMLCoordinate> cnoid::VRMLCoordinatePtr

◆ VRMLCylinderPtr

typedef boost::intrusive_ptr<VRMLCylinder> cnoid::VRMLCylinderPtr

◆ VRMLCylinderSensorPtr

typedef boost::intrusive_ptr<VRMLCylinderSensor> cnoid::VRMLCylinderSensorPtr

◆ VRMLDirectionalLightPtr

typedef boost::intrusive_ptr<VRMLDirectionalLight> cnoid::VRMLDirectionalLightPtr

◆ VRMLElevationGridPtr

typedef boost::intrusive_ptr<VRMLElevationGrid> cnoid::VRMLElevationGridPtr

◆ VRMLExtrusionPtr

typedef boost::intrusive_ptr<VRMLExtrusion> cnoid::VRMLExtrusionPtr

◆ VRMLFogPtr

typedef boost::intrusive_ptr<VRMLFog> cnoid::VRMLFogPtr

◆ VRMLFontStylePtr

typedef boost::intrusive_ptr<VRMLFontStyle> cnoid::VRMLFontStylePtr

◆ VRMLForceSensorPtr

typedef boost::intrusive_ptr<VRMLForceSensor> cnoid::VRMLForceSensorPtr

◆ VRMLGeometryPtr

typedef boost::intrusive_ptr<VRMLGeometry> cnoid::VRMLGeometryPtr

◆ VRMLGroupPtr

typedef boost::intrusive_ptr<VRMLGroup> cnoid::VRMLGroupPtr

◆ VRMLGyroPtr

typedef boost::intrusive_ptr<VRMLGyro> cnoid::VRMLGyroPtr

◆ VRMLHumanoidPtr

typedef boost::intrusive_ptr<VRMLHumanoid> cnoid::VRMLHumanoidPtr

◆ VRMLImageTexturePtr

typedef boost::intrusive_ptr<VRMLImageTexture> cnoid::VRMLImageTexturePtr

◆ VRMLIndexedFaceSetPtr

typedef boost::intrusive_ptr<VRMLIndexedFaceSet> cnoid::VRMLIndexedFaceSetPtr

◆ VRMLIndexedLineSetPtr

typedef boost::intrusive_ptr<VRMLIndexedLineSet> cnoid::VRMLIndexedLineSetPtr

◆ VRMLInlinePtr

typedef boost::intrusive_ptr<VRMLInline> cnoid::VRMLInlinePtr

◆ VRMLJointPtr

typedef boost::intrusive_ptr<VRMLJoint> cnoid::VRMLJointPtr

◆ VRMLLightPtr

typedef boost::intrusive_ptr<VRMLLight> cnoid::VRMLLightPtr

◆ VRMLLODPtr

typedef boost::intrusive_ptr<VRMLLOD> cnoid::VRMLLODPtr

◆ VRMLMaterialPtr

typedef boost::intrusive_ptr<VRMLMaterial> cnoid::VRMLMaterialPtr

◆ VRMLMovieTexturePtr

typedef boost::intrusive_ptr<VRMLMovieTexture> cnoid::VRMLMovieTexturePtr

◆ VRMLNavigationInfoPtr

typedef boost::intrusive_ptr<VRMLNavigationInfo> cnoid::VRMLNavigationInfoPtr

◆ VRMLNodePtr

typedef boost::intrusive_ptr<VRMLNode> cnoid::VRMLNodePtr

◆ VRMLNormalPtr

typedef boost::intrusive_ptr<VRMLNormal> cnoid::VRMLNormalPtr

◆ VRMLPixelTexturePtr

typedef boost::intrusive_ptr<VRMLPixelTexture> cnoid::VRMLPixelTexturePtr

◆ VRMLPointLightPtr

typedef boost::intrusive_ptr<VRMLPointLight> cnoid::VRMLPointLightPtr

◆ VRMLPointSetPtr

typedef boost::intrusive_ptr<VRMLPointSet> cnoid::VRMLPointSetPtr

◆ VRMLProtoFieldMap

typedef std::map<std::string, VRMLVariantField> cnoid::VRMLProtoFieldMap

◆ VRMLProtoFieldPair

typedef std::pair<std::string, VRMLVariantField> cnoid::VRMLProtoFieldPair

◆ VRMLProtoInstancePtr

typedef boost::intrusive_ptr<VRMLProtoInstance> cnoid::VRMLProtoInstancePtr

◆ VRMLProtoPtr

typedef boost::intrusive_ptr<VRMLProto> cnoid::VRMLProtoPtr

◆ VRMLRangeSensorPtr

typedef boost::intrusive_ptr<VRMLRangeSensor> cnoid::VRMLRangeSensorPtr

◆ VRMLSegmentPtr

typedef boost::intrusive_ptr<VRMLSegment> cnoid::VRMLSegmentPtr

◆ VRMLShapePtr

typedef boost::intrusive_ptr<VRMLShape> cnoid::VRMLShapePtr

◆ VRMLSpherePtr

typedef boost::intrusive_ptr<VRMLSphere> cnoid::VRMLSpherePtr

◆ VRMLSpotLightPtr

typedef boost::intrusive_ptr<VRMLSpotLight> cnoid::VRMLSpotLightPtr

◆ VRMLSurfacePtr

typedef boost::intrusive_ptr<VRMLSurface> cnoid::VRMLSurfacePtr

◆ VRMLSwitchPtr

typedef boost::intrusive_ptr<VRMLSwitch> cnoid::VRMLSwitchPtr

◆ VRMLTextPtr

typedef boost::intrusive_ptr<VRMLText> cnoid::VRMLTextPtr

◆ VRMLTextureCoordinatePtr

typedef boost::intrusive_ptr<VRMLTextureCoordinate> cnoid::VRMLTextureCoordinatePtr

◆ VRMLTexturePtr

typedef boost::intrusive_ptr<VRMLTexture> cnoid::VRMLTexturePtr

◆ VRMLTextureTransformPtr

typedef boost::intrusive_ptr<VRMLTextureTransform> cnoid::VRMLTextureTransformPtr

◆ VRMLTransformPtr

typedef boost::intrusive_ptr<VRMLTransform> cnoid::VRMLTransformPtr

◆ VRMLUnsupportedNodePtr

typedef boost::intrusive_ptr<VRMLUnsupportedNode> cnoid::VRMLUnsupportedNodePtr

◆ VRMLVariantField

typedef boost::variant<SFBool, SFInt32, SFFloat, SFVec2f, SFVec3f, SFRotation, SFColor, SFTime, SFString, SFNode, SFImage, MFInt32, MFFloat, MFVec2f, MFVec3f, MFRotation, MFColor, MFTime, MFString, MFNode> cnoid::VRMLVariantField

◆ VRMLViewpointPtr

typedef boost::intrusive_ptr<VRMLViewpoint> cnoid::VRMLViewpointPtr

◆ VRMLVisionSensorPtr

typedef boost::intrusive_ptr<VRMLVisionSensor> cnoid::VRMLVisionSensorPtr

◆ VRMLWorldInfoPtr

typedef boost::intrusive_ptr<VRMLWorldInfo> cnoid::VRMLWorldInfoPtr

◆ VRMLWriterNodeMethod

typedef void(VRMLWriter::* cnoid::VRMLWriterNodeMethod) (VRMLNodePtr node)

◆ WorldItemPtr

typedef ref_ptr<WorldItem> cnoid::WorldItemPtr

◆ WorldLogFileItemPtr

typedef ref_ptr<WorldLogFileItem> cnoid::WorldLogFileItemPtr

◆ ZMPSeqItemPtr

typedef ref_ptr<ZMPSeqItem> cnoid::ZMPSeqItemPtr

◆ ZMPSeqPtr

typedef boost::shared_ptr<ZMPSeq> cnoid::ZMPSeqPtr

Enumeration Type Documentation

◆ anonymous enum

anonymous enum

Enumeration type of "TAG" used in Collada.

Enumerator
EXT_NODE
EXT_UNIT
EXT_TRANSLATE
EXT_ROTATE
EXT_SCALE
EXT_MATRIX
EXT_INSTANCE_NODE
EXT_INSTANCE_GEOMETRY
EXT_INSTANCE_MATERIAL
EXT_INSTANCE_EFFECT
EXT_GEOMETRY
EXT_VERTICES
EXT_SOURCE
EXT_FLOAT_ARRAY
EXT_ACCESSOR
EXT_INPUT
EXT_TRIANGLES
EXT_LINES
EXT_P
EXT_MATERIAL
EXT_EFFECT
EXT_EMISSION
EXT_AMBIENT
EXT_DIFFUSE
EXT_SPECULAR
EXT_SHININESS
EXT_TRANSPARENCY
EXT_INIT_FORM
EXT_IMAGE
EXT_POLYLIST
EXT_VCOUNT
EXT_BOX
EXT_SPHERE
EXT_CYLINDER
EXT_TAPERED_CYLINDER
EXT_KINEMATICS_MODEL
EXT_LINK
EXT_ATTACHMENT_FULL
EXT_JOINT
EXT_REVOLUTE
EXT_PRISMATIC
EXT_AXIS
EXT_MIN
EXT_MAX
EXT_RIGID_BODY
EXT_SHAPE
EXT_INSTANCE_RIGID_BODY
EXT_INSTANCE_PHYSICS_MODEL
EXT_MASS
EXT_MASS_FRAME
EXT_INERTIA
EXT_ACTUATOR
EXT_ASSIGNED_POWER_RATING
EXT_MAX_SPEED
EXT_NO_LOAD_SPEED
EXT_NOMINAL_TORQUE
EXT_NOMINAL_VOLTAGE
EXT_ROTOR_INERTIA
EXT_SPEED_CONSTANT
EXT_SPEED_TORQUE_GRADIENT
EXT_STARTING_CURRENT
EXT_TERMINAL_RESISTANCE
EXT_TORQUE_CONSTANT
EXT_INSTANCE_ACTUATOR
EXT_BIND_ACTUATOR
EXT_INSTANCE_SENSOR
EXT_FRAME_ORIGIN
EXT_SENSOR
EXT_FOCAL_LENGTH
EXT_INTRINSIC
EXT_IMAGE_DIMENSIONS
EXT_MEASUREMENT_TIME
EXT_EXTRA

◆ anonymous enum

anonymous enum

These indexes are defined in polylist tag and triangles.

Enumerator
EXT_POSITION
EXT_VERTEX
EXT_NORMAL
EXT_COLOR
EXT_TEXCOORD

◆ anonymous enum

anonymous enum

deprecated

Enumerator
IDLE_PRIORITY_HIGH
IDLE_PRIORITY_NORMAL
IDLE_PRIORITY_LOW

◆ anonymous enum

anonymous enum

An enumeration type of the "BASE" node in the Collada. Information("CONCRETE or LIBRARY") of the entity has been stored in these nodes.

Enumerator
EXT_VISUAL_SCENES
EXT_GEOMETRIES
EXT_MATERIALS
EXT_EFFECTS
EXT_NODES
EXT_IMAGES
EXT_PHYSICS_MODELS
EXT_KINEMATICS_MODELS
EXT_PHYSICS_SCENES

◆ anonymous enum

anonymous enum

There are two types of joint and node to node of Collada. It will remain at that type when reading the node tags.

Enumerator
EXT_NODE_NODE
EXT_NODE_JOINT

◆ StringStyle

enum cnoid::StringStyle

Enumerator
PLAIN_STRING
SINGLE_QUOTED
DOUBLE_QUOTED
LITERAL_STRING
FOLDED_STRING

◆ VRMLFieldTypeId

enum cnoid::VRMLFieldTypeId

Enumerator
SFBOOL
SFINT32
SFFLOAT
SFVEC2F
SFVEC3F
SFROTATION
SFCOLOR
SFTIME
SFSTRING
SFNODE
SFIMAGE
MFINT32
MFFLOAT
MFVEC2F
MFVEC3F
MFROTATION
MFCOLOR
MFTIME
MFSTRING
MFNODE
UNKNOWN_VRML_FIELD_TYPE

◆ VRMLNodeCategory

enum cnoid::VRMLNodeCategory

Enumerator
ANY_NODE
PROTO_DEF_NODE
PROTO_INSTANCE_NODE
TOP_NODE
BINDABLE_NODE
GROUPING_NODE
CHILD_NODE
APPEARANCE_NODE
MATERIAL_NODE
TEXTURE_NODE
TEXTURE_TRANSFORM_NODE
SHAPE_NODE
GEOMETRY_NODE
COORDINATE_NODE
COLOR_NODE
NORMAL_NODE
TEXTURE_COORDINATE_NODE
LIGHT_NODE
FONT_STYLE_NODE
SENSOR_NODE
INLINE_NODE
NUM_VRML_NODE_CATEGORIES

Function Documentation

◆ addBodyToCollisionDetector()

int cnoid::addBodyToCollisionDetector	(	Body &	body,
		CollisionDetector &	detector,
		bool	enableSelfCollisions = `true`
	)

Returns: top of the geometry indices assigned to the body. The geometry id corresponding to a link is <the top="" index>=""> + <link->index()>.

◆ adjustStepPositions()

void cnoid::adjustStepPositions	(	PoseSeqPtr	seq,
		const std::vector< int > &	footLinkIndices,
		PoseSeq::iterator	origin
	)

◆ adjustWaistHeight()

CNOID_EXPORT void cnoid::adjustWaistHeight	(	PosePtr	pose,
		int	waistLinkIndex,
		const std::vector< int > &	footLinkIndices,
		double	offset
	)

◆ applyGaussianFilter() [1/3]

void cnoid::applyGaussianFilter	(	MultiValueSeq &	seq,
		double	sigma,
		int	range,
		std::ostream &	os = `nullout()`
	)

◆ applyGaussianFilter() [2/3]

template<class RESULTVECTOR , class SRCVECTOR , class ELEMENT , class T >

void cnoid::applyGaussianFilter	(	RESULTVECTOR &	result,
		const SRCVECTOR &	src,
		std::vector< T > &	gwin,
		ELEMENT	zero
	)

◆ applyGaussianFilter() [3/3]

template<class RESULTVECTOR , class SRCVECTOR , class ELEMENT , class T >

void cnoid::applyGaussianFilter	(	RESULTVECTOR &	result,
		const SRCVECTOR &	src,
		T	sigma,
		int	range,
		ELEMENT	zero
	)

◆ applyPollardVelocityLimitFilter()

bool cnoid::applyPollardVelocityLimitFilter	(	MultiValueSeq &	seq,
		Body *	body,
		double	ks,
		std::ostream &	os = `nullout()`
	)

◆ applyRangeLimitFilter()

void cnoid::applyRangeLimitFilter	(	MultiValueSeq &	seq,
		Body *	body,
		double	limitGrad,
		double	edgeGradRatio,
		double	margin,
		std::ostream &	os = `nullout()`
	)

◆ applyVelocityLimitFilter()

bool cnoid::applyVelocityLimitFilter	(	MultiValueSeq &	seq,
		Body *	body,
		std::ostream &	os = `nullout()`
	)

◆ applyVelocityLimitFilter2()

bool cnoid::applyVelocityLimitFilter2	(	MultiValueSeq &	seq,
		int	part,
		double	absLimit
	)

◆ applyVelocityLimitFilterDummy()

bool cnoid::applyVelocityLimitFilterDummy ( )

◆ bindGettextDomain()

void cnoid::bindGettextDomain ( const char * domainname )

◆ boolstr()

const char* cnoid::boolstr ( bool v )

inline

◆ calcAngularMomentumJacobian()

CNOID_EXPORT void cnoid::calcAngularMomentumJacobian	(	Body *	body,
		Link *	base,
		Eigen::MatrixXd &	H
	)

compute Angular Momentum Jacobian

Parameters

base	link fixed to the environment
H	Angular Momentum Jacobian

Note: Link::wc must be computed by calcCM() before calling

◆ calcCMJacobian()

CNOID_EXPORT void cnoid::calcCMJacobian	(	Body *	body,
		Link *	base,
		Eigen::MatrixXd &	J
	)

compute CoM Jacobian

Parameters

base	link fixed to the environment
J	CoM Jacobian

Note: Link::wc must be computed by calcCM() before calling

◆ calcInverseDynamics()

CNOID_EXPORT Vector6 cnoid::calcInverseDynamics ( Link * link )

Returns: force being applied to the root link

◆ calcLinkAccSeq()

void cnoid::calcLinkAccSeq	(	MultiSE3Seq &	linkPosSeq,
		AccelerationSensor *	gsens,
		int	frameBegin,
		int	numFrames,
		Vector3Seq &	out_accSeq
	)

Todo:: The localRotaion of gsens should be considered.

◆ calcMassMatrix() [1/4]

CNOID_EXPORT void cnoid::calcMassMatrix	(	Body *	body,
		const Vector3 &	g,
		MatrixXd &	out_M
	)

◆ calcMassMatrix() [2/4]

CNOID_EXPORT void cnoid::calcMassMatrix	(	Body *	body,
		MatrixXd &	out_M
	)

◆ calcMassMatrix() [3/4]

void cnoid::calcMassMatrix	(	Body *	body,
		const Vector3 &	g,
		Eigen::MatrixXd &	out_M
	)

calculate the mass matrix using the unit vector method

Todo:: replace the unit vector method here with a more efficient method

The motion equation (dv != dvo) | | | dv | | | | fext | | out_M | * | dw | + | b1 | = | tauext | | | |ddq | | | | u |

◆ calcMassMatrix() [4/4]

void cnoid::calcMassMatrix	(	const BodyPtr &	body,
		MatrixXd &	out_M
	)

◆ calcTotalTransform() [1/3]

Affine3 cnoid::calcTotalTransform ( const SgNodePath & path )

◆ calcTotalTransform() [2/3]

Affine3 cnoid::calcTotalTransform	(	const SgNodePath &	path,
		const SgNode *	targetNode
	)

◆ calcTotalTransform() [3/3]

Affine3 cnoid::calcTotalTransform	(	SgNodePath::const_iterator	begin,
		SgNodePath::const_iterator	end
	)

◆ callFromMainThread()

CNOID_EXPORT void cnoid::callFromMainThread	(	const boost::function< void()> &	function,
		int	priority = `LazyCaller::PRIORITY_NORMAL`
	)

◆ callLater()

CNOID_EXPORT void cnoid::callLater	(	const boost::function< void()> &	function,
		int	priority = `LazyCaller::PRIORITY_NORMAL`
	)

◆ callSynchronously()

CNOID_EXPORT bool cnoid::callSynchronously	(	const boost::function< void()> &	function,
		int	priority = `LazyCaller::PRIORITY_NORMAL`
	)

◆ changeProperty()

template<class ValueType >

ChangeProperty<ValueType> cnoid::changeProperty ( ValueType & variable )

◆ checkAbsolute()

CNOID_EXPORT bool cnoid::checkAbsolute ( const boost::filesystem::path & path )

◆ checkOrInvokeCorbaNameServer()

CNOID_EXPORT void cnoid::checkOrInvokeCorbaNameServer ( )

◆ clearMultiDeviceStateSeq()

void cnoid::clearMultiDeviceStateSeq ( BodyMotion & motion )

◆ clearZMPSeq()

void cnoid::clearZMPSeq ( BodyMotion & motion )

◆ const_pointer_cast()

template<class T , class U >

ref_ptr<T> cnoid::const_pointer_cast ( ref_ptr< U > const & p )

◆ createBodyMotionEngine()

TimeSyncItemEngine* cnoid::createBodyMotionEngine ( Item * sourceItem )

◆ createManagedRTC()

RTC::RTObject_impl * cnoid::createManagedRTC ( const char * comp_args )

Components managed by plugins should be created by using this function instead of using RTC::Manager::createComponent(). A component created by this function is registered as a plugin-managed component, and functions such as 'removeUnmanagedComponents()' ignore those components.

◆ degree() [1/2]

double cnoid::degree ( double rad )

inline

◆ degree() [2/2]

float cnoid::degree ( float rad )

inline

◆ deleteRTC()

bool cnoid::deleteRTC	(	RTC::RtcBase *	rtc,
		bool	waitToBeDeleted = `true`
	)

◆ deleteUnmanagedRTCs()

CNOID_EXPORT int cnoid::deleteUnmanagedRTCs ( )

◆ dynamic_node_cast()

template<class VRMLNodeType >

boost::intrusive_ptr<VRMLNodeType> cnoid::dynamic_node_cast ( VRMLNodePtr node )

inline

The upper cast operation that supports the situation where the original pointer is VRMLProtoInstance and you want to get the actual node, the node replaced with the pre-defined node type written in the PROTO definition.

◆ dynamic_pointer_cast()

template<class T , class U >

ref_ptr<T> cnoid::dynamic_pointer_cast ( ref_ptr< U > const & p )

◆ execPythonCode()

bool cnoid::execPythonCode ( const std::string & code )

◆ executableBasename()

CNOID_EXPORT const std::string & cnoid::executableBasename ( )

◆ executableDirectory()

CNOID_EXPORT const std::string & cnoid::executableDirectory ( )

◆ executablePath()

CNOID_EXPORT const std::string & cnoid::executablePath ( )

◆ executableTopDirectory()

CNOID_EXPORT const std::string & cnoid::executableTopDirectory ( )

◆ findBodyCustomizer()

BodyCustomizerInterface * cnoid::findBodyCustomizer ( std::string modelName )

◆ findExecutablePath()

void cnoid::findExecutablePath ( )

◆ findRelativePath() [1/2]

CNOID_EXPORT bool cnoid::findRelativePath	(	const boost::filesystem::path &	from,
		const boost::filesystem::path &	to,
		boost::filesystem::path &	out_relativePath
	)

◆ findRelativePath() [2/2]

bool cnoid::findRelativePath	(	const filesystem::path &	from_,
		const filesystem::path &	to,
		filesystem::path &	out_relativePath
	)

◆ findRTCService()

template<class ServiceType >

ServiceType::_ptr_type cnoid::findRTCService	(	RTC::RTObject_ptr	rtc,
		const std::string &	name
	)

◆ findRTCService< CORBA::Object >() [1/2]

template<>

CNOID_EXPORT CORBA::Object::_ptr_type cnoid::findRTCService< CORBA::Object >	(	RTC::RTObject_ptr	rtc,
		const std::string &	name
	)

◆ findRTCService< CORBA::Object >() [2/2]

template<>

CORBA::Object::_ptr_type cnoid::findRTCService< CORBA::Object >	(	RTC::RTObject_ptr	rtc,
		const std::string &	name
	)

◆ findSubDirectory() [1/2]

CNOID_EXPORT int cnoid::findSubDirectory	(	const boost::filesystem::path &	directory,
		const boost::filesystem::path &	path,
		boost::filesystem::path &	out_subdirectory
	)

◆ findSubDirectory() [2/2]

int cnoid::findSubDirectory	(	const filesystem::path &	directory,
		const filesystem::path &	path,
		filesystem::path &	out_subdirectory
	)

◆ findSubDirectoryOfDirectoryVariable()

bool cnoid::findSubDirectoryOfDirectoryVariable	(	ArchiveSharedData *	shared,
		const filesystem::path &	path,
		std::string &	out_varName,
		filesystem::path &	out_relativePath
	)

Todo:: Introduce a tree structure to improve the efficiency of searching matched directories

◆ flipPoses()

void cnoid::flipPoses	(	PoseSeqPtr	seq,
		BodyPtr	body
	)

◆ fmt() [1/2]

boost::format cnoid::fmt ( const char * f_string )

inline

◆ fmt() [2/2]

boost::format cnoid::fmt ( const std::string & f_string )

inline

◆ fromUTF8() [1/2]

const std::string& cnoid::fromUTF8 ( const std::string & text )

inline

◆ fromUTF8() [2/2]

const std::string cnoid::fromUTF8 ( const char * text )

inline

◆ getAbsolutePath()

CNOID_EXPORT boost::filesystem::path cnoid::getAbsolutePath ( const boost::filesystem::path & path )

◆ getAbsolutePathString()

CNOID_EXPORT std::string cnoid::getAbsolutePathString ( const boost::filesystem::path & path )

◆ getBasename()

CNOID_EXPORT std::string cnoid::getBasename ( const boost::filesystem::path & path )

◆ getCustomJointPath()

JointPathPtr cnoid::getCustomJointPath	(	Body *	body,
		Link *	baseLink,
		Link *	targetLink
	)

This function returns a joint path which may do analytical inverse kinematics when the body has the analytical one for a given path.

Todo:: move back this function to the Body class

◆ getDefaultNamingContextHelper()

NamingContextHelper * cnoid::getDefaultNamingContextHelper ( )

◆ getExtension()

CNOID_EXPORT std::string cnoid::getExtension ( const boost::filesystem::path & path )

◆ getFilename() [1/2]

CNOID_EXPORT std::string cnoid::getFilename ( const boost::filesystem::path & path )

◆ getFilename() [2/2]

CNOID_EXPORT std::string cnoid::getFilename ( const std::string & pathString )

◆ getGenericPathString()

CNOID_EXPORT std::string cnoid::getGenericPathString ( const boost::filesystem::path & path )

◆ getLeggedBodyHelper()

CNOID_EXPORT LeggedBodyHelper * cnoid::getLeggedBodyHelper ( Body * body )

◆ getMultiDeviceStateSeq()

MultiDeviceStateSeqPtr cnoid::getMultiDeviceStateSeq ( const BodyMotion & motion )

◆ getNativePathString()

CNOID_EXPORT std::string cnoid::getNativePathString ( const boost::filesystem::path & path )

◆ getOpenFileName()

CNOID_EXPORT std::string cnoid::getOpenFileName	(	const std::string &	caption,
		const std::string &	extensions
	)

◆ getOpenFileNames()

CNOID_EXPORT std::vector< std::string > cnoid::getOpenFileNames	(	const std::string &	caption,
		const std::string &	extensions
	)

◆ getORB()

CORBA::ORB_ptr cnoid::getORB ( )

◆ getOrCreateMultiDeviceStateSeq()

MultiDeviceStateSeqPtr cnoid::getOrCreateMultiDeviceStateSeq ( BodyMotion & motion )

◆ getOrCreateZMPSeq()

ZMPSeqPtr cnoid::getOrCreateZMPSeq ( BodyMotion & motion )

◆ getPathString()

CNOID_EXPORT std::string cnoid::getPathString ( const boost::filesystem::path & path )

◆ getRTCManagerServant()

RTM::Manager_ptr cnoid::getRTCManagerServant ( )

◆ getText()

const char * cnoid::getText	(	const char *	domainname,
		const char *	msgid
	)

◆ getZMPSeq()

ZMPSeqPtr cnoid::getZMPSeq ( const BodyMotion & motion )

◆ handlePythonException()

void cnoid::handlePythonException ( )

Author: Shin'ichiro Nakaoka

◆ hat()

Matrix3 cnoid::hat ( const Vector3 & x )

inline

◆ initializeCorbaUtil() [1/2]

void cnoid::initializeCorbaUtil	(	bool	activatePOAManager = `false`,
		int	listeningPort = `-1`
	)

◆ initializeCorbaUtil() [2/2]

void cnoid::initializeCorbaUtil	(	CORBA::ORB_ptr	orb,
		bool	activatePOAManager = `false`
	)

do initialization with an existing orb

◆ initializeFcpFileLoader()

void cnoid::initializeFcpFileLoader ( ExtensionManager & ext )

◆ initializeFilterDialogs()

void cnoid::initializeFilterDialogs ( ExtensionManager & ext )

◆ initializeHrpsysFileIO()

void cnoid::initializeHrpsysFileIO ( ExtensionManager * ext )

◆ initializePoseSeqEngine()

void cnoid::initializePoseSeqEngine ( ExtensionManager * em )

◆ intrusive_ptr_add_ref()

void cnoid::intrusive_ptr_add_ref ( VRMLNode * obj )

inline

◆ intrusive_ptr_release()

void cnoid::intrusive_ptr_release ( VRMLNode * obj )

inline

◆ isRunningInMainThread()

bool cnoid::isRunningInMainThread ( )

◆ labelOfVRMLfieldType()

template<typename TValue >

const char* cnoid::labelOfVRMLfieldType ( )

inline

◆ labelOfVRMLfieldTypeId()

const char * cnoid::labelOfVRMLfieldTypeId ( const std::type_info & fieldType )

◆ LGPLtext()

const char * cnoid::LGPLtext ( )

◆ loadBodyCustomizers() [1/4]

int cnoid::loadBodyCustomizers	(	const std::string	pathString,
		BodyInterface *	bodyInterface
	)

DLLs of body customizer in the path are loaded and they are registered to the customizer repository.

The loaded customizers can be obtained by using findBodyCustomizer() function.

Parameters

pathString the path to a DLL file or a directory that contains DLLs

◆ loadBodyCustomizers() [2/4]

int cnoid::loadBodyCustomizers ( const std::string pathString )

◆ loadBodyCustomizers() [3/4]

int cnoid::loadBodyCustomizers ( BodyInterface * bodyInterface )

The function loads the customizers in the directories specified by the environmental variable CNOID_CUSTOMIZER_PATH

◆ loadBodyCustomizers() [4/4]

int cnoid::loadBodyCustomizers ( )

◆ loadHrpsysSeqFileSet()

bool cnoid::loadHrpsysSeqFileSet	(	BodyMotion &	motion,
		const std::string &	filename,
		std::ostream &	os
	)

◆ loadPCD()

void cnoid::loadPCD	(	SgPointSet *	out_pointSet,
		const std::string &	filename
	)

◆ make_shared_aligned() [1/5]

template<class T >

boost::shared_ptr<T> cnoid::make_shared_aligned ( )

◆ make_shared_aligned() [2/5]

template<class T , class P1 >

boost::shared_ptr<T> cnoid::make_shared_aligned ( const P1 & p1 )

◆ make_shared_aligned() [3/5]

template<class T , class P1 , class P2 >

boost::shared_ptr<T> cnoid::make_shared_aligned	(	const P1 &	p1,
		const P2 &	p2
	)

◆ make_shared_aligned() [4/5]

template<class T , class P1 , class P2 , class P3 >

boost::shared_ptr<T> cnoid::make_shared_aligned	(	const P1 &	p1,
		const P2 &	p2,
		const P3 &	p3
	)

◆ make_shared_aligned() [5/5]

template<class T , class P1 , class P2 , class P3 , class P4 >

boost::shared_ptr<T> cnoid::make_shared_aligned	(	const P1 &	p1,
		const P2 &	p2,
		const P3 &	p3,
		const P4 &	p4
	)

◆ makeFilterString()

QString cnoid::makeFilterString	(	const std::string &	caption,
		const std::string &	extensions_
	)

◆ makePathCompact() [1/2]

CNOID_EXPORT void cnoid::makePathCompact	(	const boost::filesystem::path &	path,
		boost::filesystem::path &	out_compact
	)

◆ makePathCompact() [2/2]

void cnoid::makePathCompact	(	const filesystem::path &	path,
		filesystem::path &	out_compact
	)

◆ makeRootRelative()

bool cnoid::makeRootRelative	(	ZMPSeq &	zmpseq,
		BodyMotion &	motion,
		bool	on
	)

◆ makeTransparent()

int cnoid::makeTransparent	(	SgNode *	topNode,
		float	transparency,
		SgCloneMap &	cloneMap,
		bool	doKeepOrgTransparency = `true`
	)

◆ msleep()

void cnoid::msleep ( int msec )

inline

◆ mvout()

CNOID_EXPORT std::ostream & cnoid::mvout ( bool doFlush = false )

◆ normalizeRotation() [1/3]

CNOID_EXPORT void cnoid::normalizeRotation ( Matrix3 & R )

◆ normalizeRotation() [2/3]

CNOID_EXPORT void cnoid::normalizeRotation ( Position & T )

◆ normalizeRotation() [3/3]

CNOID_EXPORT void cnoid::normalizeRotation ( Affine3 & T )

◆ nullout()

CNOID_EXPORT std::ostream & cnoid::nullout ( )

Todo:: check if this is thread safe ?

◆ numUnmanagedRTCs()

CNOID_EXPORT int cnoid::numUnmanagedRTCs ( )

◆ omegaFromRot()

CNOID_EXPORT Vector3 cnoid::omegaFromRot ( const Matrix3 & R )

◆ operator!=() [1/3]

template<class T , class U >

bool cnoid::operator!=	(	ref_ptr< T > const &	a,
		ref_ptr< U > const &	b
	)

inline

◆ operator!=() [2/3]

template<class T , class U >

bool cnoid::operator!=	(	ref_ptr< T > const &	a,
		U *	b
	)

inline

◆ operator!=() [3/3]

template<class T , class U >

bool cnoid::operator!=	(	T *	a,
		ref_ptr< U > const &	b
	)

inline

◆ operator<() [1/2]

template<class T >

bool cnoid::operator<	(	ref_ptr< T > const &	a,
		ref_ptr< T > const &	b
	)

inline

◆ operator<() [2/2]

template<class T , class U >

bool cnoid::operator<	(	weak_ref_ptr< T > const &	a,
		weak_ref_ptr< U > const &	b
	)

inline

◆ operator<<() [1/11]

std::ostream& cnoid::operator<<	(	std::ostream &	out,
		TIndent &	indent
	)

inline

◆ operator<<() [2/11]

std::ostream& cnoid::operator<<	(	std::ostream &	out,
		const SFVec2f &	v
	)

inline

◆ operator<<() [3/11]

std::ostream & cnoid::operator<<	(	std::ostream &	os,
		const BoundingBox &	bb
	)

◆ operator<<() [4/11]

std::ostream& cnoid::operator<<	(	std::ostream &	out,
		const SFVec3f &	v
	)

inline

◆ operator<<() [5/11]

std::ostream& cnoid::operator<<	(	std::ostream &	out,
		const SFColor &	v
	)

inline

◆ operator<<() [6/11]

std::ostream& cnoid::operator<<	(	std::ostream &	out,
		const SFRotation &	v
	)

inline

◆ operator<<() [7/11]

std::ostream & cnoid::operator<<	(	std::ostream &	os,
		const BoundingBoxf &	bb
	)

◆ operator<<() [8/11]

template<class Y >

std::ostream& cnoid::operator<<	(	std::ostream &	os,
		ref_ptr< Y > const &	p
	)

◆ operator<<() [9/11]

CNOID_EXPORT BodyMotion::Frame cnoid::operator<<	(	BodyMotion::Frame	frame,
		const Body &	body
	)

◆ operator<<() [10/11]

CNOID_EXPORT Body & cnoid::operator<<	(	Body &	body,
		BodyMotion::Frame	frame
	)

◆ operator<<() [11/11]

CNOID_EXPORT Body & cnoid::operator<<	(	Body &	body,
		BodyMotion::ConstFrame	frame
	)

◆ operator==() [1/3]

template<class T , class U >

bool cnoid::operator==	(	ref_ptr< T > const &	a,
		ref_ptr< U > const &	b
	)

inline

◆ operator==() [2/3]

template<class T , class U >

bool cnoid::operator==	(	ref_ptr< T > const &	a,
		U *	b
	)

inline

◆ operator==() [3/3]

template<class T , class U >

bool cnoid::operator==	(	T *	a,
		ref_ptr< U > const &	b
	)

inline

◆ operator>>() [1/9]

EasyScanner & cnoid::operator>>	(	EasyScanner &	scanner,
		double &	value
	)

◆ operator>>() [2/9]

EasyScanner & cnoid::operator>>	(	EasyScanner &	scanner,
		int &	value
	)

◆ operator>>() [3/9]

EasyScanner & cnoid::operator>>	(	EasyScanner &	scanner,
		const char *	matchString
	)

◆ operator>>() [4/9]

EasyScanner & cnoid::operator>>	(	EasyScanner &	scanner,
		char	matchChar
	)

◆ operator>>() [5/9]

EasyScanner & cnoid::operator>>	(	EasyScanner &	scanner,
		std::string &	str
	)

◆ operator>>() [6/9]

EasyScanner & cnoid::operator>>	(	EasyScanner &	scanner,
		EasyScanner::Endl	endl
	)

◆ operator>>() [7/9]

CNOID_EXPORT const Body & cnoid::operator>>	(	const Body &	body,
		BodyMotion::Frame	frame
	)

◆ operator>>() [8/9]

CNOID_EXPORT BodyMotion::Frame cnoid::operator>>	(	BodyMotion::Frame	frame,
		Body &	body
	)

◆ operator>>() [9/9]

CNOID_EXPORT BodyMotion::ConstFrame cnoid::operator>>	(	BodyMotion::ConstFrame	frame,
		Body &	body
	)

◆ playAudioFile()

bool cnoid::playAudioFile	(	const std::string &	filename,
		double	volumeRatio = `-1.0`
	)

◆ pythonMainModule()

boost::python::object cnoid::pythonMainModule ( )

◆ pythonMainNamespace()

boost::python::object cnoid::pythonMainNamespace ( )

◆ pythonSysModule()

boost::python::object cnoid::pythonSysModule ( )

◆ radian() [1/3]

double cnoid::radian ( double deg )

inline

◆ radian() [2/3]

float cnoid::radian ( float deg )

inline

◆ radian() [3/3]

double cnoid::radian ( int deg )

inline

◆ read() [1/5]

template<typename Derived >

void cnoid::read	(	const Listing &	listing,
		Eigen::MatrixBase< Derived > &	x
	)

◆ read() [2/5]

template<typename Derived >

bool cnoid::read	(	const Mapping &	mapping,
		const std::string &	key,
		Eigen::MatrixBase< Derived > &	x
	)

◆ read() [3/5]

template<typename Scalar , int Dim, int Mode>

bool cnoid::read	(	const Mapping &	mapping,
		const std::string &	key,
		Eigen::Transform< Scalar, Dim, Mode > &	T
	)

◆ read() [4/5]

template<typename Scalar >

bool cnoid::read	(	const Mapping &	mapping,
		const std::string &	key,
		Eigen::AngleAxis< Scalar > &	r
	)

This should be defined in another file

◆ read() [5/5]

bool cnoid::read	(	const Mapping &	mapping,
		const std::string &	key,
		boost::function< void(Vector3 &)>	setterFunc
	)

inline

◆ readElements()

template<class Container >

bool cnoid::readElements	(	const Mapping &	mapping,
		const std::string &	key,
		Container &	elements
	)

◆ readEx()

template<typename Derived >

void cnoid::readEx	(	const Mapping &	mapping,
		const std::string &	key,
		Eigen::MatrixBase< Derived > &	x
	)

◆ replaceDirectoryVariable()

void cnoid::replaceDirectoryVariable	(	ArchiveSharedData *	shared,
		QString &	io_pathString,
		const QString &	varname,
		int	pos,
		int	len
	)

◆ rotateYawOrientations()

void cnoid::rotateYawOrientations	(	PoseSeqPtr	seq,
		PoseSeq::iterator	begin,
		const Vector3 &	center,
		double	angle
	)

◆ rotFromRpy() [1/2]

CNOID_EXPORT Matrix3 cnoid::rotFromRpy	(	double	r,
		double	p,
		double	y
	)

◆ rotFromRpy() [2/2]

Matrix3 cnoid::rotFromRpy ( const Vector3 & rpy )

inline

◆ rpyFromRot()

CNOID_EXPORT Vector3 cnoid::rpyFromRot ( const Matrix3 & R )

◆ saveHrpsysSeqFileSet()

bool cnoid::saveHrpsysSeqFileSet	(	BodyMotion &	motion,
		Body *	body,
		const std::string &	filename,
		std::ostream &	os
	)

◆ savePCD()

CNOID_EXPORT void cnoid::savePCD	(	SgPointSet *	pointSet,
		const std::string &	filename,
		const Affine3d &	viewpoint = `Affine3d::Identity()`
	)

◆ setGaussWindow()

template<class T >

void cnoid::setGaussWindow	(	T	sigma,
		int	range,
		std::vector< T > &	out_window
	)

◆ setJacobian() [1/2]

template<int elementMask, int rowOffset, int colOffset, bool useTargetLinkLocalPos>

void cnoid::setJacobian	(	const JointPath &	path,
		Link *	targetLink,
		const Vector3 &	targetLinkLocalPos,
		MatrixXd &	out_J
	)

◆ setJacobian() [2/2]

template<int elementMask, int rowOffset, int colOffset>

void cnoid::setJacobian	(	const JointPath &	path,
		Link *	targetLink,
		MatrixXd &	out_J
	)

◆ shareDirectory()

CNOID_EXPORT const std::string & cnoid::shareDirectory ( )

◆ showConfirmDialog() [1/3]

bool cnoid::showConfirmDialog	(	const char *	caption,
		const char *	message
	)

◆ showConfirmDialog() [2/3]

bool cnoid::showConfirmDialog	(	const std::string &	caption,
		const std::string &	message
	)

◆ showConfirmDialog() [3/3]

bool cnoid::showConfirmDialog	(	const QString &	caption,
		const QString &	message
	)

◆ showMessageBox() [1/4]

void cnoid::showMessageBox ( const std::string & message )

◆ showMessageBox() [2/4]

void cnoid::showMessageBox ( const boost::format & message )

◆ showMessageBox() [3/4]

void cnoid::showMessageBox ( const char * message )

◆ showMessageBox() [4/4]

void cnoid::showMessageBox ( const QString & message )

◆ showWarningDialog() [1/4]

void cnoid::showWarningDialog ( const std::string & message )

◆ showWarningDialog() [2/4]

void cnoid::showWarningDialog ( const boost::format & message )

◆ showWarningDialog() [3/4]

void cnoid::showWarningDialog ( const char * message )

◆ showWarningDialog() [4/4]

void cnoid::showWarningDialog ( const QString & message )

◆ sigAboutToQuit()

SignalProxy< void()> cnoid::sigAboutToQuit ( )

◆ static_pointer_cast()

template<class T , class U >

ref_ptr<T> cnoid::static_pointer_cast ( ref_ptr< U > const & p )

◆ str()

CNOID_EXPORT std::string cnoid::str ( const Vector3 & v )

◆ swap() [1/2]

template<class T >

void cnoid::swap	(	ref_ptr< T > &	lhs,
		ref_ptr< T > &	rhs
	)

◆ swap() [2/2]

template<class T >

void cnoid::swap	(	weak_ref_ptr< T > &	a,
		weak_ref_ptr< T > &	b
	)

◆ takeOverCorbaPluginInitialization()

CNOID_EXPORT bool cnoid::takeOverCorbaPluginInitialization ( CORBA::ORB_ptr orb )

◆ toActualPathName()

CNOID_EXPORT std::string cnoid::toActualPathName ( const std::string & path )

◆ toUTF8() [1/2]

const std::string& cnoid::toUTF8 ( const std::string & text )

inline

◆ toUTF8() [2/2]

const std::string cnoid::toUTF8 ( const char * text )

inline

◆ toVector3()

CNOID_EXPORT bool cnoid::toVector3	(	const std::string &	s,
		Vector3 &	out_v
	)

◆ usleep()

void cnoid::usleep ( int usec )

inline

◆ ValueNode::to< std::string >()

template<>

std::string cnoid::ValueNode::to< std::string > ( ) const

inline

◆ write() [1/3]

template<typename Derived >

Listing& cnoid::write	(	Mapping &	mapping,
		const std::string &	key,
		const Eigen::MatrixBase< Derived > &	x
	)

◆ write() [2/3]

template<typename Scalar , int Dim, int Mode>

Listing& cnoid::write	(	Mapping &	mapping,
		const std::string &	key,
		const Eigen::Transform< Scalar, Dim, Mode > &	T
	)

◆ write() [3/3]

template<typename Scalar >

Listing& cnoid::write	(	Mapping &	mapping,
		const std::string &	key,
		const Eigen::AngleAxis< Scalar > &	r
	)

◆ writeElements()

template<class Container >

bool cnoid::writeElements	(	Mapping &	mapping,
		const std::string &	key,
		const Container &	elements,
		bool	isFlowStyle = `false`
	)

Variable Documentation

◆ BODY_SIMULATION_PROFILING

const bool cnoid::BODY_SIMULATION_PROFILING = false

◆ nspoa

PortableServer::POA_var cnoid::nspoa

◆ PI

const double cnoid::PI = 3.14159265358979323846

◆ PI_2

const double cnoid::PI_2 = 1.57079632679489661923

◆ SIMULATION_PROFILING

const bool cnoid::SIMULATION_PROFILING = false

◆ TO_DEGREE

const double cnoid::TO_DEGREE = 180.0 / PI

◆ TO_RADIAN

const double cnoid::TO_RADIAN = PI / 180.0

Namespaces

Classes

Typedefs

Enumerations

Functions

Variables

Detailed Description

Typedef Documentation

◆ AbstractBodyLoaderPtr

◆ AbstractMultiSeqItemPtr

◆ AbstractMultiSeqPtr

◆ AbstractSeqItemPtr

◆ AbstractSeqPtr

◆ AbstractTextItemPtr

◆ AbstractVRMLGroupPtr

◆ AccelerationSensorPtr

◆ Affine3

◆ AISTCollisionDetectorPtr

◆ AISTSimulatorItemPtr

◆ AngleAxis

◆ ArchivePtr

◆ AudioItemPtr

◆ BodyCustomizerCalcAnalyticIkFunc

◆ BodyCustomizerCreateFunc

◆ BodyCustomizerDestroyFunc

◆ BodyCustomizerGetTargetModelNamesFunc

◆ BodyCustomizerHandle

◆ BodyCustomizerInitializeAnalyticIkFunc

◆ BodyCustomizerSetVirtualJointForcesFunc

◆ BodyGetLinkDoubleValuePtrFunc

◆ BodyGetLinkIndexFromNameFunc

◆ BodyGetLinkNameFunc

◆ BodyHandle

◆ BodyItemPtr

◆ BodyMotionControllerItemPtr

◆ BodyMotionEnginePtr

◆ BodyMotionItemPtr

◆ BodyMotionPtr

◆ BodyPtr

◆ BodyRTCItemPtr

◆ BodyTrackingCameraItemPtr

◆ BoundingBoxMarkerPtr

◆ BulletCollisionDetectorPtr

◆ BulletSimulatorItemPtr

◆ CameraPtr

◆ ColdetModelPairPtr

◆ ColdetModelPtr

◆ CollisionArray

◆ CollisionDetectorPtr

◆ CollisionLinkPairList

◆ CollisionLinkPairListPtr

◆ CollisionLinkPairPtr

◆ CollisionList

◆ CollisionPairPtr

◆ CollisionSeqEnginePtr

◆ CollisionSeqItemPtr

◆ CollisionSeqPtr

◆ CompositeIKPtr

◆ ControllerItemPtr

◆ CrawlerLinkMap

◆ CrossMarkerPtr

◆ DaeActuatorPtr

◆ DaeActuatorRelations

◆ DaeActuators

◆ DaeAttachActuatorPtr

◆ DaeAttachSensorPtr

◆ DaeEffectPtr

◆ DaeEffects

◆ DaeGeometries

◆ DaeGeometryPtr

◆ DaeJointChildren

◆ DaeJointPtr

◆ DaeJoints

◆ DaeLinkChildren

◆ DaeLinkPtr

◆ DaeLinks

◆ DaeMassFramePtr

◆ DaeMaterialPtr

◆ DaeMaterialRef

◆ DaeMaterials