"""
MobileRobots Advanced Robotics Navigation and Localization (ARNL)
Version 1.7.1

Copyright (C) 2004, 2005 ActivMedia Robotics LLC
Copyright (C) 2006, 2007, 2008, 2009 MobileRobots Inc.

All Rights Reserved.

MobileRobots Inc does not make any representations about the
suitability of this software for any purpose.  It is provided "as is"
without express or implied warranty.

The license for this software is distributed as LICENSE.txt in the top
level directory.

robots@mobilerobots.com
MobileRobots
10 Columbia Drive
Amherst, NH 03031
800-639-9481

"""
# This file was created automatically by SWIG 1.3.29.
# Don't modify this file, modify the SWIG interface instead.
# This file is compatible with both classic and new-style classes.

"""
Python wrapper library for BaseArnl
"""

import _BaseArnlPy
import new
new_instancemethod = new.instancemethod
def _swig_setattr_nondynamic(self,class_type,name,value,static=1):
    if (name == "thisown"): return self.this.own(value)
    if (name == "this"):
        if type(value).__name__ == 'PySwigObject':
            self.__dict__[name] = value
            return
    method = class_type.__swig_setmethods__.get(name,None)
    if method: return method(self,value)
    if (not static) or hasattr(self,name):
        self.__dict__[name] = value
    else:
        raise AttributeError("You cannot add attributes to %s" % self)

def _swig_setattr(self,class_type,name,value):
    return _swig_setattr_nondynamic(self,class_type,name,value,0)

def _swig_getattr(self,class_type,name):
    if (name == "thisown"): return self.this.own()
    method = class_type.__swig_getmethods__.get(name,None)
    if method: return method(self)
    raise AttributeError,name

def _swig_repr(self):
    try: strthis = "proxy of " + self.this.__repr__()
    except: strthis = ""
    return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)

import types
try:
    _object = types.ObjectType
    _newclass = 1
except AttributeError:
    class _object : pass
    _newclass = 0
del types


try:
    import weakref
    weakref_proxy = weakref.proxy
except:
    weakref_proxy = lambda x: x


MAKING_BASEARNL = _BaseArnlPy.MAKING_BASEARNL
class PySwigIterator(_object):
    """Proxy of C++ PySwigIterator class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, PySwigIterator, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, PySwigIterator, name)
    def __init__(self): raise AttributeError, "No constructor defined"
    __repr__ = _swig_repr
    __swig_destroy__ = _BaseArnlPy.delete_PySwigIterator
    __del__ = lambda self : None;
    def value(*args):
        """value(self) -> PyObject"""
        return _BaseArnlPy.PySwigIterator_value(*args)

    def incr(*args):
        """
        incr(self, size_t n=1) -> PySwigIterator
        incr(self) -> PySwigIterator
        """
        return _BaseArnlPy.PySwigIterator_incr(*args)

    def decr(*args):
        """
        decr(self, size_t n=1) -> PySwigIterator
        decr(self) -> PySwigIterator
        """
        return _BaseArnlPy.PySwigIterator_decr(*args)

    def distance(*args):
        """distance(self, PySwigIterator x) -> ptrdiff_t"""
        return _BaseArnlPy.PySwigIterator_distance(*args)

    def equal(*args):
        """equal(self, PySwigIterator x) -> bool"""
        return _BaseArnlPy.PySwigIterator_equal(*args)

    def copy(*args):
        """copy(self) -> PySwigIterator"""
        return _BaseArnlPy.PySwigIterator_copy(*args)

    def next(*args):
        """next(self) -> PyObject"""
        return _BaseArnlPy.PySwigIterator_next(*args)

    def previous(*args):
        """previous(self) -> PyObject"""
        return _BaseArnlPy.PySwigIterator_previous(*args)

    def advance(*args):
        """advance(self, ptrdiff_t n) -> PySwigIterator"""
        return _BaseArnlPy.PySwigIterator_advance(*args)

    def __eq__(*args):
        """__eq__(self, PySwigIterator x) -> bool"""
        return _BaseArnlPy.PySwigIterator___eq__(*args)

    def __ne__(*args):
        """__ne__(self, PySwigIterator x) -> bool"""
        return _BaseArnlPy.PySwigIterator___ne__(*args)

    def __iadd__(*args):
        """__iadd__(self, ptrdiff_t n) -> PySwigIterator"""
        return _BaseArnlPy.PySwigIterator___iadd__(*args)

    def __isub__(*args):
        """__isub__(self, ptrdiff_t n) -> PySwigIterator"""
        return _BaseArnlPy.PySwigIterator___isub__(*args)

    def __add__(*args):
        """__add__(self, ptrdiff_t n) -> PySwigIterator"""
        return _BaseArnlPy.PySwigIterator___add__(*args)

    def __sub__(*args):
        """
        __sub__(self, ptrdiff_t n) -> PySwigIterator
        __sub__(self, PySwigIterator x) -> ptrdiff_t
        """
        return _BaseArnlPy.PySwigIterator___sub__(*args)

    def __iter__(self): return self
PySwigIterator_swigregister = _BaseArnlPy.PySwigIterator_swigregister
PySwigIterator_swigregister(PySwigIterator)

import AriaPy
SWIG_IMPORTED_ARIA = _BaseArnlPy.SWIG_IMPORTED_ARIA
import ArNetworkingPy
SWIG_IMPORTED_ARNETWORKING = _BaseArnlPy.SWIG_IMPORTED_ARNETWORKING
class ArMultiRobotPoseAndRadius(_object):
    """Proxy of C++ ArMultiRobotPoseAndRadius class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArMultiRobotPoseAndRadius, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArMultiRobotPoseAndRadius, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, ArPose pose, double radius) -> ArMultiRobotPoseAndRadius
        __init__(self) -> ArMultiRobotPoseAndRadius
        """
        this = _BaseArnlPy.new_ArMultiRobotPoseAndRadius(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _BaseArnlPy.delete_ArMultiRobotPoseAndRadius
    __del__ = lambda self : None;
    def getX(*args):
        """getX(self) -> double"""
        return _BaseArnlPy.ArMultiRobotPoseAndRadius_getX(*args)

    def getY(*args):
        """getY(self) -> double"""
        return _BaseArnlPy.ArMultiRobotPoseAndRadius_getY(*args)

    def getTh(*args):
        """getTh(self) -> double"""
        return _BaseArnlPy.ArMultiRobotPoseAndRadius_getTh(*args)

    def getPose(*args):
        """getPose(self) -> ArPose"""
        return _BaseArnlPy.ArMultiRobotPoseAndRadius_getPose(*args)

    def getRadius(*args):
        """getRadius(self) -> double"""
        return _BaseArnlPy.ArMultiRobotPoseAndRadius_getRadius(*args)

ArMultiRobotPoseAndRadius_swigregister = _BaseArnlPy.ArMultiRobotPoseAndRadius_swigregister
ArMultiRobotPoseAndRadius_swigregister(ArMultiRobotPoseAndRadius)

class Arnl(_object):
    """Proxy of C++ Arnl class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Arnl, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Arnl, name)
    __repr__ = _swig_repr
    def init(*args):
        """init()"""
        return _BaseArnlPy.Arnl_init(*args)

    if _newclass:init = staticmethod(init)
    __swig_getmethods__["init"] = lambda x: init
    def getTypicalParamFileName(*args):
        """getTypicalParamFileName() -> char"""
        return _BaseArnlPy.Arnl_getTypicalParamFileName(*args)

    if _newclass:getTypicalParamFileName = staticmethod(getTypicalParamFileName)
    __swig_getmethods__["getTypicalParamFileName"] = lambda x: getTypicalParamFileName
    def getTypicalDefaultParamFileName(*args):
        """getTypicalDefaultParamFileName() -> char"""
        return _BaseArnlPy.Arnl_getTypicalDefaultParamFileName(*args)

    if _newclass:getTypicalDefaultParamFileName = staticmethod(getTypicalDefaultParamFileName)
    __swig_getmethods__["getTypicalDefaultParamFileName"] = lambda x: getTypicalDefaultParamFileName
    def __init__(self, *args): 
        """__init__(self) -> Arnl"""
        this = _BaseArnlPy.new_Arnl(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _BaseArnlPy.delete_Arnl
    __del__ = lambda self : None;
Arnl_swigregister = _BaseArnlPy.Arnl_swigregister
Arnl_swigregister(Arnl)

def Arnl_init(*args):
  """Arnl_init()"""
  return _BaseArnlPy.Arnl_init(*args)

def Arnl_getTypicalParamFileName(*args):
  """Arnl_getTypicalParamFileName() -> char"""
  return _BaseArnlPy.Arnl_getTypicalParamFileName(*args)

def Arnl_getTypicalDefaultParamFileName(*args):
  """Arnl_getTypicalDefaultParamFileName() -> char"""
  return _BaseArnlPy.Arnl_getTypicalDefaultParamFileName(*args)

class ArBaseLocalizationTask(AriaPy.ArASyncTask):
    """Proxy of C++ ArBaseLocalizationTask class"""
    __swig_setmethods__ = {}
    for _s in [AriaPy.ArASyncTask]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArBaseLocalizationTask, name, value)
    __swig_getmethods__ = {}
    for _s in [AriaPy.ArASyncTask]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArBaseLocalizationTask, name)
    def __init__(self): raise AttributeError, "No constructor defined"
    __repr__ = _swig_repr
    NOT_INITIALIZED = _BaseArnlPy.ArBaseLocalizationTask_NOT_INITIALIZED
    LOCALIZATION_FAILED = _BaseArnlPy.ArBaseLocalizationTask_LOCALIZATION_FAILED
    LOCALIZATION_SUCCESS = _BaseArnlPy.ArBaseLocalizationTask_LOCALIZATION_SUCCESS
    LOCALIZATION_INIT_COMPUTING = _BaseArnlPy.ArBaseLocalizationTask_LOCALIZATION_INIT_COMPUTING
    LOCALIZATION_MOVE_COMPUTING = _BaseArnlPy.ArBaseLocalizationTask_LOCALIZATION_MOVE_COMPUTING
    LOCALIZATION_IDLE = _BaseArnlPy.ArBaseLocalizationTask_LOCALIZATION_IDLE
    INVALID = _BaseArnlPy.ArBaseLocalizationTask_INVALID
    def findLocalizationMeanVar(*args):
        """findLocalizationMeanVar(self, ArPose mean, ArMatrix var) -> bool"""
        return _BaseArnlPy.ArBaseLocalizationTask_findLocalizationMeanVar(*args)

    def setCorrectRobotFlag(*args):
        """setCorrectRobotFlag(self, bool f)"""
        return _BaseArnlPy.ArBaseLocalizationTask_setCorrectRobotFlag(*args)

    def setRobotPose(*args):
        """
        setRobotPose(self, ArPose pose, ArPose spread=ArPose(-1., -1., -1.), int nSam=-1)
        setRobotPose(self, ArPose pose, ArPose spread=ArPose(-1., -1., -1.))
        setRobotPose(self, ArPose pose)
        """
        return _BaseArnlPy.ArBaseLocalizationTask_setRobotPose(*args)

    def getRobotIsLostFlag(*args):
        """getRobotIsLostFlag(self) -> bool"""
        return _BaseArnlPy.ArBaseLocalizationTask_getRobotIsLostFlag(*args)

    def getRobotHome(*args):
        """getRobotHome(self) -> ArPose"""
        return _BaseArnlPy.ArBaseLocalizationTask_getRobotHome(*args)

    def getRobotHomeCallback(*args):
        """getRobotHomeCallback(self) -> ArRetFunctor<(ArPose)>"""
        return _BaseArnlPy.ArBaseLocalizationTask_getRobotHomeCallback(*args)

    def getHomePose(*args):
        """getHomePose(self) -> ArPose"""
        return _BaseArnlPy.ArBaseLocalizationTask_getHomePose(*args)

    def localizeRobotAtHomeBlocking(*args):
        """
        localizeRobotAtHomeBlocking(self, double distSpread, double angleSpread) -> bool
        localizeRobotAtHomeBlocking(self) -> bool
        """
        return _BaseArnlPy.ArBaseLocalizationTask_localizeRobotAtHomeBlocking(*args)

    def getCurrentSamplePoses(*args):
        """getCurrentSamplePoses(self) -> ArPoseList"""
        return _BaseArnlPy.ArBaseLocalizationTask_getCurrentSamplePoses(*args)

    def getState(*args):
        """getState(self) -> int"""
        return _BaseArnlPy.ArBaseLocalizationTask_getState(*args)

    def getLocalizationScore(*args):
        """getLocalizationScore(self) -> double"""
        return _BaseArnlPy.ArBaseLocalizationTask_getLocalizationScore(*args)

    def getLocalizationThreshold(*args):
        """getLocalizationThreshold(self) -> double"""
        return _BaseArnlPy.ArBaseLocalizationTask_getLocalizationThreshold(*args)

    def checkLocalizationIdle(*args):
        """checkLocalizationIdle(self) -> bool"""
        return _BaseArnlPy.ArBaseLocalizationTask_checkLocalizationIdle(*args)

    def setLocalizationIdle(*args):
        """setLocalizationIdle(self, bool f)"""
        return _BaseArnlPy.ArBaseLocalizationTask_setLocalizationIdle(*args)

    def setLocalizationThreshold(*args):
        """setLocalizationThreshold(self, double t)"""
        return _BaseArnlPy.ArBaseLocalizationTask_setLocalizationThreshold(*args)

    def getEncoderToLocalizationTransform(*args):
        """getEncoderToLocalizationTransform(self) -> ArTransform"""
        return _BaseArnlPy.ArBaseLocalizationTask_getEncoderToLocalizationTransform(*args)

    def getName(*args):
        """getName(self) -> char"""
        return _BaseArnlPy.ArBaseLocalizationTask_getName(*args)

    def getPoseInterpPosition(*args):
        """getPoseInterpPosition(self, ArTime timeStamp, ArPose position) -> int"""
        return _BaseArnlPy.ArBaseLocalizationTask_getPoseInterpPosition(*args)

    def getPoseInterpPositionCallback(*args):
        """getPoseInterpPositionCallback(self) -> ArRetFunctor2<(int,ArTime,p.ArPose)>"""
        return _BaseArnlPy.ArBaseLocalizationTask_getPoseInterpPositionCallback(*args)

    def convertLLA2RobotCoords(*args):
        """
        convertLLA2RobotCoords(self, double lat, double lon, double alt, double ea, double no, 
            double up) -> bool
        """
        return _BaseArnlPy.ArBaseLocalizationTask_convertLLA2RobotCoords(*args)

    def convertRobot2LLACoords(*args):
        """
        convertRobot2LLACoords(self, double ea, double no, double up, double lat, double lon, 
            double alt) -> bool
        """
        return _BaseArnlPy.ArBaseLocalizationTask_convertRobot2LLACoords(*args)

    __swig_destroy__ = _BaseArnlPy.delete_ArBaseLocalizationTask
    __del__ = lambda self : None;
