hpp-corbaserver: hpp.corbaserver.problem_solver.ProblemSolver Class Reference

hpp-corbaserver 9.0.2 Corba server for Humanoid Path Planner applications

Public Member Functions | Public Attributes | List of all members
hpp.corbaserver.problem_solver.ProblemSolver Class Reference

## Public Member Functions
def | __init__ (self, robot, hppcorbaClient=None)
def | loadPlugin (self, pluginName)
def | setRandomSeed (self, seed)
def | setMaxNumThreads (self, n)
def | getMaxNumThreads (self)
def | getAvailable (self, type)
def | getSelected (self, type)
def | setParameter (self, name, value)
def | getParameter (self, name, keep_any=False)
def | getParameterDoc (self, name)
def | selectProblem (self, name)
def | movePathToProblem (self, pathId, problemName, jointNames)
def | setInitialConfig (self, dofArray)
def | getInitialConfig (self)
def | addGoalConfig (self, dofArray)
def | setGoalConstraints (self, constraints)
def | resetGoalConstraints (self)
def | getGoalConfigs (self)
def | resetGoalConfigs (self)
def | loadObstacleFromUrdf (self, *args)
def | removeObstacleFromJoint (self, objectName, jointName, collision, distance)
def | cutObstacle (self, objectName, aabb)
def | moveObstacle (self, objectName, cfg)
def | getObstaclePosition (self, objectName)
def | getObstacleNames (self, collision, distance)
def | getObstacleLinkPosition (self, objectName)
def | getObstacleLinkNames (self)
def | createOrientationConstraint (self, constraintName, joint1Name, joint2Name, p, mask)
def | createTransformationConstraint (self, constraintName, joint1Name, joint2Name, ref, mask)
def | createLockedJoint (self, lockedDofName, jointName, value, comp=None)
def | createLockedExtraDof (self, lockedDofName, index, value)
def | createRelativeComConstraint (self, constraintName, comName, jointLName, point, mask)
def | createComBeetweenFeet (self, constraintName, comName, jointLName, jointRName, pointL, pointR, jointRefName, mask)
def | addPartialCom (self, comName, jointNames)
def | getPartialCom (self, comName)
def | createPositionConstraint (self, constraintName, joint1Name, joint2Name, point1, point2, mask)
def | createDistanceBetweenJointConstraint (self, constraintName, joint1Name, joint2Name, distance)
def | createDistanceBetweenJointAndObjects (self, constraintName, joint1Name, objects, distance)
def | resetConstraints (self)
def | resetConstraintMap (self)
def | addNumericalConstraints (self, name, names, priorities=None)
def | addLockedJointConstraints (self, name, names)
def | setRightHandSide (self, rhs)
def | setRightHandSideByName (self, constraintName, rhs)
def | setRightHandSideFromConfig (self, config)
def | setRightHandSideFromConfigByName (self, constraintName, config)
def | applyConstraints (self, q)
def | optimize (self, q)
def | computeValueAndJacobian (self, q)
def | addPassiveDofs (self, name, dofNames)
def | setConstantRightHandSide (self, constraintName, constant)
def | getConstantRightHandSide (self, constraintName)
def | generateValidConfig (self, maxIter)
def | getErrorThreshold (self)
def | setErrorThreshold (self, threshold)
def | setDefaultLineSearchType (self, type)
def | getMaxIterPathPlanning (self)
def | setMaxIterPathPlanning (self, iterations)
def | getTimeOutPathPlanning (self)
def | setTimeOutPathPlanning (self, timeOut)
def | getMaxIterProjection (self)
def | setMaxIterProjection (self, iterations)
def | filterCollisionPairs (self)
def | selectPathPlanner (self, pathPlannerType)
def | selectConfigurationShooter (self, configurationShooterType)
def | addPathOptimizer (self, pathOptimizerType)
def | clearPathOptimizers (self)
def | selectPathValidation (self, pathValidationType, tolerance)
def | addConfigValidation (self, configValidationType)
def | clearConfigValidations (self)
def | selectPathProjector (self, pathProjectorType, tolerance)
def | selectDistance (self, distanceType)
def | selectSteeringMethod (self, steeringMethodType)
def | prepareSolveStepByStep (self)
def | executeOneStep (self)
def | finishSolveStepByStep (self)
def | solve (self)
def | directPath (self, startConfig, endConfig, validate)
def | appendDirectPath (self, pathId, config, validate)
def | concatenatePath (self, startId, endId)
def | extractPath (self, pathId, start, end)
def | erasePath (self, pathId)
def | projectPath (self, pathId)
def | numberPaths (self)
def | optimizePath (self, inPathId)
def | pathLength (self, inPathId)
def | configAtParam (self, inPathId, param)
def | derivativeAtParam (self, inPathId, order, param)
def | getWaypoints (self, pathId)
def | interruptPathPlanning (self)
def | nodes (self)
def | node (self, nodeId)
def | numberNodes (self)
def | numberEdges (self)
def | edge (self, edgeId)
def | numberConnectedComponents (self)
def | nodesConnectedComponent (self, ccId)
def | getNearestConfig (self, randomConfig, connectedComponentId=-1)
def | addConfigToRoadmap (self, config)
def | addEdgeToRoadmap (self, config1, config2, pathId, bothEdges)
def | clearRoadmap (self)
def | saveRoadmap (self, filename)
def | loadRoadmap (self, filename)

