OpenRAVE: headers diff between 0.5.0 and 0.6.0 versions

	config.h	config.h

	skipping to change at line 39	skipping to change at line 39
	#else	#else
	#define OPENRAVE_API OPENRAVE_HELPER_DLL_IMPORT	#define OPENRAVE_API OPENRAVE_HELPER_DLL_IMPORT
	#endif // OPENRAVE_DLL_EXPORTS	#endif // OPENRAVE_DLL_EXPORTS
	#define OPENRAVE_LOCAL OPENRAVE_HELPER_DLL_LOCAL	#define OPENRAVE_LOCAL OPENRAVE_HELPER_DLL_LOCAL
	#else // OPENRAVE_DLL is not defined: this means OpenRAVE is a static lib.	#else // OPENRAVE_DLL is not defined: this means OpenRAVE is a static lib.
	#define OPENRAVE_API	#define OPENRAVE_API
	#define OPENRAVE_LOCAL	#define OPENRAVE_LOCAL
	#endif // OPENRAVE_DLL	#endif // OPENRAVE_DLL

	#define OPENRAVE_VERSION_MAJOR 0	#define OPENRAVE_VERSION_MAJOR 0

	#define OPENRAVE_VERSION_MINOR 5	#define OPENRAVE_VERSION_MINOR 6
	#define OPENRAVE_VERSION_PATCH 0	#define OPENRAVE_VERSION_PATCH 0
	#define OPENRAVE_VERSION_COMBINED(major, minor, patch) (((major) << 16) \| ( (minor) << 8) \| (patch))	#define OPENRAVE_VERSION_COMBINED(major, minor, patch) (((major) << 16) \| ( (minor) << 8) \| (patch))
	#define OPENRAVE_VERSION OPENRAVE_VERSION_COMBINED(OPENRAVE_VERSION_MAJOR, OPENRAVE_VERSION_MINOR, OPENRAVE_VERSION_PATCH)	#define OPENRAVE_VERSION OPENRAVE_VERSION_COMBINED(OPENRAVE_VERSION_MAJOR, OPENRAVE_VERSION_MINOR, OPENRAVE_VERSION_PATCH)
	#define OPENRAVE_VERSION_EXTRACT_MAJOR(version) (((version)>>16)&0xff)	#define OPENRAVE_VERSION_EXTRACT_MAJOR(version) (((version)>>16)&0xff)
	#define OPENRAVE_VERSION_EXTRACT_MINOR(version) (((version)>>8)&0xff)	#define OPENRAVE_VERSION_EXTRACT_MINOR(version) (((version)>>8)&0xff)
	#define OPENRAVE_VERSION_EXTRACT_PATCH(version) (((version))&0xff)	#define OPENRAVE_VERSION_EXTRACT_PATCH(version) (((version))&0xff)

	#define OPENRAVE_VERSION_STRING "0.5.0"	#define OPENRAVE_VERSION_STRING "0.6.0"
	#define OPENRAVE_VERSION_STRING_FORMAT(version) boost::str(boost::format("% s.%s.%s")%(OPENRAVE_VERSION_EXTRACT_MAJOR(version))%(OPENRAVE_VERSION_EXTRA CT_MINOR(version))%(OPENRAVE_VERSION_EXTRACT_PATCH(version)))	#define OPENRAVE_VERSION_STRING_FORMAT(version) boost::str(boost::format("% s.%s.%s")%(OPENRAVE_VERSION_EXTRACT_MAJOR(version))%(OPENRAVE_VERSION_EXTRA CT_MINOR(version))%(OPENRAVE_VERSION_EXTRACT_PATCH(version)))

	#define OPENRAVE_VERSION_GE(major1, minor1, patch1, major2, minor2, patch2) (OPENRAVE_VERSION_COMBINED(major1, minor1, patch1) >= OPENRAVE_VERSION_COM BINED(major2, minor2, patch2))	#define OPENRAVE_VERSION_GE(major1, minor1, patch1, major2, minor2, patch2) (OPENRAVE_VERSION_COMBINED(major1, minor1, patch1) >= OPENRAVE_VERSION_COM BINED(major2, minor2, patch2))
	#define OPENRAVE_VERSION_MINIMUM(major, minor, patch) OPENRAVE_VERSION_GE(O PENRAVE_VERSION_MAJOR, OPENRAVE_VERSION_MINOR, OPENRAVE_VERSION_PATCH, majo r, minor, patch)	#define OPENRAVE_VERSION_MINIMUM(major, minor, patch) OPENRAVE_VERSION_GE(O PENRAVE_VERSION_MAJOR, OPENRAVE_VERSION_MINOR, OPENRAVE_VERSION_PATCH, majo r, minor, patch)

	// if 0, single precision	// if 0, single precision
	// if 1, double precision	// if 1, double precision
	#define OPENRAVE_PRECISION 1	#define OPENRAVE_PRECISION 1


	#define OPENRAVE_PLUGINS_INSTALL_DIR "/home/andrey/upstream-tracker/testing	#define OPENRAVE_PLUGINS_INSTALL_DIR "/home/andrey/upstream-tracker/testing
	/openrave/0.5.0/share/openrave-0.5/plugins"	/openrave/0.6.0/share/openrave-0.6/plugins"
	#define OPENRAVE_DATA_INSTALL_DIR "/home/andrey/upstream-tracker/testing/op	#define OPENRAVE_DATA_INSTALL_DIR "/home/andrey/upstream-tracker/testing/op
	enrave/0.5.0/share/openrave-0.5"	enrave/0.6.0/share/openrave-0.6"
	#define OPENRAVE_PYTHON_INSTALL_DIR "/home/andrey/upstream-tracker/testing/	#define OPENRAVE_PYTHON_INSTALL_DIR "/home/andrey/upstream-tracker/testing/
	openrave/0.5.0/lib/python2.7/site-packages"	openrave/0.6.0/lib/python2.7/site-packages"

	#endif	#endif

