robotic 0.2.9.dev1__cp311-cp311-manylinux2014_x86_64.whl → 0.3.4.dev5__cp311-cp311-manylinux2014_x86_64.whl

robotic/_robotic.pyi

@@ -5,15 +5,9 @@ from __future__ import annotations
 import numpy
 import typing
 from . import DataGen
+from . import algo
 from . import test
-__all__ = ['Actions2KOMO_Translator', 'ArgWord', 'BSpline', 'BotOp', 'CameraView', 'CameraViewSensor', 'Config', 'ConfigurationViewer', 'ControlMode', 'DataGen', 'FS', 'Frame', 'JT', 'KOMO', 'KOMO_Objective', 'LGP_Tool', 'NLP', 'NLP_Factory', 'NLP_Sampler', 'NLP_Solver', 'NLP_SolverOptions', 'OT', 'OptBench_Skeleton_Handover', 'OptBench_Skeleton_Pick', 'OptBench_Skeleton_StackAndBalance', 'OptBenchmark_InvKin_Endeff', 'OptMethod', 'Quaternion', 'RRT_PathFinder', 'ST', 'SY', 'Simulation', 'SimulationEngine', 'Skeleton', 'SolverReturn', 'TAMP_Provider', 'compiled', 'default_Actions2KOMO_Translator', 'default_TAMP_Provider', 'depthImage2PointCloud', 'params_add', 'params_clear', 'params_file', 'params_print', 'raiPath', 'setRaiPath', 'test']
-class Actions2KOMO_Translator:
-    """
-    Actions2KOMO_Translator
-    """
-    @staticmethod
-    def _pybind11_conduit_v1_(*args, **kwargs):
-        ...
+__all__ = ['ArgWord', 'BSpline', 'BotOp', 'CameraView', 'CameraViewSensor', 'Config', 'ConfigurationViewer', 'ControlMode', 'DataGen', 'FS', 'Frame', 'JT', 'KOMO', 'KOMO_Objective', 'LGP_TAMP_Abstraction', 'LGP_Tool', 'NLP', 'NLP_Factory', 'NLP_Sampler', 'NLP_Solver', 'NLP_SolverOptions', 'OT', 'OptBench_Skeleton_Handover', 'OptBench_Skeleton_Pick', 'OptBench_Skeleton_StackAndBalance', 'OptBenchmark_InvKin_Endeff', 'OptMethod', 'Quaternion', 'RRT_PathFinder', 'ST', 'SY', 'Simulation', 'SimulationEngine', 'Skeleton', 'SolverReturn', 'algo', 'compiled', 'default_LGP_TAMP_Abstraction', 'depthImage2PointCloud', 'get_NLP_Problem_names', 'make_NLP_Problem', 'params_add', 'params_clear', 'params_file', 'params_get', 'params_print', 'raiPath', 'rnd_seed', 'rnd_seed_random', 'setRaiPath', 'test']
 class ArgWord:
     """
     [todo: replace by str]
@@ -72,10 +66,18 @@ class BSpline:
         """
         non-initialized
         """
+    def append(self, points: arr, times_rel: arr, inside: bool = False) -> None:
+        """
+        appends points to the current spline; times_rel become relative to the current last knot; inside = remove the current end double knot (zero vel), smoothly blending but not transitioning anymore through the current end point
+        """
     def eval(self, sampleTimes: arr, derivative: int = 0) -> arr:
         """
         evaluate the spline (or its derivative) for given sampleTimes
         """
+    def eval3(self, time: float) -> arr:
+        """
+        evaluate the spline pos, vel, acc (3xn matrix) at a single time
+        """
     def getBmatrix(self, sampleTimes: arr, startDuplicates: bool = False, endDuplicates: bool = False) -> arr:
         """
         return the B-matrix mapping from ctrlPoints to (e.g. finer) sampleTimes (e.g. uniform linspace(0,1,T)
@@ -84,6 +86,14 @@ class BSpline:
         ...
     def getKnots(self) -> arr:
         ...
+    def overwriteSmooth(self, points: arr, times_rel: arr, time_cut: float) -> None:
+        """
+        overwrites the spline by adopting the pos+vel at time_cut of the current spline and appending given points; NOTE: times_rel are added to time_cut)
+        """
+    def set(self, degree: int, points: arr, times: arr, setStartVel: arr = ..., setEndVel: arr = ...) -> BSpline:
+        """
+        convenience: same as setKnots(degree, times) and setCtrlPoints(points, true, true, startVel, endVel)
+        """
     def setCtrlPoints(self, points: arr, addStartDuplicates: bool = True, addEndDuplicates: bool = True, setStartVel: arr = ..., setEndVel: arr = ...) -> None:
         """
         set the ctrl points, automatically duplicating them as needed at start/end, optionally setting vels at start/end
@@ -103,6 +113,14 @@ class BotOp:
         """
         constructor
         """
+    def attach(self, from: ..., to: ...) -> None:
+        """
+        cheating: attach two objects kinematically
+        """
+    def detach(self, from: ..., to: ...) -> None:
+        """
+        cheating: detach two previously attached objects
+        """
     def getCameraFxycxy(self, sensorName: str) -> arr:
         """
         returns camera intrinsics
@@ -218,7 +236,7 @@ class CameraView:
         """
         constructor
         """
-    def computeImageAndDepth(self, config: Config, visualsOnly: bool = True) -> tuple:
+    def computeImageAndDepth(self, config: Config, simulateDepthNoise: bool = False, visualsOnly: bool = True) -> tuple:
         """
         returns image and depth from a camera sensor; the 'config' argument needs to be the same configuration as in the constructor, but in new state
         """
@@ -275,7 +293,7 @@ class Config:
         """
         animate with random spline in limits bounding box [T=#spline points]
         """
-    def asDict(self) -> dict:
+    def asDict(self, parentsInKeys: bool = True) -> dict:
         """
         return the configuration description as a dict, e.g. for file export
         """
@@ -291,6 +309,10 @@ class Config:
         """
         clear all frames and additional data; becomes the empty configuration, with no frames
         """
+    def coll_totalViolation(self) -> float:
+        """
+        returns the sum of all penetrations (using FCL for broadphase; and low-level GJK/MRP for fine pair-wise distance/penetration computation)
+        """
     def computeCollisions(self) -> None:
         """
         [should be obsolete; getCollision* methods auto ensure proxies] call the broadphase collision engine (SWIFT++ or FCL) to generate the list of collisions (or near proximities) between all frame shapes that have the collision tag set non-zero
@@ -311,18 +333,10 @@ class Config:
         """
         returns the list of collisable pairs -- this should help debugging the 'contact' flag settings in a configuration
         """
-    def getCollisionFree(self) -> bool:
-        """
-        returns if the configuration is collision free (binary collision check, using FCL only; collidable objects need to have contact flag)
-        """
-    def getCollisions(self, belowMargin: float = 1.0) -> list:
+    def getCollisions(self, belowMargin: float = 0.0) -> list:
         """
         return the results of collision computations: a list of 3 tuples with (frame1, frame2, distance). Optionally report only on distances below a margin To get really precise distances and penetrations use the FS.distance feature with the two frame names
         """
-    def getCollisionsTotalPenetration(self) -> float:
-        """
-        returns the sum of all penetrations (using FCL for broadphase; and low-level GJK/MRP for fine pair-wise distance/penetration computation)
-        """
     def getFrame(self, frameName: str, warnIfNotExist: bool = True) -> Frame:
         """
         get access to a frame by name; use the Frame methods to set/get frame properties
@@ -361,13 +375,15 @@ class Config:
         """
         get the joint state as a numpy vector, optionally only for a subset of joints specified as list of joint names
         """
-    def get_viewer(self, window_title: str = None, offscreen: bool = False) -> ...:
+    def getRoots(self) -> list[Frame]:
+        ...
+    def get_viewer(self) -> ConfigurationViewer:
         ...
     def processInertias(self, recomputeInertias: bool = True, transformToDiagInertia: bool = False) -> None:
         """
         collect all inertia at root frame of links, optionally reestimate all inertias based on standard surface density, optionally relocate the link frame to the COM with diagonalized I)
         """
-    def processStructure(self, pruneNamed: bool, pruneNonContactNonMarker: bool, pruneTransparent: bool) -> None:
+    def processStructure(self, pruneRigidJoints: bool = False, reconnectToLinks: bool = True, pruneNonContactShapes: bool = False, pruneTransparent: bool = False) -> None:
         """
         structurally simplify the Configuration (deleting frames, relinking to minimal tree)
         """
@@ -397,7 +413,7 @@ class Config:
         """
     def setJointStateSlice(self, arg0: list[float], arg1: int) -> None:
         ...
-    def set_viewer(self, arg0: ...) -> None:
+    def set_viewer(self, arg0: ConfigurationViewer) -> None:
         ...
     def view(self, pause: bool = False, message: str = None) -> int:
         """
@@ -407,36 +423,10 @@ class Config:
         """
         close the view
         """
-    def view_focalLength(self) -> float:
-        """
-        return the focal length of the view camera (only intrinsic parameter)
-        """
-    def view_fxycxy(self) -> arr:
-        """
-        return (fx, fy, cx, cy): the focal length and image center in PIXEL UNITS
-        """
-    def view_getDepth(self) -> numpy.ndarray[numpy.float32]:
-        ...
-    def view_getRgb(self) -> numpy.ndarray[numpy.uint8]:
-        ...
-    def view_pose(self) -> arr:
-        """
-        return the 7D pose of the view camera
-        """
-    def view_raise(self) -> None:
-        """
-        raise the view
-        """
     def view_recopyMeshes(self) -> None:
         ...
-    def view_savePng(self, pathPrefix: str = 'z.vid/') -> None:
-        """
-        saves a png image of the current view, numbered with a global counter, with the intention to make a video
-        """
-    def view_setCamera(self, arg0: Frame) -> None:
-        """
-        set the camera pose to a frame, and check frame attributes for intrinsic parameters (focalLength, width height)
-        """
+    def viewer(self) -> ConfigurationViewer:
+        ...
     def watchFile(self, arg0: str) -> None:
         """
         launch a viewer that listents (inode) to changes of a file (made by you in an editor), and reloads, displays and animates the configuration whenever the file is changed
@@ -453,7 +443,7 @@ class Config:
         """
         write the full configuration in a ply mesh file
         """
-    def writeMeshes(self, pathPrefix: ..., copyTextures: bool) -> None:
+    def writeMeshes(self, pathPrefix: ..., copyTextures: bool = True, enumerateAssets: bool = False) -> None:
         """
         write all object meshes in a directory
         """
@@ -468,9 +458,67 @@ class ConfigurationViewer:
     @staticmethod
     def _pybind11_conduit_v1_(*args, **kwargs):
         ...
+    def focus(self, position_3d: arr, heightAbs: float = 1.0) -> None:
+        """
+        focus at a 3D position; second argument distances camara so that view window has roughly given absHeight around object
+        """
+    def getCamera_focalLength(self) -> float:
+        """
+        return the focal length of the view camera (only intrinsic parameter)
+        """
+    def getCamera_fxycxy(self) -> arr:
+        """
+        return (fx, fy, cx, cy): the focal length and image center in PIXEL UNITS
+        """
+    def getCamera_pose(self) -> arr:
+        """
+        get the camera pose directly
+        """
+    def getDepth(self) -> ...:
+        """
+        return the view's depth array (scaled to meters)
+        """
+    def getEventCursor(self) -> arr:
+        """
+        return the position and normal of the 'curser': mouse position 3D projected into scene via depth, and 3D normal of depth map -- returned as 6D vector
+        """
+    def getEventCursorObject(self) -> int:
+        """
+        (aka mouse picking) return the frame ID (or -1) that the 'cursor' currently points at
+        """
+    def getEvents(self) -> StringA:
+        """
+        return accumulated events as list of strings
+        """
+    def getGLFWWindow(self) -> int:
+        ...
+    def getRgb(self) -> ...:
+        """
+        return the view's rgb image
+        """
+    def raiseWindow(self) -> None:
+        """
+        raise the window
+        """
     def savePng(self, saveVideoPath: ... = 'z.vid/', count: int = -1) -> None:
         """
-        save enumerated pngs in a path - for video making
+        saves a png image of the current view, numbered with a global counter, with the intention to make a video
+        """
+    def setCamera(self, camFrame: Frame) -> None:
+        """
+        set the camera pose to a frame, and check frame attributes for intrinsic parameters (focalLength, width height)
+        """
+    def setCameraPose(self, pose_7d: arr) -> None:
+        """
+        set the camera pose directly
+        """
+    def setWindow(self, title: str, width: int, height: int) -> None:
+        """
+        set title, width, and height
+        """
+    def setupEventHandler(self, blockDefaultHandler: bool) -> None:
+        """
+        setup callbacks to grab window events and return them with methods below
         """
     def visualsOnly(self, _visualsOnly: bool = True) -> None:
         """
@@ -722,10 +770,6 @@ class Frame:
     @staticmethod
     def _pybind11_conduit_v1_(*args, **kwargs):
         ...
-    def addAttributes(self, arg0: dict) -> None:
-        """
-        add/set attributes for the frame
-        """
     def asDict(self) -> dict:
         ...
     def computeCompoundInertia(self) -> Frame:
@@ -752,11 +796,11 @@ class Frame:
         ...
     def getParent(self) -> Frame:
         ...
-    def getPose(self) -> arr:
+    def getPose(self, relativeTo: Frame = None) -> arr:
         ...
-    def getPosition(self) -> arr:
+    def getPosition(self, relativeTo: Frame = None) -> arr:
         ...
-    def getQuaternion(self) -> arr:
+    def getQuaternion(self, relativeTo: Frame = None) -> arr:
         ...
     def getRelativePose(self) -> arr:
         ...
@@ -772,12 +816,14 @@ class Frame:
         ...
     def getSize(self) -> arr:
         ...
-    def getTransform(self) -> arr:
+    def getTransform(self, relativeTo: Frame = None) -> arr:
         ...
     def makeRoot(self, untilPartBreak: bool) -> None:
         ...
-    def setAttribute(self, arg0: str, arg1: float) -> Frame:
-        ...
+    def setAttributes(self, arg0: dict) -> Frame:
+        """
+        set attributes for the frame
+        """
     def setColor(self, arg0: arr) -> Frame:
         ...
     def setContact(self, arg0: int) -> Frame:
@@ -788,11 +834,15 @@ class Frame:
         """
     def setImplicitSurface(self, data: ..., size: arr, blur: int, resample: float = -1.0) -> Frame:
         ...
-    def setJoint(self, jointType: JT, limits: arr = ...) -> Frame:
+    def setJoint(self, jointType: JT, limits: arr = ..., scale: float = 1.0, mimic: Frame = None) -> Frame:
         ...
     def setJointState(self, arg0: arr) -> Frame:
         ...
-    def setMass(self, arg0: float) -> Frame:
+    def setLines(self, verts: arr, colors: ... = ..., singleConnectedLine: bool = False) -> Frame:
+        """
+        attach lines as shape
+        """
+    def setMass(self, mass: float, inertiaMatrix: arr = ...) -> Frame:
         ...
     def setMesh(self, vertices: arr, triangles: uintA, colors: ... = ..., cvxParts: uintA = ...) -> Frame:
         """
@@ -810,17 +860,17 @@ class Frame:
         """
         attach a point cloud shape
         """
-    def setPose(self, arg0: arr) -> None:
+    def setPose(self, arg0: arr) -> Frame:
         ...
-    def setPoseByText(self, arg0: str) -> None:
+    def setPoseByText(self, arg0: str) -> Frame:
         ...
     def setPosition(self, arg0: arr) -> Frame:
         ...
     def setQuaternion(self, arg0: arr) -> Frame:
         ...
-    def setRelativePose(self, arg0: arr) -> None:
+    def setRelativePose(self, arg0: arr) -> Frame:
         ...
-    def setRelativePoseByText(self, arg0: str) -> None:
+    def setRelativePoseByText(self, arg0: str) -> Frame:
         ...
     def setRelativePosition(self, arg0: arr) -> Frame:
         ...
@@ -1090,6 +1140,13 @@ class KOMO_Objective:
     @staticmethod
     def _pybind11_conduit_v1_(*args, **kwargs):
         ...
+class LGP_TAMP_Abstraction:
+    """
+    LGP_TAMP_Abstraction
+    """
+    @staticmethod
+    def _pybind11_conduit_v1_(*args, **kwargs):
+        ...
 class LGP_Tool:
     """
     Tools to compute things (and solve) a Task-and-Motion Planning problem formulated as Logic-Geometric Program
@@ -1097,7 +1154,7 @@ class LGP_Tool:
     @staticmethod
     def _pybind11_conduit_v1_(*args, **kwargs):
         ...
-    def __init__(self, arg0: Config, arg1: TAMP_Provider, arg2: Actions2KOMO_Translator) -> None:
+    def __init__(self, arg0: Config, arg1: LGP_TAMP_Abstraction) -> None:
         """
         initialization
         """
@@ -1152,7 +1209,7 @@ class NLP:
         """
     def getBounds(self) -> arr:
         """
-        returns the tuple $(b_{lo},b_{up})$, where both vectors are of same dimensionality of $x$ (or size zero, if there are no bounds)
+        returns a 2xn array with lower and upper bounds as rows (or size zero, if there are no bounds)
         """
     def getDimension(self) -> int:
         """
@@ -1244,7 +1301,7 @@ class NLP_Solver:
         """
     def setInitialization(self, arg0: arr) -> NLP_Solver:
         ...
-    def setOptions(self, verbose: int = 1, stopTolerance: float = 0.01, stopFTolerance: float = -1.0, stopGTolerance: float = -1.0, stopEvals: int = 1000, stopInners: int = 1000, stopOuters: int = 1000, stepMax: float = 0.2, damping: float = 1.0, stepInc: float = 1.5, stepDec: float = 0.5, wolfe: float = 0.01, muInit: float = 1.0, muInc: float = 5.0, muMax: float = 10000.0, muLBInit: float = 0.1, muLBDec: float = 0.2, lambdaMax: float = -1.0) -> NLP_Solver:
+    def setOptions(self, verbose: int = 1, stopTolerance: float = 0.01, stopFTolerance: float = -1.0, stopGTolerance: float = -1.0, stopEvals: int = 1000, stopInners: int = 1000, stopOuters: int = 1000, stopLineSteps: int = 10, stopTinySteps: int = 4, stepInit: float = 1.0, stepMin: float = -1.0, stepMax: float = 0.2, stepInc: float = 1.5, stepDec: float = 0.5, damping: float = 1.0, wolfe: float = 0.01, muInit: float = 1.0, muInc: float = 5.0, muMax: float = 10000.0, muLBInit: float = 0.1, muLBDec: float = 0.2, lambdaMax: float = -1.0, interiorPadding: float = 0.01, boundedNewton: bool = True, finiteDifference: float = -1.0) -> NLP_Solver:
         """
         set solver options
         """
@@ -1400,19 +1457,21 @@ class OptMethod:
     
       none
     
-      gradientDescent
+      GradientDescent
     
-      rprop
+      Rprop
     
       LBFGS
     
-      newton
+      Newton
+    
+      AugmentedLag
     
-      augmentedLag
+      LogBarrier
     
-      squaredPenalty
+      slackGN_logBarrier
     
-      logBarrier
+      SquaredPenalty
     
       singleSquaredPenalty
     
@@ -1422,22 +1481,41 @@ class OptMethod:
     
       Ipopt
     
+      slackGN_Ipopt
+    
       Ceres
+    
+      LSZO
+    
+      greedy
+    
+      NelderMead
+    
+      CMA
+    
+      ES
     """
-    Ceres: typing.ClassVar[OptMethod]  # value = <OptMethod.Ceres: 12>
-    Ipopt: typing.ClassVar[OptMethod]  # value = <OptMethod.Ipopt: 11>
+    AugmentedLag: typing.ClassVar[OptMethod]  # value = <OptMethod.AugmentedLag: 5>
+    CMA: typing.ClassVar[OptMethod]  # value = <OptMethod.CMA: 18>
+    Ceres: typing.ClassVar[OptMethod]  # value = <OptMethod.Ceres: 14>
+    ES: typing.ClassVar[OptMethod]  # value = <OptMethod.ES: 19>
+    GradientDescent: typing.ClassVar[OptMethod]  # value = <OptMethod.GradientDescent: 1>
+    Ipopt: typing.ClassVar[OptMethod]  # value = <OptMethod.Ipopt: 12>
     LBFGS: typing.ClassVar[OptMethod]  # value = <OptMethod.LBFGS: 3>
-    NLopt: typing.ClassVar[OptMethod]  # value = <OptMethod.NLopt: 10>
-    __members__: typing.ClassVar[dict[str, OptMethod]]  # value = {'none': <OptMethod.none: 0>, 'gradientDescent': <OptMethod.gradientDescent: 1>, 'rprop': <OptMethod.rprop: 2>, 'LBFGS': <OptMethod.LBFGS: 3>, 'newton': <OptMethod.newton: 4>, 'augmentedLag': <OptMethod.augmentedLag: 5>, 'squaredPenalty': <OptMethod.squaredPenalty: 6>, 'logBarrier': <OptMethod.logBarrier: 7>, 'singleSquaredPenalty': <OptMethod.singleSquaredPenalty: 8>, 'slackGN': <OptMethod.slackGN: 9>, 'NLopt': <OptMethod.NLopt: 10>, 'Ipopt': <OptMethod.Ipopt: 11>, 'Ceres': <OptMethod.Ceres: 12>}
-    augmentedLag: typing.ClassVar[OptMethod]  # value = <OptMethod.augmentedLag: 5>
-    gradientDescent: typing.ClassVar[OptMethod]  # value = <OptMethod.gradientDescent: 1>
-    logBarrier: typing.ClassVar[OptMethod]  # value = <OptMethod.logBarrier: 7>
-    newton: typing.ClassVar[OptMethod]  # value = <OptMethod.newton: 4>
+    LSZO: typing.ClassVar[OptMethod]  # value = <OptMethod.LSZO: 15>
+    LogBarrier: typing.ClassVar[OptMethod]  # value = <OptMethod.LogBarrier: 6>
+    NLopt: typing.ClassVar[OptMethod]  # value = <OptMethod.NLopt: 11>
+    NelderMead: typing.ClassVar[OptMethod]  # value = <OptMethod.NelderMead: 17>
+    Newton: typing.ClassVar[OptMethod]  # value = <OptMethod.Newton: 4>
+    Rprop: typing.ClassVar[OptMethod]  # value = <OptMethod.Rprop: 2>
+    SquaredPenalty: typing.ClassVar[OptMethod]  # value = <OptMethod.SquaredPenalty: 8>
+    __members__: typing.ClassVar[dict[str, OptMethod]]  # value = {'none': <OptMethod.none: 0>, 'GradientDescent': <OptMethod.GradientDescent: 1>, 'Rprop': <OptMethod.Rprop: 2>, 'LBFGS': <OptMethod.LBFGS: 3>, 'Newton': <OptMethod.Newton: 4>, 'AugmentedLag': <OptMethod.AugmentedLag: 5>, 'LogBarrier': <OptMethod.LogBarrier: 6>, 'slackGN_logBarrier': <OptMethod.slackGN_logBarrier: 7>, 'SquaredPenalty': <OptMethod.SquaredPenalty: 8>, 'singleSquaredPenalty': <OptMethod.singleSquaredPenalty: 9>, 'slackGN': <OptMethod.slackGN: 10>, 'NLopt': <OptMethod.NLopt: 11>, 'Ipopt': <OptMethod.Ipopt: 12>, 'slackGN_Ipopt': <OptMethod.slackGN_Ipopt: 13>, 'Ceres': <OptMethod.Ceres: 14>, 'LSZO': <OptMethod.LSZO: 15>, 'greedy': <OptMethod.greedy: 16>, 'NelderMead': <OptMethod.NelderMead: 17>, 'CMA': <OptMethod.CMA: 18>, 'ES': <OptMethod.ES: 19>}
+    greedy: typing.ClassVar[OptMethod]  # value = <OptMethod.greedy: 16>
     none: typing.ClassVar[OptMethod]  # value = <OptMethod.none: 0>
-    rprop: typing.ClassVar[OptMethod]  # value = <OptMethod.rprop: 2>
-    singleSquaredPenalty: typing.ClassVar[OptMethod]  # value = <OptMethod.singleSquaredPenalty: 8>
-    slackGN: typing.ClassVar[OptMethod]  # value = <OptMethod.slackGN: 9>
-    squaredPenalty: typing.ClassVar[OptMethod]  # value = <OptMethod.squaredPenalty: 6>
+    singleSquaredPenalty: typing.ClassVar[OptMethod]  # value = <OptMethod.singleSquaredPenalty: 9>
+    slackGN: typing.ClassVar[OptMethod]  # value = <OptMethod.slackGN: 10>
+    slackGN_Ipopt: typing.ClassVar[OptMethod]  # value = <OptMethod.slackGN_Ipopt: 13>
+    slackGN_logBarrier: typing.ClassVar[OptMethod]  # value = <OptMethod.slackGN_logBarrier: 7>
     @staticmethod
     def _pybind11_conduit_v1_(*args, **kwargs):
         ...
@@ -1469,7 +1547,12 @@ class OptMethod:
         ...
 class Quaternion:
     """
+    See the Quaternion Lecture Note https://www.user.tu-berlin.de/mtoussai/notes/quaternions.html for details
     """
+    w: float
+    x: float
+    y: float
+    z: float
     @staticmethod
     def _pybind11_conduit_v1_(*args, **kwargs):
         ...
@@ -1477,13 +1560,23 @@ class Quaternion:
         """
         non-initialized
         """
-    def append(self, q: Quaternion) -> None:
+    def __mul__(self, arg0: Quaternion) -> Quaternion:
+        """
+        concatenation (quaternion multiplication) of two transforms
+        """
+    def __neg__(self) -> Quaternion:
+        """
+        inverse quaternion
+        """
+    def __str__(self) -> str:
+        ...
+    def append(self, q: Quaternion) -> Quaternion:
         ...
     def applyOnPointArray(self, pts: arr) -> None:
         ...
-    def flipSign(self) -> None:
+    def asArr(self) -> arr:
         ...
-    def getArr(self) -> arr:
+    def flipSign(self) -> Quaternion:
         ...
     def getJacobian(self) -> arr:
         ...
@@ -1495,11 +1588,11 @@ class Quaternion:
         ...
     def getRollPitchYaw(self) -> arr:
         ...
-    def invert(self) -> None:
+    def invert(self) -> Quaternion:
         ...
     def multiply(self, f: float) -> None:
         ...
-    def normalize(self) -> None:
+    def normalize(self) -> Quaternion:
         ...
     def set(self, q: arr) -> Quaternion:
         ...
@@ -1540,11 +1633,17 @@ class RRT_PathFinder:
         """
         only after setProblem
         """
+    def setOptions(self, verbose: int = 0, stepsize: float = 0.1, subsamples: int = 4, maxIters: int = 5000, p_connect: float = 0.5, collisionTolerance: float = 0.0001, useBroadCollisions: bool = True) -> RRT_PathFinder:
+        """
+        set solver options
+        """
     def setProblem(self, Configuration: Config) -> None:
         ...
     def setStartGoal(self, starts: arr, goals: arr) -> None:
         ...
-    def solve(self) -> SolverReturn:
+    def solve(self, verbose: int = 1) -> SolverReturn:
+        ...
+    def view(self, pause: bool, message: str = None, play: bool = False) -> None:
         ...
 class ST:
     """
@@ -1807,11 +1906,13 @@ class Simulation:
         """
     def addSensor(self, sensorName: str, width: int = 640, height: int = 360, focalLength: float = -1.0, orthoAbsHeight: float = -1.0, zRange: arr = []) -> ...:
         ...
-    def attach(self, gripper: Frame, obj: Frame) -> None:
+    def attach(self, from: Frame, to: Frame) -> None:
         ...
     def depthData2pointCloud(self, arg0: numpy.ndarray[numpy.float32], arg1: list[float]) -> numpy.ndarray[numpy.float64]:
         ...
-    def detach(self, obj: Frame) -> None:
+    def detach(self, from: Frame, to: Frame) -> None:
+        ...
+    def getFreeFrames(self) -> list[Frame]:
         ...
     def getGripperWidth(self, gripperFrameName: str) -> float:
         ...
@@ -1821,7 +1922,7 @@ class Simulation:
         ...
     def getState(self) -> tuple:
         """
-        returns a 4-tuple or frame state, joint state, frame velocities (linear & angular), joint velocities
+        returns a 5-tuple of (time, q, qDot, freePos, freeVel)
         """
     def getTimeToSplineEnd(self) -> float:
         ...
@@ -1843,8 +1944,14 @@ class Simulation:
         """
         reset the spline reference, i.e., clear the current spline buffer and initialize it to constant spline at current position (to which setSplineRef can append)
         """
+    def resetTime(self, time: float = 1.0) -> None:
+        ...
     def selectSensor(self, sensorName: str) -> ...:
         ...
+    def setSimulateDepthNoise(self, _setSimulateDepthNoise: bool) -> None:
+        """
+        specify (boolean) on whether to simulate noise
+        """
     def setSplineRef(self, path: arr, times: arr, append: bool = True) -> None:
         """
         set the spline reference to generate motion
@@ -1852,9 +1959,9 @@ class Simulation:
         * times: array with single total duration, or time for each control point (times.N==path.d0)
         * append: append (with zero-velocity at append), or smoothly overwrite
         """
-    def setState(self, frameState: arr, jointState: arr = ..., frameVelocities: arr = ..., jointVelocities: arr = ...) -> None:
+    def setState(self, time: float, q: arr, qDot: arr, freePos: arr, freeVel: arr) -> None:
         ...
-    def step(self, u_control: arr, tau: float = 0.01, u_mode: ControlMode = ...) -> None:
+    def step(self, u_control: arr = ..., tau: float = 0.01, u_mode: ControlMode = ...) -> None:
         ...
 class SimulationEngine:
     """
@@ -1947,25 +2054,24 @@ class SolverReturn:
         ...
     def dict(self) -> dict:
         ...
-class TAMP_Provider:
-    """
-    TAMP_Provider
-    """
-    @staticmethod
-    def _pybind11_conduit_v1_(*args, **kwargs):
-        ...
 def compiled() -> str:
     """
     return a compile date+time version string
     """
-def default_Actions2KOMO_Translator() -> Actions2KOMO_Translator:
-    ...
-def default_TAMP_Provider(C: Config, lgp_config_file: str) -> TAMP_Provider:
+def default_LGP_TAMP_Abstraction(C: Config, lgp_config_file: str) -> LGP_TAMP_Abstraction:
     ...
 def depthImage2PointCloud(depth: numpy.ndarray[numpy.float32], fxycxy: arr) -> arr:
     """
     return the point cloud from the depth image
     """
+def get_NLP_Problem_names() -> StringA:
+    """
+    return all problem names
+    """
+def make_NLP_Problem(problem_name: ...) -> NLP:
+    """
+    create a benchmark NLP
+    """
 def params_add(*args, **kwargs) -> None:
     """
     add/set parameters
@@ -1978,6 +2084,10 @@ def params_file(filename: str) -> None:
     """
     add parameters from a file
     """
+def params_get() -> dict:
+    """
+    return parameters as dict
+    """
 def params_print() -> None:
     """
     print the parameters
@@ -1986,6 +2096,14 @@ def raiPath(arg0: str) -> ...:
     """
     get a path relative to rai base path
     """
+def rnd_seed(s: int) -> None:
+    """
+    seed rnd with s
+    """
+def rnd_seed_random() -> None:
+    """
+    seed rnd randomly
+    """
 def setRaiPath(arg0: str) -> None:
     """
     redefine the rai (or rai-robotModels) path

robotic/algo.pyi

@@ -0,0 +1,17 @@
+"""
+basic algorithmic methods
+"""
+from __future__ import annotations
+__all__ = ['box_filter', 'marching_cubes', 'trilinear_interpolate']
+def box_filter(grid_values: ..., width: int = 3) -> ...:
+    """
+    apply a box filter of given width (typically 3) -- use multiple times to approximate Gaussian filter
+    """
+def marching_cubes(grid_values: ..., size: arr) -> tuple[arr, uintA]:
+    """
+    use Lewiner's original Marching Cubes algorithm compute a zero-levelset mesh from a 3D tensor. Returned vertices are centered and assume given total box size
+    """
+def trilinear_interpolate(pts: arr, grid_values: ..., grid_res: arr) -> ...:
+    """
+    use trilinear interpolation to sample values from a 3D grid of values
+    """