## Public Attributes
| client
| hppcorba
| robot

## Constructor & Destructor Documentation

## ◆ __init__()

def hpp.corbaserver.problem_solver.ProblemSolver.__init__ | ( |  | self,
|  |  | robot,
|  |  | hppcorbaClient = `None`
| ) |  |

## Member Function Documentation

## ◆ addConfigToRoadmap()

def hpp.corbaserver.problem_solver.ProblemSolver.addConfigToRoadmap | ( |  | self,
|  |  | config
| ) |  |

## ◆ addConfigValidation()

def hpp.corbaserver.problem_solver.ProblemSolver.addConfigValidation | ( |  | self,
|  |  | configValidationType
| ) |  |

## ◆ addEdgeToRoadmap()

def hpp.corbaserver.problem_solver.ProblemSolver.addEdgeToRoadmap | ( |  | self,
|  |  | config1,
|  |  | config2,
|  |  | pathId,
|  |  | bothEdges
| ) |  |

## ◆ addGoalConfig()

def hpp.corbaserver.problem_solver.ProblemSolver.addGoalConfig | ( |  | self,
|  |  | dofArray
| ) |  |

## ◆ addLockedJointConstraints()

def hpp.corbaserver.problem_solver.ProblemSolver.addLockedJointConstraints | ( |  | self,
|  |  | name,
|  |  | names
| ) |  |

## ◆ addNumericalConstraints()

def hpp.corbaserver.problem_solver.ProblemSolver.addNumericalConstraints | ( |  | self,
|  |  | name,
|  |  | names,
|  |  | priorities = `None`
| ) |  |

## ◆ addPartialCom()

def hpp.corbaserver.problem_solver.ProblemSolver.addPartialCom | ( |  | self,
|  |  | comName,
|  |  | jointNames
| ) |  |

## ◆ addPassiveDofs()

def hpp.corbaserver.problem_solver.ProblemSolver.addPassiveDofs | ( |  | self,
|  |  | name,
|  |  | dofNames
| ) |  |

## ◆ addPathOptimizer()

def hpp.corbaserver.problem_solver.ProblemSolver.addPathOptimizer | ( |  | self,
|  |  | pathOptimizerType
| ) |  |

## ◆ appendDirectPath()

def hpp.corbaserver.problem_solver.ProblemSolver.appendDirectPath | ( |  | self,
|  |  | pathId,
|  |  | config,
|  |  | validate
| ) |  |

## ◆ applyConstraints()

def hpp.corbaserver.problem_solver.ProblemSolver.applyConstraints | ( |  | self,
|  |  | q
| ) |  |

## ◆ clearConfigValidations()

def hpp.corbaserver.problem_solver.ProblemSolver.clearConfigValidations | ( |  | self | ) |

## ◆ clearPathOptimizers()

def hpp.corbaserver.problem_solver.ProblemSolver.clearPathOptimizers | ( |  | self | ) |

## ◆ clearRoadmap()

def hpp.corbaserver.problem_solver.ProblemSolver.clearRoadmap | ( |  | self | ) |

## ◆ computeValueAndJacobian()