End of changes. 3 change blocks.
	8 lines changed or deleted	8 lines changed or added

	environment.h	environment.h

	skipping to change at line 378	skipping to change at line 378
	/// \return first Robot that matches the name	/// \return first Robot that matches the name
	virtual RobotBasePtr GetRobot(const std::string& name) const =0;	virtual RobotBasePtr GetRobot(const std::string& name) const =0;

	/// \brief Get all bodies loaded in the environment (including robots). <b>[multi-thread safe]</b>	/// \brief Get all bodies loaded in the environment (including robots). <b>[multi-thread safe]</b>
	/// \param[out] bodies filled with all the bodies	/// \param[out] bodies filled with all the bodies
	virtual void GetBodies(std::vector<KinBodyPtr>& bodies) const = 0;	virtual void GetBodies(std::vector<KinBodyPtr>& bodies) const = 0;

	/// \brief Fill an array with all robots loaded in the environment. <b> [multi-thread safe]</b>	/// \brief Fill an array with all robots loaded in the environment. <b> [multi-thread safe]</b>
	virtual void GetRobots(std::vector<RobotBasePtr>& robots) const = 0;	virtual void GetRobots(std::vector<RobotBasePtr>& robots) const = 0;


	/// \brief adds a viewer to the environment
	///
	/// \throw openrave_exception Throw if body is invalid or already added
	virtual void AddViewer(ViewerBasePtr pviewer) = 0;

	/// \deprecated (11/06/13) see AddViewer
	virtual bool AttachViewer(ViewerBasePtr pnewviewer) RAVE_DEPRECATED {
	AddViewer(pnewviewer); return true;
	}

	/// \brief Return a viewer with a particular name.
	///
	/// When no name is specified, the first loaded viewer is returned.
	virtual ViewerBasePtr GetViewer(const std::string& name="") const = 0;

	/// \brief Returns a list of loaded viewers with a pointer to a lock pr
	eventing the list from being modified.
	///
	/// As long as the lock is held, the problems are guaranteed to stay lo
	aded in the environment.
	/// \return returns a pointer to a Lock. Destroying the shared_ptr will
	release the lock
	virtual boost::shared_ptr<boost::mutex::scoped_lock> GetViewers(std::li
	st<ViewerBasePtr>& listViewers) const = 0;

	/// \brief Retrieve published bodies, completes even if environment is locked. <b>[multi-thread safe]</b>	/// \brief Retrieve published bodies, completes even if environment is locked. <b>[multi-thread safe]</b>
	///	///
	/// Note that the pbody pointer might become invalid as soon as GetPubl ishedBodies returns.	/// Note that the pbody pointer might become invalid as soon as GetPubl ishedBodies returns.
	virtual void GetPublishedBodies(std::vector<KinBody::BodyState>& vbodie s) = 0;	virtual void GetPublishedBodies(std::vector<KinBody::BodyState>& vbodie s) = 0;

	/// updates the published bodies that viewers and other programs listen ing in on the environment see.	/// updates the published bodies that viewers and other programs listen ing in on the environment see.
	/// For example, calling this function inside a planning loop allows th e viewer to update the environment	/// For example, calling this function inside a planning loop allows th e viewer to update the environment
	/// reflecting the status of the planner.	/// reflecting the status of the planner.
	/// Assumes that the physics are locked.	/// Assumes that the physics are locked.
	virtual void UpdatePublishedBodies() = 0;	virtual void UpdatePublishedBodies() = 0;

	skipping to change at line 432	skipping to change at line 411
	/// \param[out] trimesh - The output triangle mesh. The new triangles a re appended to the existing triangles!	/// \param[out] trimesh - The output triangle mesh. The new triangles a re appended to the existing triangles!
	/// \param[in] options - Controlls what to triangulate.	/// \param[in] options - Controlls what to triangulate.
	/// \param[in] selectname - name of the body used in options	/// \param[in] selectname - name of the body used in options
	/// \throw openrave_exception Throw if failed to add anything	/// \throw openrave_exception Throw if failed to add anything
	virtual void TriangulateScene(KinBody::Link::TRIMESH& trimesh, Selectio nOptions options, const std::string& selectname) = 0;	virtual void TriangulateScene(KinBody::Link::TRIMESH& trimesh, Selectio nOptions options, const std::string& selectname) = 0;
	//@}	//@}

	/// \brief Load a new module, need to Lock if calling outside simulatio n thread	/// \brief Load a new module, need to Lock if calling outside simulatio n thread
	virtual int AddModule(ModuleBasePtr module, const std::string& cmdargs) = 0;	virtual int AddModule(ModuleBasePtr module, const std::string& cmdargs) = 0;


	virtual int LoadProblem(ModuleBasePtr module, const std::string& cmdarg	/// \deprecated (12/01/30) see \ref EnvironmentBase::AddModule
	s) {	virtual int LoadProblem(ModuleBasePtr module, const std::string& cmdarg
		s) RAVE_DEPRECATED {
	return AddModule(module,cmdargs);	return AddModule(module,cmdargs);
	}	}

	/// \deprecated (10/09/15) see \ref EnvironmentBase::Remove	/// \deprecated (10/09/15) see \ref EnvironmentBase::Remove
	virtual bool RemoveProblem(ModuleBasePtr prob) RAVE_DEPRECATED = 0;	virtual bool RemoveProblem(ModuleBasePtr prob) RAVE_DEPRECATED = 0;

	/// \brief Returns a list of loaded problems with a pointer to a lock p reventing the list from being modified.	/// \brief Returns a list of loaded problems with a pointer to a lock p reventing the list from being modified.
	///	///
	/// As long as the lock is held, the problems are guaranteed to stay lo aded in the environment.	/// As long as the lock is held, the problems are guaranteed to stay lo aded in the environment.
	/// \return returns a pointer to a Lock. Destroying the shared_ptr will release the lock	/// \return returns a pointer to a Lock. Destroying the shared_ptr will release the lock

	skipping to change at line 463	skipping to change at line 443
	/// is locked, the user is guaranteed that nnothing will change in the environment.	/// is locked, the user is guaranteed that nnothing will change in the environment.
	virtual EnvironmentMutex& GetMutex() const = 0;	virtual EnvironmentMutex& GetMutex() const = 0;

	/// \name 3D plotting methods.	/// \name 3D plotting methods.
	/// \anchor env_plotting	/// \anchor env_plotting
	//@{	//@{

	/// \deprecated (10/11/05)	/// \deprecated (10/11/05)
	typedef OpenRAVE::GraphHandlePtr GraphHandlePtr RAVE_DEPRECATED;	typedef OpenRAVE::GraphHandlePtr GraphHandlePtr RAVE_DEPRECATED;


		/// \brief adds a viewer to the environment
		///
		/// \throw openrave_exception Throw if body is invalid or already added
		virtual void AddViewer(ViewerBasePtr pviewer) = 0;

		/// \deprecated (11/06/13) see AddViewer
		virtual bool AttachViewer(ViewerBasePtr pnewviewer) RAVE_DEPRECATED {
		AddViewer(pnewviewer); return true;
		}

		/// \brief Return a viewer with a particular name.
		///
		/// When no name is specified, the first loaded viewer is returned.
		virtual ViewerBasePtr GetViewer(const std::string& name="") const = 0;

		/// \brief Returns a list of loaded viewers with a pointer to a lock pr
		eventing the list from being modified.
		///
		/// As long as the lock is held, the problems are guaranteed to stay lo
		aded in the environment.
		/// \return returns a pointer to a Lock. Destroying the shared_ptr will
		release the lock
		virtual boost::shared_ptr<boost::mutex::scoped_lock> GetViewers(std::li
		st<ViewerBasePtr>& listViewers) const = 0;

	/// \brief Plot a point cloud with one color. <b>[multi-thread safe]</b >	/// \brief Plot a point cloud with one color. <b>[multi-thread safe]</b >
	///	///
	/// \param ppoints array of points	/// \param ppoints array of points
	/// \param numPoints number of points to plot	/// \param numPoints number of points to plot
	/// \param stride stride in bytes to next point, ie: nextpoint = (float )((char)ppoints+stride)	/// \param stride stride in bytes to next point, ie: nextpoint = (float )((char)ppoints+stride)
	/// \param fPointSize size of a point in pixels	/// \param fPointSize size of a point in pixels
	/// \param color the rgb color of the point. The last component of the color is used for alpha blending	/// \param color the rgb color of the point. The last component of the color is used for alpha blending
	/// \param drawstyle if 0 will draw pixels. if 1, will draw 3D spheres	/// \param drawstyle if 0 will draw pixels. if 1, will draw 3D spheres
	/// \return handle to plotted points, graph is removed when handle is d estroyed (goes out of scope). This requires the user to always store the ha ndle in a persistent variable if the plotted graphics are to remain on the viewer.	/// \return handle to plotted points, graph is removed when handle is d estroyed (goes out of scope). This requires the user to always store the ha ndle in a persistent variable if the plotted graphics are to remain on the viewer.
	virtual OpenRAVE::GraphHandlePtr plot3(const float* ppoints, int numPoi nts, int stride, float fPointSize, const RaveVector<float>& color = RaveVec tor<float>(1,0.5,0.5,1), int drawstyle = 0) = 0;	virtual OpenRAVE::GraphHandlePtr plot3(const float* ppoints, int numPoi nts, int stride, float fPointSize, const RaveVector<float>& color = RaveVec tor<float>(1,0.5,0.5,1), int drawstyle = 0) = 0;