ArBaseLocalizationTask_swigregister = _BaseArnlPy.ArBaseLocalizationTask_swigregister
ArBaseLocalizationTask_swigregister(ArBaseLocalizationTask)

class ArPathPlanningTask(AriaPy.ArASyncTask):
    """Proxy of C++ ArPathPlanningTask class"""
    __swig_setmethods__ = {}
    for _s in [AriaPy.ArASyncTask]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArPathPlanningTask, name, value)
    __swig_getmethods__ = {}
    for _s in [AriaPy.ArASyncTask]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArPathPlanningTask, name)
    __repr__ = _swig_repr
    NOT_INITIALIZED = _BaseArnlPy.ArPathPlanningTask_NOT_INITIALIZED
    PLANNING_PATH = _BaseArnlPy.ArPathPlanningTask_PLANNING_PATH
    MOVING_TO_GOAL = _BaseArnlPy.ArPathPlanningTask_MOVING_TO_GOAL
    REACHED_GOAL = _BaseArnlPy.ArPathPlanningTask_REACHED_GOAL
    FAILED_PLAN = _BaseArnlPy.ArPathPlanningTask_FAILED_PLAN
    FAILED_MOVE = _BaseArnlPy.ArPathPlanningTask_FAILED_MOVE
    ABORTED_PATHPLAN = _BaseArnlPy.ArPathPlanningTask_ABORTED_PATHPLAN
    INVALID = _BaseArnlPy.ArPathPlanningTask_INVALID
    NO_LOCAL_PLAN_GFD = _BaseArnlPy.ArPathPlanningTask_NO_LOCAL_PLAN_GFD
    NO_LOCAL_PLAN_LFD = _BaseArnlPy.ArPathPlanningTask_NO_LOCAL_PLAN_LFD
    NO_LOCAL_PLAN = _BaseArnlPy.ArPathPlanningTask_NO_LOCAL_PLAN
    GOAL_OCCUPIED = _BaseArnlPy.ArPathPlanningTask_GOAL_OCCUPIED
    NO_MOVE = _BaseArnlPy.ArPathPlanningTask_NO_MOVE
    OBSTACLE_TOO_CLOSE = _BaseArnlPy.ArPathPlanningTask_OBSTACLE_TOO_CLOSE
    COMPLETELY_BLOCKED = _BaseArnlPy.ArPathPlanningTask_COMPLETELY_BLOCKED
    GOT_PLAN_AND_VEL_HEADING = _BaseArnlPy.ArPathPlanningTask_GOT_PLAN_AND_VEL_HEADING
    GOT_PLAN_AND_VELS = _BaseArnlPy.ArPathPlanningTask_GOT_PLAN_AND_VELS
    GOT_BLOCKED_PLAN_AND_VEL_HEADING = _BaseArnlPy.ArPathPlanningTask_GOT_BLOCKED_PLAN_AND_VEL_HEADING
    GOT_BLOCKED_PLAN_AND_VELS = _BaseArnlPy.ArPathPlanningTask_GOT_BLOCKED_PLAN_AND_VELS
    NEITHER = _BaseArnlPy.ArPathPlanningTask_NEITHER
    CURRENT = _BaseArnlPy.ArPathPlanningTask_CURRENT
    CUMULATIVE = _BaseArnlPy.ArPathPlanningTask_CUMULATIVE
    BOTH = _BaseArnlPy.ArPathPlanningTask_BOTH
    def __init__(self, *args): 
        """
        __init__(self, ArRobot robot, ArRangeDevice laser, ArRangeDevice sonar, 
            ArMapInterface m) -> ArPathPlanningTask
        __init__(self, ArRobot robot, ArRangeDevice sonar, ArMapInterface map) -> ArPathPlanningTask
        """
        this = _BaseArnlPy.new_ArPathPlanningTask(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _BaseArnlPy.delete_ArPathPlanningTask
    __del__ = lambda self : None;
    def pathPlanToPose(*args):
        """
        pathPlanToPose(self, ArPose goal, bool headingFlag, bool printFlag=True) -> bool
        pathPlanToPose(self, ArPose goal, bool headingFlag) -> bool
        """
        return _BaseArnlPy.ArPathPlanningTask_pathPlanToPose(*args)

    def pathPlanToGoal(*args):
        """
        pathPlanToGoal(self, char goalname, bool strictGoalTypeMatching=True) -> bool
        pathPlanToGoal(self, char goalname) -> bool
        """
        return _BaseArnlPy.ArPathPlanningTask_pathPlanToGoal(*args)

    def startPathPlanToLocalPose(*args):
        """startPathPlanToLocalPose(self, bool printFlag) -> bool"""
        return _BaseArnlPy.ArPathPlanningTask_startPathPlanToLocalPose(*args)

    def continuePathPlanToLocalPose(*args):
        """
        continuePathPlanToLocalPose(self, ArPose goal, bool headingFlag, bool printFlag=True) -> bool
        continuePathPlanToLocalPose(self, ArPose goal, bool headingFlag) -> bool
        """
        return _BaseArnlPy.ArPathPlanningTask_continuePathPlanToLocalPose(*args)

    def endPathPlanToLocalPose(*args):
        """endPathPlanToLocalPose(self, bool printFlag) -> bool"""
        return _BaseArnlPy.ArPathPlanningTask_endPathPlanToLocalPose(*args)

    def getPathPlanAction(*args):
        """getPathPlanAction(self) -> ArActionPlanAndMoveToGoal"""
        return _BaseArnlPy.ArPathPlanningTask_getPathPlanAction(*args)

    def getPathPlanActionGroup(*args):
        """getPathPlanActionGroup(self) -> ArActionGroup"""
        return _BaseArnlPy.ArPathPlanningTask_getPathPlanActionGroup(*args)

    def setPathPlanActionGroup(*args):
        """
        setPathPlanActionGroup(self, ArActionGroup group, bool takeOwnershipOfGroup=False)
        setPathPlanActionGroup(self, ArActionGroup group)
        """
        return _BaseArnlPy.ArPathPlanningTask_setPathPlanActionGroup(*args)

    def loadParamFile(*args):
        """loadParamFile(self, char file) -> bool"""
        return _BaseArnlPy.ArPathPlanningTask_loadParamFile(*args)

    def getSafeCollisionRange(*args):
        """getSafeCollisionRange(self) -> double"""
        return _BaseArnlPy.ArPathPlanningTask_getSafeCollisionRange(*args)

    def saveParams(*args):
        """saveParams(self, char filename) -> bool"""
        return _BaseArnlPy.ArPathPlanningTask_saveParams(*args)

    def addGoalDoneCB(*args):
        """addGoalDoneCB(self, ArFunctor1<(ArPose)> functor)"""
        return _BaseArnlPy.ArPathPlanningTask_addGoalDoneCB(*args)

    def remGoalDoneCB(*args):
        """remGoalDoneCB(self, ArFunctor1<(ArPose)> functor)"""
        return _BaseArnlPy.ArPathPlanningTask_remGoalDoneCB(*args)

    def addGoalFailedCB(*args):
        """addGoalFailedCB(self, ArFunctor1<(ArPose)> functor)"""
        return _BaseArnlPy.ArPathPlanningTask_addGoalFailedCB(*args)

    def remGoalFailedCB(*args):
        """remGoalFailedCB(self, ArFunctor1<(ArPose)> functor)"""
        return _BaseArnlPy.ArPathPlanningTask_remGoalFailedCB(*args)

    def addGoalInterruptedCB(*args):
        """addGoalInterruptedCB(self, ArFunctor1<(ArPose)> functor)"""
        return _BaseArnlPy.ArPathPlanningTask_addGoalInterruptedCB(*args)

    def remGoalInterruptedCB(*args):
        """remGoalInterruptedCB(self, ArFunctor1<(ArPose)> functor)"""
        return _BaseArnlPy.ArPathPlanningTask_remGoalInterruptedCB(*args)

    def addNewGoalCB(*args):
        """addNewGoalCB(self, ArFunctor1<(ArPose)> functor)"""
        return _BaseArnlPy.ArPathPlanningTask_addNewGoalCB(*args)

    def remNewGoalCB(*args):
        """remNewGoalCB(self, ArFunctor1<(ArPose)> functor)"""
        return _BaseArnlPy.ArPathPlanningTask_remNewGoalCB(*args)

    def addGoalFinishedCB(*args):
        """addGoalFinishedCB(self, ArFunctor functor)"""
        return _BaseArnlPy.ArPathPlanningTask_addGoalFinishedCB(*args)

    def remGoalFinishedCB(*args):
        """remGoalFinishedCB(self, ArFunctor functor)"""
        return _BaseArnlPy.ArPathPlanningTask_remGoalFinishedCB(*args)

    def addPlainNewGoalCB(*args):
        """
        addPlainNewGoalCB(self, ArFunctor functor, int position=50)
        addPlainNewGoalCB(self, ArFunctor functor)
        """
        return _BaseArnlPy.ArPathPlanningTask_addPlainNewGoalCB(*args)

    def remPlainNewGoalCB(*args):
        """remPlainNewGoalCB(self, ArFunctor functor)"""
        return _BaseArnlPy.ArPathPlanningTask_remPlainNewGoalCB(*args)

    def addPlainGoalFinishedCB(*args):
        """
        addPlainGoalFinishedCB(self, ArFunctor functor, int position=50)
        addPlainGoalFinishedCB(self, ArFunctor functor)
        """
        return _BaseArnlPy.ArPathPlanningTask_addPlainGoalFinishedCB(*args)

    def remPlainGoalFinishedCB(*args):
        """remPlainGoalFinishedCB(self, ArFunctor functor)"""
        return _BaseArnlPy.ArPathPlanningTask_remPlainGoalFinishedCB(*args)

    def addPlainGoalDoneCB(*args):
        """
        addPlainGoalDoneCB(self, ArFunctor functor, int position=50)
        addPlainGoalDoneCB(self, ArFunctor functor)
        """
        return _BaseArnlPy.ArPathPlanningTask_addPlainGoalDoneCB(*args)

    def remPlainGoalDoneCB(*args):
        """remPlainGoalDoneCB(self, ArFunctor functor)"""
        return _BaseArnlPy.ArPathPlanningTask_remPlainGoalDoneCB(*args)

    def addPlainGoalFailedCB(*args):
        """
        addPlainGoalFailedCB(self, ArFunctor functor, int position=50)
        addPlainGoalFailedCB(self, ArFunctor functor)
        """
        return _BaseArnlPy.ArPathPlanningTask_addPlainGoalFailedCB(*args)

    def remPlainGoalFailedCB(*args):
        """remPlainGoalFailedCB(self, ArFunctor functor)"""
        return _BaseArnlPy.ArPathPlanningTask_remPlainGoalFailedCB(*args)

    def addPlainGoalInterruptedCB(*args):
        """
        addPlainGoalInterruptedCB(self, ArFunctor functor, int position=50)
        addPlainGoalInterruptedCB(self, ArFunctor functor)
        """
        return _BaseArnlPy.ArPathPlanningTask_addPlainGoalInterruptedCB(*args)

    def remPlainGoalInterruptedCB(*args):
        """remPlainGoalInterruptedCB(self, ArFunctor functor)"""
        return _BaseArnlPy.ArPathPlanningTask_remPlainGoalInterruptedCB(*args)

    def trackingFailed(*args):
        """trackingFailed(self, int failedTimes)"""
        return _BaseArnlPy.ArPathPlanningTask_trackingFailed(*args)

    def cancelPathPlan(*args):
        """cancelPathPlan(self)"""
        return _BaseArnlPy.ArPathPlanningTask_cancelPathPlan(*args)

    def setVerboseFlag(*args):
        """setVerboseFlag(self, bool f)"""
        return _BaseArnlPy.ArPathPlanningTask_setVerboseFlag(*args)

    def getCurrentGoal(*args):
        """getCurrentGoal(self) -> ArPose"""
        return _BaseArnlPy.ArPathPlanningTask_getCurrentGoal(*args)

    def getInitializedFlag(*args):
        """getInitializedFlag(self) -> bool"""
        return _BaseArnlPy.ArPathPlanningTask_getInitializedFlag(*args)

    def getVerboseFlag(*args):
        """getVerboseFlag(self) -> bool"""
        return _BaseArnlPy.ArPathPlanningTask_getVerboseFlag(*args)

    def getState(*args):
        """getState(self) -> int"""
        return _BaseArnlPy.ArPathPlanningTask_getState(*args)

    def getFailureString(*args):
        """getFailureString(self, char str, size_t len)"""
        return _BaseArnlPy.ArPathPlanningTask_getFailureString(*args)

    def getStatusString(*args):
        """getStatusString(self, char str, size_t len)"""
        return _BaseArnlPy.ArPathPlanningTask_getStatusString(*args)

    def getCurrentPath(*args):
        """
        getCurrentPath(self, ArPose from, bool local=False) -> ArPoseList
        getCurrentPath(self, ArPose from) -> ArPoseList
        """
        return _BaseArnlPy.ArPathPlanningTask_getCurrentPath(*args)

    def getAriaMap(*args):
        """getAriaMap(self) -> ArMapInterface"""
        return _BaseArnlPy.ArPathPlanningTask_getAriaMap(*args)

    def getUseLaserFlag(*args):
        """getUseLaserFlag(self) -> bool"""
        return _BaseArnlPy.ArPathPlanningTask_getUseLaserFlag(*args)

    def getUseSonarFlag(*args):
        """getUseSonarFlag(self) -> bool"""
        return _BaseArnlPy.ArPathPlanningTask_getUseSonarFlag(*args)

    def getMapChangedFlag(*args):
        """getMapChangedFlag(self) -> bool"""
        return _BaseArnlPy.ArPathPlanningTask_getMapChangedFlag(*args)

    def getUseOneWaysFlag(*args):
        """getUseOneWaysFlag(self) -> bool"""
        return _BaseArnlPy.ArPathPlanningTask_getUseOneWaysFlag(*args)

    def getMaxSpeed(*args):
        """getMaxSpeed(self) -> double"""
        return _BaseArnlPy.ArPathPlanningTask_getMaxSpeed(*args)

    def getMaxRotSpeed(*args):
        """getMaxRotSpeed(self) -> double"""
        return _BaseArnlPy.ArPathPlanningTask_getMaxRotSpeed(*args)

    def getCollisionRange(*args):
        """getCollisionRange(self) -> double"""
        return _BaseArnlPy.ArPathPlanningTask_getCollisionRange(*args)

    def getSlowSpeed(*args):
        """getSlowSpeed(self) -> double"""
        return _BaseArnlPy.ArPathPlanningTask_getSlowSpeed(*args)

    def getFastSpeed(*args):
        """getFastSpeed(self) -> double"""
        return _BaseArnlPy.ArPathPlanningTask_getFastSpeed(*args)

    def getSideClearanceAtSlowSpeed(*args):
        """getSideClearanceAtSlowSpeed(self) -> double"""
        return _BaseArnlPy.ArPathPlanningTask_getSideClearanceAtSlowSpeed(*args)

    def getSideClearanceAtFastSpeed(*args):
        """getSideClearanceAtFastSpeed(self) -> double"""
        return _BaseArnlPy.ArPathPlanningTask_getSideClearanceAtFastSpeed(*args)

    def getFrontClearance(*args):
        """getFrontClearance(self) -> double"""
        return _BaseArnlPy.ArPathPlanningTask_getFrontClearance(*args)

    def getFrontPaddingAtSlowSpeed(*args):
        """getFrontPaddingAtSlowSpeed(self) -> double"""
        return _BaseArnlPy.ArPathPlanningTask_getFrontPaddingAtSlowSpeed(*args)

    def getFrontPaddingAtFastSpeed(*args):
        """getFrontPaddingAtFastSpeed(self) -> double"""
        return _BaseArnlPy.ArPathPlanningTask_getFrontPaddingAtFastSpeed(*args)

    def getSuperMaxTransDecel(*args):
        """getSuperMaxTransDecel(self) -> double"""
        return _BaseArnlPy.ArPathPlanningTask_getSuperMaxTransDecel(*args)

    def getEmergencyMaxTransDecel(*args):
        """getEmergencyMaxTransDecel(self) -> double"""
        return _BaseArnlPy.ArPathPlanningTask_getEmergencyMaxTransDecel(*args)

    def getWidth(*args):
        """getWidth(self) -> double"""
        return _BaseArnlPy.ArPathPlanningTask_getWidth(*args)

    def getLength(*args):
        """getLength(self) -> double"""
        return _BaseArnlPy.ArPathPlanningTask_getLength(*args)

    def getPlanMapResolution(*args):
        """getPlanMapResolution(self) -> double"""
        return _BaseArnlPy.ArPathPlanningTask_getPlanMapResolution(*args)

    def getPlanFreeSpace(*args):
        """getPlanFreeSpace(self) -> double"""
        return _BaseArnlPy.ArPathPlanningTask_getPlanFreeSpace(*args)

    def getHeadingWt(*args):
        """getHeadingWt(self) -> double"""
        return _BaseArnlPy.ArPathPlanningTask_getHeadingWt(*args)

    def getDistanceWt(*args):
        """getDistanceWt(self) -> double"""
        return _BaseArnlPy.ArPathPlanningTask_getDistanceWt(*args)

    def getVelocityWt(*args):
        """getVelocityWt(self) -> double"""
        return _BaseArnlPy.ArPathPlanningTask_getVelocityWt(*args)

    def getSmoothingWt(*args):
        """getSmoothingWt(self) -> double"""
        return _BaseArnlPy.ArPathPlanningTask_getSmoothingWt(*args)

    def getLinVelIncrements(*args):
        """getLinVelIncrements(self) -> int"""
        return _BaseArnlPy.ArPathPlanningTask_getLinVelIncrements(*args)

    def getRotVelIncrements(*args):
        """getRotVelIncrements(self) -> int"""
        return _BaseArnlPy.ArPathPlanningTask_getRotVelIncrements(*args)

    def getSmoothSize(*args):
        """getSmoothSize(self) -> int"""
        return _BaseArnlPy.ArPathPlanningTask_getSmoothSize(*args)

    def getObsThreshold(*args):
        """getObsThreshold(self) -> double"""
        return _BaseArnlPy.ArPathPlanningTask_getObsThreshold(*args)

    def getMaxExpansionFactor(*args):
        """getMaxExpansionFactor(self) -> double"""
        return _BaseArnlPy.ArPathPlanningTask_getMaxExpansionFactor(*args)

    def getUseCollisionRangeForPlanningFlag(*args):
        """getUseCollisionRangeForPlanningFlag(self) -> bool"""
        return _BaseArnlPy.ArPathPlanningTask_getUseCollisionRangeForPlanningFlag(*args)

    def getGoalDistanceTolerance(*args):
        """getGoalDistanceTolerance(self) -> double"""
        return _BaseArnlPy.ArPathPlanningTask_getGoalDistanceTolerance(*args)

    def getGoalAngleTolerance(*args):
        """getGoalAngleTolerance(self) -> double"""
        return _BaseArnlPy.ArPathPlanningTask_getGoalAngleTolerance(*args)

    def getGoalSpeed(*args):
        """getGoalSpeed(self) -> double"""
        return _BaseArnlPy.ArPathPlanningTask_getGoalSpeed(*args)

    def getGoalRotSpeed(*args):
        """getGoalRotSpeed(self) -> double"""
        return _BaseArnlPy.ArPathPlanningTask_getGoalRotSpeed(*args)

    def getGoalTransAccel(*args):
        """getGoalTransAccel(self) -> double"""
        return _BaseArnlPy.ArPathPlanningTask_getGoalTransAccel(*args)

    def getGoalRotAccel(*args):
        """getGoalRotAccel(self) -> double"""
        return _BaseArnlPy.ArPathPlanningTask_getGoalRotAccel(*args)

    def getGoalTransDecel(*args):
        """getGoalTransDecel(self) -> double"""
        return _BaseArnlPy.ArPathPlanningTask_getGoalTransDecel(*args)

    def getGoalRotDecel(*args):
        """getGoalRotDecel(self) -> double"""
        return _BaseArnlPy.ArPathPlanningTask_getGoalRotDecel(*args)

    def getGoalSwitchTime(*args):
        """getGoalSwitchTime(self) -> double"""
        return _BaseArnlPy.ArPathPlanningTask_getGoalSwitchTime(*args)

    def getGoalUseEncoderFlag(*args):
        """getGoalUseEncoderFlag(self) -> bool"""
        return _BaseArnlPy.ArPathPlanningTask_getGoalUseEncoderFlag(*args)

    def getGoalOccupiedFailDistance(*args):
        """getGoalOccupiedFailDistance(self) -> double"""
        return _BaseArnlPy.ArPathPlanningTask_getGoalOccupiedFailDistance(*args)

    def getLocalPathFailDistance(*args):
        """getLocalPathFailDistance(self) -> double"""
        return _BaseArnlPy.ArPathPlanningTask_getLocalPathFailDistance(*args)

    def getHeadingRotSpeed(*args):
        """getHeadingRotSpeed(self) -> double"""
        return _BaseArnlPy.ArPathPlanningTask_getHeadingRotSpeed(*args)

    def getHeadingRotAccel(*args):
        """getHeadingRotAccel(self) -> double"""
        return _BaseArnlPy.ArPathPlanningTask_getHeadingRotAccel(*args)

    def getHeadingRotDecel(*args):
        """getHeadingRotDecel(self) -> double"""
        return _BaseArnlPy.ArPathPlanningTask_getHeadingRotDecel(*args)

    def getSecsToFail(*args):
        """getSecsToFail(self) -> int"""
        return _BaseArnlPy.ArPathPlanningTask_getSecsToFail(*args)

    def getAlignSpeed(*args):
        """getAlignSpeed(self) -> double"""
        return _BaseArnlPy.ArPathPlanningTask_getAlignSpeed(*args)

    def getAlignAngle(*args):
        """getAlignAngle(self) -> double"""
        return _BaseArnlPy.ArPathPlanningTask_getAlignAngle(*args)

    def getSplineDegree(*args):
        """getSplineDegree(self) -> int"""
        return _BaseArnlPy.ArPathPlanningTask_getSplineDegree(*args)

    def getNumSplinePoints(*args):
        """getNumSplinePoints(self) -> int"""
        return _BaseArnlPy.ArPathPlanningTask_getNumSplinePoints(*args)

    def getPlanEverytimeFlag(*args):
        """getPlanEverytimeFlag(self) -> bool"""
        return _BaseArnlPy.ArPathPlanningTask_getPlanEverytimeFlag(*args)

    def getClearOnFailFlag(*args):
        """getClearOnFailFlag(self) -> bool"""
        return _BaseArnlPy.ArPathPlanningTask_getClearOnFailFlag(*args)

    def getUseEStopFlag(*args):
        """getUseEStopFlag(self) -> bool"""
        return _BaseArnlPy.ArPathPlanningTask_getUseEStopFlag(*args)

    def getCurvatureSpeedFactor(*args):
        """getCurvatureSpeedFactor(self) -> double"""
        return _BaseArnlPy.ArPathPlanningTask_getCurvatureSpeedFactor(*args)

    def getOneWayCost(*args):
        """getOneWayCost(self) -> double"""
        return _BaseArnlPy.ArPathPlanningTask_getOneWayCost(*args)

    def getCenterAwayCost(*args):
        """getCenterAwayCost(self) -> double"""
        return _BaseArnlPy.ArPathPlanningTask_getCenterAwayCost(*args)

    def getResistance(*args):
        """
        getResistance(self) -> short
        getResistance(self) -> double
        """
        return _BaseArnlPy.ArPathPlanningTask_getResistance(*args)

    def getUseResistanceFlag(*args):
        """
        getUseResistanceFlag(self) -> bool
        getUseResistanceFlag(self) -> double
        """
        return _BaseArnlPy.ArPathPlanningTask_getUseResistanceFlag(*args)

    def getMarkOldPathFactor(*args):
        """
        getMarkOldPathFactor(self) -> double
        getMarkOldPathFactor(self) -> double
        """
        return _BaseArnlPy.ArPathPlanningTask_getMarkOldPathFactor(*args)

    def getLogFlag(*args):
        """getLogFlag(self) -> bool"""
        return _BaseArnlPy.ArPathPlanningTask_getLogFlag(*args)

    def getPathPlanningLogLevel(*args):
        """getPathPlanningLogLevel(self) -> int"""
        return _BaseArnlPy.ArPathPlanningTask_getPathPlanningLogLevel(*args)

    def getMatchLengths(*args):
        """getMatchLengths(self) -> double"""
        return _BaseArnlPy.ArPathPlanningTask_getMatchLengths(*args)

    def getLocalPathPlanningFlag(*args):
        """getLocalPathPlanningFlag(self) -> bool"""
        return _BaseArnlPy.ArPathPlanningTask_getLocalPathPlanningFlag(*args)

    def setUseLaserFlag(*args):
        """setUseLaserFlag(self, bool f)"""
        return _BaseArnlPy.ArPathPlanningTask_setUseLaserFlag(*args)

    def setUseSonarFlag(*args):
        """setUseSonarFlag(self, bool f)"""
        return _BaseArnlPy.ArPathPlanningTask_setUseSonarFlag(*args)

    def setMapChangedFlag(*args):
        """setMapChangedFlag(self, bool f)"""
        return _BaseArnlPy.ArPathPlanningTask_setMapChangedFlag(*args)

    def setUseOneWaysFlag(*args):
        """setUseOneWaysFlag(self, bool f)"""
        return _BaseArnlPy.ArPathPlanningTask_setUseOneWaysFlag(*args)

    def setResistance(*args):
        """setResistance(self, short f)"""
        return _BaseArnlPy.ArPathPlanningTask_setResistance(*args)

    def setPlanDoneCallBack(*args):
        """setPlanDoneCallBack(self, ArFunctor prcb)"""
        return _BaseArnlPy.ArPathPlanningTask_setPlanDoneCallBack(*args)

    def setUseCollisionRangeForPlanningFlag(*args):
        """setUseCollisionRangeForPlanningFlag(self, bool f)"""
        return _BaseArnlPy.ArPathPlanningTask_setUseCollisionRangeForPlanningFlag(*args)

    def setMaxSpeed(*args):
        """setMaxSpeed(self, double f)"""
        return _BaseArnlPy.ArPathPlanningTask_setMaxSpeed(*args)

    def setMaxRotSpeed(*args):
        """setMaxRotSpeed(self, double f)"""
        return _BaseArnlPy.ArPathPlanningTask_setMaxRotSpeed(*args)

    def setCollisionRange(*args):
        """setCollisionRange(self, double f)"""
        return _BaseArnlPy.ArPathPlanningTask_setCollisionRange(*args)

    def setSlowSpeed(*args):
        """setSlowSpeed(self, double f)"""
        return _BaseArnlPy.ArPathPlanningTask_setSlowSpeed(*args)

    def setFastSpeed(*args):
        """setFastSpeed(self, double f)"""
        return _BaseArnlPy.ArPathPlanningTask_setFastSpeed(*args)

    def setSideClearanceAtSlowSpeed(*args):
        """setSideClearanceAtSlowSpeed(self, double f)"""
        return _BaseArnlPy.ArPathPlanningTask_setSideClearanceAtSlowSpeed(*args)

    def setSideClearanceAtFastSpeed(*args):
        """setSideClearanceAtFastSpeed(self, double f)"""
        return _BaseArnlPy.ArPathPlanningTask_setSideClearanceAtFastSpeed(*args)

    def setFrontClearance(*args):
        """setFrontClearance(self, double f)"""
        return _BaseArnlPy.ArPathPlanningTask_setFrontClearance(*args)

    def setFrontPaddingAtSlowSpeed(*args):
        """setFrontPaddingAtSlowSpeed(self, double f)"""
        return _BaseArnlPy.ArPathPlanningTask_setFrontPaddingAtSlowSpeed(*args)

    def setFrontPaddingAtFastSpeed(*args):
        """setFrontPaddingAtFastSpeed(self, double f)"""
        return _BaseArnlPy.ArPathPlanningTask_setFrontPaddingAtFastSpeed(*args)

    def setSuperMaxTransDecel(*args):
        """setSuperMaxTransDecel(self, double f)"""
        return _BaseArnlPy.ArPathPlanningTask_setSuperMaxTransDecel(*args)

    def setEmergencyMaxTransDecel(*args):
        """setEmergencyMaxTransDecel(self, double f)"""
        return _BaseArnlPy.ArPathPlanningTask_setEmergencyMaxTransDecel(*args)

    def setWidth(*args):
        """setWidth(self, double f)"""
        return _BaseArnlPy.ArPathPlanningTask_setWidth(*args)

    def setLength(*args):
        """setLength(self, double f)"""
        return _BaseArnlPy.ArPathPlanningTask_setLength(*args)

    def setPlanMapResolution(*args):
        """setPlanMapResolution(self, double f)"""
        return _BaseArnlPy.ArPathPlanningTask_setPlanMapResolution(*args)

    def setPlanFreeSpace(*args):
        """setPlanFreeSpace(self, double f)"""
        return _BaseArnlPy.ArPathPlanningTask_setPlanFreeSpace(*args)

    def setHeadingWt(*args):
        """setHeadingWt(self, double f)"""
        return _BaseArnlPy.ArPathPlanningTask_setHeadingWt(*args)

    def setDistanceWt(*args):
        """setDistanceWt(self, double f)"""
        return _BaseArnlPy.ArPathPlanningTask_setDistanceWt(*args)

    def setVelocityWt(*args):
        """setVelocityWt(self, double f)"""
        return _BaseArnlPy.ArPathPlanningTask_setVelocityWt(*args)

    def setSmoothingWt(*args):
        """setSmoothingWt(self, double f)"""
        return _BaseArnlPy.ArPathPlanningTask_setSmoothingWt(*args)

    def setLinVelIncrements(*args):
        """setLinVelIncrements(self, int f)"""
        return _BaseArnlPy.ArPathPlanningTask_setLinVelIncrements(*args)

    def setRotVelIncrements(*args):
        """setRotVelIncrements(self, int f)"""
        return _BaseArnlPy.ArPathPlanningTask_setRotVelIncrements(*args)

    def setSmoothWinSize(*args):
        """setSmoothWinSize(self, int f)"""
        return _BaseArnlPy.ArPathPlanningTask_setSmoothWinSize(*args)

    def setObsThreshold(*args):
        """setObsThreshold(self, double f)"""
        return _BaseArnlPy.ArPathPlanningTask_setObsThreshold(*args)

    def setMaxExpansionFactor(*args):
        """setMaxExpansionFactor(self, double f)"""
        return _BaseArnlPy.ArPathPlanningTask_setMaxExpansionFactor(*args)

    def setGoalDistanceTolerance(*args):
        """setGoalDistanceTolerance(self, double f)"""
        return _BaseArnlPy.ArPathPlanningTask_setGoalDistanceTolerance(*args)

    def setGoalAngleTolerance(*args):
        """setGoalAngleTolerance(self, double f)"""
        return _BaseArnlPy.ArPathPlanningTask_setGoalAngleTolerance(*args)

    def setGoalSpeed(*args):
        """setGoalSpeed(self, double f)"""
        return _BaseArnlPy.ArPathPlanningTask_setGoalSpeed(*args)

    def setGoalRotSpeed(*args):
        """setGoalRotSpeed(self, double f)"""
        return _BaseArnlPy.ArPathPlanningTask_setGoalRotSpeed(*args)

    def setGoalTransAccel(*args):
        """setGoalTransAccel(self, double f)"""
        return _BaseArnlPy.ArPathPlanningTask_setGoalTransAccel(*args)

    def setGoalRotAccel(*args):
        """setGoalRotAccel(self, double f)"""
        return _BaseArnlPy.ArPathPlanningTask_setGoalRotAccel(*args)

    def setGoalTransDecel(*args):
        """setGoalTransDecel(self, double f)"""
        return _BaseArnlPy.ArPathPlanningTask_setGoalTransDecel(*args)

    def setGoalRotDecel(*args):
        """setGoalRotDecel(self, double f)"""
        return _BaseArnlPy.ArPathPlanningTask_setGoalRotDecel(*args)

    def setGoalSwitchTime(*args):
        """setGoalSwitchTime(self, double f)"""
        return _BaseArnlPy.ArPathPlanningTask_setGoalSwitchTime(*args)

    def setGoalUseEncoderFlag(*args):
        """setGoalUseEncoderFlag(self, bool f)"""
        return _BaseArnlPy.ArPathPlanningTask_setGoalUseEncoderFlag(*args)

    def setGoalOccupiedFailDistance(*args):
        """setGoalOccupiedFailDistance(self, double f)"""
        return _BaseArnlPy.ArPathPlanningTask_setGoalOccupiedFailDistance(*args)

    def setHeadingRotSpeed(*args):
        """setHeadingRotSpeed(self, double f)"""
        return _BaseArnlPy.ArPathPlanningTask_setHeadingRotSpeed(*args)

    def setHeadingRotAccel(*args):
        """setHeadingRotAccel(self, double f)"""
        return _BaseArnlPy.ArPathPlanningTask_setHeadingRotAccel(*args)

    def setHeadingRotDecel(*args):
        """setHeadingRotDecel(self, double f)"""
        return _BaseArnlPy.ArPathPlanningTask_setHeadingRotDecel(*args)

    def setSecsToFail(*args):
        """setSecsToFail(self, int f)"""
        return _BaseArnlPy.ArPathPlanningTask_setSecsToFail(*args)

    def setAlignAngle(*args):
        """setAlignAngle(self, double f)"""
        return _BaseArnlPy.ArPathPlanningTask_setAlignAngle(*args)

    def setAlignSpeed(*args):
        """setAlignSpeed(self, double f)"""
        return _BaseArnlPy.ArPathPlanningTask_setAlignSpeed(*args)

    def setSplineDegree(*args):
        """setSplineDegree(self, int f)"""
        return _BaseArnlPy.ArPathPlanningTask_setSplineDegree(*args)

    def setNumSplinePoints(*args):
        """setNumSplinePoints(self, int f)"""
        return _BaseArnlPy.ArPathPlanningTask_setNumSplinePoints(*args)

    def setPlanEverytimeFlag(*args):
        """setPlanEverytimeFlag(self, bool f)"""
        return _BaseArnlPy.ArPathPlanningTask_setPlanEverytimeFlag(*args)

    def setClearOnFailFlag(*args):
        """setClearOnFailFlag(self, bool f)"""
        return _BaseArnlPy.ArPathPlanningTask_setClearOnFailFlag(*args)

    def setUseEStopFlag(*args):
        """setUseEStopFlag(self, bool f)"""
        return _BaseArnlPy.ArPathPlanningTask_setUseEStopFlag(*args)

    def setUseResistanceFlag(*args):
        """setUseResistanceFlag(self, bool f)"""
        return _BaseArnlPy.ArPathPlanningTask_setUseResistanceFlag(*args)

    def setMarkOldPathFactor(*args):
        """setMarkOldPathFactor(self, double f)"""
        return _BaseArnlPy.ArPathPlanningTask_setMarkOldPathFactor(*args)

    def setLogFlag(*args):
        """setLogFlag(self, bool f)"""
        return _BaseArnlPy.ArPathPlanningTask_setLogFlag(*args)

    def setLogLevel(*args):
        """setLogLevel(self, int f)"""
        return _BaseArnlPy.ArPathPlanningTask_setLogLevel(*args)

    def setMatchLengths(*args):
        """setMatchLengths(self, double f)"""
        return _BaseArnlPy.ArPathPlanningTask_setMatchLengths(*args)

    def setLocalPathPlanningFlag(*args):
        """setLocalPathPlanningFlag(self, bool f)"""
        return _BaseArnlPy.ArPathPlanningTask_setLocalPathPlanningFlag(*args)

    def setPlanParams(*args):
        """
        setPlanParams(self, double robotWidth, double robotLength, double frontClearance, 
            double sideClearance, double obsThreshold, 
            double maxLinAcc, double maxRotAcc, 
            double maxLinDec, double maxRotDec, double maxLinVel, 
            double maxRotVel, double headingWt, 
            double distanceWt, double velocityWt, double smoothingWt, 
            double gridRes, int nli, int nri, 
            int sws, double maxObsDistance, double goalDistTol, 
            double goalAngTol, double PlanFreeSpace, 
            int secsToFail, double alignAngle, double alignSpeed, 
            int splineDegree, int numSplinePoints, 
            double goalOccupiedFailDistance, double curvatureSpeedFactor, 
            bool useCollisionRangeForPlanningFlag, 
            double oneWayCost, double centerAwayCost, 
            double localPathFailDistance, 
            short resistance, double markOldPathFactor, 
            double matchLengths, bool checkInsideRadius)
        """
        return _BaseArnlPy.ArPathPlanningTask_setPlanParams(*args)

    def setMovementParams(*args):
        """
        setMovementParams(self, double linVel, double rotVel, double linAcc, double rotAcc, 
            double linDec, double rotDec)
        """
        return _BaseArnlPy.ArPathPlanningTask_setMovementParams(*args)

    def addRangeDevice(*args):
        """addRangeDevice(self, ArRangeDevice device, RangeType type)"""
        return _BaseArnlPy.ArPathPlanningTask_addRangeDevice(*args)

    def remRangeDevice(*args):
        """
        remRangeDevice(self, char name, RangeType type)
        remRangeDevice(self, ArRangeDevice device, RangeType type)
        """
        return _BaseArnlPy.ArPathPlanningTask_remRangeDevice(*args)

    def addGlobalPlanningRangeDevice(*args):
        """addGlobalPlanningRangeDevice(self, ArRangeDevice device, RangeType type)"""
        return _BaseArnlPy.ArPathPlanningTask_addGlobalPlanningRangeDevice(*args)

    def remGlobalPlanningRangeDevice(*args):
        """
        remGlobalPlanningRangeDevice(self, char name, RangeType type)
        remGlobalPlanningRangeDevice(self, ArRangeDevice device, RangeType type)
        """
        return _BaseArnlPy.ArPathPlanningTask_remGlobalPlanningRangeDevice(*args)

    def getRangeDeviceList(*args):
        """getRangeDeviceList(self) -> ArRangeDevicePtrList"""
        return _BaseArnlPy.ArPathPlanningTask_getRangeDeviceList(*args)

    def getCumRangeDeviceList(*args):
        """getCumRangeDeviceList(self) -> ArRangeDevicePtrList"""
        return _BaseArnlPy.ArPathPlanningTask_getCumRangeDeviceList(*args)

    def getGlobalPlanningRangeDeviceList(*args):
        """getGlobalPlanningRangeDeviceList(self) -> ArRangeDevicePtrList"""
        return _BaseArnlPy.ArPathPlanningTask_getGlobalPlanningRangeDeviceList(*args)

    def getGlobalPlanningCumRangeDeviceList(*args):
        """getGlobalPlanningCumRangeDeviceList(self) -> ArRangeDevicePtrList"""
        return _BaseArnlPy.ArPathPlanningTask_getGlobalPlanningCumRangeDeviceList(*args)

    def clearRangeDevices(*args):
        """clearRangeDevices(self)"""
        return _BaseArnlPy.ArPathPlanningTask_clearRangeDevices(*args)

    def clearGlobalPlanningRangeDevices(*args):
        """clearGlobalPlanningRangeDevices(self)"""
        return _BaseArnlPy.ArPathPlanningTask_clearGlobalPlanningRangeDevices(*args)

    def clearGlobalPlanningCumRangeDevices(*args):
        """clearGlobalPlanningCumRangeDevices(self, unsigned int cyt)"""
        return _BaseArnlPy.ArPathPlanningTask_clearGlobalPlanningCumRangeDevices(*args)

    def clearCumRangeDevices(*args):
        """clearCumRangeDevices(self, unsigned int cyt)"""
        return _BaseArnlPy.ArPathPlanningTask_clearCumRangeDevices(*args)

    def goalFailed(*args):
        """
        goalFailed(self, ArPose goal, char failureString="Failed going to goal", 
            PathPlanningState state=FAILED_MOVE)
        goalFailed(self, ArPose goal, char failureString="Failed going to goal")
        goalFailed(self, ArPose goal)
        """
        return _BaseArnlPy.ArPathPlanningTask_goalFailed(*args)

    def getLastMoveTime(*args):
        """getLastMoveTime(self) -> double"""
        return _BaseArnlPy.ArPathPlanningTask_getLastMoveTime(*args)

    def getLastLinearMoveTime(*args):
        """getLastLinearMoveTime(self) -> double"""
        return _BaseArnlPy.ArPathPlanningTask_getLastLinearMoveTime(*args)

    def setLastMoveTime(*args):
        """setLastMoveTime(self, double t)"""
        return _BaseArnlPy.ArPathPlanningTask_setLastMoveTime(*args)

    def setLastLinearMoveTime(*args):
        """setLastLinearMoveTime(self, double t)"""
        return _BaseArnlPy.ArPathPlanningTask_setLastLinearMoveTime(*args)

    def computeProgress(*args):
        """
        computeProgress(self, ArPose robotPose) -> double
        computeProgress(self) -> double
        """
        return _BaseArnlPy.ArPathPlanningTask_computeProgress(*args)

    def estimateTimeToGoal(*args):
        """
        estimateTimeToGoal(self, ArPose robotPose) -> double
        estimateTimeToGoal(self) -> double
        """
        return _BaseArnlPy.ArPathPlanningTask_estimateTimeToGoal(*args)

    def estimateDistanceToGoal(*args):
        """
        estimateDistanceToGoal(self, ArPose robotPose) -> double
        estimateDistanceToGoal(self) -> double
        """
        return _BaseArnlPy.ArPathPlanningTask_estimateDistanceToGoal(*args)

    def drawSearchRectangle(*args):
        """drawSearchRectangle(self, ArServerClient client, ArNetPacket packet)"""
        return _BaseArnlPy.ArPathPlanningTask_drawSearchRectangle(*args)

    def drawNewPoints(*args):
        """drawNewPoints(self, ArServerClient client, ArNetPacket packet)"""
        return _BaseArnlPy.ArPathPlanningTask_drawNewPoints(*args)

    def drawGridPoints(*args):
        """drawGridPoints(self, ArServerClient client, ArNetPacket packet)"""
        return _BaseArnlPy.ArPathPlanningTask_drawGridPoints(*args)

    def drawPathPoints(*args):
        """drawPathPoints(self, ArServerClient client, ArNetPacket packet)"""
        return _BaseArnlPy.ArPathPlanningTask_drawPathPoints(*args)

    def drawObsPoints(*args):
        """drawObsPoints(self, ArServerClient client, ArNetPacket packet)"""
        return _BaseArnlPy.ArPathPlanningTask_drawObsPoints(*args)

    def drawFailPoints(*args):
        """drawFailPoints(self, ArServerClient client, ArNetPacket packet)"""
        return _BaseArnlPy.ArPathPlanningTask_drawFailPoints(*args)

    def drawVelocityPath(*args):
        """drawVelocityPath(self, ArServerClient client, ArNetPacket packet)"""
        return _BaseArnlPy.ArPathPlanningTask_drawVelocityPath(*args)

    def drawRobotBounds(*args):
        """drawRobotBounds(self, ArServerClient client, ArNetPacket packet)"""
        return _BaseArnlPy.ArPathPlanningTask_drawRobotBounds(*args)

    def drawCollidePath(*args):
        """drawCollidePath(self, ArServerClient client, ArNetPacket packet)"""
        return _BaseArnlPy.ArPathPlanningTask_drawCollidePath(*args)

    def getLocalPathState(*args):
        """getLocalPathState(self) -> ArPathPlan::LocalPathState"""
        return _BaseArnlPy.ArPathPlanningTask_getLocalPathState(*args)

    def getDWAState(*args):
        """getDWAState(self) -> ArPathPlan::SearchVelocityState"""
        return _BaseArnlPy.ArPathPlanningTask_getDWAState(*args)

    def getCost(*args):
        """getCost(self) -> double"""
        return _BaseArnlPy.ArPathPlanningTask_getCost(*args)

    def getUtil(*args):
        """getUtil(self) -> double"""
        return _BaseArnlPy.ArPathPlanningTask_getUtil(*args)

    def getPathFromTo(*args):
        """getPathFromTo(self, ArPose from, ArPose to) -> ArPoseList"""
        return _BaseArnlPy.ArPathPlanningTask_getPathFromTo(*args)

    def addStateChangeCB(*args):
        """addStateChangeCB(self, ArFunctor cb)"""
        return _BaseArnlPy.ArPathPlanningTask_addStateChangeCB(*args)

    def remStateChangeCB(*args):
        """remStateChangeCB(self, ArFunctor cb)"""
        return _BaseArnlPy.ArPathPlanningTask_remStateChangeCB(*args)

    def getObsListPtr(*args):
        """getObsListPtr(self) -> ArPoseList"""
        return _BaseArnlPy.ArPathPlanningTask_getObsListPtr(*args)

    def addBlockedPathCB(*args):
        """addBlockedPathCB(self, ArFunctor1<(p.q(const).std::list<(ArPose,std::allocator<(ArPose)>)>)> cb)"""
        return _BaseArnlPy.ArPathPlanningTask_addBlockedPathCB(*args)

    def remBlockedPathCB(*args):
        """remBlockedPathCB(self, ArFunctor1<(p.q(const).std::list<(ArPose,std::allocator<(ArPose)>)>)> cb)"""
        return _BaseArnlPy.ArPathPlanningTask_remBlockedPathCB(*args)

    def addPlainBlockedPathCB(*args):
        """
        addPlainBlockedPathCB(self, ArFunctor functor, int position=50)
        addPlainBlockedPathCB(self, ArFunctor functor)
        """
        return _BaseArnlPy.ArPathPlanningTask_addPlainBlockedPathCB(*args)

    def remPlainBlockedPathCB(*args):
        """remPlainBlockedPathCB(self, ArFunctor functor)"""
        return _BaseArnlPy.ArPathPlanningTask_remPlainBlockedPathCB(*args)

    def invokeBlockedPathCB(*args):
        """invokeBlockedPathCB(self)"""
        return _BaseArnlPy.ArPathPlanningTask_invokeBlockedPathCB(*args)

    def getWaitingToFailFlag(*args):
        """getWaitingToFailFlag(self) -> bool"""
        return _BaseArnlPy.ArPathPlanningTask_getWaitingToFailFlag(*args)

ArPathPlanningTask_swigregister = _BaseArnlPy.ArPathPlanningTask_swigregister
ArPathPlanningTask_swigregister(ArPathPlanningTask)

class ArActionPlanAndMoveToGoal(AriaPy.ArAction):
    """Proxy of C++ ArActionPlanAndMoveToGoal class"""
    __swig_setmethods__ = {}
    for _s in [AriaPy.ArAction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArActionPlanAndMoveToGoal, name, value)
    __swig_getmethods__ = {}
    for _s in [AriaPy.ArAction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArActionPlanAndMoveToGoal, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, double maxVel, double maxRotVel, ArPathPlanningTask ppt, 
            ArRangeDevice laser, ArRangeDevice sonar) -> ArActionPlanAndMoveToGoal
        """
        this = _BaseArnlPy.new_ArActionPlanAndMoveToGoal(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _BaseArnlPy.delete_ArActionPlanAndMoveToGoal
    __del__ = lambda self : None;
    def fire(*args):
        """fire(self, ArActionDesired currentDesired) -> ArActionDesired"""
        return _BaseArnlPy.ArActionPlanAndMoveToGoal_fire(*args)

    def deactivate(*args):
        """deactivate(self)"""
        return _BaseArnlPy.ArActionPlanAndMoveToGoal_deactivate(*args)

    def setTotalVel(*args):
        """setTotalVel(self, double lvel, double avel)"""
        return _BaseArnlPy.ArActionPlanAndMoveToGoal_setTotalVel(*args)

    def setEndMoveParams(*args):
        """setEndMoveParams(self)"""
        return _BaseArnlPy.ArActionPlanAndMoveToGoal_setEndMoveParams(*args)

    def setHeadingParams(*args):
        """setHeadingParams(self)"""
        return _BaseArnlPy.ArActionPlanAndMoveToGoal_setHeadingParams(*args)

    def clearRangeDevices(*args):
        """clearRangeDevices(self)"""
        return _BaseArnlPy.ArActionPlanAndMoveToGoal_clearRangeDevices(*args)

    def clearCumRangeDevices(*args):
        """clearCumRangeDevices(self, unsigned int cyt)"""
        return _BaseArnlPy.ArActionPlanAndMoveToGoal_clearCumRangeDevices(*args)

    def setMaxVel(*args):
        """setMaxVel(self, double v)"""
        return _BaseArnlPy.ArActionPlanAndMoveToGoal_setMaxVel(*args)

    def setMaxRotVel(*args):
        """setMaxRotVel(self, double r)"""
        return _BaseArnlPy.ArActionPlanAndMoveToGoal_setMaxRotVel(*args)

    def setFailedTimes(*args):
        """setFailedTimes(self, int i)"""
        return _BaseArnlPy.ArActionPlanAndMoveToGoal_setFailedTimes(*args)

    def setRangeFactor(*args):
        """setRangeFactor(self, double r)"""
        return _BaseArnlPy.ArActionPlanAndMoveToGoal_setRangeFactor(*args)

    def setEndMoveFlag(*args):
        """setEndMoveFlag(self, bool f)"""
        return _BaseArnlPy.ArActionPlanAndMoveToGoal_setEndMoveFlag(*args)

    def setPlanState(*args):
        """setPlanState(self, LocalPlanningState s)"""
        return _BaseArnlPy.ArActionPlanAndMoveToGoal_setPlanState(*args)

    def setReplannedTimes(*args):
        """setReplannedTimes(self, int f)"""
        return _BaseArnlPy.ArActionPlanAndMoveToGoal_setReplannedTimes(*args)

    def getMaxVel(*args):
        """getMaxVel(self) -> double"""
        return _BaseArnlPy.ArActionPlanAndMoveToGoal_getMaxVel(*args)

    def getRotMaxVel(*args):
        """getRotMaxVel(self) -> double"""
        return _BaseArnlPy.ArActionPlanAndMoveToGoal_getRotMaxVel(*args)

    def getFailedTimes(*args):
        """getFailedTimes(self) -> int"""
        return _BaseArnlPy.ArActionPlanAndMoveToGoal_getFailedTimes(*args)

    def getRangeFactor(*args):
        """getRangeFactor(self) -> double"""
        return _BaseArnlPy.ArActionPlanAndMoveToGoal_getRangeFactor(*args)

    def getEndMoveFlag(*args):
        """getEndMoveFlag(self) -> bool"""
        return _BaseArnlPy.ArActionPlanAndMoveToGoal_getEndMoveFlag(*args)

    def getPlanState(*args):
        """getPlanState(self) -> int"""
        return _BaseArnlPy.ArActionPlanAndMoveToGoal_getPlanState(*args)

    def getReplannedTimes(*args):
        """getReplannedTimes(self) -> int"""
        return _BaseArnlPy.ArActionPlanAndMoveToGoal_getReplannedTimes(*args)

    def setCurrentDynamicParams(*args):
        """setCurrentDynamicParams(self, ArActionDesired curDesired)"""
        return _BaseArnlPy.ArActionPlanAndMoveToGoal_setCurrentDynamicParams(*args)

    def getFailedTimeRatio(*args):
        """getFailedTimeRatio(self) -> double"""
        return _BaseArnlPy.ArActionPlanAndMoveToGoal_getFailedTimeRatio(*args)

    def getDesired(*args):
        """getDesired(self) -> ArActionDesired"""
        return _BaseArnlPy.ArActionPlanAndMoveToGoal_getDesired(*args)

    def computeSafeDecel(*args):
        """
        computeSafeDecel(self, double obsDist, double linVel, double rotVel, double currentDecel, 
            bool eStopFlag, bool brakeFlag) -> double
        """
        return _BaseArnlPy.ArActionPlanAndMoveToGoal_computeSafeDecel(*args)

    def stop(*args):
        """stop(self, double obsDist, double linVel, double rotVel, double currentDecel) -> ArActionDesired"""
        return _BaseArnlPy.ArActionPlanAndMoveToGoal_stop(*args)

ArActionPlanAndMoveToGoal_swigregister = _BaseArnlPy.ArActionPlanAndMoveToGoal_swigregister
ArActionPlanAndMoveToGoal_swigregister(ArActionPlanAndMoveToGoal)

class ArGlobalReplanningRangeDevice(AriaPy.ArRangeDevice):
    """Proxy of C++ ArGlobalReplanningRangeDevice class"""
    __swig_setmethods__ = {}
    for _s in [AriaPy.ArRangeDevice]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArGlobalReplanningRangeDevice, name, value)
    __swig_getmethods__ = {}
    for _s in [AriaPy.ArRangeDevice]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArGlobalReplanningRangeDevice, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, ArPathPlanningTask pathTask, size_t currentBufferSize=10000, 
            size_t cumulativeBufferSize=10000, 
            char name="Global Replanning") -> ArGlobalReplanningRangeDevice
        __init__(self, ArPathPlanningTask pathTask, size_t currentBufferSize=10000, 
            size_t cumulativeBufferSize=10000) -> ArGlobalReplanningRangeDevice
        __init__(self, ArPathPlanningTask pathTask, size_t currentBufferSize=10000) -> ArGlobalReplanningRangeDevice
        __init__(self, ArPathPlanningTask pathTask) -> ArGlobalReplanningRangeDevice
        """
        this = _BaseArnlPy.new_ArGlobalReplanningRangeDevice(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _BaseArnlPy.delete_ArGlobalReplanningRangeDevice
    __del__ = lambda self : None;
    def clear(*args):
        """clear(self, ArPose pose)"""
        return _BaseArnlPy.ArGlobalReplanningRangeDevice_clear(*args)

    def addReadings(*args):
        """addReadings(self, ArPoseList readings)"""
        return _BaseArnlPy.ArGlobalReplanningRangeDevice_addReadings(*args)

ArGlobalReplanningRangeDevice_swigregister = _BaseArnlPy.ArGlobalReplanningRangeDevice_swigregister
ArGlobalReplanningRangeDevice_swigregister(ArGlobalReplanningRangeDevice)

class ArServerInfoPath(_object):
    """Proxy of C++ ArServerInfoPath class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerInfoPath, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerInfoPath, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, ArServerBase server, ArRobot robot, ArPathPlanningTask pathTask) -> ArServerInfoPath"""
        this = _BaseArnlPy.new_ArServerInfoPath(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _BaseArnlPy.delete_ArServerInfoPath
    __del__ = lambda self : None;
    def getPath(*args):
        """getPath(self, ArServerClient client, ArNetPacket packet)"""
        return _BaseArnlPy.ArServerInfoPath_getPath(*args)

    def getSearchRectangle(*args):
        """getSearchRectangle(self, ArServerClient client, ArNetPacket packet)"""
        return _BaseArnlPy.ArServerInfoPath_getSearchRectangle(*args)

    def addSearchRectangleDrawing(*args):
        """addSearchRectangleDrawing(self, ArServerInfoDrawings drawings)"""
        return _BaseArnlPy.ArServerInfoPath_addSearchRectangleDrawing(*args)

    def addControlCommands(*args):
        """addControlCommands(self, ArServerHandlerCommands handlerCommands)"""
        return _BaseArnlPy.ArServerInfoPath_addControlCommands(*args)

    def searchRectangleEnable(*args):
        """searchRectangleEnable(self)"""
        return _BaseArnlPy.ArServerInfoPath_searchRectangleEnable(*args)

    def searchRectangleDisable(*args):
        """searchRectangleDisable(self)"""
        return _BaseArnlPy.ArServerInfoPath_searchRectangleDisable(*args)

    def setSearchRectangleDrawingData(*args):
        """setSearchRectangleDrawingData(self, ArDrawingData data, bool takeOwnershipOfData)"""
        return _BaseArnlPy.ArServerInfoPath_setSearchRectangleDrawingData(*args)

ArServerInfoPath_swigregister = _BaseArnlPy.ArServerInfoPath_swigregister
ArServerInfoPath_swigregister(ArServerInfoPath)

class ArServerInfoLocalization(_object):
    """Proxy of C++ ArServerInfoLocalization class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerInfoLocalization, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerInfoLocalization, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, ArServerBase server, ArRobot robot, ArBaseLocalizationTask locTask) -> ArServerInfoLocalization"""
        this = _BaseArnlPy.new_ArServerInfoLocalization(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _BaseArnlPy.delete_ArServerInfoLocalization
    __del__ = lambda self : None;
    def getLocPoints(*args):
        """getLocPoints(self, ArServerClient client, ArNetPacket packet)"""
        return _BaseArnlPy.ArServerInfoLocalization_getLocPoints(*args)

    def getLocState(*args):
        """getLocState(self, ArServerClient client, ArNetPacket packet)"""
        return _BaseArnlPy.ArServerInfoLocalization_getLocState(*args)

    def addInitializingCB(*args):
        """
        addInitializingCB(self, ArFunctor functor, int position=50)
        addInitializingCB(self, ArFunctor functor)
        """
        return _BaseArnlPy.ArServerInfoLocalization_addInitializingCB(*args)

    def remInitializingingCB(*args):
        """remInitializingingCB(self, ArFunctor functor)"""
        return _BaseArnlPy.ArServerInfoLocalization_remInitializingingCB(*args)

    def addInitializingSucceededCB(*args):
        """
        addInitializingSucceededCB(self, ArFunctor functor, int position=50)
        addInitializingSucceededCB(self, ArFunctor functor)
        """
        return _BaseArnlPy.ArServerInfoLocalization_addInitializingSucceededCB(*args)

    def remInitializingSucceededCB(*args):
        """remInitializingSucceededCB(self, ArFunctor functor)"""
        return _BaseArnlPy.ArServerInfoLocalization_remInitializingSucceededCB(*args)

    def addInitializingFailedCB(*args):
        """
        addInitializingFailedCB(self, ArFunctor functor, int position=50)
        addInitializingFailedCB(self, ArFunctor functor)
        """
        return _BaseArnlPy.ArServerInfoLocalization_addInitializingFailedCB(*args)

    def remInitializingFailedCB(*args):
        """remInitializingFailedCB(self, ArFunctor functor)"""
        return _BaseArnlPy.ArServerInfoLocalization_remInitializingFailedCB(*args)

    def addLostCB(*args):
        """
        addLostCB(self, ArFunctor functor, int position=50)
        addLostCB(self, ArFunctor functor)
        """
        return _BaseArnlPy.ArServerInfoLocalization_addLostCB(*args)

    def remInitingCB(*args):
        """remInitingCB(self, ArFunctor functor)"""
        return _BaseArnlPy.ArServerInfoLocalization_remInitingCB(*args)

ArServerInfoLocalization_swigregister = _BaseArnlPy.ArServerInfoLocalization_swigregister
ArServerInfoLocalization_swigregister(ArServerInfoLocalization)

class ArServerHandlerLocalization(_object):
    """Proxy of C++ ArServerHandlerLocalization class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerHandlerLocalization, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerHandlerLocalization, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, ArServerBase server, ArRobot robot, ArBaseLocalizationTask locTask, 
            bool addResetToHome=True, bool setSimPoseOnLocalize=True) -> ArServerHandlerLocalization
        __init__(self, ArServerBase server, ArRobot robot, ArBaseLocalizationTask locTask, 
            bool addResetToHome=True) -> ArServerHandlerLocalization
        __init__(self, ArServerBase server, ArRobot robot, ArBaseLocalizationTask locTask) -> ArServerHandlerLocalization
        """
        this = _BaseArnlPy.new_ArServerHandlerLocalization(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _BaseArnlPy.delete_ArServerHandlerLocalization
    __del__ = lambda self : None;
    def localizeToPose(*args):
        """
        localizeToPose(self, ArPose pose, bool lockRobot=True, double xySpread=-1, 
            double thSpread=-1)
        localizeToPose(self, ArPose pose, bool lockRobot=True, double xySpread=-1)
        localizeToPose(self, ArPose pose, bool lockRobot=True)
        localizeToPose(self, ArPose pose)
        """
        return _BaseArnlPy.ArServerHandlerLocalization_localizeToPose(*args)

    def setSimPose(*args):
        """
        setSimPose(self, ArPose pose, bool lockRobot=True)
        setSimPose(self, ArPose pose)
        """
        return _BaseArnlPy.ArServerHandlerLocalization_setSimPose(*args)

    def netResetToHome(*args):
        """netResetToHome(self, ArServerClient client, ArNetPacket packet)"""
        return _BaseArnlPy.ArServerHandlerLocalization_netResetToHome(*args)

    def netLocalizeToPose(*args):
        """netLocalizeToPose(self, ArServerClient client, ArNetPacket packet)"""
        return _BaseArnlPy.ArServerHandlerLocalization_netLocalizeToPose(*args)

    def addSimpleRelativeCommands(*args):
        """addSimpleRelativeCommands(self, ArServerHandlerCommands commands)"""
        return _BaseArnlPy.ArServerHandlerLocalization_addSimpleRelativeCommands(*args)

ArServerHandlerLocalization_swigregister = _BaseArnlPy.ArServerHandlerLocalization_swigregister
ArServerHandlerLocalization_swigregister(ArServerHandlerLocalization)

class ArServerModeGotoLLA(ArNetworkingPy.ArServerMode):
    """Proxy of C++ ArServerModeGotoLLA class"""
    __swig_setmethods__ = {}
    for _s in [ArNetworkingPy.ArServerMode]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerModeGotoLLA, name, value)
    __swig_getmethods__ = {}
    for _s in [ArNetworkingPy.ArServerMode]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerModeGotoLLA, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, ArServerBase server, ArRobot robot, ArBaseLocalizationTask locTask, 
            ArPathPlanningTask pathTask, 
            ArMapInterface arMap, ArPose home=ArPose(0, 0, 0), 
            ArRetFunctor<(ArPose)> getHomePoseCB=None) -> ArServerModeGotoLLA
        __init__(self, ArServerBase server, ArRobot robot, ArBaseLocalizationTask locTask, 
            ArPathPlanningTask pathTask, 
            ArMapInterface arMap, ArPose home=ArPose(0, 0, 0)) -> ArServerModeGotoLLA
        __init__(self, ArServerBase server, ArRobot robot, ArBaseLocalizationTask locTask, 
            ArPathPlanningTask pathTask, 
            ArMapInterface arMap) -> ArServerModeGotoLLA
        """
        this = _BaseArnlPy.new_ArServerModeGotoLLA(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _BaseArnlPy.delete_ArServerModeGotoLLA
    __del__ = lambda self : None;
    def activate(*args):
        """activate(self)"""
        return _BaseArnlPy.ArServerModeGotoLLA_activate(*args)

    def deactivate(*args):
        """deactivate(self)"""
        return _BaseArnlPy.ArServerModeGotoLLA_deactivate(*args)

    def gotoPose(*args):
        """gotoPose(self, ArPose pose, ArPose llaPose, bool useHeading)"""
        return _BaseArnlPy.ArServerModeGotoLLA_gotoPose(*args)

    def tourGoalsInList(*args):
        """tourGoalsInList(self, ArPoseList goalList, ArPoseList llaGoalList)"""
        return _BaseArnlPy.ArServerModeGotoLLA_tourGoalsInList(*args)

    def addGotoLLACommand(*args):
        """addGotoLLACommand(self, ArServerHandlerCommands commandsServer)"""
        return _BaseArnlPy.ArServerModeGotoLLA_addGotoLLACommand(*args)

    def gotoLLA(*args):
        """gotoLLA(self, ArArgumentBuilder args)"""
        return _BaseArnlPy.ArServerModeGotoLLA_gotoLLA(*args)

    def addTourGoalsInListCommand(*args):
        """addTourGoalsInListCommand(self, ArServerHandlerCommands commandsServer)"""
        return _BaseArnlPy.ArServerModeGotoLLA_addTourGoalsInListCommand(*args)

    def tourGoalsInListCommand(*args):
        """tourGoalsInListCommand(self, ArArgumentBuilder arg)"""
        return _BaseArnlPy.ArServerModeGotoLLA_tourGoalsInListCommand(*args)

ArServerModeGotoLLA_swigregister = _BaseArnlPy.ArServerModeGotoLLA_swigregister
ArServerModeGotoLLA_swigregister(ArServerModeGotoLLA)

class ArServerModeGoto(ArNetworkingPy.ArServerMode):
    """Proxy of C++ ArServerModeGoto class"""
    __swig_setmethods__ = {}
    for _s in [ArNetworkingPy.ArServerMode]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerModeGoto, name, value)
    __swig_getmethods__ = {}
    for _s in [ArNetworkingPy.ArServerMode]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerModeGoto, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, ArServerBase server, ArRobot robot, ArPathPlanningTask pathTask, 
            ArMapInterface arMap, ArPose home=ArPose(0, 0, 0), 
            ArRetFunctor<(ArPose)> getHomePoseCB=None) -> ArServerModeGoto
        __init__(self, ArServerBase server, ArRobot robot, ArPathPlanningTask pathTask, 
            ArMapInterface arMap, ArPose home=ArPose(0, 0, 0)) -> ArServerModeGoto
        __init__(self, ArServerBase server, ArRobot robot, ArPathPlanningTask pathTask, 
            ArMapInterface arMap) -> ArServerModeGoto
        """
        this = _BaseArnlPy.new_ArServerModeGoto(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _BaseArnlPy.delete_ArServerModeGoto
    __del__ = lambda self : None;
    def activate(*args):
        """activate(self)"""
        return _BaseArnlPy.ArServerModeGoto_activate(*args)

    def deactivate(*args):
        """deactivate(self)"""
        return _BaseArnlPy.ArServerModeGoto_deactivate(*args)

    def home(*args):
        """home(self)"""
        return _BaseArnlPy.ArServerModeGoto_home(*args)

    def gotoGoal(*args):
        """gotoGoal(self, char goal)"""
        return _BaseArnlPy.ArServerModeGoto_gotoGoal(*args)

    def gotoPose(*args):
        """gotoPose(self, ArPose pose, bool useHeading)"""
        return _BaseArnlPy.ArServerModeGoto_gotoPose(*args)

    def tourGoals(*args):
        """tourGoals(self)"""
        return _BaseArnlPy.ArServerModeGoto_tourGoals(*args)

    def tourGoalsInList(*args):
        """tourGoalsInList(self, std::deque<(std::string)> goalList)"""
        return _BaseArnlPy.ArServerModeGoto_tourGoalsInList(*args)

    def addTourGoalsInListSimpleCommand(*args):
        """addTourGoalsInListSimpleCommand(self, ArServerHandlerCommands commandsServer)"""
        return _BaseArnlPy.ArServerModeGoto_addTourGoalsInListSimpleCommand(*args)

    def isAutoResumeAfterInterrupt(*args):
        """isAutoResumeAfterInterrupt(self) -> bool"""
        return _BaseArnlPy.ArServerModeGoto_isAutoResumeAfterInterrupt(*args)

ArServerModeGoto_swigregister = _BaseArnlPy.ArServerModeGoto_swigregister
ArServerModeGoto_swigregister(ArServerModeGoto)

class ArServerDrawingDestination(_object):
    """Proxy of C++ ArServerDrawingDestination class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerDrawingDestination, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerDrawingDestination, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, ArServerInfoDrawings infoDrawings, ArPathPlanningTask pathTask, 
            char name="destination") -> ArServerDrawingDestination
        __init__(self, ArServerInfoDrawings infoDrawings, ArPathPlanningTask pathTask) -> ArServerDrawingDestination
        """
        this = _BaseArnlPy.new_ArServerDrawingDestination(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _BaseArnlPy.delete_ArServerDrawingDestination
    __del__ = lambda self : None;
    def setFlashingParameters(*args):
        """
        setFlashingParameters(self, int onMSec=1, int offMSec=0)
        setFlashingParameters(self, int onMSec=1)
        setFlashingParameters(self)
        """
        return _BaseArnlPy.ArServerDrawingDestination_setFlashingParameters(*args)

    def setDrawingData(*args):
        """setDrawingData(self, ArDrawingData drawingData, bool ownDrawingData)"""
        return _BaseArnlPy.ArServerDrawingDestination_setDrawingData(*args)

    def drawDestination(*args):
        """drawDestination(self, ArServerClient client, ArNetPacket packet)"""
        return _BaseArnlPy.ArServerDrawingDestination_drawDestination(*args)

    def addToConfig(*args):
        """addToConfig(self, ArConfig config)"""
        return _BaseArnlPy.ArServerDrawingDestination_addToConfig(*args)

ArServerDrawingDestination_swigregister = _BaseArnlPy.ArServerDrawingDestination_swigregister
ArServerDrawingDestination_swigregister(ArServerDrawingDestination)

class ArActionLost(AriaPy.ArAction):
    """Proxy of C++ ArActionLost class"""
    __swig_setmethods__ = {}
    for _s in [AriaPy.ArAction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArActionLost, name, value)
    __swig_getmethods__ = {}
    for _s in [AriaPy.ArAction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArActionLost, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, ArBaseLocalizationTask locTask, ArPathPlanningTask pathTask, 
            ArServerMode serverMode=None, char name="lost stopper") -> ArActionLost
        __init__(self, ArBaseLocalizationTask locTask, ArPathPlanningTask pathTask, 
            ArServerMode serverMode=None) -> ArActionLost
        __init__(self, ArBaseLocalizationTask locTask, ArPathPlanningTask pathTask) -> ArActionLost
        """
        this = _BaseArnlPy.new_ArActionLost(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _BaseArnlPy.delete_ArActionLost
    __del__ = lambda self : None;
    def fire(*args):
        """fire(self, ArActionDesired currentDesired) -> ArActionDesired"""
        return _BaseArnlPy.ArActionLost_fire(*args)

    def getDesired(*args):
        """getDesired(self) -> ArActionDesired"""
        return _BaseArnlPy.ArActionLost_getDesired(*args)

    def enable(*args):
        """enable(self)"""
        return _BaseArnlPy.ArActionLost_enable(*args)

    def disable(*args):
        """disable(self)"""
        return _BaseArnlPy.ArActionLost_disable(*args)

    def isEnabled(*args):
        """isEnabled(self) -> bool"""
        return _BaseArnlPy.ArActionLost_isEnabled(*args)

    def getEnableCB(*args):
        """getEnableCB(self) -> ArFunctor"""
        return _BaseArnlPy.ArActionLost_getEnableCB(*args)

    def getDisableCB(*args):
        """getDisableCB(self) -> ArFunctor"""
        return _BaseArnlPy.ArActionLost_getDisableCB(*args)

ArActionLost_swigregister = _BaseArnlPy.ArActionLost_swigregister
ArActionLost_swigregister(ArActionLost)

class ArActionSlowDownWhenNotCertain(AriaPy.ArAction):
    """Proxy of C++ ArActionSlowDownWhenNotCertain class"""
    __swig_setmethods__ = {}
    for _s in [AriaPy.ArAction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArActionSlowDownWhenNotCertain, name, value)
    __swig_getmethods__ = {}
    for _s in [AriaPy.ArAction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArActionSlowDownWhenNotCertain, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, ArBaseLocalizationTask lt) -> ArActionSlowDownWhenNotCertain"""
        this = _BaseArnlPy.new_ArActionSlowDownWhenNotCertain(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _BaseArnlPy.delete_ArActionSlowDownWhenNotCertain
    __del__ = lambda self : None;
    def fire(*args):
        """fire(self, ArActionDesired currentDesired) -> ArActionDesired"""
        return _BaseArnlPy.ArActionSlowDownWhenNotCertain_fire(*args)

    def setRobot(*args):
        """setRobot(self, ArRobot robot)"""
        return _BaseArnlPy.ArActionSlowDownWhenNotCertain_setRobot(*args)

    def deactivate(*args):
        """deactivate(self)"""
        return _BaseArnlPy.ArActionSlowDownWhenNotCertain_deactivate(*args)

    def setPower(*args):
        """setPower(self, double p)"""
        return _BaseArnlPy.ArActionSlowDownWhenNotCertain_setPower(*args)

    def getPower(*args):
        """getPower(self, double ?) -> double"""
        return _BaseArnlPy.ArActionSlowDownWhenNotCertain_getPower(*args)

    def getDesired(*args):
        """getDesired(self) -> ArActionDesired"""
        return _BaseArnlPy.ArActionSlowDownWhenNotCertain_getDesired(*args)

ArActionSlowDownWhenNotCertain_swigregister = _BaseArnlPy.ArActionSlowDownWhenNotCertain_swigregister
ArActionSlowDownWhenNotCertain_swigregister(ArActionSlowDownWhenNotCertain)

class ArSimMapSwitcher(_object):
    """Proxy of C++ ArSimMapSwitcher class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArSimMapSwitcher, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArSimMapSwitcher, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, ArRobot robot, ArMapInterface arMap) -> ArSimMapSwitcher"""
        this = _BaseArnlPy.new_ArSimMapSwitcher(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _BaseArnlPy.delete_ArSimMapSwitcher
    __del__ = lambda self : None;
    def mapChanged(*args):
        """mapChanged(self)"""
        return _BaseArnlPy.ArSimMapSwitcher_mapChanged(*args)

ArSimMapSwitcher_swigregister = _BaseArnlPy.ArSimMapSwitcher_swigregister
ArSimMapSwitcher_swigregister(ArSimMapSwitcher)

class ArPoseStorage(_object):
    """Proxy of C++ ArPoseStorage class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArPoseStorage, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArPoseStorage, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, ArRobot robot, char baseDirectory="", int poseWriteIntervalInMSecs=1000, 
            bool addAriaExitCB=True) -> ArPoseStorage
        __init__(self, ArRobot robot, char baseDirectory="", int poseWriteIntervalInMSecs=1000) -> ArPoseStorage
        __init__(self, ArRobot robot, char baseDirectory="") -> ArPoseStorage
        __init__(self, ArRobot robot) -> ArPoseStorage
        """
        this = _BaseArnlPy.new_ArPoseStorage(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _BaseArnlPy.delete_ArPoseStorage
    __del__ = lambda self : None;
    def savePose(*args):
        """savePose(self) -> bool"""
        return _BaseArnlPy.ArPoseStorage_savePose(*args)

    def restorePose(*args):
        """restorePose(self, char fileName) -> bool"""
        return _BaseArnlPy.ArPoseStorage_restorePose(*args)

ArPoseStorage_swigregister = _BaseArnlPy.ArPoseStorage_swigregister
ArPoseStorage_swigregister(ArPoseStorage)

class ArLocalizationManager(ArBaseLocalizationTask):
    """Proxy of C++ ArLocalizationManager class"""
    __swig_setmethods__ = {}
    for _s in [ArBaseLocalizationTask]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArLocalizationManager, name, value)
    __swig_getmethods__ = {}
    for _s in [ArBaseLocalizationTask]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArLocalizationManager, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, ArRobot robot, ArMapInterface ariaMap) -> ArLocalizationManager"""
        this = _BaseArnlPy.new_ArLocalizationManager(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _BaseArnlPy.delete_ArLocalizationManager
    __del__ = lambda self : None;
    def fuseTwoDistributions(*args):
        """
        fuseTwoDistributions(self, ArPose m1, ArMatrix V1, double s1, double threshold1, 
            ArPose m2, ArMatrix V2, double s2, double threshold2, 
            ArPose mean, ArMatrix Var, double s, 
            double threshold) -> bool
        """
        return _BaseArnlPy.ArLocalizationManager_fuseTwoDistributions(*args)

    def addLocalizationTask(*args):
        """addLocalizationTask(self, ArBaseLocalizationTask loca) -> bool"""
        return _BaseArnlPy.ArLocalizationManager_addLocalizationTask(*args)

    def removeLocalizationTask(*args):
        """removeLocalizationTask(self, ArBaseLocalizationTask loca) -> bool"""
        return _BaseArnlPy.ArLocalizationManager_removeLocalizationTask(*args)

    def findLocalizationMeanVar(*args):
        """findLocalizationMeanVar(self, ArPose mean, ArMatrix Var) -> bool"""
        return _BaseArnlPy.ArLocalizationManager_findLocalizationMeanVar(*args)

    def setCorrectRobotFlag(*args):
        """setCorrectRobotFlag(self, bool a)"""
        return _BaseArnlPy.ArLocalizationManager_setCorrectRobotFlag(*args)

    def setRobotPose(*args):
        """
        setRobotPose(self, ArPose pose, ArPose spread=ArPose(0, 0, 0), int nSam=0)
        setRobotPose(self, ArPose pose, ArPose spread=ArPose(0, 0, 0))
        setRobotPose(self, ArPose pose)
        """
        return _BaseArnlPy.ArLocalizationManager_setRobotPose(*args)

    def localizeRobotAtHomeBlocking(*args):
        """localizeRobotAtHomeBlocking(self, double distSpread, double angleSpread) -> bool"""
        return _BaseArnlPy.ArLocalizationManager_localizeRobotAtHomeBlocking(*args)

    def getLocalizationScore(*args):
        """getLocalizationScore(self) -> double"""
        return _BaseArnlPy.ArLocalizationManager_getLocalizationScore(*args)

    def setLocalizationScore(*args):
        """setLocalizationScore(self, double f)"""
        return _BaseArnlPy.ArLocalizationManager_setLocalizationScore(*args)

    def getLocalizationThreshold(*args):
        """getLocalizationThreshold(self) -> double"""
        return _BaseArnlPy.ArLocalizationManager_getLocalizationThreshold(*args)

    def setLocalizationThreshold(*args):
        """setLocalizationThreshold(self, double t)"""
        return _BaseArnlPy.ArLocalizationManager_setLocalizationThreshold(*args)

    def getLightLocalizationPtr(*args):
        """getLightLocalizationPtr(self) -> ArBaseLocalizationTask"""
        return _BaseArnlPy.ArLocalizationManager_getLightLocalizationPtr(*args)

ArLocalizationManager_swigregister = _BaseArnlPy.ArLocalizationManager_swigregister
ArLocalizationManager_swigregister(ArLocalizationManager)

class ArServerHandlerMultiRobot(_object):
    """Proxy of C++ ArServerHandlerMultiRobot class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerHandlerMultiRobot, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerHandlerMultiRobot, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, ArServerBase server, ArRobot robot, ArPathPlanningTask pathTask, 
            ArBaseLocalizationTask locTask, 
            ArMapInterface arMap) -> ArServerHandlerMultiRobot
        """
        this = _BaseArnlPy.new_ArServerHandlerMultiRobot(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _BaseArnlPy.delete_ArServerHandlerMultiRobot
    __del__ = lambda self : None;
    def multiRobotInfo(*args):
        """multiRobotInfo(self, ArServerClient client, ArNetPacket packet)"""
        return _BaseArnlPy.ArServerHandlerMultiRobot_multiRobotInfo(*args)

    def getPrecedenceClass(*args):
        """getPrecedenceClass(self) -> int"""
        return _BaseArnlPy.ArServerHandlerMultiRobot_getPrecedenceClass(*args)

    def setPrecedenceClass(*args):
        """
        setPrecedenceClass(self, int precedenceClass=0)
        setPrecedenceClass(self)
        """
        return _BaseArnlPy.ArServerHandlerMultiRobot_setPrecedenceClass(*args)

    def overrideMapName(*args):
        """overrideMapName(self, char overrideMapName)"""
        return _BaseArnlPy.ArServerHandlerMultiRobot_overrideMapName(*args)

    def processFile(*args):
        """processFile(self, char errorBuffer, size_t errorBufferLen) -> bool"""
        return _BaseArnlPy.ArServerHandlerMultiRobot_processFile(*args)

ArServerHandlerMultiRobot_swigregister = _BaseArnlPy.ArServerHandlerMultiRobot_swigregister
ArServerHandlerMultiRobot_swigregister(ArServerHandlerMultiRobot)

class ArMultiRobotRangeDevice(AriaPy.ArRangeDevice):
    """Proxy of C++ ArMultiRobotRangeDevice class"""
    __swig_setmethods__ = {}
    for _s in [AriaPy.ArRangeDevice]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArMultiRobotRangeDevice, name, value)
    __swig_getmethods__ = {}
    for _s in [AriaPy.ArRangeDevice]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArMultiRobotRangeDevice, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, ArServerBase serverBase) -> ArMultiRobotRangeDevice"""
        this = _BaseArnlPy.new_ArMultiRobotRangeDevice(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _BaseArnlPy.delete_ArMultiRobotRangeDevice
    __del__ = lambda self : None;
    def applyTransform(*args):
        """applyTransform(self, ArTransform trans, bool doCumulative)"""
        return _BaseArnlPy.ArMultiRobotRangeDevice_applyTransform(*args)

    def getOtherRobots(*args):
        """getOtherRobots(self) -> std::list<(ArMultiRobotPoseAndRadius,std::allocator<(ArMultiRobotPoseAndRadius)>)>"""
        return _BaseArnlPy.ArMultiRobotRangeDevice_getOtherRobots(*args)

    def getOtherRobotsCB(*args):
        """getOtherRobotsCB(self) -> ArRetFunctor<(std::list<(ArMultiRobotPoseAndRadius,std::allocator<(ArMultiRobotPoseAndRadius)>)>)>"""
        return _BaseArnlPy.ArMultiRobotRangeDevice_getOtherRobotsCB(*args)

ArMultiRobotRangeDevice_swigregister = _BaseArnlPy.ArMultiRobotRangeDevice_swigregister
ArMultiRobotRangeDevice_swigregister(ArMultiRobotRangeDevice)

class ArMultiRobotFlags1(_object):
    """Proxy of C++ ArMultiRobotFlags1 class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArMultiRobotFlags1, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArMultiRobotFlags1, name)
    __repr__ = _swig_repr
    WAITING_TO_FAIL = _BaseArnlPy.ArMultiRobotFlags1_WAITING_TO_FAIL
    END_OF_PATH = _BaseArnlPy.ArMultiRobotFlags1_END_OF_PATH
    def __init__(self, *args): 
        """__init__(self) -> ArMultiRobotFlags1"""
        this = _BaseArnlPy.new_ArMultiRobotFlags1(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _BaseArnlPy.delete_ArMultiRobotFlags1
    __del__ = lambda self : None;
ArMultiRobotFlags1_swigregister = _BaseArnlPy.ArMultiRobotFlags1_swigregister
ArMultiRobotFlags1_swigregister(ArMultiRobotFlags1)

class ArServerHandlerMultiRobotPeer(_object):
    """Proxy of C++ ArServerHandlerMultiRobotPeer class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerHandlerMultiRobotPeer, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerHandlerMultiRobotPeer, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, ArServerBase server, ArRobot robot, ArPathPlanningTask pathTask, 
            ArBaseLocalizationTask lockTask) -> ArServerHandlerMultiRobotPeer
        """
        this = _BaseArnlPy.new_ArServerHandlerMultiRobotPeer(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _BaseArnlPy.delete_ArServerHandlerMultiRobotPeer
    __del__ = lambda self : None;
    def setPrecedenceClass(*args):
        """setPrecedenceClass(self, int precedenceClass)"""
        return _BaseArnlPy.ArServerHandlerMultiRobotPeer_setPrecedenceClass(*args)

    def getPrecedenceClass(*args):
        """getPrecedenceClass(self) -> int"""
        return _BaseArnlPy.ArServerHandlerMultiRobotPeer_getPrecedenceClass(*args)

    def setNewPrecedenceCallback(*args):
        """setNewPrecedenceCallback(self, ArFunctor2<(short,short)> newPrecedenceCallback)"""
        return _BaseArnlPy.ArServerHandlerMultiRobotPeer_setNewPrecedenceCallback(*args)

    def setNewFingerprintCallback(*args):
        """setNewFingerprintCallback(self, ArFunctor1<(p.unsigned char)> newFingerprintCallback)"""
        return _BaseArnlPy.ArServerHandlerMultiRobotPeer_setNewFingerprintCallback(*args)

    def getChangeFingerprintCB(*args):
        """getChangeFingerprintCB(self) -> ArFunctor"""
        return _BaseArnlPy.ArServerHandlerMultiRobotPeer_getChangeFingerprintCB(*args)

    def changeFingerprint(*args):
        """
        changeFingerprint(self, bool lockRobot=True)
        changeFingerprint(self)
        """
        return _BaseArnlPy.ArServerHandlerMultiRobotPeer_changeFingerprint(*args)

    def netGetFingerprint(*args):
        """netGetFingerprint(self, ArServerClient client, ArNetPacket packet)"""
        return _BaseArnlPy.ArServerHandlerMultiRobotPeer_netGetFingerprint(*args)

    def netAdjustPrecedence(*args):
        """netAdjustPrecedence(self, ArServerClient client, ArNetPacket packet)"""
        return _BaseArnlPy.ArServerHandlerMultiRobotPeer_netAdjustPrecedence(*args)

    def netRobotInfo(*args):
        """netRobotInfo(self, ArServerClient client, ArNetPacket packet)"""
        return _BaseArnlPy.ArServerHandlerMultiRobotPeer_netRobotInfo(*args)

    def netPathInfo(*args):
        """netPathInfo(self, ArServerClient client, ArNetPacket packet)"""
        return _BaseArnlPy.ArServerHandlerMultiRobotPeer_netPathInfo(*args)

    def netShortPathInfo(*args):
        """netShortPathInfo(self, ArServerClient client, ArNetPacket packet)"""
        return _BaseArnlPy.ArServerHandlerMultiRobotPeer_netShortPathInfo(*args)

    def processFile(*args):
        """processFile(self, char errorBuffer, size_t errorBufferLen) -> bool"""
        return _BaseArnlPy.ArServerHandlerMultiRobotPeer_processFile(*args)

ArServerHandlerMultiRobotPeer_swigregister = _BaseArnlPy.ArServerHandlerMultiRobotPeer_swigregister
ArServerHandlerMultiRobotPeer_swigregister(ArServerHandlerMultiRobotPeer)

class ArMultiRobotPeerRangeDevice(AriaPy.ArRangeDevice):
    """Proxy of C++ ArMultiRobotPeerRangeDevice class"""
    __swig_setmethods__ = {}
    for _s in [AriaPy.ArRangeDevice]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArMultiRobotPeerRangeDevice, name, value)
    __swig_getmethods__ = {}
    for _s in [AriaPy.ArRangeDevice]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArMultiRobotPeerRangeDevice, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, ArMapInterface arMap) -> ArMultiRobotPeerRangeDevice"""
        this = _BaseArnlPy.new_ArMultiRobotPeerRangeDevice(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _BaseArnlPy.delete_ArMultiRobotPeerRangeDevice
    __del__ = lambda self : None;
    def processFile(*args):
        """processFile(self, char errorBuffer, size_t errorBufferLen) -> bool"""
        return _BaseArnlPy.ArMultiRobotPeerRangeDevice_processFile(*args)

    def sensorInterpCallback(*args):
        """sensorInterpCallback(self)"""
        return _BaseArnlPy.ArMultiRobotPeerRangeDevice_sensorInterpCallback(*args)

    def setPrecedence(*args):
        """setPrecedence(self, short precedenceBase, short precedenceClass)"""
        return _BaseArnlPy.ArMultiRobotPeerRangeDevice_setPrecedence(*args)

    def setFingerprint(*args):
        """setFingerprint(self, unsigned char fingerprint)"""
        return _BaseArnlPy.ArMultiRobotPeerRangeDevice_setFingerprint(*args)

    def getSetPrecedenceCallback(*args):
        """getSetPrecedenceCallback(self) -> ArFunctor2<(short,short)>"""
        return _BaseArnlPy.ArMultiRobotPeerRangeDevice_getSetPrecedenceCallback(*args)

    def getSetFingerprintCallback(*args):
        """getSetFingerprintCallback(self) -> ArFunctor1<(p.unsigned char)>"""
        return _BaseArnlPy.ArMultiRobotPeerRangeDevice_getSetFingerprintCallback(*args)

    def setChangeFingerprintCB(*args):
        """setChangeFingerprintCB(self, ArFunctor functor)"""
        return _BaseArnlPy.ArMultiRobotPeerRangeDevice_setChangeFingerprintCB(*args)

    def mapChanged(*args):
        """mapChanged(self)"""
        return _BaseArnlPy.ArMultiRobotPeerRangeDevice_mapChanged(*args)

    def setRobot(*args):
        """setRobot(self, ArRobot robot)"""
        return _BaseArnlPy.ArMultiRobotPeerRangeDevice_setRobot(*args)

    def applyTransform(*args):
        """applyTransform(self, ArTransform trans, bool doCumulative)"""
        return _BaseArnlPy.ArMultiRobotPeerRangeDevice_applyTransform(*args)

    def getOtherRobots(*args):
        """getOtherRobots(self) -> std::list<(ArMultiRobotPoseAndRadius,std::allocator<(ArMultiRobotPoseAndRadius)>)>"""
        return _BaseArnlPy.ArMultiRobotPeerRangeDevice_getOtherRobots(*args)

    def getOtherRobotsCB(*args):
        """getOtherRobotsCB(self) -> ArRetFunctor<(std::list<(ArMultiRobotPoseAndRadius,std::allocator<(ArMultiRobotPoseAndRadius)>)>)>"""
        return _BaseArnlPy.ArMultiRobotPeerRangeDevice_getOtherRobotsCB(*args)

ArMultiRobotPeerRangeDevice_swigregister = _BaseArnlPy.ArMultiRobotPeerRangeDevice_swigregister
ArMultiRobotPeerRangeDevice_swigregister(ArMultiRobotPeerRangeDevice)