def hpp.corbaserver.problem_solver.ProblemSolver.computeValueAndJacobian | ( |  | self,
|  |  | q
| ) |  |

## ◆ concatenatePath()

def hpp.corbaserver.problem_solver.ProblemSolver.concatenatePath | ( |  | self,
|  |  | startId,
|  |  | endId
| ) |  |

## ◆ configAtParam()

def hpp.corbaserver.problem_solver.ProblemSolver.configAtParam | ( |  | self,
|  |  | inPathId,
|  |  | param
| ) |  |

## ◆ createComBeetweenFeet()

def hpp.corbaserver.problem_solver.ProblemSolver.createComBeetweenFeet | ( |  | self,
|  |  | constraintName,
|  |  | comName,
|  |  | jointLName,
|  |  | jointRName,
|  |  | pointL,
|  |  | pointR,
|  |  | jointRefName,
|  |  | mask
| ) |  |

## ◆ createDistanceBetweenJointAndObjects()

def hpp.corbaserver.problem_solver.ProblemSolver.createDistanceBetweenJointAndObjects | ( |  | self,
|  |  | constraintName,
|  |  | joint1Name,
|  |  | objects,
|  |  | distance
| ) |  |

## ◆ createDistanceBetweenJointConstraint()

def hpp.corbaserver.problem_solver.ProblemSolver.createDistanceBetweenJointConstraint | ( |  | self,
|  |  | constraintName,
|  |  | joint1Name,
|  |  | joint2Name,
|  |  | distance
| ) |  |

## ◆ createLockedExtraDof()

def hpp.corbaserver.problem_solver.ProblemSolver.createLockedExtraDof | ( |  | self,
|  |  | lockedDofName,
|  |  | index,
|  |  | value
| ) |  |

## ◆ createLockedJoint()

def hpp.corbaserver.problem_solver.ProblemSolver.createLockedJoint | ( |  | self,
|  |  | lockedDofName,
|  |  | jointName,
|  |  | value,
|  |  | comp = `None`
| ) |  |

## ◆ createOrientationConstraint()

def hpp.corbaserver.problem_solver.ProblemSolver.createOrientationConstraint | ( |  | self,
|  |  | constraintName,
|  |  | joint1Name,
|  |  | joint2Name,
|  |  | p,
|  |  | mask
| ) |  |

## ◆ createPositionConstraint()

def hpp.corbaserver.problem_solver.ProblemSolver.createPositionConstraint | ( |  | self,
|  |  | constraintName,
|  |  | joint1Name,
|  |  | joint2Name,
|  |  | point1,
|  |  | point2,
|  |  | mask
| ) |  |

## ◆ createRelativeComConstraint()

def hpp.corbaserver.problem_solver.ProblemSolver.createRelativeComConstraint | ( |  | self,
|  |  | constraintName,
|  |  | comName,
|  |  | jointLName,
|  |  | point,
|  |  | mask
| ) |  |

## ◆ createTransformationConstraint()

def hpp.corbaserver.problem_solver.ProblemSolver.createTransformationConstraint | ( |  | self,
|  |  | constraintName,
|  |  | joint1Name,
|  |  | joint2Name,
|  |  | ref,
|  |  | mask
| ) |  |

## ◆ cutObstacle()

def hpp.corbaserver.problem_solver.ProblemSolver.cutObstacle | ( |  | self,
|  |  | objectName,
|  |  | aabb
| ) |  |

## ◆ derivativeAtParam()

def hpp.corbaserver.problem_solver.ProblemSolver.derivativeAtParam | ( |  | self,
|  |  | inPathId,
|  |  | order,
|  |  | param
| ) |  |

## ◆ directPath()

def hpp.corbaserver.problem_solver.ProblemSolver.directPath | ( |  | self,
|  |  | startConfig,
|  |  | endConfig,
|  |  | validate
| ) |  |

## ◆ edge()

def hpp.corbaserver.problem_solver.ProblemSolver.edge | ( |  | self,
|  |  | edgeId
| ) |  |

## ◆ erasePath()

def hpp.corbaserver.problem_solver.ProblemSolver.erasePath | ( |  | self,
|  |  | pathId
| ) |  |

## ◆ executeOneStep()

def hpp.corbaserver.problem_solver.ProblemSolver.executeOneStep | ( |  | self | ) |