End of changes. 3 change blocks.
	27 lines changed or deleted	28 lines changed or added

	planningutils.h	planningutils.h

	skipping to change at line 32	skipping to change at line 32
	#define OPENRAVE_PLANNINGUTILS_H	#define OPENRAVE_PLANNINGUTILS_H

	#include <openrave/openrave.h>	#include <openrave/openrave.h>

	namespace OpenRAVE {	namespace OpenRAVE {

	namespace planningutils {	namespace planningutils {

	/// \brief Jitters the active joint angles of the robot until it escapes co llision.	/// \brief Jitters the active joint angles of the robot until it escapes co llision.
	///	///

	/// Return 0 if jitter failed and robot is in collision, -1 if robot origin ally not in collision, 1 if jitter succeeded.	/// Return 0 if jitter failed and robot is in collision, -1 if robot origin ally not in collision, 1 if jitter succeeded and position is different.
	OPENRAVE_API int JitterActiveDOF(RobotBasePtr robot,int nMaxIterations=5000 ,dReal fRand=0.03f,const PlannerBase::PlannerParameters::NeighStateFn& neig hstatefn = PlannerBase::PlannerParameters::NeighStateFn());	OPENRAVE_API int JitterActiveDOF(RobotBasePtr robot,int nMaxIterations=5000 ,dReal fRand=0.03f,const PlannerBase::PlannerParameters::NeighStateFn& neig hstatefn = PlannerBase::PlannerParameters::NeighStateFn());

	/// \brief Jitters the transform of a body until it escapes collision.	/// \brief Jitters the transform of a body until it escapes collision.
	OPENRAVE_API bool JitterTransform(KinBodyPtr pbody, float fJitter, int nMax Iterations=1000);	OPENRAVE_API bool JitterTransform(KinBodyPtr pbody, float fJitter, int nMax Iterations=1000);

	/** \brief validates a trajectory with respect to the planning constraints. <b>[multi-thread safe]</b>	/** \brief validates a trajectory with respect to the planning constraints. <b>[multi-thread safe]</b>

	checks internal data structures and verifies that all trajectory via po ints do not violate joint position, velocity, and acceleration limits.	checks internal data structures and verifies that all trajectory via po ints do not violate joint position, velocity, and acceleration limits.
	\param trajectory trajectory of points to be checked	\param trajectory trajectory of points to be checked
	\param parameters the planner parameters passed to the planner that ret urned the trajectory	\param parameters the planner parameters passed to the planner that ret urned the trajectory

	\param samplingstep If == 0, then will only test the supports points in trajectory->GetPoints(). If > 0, then will sample the trajectory at this t ime interval.	\param samplingstep If == 0, then will only test the supports points in trajectory->GetPoints(). If > 0, then will sample the trajectory at this t ime interval and check that smoothness is satisfied along with segment cons traints.
	\throw openrave_exception If the trajectory is invalid, will throw ORE_ InconsistentConstraints.	\throw openrave_exception If the trajectory is invalid, will throw ORE_ InconsistentConstraints.
	*/	*/
	OPENRAVE_API void VerifyTrajectory(PlannerBase::PlannerParametersConstPtr p arameters, TrajectoryBaseConstPtr trajectory, dReal samplingstep=0.002);	OPENRAVE_API void VerifyTrajectory(PlannerBase::PlannerParametersConstPtr p arameters, TrajectoryBaseConstPtr trajectory, dReal samplingstep=0.002);

	/** \brief Smooth the trajectory points consisting of active dofs of the ro bot while avoiding collisions. <b>[multi-thread safe]</b>	/** \brief Smooth the trajectory points consisting of active dofs of the ro bot while avoiding collisions. <b>[multi-thread safe]</b>

	Only initial and goal configurations are preserved.	Only initial and goal configurations are preserved.
	\param traj the trajectory that initially contains the input points, it is modified to contain the new re-timed data.	\param traj the trajectory that initially contains the input points, it is modified to contain the new re-timed data.
	\param robot use the robot's active dofs to initialize the trajectory s pace	\param robot use the robot's active dofs to initialize the trajectory s pace
	\param plannername the name of the planner to use to smooth. If empty, will use the default trajectory re-timer.	\param plannername the name of the planner to use to smooth. If empty, will use the default trajectory re-timer.

	skipping to change at line 90	skipping to change at line 90

	Collision is not checked. Every waypoint in the trajectory is guarantee d to be hit.	Collision is not checked. Every waypoint in the trajectory is guarantee d to be hit.
	\param traj the trajectory that initially contains the input points, it is modified to contain the new re-timed data.	\param traj the trajectory that initially contains the input points, it is modified to contain the new re-timed data.
	\param maxvelocities the max velocities of each dof	\param maxvelocities the max velocities of each dof
	\param maxaccelerations the max acceleration of each dof	\param maxaccelerations the max acceleration of each dof
	\param plannername the name of the planner to use to retime. If empty, will use the default trajectory re-timer.	\param plannername the name of the planner to use to retime. If empty, will use the default trajectory re-timer.
	\param hastimestamps if true, use the already initialized timestamps of the trajectory	\param hastimestamps if true, use the already initialized timestamps of the trajectory
	*/	*/
	OPENRAVE_API void RetimeAffineTrajectory(TrajectoryBasePtr traj, const std: :vector<dReal>& maxvelocities, const std::vector<dReal>& maxaccelerations, bool hastimestamps=false, const std::string& plannername="");	OPENRAVE_API void RetimeAffineTrajectory(TrajectoryBasePtr traj, const std: :vector<dReal>& maxvelocities, const std::vector<dReal>& maxaccelerations, bool hastimestamps=false, const std::string& plannername="");


		/** \brief Inserts a waypoint into a trajectory at the index specified, and
		retimes the segment before and after the trajectory. <b>[multi-thread safe
		]</b>

		Collision is not checked on the modified segments of the trajectory.
		\param index The index where to start modifying the trajectory.
		\param dofvalues the configuration to insert into the trajectcory (acti
		ve dof values of the robot)
		\param dofvelocities the velocities that the inserted point should star
		t with
		\param traj the trajectory that initially contains the input points, it
		is modified to contain the new re-timed data.
		\param robot use the robot's active dofs to initialize the trajectory s
		pace
		\param plannername the name of the planner to use to retime. If empty,
		will use the default trajectory re-timer.
		*/
		OPENRAVE_API void InsertActiveDOFWaypointWithRetiming(int index, const std:
		:vector<dReal>& dofvalues, const std::vector<dReal>& dofvelocities, Traject
		oryBasePtr traj, RobotBasePtr robot, dReal fmaxvelmult=1, const std::string
		& plannername="");

	/// \brief convert the trajectory and all its points to a new specification	/// \brief convert the trajectory and all its points to a new specification
	OPENRAVE_API void ConvertTrajectorySpecification(TrajectoryBasePtr traj, co nst ConfigurationSpecification& spec);	OPENRAVE_API void ConvertTrajectorySpecification(TrajectoryBasePtr traj, co nst ConfigurationSpecification& spec);

	/// \brief reverses the order of the trajectory waypoints and times.	/// \brief reverses the order of the trajectory waypoints and times.
	///	///
	/// Velocities are just negated and the new trajectory is not guaranteed to be executable or valid	/// Velocities are just negated and the new trajectory is not guaranteed to be executable or valid
	OPENRAVE_API TrajectoryBasePtr ReverseTrajectory(TrajectoryBaseConstPtr tra j);	OPENRAVE_API TrajectoryBasePtr ReverseTrajectory(TrajectoryBaseConstPtr tra j);

	/// \brief merges the contents of multiple trajectories into one so that ev erything can be played simultaneously.	/// \brief merges the contents of multiple trajectories into one so that ev erything can be played simultaneously.
	///	///
	/// Each trajectory needs to have a 'deltatime' group for timestamps. The t rajectories cannot share common configuration data because only one	/// Each trajectory needs to have a 'deltatime' group for timestamps. The t rajectories cannot share common configuration data because only one
	/// trajectories's data can be set at a time.	/// trajectories's data can be set at a time.
	/// \throw openrave_exception throws an exception if the trajectory data is incompatible and cannot be merged.	/// \throw openrave_exception throws an exception if the trajectory data is incompatible and cannot be merged.
	OPENRAVE_API TrajectoryBasePtr MergeTrajectories(const std::list<Trajectory BaseConstPtr>& listtrajectories);	OPENRAVE_API TrajectoryBasePtr MergeTrajectories(const std::list<Trajectory BaseConstPtr>& listtrajectories);


		/** \brief sets the planner parameters structure from a configuration speci
		fication

		Attempt to set default values for all parameters
		*/
		OPENRAVE_API void SetPlannerParametersFromSpecification(PlannerBase::Planne
		rParametersPtr parameters, const ConfigurationSpecification& spec);

	/// \brief Line collision	/// \brief Line collision
	class OPENRAVE_API LineCollisionConstraint	class OPENRAVE_API LineCollisionConstraint
	{	{
	public:	public:
	LineCollisionConstraint();	LineCollisionConstraint();
	bool Check(PlannerBase::PlannerParametersWeakPtr _params, KinBodyPtr ro bot, const std::vector<dReal>& pQ0, const std::vector<dReal>& pQ1, Interval Type interval, PlannerBase::ConfigurationListPtr pvCheckedConfigurations);	bool Check(PlannerBase::PlannerParametersWeakPtr _params, KinBodyPtr ro bot, const std::vector<dReal>& pQ0, const std::vector<dReal>& pQ1, Interval Type interval, PlannerBase::ConfigurationListPtr pvCheckedConfigurations);

	protected:	protected:
	std::vector<dReal> _vtempconfig, dQ;	std::vector<dReal> _vtempconfig, dQ;
	CollisionReportPtr _report;	CollisionReportPtr _report;

End of changes. 4 change blocks.
	2 lines changed or deleted	32 lines changed or added

This html diff was produced by rfcdiff 1.41. The latest version is available from http://tools.ietf.org/tools/rfcdiff/

	interfacehashes.h	interfacehashes.h
	#define OPENRAVE_COLLISIONCHECKER_HASH "690784eb9e41b068a893dbf1761c01d1"	#define OPENRAVE_COLLISIONCHECKER_HASH "690784eb9e41b068a893dbf1761c01d1"

	#define OPENRAVE_ROBOT_HASH "daecf7d25afb90fef5dd9987f5c98f5b"	#define OPENRAVE_ROBOT_HASH "176817657116a7793a3eb0c1001e7127"
	#define OPENRAVE_PLANNER_HASH "6fc740f9b2bbfde93d78032cbf1b9121"	#define OPENRAVE_PLANNER_HASH "6fc740f9b2bbfde93d78032cbf1b9121"

	#define OPENRAVE_KINBODY_HASH "39cb185f844b5607190cd761199c7ae2"	#define OPENRAVE_KINBODY_HASH "b46f2dd7208a9ac04b639bc04f521c45"
	#define OPENRAVE_SENSORSYSTEM_HASH "83208394c99a021fbdcd55ac2810e65f"	#define OPENRAVE_SENSORSYSTEM_HASH "83208394c99a021fbdcd55ac2810e65f"
	#define OPENRAVE_CONTROLLER_HASH "4b94816a0f156bc4a3e98f79f3898683"	#define OPENRAVE_CONTROLLER_HASH "4b94816a0f156bc4a3e98f79f3898683"
	#define OPENRAVE_MODULE_HASH "fec1b591cb5ef03912009f9abdcd037d"	#define OPENRAVE_MODULE_HASH "fec1b591cb5ef03912009f9abdcd037d"
	#define OPENRAVE_IKSOLVER_HASH "9fd7944dbecc4eed8cceb4f6d5a618ce"	#define OPENRAVE_IKSOLVER_HASH "9fd7944dbecc4eed8cceb4f6d5a618ce"
	#define OPENRAVE_PHYSICSENGINE_HASH "257dd698a5b7a78b8bd4d05a3d322c0b"	#define OPENRAVE_PHYSICSENGINE_HASH "257dd698a5b7a78b8bd4d05a3d322c0b"
	#define OPENRAVE_SENSOR_HASH "1425016f0176ff3811962fbefd63c31e"	#define OPENRAVE_SENSOR_HASH "1425016f0176ff3811962fbefd63c31e"
	#define OPENRAVE_TRAJECTORY_HASH "c386a85687d6dea075d3d9ed1c68b808"	#define OPENRAVE_TRAJECTORY_HASH "c386a85687d6dea075d3d9ed1c68b808"
	#define OPENRAVE_VIEWER_HASH "c58fb4ff10585995bc49e53f3175b473"	#define OPENRAVE_VIEWER_HASH "c58fb4ff10585995bc49e53f3175b473"
	#define OPENRAVE_SPACESAMPLER_HASH "3b8faec230636cab285670c095c95496"	#define OPENRAVE_SPACESAMPLER_HASH "3b8faec230636cab285670c095c95496"

	#define OPENRAVE_ENVIRONMENT_HASH "bee66712a5dc2ac11644ab32817ee06a"	#define OPENRAVE_ENVIRONMENT_HASH "d4cc98d22fe988548a1788456c51629e"
	#define OPENRAVE_PLUGININFO_HASH "8d45441947223c660c8f8ff9723bf58e"	#define OPENRAVE_PLUGININFO_HASH "8d45441947223c660c8f8ff9723bf58e"

End of changes. 3 change blocks.
	3 lines changed or deleted	3 lines changed or added

	kinbody.h	kinbody.h

	skipping to change at line 629	skipping to change at line 629
	virtual void GetTorqueLimits(std::vector<dReal>& vmax, bool bAppend =false) const;	virtual void GetTorqueLimits(std::vector<dReal>& vmax, bool bAppend =false) const;

	/// \brief \see GetTorqueLimits	/// \brief \see GetTorqueLimits
	virtual void SetTorqueLimits(const std::vector<dReal>& vmax);	virtual void SetTorqueLimits(const std::vector<dReal>& vmax);

	/// \brief The weight associated with a joint's axis for computing a distance in the robot configuration space.	/// \brief The weight associated with a joint's axis for computing a distance in the robot configuration space.
	virtual dReal GetWeight(int axis=0) const;	virtual dReal GetWeight(int axis=0) const;
	/// \brief \see GetWeight	/// \brief \see GetWeight
	virtual void SetWeights(const std::vector<dReal>& weights);	virtual void SetWeights(const std::vector<dReal>& weights);


		/// \brief Computes the configuration difference values1-values2 an
		d stores it in values1.
		///
		/// Takes into account joint limits and wrapping of circular joints
		.
		virtual void SubtractValues(std::vector<dReal>& values1, const std:
		:vector<dReal>& values2) const;

	/// \brief Return internal offset parameter that determines the bra nch the angle centers on	/// \brief Return internal offset parameter that determines the bra nch the angle centers on
	///	///
	/// Wrap offsets are needed for rotation joints since the range is limited to 2*pi.	/// Wrap offsets are needed for rotation joints since the range is limited to 2*pi.
	/// This allows the wrap offset to be set so the joint can function in [-pi+offset,pi+offset]..	/// This allows the wrap offset to be set so the joint can function in [-pi+offset,pi+offset]..
	/// \param iaxis the axis to get the offset from	/// \param iaxis the axis to get the offset from
	inline dReal GetWrapOffset(int iaxis=0) const {	inline dReal GetWrapOffset(int iaxis=0) const {
	return _voffsets.at(iaxis);	return _voffsets.at(iaxis);
	}	}

	inline dReal GetOffset(int iaxis=0) const RAVE_DEPRECATED {	inline dReal GetOffset(int iaxis=0) const RAVE_DEPRECATED {

	skipping to change at line 1163	skipping to change at line 1168
	/** \brief Sets the velocity of the base link and each of the joints.	/** \brief Sets the velocity of the base link and each of the joints.

	Computes internally what the correponding velocities of each of the links should be in order to	Computes internally what the correponding velocities of each of the links should be in order to
	achieve consistent results with the joint velocities. Sends the vel ocities to the physics engine.	achieve consistent results with the joint velocities. Sends the vel ocities to the physics engine.
	Velocities correspond to the link's coordinate system origin.	Velocities correspond to the link's coordinate system origin.
	\param[in] linearvel linear velocity of base link	\param[in] linearvel linear velocity of base link
	\param[in] angularvel angular velocity rotation_axis*theta_dot	\param[in] angularvel angular velocity rotation_axis*theta_dot
	\param[in] vDOFVelocities - velocities of each of the degrees of fr eeom	\param[in] vDOFVelocities - velocities of each of the degrees of fr eeom
	\param checklimits if true, will excplicitly check the joint veloci ty limits before setting the values.	\param checklimits if true, will excplicitly check the joint veloci ty limits before setting the values.
	*/	*/

	virtual void SetDOFVelocities(const std::vector<dReal>& vDOFVelocities, const Vector& linearvel, const Vector& angularvel,bool checklimits = false );	virtual void SetDOFVelocities(const std::vector<dReal>& vDOFVelocities, const Vector& linearvel, const Vector& angularvel,bool checklimits = true) ;

	/// \brief Sets the velocity of the joints.	/// \brief Sets the velocity of the joints.
	///	///
	/// Copies the current velocity of the base link and calls SetDOFVeloci ties(linearvel,angularvel,vDOFVelocities)	/// Copies the current velocity of the base link and calls SetDOFVeloci ties(linearvel,angularvel,vDOFVelocities)
	/// \param[in] vDOFVelocity - velocities of each of the degrees of free om	/// \param[in] vDOFVelocity - velocities of each of the degrees of free om
	/// \praam checklimits if true, will excplicitly check the joint veloci ty limits before setting the values.	/// \praam checklimits if true, will excplicitly check the joint veloci ty limits before setting the values.

	virtual void SetDOFVelocities(const std::vector<dReal>& vDOFVelocities, bool checklimits = false);	virtual void SetDOFVelocities(const std::vector<dReal>& vDOFVelocities, bool checklimits = true);

	/// \brief Returns the linear and angular velocities for each link	/// \brief Returns the linear and angular velocities for each link
	virtual void GetLinkVelocities(std::vector<std::pair<Vector,Vector> >& velocities) const;	virtual void GetLinkVelocities(std::vector<std::pair<Vector,Vector> >& velocities) const;

	/** \en \brief set the transform of the first link (the rest of the lin ks are computed based on the joint values).	/** \en \brief set the transform of the first link (the rest of the lin ks are computed based on the joint values).

	\param transform affine transformation	\param transform affine transformation

	\ja \brief èƒ´ä½“ã®çµ¶å¯¾å§¿å‹¢ã‚’è¨å®šã€æ®‹ã‚Šã®ãƒªãƒ³ã‚¯ã¯é ‹å‹•å¦ã®æ§‹é€ ã«å¾“ã£ã¦å¤‰æ›ã•ã‚Œã‚‹ï¼Ž	\ja \brief èƒ´ä½“ã®çµ¶å¯¾å§¿å‹¢ã‚’è¨å®šã€æ®‹ã‚Šã®ãƒªãƒ³ã‚¯ã¯é ‹å‹•å¦ã®æ§‹é€ ã«å¾“ã£ã¦å¤‰æ›ã•ã‚Œã‚‹ï¼Ž


	skipping to change at line 1214	skipping to change at line 1219
	/// \return true if changed	/// \return true if changed
	virtual bool SetVisible(bool visible);	virtual bool SetVisible(bool visible);

	/// \return true if any link of the KinBody is visible.	/// \return true if any link of the KinBody is visible.
	virtual bool IsVisible() const;	virtual bool IsVisible() const;

	/// \brief Sets the joint values of the robot.	/// \brief Sets the joint values of the robot.
	///	///
	/// \param values the values to set the joint angles (ordered by the do f indices)	/// \param values the values to set the joint angles (ordered by the do f indices)
	/// \praam checklimits if true, will excplicitly check the joint limits before setting the values.	/// \praam checklimits if true, will excplicitly check the joint limits before setting the values.

	virtual void SetDOFValues(const std::vector<dReal>& values, bool checkl imits = false);	virtual void SetDOFValues(const std::vector<dReal>& values, bool checkl imits = true);


	virtual void SetJointValues(const std::vector<dReal>& values, bool chec klimits = false) {	virtual void SetJointValues(const std::vector<dReal>& values, bool chec klimits = true) {
	SetDOFValues(values,checklimits);	SetDOFValues(values,checklimits);
	}	}

	/// \brief Sets the joint values and transformation of the body.	/// \brief Sets the joint values and transformation of the body.
	///	///
	/// \param values the values to set the joint angles (ordered by the do f indices)	/// \param values the values to set the joint angles (ordered by the do f indices)
	/// \param transform represents the transformation of the first body.	/// \param transform represents the transformation of the first body.
	/// \praam checklimits if true, will excplicitly check the joint limits before setting the values.	/// \praam checklimits if true, will excplicitly check the joint limits before setting the values.

	virtual void SetDOFValues(const std::vector<dReal>& values, const Trans form& transform, bool checklimits = false);	virtual void SetDOFValues(const std::vector<dReal>& values, const Trans form& transform, bool checklimits = true);


	virtual void SetJointValues(const std::vector<dReal>& values, const Tra nsform& transform, bool checklimits = false)	virtual void SetJointValues(const std::vector<dReal>& values, const Tra nsform& transform, bool checklimits = true)
	{	{
	SetDOFValues(values,transform,checklimits);	SetDOFValues(values,transform,checklimits);
	}	}

	/// \brief sets the transformations of all the links at once	/// \brief sets the transformations of all the links at once
	virtual void SetLinkTransformations(const std::vector<Transform>& trans forms);	virtual void SetLinkTransformations(const std::vector<Transform>& trans forms);

	/// \brief sets the transformations of all the links and dof branches a t once.	/// \brief sets the transformations of all the links and dof branches a t once.
	///	///
	/// Using dof branches allows the full joint state to be recovered	/// Using dof branches allows the full joint state to be recovered

	skipping to change at line 1400	skipping to change at line 1405
	virtual const ConfigurationSpecification& GetConfigurationSpecification () const;	virtual const ConfigurationSpecification& GetConfigurationSpecification () const;

	/// \brief return the configuration specification of the specified join t indices.	/// \brief return the configuration specification of the specified join t indices.
	///	///
	/// Note that the return type is by-value, so should not be used in ite ration	/// Note that the return type is by-value, so should not be used in ite ration
	virtual ConfigurationSpecification GetConfigurationSpecificationIndices (const std::vector<int>& indices) const;	virtual ConfigurationSpecification GetConfigurationSpecificationIndices (const std::vector<int>& indices) const;

	/// \brief sets joint values and transform of the body using configurat ion values as specified by \ref GetConfigurationSpecification()	/// \brief sets joint values and transform of the body using configurat ion values as specified by \ref GetConfigurationSpecification()
	///	///
	/// \param itvalues the iterator to the vector containing the dof value s. Must have GetConfigurationSpecification().GetDOF() values!	/// \param itvalues the iterator to the vector containing the dof value s. Must have GetConfigurationSpecification().GetDOF() values!

	virtual void SetConfigurationValues(std::vector<dReal>::const_iterator itvalues, bool checklimits = false);	virtual void SetConfigurationValues(std::vector<dReal>::const_iterator itvalues, bool checklimits = true);

	/// \brief returns the configuration values as specified by \ref GetCon figurationSpecification()	/// \brief returns the configuration values as specified by \ref GetCon figurationSpecification()
	virtual void GetConfigurationValues(std::vector<dReal>& v) const;	virtual void GetConfigurationValues(std::vector<dReal>& v) const;

	//@}	//@}

	protected:	protected:
	/// \brief constructors declared protected so that user always goes thr ough environment to create bodies	/// \brief constructors declared protected so that user always goes thr ough environment to create bodies
	KinBody(InterfaceType type, EnvironmentBasePtr penv);	KinBody(InterfaceType type, EnvironmentBasePtr penv);
	inline KinBodyPtr shared_kinbody() {	inline KinBodyPtr shared_kinbody() {

End of changes. 8 change blocks.
	7 lines changed or deleted	15 lines changed or added

	openrave.h	openrave.h

	skipping to change at line 890	skipping to change at line 890
	BaseXMLReaderPtr _preader;	BaseXMLReaderPtr _preader;
	};	};

	virtual ~ConfigurationSpecification() {	virtual ~ConfigurationSpecification() {
	}	}

	/// \brief return the dimension of the configuraiton space (degrees of freedom)	/// \brief return the dimension of the configuraiton space (degrees of freedom)
	virtual int GetDOF() const;	virtual int GetDOF() const;

	/// \brief check if the groups form a continguous space	/// \brief check if the groups form a continguous space

		///
		/// If there are two or more groups with the same semantic names, will
		fail. Theese groups should be merged into one.
	virtual bool IsValid() const;	virtual bool IsValid() const;

	virtual bool operator==(const ConfigurationSpecification& r) const;	virtual bool operator==(const ConfigurationSpecification& r) const;
	virtual bool operator!=(const ConfigurationSpecification& r) const;	virtual bool operator!=(const ConfigurationSpecification& r) const;

	/// \brief return the group whose name begins with a particular string.	/// \brief return the group whose name begins with a particular string.
	///	///
	/// If multiple groups exist that begin with the same string, then the shortest one is returned.	/// If multiple groups exist that begin with the same string, then the shortest one is returned.
	/// \throw openrave_exception if a group is not found	/// \throw openrave_exception if a group is not found
	virtual const Group& GetGroupFromName(const std::string& name) const;	virtual const Group& GetGroupFromName(const std::string& name) const;

	skipping to change at line 942	skipping to change at line 944
	For example given a 'joint_values' group, this will return the clos est 'joint_velocities' group.	For example given a 'joint_values' group, this will return the clos est 'joint_velocities' group.
	\param name the name of the group to query	\param name the name of the group to query
	\param exactmatch if true, will only return groups whose name exact ly matches with g.name	\param exactmatch if true, will only return groups whose name exact ly matches with g.name
	\return an iterator part of _vgroups that represents the most compa tible group. If no group is found, will return _vgroups.end()	\return an iterator part of _vgroups that represents the most compa tible group. If no group is found, will return _vgroups.end()
	*/	*/
	virtual std::vector<Group>::const_iterator FindTimeDerivativeGroup(cons t std::string& name, bool exactmatch=false) const;	virtual std::vector<Group>::const_iterator FindTimeDerivativeGroup(cons t std::string& name, bool exactmatch=false) const;

	/** \brief adds a velocity group for every position group.	/** \brief adds a velocity group for every position group.

	If velocities groups already exist, they are checked for and/or mod ified. Note that the configuration space	If velocities groups already exist, they are checked for and/or mod ified. Note that the configuration space

	might be re-ordered as a result of this function call.	might be re-ordered as a result of this function call. If a new gro
		up is added, its interpolation will be
		the derivative of the position group as returned by \ref GetInterpo
		lationDerivative.
	\param adddeltatime If true will add the 'deltatime' tag, which is necessary for trajectory sampling	\param adddeltatime If true will add the 'deltatime' tag, which is necessary for trajectory sampling
	*/	*/
	virtual void AddVelocityGroups(bool adddeltatime);	virtual void AddVelocityGroups(bool adddeltatime);


	/// \brief converts all the groups to the corresponding velocity groups	/** \brief converts all the groups to the corresponding velocity groups
	and returns the specification	and returns the specification
	///
	/// The velocity configuration space will have a one-to-one corresponde	The velocity configuration space will have a one-to-one corresponde
	nce with the	nce with the original configuration.
		The interpolation of each of the groups will correspondingly repres
		ent the derivative as returned by \ref GetInterpolationDerivative.
		*/
	virtual ConfigurationSpecification ConvertToVelocitySpecification() con st;	virtual ConfigurationSpecification ConvertToVelocitySpecification() con st;

	/// \brief returns a new specification of just particular time-derivati ve groups.	/// \brief returns a new specification of just particular time-derivati ve groups.
	///	///
	/// \param timederivative the time derivative to query groups from. 0 i s positions/joint values, 1 is velocities, 2 is accelerations, etc	/// \param timederivative the time derivative to query groups from. 0 i s positions/joint values, 1 is velocities, 2 is accelerations, etc
	virtual ConfigurationSpecification GetTimeDerivativeSpecification(int t imederivative) const;	virtual ConfigurationSpecification GetTimeDerivativeSpecification(int t imederivative) const;

	/** \brief set the offsets of each group in order to get a contiguous c onfiguration space	/** \brief set the offsets of each group in order to get a contiguous c onfiguration space
	*/	*/
	virtual void ResetGroupOffsets();	virtual void ResetGroupOffsets();

	/// \brief adds the deltatime tag to the end if one doesn't exist and r eturns the index into the configuration space	/// \brief adds the deltatime tag to the end if one doesn't exist and r eturns the index into the configuration space
	virtual int AddDeltaTimeGroup();	virtual int AddDeltaTimeGroup();


	/// \brief adds a new group to the specification and returns its new of	/** \brief Adds a new group to the specification and returns its new of
	fset.	fset.
	///
	/// If the new group's semantic name exists in the current specificatio	If the new group's semantic name does not exist in the current spec
	n and it exactly matches, then succeeds. If the match	ification, adds it and returns the new offset.
	/// isn't exact, then an openrave_exception is throw.	If the new group's semantic name exists in the current specificatio
		n and it exactly matches, then function returns the old group's index. If t
		he semantic names match, but parameters do not match, then an openrave_exce
		ption is thrown.
		This method is not responsible for merging semantic information
		*/
	virtual int AddGroup(const std::string& name, int dof, const std::strin g& interpolation = "");	virtual int AddGroup(const std::string& name, int dof, const std::strin g& interpolation = "");


	/// \brief merges all the information from the input group into this gr	/** \brief Merges all the information from the input group into this gr
	oup	oup
	///
	/// For groups that are merged, the interpolation method is not changed	For groups that are merged, the interpolation is overwritten if the
	.	source group has an empty string.
	/// \throw openrave_exception throws if groups do not contain enough in	\throw openrave_exception throws if groups do not contain enough in
	formation to be merged	formation to be merged or interpolations do not match.
		*/
	virtual ConfigurationSpecification& operator+= (const ConfigurationSpec ification& r);	virtual ConfigurationSpecification& operator+= (const ConfigurationSpec ification& r);


	/// \brief return a new specification that holds the merged information	/** \brief Return a new specification that holds the merged information
	from the current and input specification and the input parameter..	from the current and input specification and the input parameter..
	///
	/// For groups that are merged, the interpolation method is not changed	For groups that are merged, the interpolation either has to match f
	.	or both groups, or one of the groups needs an empty interpolation.
	/// \throw openrave_exception throws if groups do not contain enough in	\throw openrave_exception throws if groups do not contain enough in
	formation to be merged	formation to be merged or interpolations do not match.
		*/
	virtual ConfigurationSpecification operator+ (const ConfigurationSpecif ication& r) const;	virtual ConfigurationSpecification operator+ (const ConfigurationSpecif ication& r) const;

	/** \brief extracts an affine transform given the start of a configurat ion space point	/** \brief extracts an affine transform given the start of a configurat ion space point

	Looks for 'affine_transform' groups. If pbody is not initialized, w ill choose the first affine_transform found.	Looks for 'affine_transform' groups. If pbody is not initialized, w ill choose the first affine_transform found.
	\param[inout] t the transform holding the default values, which wil l be overwritten with the new values.	\param[inout] t the transform holding the default values, which wil l be overwritten with the new values.
	\param[in] itdata data in the format of this configuration specific ation.	\param[in] itdata data in the format of this configuration specific ation.
	\return true if at least one group was found for extracting	\return true if at least one group was found for extracting
	*/	*/
	virtual bool ExtractTransform(Transform& t, std::vector<dReal>::const_i terator itdata, KinBodyConstPtr pbody) const;	virtual bool ExtractTransform(Transform& t, std::vector<dReal>::const_i terator itdata, KinBodyConstPtr pbody) const;

	skipping to change at line 1044	skipping to change at line 1053
	\return true if at least one group was found for inserting	\return true if at least one group was found for inserting
	*/	*/
	virtual bool InsertJointValues(std::vector<dReal>::iterator itdata, std ::vector<dReal>::const_iterator itvalues, KinBodyConstPtr pbody, const std: :vector<int>& indices, int timederivative=0) const;	virtual bool InsertJointValues(std::vector<dReal>::iterator itdata, std ::vector<dReal>::const_iterator itvalues, KinBodyConstPtr pbody, const std: :vector<int>& indices, int timederivative=0) const;

	/** \brief sets the deltatime field of the data if one exists	/** \brief sets the deltatime field of the data if one exists

	\param[inout] itdata data in the format of this configuration speci fication.	\param[inout] itdata data in the format of this configuration speci fication.
	\param[in] deltatime the delta time of the time stamp (from previou s point)	\param[in] deltatime the delta time of the time stamp (from previou s point)
	\return true if at least one group was found for inserting	\return true if at least one group was found for inserting
	*/	*/

	virtual bool InsertDeltaTime(std::vector<dReal>::iterator itdata, dReal deltatime);	virtual bool InsertDeltaTime(std::vector<dReal>::iterator itdata, dReal deltatime) const;

	/** \brief given two compatible groups, convers data represented in the source group to data represented in the target group	/** \brief given two compatible groups, convers data represented in the source group to data represented in the target group

	\param ittargetdata iterator pointing to start of target group data that should be overwritten	\param ittargetdata iterator pointing to start of target group data that should be overwritten
	\param targetstride the number of elements that to go from the next target point. Necessary if numpoints > 1.	\param targetstride the number of elements that to go from the next target point. Necessary if numpoints > 1.
	\param gtarget the target configuration group	\param gtarget the target configuration group
	\param itsourcedata iterator pointing to start of source group data that should be read	\param itsourcedata iterator pointing to start of source group data that should be read
	\param sourcestride the number of elements that to go from the next source point. Necessary if numpoints > 1.	\param sourcestride the number of elements that to go from the next source point. Necessary if numpoints > 1.
	\param gsource the source configuration group	\param gsource the source configuration group
	\param numpoints the number of points to convert. The target and so urce strides are gtarget.dof and gsource.dof	\param numpoints the number of points to convert. The target and so urce strides are gtarget.dof and gsource.dof

	skipping to change at line 1073	skipping to change at line 1082
	\param ittargetdata iterator pointing to start of target group data that should be overwritten	\param ittargetdata iterator pointing to start of target group data that should be overwritten
	\param targetspec the target configuration specification	\param targetspec the target configuration specification
	\param itsourcedata iterator pointing to start of source group data that should be read	\param itsourcedata iterator pointing to start of source group data that should be read
	\param sourcespec the source configuration specification	\param sourcespec the source configuration specification
	\param numpoints the number of points to convert. The target and so urce strides are gtarget.dof and gsource.dof	\param numpoints the number of points to convert. The target and so urce strides are gtarget.dof and gsource.dof
	\param penv [optional] The environment which might be needed to fil l in unknown data. Assumes environment is locked.	\param penv [optional] The environment which might be needed to fil l in unknown data. Assumes environment is locked.
	\param filluninitialized If there exists target groups that cannot be initialized, then will set default values using the current environment. For example, the current joint values of the body will be used.	\param filluninitialized If there exists target groups that cannot be initialized, then will set default values using the current environment. For example, the current joint values of the body will be used.
	*/	*/
	static void ConvertData(std::vector<dReal>::iterator ittargetdata, cons t ConfigurationSpecification& targetspec, std::vector<dReal>::const_iterato r itsourcedata, const ConfigurationSpecification& sourcespec, size_t numpoi nts, EnvironmentBaseConstPtr penv, bool filluninitialized = true);	static void ConvertData(std::vector<dReal>::iterator ittargetdata, cons t ConfigurationSpecification& targetspec, std::vector<dReal>::const_iterato r itsourcedata, const ConfigurationSpecification& sourcespec, size_t numpoi nts, EnvironmentBaseConstPtr penv, bool filluninitialized = true);


		/// \brief gets the name of the interpolation that represents the deriv
		ative of the passed in interpolation.
		///
		/// For example GetInterpolationDerivative("quadratic") -> "linear"
		static std::string GetInterpolationDerivative(const std::string& interp
		olation);

	std::vector<Group> _vgroups;	std::vector<Group> _vgroups;
	};	};

	OPENRAVE_API std::ostream& operator<<(std::ostream& O, const ConfigurationS pecification &spec);	OPENRAVE_API std::ostream& operator<<(std::ostream& O, const ConfigurationS pecification &spec);
	OPENRAVE_API std::istream& operator>>(std::istream& I, ConfigurationSpecifi cation& spec);	OPENRAVE_API std::istream& operator>>(std::istream& I, ConfigurationSpecifi cation& spec);

	typedef boost::shared_ptr<ConfigurationSpecification> ConfigurationSpecific ationPtr;	typedef boost::shared_ptr<ConfigurationSpecification> ConfigurationSpecific ationPtr;
	typedef boost::shared_ptr<ConfigurationSpecification const> ConfigurationSp ecificationConstPtr;	typedef boost::shared_ptr<ConfigurationSpecification const> ConfigurationSp ecificationConstPtr;

	/** \brief Parameterization of basic primitives for querying inverse-kinema tics solutions.	/** \brief Parameterization of basic primitives for querying inverse-kinema tics solutions.

End of changes. 8 change blocks.
	27 lines changed or deleted	50 lines changed or added

	planner.h	planner.h

	skipping to change at line 186	skipping to change at line 186

	An explicit difference function is necessary for correct interp olation when there are circular joints.	An explicit difference function is necessary for correct interp olation when there are circular joints.
	Default is regular subtraction.	Default is regular subtraction.
	*/	*/
	typedef boost::function<void (std::vector<dReal>&,const std::vector <dReal>&)> DiffStateFn;	typedef boost::function<void (std::vector<dReal>&,const std::vector <dReal>&)> DiffStateFn;
	DiffStateFn _diffstatefn;	DiffStateFn _diffstatefn;

	/** \brief Adds a delta state to a curent state, acting like a next -nearest-neighbor function along a given direction.	/** \brief Adds a delta state to a curent state, acting like a next -nearest-neighbor function along a given direction.

	success = _neighstatefn(q,qdelta,fromgoal) -> q = Filter(q+qdel ta)	success = _neighstatefn(q,qdelta,fromgoal) -> q = Filter(q+qdel ta)

	\param q the current state	\param q the current state. In order to save computation, assum es this state is the currently set configuration.
	\param qdelta the delta to add	\param qdelta the delta to add
	\param fromgoal 1 if q is coming from a goal state, 0 if it is coming from an initial state	\param fromgoal 1 if q is coming from a goal state, 0 if it is coming from an initial state

	In RRTs this is used for the extension operation. The new state is stored in the first parameter q.	In RRTs this is used for the extension operation. The new state is stored in the first parameter q.
	Note that the function can also add a filter to the final desti nation (like projecting onto a constraint manifold).	Note that the function can also add a filter to the final desti nation (like projecting onto a constraint manifold).
	*/	*/
	typedef boost::function<bool (std::vector<dReal>&,const std::vector <dReal>&, int)> NeighStateFn;	typedef boost::function<bool (std::vector<dReal>&,const std::vector <dReal>&, int)> NeighStateFn;
	NeighStateFn _neighstatefn;	NeighStateFn _neighstatefn;

	/// to specify multiple initial or goal configurations, put them in to the vector in series	/// to specify multiple initial or goal configurations, put them in to the vector in series

End of changes. 1 change blocks.
	1 lines changed or deleted	1 lines changed or added

	robot.h	robot.h

	skipping to change at line 392	skipping to change at line 392

	/// \brief Returns the manipulators of the robot	/// \brief Returns the manipulators of the robot
	virtual std::vector<ManipulatorPtr>& GetManipulators() {	virtual std::vector<ManipulatorPtr>& GetManipulators() {
	return _vecManipulators;	return _vecManipulators;
	}	}

	virtual std::vector<AttachedSensorPtr>& GetAttachedSensors() {	virtual std::vector<AttachedSensorPtr>& GetAttachedSensors() {
	return _vecSensors;	return _vecSensors;
	}	}


	virtual void SetDOFValues(const std::vector<dReal>& vJointValues, bool	virtual void SetDOFValues(const std::vector<dReal>& vJointValues, bool
	bCheckLimits = false);	checklimits = true);
	virtual void SetDOFValues(const std::vector<dReal>& vJointValues, const	virtual void SetDOFValues(const std::vector<dReal>& vJointValues, const
	Transform& transbase, bool bCheckLimits = false);	Transform& transbase, bool checklimits = true);

	virtual void SetLinkTransformations(const std::vector<Transform>& trans forms);	virtual void SetLinkTransformations(const std::vector<Transform>& trans forms);
	virtual void SetLinkTransformations(const std::vector<Transform>& trans forms, const std::vector<int>& dofbranches);	virtual void SetLinkTransformations(const std::vector<Transform>& trans forms, const std::vector<int>& dofbranches);

	/// Transforms the robot and updates the attached sensors and grabbed b odies.	/// Transforms the robot and updates the attached sensors and grabbed b odies.
	virtual void SetTransform(const Transform& trans);	virtual void SetTransform(const Transform& trans);

	/** Methods using the active degrees of freedoms of the robot. Active D OFs are a way for the	/** Methods using the active degrees of freedoms of the robot. Active D OFs are a way for the
	user to specify degrees of freedom of interest for a current execut ion block. All planners	user to specify degrees of freedom of interest for a current execut ion block. All planners
	by default use the robot's active DOF and active manipultor. For ev ery Get* method, there is	by default use the robot's active DOF and active manipultor. For ev ery Get* method, there is

	skipping to change at line 526	skipping to change at line 526
	virtual Vector GetAffineRotationAxisWeights() const {	virtual Vector GetAffineRotationAxisWeights() const {
	return _vRotationAxisWeights;	return _vRotationAxisWeights;
	}	}
	virtual Vector GetAffineRotation3DWeights() const {	virtual Vector GetAffineRotation3DWeights() const {
	return _vRotation3DWeights;	return _vRotation3DWeights;
	}	}
	virtual dReal GetAffineRotationQuatWeights() const {	virtual dReal GetAffineRotationQuatWeights() const {
	return _fQuatAngleResolution;	return _fQuatAngleResolution;
	}	}


	virtual void SetActiveDOFValues(const std::vector<dReal>& values, bool bCheckLimits=false);	virtual void SetActiveDOFValues(const std::vector<dReal>& values, bool checklimits=true);
	virtual void GetActiveDOFValues(std::vector<dReal>& v) const;	virtual void GetActiveDOFValues(std::vector<dReal>& v) const;

	virtual void SetActiveDOFVelocities(const std::vector<dReal>& velocitie s, bool bCheckLimits=false);	virtual void SetActiveDOFVelocities(const std::vector<dReal>& velocitie s, bool checklimits=true);
	virtual void GetActiveDOFVelocities(std::vector<dReal>& velocities) con st;	virtual void GetActiveDOFVelocities(std::vector<dReal>& velocities) con st;
	virtual void GetActiveDOFLimits(std::vector<dReal>& lower, std::vector< dReal>& upper) const;	virtual void GetActiveDOFLimits(std::vector<dReal>& lower, std::vector< dReal>& upper) const;
	virtual void GetActiveDOFResolutions(std::vector<dReal>& v) const;	virtual void GetActiveDOFResolutions(std::vector<dReal>& v) const;
	virtual void GetActiveDOFWeights(std::vector<dReal>& v) const;	virtual void GetActiveDOFWeights(std::vector<dReal>& v) const;
	virtual void GetActiveDOFVelocityLimits(std::vector<dReal>& v) const;	virtual void GetActiveDOFVelocityLimits(std::vector<dReal>& v) const;
	virtual void GetActiveDOFAccelerationLimits(std::vector<dReal>& v) cons t;	virtual void GetActiveDOFAccelerationLimits(std::vector<dReal>& v) cons t;
	virtual void GetActiveDOFMaxVel(std::vector<dReal>& v) const {	virtual void GetActiveDOFMaxVel(std::vector<dReal>& v) const {
	return GetActiveDOFVelocityLimits(v);	return GetActiveDOFVelocityLimits(v);
	}	}
	virtual void GetActiveDOFMaxAccel(std::vector<dReal>& v) const {	virtual void GetActiveDOFMaxAccel(std::vector<dReal>& v) const {

End of changes. 3 change blocks.
	6 lines changed or deleted	6 lines changed or added