hpp-corbaserver  5.0.0
Corba server for Humanoid Path Planner applications
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: