Inheritance diagram for manipulation.problem_solver.ProblemSolver:

Collaboration diagram for manipulation.problem_solver.ProblemSolver:

Public Member Functions
def	__init__ (self, robot)

def	selectProblem (self, name)

def	getAvailable (self, type)

def	getSelected (self, type)

def	getEnvironmentContactNames (self)

def	getRobotContactNames (self)

def	getEnvironmentContact (self, name)

def	getRobotContact (self, name)

def	createPlacementConstraints (self, placementName, shapeName, envContactName, width=0.05)

def	createQPStabilityConstraint (self, *args)

def	registerConstraints (self, *args)

def	balanceConstraints (self)

def	getConstantRightHandSide (self, constraintName)

def	lockFreeFlyerJoint (self, freeflyerBname, lockJointBname, values=(0, 0, 0, 0, 0, 0, 1))

def	lockPlanarJoint (self, jointName, lockJointName, values=(0, 0, 1, 0))

def	setTargetState (self, stateId)

Detailed Description

Definition of a manipulation planning problem

This class wraps the Corba client to the server implemented by
libhpp-manipulation-corba.so

Some method implemented by the server can be considered as private. The
goal of this class is to hide them and to expose those that can be
considered as public.

Constructor & Destructor Documentation

◆ init()

def manipulation.problem_solver.ProblemSolver.__init__	(	self,
		robot
	)

Member Function Documentation

◆ balanceConstraints()

def manipulation.problem_solver.ProblemSolver.balanceConstraints ( self )

Return balance constraints created by method
ProblemSolver.createStaticStabilityConstraints

◆ createPlacementConstraints()

def manipulation.problem_solver.ProblemSolver.createPlacementConstraints	(	self,
		placementName,
		shapeName,
		envContactName,
		width = `0.05`
	)

Create placement and pre-placement constraints

\\param width set to None to skip creation of pre-placement constraint
\\return names of the placement and preplacement constraints

See hpp::corbaserver::manipulation::Problem::createPlacementConstraint
and hpp::corbaserver::manipulation::Problem::createPrePlacementConstraint

◆ createQPStabilityConstraint()

def manipulation.problem_solver.ProblemSolver.createQPStabilityConstraint	(		self,
		*	args
	)

Create QP Static stability constraint

 \\copydoc hpp::corbaserver::manipulation::Problem::createQPStabilityConstraint

◆ getAvailable()

def manipulation.problem_solver.ProblemSolver.getAvailable	(	self,
		type
	)

Return a list of available elements of type type
\\param type enter "type" to know what types I know of.
            This is case insensitive.

◆ getConstantRightHandSide()

def manipulation.problem_solver.ProblemSolver.getConstantRightHandSide	(	self,
		constraintName
	)

Get whether right hand side of a numerical constraint is constant
 \\param constraintName Name of the numerical constraint,
 \\return whether right hand side is constant

◆ getEnvironmentContact()

def manipulation.problem_solver.ProblemSolver.getEnvironmentContact	(	self,
		name
	)

\\copydoc hpp::corbaserver::manipulation::Problem::getEnvironmentContact

◆ getEnvironmentContactNames()

def manipulation.problem_solver.ProblemSolver.getEnvironmentContactNames ( self )

\\copydoc hpp::corbaserver::manipulation::Problem::getEnvironmentContactNames

◆ getRobotContact()

def manipulation.problem_solver.ProblemSolver.getRobotContact	(	self,
		name
	)

\\copydoc hpp::corbaserver::manipulation::Problem::getRobotContact

◆ getRobotContactNames()

def manipulation.problem_solver.ProblemSolver.getRobotContactNames ( self )

\\copydoc hpp::corbaserver::manipulation::Problem::getRobotContactNames

◆ getSelected()

def manipulation.problem_solver.ProblemSolver.getSelected	(	self,
		type
	)

Return a list of selected elements of type type
\\param type enter "type" to know what types I know of.
            This is case insensitive.
\\note For most of the types, the list will contain only one element.

◆ lockFreeFlyerJoint()

def manipulation.problem_solver.ProblemSolver.lockFreeFlyerJoint	(	self,
		freeflyerBname,
		lockJointBname,
		values = `(0, 0, 0, 0, 0, 0, 1)`
	)

Lock degree of freedom of a FreeFlyer joint
\\param freeflyerBname base name of the joint
       (It will be completed by '_xyz' and '_SO3'),
\\param lockJointBname base name of the LockedJoint constraints
       (It will be completed by '_xyz' and '_SO3'),
\\param values config of the locked joints (7 float)

◆ lockPlanarJoint()

def manipulation.problem_solver.ProblemSolver.lockPlanarJoint	(	self,
		jointName,
		lockJointName,
		values = `(0, 0, 1, 0)`
	)

Lock degree of freedom of a planar joint
\\param jointName name of the joint
       (It will be completed by '_xy' and '_rz'),
\\param lockJointName name of the LockedJoint constraint
\\param values config of the locked joints (4 float)

◆ registerConstraints()

def manipulation.problem_solver.ProblemSolver.registerConstraints	(		self,
		*	args
	)

\\copydoc hpp::corbaserver::manipulation::Problem::registerConstraints

◆ selectProblem()

def manipulation.problem_solver.ProblemSolver.selectProblem	(	self,
		name
	)

Select a problem by its name.
If no problem with this name exists, a new
hpp::manipulation::ProblemSolver is created and selected.
\\param name the problem name.
\\return true if a new problem was created.

◆ setTargetState()

def manipulation.problem_solver.ProblemSolver.setTargetState	(	self,
		stateId
	)

Set the problem target to stateId
The planner will look for a path from the init configuration to a configuration
in state stateId

The documentation for this class was generated from the following file:

src/hpp/corbaserver/manipulation/problem_solver.py

Public Member Functions