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

hpp-corbaserver 9.0.2 Corba server for Humanoid Path Planner applications

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

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

## Public Attributes
| client
| hppcorba
| robot

## Constructor & Destructor Documentation

## ◆ __init__()

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

## Member Function Documentation

## ◆ addConfigToRoadmap()

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

## ◆ addConfigValidation()

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

## ◆ addEdgeToRoadmap()

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

## ◆ addGoalConfig()

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

## ◆ addLockedJointConstraints()

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

## ◆ addNumericalConstraints()

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

## ◆ addPartialCom()

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

## ◆ addPassiveDofs()

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

## ◆ addPathOptimizer()

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

## ◆ appendDirectPath()

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

## ◆ applyConstraints()

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

## ◆ clearConfigValidations()

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

## ◆ clearPathOptimizers()

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

## ◆ clearRoadmap()

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

## ◆ computeValueAndJacobian()

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

## ◆ concatenatePath()

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

## ◆ configAtParam()

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

## ◆ createComBeetweenFeet()

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

## ◆ createDistanceBetweenJointAndObjects()

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

## ◆ createDistanceBetweenJointConstraint()

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

## ◆ createLockedExtraDof()

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

## ◆ createLockedJoint()

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

## ◆ createOrientationConstraint()

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

## ◆ createPositionConstraint()

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

## ◆ createRelativeComConstraint()

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

## ◆ createTransformationConstraint()

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

## ◆ cutObstacle()

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

## ◆ derivativeAtParam()

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

## ◆ directPath()

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

## ◆ edge()

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

## ◆ erasePath()

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

## ◆ executeOneStep()

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

## ◆ extractPath()

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

## ◆ filterCollisionPairs()

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

## ◆ finishSolveStepByStep()

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

## ◆ generateValidConfig()

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

## ◆ getAvailable()

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

## ◆ getConstantRightHandSide()

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

## ◆ getErrorThreshold()

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

## ◆ getGoalConfigs()

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

## ◆ getInitialConfig()

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

## ◆ getMaxIterPathPlanning()

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

## ◆ getMaxIterProjection()

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

## ◆ getMaxNumThreads()

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

## ◆ getNearestConfig()

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

## ◆ getObstacleLinkNames()

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

## ◆ getObstacleLinkPosition()

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

## ◆ getObstacleNames()

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

## ◆ getObstaclePosition()

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

## ◆ getParameter()

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

## ◆ getParameterDoc()

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

## ◆ getPartialCom()

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

## ◆ getSelected()

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

## ◆ getTimeOutPathPlanning()

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

## ◆ getWaypoints()

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

## ◆ interruptPathPlanning()

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

## ◆ loadObstacleFromUrdf()

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

## ◆ loadPlugin()

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

## ◆ loadRoadmap()

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

## ◆ moveObstacle()

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

## ◆ movePathToProblem()

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

## ◆ node()

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

## ◆ nodes()

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

## ◆ nodesConnectedComponent()

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

## ◆ numberConnectedComponents()

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

## ◆ numberEdges()

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

## ◆ numberNodes()

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

## ◆ numberPaths()

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

## ◆ optimize()

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

## ◆ optimizePath()

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

## ◆ pathLength()

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

## ◆ prepareSolveStepByStep()

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

## ◆ projectPath()

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

## ◆ removeObstacleFromJoint()

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

## ◆ resetConstraintMap()

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

## ◆ resetConstraints()

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

## ◆ resetGoalConfigs()

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

## ◆ resetGoalConstraints()

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

## ◆ saveRoadmap()

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

## ◆ selectConfigurationShooter()

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

## ◆ selectDistance()

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

## ◆ selectPathPlanner()

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

## ◆ selectPathProjector()

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

## ◆ selectPathValidation()

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

## ◆ selectProblem()

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

## ◆ selectSteeringMethod()

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

## ◆ setConstantRightHandSide()

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

## ◆ setDefaultLineSearchType()

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

## ◆ setErrorThreshold()

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

## ◆ setGoalConstraints()

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

## ◆ setInitialConfig()

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

## ◆ setMaxIterPathPlanning()

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

## ◆ setMaxIterProjection()

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

## ◆ setMaxNumThreads()

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

## ◆ setParameter()

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

## ◆ setRandomSeed()

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

## ◆ setRightHandSide()

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

## ◆ setRightHandSideByName()

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

## ◆ setRightHandSideFromConfig()

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

## ◆ setRightHandSideFromConfigByName()

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

## ◆ setTimeOutPathPlanning()

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

## ◆ solve()

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