## ◆ extractPath()

def hpp.corbaserver.problem_solver.ProblemSolver.extractPath | ( |  | self,
|  |  | pathId,
|  |  | start,
|  |  | end
| ) |  |

## ◆ filterCollisionPairs()

def hpp.corbaserver.problem_solver.ProblemSolver.filterCollisionPairs | ( |  | self | ) |

## ◆ finishSolveStepByStep()

def hpp.corbaserver.problem_solver.ProblemSolver.finishSolveStepByStep | ( |  | self | ) |

## ◆ generateValidConfig()

def hpp.corbaserver.problem_solver.ProblemSolver.generateValidConfig | ( |  | self,
|  |  | maxIter
| ) |  |

## ◆ getAvailable()

def hpp.corbaserver.problem_solver.ProblemSolver.getAvailable | ( |  | self,
|  |  | type
| ) |  |

## ◆ getConstantRightHandSide()

def hpp.corbaserver.problem_solver.ProblemSolver.getConstantRightHandSide | ( |  | self,
|  |  | constraintName
| ) |  |

## ◆ getErrorThreshold()

def hpp.corbaserver.problem_solver.ProblemSolver.getErrorThreshold | ( |  | self | ) |

## ◆ getGoalConfigs()

def hpp.corbaserver.problem_solver.ProblemSolver.getGoalConfigs | ( |  | self | ) |

## ◆ getInitialConfig()

def hpp.corbaserver.problem_solver.ProblemSolver.getInitialConfig | ( |  | self | ) |

## ◆ getMaxIterPathPlanning()

def hpp.corbaserver.problem_solver.ProblemSolver.getMaxIterPathPlanning | ( |  | self | ) |

## ◆ getMaxIterProjection()

def hpp.corbaserver.problem_solver.ProblemSolver.getMaxIterProjection | ( |  | self | ) |

## ◆ getMaxNumThreads()

def hpp.corbaserver.problem_solver.ProblemSolver.getMaxNumThreads | ( |  | self | ) |

## ◆ getNearestConfig()

def hpp.corbaserver.problem_solver.ProblemSolver.getNearestConfig | ( |  | self,
|  |  | randomConfig,
|  |  | connectedComponentId = `-1`
| ) |  |

## ◆ getObstacleLinkNames()

def hpp.corbaserver.problem_solver.ProblemSolver.getObstacleLinkNames | ( |  | self | ) |

## ◆ getObstacleLinkPosition()

def hpp.corbaserver.problem_solver.ProblemSolver.getObstacleLinkPosition | ( |  | self,
|  |  | objectName
| ) |  |

## ◆ getObstacleNames()

def hpp.corbaserver.problem_solver.ProblemSolver.getObstacleNames | ( |  | self,
|  |  | collision,
|  |  | distance
| ) |  |

## ◆ getObstaclePosition()

def hpp.corbaserver.problem_solver.ProblemSolver.getObstaclePosition | ( |  | self,
|  |  | objectName
| ) |  |

## ◆ getParameter()

def hpp.corbaserver.problem_solver.ProblemSolver.getParameter | ( |  | self,
|  |  | name,
|  |  | keep_any = `False`
| ) |  |

## ◆ getParameterDoc()

def hpp.corbaserver.problem_solver.ProblemSolver.getParameterDoc | ( |  | self,
|  |  | name
| ) |  |

## ◆ getPartialCom()

def hpp.corbaserver.problem_solver.ProblemSolver.getPartialCom | ( |  | self,
|  |  | comName
| ) |  |

## ◆ getSelected()

def hpp.corbaserver.problem_solver.ProblemSolver.getSelected | ( |  | self,
|  |  | type
| ) |  |

## ◆ getTimeOutPathPlanning()

def hpp.corbaserver.problem_solver.ProblemSolver.getTimeOutPathPlanning | ( |  | self | ) |

## ◆ getWaypoints()

def hpp.corbaserver.problem_solver.ProblemSolver.getWaypoints | ( |  | self,
|  |  | pathId
| ) |  |

## ◆ interruptPathPlanning()

def hpp.corbaserver.problem_solver.ProblemSolver.interruptPathPlanning | ( |  | self | ) |

## ◆ loadObstacleFromUrdf()

