pymoveit_mtc.core.MonitoringGenerator¶

class MonitoringGenerator(self: pymoveit_mtc.core.MonitoringGenerator, name: str = 'generator')¶

Bases: Generator

Base class for monitoring generator stages

To implement a generator stage that draws on some previously computed solution, you need to derive from MonitoringGenerator - monitoring the solutions produced by another stage. Each time, the monitored stage produces a new solution, the method onNewSolution() of the MonitoringGenerator is called. Usually, you schedule this solution for later processing in compute():

class PyMonitoringGenerator(core.MonitoringGenerator):
        """ Implements a custom 'MonitoringGenerator' stage."""

        solution_multiplier = 2

        def __init__(self, name="MonitoringGenerator"):
                core.MonitoringGenerator.__init__(self, name)
                self.reset()

        def reset(self):
                core.MonitoringGenerator.reset(self)
                self.pending = []

        def onNewSolution(self, sol):
                self.pending.append(sol)

        def canCompute(self):
                return bool(self.pending)

        def compute(self):
                # fetch first pending upstream solution ...
                scene = self.pending.pop(0).end.scene
                # ... and generate new solutions derived from it
                for i in range(self.solution_multiplier):
                        self.spawn(core.InterfaceState(scene), i)

Upon creation of the stage, assign the monitored stage as follows:

jointspace = core.JointInterpolationPlanner()

task = core.Task()
current = stages.CurrentState("current")
task.add(current)

connect = stages.Connect(planners=[('panda_arm', jointspace)])
task.add(connect)

mg = PyMonitoringGenerator("generator")
mg.setMonitoredStage(task["current"])
task.add(mg)

Methods

`canCompute`	Return `True` if the stage can still produce solutions.
`compute`	Compute an actual solution and `spawn` an `InterfaceState`
`init`	Initialize the stage once before planning.
`reset`	Reset the Stage.
`setCostTerm`	Overloaded function.
`setMonitoredStage`	Set the monitored `Stage`
`spawn`	Spawn an `InterfaceState` to both, start and end interface

Attributes

`failures`	Failed Solutions of the stage (read-only)
`forwarded_properties`	set of properties forwarded from input to output InterfaceState
`marker_ns`	Namespace for any markers that are associated to the stage
`name`	name of the stage displayed e.g.
`properties`	PropertyMap of the stage (read-only)
`solutions`	Successful Solutions of the stage (read-only)
`timeout`	Maximally allowed time [s] per computation step

class PropertyInitializerSource(self: pymoveit_mtc.core.Stage.PropertyInitializerSource, value: int)¶

Bases: pybind11_object

OR-combinable flags defining a source to initialize a specific property from. Used in pymoveit_mtc.core.PropertyMap configureInitFrom().

Members:

PARENT : Inherit properties from parent stage

INTERFACE : Inherit properties from the input InterfaceState

property name¶

canCompute(self: pymoveit_mtc.core.Generator) → bool¶: Return True if the stage can still produce solutions.

compute(self: pymoveit_mtc.core.Generator) → None¶: Compute an actual solution and spawn an InterfaceState

property failures¶

Failed Solutions of the stage (read-only)

Type:: Solutions

property forwarded_properties¶

set of properties forwarded from input to output InterfaceState

Type:: list

init(self: pymoveit_mtc.core.Stage, robot_model: moveit::core::RobotModel) → None¶: Initialize the stage once before planning. Will setup properties configured for initialization from parent.

property marker_ns¶

Namespace for any markers that are associated to the stage

Type:: str

property name¶

name of the stage displayed e.g. in rviz

Type:: str

property properties¶

PropertyMap of the stage (read-only)

Type:: PropertyMap

reset(self: pymoveit_mtc.core.Stage) → None¶: Reset the Stage. Clears all solutions, interfaces and inherited properties

setCostTerm(*args, **kwargs)¶

Overloaded function.

setCostTerm(self: pymoveit_mtc.core.Stage, arg0: pymoveit_mtc.core.CostTerm) -> None

Specify a CostTerm for calculation of stage costs

setCostTerm(self: pymoveit_mtc.core.Stage, arg0: Callable[[pymoveit_mtc.core.SubTrajectory, str], float]) -> None

Specify a function to calculate trajectory costs

setCostTerm(self: pymoveit_mtc.core.Stage, arg0: Callable[[pymoveit_mtc.core.SubTrajectory], float]) -> None

Specify a function to calculate trajectory costs

setMonitoredStage(self: pymoveit_mtc.core.MonitoringGenerator, stage: pymoveit_mtc.core.Stage) → None¶: Set the monitored Stage

property solutions¶: Successful Solutions of the stage (read-only)

spawn(self: pymoveit_mtc.core.Generator, state: pymoveit_mtc.core.InterfaceState, cost: float) → None¶: Spawn an InterfaceState to both, start and end interface

property timeout¶

Maximally allowed time [s] per computation step

Type:: float