def hpp.corbaserver.problem_solver.ProblemSolver.loadObstacleFromUrdf | ( |  | self,
|  | * | args
| ) |  |

## ◆ loadPlugin()

def hpp.corbaserver.problem_solver.ProblemSolver.loadPlugin | ( |  | self,
|  |  | pluginName
| ) |  |

## ◆ loadRoadmap()

def hpp.corbaserver.problem_solver.ProblemSolver.loadRoadmap | ( |  | self,
|  |  | filename
| ) |  |

## ◆ moveObstacle()

def hpp.corbaserver.problem_solver.ProblemSolver.moveObstacle | ( |  | self,
|  |  | objectName,
|  |  | cfg
| ) |  |

## ◆ movePathToProblem()

def hpp.corbaserver.problem_solver.ProblemSolver.movePathToProblem | ( |  | self,
|  |  | pathId,
|  |  | problemName,
|  |  | jointNames
| ) |  |

## ◆ node()

def hpp.corbaserver.problem_solver.ProblemSolver.node | ( |  | self,
|  |  | nodeId
| ) |  |

## ◆ nodes()

def hpp.corbaserver.problem_solver.ProblemSolver.nodes | ( |  | self | ) |

## ◆ nodesConnectedComponent()

def hpp.corbaserver.problem_solver.ProblemSolver.nodesConnectedComponent | ( |  | self,
|  |  | ccId
| ) |  |

## ◆ numberConnectedComponents()

def hpp.corbaserver.problem_solver.ProblemSolver.numberConnectedComponents | ( |  | self | ) |

## ◆ numberEdges()

def hpp.corbaserver.problem_solver.ProblemSolver.numberEdges | ( |  | self | ) |

## ◆ numberNodes()

def hpp.corbaserver.problem_solver.ProblemSolver.numberNodes | ( |  | self | ) |

## ◆ numberPaths()

def hpp.corbaserver.problem_solver.ProblemSolver.numberPaths | ( |  | self | ) |

## ◆ optimize()

def hpp.corbaserver.problem_solver.ProblemSolver.optimize | ( |  | self,
|  |  | q
| ) |  |

## ◆ optimizePath()

def hpp.corbaserver.problem_solver.ProblemSolver.optimizePath | ( |  | self,
|  |  | inPathId
| ) |  |

## ◆ pathLength()

def hpp.corbaserver.problem_solver.ProblemSolver.pathLength | ( |  | self,
|  |  | inPathId
| ) |  |

## ◆ prepareSolveStepByStep()

def hpp.corbaserver.problem_solver.ProblemSolver.prepareSolveStepByStep | ( |  | self | ) |

## ◆ projectPath()

def hpp.corbaserver.problem_solver.ProblemSolver.projectPath | ( |  | self,
|  |  | pathId
| ) |  |

## ◆ removeObstacleFromJoint()

def hpp.corbaserver.problem_solver.ProblemSolver.removeObstacleFromJoint | ( |  | self,
|  |  | objectName,
|  |  | jointName,
|  |  | collision,
|  |  | distance
| ) |  |

## ◆ resetConstraintMap()

def hpp.corbaserver.problem_solver.ProblemSolver.resetConstraintMap | ( |  | self | ) |

## ◆ resetConstraints()

def hpp.corbaserver.problem_solver.ProblemSolver.resetConstraints | ( |  | self | ) |

## ◆ resetGoalConfigs()

def hpp.corbaserver.problem_solver.ProblemSolver.resetGoalConfigs | ( |  | self | ) |

## ◆ resetGoalConstraints()

def hpp.corbaserver.problem_solver.ProblemSolver.resetGoalConstraints | ( |  | self | ) |

## ◆ saveRoadmap()

def hpp.corbaserver.problem_solver.ProblemSolver.saveRoadmap | ( |  | self,
|  |  | filename
| ) |  |

## ◆ selectConfigurationShooter()

def hpp.corbaserver.problem_solver.ProblemSolver.selectConfigurationShooter | ( |  | self,
|  |  | configurationShooterType
| ) |  |

## ◆ selectDistance()

def hpp.corbaserver.problem_solver.ProblemSolver.selectDistance | ( |  | self,
|  |  | distanceType
| ) |  |

## ◆ selectPathPlanner()

def hpp.corbaserver.problem_solver.ProblemSolver.selectPathPlanner | ( |  | self,
|  |  | pathPlannerType
| ) |  |

## ◆ selectPathProjector()

def hpp.corbaserver.problem_solver.ProblemSolver.selectPathProjector | ( |  | self,
|  |  | pathProjectorType,
|  |  | tolerance
| ) |  |

## ◆ selectPathValidation()

def hpp.corbaserver.problem_solver.ProblemSolver.selectPathValidation | ( |  | self,
|  |  | pathValidationType,
|  |  | tolerance
| ) |  |

## ◆ selectProblem()

def hpp.corbaserver.problem_solver.ProblemSolver.selectProblem | ( |  | self,
|  |  | name
| ) |  |

## ◆ selectSteeringMethod()

def hpp.corbaserver.problem_solver.ProblemSolver.selectSteeringMethod | ( |  | self,
|  |  | steeringMethodType
| ) |  |

## ◆ setConstantRightHandSide()

def hpp.corbaserver.problem_solver.ProblemSolver.setConstantRightHandSide | ( |  | self,
|  |  | constraintName,
|  |  | constant
| ) |  |

## ◆ setDefaultLineSearchType()

def hpp.corbaserver.problem_solver.ProblemSolver.setDefaultLineSearchType | ( |  | self,
|  |  | type
| ) |  |

## ◆ setErrorThreshold()

def hpp.corbaserver.problem_solver.ProblemSolver.setErrorThreshold | ( |  | self,
|  |  | threshold
| ) |  |

## ◆ setGoalConstraints()

def hpp.corbaserver.problem_solver.ProblemSolver.setGoalConstraints | ( |  | self,
|  |  | constraints
| ) |  |

## ◆ setInitialConfig()

def hpp.corbaserver.problem_solver.ProblemSolver.setInitialConfig | ( |  | self,
|  |  | dofArray
| ) |  |

## ◆ setMaxIterPathPlanning()

def hpp.corbaserver.problem_solver.ProblemSolver.setMaxIterPathPlanning | ( |  | self,
|  |  | iterations
| ) |  |

## ◆ setMaxIterProjection()

def hpp.corbaserver.problem_solver.ProblemSolver.setMaxIterProjection | ( |  | self,
|  |  | iterations
| ) |  |

## ◆ setMaxNumThreads()

def hpp.corbaserver.problem_solver.ProblemSolver.setMaxNumThreads | ( |  | self,
|  |  | n
| ) |  |

## ◆ setParameter()

def hpp.corbaserver.problem_solver.ProblemSolver.setParameter | ( |  | self,
|  |  | name,
|  |  | value
| ) |  |

## ◆ setRandomSeed()

def hpp.corbaserver.problem_solver.ProblemSolver.setRandomSeed | ( |  | self,
|  |  | seed
| ) |  |

## ◆ setRightHandSide()

def hpp.corbaserver.problem_solver.ProblemSolver.setRightHandSide | ( |  | self,
|  |  | rhs
| ) |  |

## ◆ setRightHandSideByName()

def hpp.corbaserver.problem_solver.ProblemSolver.setRightHandSideByName | ( |  | self,
|  |  | constraintName,
|  |  | rhs
| ) |  |

## ◆ setRightHandSideFromConfig()

def hpp.corbaserver.problem_solver.ProblemSolver.setRightHandSideFromConfig | ( |  | self,
|  |  | config
| ) |  |

## ◆ setRightHandSideFromConfigByName()

def hpp.corbaserver.problem_solver.ProblemSolver.setRightHandSideFromConfigByName | ( |  | self,
|  |  | constraintName,
|  |  | config
| ) |  |

## ◆ setTimeOutPathPlanning()

def hpp.corbaserver.problem_solver.ProblemSolver.setTimeOutPathPlanning | ( |  | self,
|  |  | timeOut
| ) |  |

## ◆ solve()

def hpp.corbaserver.problem_solver.ProblemSolver.solve | ( |  | self | ) |

## Member Data Documentation

## ◆ client

hpp.corbaserver.problem_solver.ProblemSolver.client

## ◆ hppcorba

hpp.corbaserver.problem_solver.ProblemSolver.hppcorba

## ◆ robot

hpp.corbaserver.problem_solver.ProblemSolver.robot

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

- src/hpp/corbaserver/problem_solver.py