Programming- Nao Robot by choregraphe

As discussed in class, your second program with the Nao will be programmed in python using the various libraries of functions I demonstrated. Your program should do the following:

a) Begin by listening for the word “Go”. You should recognize this word with the speech recognition routines.

b) A localization step should then occur. The robot should say “Where are you?” using the text to speech routines. It should then use the audio location routines to determine where your response of “Here” comes from. This will be an angle in radians that you can use to turn your robot in the correct direction using the motion routines. You can repeat this localization step whenever you want as your program is running.

c) The robot should walk in the direction of the voice, listening for the word “Stop”, which will either indicate he has reached you, or some other emergency is about to occur and you want the robot to stop.

d) As the robot is walking it may encounter an obstacle. You can detect this by monitoring the values determined by the ultrasound sensors to measure that there is an object right in front of part of the robot. When this is detected, the robot should use the approach of the bug algorithm to walk around the perimeter of the object until there is again a clear line of sight between the robot and you, and it can continue its journey. You might want to use the localization step during this process. For obstacles, make sure to use things that are tall enough to bounce the ultrasound waves off of, like a box or a trash can.

pynaoqi-python-2.6-naoqi-1.14-linux32/_inaoqi.so

pynaoqi-python-2.6-naoqi-1.14-linux32/_almath.so

pynaoqi-python-2.6-naoqi-1.14-linux32/naoqi.py
import os
import sys
import weakref
import logging

try:
import _inaoqi
except ImportError:
# quick hack to keep inaoqi.py happy
if sys.platform.startswith(“win”):
print “Could not find _inaoqi, trying with _inaoqi_d”
import _inaoqi_d as _inaoqi
else:
raise
import inaoqi
import motion
import allog
def autoBind(myClass, bindIfnoDocumented):
“””Show documentation for each
method of the class”””
# dir(myClass) is a list of the names of
# everything in class
myClass.setModuleDescription(myClass.__doc__)
for thing in dir(myClass):
# getattr(x, “y”) is exactly: x.y
function = getattr(myClass, thing)
if callable(function):
if (type(function) == type(myClass.__init__)):
if (bindIfnoDocumented or function.__doc__ != “”):
if (thing[0] != “_”): # private method
if (function.__doc__):
myClass.functionName(thing, myClass.getName(), function.__doc__)
else:
myClass.functionName(thing, myClass.getName(), “”)
for param in function.func_code.co_varnames:
if (param != “self”):
myClass.addParam(param)
myClass._bindWithParam(myClass.getName(),thing,len(function.func_code.co_varnames)-1)

class ALDocable():
def __init__(self, bindIfnoDocumented):
autoBind(self,bindIfnoDocumented)

# define the log handler to be used by the logging module
class ALLogHandler(logging.Handler):
def __init__(self):
logging.Handler.__init__(self)
def emit(self, record):
level_to_function = {
logging.DEBUG: allog.debug,
logging.INFO: allog.info,
logging.WARNING: allog.warning,
logging.ERROR: allog.error,
logging.CRITICAL: allog.fatal,
}
function = level_to_function.get(record.levelno, allog.debug)
function(record.getMessage(),
record.name,
record.filename,
record.funcName,
record.lineno)

# Same as above, but we force the category to be behavior.box
# *AND* we prefix the message with the module name
# look at errorInBox in choregraphe for explanation
class ALBehaviorLogHandler(logging.Handler):
def __init__(self):
logging.Handler.__init__(self)
def emit(self, record):
level_to_function = {
logging.DEBUG: allog.debug,
logging.INFO: allog.info,
logging.WARNING: allog.warning,
logging.ERROR: allog.error,
logging.CRITICAL: allog.fatal,
}
function = level_to_function.get(record.levelno, allog.debug)
function(record.name + “: ” + record.getMessage(),
“behavior.box”,
“”, # record.filename in this case is simply ‘‘
record.funcName,
record.lineno)
# define a class that will be inherited by both ALModule and ALBehavior, to store instances of modules, so a bound method can be called on them.
class NaoQiModule():
_modules = dict()
@classmethod
def getModule(cls, name):
# returns a reference a module, giving its string, if it exists !
if(name not in cls._modules):
raise RuntimeError(“Module ” + str(name) + ” does not exist”)
return cls._modules[name]()
def __init__(self, name, logger=True):
# keep a weak reference to ourself, so a proxy can be called on this module easily
self._modules[name] = weakref.ref(self)
self.loghandler = None
if logger:
self.logger = logging.getLogger(name)
self.loghandler = ALLogHandler()
self.logger.addHandler(self.loghandler)
self.logger.setLevel(logging.DEBUG)
def __del__(self):
# when object is deleted, clean up dictionnary so we do not keep a weak reference to it
del self._modules[self.getName()]
if(self.loghandler != None):
self.logger.removeHandler(self.loghandler)

class ALBroker(inaoqi.broker):
def init(self):
pass
class ALModule(inaoqi.module, ALDocable, NaoQiModule):
def __init__(self,param):
inaoqi.module.__init__(self, param)
ALDocable.__init__(self, False)
NaoQiModule.__init__(self, param)
def __del__(self):
NaoQiModule.__del__(self)
def methodtest(self):
pass
def pythonChanged(self, param1, param2, param3):
pass

class ALBehavior(inaoqi.behavior, NaoQiModule):
# class var in order not to build it each time
_noNeedToBind = set(dir(inaoqi.behavior))
_noNeedToBind.add(“getModule”)
_noNeedToBind.add(“onLoad”)
_noNeedToBind.add(“onUnload”)
# deprecated since 1.14 methods
_noNeedToBind.add(“log”)
_noNeedToBind.add(“playTimeline”)
_noNeedToBind.add(“stopTimeline”)
_noNeedToBind.add(“exitBehavior”)
_noNeedToBind.add(“gotoAndStop”)
_noNeedToBind.add(“gotoAndPlay”)
_noNeedToBind.add(“playTimelineParent”)
_noNeedToBind.add(“stopTimelineParent”)
_noNeedToBind.add(“exitBehaviorParent”)
_noNeedToBind.add(“gotoAndPlayParent”)
_noNeedToBind.add(“gotoAndStopParent”)
def __init__(self, param, autoBind):
inaoqi.behavior.__init__(self, param)
NaoQiModule.__init__(self, param, logger=False)
self.logger = logging.getLogger(param)
self.behaviorloghandler = ALBehaviorLogHandler()
self.logger.addHandler(self.behaviorloghandler)
self.logger.setLevel(logging.DEBUG)
self.resource = False
self.BIND_PYTHON(self.getName(), “__onLoad__”)
self.BIND_PYTHON(self.getName(), “__onUnload__”)
if(autoBind):
behName = self.getName()
userMethList = set(dir(self)) – self._noNeedToBind
for methName in userMethList:
function = getattr(self, methName)
if callable(function) and type(function) == type(self.__init__):
if (methName[0] != “_”): # private method
self.functionName(methName, behName, “”)
for param in function.func_code.co_varnames:
if (param != “self”):
self.addParam(param)
self._bindWithParam(behName,methName,len(function.func_code.co_varnames)-1)
def __del__(self):
NaoQiModule.__del__(self)
self.logger.removeHandler(self.behaviorloghandler)
self.behaviorloghandler.close()
def __onLoad__(self):
self._safeCallOfUserMethod(“onLoad”,None)
def __onUnload__(self):
if(self.resource):
self.releaseResource()
self._safeCallOfUserMethod(“onUnload”,None)
def setParameter(self, parameterName, newValue):
inaoqi.behavior.setParameter(self, parameterName, newValue)
def _safeCallOfUserMethod(self, functionName, functionArg):
try:
if(functionName in dir(self)):
func = getattr(self, functionName)
if(func.im_func.func_code.co_argcount == 2):
func(functionArg)
else:
func()
return True
except BaseException, err:
self.logger.error(str(err))
try:
if(“onError” in dir(self)):
self.onError(self.getName() + ‘:’ +str(err))
except BaseException, err2:
self.logger.error(str(err2))
return False
# Depreciate this!!! Same as self.logger.info(), but function is always “log”
def log(self, p):
self.logger.info(p)

class MethodMissingMixin(object):
“”” A Mixin’ to implement the ‘method_missing’ Ruby-like protocol. “””
def __getattribute__(self, attr):
try:
return object.__getattribute__(self, attr)
except:
class MethodMissing(object):
def __init__(self, wrapped, method):
self.__wrapped__ = wrapped
self.__method__ = method
def __call__(self, *args, **kwargs):
return self.__wrapped__.method_missing(self.__method__, *args, **kwargs)
return MethodMissing(self, attr)
def method_missing(self, *args, **kwargs):
“”” This method should be overridden in the derived class. “””
raise NotImplementedError(str(self.__wrapped__) + ” ‘method_missing’ method has not been implemented.”)

class postType(MethodMissingMixin):
def __init__(self):
“”
def setProxy(self, proxy):
self.proxy = weakref.ref(proxy)
# print name
def method_missing(self, method, *args, **kwargs):
list = []
list.append(method)
for arg in args:
list.append(arg)
result = 0
try:
p = self.proxy()
result = p.pythonPCall(list)
except RuntimeError,e:
raise e
return result

class ALProxy(inaoqi.proxy,MethodMissingMixin):
def __init__(self, *args):
self.post = postType()
self.post.setProxy(self)
if (len (args) == 1):
inaoqi.proxy.__init__(self, args[0])
elif (len (args) == 2):
inaoqi.proxy.__init__(self, args[0], args[1])
else:
inaoqi.proxy.__init__(self, args[0], args[1], args[2])
def call(self, *args):
list = []
for arg in args:
list.append(arg)
return self.pythonCall(list)

def pCall(self, *args):
list = []
for arg in args:
list.append(arg)
return self.pythonPCall(list)

def method_missing(self, method, *args, **kwargs):
list = []
list.append(method)
for arg in args:
list.append(arg)
result = 0
try:
result = self.pythonCall(list)
except RuntimeError,e:
raise e
#print e.args[0]
return result
@staticmethod
def initProxies():
#Warning: The use of these default proxies is deprecated.
global ALMemory
global ALMotion
global ALFrameManager
global ALLeds
global ALLogger
global ALSensors
try:
ALMemory = inaoqi.getMemoryProxy()
except:
ALMemory = ALProxy(“ALMemory”)
try:
ALFrameManager = ALProxy(“ALFrameManager”)
except:
print “No proxy to ALFrameManager”
try:
ALMotion = ALProxy(“ALMotion”)
except:
print “No proxy to ALMotion”
try:
ALLeds = ALProxy(“ALLeds”)
except:
pass
try:
ALLogger = ALProxy(“ALLogger”)
except:
print “No proxy to ALLogger”
try:
ALSensors = ALProxy(“ALSensors”)
except:
pass

def createModule(name):
global moduleList
str = “moduleList.append(“+ “module(\”” + name + “\”))”
exec(str)

pynaoqi-python-2.6-naoqi-1.14-linux32/license.rtf

End-
User Software License Agreement

This Limited End-User Software License Agreement (the “Agreement”) is a legal agreement between you (“Licensee”), the end-user, and Aldebaran Robotics SAS having its registered office at 168-170 Rue Raymond Losserand, 75014 Paris, France, registered with the trade and companies register of Paris under number 483 185 807 (hereinafter “Aldebaran”) for the use of the ” Aldebaran Software Toolkit ” (“Software”). By using this software or storing this program on a computer or robot hard drive (or other media), you are agreeing to be bound by the terms of this Agreement. If you do not agree to any of the terms of this agreement uninstall and delete the software from all storage media.

ARTICLE 1 – RIGHTS GRANTED

ALDEBARAN grants to the LICENSEE a personal, non-exclusive, non-transferable, non sub-licensable right to install and use the Software and the Documentation (if any), for the duration of the applicable intellectual property rights.

ALDEBARAN shall have the right to make update and/or upgrade of the Software. However this Agreement does not grant any right on any update or upgrade of the Software. In the event ALDEBARAN provided an upgrade or upgrade of the Software which is not used by Licensee will not benefit from warranties given by ALDABARAN within this Agreement (as far as permitted by the applicable law).

ALDEBARAN may discontinue or change the Software, at any time or for any reason, with or without notice. To avoid any misunderstanding it is agreed that ALDEBARAN has no right to operate a change on the LICENSEE‘s device where the Software is install without its consent.

This Agreement does not grant any right to any Third-Party Software.

Some Third-Party Software may be needed to permit the Software to operate properly. Even in such event ALDEBARAN is not granting any right on the Third-Party Software. The Third-Party Software remains subject to the specific licenses applicable to each Third-Party Software and as described in their related applicable documentation. Licensee shall on his owns decide to either accept or not the applicable terms and conditions related to Third-Party Software. Licensee accepts and understands that refusing the terms and conditions applicable to Third-Party Software may impact in whole or in part the use of the Software.

ARTICLE 2 – OBLIGATIONS OF THE LICENSEE

LICENSEE agrees to the following:

– The LICENSEE shall strictly comply with the user instructions set forth in the Documentation;

– Even if LICENSEE keeps its right of objectively critic the Software, the LICENSEE shall not take any action to impair the reputation of the Product, the trademarks of ALDEBARAN or its licensors and any other product of ALDEBARAN or its licensors;

– LICENSEE shall in no event use the Software for any illegal, defaming, pornographic or detrimental activities;

– The LICENSEE shall use the ALDEBARAN name and trademarks only in the manner prescribed by ALDEBARAN in writing;

– The LICENSEE shall inform ALDEBARAN of any potential defects discovered when using the Product;

– The LICENSEE shall notify ALDEBARAN promptly of any legal notices, claims or actions directly or indirectly relating to the Software against a third party and not enter into or compromise any legal action or other proceeding relating to the Software without the prior written consent of ALDEBARAN;

– The LICENSEE shall not use, without the prior written consent of ALDEBARAN, the Software for the benefit of third parties in any manner, and in particular:

(a) not sell, resell, lease, transfer, license or sublicense or otherwise provide the Software to any third party, and, in a more general manner, not communicate all or part of the Software to any third party;

(b) not charge or otherwise deal in or encumber the Software;

– The LICENSEE shall not delete, remove or in any way obscure the proprietary notices, labels or marks of ALDEBARAN or its licensors on the Software and conspicuously display the proprietary notices, labels or marks on any copy of the Software;

– Except otherwise expressly agreed the LICENSEE shall not alter, modify, decompile, disassemble, or reverse engineer the program code or any other part of the Software, in whole or in part, except in the events and only to the extent expressly provided by law. However, even if the law authorizes the above acts, LICENSEE shall give ALDEBARAN a written notice seven (7) calendar days prior to the date on which these acts are scheduled to take place and allow a representative of ALDEBARAN to be present during these acts;

– Except otherwise expressly agreed the LICENSEE shall not develop any other software programs or derivative works on the basis of the Software. Any such software program or derivative work shall in no case be sold, assigned or licensed by the LICENSEE;

– To avoid any misunderstanding it is agreed that LICENSEE shall have the right to use and exploit the result given by the use of the software in conformity of this license agreement.

– The LICENSEE shall not use the Software for illegal purposes or in illegal manner, including in violation of the intellectual property rights of ALDEBARAN or any third party;

– The LICENSEE shall provide ALDEBARAN promptly with any information, material, software or specification as may reasonably be required for the proper performance of this Agreement including access to appropriate members of the LICENSEE’s staff. The LICENSEE is responsible for the completeness and accuracy of such information, material, software or specification;

ARTICLE 3 – LIMITED WARRANTIES AND LIMITATION OF LIABILITY

3.1 ALDEBARAN warrants that it has full title and ownership to the Software. ALDEBARAN also warrants that it has the full power and authority to enter into this agreement and to grant the license conveyed in this Agreement. Aldebaran warrants that the use of the Software in conformity with this Agreement will in no way constitute an infringement or other violation of any Intellectual Property of any third party.
Should the Software give rise, or in ALDEBARAN opinion be likely to give rise to any such claim, ALDEBARAN shall, at its option and expense, either:

(i) procure for LICENSEE the right to continue using such Aldebaran Software; or
(ii) replace or modify the Aldebaran Software so that it does not infringe the intellectual property rights anymore; or
(iii) terminate the right of use of the Software.

Except as set out in this Agreement, all conditions, warranties and representations in relation to the Software are excluded to the extent permitted under applicable law.

3.2 AS FAR AS PERMITTED BY THE APPLICABLE LAW:

ALDEBARAN PROVIDES THE SOFTWARE “AS IS”, AND DOES NOT WARRANT THAT THE USE OF THE SOFTWARE, FUNCTIONALITY, THE OPERATION AND/OR CONTENT WILL BE: UNINTERRUPTED, ACCURATE, COMPLETE, FREE FROM ANY SOFTWARE VIRUS OR OTHER HARMFUL COMPONENT.

ALDEBARAN DOES NOT WARRANT THE INTERNAL CHARACTERISTICS, THE COMPATIBILITY FO THE SOFTWARE WITH OTHER SOFTWARE, THE ACCURACY, ADEQUACY, OR COMPLETENESS OF SOTWARE AND ITS RESULT AND DISCLAIMS LIABILITY FOR ERRORS OR OMISSIONS.

ALDEBARAN DISCLAIMS ANY REPRESENTATIONS, WARRANTIES OR CONDITIONS, EXPRESS OR IMPLIED, INCLUDING THOSE OF PERFORMANCE OR MERCHANTABILITY OR RELIABILITY USEFULNESS OR FITNESS FOR A PARTICULAR PURPOSE WITH RESPECT TO THE SOFTWARE AND ITS RESULTS.

3.3 IN NO EVENT WILL ALDEBARAN BE LIABLE FOR ANY DAMAGES (INCLUDING WITHOUT LIMITATION DIRECT, INDIRECT, PUNITIVE, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES, COST OF PROCURING SUBSTITUTE SERVICES, LOST PROFITS, LOSS OF DATA, LOSSES, OR OTHER EXPENSES) ARISING IN CONNECTION WITH THE PROVISION OR USE OF THE SOFTWARE, RELATED SERVICES OR INFORMATION PROVIDED PURSUANT TO THIS AGREEMENT, REGARDLESS OF WHETHER SUCH CLAIMS ARE BASED ON CONTRACT, TORT, STRICT LIABILITY, OR OTHERWISE, OR WHETHER PROVIDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES, LOSSES, OR EXPENSES.

WITHOUT LIMITING THE FOREGOING, THIS LIMITATION OF LIABILITY INCLUDES, BUT IS NOT LIMITED TO, THE UNAVAILABILITY OF THE APPLICATION(S), UNAUTHORIZED ACCESS, ANY FAILURE OF PERFORMANCE, INTERRUPTION, ERROR, OMISSION, DEFECT, DELAY IN OPERATION OR TRANSMISSION, COMPUTER VIRUS, OR SYSTEM FAILURE.

NOTWITHSTANDING ANYTHING TO THE CONTRARY IN THIS AGREEMENT OR ANY STATUTE OR RULE OF LAW TO THE CONTRARY, SUBJECT TO THIS ARTICLE, ALDEBARAN’S CUMULATIVE LIABILITY FOR ALL CLAIMS ARISING OUT OF OR IN CONNECTION WITH THIS AGREEMENT, WHETHER DIRECTLY OR INDIRECTLY, SHALL NOT EXCEED ALL FEES PAID TO ALDEBARAN BY THE LICENSEE FOR THE USE OF THE SOFTWARE. IN THE EVENT THE SOFTWARE IS GRANTED FOR FREE TO THE LICENSEE, ALDEBARAN’S CUMULATIVE LIABILITY FOR ALL CLAIMS ARISING OUT OF OR IN CONNECTION WITH THIS AGREEMENT, WHETHER DIRECTLY OR INDIRECTLY, SHALL NOT EXCEED 100 € (ONE HUNDRED EUROS).

WHENEVER THE ABOVE SECTIONS ARE NOT APPLICABLE UNDER THE APPLYING LAW ALDEBARAN AS SOLE REMEDY SHALL AT ITS OPTION AND EXPENSE EITHER (I) REPAIR THE DEFECTIVE OR INFRINGING SOFTWARE, OR (II) REPLACE THE DEFECTIVE OR INFRINGING SOFTWARE, OR (III) REIMBURSE THE FEE PAID TO ALDEBARAN FOR THE DEFECTIVE OR INFRINGING SOFTWARE. THESE REMEDIES ARE EXCLUSIVE OF ANY OTHER REMEDIES AND ANY OTHER WARRANTY IS EXCLUDED.

ANY INDEMNIFICATION BY ALDEBARAN UNDER THIS WARRANTY IS EXCLUDED IF THE CLAIM IS BASED UPON (I) A MODIFIED VERSION OF THE SOFTWARE FOR WHICH THE CHANGES HAVE NOT BEEN EXPRESSLY AUTHORIZED OR VALIDATED BY ALDEBARAN, OR (II) A COMBINATION, INSTALLATION OR USE OF ANY SOFTWARE COMPONENT EMBEDDED IN THE NAO ROBOT WITH ANY OTHER ELEMENT, MATERIAL OR ITEM THAT IS NOT EXPRESSLY PROVIDED BY ALDEBARAN FOR COMBINATION, INSTALLATION OR USE WITH THE SOFTWARE,
OR (III) A COMBINATION, INSTALLATION OR USE OF THE SOFTWARE WITH ANY OTHER ELEMENT, MATERIAL OR ITEM THAT IS NOT EXPRESSLY AUTHORIZED BY ALDEBARAN FOR COMBINATION, INSTALLATION OR USE WITH THE SOFTWARE, OR (IV) ANY OTHER FAULT OR NEGLIGENCE OF LICENSEE OR A THIRD PARTY.

This warranty does not cover incorrect installation or use by any third party; misuse of the Software voids the warranty.
The Third-Party Software is warranted only as provided in the specific licenses applicable to each.

ARTICLE 4 – INTELLECTUAL PROPERTY

ALDEBARAN is the owner or licensee of the Software. Title, copyright and any other proprietary and intellectual property right in the Software shall remain vested in ALDEBARAN or its licensors. The rights granted to the LICENSEE under this Agreement do not transfer to the LICENSEE title or any proprietary or intellectual property rights to the Software and do not constitute a sale of such rights;

ALDEBARAN shall retain the ownership of all rights in any inventions, discoveries, improvements, ideas, techniques or know-how embodied conceived by ALDEBARAN under this Agreement, including, without limitation, its methods of work, programs, methodologies and related documentation, including any derivative works of software code developed by ALDEBARAN in the course of performing this Agreement as well any knowledge and experience of ALDEBARAN’s directors, staff and consultants.

ARTICLE 5
–

COLLECTION AND USE OF PERSONAL INFORMATION

Privacy of the Licensee is important to ALDEBARAN. Therefore ALDEBARAN is not collecting any personal data except as expressly agreed by the Licensee.

ALDEBARAN will abide any applicable law, rules, or regulations relating to the privacy of personal information. Such data shall only be used for the purposes for which it was provided. Licensee understands that Third Party software may have their own privacy policy which may be less secure than the Aldebaran’s privacy policy.

ALDEBARAN will do its best to ensure that any personal data which may be collected from the Licensee will remain confidential.

Licensee hereby agrees and consents that the following data maybe collected by ALDEBARAN in order permit a network-enhanced services, improve the general quality and/or functionality of its products and/or software, permit development of new version of its products and/or software, fix bug or defect, develop patch and other solution, permit to install new version, update or upgrade, monitor and/or permit the maintenance of Aldebaran products and/or software:
Crash reporting, robot ID, robot health metrics, hardware-specific preferences, application install history, user preferences.

Licensee expressly consents that Aldebaran may generate statistical data from the information provided through the Software without identifying Licensee.
Licensee understands and agrees that, within the course of the use of the software, some voice data and/or video data could transit through ALDEBARAN and/or other third party network.

ARTICLE 6 – NO TRANSFER OR ASSIGNMENT

In no event shall LICENSEE sublicense, assign or otherwise transfer all or part of its rights and obligations under this Agreement to any third party. Any such sublicensing, assignment or transfer shall be null and void, unless expressly agreed to by ALDEBARAN in writing.

ARTICLE 7 – MISCELLEANEOUS

Termination. Either party may terminate this Agreement without advance notice. In case of breach of this Agreement by the Licensee, the authorization to access and use the Software will automatically terminate absent Aldebaran’s written waiver of such breach.

Survival. To the extent applicable, the following articles shall survive the termination, cancellation, expiration, and/or rescission of this Agreement: Articles 3.3, 4, 5, 7 and any provision that expressly states its survival and/or are necessary for the enforcement of this Agreement.

Headings. The headings referred to or used in this Agreement are for reference and convenience purposes only and shall not in any way limit or affect the meaning or interpretation of any of the terms hereof.

Severability. If any of the provisions of this Agreement are held or deemed to be invalid, illegal or unenforceable, the remaining provisions of this Agreement shall be unimpaired, and the invalid, illegal or unenforceable provision shall be replaced by a mutually acceptable provision, which being valid, legal and enforceable, comes closest to the intention of the Parties underlying the invalid, illegal or unenforceable provision.

Waiver. Any failure or delay by either Party in exercising its right under any provisions of the Agreement shall not be construed as a waiver of those rights at any time now or in the future unless an express declaration in writing from the Party concerned.

Governing law and Jurisdiction. Parties agree that all matters arising from or relating to the Software and this Agreement, shall be governed by the laws of France, without regard to conflict of laws principles. In the event of any dispute between the Parties, the Parties agreed to meet to discuss their dispute before resorting to formal dispute resolution procedures.

BY CLICKING “AGREE”, YOU AS LICENSEE ACKNOWLEDGE THAT YOU HAVE READ, UNDERSTAND AND ACCEPT THIS LIMITED END-USER SOFTWARE LICENSE AGREEMENT.

BY CLICKING “AGREE” YOU AS LICENSEE AGREE TO BE BOUND BY ALL OF ITS TERMS AND CONDITIONS OF THIS LIMITED END-USER SOFTWARE LICENSE AGREEMENT.

IF YOU AS A LICENSEE DO NOT AGREE TO ANY TERMS AND CONDITIONS, OF THIS LIMITED END-USER SOFTWARE LICENSE AGREEMENT DO NOT INSTALL OR USE THE SOFTWARE AND CLICK ON “DISAGREE”. By CLICKING ON “DESAGREE” YOU WILL NOT BE ABLE TO USE THE SOFTWARE.

pynaoqi-python-2.6-naoqi-1.14-linux32/allog.py
# This file was automatically generated by SWIG (http://www.swig.org).
# Version 1.3.40
#
# Do not make changes to this file unless you know what you are doing–modify
# the SWIG interface file instead.
# This file is compatible with both classic and new-style classes.
from sys import version_info
if version_info >= (2,6,0):
def swig_import_helper():
from os.path import dirname
import imp
fp = None
try:
fp, pathname, description = imp.find_module(‘_allog’, [dirname(__file__)])
except ImportError:
import _allog
return _allog
if fp is not None:
try:
_mod = imp.load_module(‘_allog’, fp, pathname, description)
finally:
fp.close()
return _mod
_allog = swig_import_helper()
del swig_import_helper
else:
import _allog
del version_info
try:
_swig_property = property
except NameError:
pass # Python < 2.2 doesn't have 'property'. 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__ == 'SwigPyObject': 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,)
try:
_object = object
_newclass = 1
except AttributeError:
class _object : pass
_newclass = 0

def debug(*args):
return _allog.debug(*args)
debug = _allog.debug
def info(*args):
return _allog.info(*args)
info = _allog.info
def warning(*args):
return _allog.warning(*args)
warning = _allog.warning
def error(*args):
return _allog.error(*args)
error = _allog.error
def fatal(*args):
return _allog.fatal(*args)
fatal = _allog.fatal

pynaoqi-python-2.6-naoqi-1.14-linux32/almath.py
# This file was automatically generated by SWIG (http://www.swig.org).
# Version 1.3.40
#
# Do not make changes to this file unless you know what you are doing–modify
# the SWIG interface file instead.
# This file is compatible with both classic and new-style classes.
from sys import version_info
if version_info >= (2,6,0):
def swig_import_helper():
from os.path import dirname
import imp
fp = None
try:
fp, pathname, description = imp.find_module(‘_almath’, [dirname(__file__)])
except ImportError:
import _almath
return _almath
if fp is not None:
try:
_mod = imp.load_module(‘_almath’, fp, pathname, description)
finally:
fp.close()
return _mod
_almath = swig_import_helper()
del swig_import_helper
else:
import _almath
del version_info
try:
_swig_property = property
except NameError:
pass # Python < 2.2 doesn't have 'property'. 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__ == 'SwigPyObject': 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,)
try:
_object = object
_newclass = 1
except AttributeError:
class _object : pass
_newclass = 0

class SwigPyIterator(_object):
“””Proxy of C++ swig::SwigPyIterator class”””
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, SwigPyIterator, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, SwigPyIterator, name)
def __init__(self, *args, **kwargs): raise AttributeError(“No constructor defined – class is abstract”)
__repr__ = _swig_repr
__swig_destroy__ = _almath.delete_SwigPyIterator
__del__ = lambda self : None;
def value(self):
“””value(self) -> PyObject”””
return _almath.SwigPyIterator_value(self)
def incr(self, n = 1):
“””
incr(self, size_t n = 1) -> SwigPyIterator
incr(self) -> SwigPyIterator
“””
return _almath.SwigPyIterator_incr(self, n)
def decr(self, n = 1):
“””
decr(self, size_t n = 1) -> SwigPyIterator
decr(self) -> SwigPyIterator
“””
return _almath.SwigPyIterator_decr(self, n)
def distance(self, *args):
“””distance(self, SwigPyIterator x) -> ptrdiff_t”””
return _almath.SwigPyIterator_distance(self, *args)
def equal(self, *args):
“””equal(self, SwigPyIterator x) -> bool”””
return _almath.SwigPyIterator_equal(self, *args)
def copy(self):
“””copy(self) -> SwigPyIterator”””
return _almath.SwigPyIterator_copy(self)
def next(self):
“””next(self) -> PyObject”””
return _almath.SwigPyIterator_next(self)
def __next__(self):
“””__next__(self) -> PyObject”””
return _almath.SwigPyIterator___next__(self)
def previous(self):
“””previous(self) -> PyObject”””
return _almath.SwigPyIterator_previous(self)
def advance(self, *args):
“””advance(self, ptrdiff_t n) -> SwigPyIterator”””
return _almath.SwigPyIterator_advance(self, *args)
def __eq__(self, *args):
“””__eq__(self, SwigPyIterator x) -> bool”””
return _almath.SwigPyIterator___eq__(self, *args)
def __ne__(self, *args):
“””__ne__(self, SwigPyIterator x) -> bool”””
return _almath.SwigPyIterator___ne__(self, *args)
def __iadd__(self, *args):
“””__iadd__(self, ptrdiff_t n) -> SwigPyIterator”””
return _almath.SwigPyIterator___iadd__(self, *args)
def __isub__(self, *args):
“””__isub__(self, ptrdiff_t n) -> SwigPyIterator”””
return _almath.SwigPyIterator___isub__(self, *args)
def __add__(self, *args):
“””__add__(self, ptrdiff_t n) -> SwigPyIterator”””
return _almath.SwigPyIterator___add__(self, *args)
def __sub__(self, *args):
“””
__sub__(self, ptrdiff_t n) -> SwigPyIterator
__sub__(self, SwigPyIterator x) -> ptrdiff_t
“””
return _almath.SwigPyIterator___sub__(self, *args)
def __iter__(self): return self
SwigPyIterator_swigregister = _almath.SwigPyIterator_swigregister
SwigPyIterator_swigregister(SwigPyIterator)
class vectorFloat(_object):
“””Proxy of C++ std::vector<(float)> class”””
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, vectorFloat, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, vectorFloat, name)
def iterator(self):
“””iterator(self) -> SwigPyIterator”””
return _almath.vectorFloat_iterator(self)
def __iter__(self): return self.iterator()
def __nonzero__(self):
“””__nonzero__(self) -> bool”””
return _almath.vectorFloat___nonzero__(self)
def __bool__(self):
“””__bool__(self) -> bool”””
return _almath.vectorFloat___bool__(self)
def __len__(self):
“””__len__(self) -> size_type”””
return _almath.vectorFloat___len__(self)
def pop(self):
“””pop(self) -> value_type”””
return _almath.vectorFloat_pop(self)
def __getslice__(self, *args):
“””__getslice__(self, difference_type i, difference_type j) -> vectorFloat”””
return _almath.vectorFloat___getslice__(self, *args)
def __setslice__(self, *args):
“””__setslice__(self, difference_type i, difference_type j, vectorFloat v)”””
return _almath.vectorFloat___setslice__(self, *args)
def __delslice__(self, *args):
“””__delslice__(self, difference_type i, difference_type j)”””
return _almath.vectorFloat___delslice__(self, *args)
def __delitem__(self, *args):
“””
__delitem__(self, difference_type i)
__delitem__(self, PySliceObject slice)
“””
return _almath.vectorFloat___delitem__(self, *args)
def __getitem__(self, *args):
“””
__getitem__(self, PySliceObject slice) -> vectorFloat
__getitem__(self, difference_type i) -> value_type
“””
return _almath.vectorFloat___getitem__(self, *args)
def __setitem__(self, *args):
“””
__setitem__(self, PySliceObject slice, vectorFloat v)
__setitem__(self, difference_type i, value_type x)
“””
return _almath.vectorFloat___setitem__(self, *args)
def append(self, *args):
“””append(self, value_type x)”””
return _almath.vectorFloat_append(self, *args)
def empty(self):
“””empty(self) -> bool”””
return _almath.vectorFloat_empty(self)
def size(self):
“””size(self) -> size_type”””
return _almath.vectorFloat_size(self)
def clear(self):
“””clear(self)”””
return _almath.vectorFloat_clear(self)
def swap(self, *args):
“””swap(self, vectorFloat v)”””
return _almath.vectorFloat_swap(self, *args)
def get_allocator(self):
“””get_allocator(self) -> allocator_type”””
return _almath.vectorFloat_get_allocator(self)
def begin(self):
“””begin(self) -> const_iterator”””
return _almath.vectorFloat_begin(self)
def end(self):
“””end(self) -> const_iterator”””
return _almath.vectorFloat_end(self)
def rbegin(self):
“””rbegin(self) -> const_reverse_iterator”””
return _almath.vectorFloat_rbegin(self)
def rend(self):
“””rend(self) -> const_reverse_iterator”””
return _almath.vectorFloat_rend(self)
def pop_back(self):
“””pop_back(self)”””
return _almath.vectorFloat_pop_back(self)
def erase(self, *args):
“””
erase(self, iterator pos) -> iterator
erase(self, iterator first, iterator last) -> iterator
“””
return _almath.vectorFloat_erase(self, *args)
def __init__(self, *args):
“””
__init__(self) -> vectorFloat
__init__(self, vectorFloat arg0) -> vectorFloat
__init__(self, size_type size) -> vectorFloat
__init__(self, size_type size, value_type value) -> vectorFloat
“””
this = _almath.new_vectorFloat(*args)
try: self.this.append(this)
except: self.this = this
def push_back(self, *args):
“””push_back(self, value_type x)”””
return _almath.vectorFloat_push_back(self, *args)
def front(self):
“””front(self) -> value_type”””
return _almath.vectorFloat_front(self)
def back(self):
“””back(self) -> value_type”””
return _almath.vectorFloat_back(self)
def assign(self, *args):
“””assign(self, size_type n, value_type x)”””
return _almath.vectorFloat_assign(self, *args)
def resize(self, *args):
“””
resize(self, size_type new_size)
resize(self, size_type new_size, value_type x)
“””
return _almath.vectorFloat_resize(self, *args)
def insert(self, *args):
“””
insert(self, iterator pos, value_type x) -> iterator
insert(self, iterator pos, size_type n, value_type x)
“””
return _almath.vectorFloat_insert(self, *args)
def reserve(self, *args):
“””reserve(self, size_type n)”””
return _almath.vectorFloat_reserve(self, *args)
def capacity(self):
“””capacity(self) -> size_type”””
return _almath.vectorFloat_capacity(self)
def __repr__(self):
“””__repr__(self) -> string”””
return _almath.vectorFloat___repr__(self)
__swig_destroy__ = _almath.delete_vectorFloat
__del__ = lambda self : None;
vectorFloat_swigregister = _almath.vectorFloat_swigregister
vectorFloat_swigregister(vectorFloat)
class vectorPosition2D(_object):
“””Proxy of C++ std::vector<(AL::Math::Position2D)> class”””
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, vectorPosition2D, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, vectorPosition2D, name)
def iterator(self):
“””iterator(self) -> SwigPyIterator”””
return _almath.vectorPosition2D_iterator(self)
def __iter__(self): return self.iterator()
def __nonzero__(self):
“””__nonzero__(self) -> bool”””
return _almath.vectorPosition2D___nonzero__(self)
def __bool__(self):
“””__bool__(self) -> bool”””
return _almath.vectorPosition2D___bool__(self)
def __len__(self):
“””__len__(self) -> size_type”””
return _almath.vectorPosition2D___len__(self)
def pop(self):
“””pop(self) -> value_type”””
return _almath.vectorPosition2D_pop(self)
def __getslice__(self, *args):
“””__getslice__(self, difference_type i, difference_type j) -> vectorPosition2D”””
return _almath.vectorPosition2D___getslice__(self, *args)
def __setslice__(self, *args):
“””__setslice__(self, difference_type i, difference_type j, vectorPosition2D v)”””
return _almath.vectorPosition2D___setslice__(self, *args)
def __delslice__(self, *args):
“””__delslice__(self, difference_type i, difference_type j)”””
return _almath.vectorPosition2D___delslice__(self, *args)
def __delitem__(self, *args):
“””
__delitem__(self, difference_type i)
__delitem__(self, PySliceObject slice)
“””
return _almath.vectorPosition2D___delitem__(self, *args)
def __getitem__(self, *args):
“””
__getitem__(self, PySliceObject slice) -> vectorPosition2D
__getitem__(self, difference_type i) -> value_type
“””
return _almath.vectorPosition2D___getitem__(self, *args)
def __setitem__(self, *args):
“””
__setitem__(self, PySliceObject slice, vectorPosition2D v)
__setitem__(self, difference_type i, value_type x)
“””
return _almath.vectorPosition2D___setitem__(self, *args)
def append(self, *args):
“””append(self, value_type x)”””
return _almath.vectorPosition2D_append(self, *args)
def empty(self):
“””empty(self) -> bool”””
return _almath.vectorPosition2D_empty(self)
def size(self):
“””size(self) -> size_type”””
return _almath.vectorPosition2D_size(self)
def clear(self):
“””clear(self)”””
return _almath.vectorPosition2D_clear(self)
def swap(self, *args):
“””swap(self, vectorPosition2D v)”””
return _almath.vectorPosition2D_swap(self, *args)
def get_allocator(self):
“””get_allocator(self) -> allocator_type”””
return _almath.vectorPosition2D_get_allocator(self)
def begin(self):
“””begin(self) -> const_iterator”””
return _almath.vectorPosition2D_begin(self)
def end(self):
“””end(self) -> const_iterator”””
return _almath.vectorPosition2D_end(self)
def rbegin(self):
“””rbegin(self) -> const_reverse_iterator”””
return _almath.vectorPosition2D_rbegin(self)
def rend(self):
“””rend(self) -> const_reverse_iterator”””
return _almath.vectorPosition2D_rend(self)
def pop_back(self):
“””pop_back(self)”””
return _almath.vectorPosition2D_pop_back(self)
def erase(self, *args):
“””
erase(self, iterator pos) -> iterator
erase(self, iterator first, iterator last) -> iterator
“””
return _almath.vectorPosition2D_erase(self, *args)
def __init__(self, *args):
“””
__init__(self) -> vectorPosition2D
__init__(self, vectorPosition2D arg0) -> vectorPosition2D
__init__(self, size_type size) -> vectorPosition2D
__init__(self, size_type size, value_type value) -> vectorPosition2D
“””
this = _almath.new_vectorPosition2D(*args)
try: self.this.append(this)
except: self.this = this
def push_back(self, *args):
“””push_back(self, value_type x)”””
return _almath.vectorPosition2D_push_back(self, *args)
def front(self):
“””front(self) -> value_type”””
return _almath.vectorPosition2D_front(self)
def back(self):
“””back(self) -> value_type”””
return _almath.vectorPosition2D_back(self)
def assign(self, *args):
“””assign(self, size_type n, value_type x)”””
return _almath.vectorPosition2D_assign(self, *args)
def resize(self, *args):
“””
resize(self, size_type new_size)
resize(self, size_type new_size, value_type x)
“””
return _almath.vectorPosition2D_resize(self, *args)
def insert(self, *args):
“””
insert(self, iterator pos, value_type x) -> iterator
insert(self, iterator pos, size_type n, value_type x)
“””
return _almath.vectorPosition2D_insert(self, *args)
def reserve(self, *args):
“””reserve(self, size_type n)”””
return _almath.vectorPosition2D_reserve(self, *args)
def capacity(self):
“””capacity(self) -> size_type”””
return _almath.vectorPosition2D_capacity(self)
def __repr__(self):
“””__repr__(self) -> string”””
return _almath.vectorPosition2D___repr__(self)
__swig_destroy__ = _almath.delete_vectorPosition2D
__del__ = lambda self : None;
vectorPosition2D_swigregister = _almath.vectorPosition2D_swigregister
vectorPosition2D_swigregister(vectorPosition2D)
class vectorPose2D(_object):
“””Proxy of C++ std::vector<(AL::Math::Pose2D)> class”””
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, vectorPose2D, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, vectorPose2D, name)
def iterator(self):
“””iterator(self) -> SwigPyIterator”””
return _almath.vectorPose2D_iterator(self)
def __iter__(self): return self.iterator()
def __nonzero__(self):
“””__nonzero__(self) -> bool”””
return _almath.vectorPose2D___nonzero__(self)
def __bool__(self):
“””__bool__(self) -> bool”””
return _almath.vectorPose2D___bool__(self)
def __len__(self):
“””__len__(self) -> size_type”””
return _almath.vectorPose2D___len__(self)
def pop(self):
“””pop(self) -> value_type”””
return _almath.vectorPose2D_pop(self)
def __getslice__(self, *args):
“””__getslice__(self, difference_type i, difference_type j) -> vectorPose2D”””
return _almath.vectorPose2D___getslice__(self, *args)
def __setslice__(self, *args):
“””__setslice__(self, difference_type i, difference_type j, vectorPose2D v)”””
return _almath.vectorPose2D___setslice__(self, *args)
def __delslice__(self, *args):
“””__delslice__(self, difference_type i, difference_type j)”””
return _almath.vectorPose2D___delslice__(self, *args)
def __delitem__(self, *args):
“””
__delitem__(self, difference_type i)
__delitem__(self, PySliceObject slice)
“””
return _almath.vectorPose2D___delitem__(self, *args)
def __getitem__(self, *args):
“””
__getitem__(self, PySliceObject slice) -> vectorPose2D
__getitem__(self, difference_type i) -> value_type
“””
return _almath.vectorPose2D___getitem__(self, *args)
def __setitem__(self, *args):
“””
__setitem__(self, PySliceObject slice, vectorPose2D v)
__setitem__(self, difference_type i, value_type x)
“””
return _almath.vectorPose2D___setitem__(self, *args)
def append(self, *args):
“””append(self, value_type x)”””
return _almath.vectorPose2D_append(self, *args)
def empty(self):
“””empty(self) -> bool”””
return _almath.vectorPose2D_empty(self)
def size(self):
“””size(self) -> size_type”””
return _almath.vectorPose2D_size(self)
def clear(self):
“””clear(self)”””
return _almath.vectorPose2D_clear(self)
def swap(self, *args):
“””swap(self, vectorPose2D v)”””
return _almath.vectorPose2D_swap(self, *args)
def get_allocator(self):
“””get_allocator(self) -> allocator_type”””
return _almath.vectorPose2D_get_allocator(self)
def begin(self):
“””begin(self) -> const_iterator”””
return _almath.vectorPose2D_begin(self)
def end(self):
“””end(self) -> const_iterator”””
return _almath.vectorPose2D_end(self)
def rbegin(self):
“””rbegin(self) -> const_reverse_iterator”””
return _almath.vectorPose2D_rbegin(self)
def rend(self):
“””rend(self) -> const_reverse_iterator”””
return _almath.vectorPose2D_rend(self)
def pop_back(self):
“””pop_back(self)”””
return _almath.vectorPose2D_pop_back(self)
def erase(self, *args):
“””
erase(self, iterator pos) -> iterator
erase(self, iterator first, iterator last) -> iterator
“””
return _almath.vectorPose2D_erase(self, *args)
def __init__(self, *args):
“””
__init__(self) -> vectorPose2D
__init__(self, vectorPose2D arg0) -> vectorPose2D
__init__(self, size_type size) -> vectorPose2D
__init__(self, size_type size, value_type value) -> vectorPose2D
“””
this = _almath.new_vectorPose2D(*args)
try: self.this.append(this)
except: self.this = this
def push_back(self, *args):
“””push_back(self, value_type x)”””
return _almath.vectorPose2D_push_back(self, *args)
def front(self):
“””front(self) -> value_type”””
return _almath.vectorPose2D_front(self)
def back(self):
“””back(self) -> value_type”””
return _almath.vectorPose2D_back(self)
def assign(self, *args):
“””assign(self, size_type n, value_type x)”””
return _almath.vectorPose2D_assign(self, *args)
def resize(self, *args):
“””
resize(self, size_type new_size)
resize(self, size_type new_size, value_type x)
“””
return _almath.vectorPose2D_resize(self, *args)
def insert(self, *args):
“””
insert(self, iterator pos, value_type x) -> iterator
insert(self, iterator pos, size_type n, value_type x)
“””
return _almath.vectorPose2D_insert(self, *args)
def reserve(self, *args):
“””reserve(self, size_type n)”””
return _almath.vectorPose2D_reserve(self, *args)
def capacity(self):
“””capacity(self) -> size_type”””
return _almath.vectorPose2D_capacity(self)
def __repr__(self):
“””__repr__(self) -> string”””
return _almath.vectorPose2D___repr__(self)
__swig_destroy__ = _almath.delete_vectorPose2D
__del__ = lambda self : None;
vectorPose2D_swigregister = _almath.vectorPose2D_swigregister
vectorPose2D_swigregister(vectorPose2D)
class vectorPosition6D(_object):
“””Proxy of C++ std::vector<(AL::Math::Position6D)> class”””
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, vectorPosition6D, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, vectorPosition6D, name)
def iterator(self):
“””iterator(self) -> SwigPyIterator”””
return _almath.vectorPosition6D_iterator(self)
def __iter__(self): return self.iterator()
def __nonzero__(self):
“””__nonzero__(self) -> bool”””
return _almath.vectorPosition6D___nonzero__(self)
def __bool__(self):
“””__bool__(self) -> bool”””
return _almath.vectorPosition6D___bool__(self)
def __len__(self):
“””__len__(self) -> size_type”””
return _almath.vectorPosition6D___len__(self)
def pop(self):
“””pop(self) -> value_type”””
return _almath.vectorPosition6D_pop(self)
def __getslice__(self, *args):
“””__getslice__(self, difference_type i, difference_type j) -> vectorPosition6D”””
return _almath.vectorPosition6D___getslice__(self, *args)
def __setslice__(self, *args):
“””__setslice__(self, difference_type i, difference_type j, vectorPosition6D v)”””
return _almath.vectorPosition6D___setslice__(self, *args)
def __delslice__(self, *args):
“””__delslice__(self, difference_type i, difference_type j)”””
return _almath.vectorPosition6D___delslice__(self, *args)
def __delitem__(self, *args):
“””
__delitem__(self, difference_type i)
__delitem__(self, PySliceObject slice)
“””
return _almath.vectorPosition6D___delitem__(self, *args)
def __getitem__(self, *args):
“””
__getitem__(self, PySliceObject slice) -> vectorPosition6D
__getitem__(self, difference_type i) -> value_type
“””
return _almath.vectorPosition6D___getitem__(self, *args)
def __setitem__(self, *args):
“””
__setitem__(self, PySliceObject slice, vectorPosition6D v)
__setitem__(self, difference_type i, value_type x)
“””
return _almath.vectorPosition6D___setitem__(self, *args)
def append(self, *args):
“””append(self, value_type x)”””
return _almath.vectorPosition6D_append(self, *args)
def empty(self):
“””empty(self) -> bool”””
return _almath.vectorPosition6D_empty(self)
def size(self):
“””size(self) -> size_type”””
return _almath.vectorPosition6D_size(self)
def clear(self):
“””clear(self)”””
return _almath.vectorPosition6D_clear(self)
def swap(self, *args):
“””swap(self, vectorPosition6D v)”””
return _almath.vectorPosition6D_swap(self, *args)
def get_allocator(self):
“””get_allocator(self) -> allocator_type”””
return _almath.vectorPosition6D_get_allocator(self)
def begin(self):
“””begin(self) -> const_iterator”””
return _almath.vectorPosition6D_begin(self)
def end(self):
“””end(self) -> const_iterator”””
return _almath.vectorPosition6D_end(self)
def rbegin(self):
“””rbegin(self) -> const_reverse_iterator”””
return _almath.vectorPosition6D_rbegin(self)
def rend(self):
“””rend(self) -> const_reverse_iterator”””
return _almath.vectorPosition6D_rend(self)
def pop_back(self):
“””pop_back(self)”””
return _almath.vectorPosition6D_pop_back(self)
def erase(self, *args):
“””
erase(self, iterator pos) -> iterator
erase(self, iterator first, iterator last) -> iterator
“””
return _almath.vectorPosition6D_erase(self, *args)
def __init__(self, *args):
“””
__init__(self) -> vectorPosition6D
__init__(self, vectorPosition6D arg0) -> vectorPosition6D
__init__(self, size_type size) -> vectorPosition6D
__init__(self, size_type size, value_type value) -> vectorPosition6D
“””
this = _almath.new_vectorPosition6D(*args)
try: self.this.append(this)
except: self.this = this
def push_back(self, *args):
“””push_back(self, value_type x)”””
return _almath.vectorPosition6D_push_back(self, *args)
def front(self):
“””front(self) -> value_type”””
return _almath.vectorPosition6D_front(self)
def back(self):
“””back(self) -> value_type”””
return _almath.vectorPosition6D_back(self)
def assign(self, *args):
“””assign(self, size_type n, value_type x)”””
return _almath.vectorPosition6D_assign(self, *args)
def resize(self, *args):
“””
resize(self, size_type new_size)
resize(self, size_type new_size, value_type x)
“””
return _almath.vectorPosition6D_resize(self, *args)
def insert(self, *args):
“””
insert(self, iterator pos, value_type x) -> iterator
insert(self, iterator pos, size_type n, value_type x)
“””
return _almath.vectorPosition6D_insert(self, *args)
def reserve(self, *args):
“””reserve(self, size_type n)”””
return _almath.vectorPosition6D_reserve(self, *args)
def capacity(self):
“””capacity(self) -> size_type”””
return _almath.vectorPosition6D_capacity(self)
def __repr__(self):
“””__repr__(self) -> string”””
return _almath.vectorPosition6D___repr__(self)
__swig_destroy__ = _almath.delete_vectorPosition6D
__del__ = lambda self : None;
vectorPosition6D_swigregister = _almath.vectorPosition6D_swigregister
vectorPosition6D_swigregister(vectorPosition6D)
class Pose2D(_object):
“””Proxy of C++ AL::Math::Pose2D class”””
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, Pose2D, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, Pose2D, name)
__swig_setmethods__[“x”] = _almath.Pose2D_x_set
__swig_getmethods__[“x”] = _almath.Pose2D_x_get
if _newclass:x = _swig_property(_almath.Pose2D_x_get, _almath.Pose2D_x_set)
__swig_setmethods__[“y”] = _almath.Pose2D_y_set
__swig_getmethods__[“y”] = _almath.Pose2D_y_get
if _newclass:y = _swig_property(_almath.Pose2D_y_get, _almath.Pose2D_y_set)
__swig_setmethods__[“theta”] = _almath.Pose2D_theta_set
__swig_getmethods__[“theta”] = _almath.Pose2D_theta_get
if _newclass:theta = _swig_property(_almath.Pose2D_theta_get, _almath.Pose2D_theta_set)
def __init__(self, *args):
“””
__init__(self) -> Pose2D
__init__(self, float pInit) -> Pose2D
__init__(self, float pX, float pY, float pTheta) -> Pose2D
__init__(self, vectorFloat pFloats) -> Pose2D
“””
this = _almath.new_Pose2D(*args)
try: self.this.append(this)
except: self.this = this
def __add__(self, *args):
“””__add__(self, Pose2D pPos2) -> Pose2D”””
return _almath.Pose2D___add__(self, *args)
def __sub__(self, *args):
“””__sub__(self, Pose2D pPos2) -> Pose2D”””
return _almath.Pose2D___sub__(self, *args)
def __pos__(self):
“””__pos__(self) -> Pose2D”””
return _almath.Pose2D___pos__(self)
def __neg__(self):
“””__neg__(self) -> Pose2D”””
return _almath.Pose2D___neg__(self)
def __iadd__(self, *args):
“””__iadd__(self, Pose2D pPos2) -> Pose2D”””
return _almath.Pose2D___iadd__(self, *args)
def __isub__(self, *args):
“””__isub__(self, Pose2D pPos2) -> Pose2D”””
return _almath.Pose2D___isub__(self, *args)
def __eq__(self, *args):
“””__eq__(self, Pose2D pPos2) -> bool”””
return _almath.Pose2D___eq__(self, *args)
def __ne__(self, *args):
“””__ne__(self, Pose2D pPos2) -> bool”””
return _almath.Pose2D___ne__(self, *args)
def __mul__(self, *args):
“””
__mul__(self, Pose2D pPos2) -> Pose2D
__mul__(self, float pVal) -> Pose2D
“””
return _almath.Pose2D___mul__(self, *args)
def __div__(self, *args):
“””__div__(self, float pVal) -> Pose2D”””
return _almath.Pose2D___div__(self, *args)
def __imul__(self, *args):
“””
__imul__(self, Pose2D pPos2) -> Pose2D
__imul__(self, float pVal) -> Pose2D
“””
return _almath.Pose2D___imul__(self, *args)
def __idiv__(self, *args):
“””__idiv__(self, float pVal) -> Pose2D”””
return _almath.Pose2D___idiv__(self, *args)
def distanceSquared(self, *args):
“””distanceSquared(self, Pose2D pPos2) -> float”””
return _almath.Pose2D_distanceSquared(self, *args)
def distance(self, *args):
“””distance(self, Pose2D pPos2) -> float”””
return _almath.Pose2D_distance(self, *args)
def inverse(self):
“””inverse(self) -> Pose2D”””
return _almath.Pose2D_inverse(self)
def isNear(self, *args):
“””
isNear(self, Pose2D pPos2, float pEpsilon = 0.0001) -> bool
isNear(self, Pose2D pPos2) -> bool
“””
return _almath.Pose2D_isNear(self, *args)
def toVector(self):
“””toVector(self) -> vectorFloat”””
return _almath.Pose2D_toVector(self)
def __repr__(self):
“””__repr__(self) -> char”””
return _almath.Pose2D___repr__(self)
def __rmul__(self, *args):
“””__rmul__(self, float lhs) -> Pose2D”””
return _almath.Pose2D___rmul__(self, *args)
__swig_destroy__ = _almath.delete_Pose2D
__del__ = lambda self : None;
Pose2D_swigregister = _almath.Pose2D_swigregister
Pose2D_swigregister(Pose2D)
cvar = _almath.cvar
AXIS_MASK_X = cvar.AXIS_MASK_X
AXIS_MASK_Y = cvar.AXIS_MASK_Y
AXIS_MASK_XY = cvar.AXIS_MASK_XY
AXIS_MASK_Z = cvar.AXIS_MASK_Z
AXIS_MASK_WX = cvar.AXIS_MASK_WX
AXIS_MASK_WY = cvar.AXIS_MASK_WY
AXIS_MASK_WZ = cvar.AXIS_MASK_WZ
AXIS_MASK_WYWZ = cvar.AXIS_MASK_WYWZ
AXIS_MASK_ALL = cvar.AXIS_MASK_ALL
AXIS_MASK_VEL = cvar.AXIS_MASK_VEL
AXIS_MASK_ROT = cvar.AXIS_MASK_ROT
AXIS_MASK_NONE = cvar.AXIS_MASK_NONE
class Position2D(_object):
“””Proxy of C++ AL::Math::Position2D class”””
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, Position2D, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, Position2D, name)
__swig_setmethods__[“x”] = _almath.Position2D_x_set
__swig_getmethods__[“x”] = _almath.Position2D_x_get
if _newclass:x = _swig_property(_almath.Position2D_x_get, _almath.Position2D_x_set)
__swig_setmethods__[“y”] = _almath.Position2D_y_set
__swig_getmethods__[“y”] = _almath.Position2D_y_get
if _newclass:y = _swig_property(_almath.Position2D_y_get, _almath.Position2D_y_set)
def __init__(self, *args):
“””
__init__(self) -> Position2D
__init__(self, float pInit) -> Position2D
__init__(self, float pX, float pY) -> Position2D
__init__(self, vectorFloat pFloats) -> Position2D
“””
this = _almath.new_Position2D(*args)
try: self.this.append(this)
except: self.this = this
def __add__(self, *args):
“””__add__(self, Position2D pPos2) -> Position2D”””
return _almath.Position2D___add__(self, *args)
def __sub__(self, *args):
“””__sub__(self, Position2D pPos2) -> Position2D”””
return _almath.Position2D___sub__(self, *args)
def __pos__(self):
“””__pos__(self) -> Position2D”””
return _almath.Position2D___pos__(self)
def __neg__(self):
“””__neg__(self) -> Position2D”””
return _almath.Position2D___neg__(self)
def __iadd__(self, *args):
“””__iadd__(self, Position2D pPos2) -> Position2D”””
return _almath.Position2D___iadd__(self, *args)
def __isub__(self, *args):
“””__isub__(self, Position2D pPos2) -> Position2D”””
return _almath.Position2D___isub__(self, *args)
def __eq__(self, *args):
“””__eq__(self, Position2D pPos2) -> bool”””
return _almath.Position2D___eq__(self, *args)
def __ne__(self, *args):
“””__ne__(self, Position2D pPos2) -> bool”””
return _almath.Position2D___ne__(self, *args)
def __mul__(self, *args):
“””__mul__(self, float pVal) -> Position2D”””
return _almath.Position2D___mul__(self, *args)
def __div__(self, *args):
“””__div__(self, float pVal) -> Position2D”””
return _almath.Position2D___div__(self, *args)
def __imul__(self, *args):
“””__imul__(self, float pVal) -> Position2D”””
return _almath.Position2D___imul__(self, *args)
def __idiv__(self, *args):
“””__idiv__(self, float pVal) -> Position2D”””
return _almath.Position2D___idiv__(self, *args)
def distanceSquared(self, *args):
“””distanceSquared(self, Position2D pPos2) -> float”””
return _almath.Position2D_distanceSquared(self, *args)
def distance(self, *args):
“””distance(self, Position2D pPos2) -> float”””
return _almath.Position2D_distance(self, *args)
def isNear(self, *args):
“””
isNear(self, Position2D pPos2, float pEpsilon = 0.0001) -> bool
isNear(self, Position2D pPos2) -> bool
“””
return _almath.Position2D_isNear(self, *args)
def norm(self):
“””norm(self) -> float”””
return _almath.Position2D_norm(self)
def normalize(self):
“””normalize(self) -> Position2D”””
return _almath.Position2D_normalize(self)
def crossProduct(self, *args):
“””crossProduct(self, Position2D pPos2) -> float”””
return _almath.Position2D_crossProduct(self, *args)
def toVector(self):
“””toVector(self) -> vectorFloat”””
return _almath.Position2D_toVector(self)
def __repr__(self):
“””__repr__(self) -> char”””
return _almath.Position2D___repr__(self)
def __rmul__(self, *args):
“””__rmul__(self, float lhs) -> Position2D”””
return _almath.Position2D___rmul__(self, *args)
__swig_destroy__ = _almath.delete_Position2D
__del__ = lambda self : None;
Position2D_swigregister = _almath.Position2D_swigregister
Position2D_swigregister(Position2D)
def pose2DInverse(*args):
“””
pose2DInverse(Pose2D pPos) -> Pose2D
pose2DInverse(Pose2D pPos, Pose2D pRes)
“””
return _almath.pose2DInverse(*args)
class Position3D(_object):
“””Proxy of C++ AL::Math::Position3D class”””
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, Position3D, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, Position3D, name)
__swig_setmethods__[“x”] = _almath.Position3D_x_set
__swig_getmethods__[“x”] = _almath.Position3D_x_get
if _newclass:x = _swig_property(_almath.Position3D_x_get, _almath.Position3D_x_set)
__swig_setmethods__[“y”] = _almath.Position3D_y_set
__swig_getmethods__[“y”] = _almath.Position3D_y_get
if _newclass:y = _swig_property(_almath.Position3D_y_get, _almath.Position3D_y_set)
__swig_setmethods__[“z”] = _almath.Position3D_z_set
__swig_getmethods__[“z”] = _almath.Position3D_z_get
if _newclass:z = _swig_property(_almath.Position3D_z_get, _almath.Position3D_z_set)
def __init__(self, *args):
“””
__init__(self) -> Position3D
__init__(self, float pInit) -> Position3D
__init__(self, float pX, float pY, float pZ) -> Position3D
__init__(self, vectorFloat pFloats) -> Position3D
“””
this = _almath.new_Position3D(*args)
try: self.this.append(this)
except: self.this = this
def __add__(self, *args):
“””__add__(self, Position3D pPos2) -> Position3D”””
return _almath.Position3D___add__(self, *args)
def __sub__(self, *args):
“””__sub__(self, Position3D pPos2) -> Position3D”””
return _almath.Position3D___sub__(self, *args)
def __pos__(self):
“””__pos__(self) -> Position3D”””
return _almath.Position3D___pos__(self)
def __neg__(self):
“””__neg__(self) -> Position3D”””
return _almath.Position3D___neg__(self)
def __iadd__(self, *args):
“””__iadd__(self, Position3D pPos2) -> Position3D”””
return _almath.Position3D___iadd__(self, *args)
def __isub__(self, *args):
“””__isub__(self, Position3D pPos2) -> Position3D”””
return _almath.Position3D___isub__(self, *args)
def __eq__(self, *args):
“””__eq__(self, Position3D pPos2) -> bool”””
return _almath.Position3D___eq__(self, *args)
def __ne__(self, *args):
“””__ne__(self, Position3D pPos2) -> bool”””
return _almath.Position3D___ne__(self, *args)
def __mul__(self, *args):
“””__mul__(self, float pVal) -> Position3D”””
return _almath.Position3D___mul__(self, *args)
def __div__(self, *args):
“””__div__(self, float pVal) -> Position3D”””
return _almath.Position3D___div__(self, *args)
def __imul__(self, *args):
“””__imul__(self, float pVal) -> Position3D”””
return _almath.Position3D___imul__(self, *args)
def __idiv__(self, *args):
“””__idiv__(self, float pVal) -> Position3D”””
return _almath.Position3D___idiv__(self, *args)
def distanceSquared(self, *args):
“””distanceSquared(self, Position3D pPos2) -> float”””
return _almath.Position3D_distanceSquared(self, *args)
def distance(self, *args):
“””distance(self, Position3D pPos2) -> float”””
return _almath.Position3D_distance(self, *args)
def isNear(self, *args):
“””
isNear(self, Position3D pPos2, float pEpsilon = 0.0001) -> bool
isNear(self, Position3D pPos2) -> bool
“””
return _almath.Position3D_isNear(self, *args)
def norm(self):
“””norm(self) -> float”””
return _almath.Position3D_norm(self)
def normalize(self):
“””normalize(self) -> Position3D”””
return _almath.Position3D_normalize(self)
def dotProduct(self, *args):
“””dotProduct(self, Position3D pPos2) -> float”””
return _almath.Position3D_dotProduct(self, *args)
def crossProduct(self, *args):
“””crossProduct(self, Position3D pPos2) -> Position3D”””
return _almath.Position3D_crossProduct(self, *args)
def toVector(self):
“””toVector(self) -> vectorFloat”””
return _almath.Position3D_toVector(self)
def __repr__(self):
“””__repr__(self) -> char”””
return _almath.Position3D___repr__(self)
def __rmul__(self, *args):
“””__rmul__(self, float lhs) -> Position3D”””
return _almath.Position3D___rmul__(self, *args)
__swig_destroy__ = _almath.delete_Position3D
__del__ = lambda self : None;
Position3D_swigregister = _almath.Position3D_swigregister
Position3D_swigregister(Position3D)

def __div__(*args):
“””__div__(float pM, Position3D pPos1) -> Position3D”””
return _almath.__div__(*args)
def dotProduct(*args):
“””dotProduct(Position3D pPos1, Position3D pPos2) -> float”””
return _almath.dotProduct(*args)
class Position6D(_object):
“””Proxy of C++ AL::Math::Position6D class”””
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, Position6D, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, Position6D, name)
__swig_setmethods__[“x”] = _almath.Position6D_x_set
__swig_getmethods__[“x”] = _almath.Position6D_x_get
if _newclass:x = _swig_property(_almath.Position6D_x_get, _almath.Position6D_x_set)
__swig_setmethods__[“y”] = _almath.Position6D_y_set
__swig_getmethods__[“y”] = _almath.Position6D_y_get
if _newclass:y = _swig_property(_almath.Position6D_y_get, _almath.Position6D_y_set)
__swig_setmethods__[“z”] = _almath.Position6D_z_set
__swig_getmethods__[“z”] = _almath.Position6D_z_get
if _newclass:z = _swig_property(_almath.Position6D_z_get, _almath.Position6D_z_set)
__swig_setmethods__[“wx”] = _almath.Position6D_wx_set
__swig_getmethods__[“wx”] = _almath.Position6D_wx_get
if _newclass:wx = _swig_property(_almath.Position6D_wx_get, _almath.Position6D_wx_set)
__swig_setmethods__[“wy”] = _almath.Position6D_wy_set
__swig_getmethods__[“wy”] = _almath.Position6D_wy_get
if _newclass:wy = _swig_property(_almath.Position6D_wy_get, _almath.Position6D_wy_set)
__swig_setmethods__[“wz”] = _almath.Position6D_wz_set
__swig_getmethods__[“wz”] = _almath.Position6D_wz_get
if _newclass:wz = _swig_property(_almath.Position6D_wz_get, _almath.Position6D_wz_set)
def __init__(self, *args):
“””
__init__(self) -> Position6D
__init__(self, float pInit) -> Position6D
__init__(self, float pX, float pY, float pZ, float pWx, float pWy,
float pWz) -> Position6D
__init__(self, vectorFloat pFloats) -> Position6D
“””
this = _almath.new_Position6D(*args)
try: self.this.append(this)
except: self.this = this
def __add__(self, *args):
“””__add__(self, Position6D pPos2) -> Position6D”””
return _almath.Position6D___add__(self, *args)
def __sub__(self, *args):
“””__sub__(self, Position6D pPos2) -> Position6D”””
return _almath.Position6D___sub__(self, *args)
def __pos__(self):
“””__pos__(self) -> Position6D”””
return _almath.Position6D___pos__(self)
def __neg__(self):
“””__neg__(self) -> Position6D”””
return _almath.Position6D___neg__(self)
def __iadd__(self, *args):
“””__iadd__(self, Position6D pPos2) -> Position6D”””
return _almath.Position6D___iadd__(self, *args)
def __isub__(self, *args):
“””__isub__(self, Position6D pPos2) -> Position6D”””
return _almath.Position6D___isub__(self, *args)
def __eq__(self, *args):
“””__eq__(self, Position6D pPos2) -> bool”””
return _almath.Position6D___eq__(self, *args)
def __ne__(self, *args):
“””__ne__(self, Position6D pPos2) -> bool”””
return _almath.Position6D___ne__(self, *args)
def __mul__(self, *args):
“””__mul__(self, float pVal) -> Position6D”””
return _almath.Position6D___mul__(self, *args)
def __div__(self, *args):
“””__div__(self, float pVal) -> Position6D”””
return _almath.Position6D___div__(self, *args)
def __imul__(self, *args):
“””__imul__(self, float pVal) -> Position6D”””
return _almath.Position6D___imul__(self, *args)
def __idiv__(self, *args):
“””__idiv__(self, float pVal) -> Position6D”””
return _almath.Position6D___idiv__(self, *args)
def isNear(self, *args):
“””
isNear(self, Position6D pPos2, float pEpsilon = 0.0001) -> bool
isNear(self, Position6D pPos2) -> bool
“””
return _almath.Position6D_isNear(self, *args)
def distanceSquared(self, *args):
“””distanceSquared(self, Position6D pPos2) -> float”””
return _almath.Position6D_distanceSquared(self, *args)
def distance(self, *args):
“””distance(self, Position6D pPos2) -> float”””
return _almath.Position6D_distance(self, *args)
def norm(self):
“””norm(self) -> float”””
return _almath.Position6D_norm(self)
def toVector(self):
“””toVector(self) -> vectorFloat”””
return _almath.Position6D_toVector(self)
def __repr__(self):
“””__repr__(self) -> char”””
return _almath.Position6D___repr__(self)
def __rmul__(self, *args):
“””__rmul__(self, float lhs) -> Position6D”””
return _almath.Position6D___rmul__(self, *args)
__swig_destroy__ = _almath.delete_Position6D
__del__ = lambda self : None;
Position6D_swigregister = _almath.Position6D_swigregister
Position6D_swigregister(Position6D)
def crossProduct(*args):
“””
crossProduct(Position2D pPos1, Position2D pPos2) -> float
crossProduct(Position2D pPos1, Position2D pPos2, float pRes)
crossProduct(Position3D pPos1, Position3D pPos2) -> Position3D
crossProduct(Position3D pPos1, Position3D pPos2, Position3D pRes)
“””
return _almath.crossProduct(*args)
class PositionAndVelocity(_object):
“””Proxy of C++ AL::Math::PositionAndVelocity class”””
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, PositionAndVelocity, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, PositionAndVelocity, name)
__swig_setmethods__[“q”] = _almath.PositionAndVelocity_q_set
__swig_getmethods__[“q”] = _almath.PositionAndVelocity_q_get
if _newclass:q = _swig_property(_almath.PositionAndVelocity_q_get, _almath.PositionAndVelocity_q_set)
__swig_setmethods__[“dq”] = _almath.PositionAndVelocity_dq_set
__swig_getmethods__[“dq”] = _almath.PositionAndVelocity_dq_get
if _newclass:dq = _swig_property(_almath.PositionAndVelocity_dq_get, _almath.PositionAndVelocity_dq_set)
def __init__(self, pq = 0.0, pdq = 0.0):
“””
__init__(self, float pq = 0.0, float pdq = 0.0) -> PositionAndVelocity
__init__(self, float pq = 0.0) -> PositionAndVelocity
__init__(self) -> PositionAndVelocity
“””
this = _almath.new_PositionAndVelocity(pq, pdq)
try: self.this.append(this)
except: self.this = this
def isNear(self, *args):
“””
isNear(self, PositionAndVelocity pDat2, float pEpsilon = 0.0001) -> bool
isNear(self, PositionAndVelocity pDat2) -> bool
“””
return _almath.PositionAndVelocity_isNear(self, *args)
def __repr__(self):
“””__repr__(self) -> char”””
return _almath.PositionAndVelocity___repr__(self)
__swig_destroy__ = _almath.delete_PositionAndVelocity
__del__ = lambda self : None;
PositionAndVelocity_swigregister = _almath.PositionAndVelocity_swigregister
PositionAndVelocity_swigregister(PositionAndVelocity)
def distanceSquared(*args):
“””
distanceSquared(Pose2D pPos1, Pose2D pPos2) -> float
distanceSquared(Position2D pPos1, Position2D pPos2) -> float
distanceSquared(Position3D pPos1, Position3D pPos2) -> float
distanceSquared(Position6D pPos1, Position6D pPos2) -> float
“””
return _almath.distanceSquared(*args)
def distance(*args):
“””
distance(Pose2D pPos1, Pose2D pPos2) -> float
distance(Position2D pPos1, Position2D pPos2) -> float
distance(Position3D pPos1, Position3D pPos2) -> float
distance(Position6D pPos1, Position6D pPos2) -> float
“””
return _almath.distance(*args)
class Quaternion(_object):
“””Proxy of C++ AL::Math::Quaternion class”””
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, Quaternion, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, Quaternion, name)
__swig_setmethods__[“w”] = _almath.Quaternion_w_set
__swig_getmethods__[“w”] = _almath.Quaternion_w_get
if _newclass:w = _swig_property(_almath.Quaternion_w_get, _almath.Quaternion_w_set)
__swig_setmethods__[“x”] = _almath.Quaternion_x_set
__swig_getmethods__[“x”] = _almath.Quaternion_x_get
if _newclass:x = _swig_property(_almath.Quaternion_x_get, _almath.Quaternion_x_set)
__swig_setmethods__[“y”] = _almath.Quaternion_y_set
__swig_getmethods__[“y”] = _almath.Quaternion_y_get
if _newclass:y = _swig_property(_almath.Quaternion_y_get, _almath.Quaternion_y_set)
__swig_setmethods__[“z”] = _almath.Quaternion_z_set
__swig_getmethods__[“z”] = _almath.Quaternion_z_get
if _newclass:z = _swig_property(_almath.Quaternion_z_get, _almath.Quaternion_z_set)
def __init__(self, *args):
“””
__init__(self) -> Quaternion
__init__(self, float pW, float pX, float pY, float pZ) -> Quaternion
__init__(self, vectorFloat pFloats) -> Quaternion
“””
this = _almath.new_Quaternion(*args)
try: self.this.append(this)
except: self.this = this
def __mul__(self, *args):
“””__mul__(self, Quaternion pQua2) -> Quaternion”””
return _almath.Quaternion___mul__(self, *args)
def __eq__(self, *args):
“””__eq__(self, Quaternion pQua2) -> bool”””
return _almath.Quaternion___eq__(self, *args)
def __ne__(self, *args):
“””__ne__(self, Quaternion pQua2) -> bool”””
return _almath.Quaternion___ne__(self, *args)
def __imul__(self, *args):
“””
__imul__(self, Quaternion pQu2) -> Quaternion
__imul__(self, float pVal) -> Quaternion
“””
return _almath.Quaternion___imul__(self, *args)
def __idiv__(self, *args):
“””__idiv__(self, float pVal) -> Quaternion”””
return _almath.Quaternion___idiv__(self, *args)
def isNear(self, *args):
“””
isNear(self, Quaternion pQua2, float pEpsilon = 0.0001) -> bool
isNear(self, Quaternion pQua2) -> bool
“””
return _almath.Quaternion_isNear(self, *args)
def norm(self):
“””norm(self) -> float”””
return _almath.Quaternion_norm(self)
def normalize(self):
“””normalize(self) -> Quaternion”””
return _almath.Quaternion_normalize(self)
def inverse(self):
“””inverse(self) -> Quaternion”””
return _almath.Quaternion_inverse(self)
def fromAngleAndAxisRotation(*args):
“””fromAngleAndAxisRotation(float pAngle, float pAxisX, float pAxisY, float pAxisZ) -> Quaternion”””
return _almath.Quaternion_fromAngleAndAxisRotation(*args)
if _newclass:fromAngleAndAxisRotation = staticmethod(fromAngleAndAxisRotation)
__swig_getmethods__[“fromAngleAndAxisRotation”] = lambda x: fromAngleAndAxisRotation
def toVector(self):
“””toVector(self) -> vectorFloat”””
return _almath.Quaternion_toVector(self)
def __repr__(self):
“””__repr__(self) -> char”””
return _almath.Quaternion___repr__(self)
__swig_destroy__ = _almath.delete_Quaternion
__del__ = lambda self : None;
Quaternion_swigregister = _almath.Quaternion_swigregister
Quaternion_swigregister(Quaternion)
def Quaternion_fromAngleAndAxisRotation(*args):
“””Quaternion_fromAngleAndAxisRotation(float pAngle, float pAxisX, float pAxisY, float pAxisZ) -> Quaternion”””
return _almath.Quaternion_fromAngleAndAxisRotation(*args)

def quaternionFromAngleAndAxisRotation(*args):
“””quaternionFromAngleAndAxisRotation(float pAngle, float pAxisX, float pAxisY, float pAxisZ) -> Quaternion”””
return _almath.quaternionFromAngleAndAxisRotation(*args)
def angleAndAxisRotationFromQuaternion(*args):
“””
angleAndAxisRotationFromQuaternion(Quaternion pQuaternion, float pAngle, float pAxisX,
float pAxisY, float pAxisZ)
“””
return _almath.angleAndAxisRotationFromQuaternion(*args)
class Rotation(_object):
“””Proxy of C++ AL::Math::Rotation class”””
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, Rotation, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, Rotation, name)
__swig_setmethods__[“r1_c1”] = _almath.Rotation_r1_c1_set
__swig_getmethods__[“r1_c1”] = _almath.Rotation_r1_c1_get
if _newclass:r1_c1 = _swig_property(_almath.Rotation_r1_c1_get, _almath.Rotation_r1_c1_set)
__swig_setmethods__[“r1_c2”] = _almath.Rotation_r1_c2_set
__swig_getmethods__[“r1_c2”] = _almath.Rotation_r1_c2_get
if _newclass:r1_c2 = _swig_property(_almath.Rotation_r1_c2_get, _almath.Rotation_r1_c2_set)
__swig_setmethods__[“r1_c3”] = _almath.Rotation_r1_c3_set
__swig_getmethods__[“r1_c3”] = _almath.Rotation_r1_c3_get
if _newclass:r1_c3 = _swig_property(_almath.Rotation_r1_c3_get, _almath.Rotation_r1_c3_set)
__swig_setmethods__[“r2_c1”] = _almath.Rotation_r2_c1_set
__swig_getmethods__[“r2_c1”] = _almath.Rotation_r2_c1_get
if _newclass:r2_c1 = _swig_property(_almath.Rotation_r2_c1_get, _almath.Rotation_r2_c1_set)
__swig_setmethods__[“r2_c2”] = _almath.Rotation_r2_c2_set
__swig_getmethods__[“r2_c2”] = _almath.Rotation_r2_c2_get
if _newclass:r2_c2 = _swig_property(_almath.Rotation_r2_c2_get, _almath.Rotation_r2_c2_set)
__swig_setmethods__[“r2_c3”] = _almath.Rotation_r2_c3_set
__swig_getmethods__[“r2_c3”] = _almath.Rotation_r2_c3_get
if _newclass:r2_c3 = _swig_property(_almath.Rotation_r2_c3_get, _almath.Rotation_r2_c3_set)
__swig_setmethods__[“r3_c1”] = _almath.Rotation_r3_c1_set
__swig_getmethods__[“r3_c1”] = _almath.Rotation_r3_c1_get
if _newclass:r3_c1 = _swig_property(_almath.Rotation_r3_c1_get, _almath.Rotation_r3_c1_set)
__swig_setmethods__[“r3_c2”] = _almath.Rotation_r3_c2_set
__swig_getmethods__[“r3_c2”] = _almath.Rotation_r3_c2_get
if _newclass:r3_c2 = _swig_property(_almath.Rotation_r3_c2_get, _almath.Rotation_r3_c2_set)
__swig_setmethods__[“r3_c3”] = _almath.Rotation_r3_c3_set
__swig_getmethods__[“r3_c3”] = _almath.Rotation_r3_c3_get
if _newclass:r3_c3 = _swig_property(_almath.Rotation_r3_c3_get, _almath.Rotation_r3_c3_set)
def __init__(self, *args):
“””
__init__(self) -> Rotation
__init__(self, vectorFloat pFloats) -> Rotation
“””
this = _almath.new_Rotation(*args)
try: self.this.append(this)
except: self.this = this
def __imul__(self, *args):
“””__imul__(self, Rotation pRot2) -> Rotation”””
return _almath.Rotation___imul__(self, *args)
def __eq__(self, *args):
“””__eq__(self, Rotation pRot2) -> bool”””
return _almath.Rotation___eq__(self, *args)
def __ne__(self, *args):
“””__ne__(self, Rotation pRot2) -> bool”””
return _almath.Rotation___ne__(self, *args)
def isNear(self, *args):
“””
isNear(self, Rotation pRot2, float pEpsilon = 0.0001) -> bool
isNear(self, Rotation pRot2) -> bool
“””
return _almath.Rotation_isNear(self, *args)
def transpose(self):
“””transpose(self) -> Rotation”””
return _almath.Rotation_transpose(self)
def determinant(self):
“””determinant(self) -> float”””
return _almath.Rotation_determinant(self)
def fromQuaternion(*args):
“””fromQuaternion(float pA, float pB, float pC, float pD) -> Rotation”””
return _almath.Rotation_fromQuaternion(*args)
if _newclass:fromQuaternion = staticmethod(fromQuaternion)
__swig_getmethods__[“fromQuaternion”] = lambda x: fromQuaternion
def fromAngleDirection(*args):
“””fromAngleDirection(float pAngle, float pX, float pY, float pZ) -> Rotation”””
return _almath.Rotation_fromAngleDirection(*args)
if _newclass:fromAngleDirection = staticmethod(fromAngleDirection)
__swig_getmethods__[“fromAngleDirection”] = lambda x: fromAngleDirection
def fromRotX(*args):
“””fromRotX(float pRotX) -> Rotation”””
return _almath.Rotation_fromRotX(*args)
if _newclass:fromRotX = staticmethod(fromRotX)
__swig_getmethods__[“fromRotX”] = lambda x: fromRotX
def fromRotY(*args):
“””fromRotY(float pRotY) -> Rotation”””
return _almath.Rotation_fromRotY(*args)
if _newclass:fromRotY = staticmethod(fromRotY)
__swig_getmethods__[“fromRotY”] = lambda x: fromRotY
def fromRotZ(*args):
“””fromRotZ(float pRotZ) -> Rotation”””
return _almath.Rotation_fromRotZ(*args)
if _newclass:fromRotZ = staticmethod(fromRotZ)
__swig_getmethods__[“fromRotZ”] = lambda x: fromRotZ
def from3DRotation(*args):
“””from3DRotation(float pWX, float pWY, float pWZ) -> Rotation”””
return _almath.Rotation_from3DRotation(*args)
if _newclass:from3DRotation = staticmethod(from3DRotation)
__swig_getmethods__[“from3DRotation”] = lambda x: from3DRotation
def toVector(self):
“””toVector(self) -> vectorFloat”””
return _almath.Rotation_toVector(self)
def __str__(self):
“””__str__(self) -> char”””
return _almath.Rotation___str__(self)
def __repr__(self):
“””__repr__(self) -> char”””
return _almath.Rotation___repr__(self)
def __mul__(self, *args):
“””
__mul__(self, Rotation pRot2) -> Rotation
__mul__(self, Position3D rhs) -> Position3D
“””
return _almath.Rotation___mul__(self, *args)
__swig_destroy__ = _almath.delete_Rotation
__del__ = lambda self : None;
Rotation_swigregister = _almath.Rotation_swigregister
Rotation_swigregister(Rotation)
def quaternionInverse(*args):
“””
quaternionInverse(Quaternion pQua, Quaternion pQuaOut)
quaternionInverse(Quaternion pQua) -> Quaternion
“””
return _almath.quaternionInverse(*args)
def Rotation_fromQuaternion(*args):
“””Rotation_fromQuaternion(float pA, float pB, float pC, float pD) -> Rotation”””
return _almath.Rotation_fromQuaternion(*args)
def Rotation_fromAngleDirection(*args):
“””Rotation_fromAngleDirection(float pAngle, float pX, float pY, float pZ) -> Rotation”””
return _almath.Rotation_fromAngleDirection(*args)
def Rotation_fromRotX(*args):
“””Rotation_fromRotX(float pRotX) -> Rotation”””
return _almath.Rotation_fromRotX(*args)
def Rotation_fromRotY(*args):
“””Rotation_fromRotY(float pRotY) -> Rotation”””
return _almath.Rotation_fromRotY(*args)
def Rotation_fromRotZ(*args):
“””Rotation_fromRotZ(float pRotZ) -> Rotation”””
return _almath.Rotation_fromRotZ(*args)
def Rotation_from3DRotation(*args):
“””Rotation_from3DRotation(float pWX, float pWY, float pWZ) -> Rotation”””
return _almath.Rotation_from3DRotation(*args)

def transpose(*args):
“””transpose(Rotation pRot) -> Rotation”””
return _almath.transpose(*args)
def rotationFromQuaternion(*args):
“””rotationFromQuaternion(float pA, float pB, float pC, float pD) -> Rotation”””
return _almath.rotationFromQuaternion(*args)
def applyRotation(*args):
“””applyRotation(Rotation pRot, float pX, float pY, float pZ)”””
return _almath.applyRotation(*args)
def rotationFromRotX(*args):
“””rotationFromRotX(float pRotX) -> Rotation”””
return _almath.rotationFromRotX(*args)
def rotationFromRotY(*args):
“””rotationFromRotY(float pRotY) -> Rotation”””
return _almath.rotationFromRotY(*args)
def rotationFromRotZ(*args):
“””rotationFromRotZ(float pRotZ) -> Rotation”””
return _almath.rotationFromRotZ(*args)
def rotationFrom3DRotation(*args):
“””rotationFrom3DRotation(float pWX, float pWY, float pWZ) -> Rotation”””
return _almath.rotationFrom3DRotation(*args)
class Rotation3D(_object):
“””Proxy of C++ AL::Math::Rotation3D class”””
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, Rotation3D, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, Rotation3D, name)
__swig_setmethods__[“wx”] = _almath.Rotation3D_wx_set
__swig_getmethods__[“wx”] = _almath.Rotation3D_wx_get
if _newclass:wx = _swig_property(_almath.Rotation3D_wx_get, _almath.Rotation3D_wx_set)
__swig_setmethods__[“wy”] = _almath.Rotation3D_wy_set
__swig_getmethods__[“wy”] = _almath.Rotation3D_wy_get
if _newclass:wy = _swig_property(_almath.Rotation3D_wy_get, _almath.Rotation3D_wy_set)
__swig_setmethods__[“wz”] = _almath.Rotation3D_wz_set
__swig_getmethods__[“wz”] = _almath.Rotation3D_wz_get
if _newclass:wz = _swig_property(_almath.Rotation3D_wz_get, _almath.Rotation3D_wz_set)
def __init__(self, *args):
“””
__init__(self) -> Rotation3D
__init__(self, float pInit) -> Rotation3D
__init__(self, float pWx, float pWy, float pWz) -> Rotation3D
__init__(self, vectorFloat pFloats) -> Rotation3D
“””
this = _almath.new_Rotation3D(*args)
try: self.this.append(this)
except: self.this = this
def __add__(self, *args):
“””__add__(self, Rotation3D pRot2) -> Rotation3D”””
return _almath.Rotation3D___add__(self, *args)
def __sub__(self, *args):
“””__sub__(self, Rotation3D pRot2) -> Rotation3D”””
return _almath.Rotation3D___sub__(self, *args)
def __iadd__(self, *args):
“””__iadd__(self, Rotation3D pRot2) -> Rotation3D”””
return _almath.Rotation3D___iadd__(self, *args)
def __isub__(self, *args):
“””__isub__(self, Rotation3D pRot2) -> Rotation3D”””
return _almath.Rotation3D___isub__(self, *args)
def __eq__(self, *args):
“””__eq__(self, Rotation3D pRot2) -> bool”””
return _almath.Rotation3D___eq__(self, *args)
def __ne__(self, *args):
“””__ne__(self, Rotation3D pRot2) -> bool”””
return _almath.Rotation3D___ne__(self, *args)
def __mul__(self, *args):
“””__mul__(self, float pVal) -> Rotation3D”””
return _almath.Rotation3D___mul__(self, *args)
def __div__(self, *args):
“””__div__(self, float pVal) -> Rotation3D”””
return _almath.Rotation3D___div__(self, *args)
def __imul__(self, *args):
“””__imul__(self, float pVal) -> Rotation3D”””
return _almath.Rotation3D___imul__(self, *args)
def __idiv__(self, *args):
“””__idiv__(self, float pVal) -> Rotation3D”””
return _almath.Rotation3D___idiv__(self, *args)
def isNear(self, *args):
“””
isNear(self, Rotation3D pRot2, float pEpsilon = 0.0001) -> bool
isNear(self, Rotation3D pRot2) -> bool
“””
return _almath.Rotation3D_isNear(self, *args)
def norm(self):
“””norm(self) -> float”””
return _almath.Rotation3D_norm(self)
def toVector(self):
“””toVector(self) -> vectorFloat”””
return _almath.Rotation3D_toVector(self)
def __repr__(self):
“””__repr__(self) -> char”””
return _almath.Rotation3D___repr__(self)
__swig_destroy__ = _almath.delete_Rotation3D
__del__ = lambda self : None;
Rotation3D_swigregister = _almath.Rotation3D_swigregister
Rotation3D_swigregister(Rotation3D)
class Transform(_object):
“””Proxy of C++ AL::Math::Transform class”””
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, Transform, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, Transform, name)
__swig_setmethods__[“r1_c1”] = _almath.Transform_r1_c1_set
__swig_getmethods__[“r1_c1”] = _almath.Transform_r1_c1_get
if _newclass:r1_c1 = _swig_property(_almath.Transform_r1_c1_get, _almath.Transform_r1_c1_set)
__swig_setmethods__[“r1_c2”] = _almath.Transform_r1_c2_set
__swig_getmethods__[“r1_c2”] = _almath.Transform_r1_c2_get
if _newclass:r1_c2 = _swig_property(_almath.Transform_r1_c2_get, _almath.Transform_r1_c2_set)
__swig_setmethods__[“r1_c3”] = _almath.Transform_r1_c3_set
__swig_getmethods__[“r1_c3”] = _almath.Transform_r1_c3_get
if _newclass:r1_c3 = _swig_property(_almath.Transform_r1_c3_get, _almath.Transform_r1_c3_set)
__swig_setmethods__[“r1_c4”] = _almath.Transform_r1_c4_set
__swig_getmethods__[“r1_c4”] = _almath.Transform_r1_c4_get
if _newclass:r1_c4 = _swig_property(_almath.Transform_r1_c4_get, _almath.Transform_r1_c4_set)
__swig_setmethods__[“r2_c1”] = _almath.Transform_r2_c1_set
__swig_getmethods__[“r2_c1”] = _almath.Transform_r2_c1_get
if _newclass:r2_c1 = _swig_property(_almath.Transform_r2_c1_get, _almath.Transform_r2_c1_set)
__swig_setmethods__[“r2_c2”] = _almath.Transform_r2_c2_set
__swig_getmethods__[“r2_c2”] = _almath.Transform_r2_c2_get
if _newclass:r2_c2 = _swig_property(_almath.Transform_r2_c2_get, _almath.Transform_r2_c2_set)
__swig_setmethods__[“r2_c3”] = _almath.Transform_r2_c3_set
__swig_getmethods__[“r2_c3”] = _almath.Transform_r2_c3_get
if _newclass:r2_c3 = _swig_property(_almath.Transform_r2_c3_get, _almath.Transform_r2_c3_set)
__swig_setmethods__[“r2_c4”] = _almath.Transform_r2_c4_set
__swig_getmethods__[“r2_c4”] = _almath.Transform_r2_c4_get
if _newclass:r2_c4 = _swig_property(_almath.Transform_r2_c4_get, _almath.Transform_r2_c4_set)
__swig_setmethods__[“r3_c1”] = _almath.Transform_r3_c1_set
__swig_getmethods__[“r3_c1”] = _almath.Transform_r3_c1_get
if _newclass:r3_c1 = _swig_property(_almath.Transform_r3_c1_get, _almath.Transform_r3_c1_set)
__swig_setmethods__[“r3_c2”] = _almath.Transform_r3_c2_set
__swig_getmethods__[“r3_c2”] = _almath.Transform_r3_c2_get
if _newclass:r3_c2 = _swig_property(_almath.Transform_r3_c2_get, _almath.Transform_r3_c2_set)
__swig_setmethods__[“r3_c3”] = _almath.Transform_r3_c3_set
__swig_getmethods__[“r3_c3”] = _almath.Transform_r3_c3_get
if _newclass:r3_c3 = _swig_property(_almath.Transform_r3_c3_get, _almath.Transform_r3_c3_set)
__swig_setmethods__[“r3_c4”] = _almath.Transform_r3_c4_set
__swig_getmethods__[“r3_c4”] = _almath.Transform_r3_c4_get
if _newclass:r3_c4 = _swig_property(_almath.Transform_r3_c4_get, _almath.Transform_r3_c4_set)
def __init__(self, *args):
“””
__init__(self) -> Transform
__init__(self, vectorFloat pFloats) -> Transform
__init__(self, float pPosX, float pPosY, float pPosZ) -> Transform
“””
this = _almath.new_Transform(*args)
try: self.this.append(this)
except: self.this = this
def __imul__(self, *args):
“””__imul__(self, Transform pT2) -> Transform”””
return _almath.Transform___imul__(self, *args)
def __eq__(self, *args):
“””__eq__(self, Transform pT2) -> bool”””
return _almath.Transform___eq__(self, *args)
def __ne__(self, *args):
“””__ne__(self, Transform pT2) -> bool”””
return _almath.Transform___ne__(self, *args)
def isNear(self, *args):
“””
isNear(self, Transform pT2, float pEpsilon = 0.0001) -> bool
isNear(self, Transform pT2) -> bool
“””
return _almath.Transform_isNear(self, *args)
def isTransform(self, pEpsilon = 0.0001):
“””
isTransform(self, float pEpsilon = 0.0001) -> bool
isTransform(self) -> bool
“””
return _almath.Transform_isTransform(self, pEpsilon)
def norm(self):
“””norm(self) -> float”””
return _almath.Transform_norm(self)
def determinant(self):
“””determinant(self) -> float”””
return _almath.Transform_determinant(self)
def inverse(self):
“””inverse(self) -> Transform”””
return _almath.Transform_inverse(self)
def fromRotX(*args):
“””fromRotX(float pRotX) -> Transform”””
return _almath.Transform_fromRotX(*args)
if _newclass:fromRotX = staticmethod(fromRotX)
__swig_getmethods__[“fromRotX”] = lambda x: fromRotX
def fromRotY(*args):
“””fromRotY(float pRotY) -> Transform”””
return _almath.Transform_fromRotY(*args)
if _newclass:fromRotY = staticmethod(fromRotY)
__swig_getmethods__[“fromRotY”] = lambda x: fromRotY
def fromRotZ(*args):
“””fromRotZ(float pRotZ) -> Transform”””
return _almath.Transform_fromRotZ(*args)
if _newclass:fromRotZ = staticmethod(fromRotZ)
__swig_getmethods__[“fromRotZ”] = lambda x: fromRotZ
def from3DRotation(*args):
“””from3DRotation(float pWX, float pWY, float pWZ) -> Transform”””
return _almath.Transform_from3DRotation(*args)
if _newclass:from3DRotation = staticmethod(from3DRotation)
__swig_getmethods__[“from3DRotation”] = lambda x: from3DRotation
def fromPosition(*args):
“””
fromPosition(float pX, float pY, float pZ) -> Transform
fromPosition(float pX, float pY, float pZ, float pWX, float pWY,
float pWZ) -> Transform
“””
return _almath.Transform_fromPosition(*args)
if _newclass:fromPosition = staticmethod(fromPosition)
__swig_getmethods__[“fromPosition”] = lambda x: fromPosition
def diff(self, *args):
“””diff(self, Transform pT2) -> Transform”””
return _almath.Transform_diff(self, *args)
def distanceSquared(self, *args):
“””distanceSquared(self, Transform pT2) -> float”””
return _almath.Transform_distanceSquared(self, *args)
def distance(self, *args):
“””distance(self, Transform pT2) -> float”””
return _almath.Transform_distance(self, *args)
def toVector(self):
“””toVector(self) -> vectorFloat”””
return _almath.Transform_toVector(self)
def __str__(self):
“””__str__(self) -> char”””
return _almath.Transform___str__(self)
def __repr__(self):
“””__repr__(self) -> char”””
return _almath.Transform___repr__(self)
def __mul__(self, *args):
“””
__mul__(self, Transform pT2) -> Transform
__mul__(self, Position3D rhs) -> Position3D
“””
return _almath.Transform___mul__(self, *args)
__swig_destroy__ = _almath.delete_Transform
__del__ = lambda self : None;
Transform_swigregister = _almath.Transform_swigregister
Transform_swigregister(Transform)
def Transform_fromRotX(*args):
“””Transform_fromRotX(float pRotX) -> Transform”””
return _almath.Transform_fromRotX(*args)
def Transform_fromRotY(*args):
“””Transform_fromRotY(float pRotY) -> Transform”””
return _almath.Transform_fromRotY(*args)
def Transform_fromRotZ(*args):
“””Transform_fromRotZ(float pRotZ) -> Transform”””
return _almath.Transform_fromRotZ(*args)
def Transform_from3DRotation(*args):
“””Transform_from3DRotation(float pWX, float pWY, float pWZ) -> Transform”””
return _almath.Transform_from3DRotation(*args)
def Transform_fromPosition(*args):
“””
fromPosition(float pX, float pY, float pZ) -> Transform
Transform_fromPosition(float pX, float pY, float pZ, float pWX, float pWY,
float pWZ) -> Transform
“””
return _almath.Transform_fromPosition(*args)

def transformPreMultiply(*args):
“””transformPreMultiply(Transform pT, Transform pTOut)”””
return _almath.transformPreMultiply(*args)
def transformFromRotX(*args):
“””transformFromRotX(float pRotX) -> Transform”””
return _almath.transformFromRotX(*args)
def transformFromRotY(*args):
“””transformFromRotY(float pRotY) -> Transform”””
return _almath.transformFromRotY(*args)
def transformFromRotZ(*args):
“””transformFromRotZ(float pRotZ) -> Transform”””
return _almath.transformFromRotZ(*args)
def transformFrom3DRotation(*args):
“””transformFrom3DRotation(float pWX, float pWY, float pWZ) -> Transform”””
return _almath.transformFrom3DRotation(*args)
def transformInvertInPlace(*args):
“””transformInvertInPlace(Transform pT)”””
return _almath.transformInvertInPlace(*args)
def pinv(*args):
“””pinv(Transform pT) -> Transform”””
return _almath.pinv(*args)
def transformDiff(*args):
“””transformDiff(Transform pT1, Transform pT2) -> Transform”””
return _almath.transformDiff(*args)
def transformDistanceSquared(*args):
“””transformDistanceSquared(Transform pT1, Transform pT2) -> float”””
return _almath.transformDistanceSquared(*args)
def transformDistance(*args):
“””transformDistance(Transform pT1, Transform pT2) -> float”””
return _almath.transformDistance(*args)
class Velocity3D(_object):
“””Proxy of C++ AL::Math::Velocity3D class”””
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, Velocity3D, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, Velocity3D, name)
__swig_setmethods__[“xd”] = _almath.Velocity3D_xd_set
__swig_getmethods__[“xd”] = _almath.Velocity3D_xd_get
if _newclass:xd = _swig_property(_almath.Velocity3D_xd_get, _almath.Velocity3D_xd_set)
__swig_setmethods__[“yd”] = _almath.Velocity3D_yd_set
__swig_getmethods__[“yd”] = _almath.Velocity3D_yd_get
if _newclass:yd = _swig_property(_almath.Velocity3D_yd_get, _almath.Velocity3D_yd_set)
__swig_setmethods__[“zd”] = _almath.Velocity3D_zd_set
__swig_getmethods__[“zd”] = _almath.Velocity3D_zd_get
if _newclass:zd = _swig_property(_almath.Velocity3D_zd_get, _almath.Velocity3D_zd_set)
def __init__(self, *args):
“””
__init__(self) -> Velocity3D
__init__(self, float pInit) -> Velocity3D
__init__(self, float pXd, float pYd, float pZd) -> Velocity3D
__init__(self, vectorFloat pFloats) -> Velocity3D
“””
this = _almath.new_Velocity3D(*args)
try: self.this.append(this)
except: self.this = this
def __add__(self, *args):
“””__add__(self, Velocity3D pVel2) -> Velocity3D”””
return _almath.Velocity3D___add__(self, *args)
def __sub__(self, *args):
“””__sub__(self, Velocity3D pVel2) -> Velocity3D”””
return _almath.Velocity3D___sub__(self, *args)
def __pos__(self):
“””__pos__(self) -> Velocity3D”””
return _almath.Velocity3D___pos__(self)
def __neg__(self):
“””__neg__(self) -> Velocity3D”””
return _almath.Velocity3D___neg__(self)
def __iadd__(self, *args):
“””__iadd__(self, Velocity3D pVel2) -> Velocity3D”””
return _almath.Velocity3D___iadd__(self, *args)
def __isub__(self, *args):
“””__isub__(self, Velocity3D pVel2) -> Velocity3D”””
return _almath.Velocity3D___isub__(self, *args)
def __eq__(self, *args):
“””__eq__(self, Velocity3D pVel2) -> bool”””
return _almath.Velocity3D___eq__(self, *args)
def __ne__(self, *args):
“””__ne__(self, Velocity3D pVel2) -> bool”””
return _almath.Velocity3D___ne__(self, *args)
def __mul__(self, *args):
“””__mul__(self, float pVal) -> Velocity3D”””
return _almath.Velocity3D___mul__(self, *args)
def __div__(self, *args):
“””__div__(self, float pVal) -> Velocity3D”””
return _almath.Velocity3D___div__(self, *args)
def __imul__(self, *args):
“””__imul__(self, float pVal) -> Velocity3D”””
return _almath.Velocity3D___imul__(self, *args)
def __idiv__(self, *args):
“””__idiv__(self, float pVal) -> Velocity3D”””
return _almath.Velocity3D___idiv__(self, *args)
def isNear(self, *args):
“””
isNear(self, Velocity3D pVel2, float pEpsilon = 0.0001) -> bool
isNear(self, Velocity3D pVel2) -> bool
“””
return _almath.Velocity3D_isNear(self, *args)
def norm(self):
“””norm(self) -> float”””
return _almath.Velocity3D_norm(self)
def normalize(self):
“””normalize(self) -> Velocity3D”””
return _almath.Velocity3D_normalize(self)
def toVector(self):
“””toVector(self) -> vectorFloat”””
return _almath.Velocity3D_toVector(self)
def __repr__(self):
“””__repr__(self) -> char”””
return _almath.Velocity3D___repr__(self)
def __rmul__(self, *args):
“””__rmul__(self, float lhs) -> Velocity3D”””
return _almath.Velocity3D___rmul__(self, *args)
__swig_destroy__ = _almath.delete_Velocity3D
__del__ = lambda self : None;
Velocity3D_swigregister = _almath.Velocity3D_swigregister
Velocity3D_swigregister(Velocity3D)
def transformToFloatVector(*args):
“””
transformToFloatVector(Transform pT, vectorFloat pTOut)
transformToFloatVector(Transform pT) -> vectorFloat
“””
return _almath.transformToFloatVector(*args)
def determinant(*args):
“””
determinant(Rotation pRot) -> float
determinant(Transform pT) -> float
determinant(vectorFloat pFloats) -> float
“””
return _almath.determinant(*args)
def transformInverse(*args):
“””
transformInverse(Transform pT, Transform pTOut)
transformInverse(Transform pT) -> Transform
“””
return _almath.transformInverse(*args)
def transformFromPosition(*args):
“””
transformFromPosition(float pX, float pY, float pZ) -> Transform
transformFromPosition(float pX, float pY, float pZ, float pWX, float pWY,
float pWZ) -> Transform
“””
return _almath.transformFromPosition(*args)
class Velocity6D(_object):
“””Proxy of C++ AL::Math::Velocity6D class”””
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, Velocity6D, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, Velocity6D, name)
__swig_setmethods__[“xd”] = _almath.Velocity6D_xd_set
__swig_getmethods__[“xd”] = _almath.Velocity6D_xd_get
if _newclass:xd = _swig_property(_almath.Velocity6D_xd_get, _almath.Velocity6D_xd_set)
__swig_setmethods__[“yd”] = _almath.Velocity6D_yd_set
__swig_getmethods__[“yd”] = _almath.Velocity6D_yd_get
if _newclass:yd = _swig_property(_almath.Velocity6D_yd_get, _almath.Velocity6D_yd_set)
__swig_setmethods__[“zd”] = _almath.Velocity6D_zd_set
__swig_getmethods__[“zd”] = _almath.Velocity6D_zd_get
if _newclass:zd = _swig_property(_almath.Velocity6D_zd_get, _almath.Velocity6D_zd_set)
__swig_setmethods__[“wxd”] = _almath.Velocity6D_wxd_set
__swig_getmethods__[“wxd”] = _almath.Velocity6D_wxd_get
if _newclass:wxd = _swig_property(_almath.Velocity6D_wxd_get, _almath.Velocity6D_wxd_set)
__swig_setmethods__[“wyd”] = _almath.Velocity6D_wyd_set
__swig_getmethods__[“wyd”] = _almath.Velocity6D_wyd_get
if _newclass:wyd = _swig_property(_almath.Velocity6D_wyd_get, _almath.Velocity6D_wyd_set)
__swig_setmethods__[“wzd”] = _almath.Velocity6D_wzd_set
__swig_getmethods__[“wzd”] = _almath.Velocity6D_wzd_get
if _newclass:wzd = _swig_property(_almath.Velocity6D_wzd_get, _almath.Velocity6D_wzd_set)
def __init__(self, *args):
“””
__init__(self) -> Velocity6D
__init__(self, float pInit) -> Velocity6D
__init__(self, float pXd, float pYd, float pZd, float pWxd, float pWyd,
float pWzd) -> Velocity6D
__init__(self, vectorFloat pFloats) -> Velocity6D
“””
this = _almath.new_Velocity6D(*args)
try: self.this.append(this)
except: self.this = this
def __add__(self, *args):
“””__add__(self, Velocity6D pVel2) -> Velocity6D”””
return _almath.Velocity6D___add__(self, *args)
def __sub__(self, *args):
“””__sub__(self, Velocity6D pVel2) -> Velocity6D”””
return _almath.Velocity6D___sub__(self, *args)
def __pos__(self):
“””__pos__(self) -> Velocity6D”””
return _almath.Velocity6D___pos__(self)
def __neg__(self):
“””__neg__(self) -> Velocity6D”””
return _almath.Velocity6D___neg__(self)
def __mul__(self, *args):
“””__mul__(self, float pVal) -> Velocity6D”””
return _almath.Velocity6D___mul__(self, *args)
def __div__(self, *args):
“””__div__(self, float pVal) -> Velocity6D”””
return _almath.Velocity6D___div__(self, *args)
def __eq__(self, *args):
“””__eq__(self, Velocity6D pVel2) -> bool”””
return _almath.Velocity6D___eq__(self, *args)
def __ne__(self, *args):
“””__ne__(self, Velocity6D pVel2) -> bool”””
return _almath.Velocity6D___ne__(self, *args)
def __imul__(self, *args):
“””__imul__(self, float pVal) -> Velocity6D”””
return _almath.Velocity6D___imul__(self, *args)
def __idiv__(self, *args):
“””__idiv__(self, float pVal) -> Velocity6D”””
return _almath.Velocity6D___idiv__(self, *args)
def isNear(self, *args):
“””
isNear(self, Velocity6D pVel2, float pEpsilon = 0.0001) -> bool
isNear(self, Velocity6D pVel2) -> bool
“””
return _almath.Velocity6D_isNear(self, *args)
def norm(self):
“””norm(self) -> float”””
return _almath.Velocity6D_norm(self)
def normalize(self):
“””normalize(self) -> Velocity6D”””
return _almath.Velocity6D_normalize(self)
def toVector(self):
“””toVector(self) -> vectorFloat”””
return _almath.Velocity6D_toVector(self)
def __repr__(self):
“””__repr__(self) -> char”””
return _almath.Velocity6D___repr__(self)
def __rmul__(self, *args):
“””__rmul__(self, float lhs) -> Velocity6D”””
return _almath.Velocity6D___rmul__(self, *args)
__swig_destroy__ = _almath.delete_Velocity6D
__del__ = lambda self : None;
Velocity6D_swigregister = _almath.Velocity6D_swigregister
Velocity6D_swigregister(Velocity6D)
class TransformAndVelocity6D(_object):
“””Proxy of C++ AL::Math::TransformAndVelocity6D class”””
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, TransformAndVelocity6D, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, TransformAndVelocity6D, name)
__swig_setmethods__[“T”] = _almath.TransformAndVelocity6D_T_set
__swig_getmethods__[“T”] = _almath.TransformAndVelocity6D_T_get
if _newclass:T = _swig_property(_almath.TransformAndVelocity6D_T_get, _almath.TransformAndVelocity6D_T_set)
__swig_setmethods__[“V”] = _almath.TransformAndVelocity6D_V_set
__swig_getmethods__[“V”] = _almath.TransformAndVelocity6D_V_get
if _newclass:V = _swig_property(_almath.TransformAndVelocity6D_V_get, _almath.TransformAndVelocity6D_V_set)
def isNear(self, *args):
“””
isNear(self, TransformAndVelocity6D pTV2, float pEpsilon = 0.0001) -> bool
isNear(self, TransformAndVelocity6D pTV2) -> bool
“””
return _almath.TransformAndVelocity6D_isNear(self, *args)
def __repr__(self):
“””__repr__(self) -> char”””
return _almath.TransformAndVelocity6D___repr__(self)
def __init__(self):
“””__init__(self) -> TransformAndVelocity6D”””
this = _almath.new_TransformAndVelocity6D()
try: self.this.append(this)
except: self.this = this
__swig_destroy__ = _almath.delete_TransformAndVelocity6D
__del__ = lambda self : None;
TransformAndVelocity6D_swigregister = _almath.TransformAndVelocity6D_swigregister
TransformAndVelocity6D_swigregister(TransformAndVelocity6D)
def norm(*args):
“””
norm(Position2D pPos) -> float
norm(Position3D pPos) -> float
norm(Position6D pPos) -> float
norm(Quaternion pQua) -> float
norm(Rotation3D pRot) -> float
norm(Transform pT) -> float
norm(Velocity3D pVel) -> float
norm(Velocity6D pVel) -> float
“””
return _almath.norm(*args)
def normalize(*args):
“””
normalize(Position2D pPos) -> Position2D
normalize(Position3D pPos) -> Position3D
normalize(Position6D pPos) -> Position6D
normalize(Quaternion pQua) -> Quaternion
normalize(Velocity3D pVel) -> Velocity3D
normalize(Velocity6D pVel) -> Velocity6D
“””
return _almath.normalize(*args)

def getDubinsSolutions(*args):
“””getDubinsSolutions(Pose2D pTargetPose, float pCircleRadius) -> vectorPose2D”””
return _almath.getDubinsSolutions(*args)
def avoidFootCollision(*args):
“””
avoidFootCollision(vectorPose2D pLFootBoundingBox, vectorPose2D pRFootBoundingBox,
bool pIsLeftSupport, Pose2D pMove) -> bool
“””
return _almath.avoidFootCollision(*args)
def clipFootWithEllipse(*args):
“””clipFootWithEllipse(float pMaxFootX, float pMaxFootY, Pose2D pMove) -> bool”””
return _almath.clipFootWithEllipse(*args)
def transformLogarithmInPlace(*args):
“””transformLogarithmInPlace(Transform pT, Velocity6D pVel)”””
return _almath.transformLogarithmInPlace(*args)
def transformLogarithm(*args):
“””transformLogarithm(Transform pT) -> Velocity6D”””
return _almath.transformLogarithm(*args)
def velocityExponential(*args):
“””velocityExponential(Velocity6D pVel) -> Transform”””
return _almath.velocityExponential(*args)
def velocityExponentialInPlace(*args):
“””velocityExponentialInPlace(Velocity6D pVel, Transform pT)”””
return _almath.velocityExponentialInPlace(*args)
def changeReferenceVelocity6D(*args):
“””changeReferenceVelocity6D(Transform pT, Velocity6D pVelIn, Velocity6D pVelOut)”””
return _almath.changeReferenceVelocity6D(*args)
def changeReferencePosition6D(*args):
“””changeReferencePosition6D(Transform pT, Position6D pPosIn, Position6D pPosOut)”””
return _almath.changeReferencePosition6D(*args)
def changeReferencePosition3DInPlace(*args):
“””changeReferencePosition3DInPlace(Transform pT, Position3D pPosOut)”””
return _almath.changeReferencePosition3DInPlace(*args)
def changeReferenceTransposePosition3DInPlace(*args):
“””changeReferenceTransposePosition3DInPlace(Transform pT, Position3D pPosOut)”””
return _almath.changeReferenceTransposePosition3DInPlace(*args)
def changeReferencePosition3D(*args):
“””changeReferencePosition3D(Transform pT, Position3D pPosIn, Position3D pPosOut)”””
return _almath.changeReferencePosition3D(*args)
def changeReferenceTransposePosition3D(*args):
“””changeReferenceTransposePosition3D(Transform pT, Position3D pPosIn, Position3D pPosOut)”””
return _almath.changeReferenceTransposePosition3D(*args)
def changeReferenceTransform(*args):
“””changeReferenceTransform(Transform pT, Transform pTIn, Transform pTOut)”””
return _almath.changeReferenceTransform(*args)
def changeReferenceTransposeTransform(*args):
“””changeReferenceTransposeTransform(Transform pT, Transform pTIn, Transform pTOut)”””
return _almath.changeReferenceTransposeTransform(*args)
def changeReferenceTransposeVelocity6D(*args):
“””changeReferenceTransposeVelocity6D(Transform pT, Velocity6D pVelIn, Velocity6D pVelOut)”””
return _almath.changeReferenceTransposeVelocity6D(*args)
def changeReferenceTransposePosition6D(*args):
“””changeReferenceTransposePosition6D(Transform pT, Position6D pPosIn, Position6D pPosOut)”””
return _almath.changeReferenceTransposePosition6D(*args)
def transformMeanInPlace(*args):
“””transformMeanInPlace(Transform pTIn1, Transform pTIn2, float pVal, Transform pTOut)”””
return _almath.transformMeanInPlace(*args)
def transformFromPosition3DInPlace(*args):
“””transformFromPosition3DInPlace(Position3D pPosition, Transform pTransform)”””
return _almath.transformFromPosition3DInPlace(*args)
def transformFromPosition3D(*args):
“””transformFromPosition3D(Position3D pPosition) -> Transform”””
return _almath.transformFromPosition3D(*args)
def transformFromRotationInPlace(*args):
“””transformFromRotationInPlace(Rotation pRotation, Transform pTransform)”””
return _almath.transformFromRotationInPlace(*args)
def transformFromRotation(*args):
“””transformFromRotation(Rotation pRotation) -> Transform”””
return _almath.transformFromRotation(*args)
def rotationFromTransformInPlace(*args):
“””rotationFromTransformInPlace(Transform pTransform, Rotation pRotation)”””
return _almath.rotationFromTransformInPlace(*args)
def rotationFromTransform(*args):
“””rotationFromTransform(Transform pTransform) -> Rotation”””
return _almath.rotationFromTransform(*args)
def rotation3DFromRotation(*args):
“””rotation3DFromRotation(Rotation pRotation) -> Rotation3D”””
return _almath.rotation3DFromRotation(*args)
def position6DFromTransformInPlace(*args):
“””position6DFromTransformInPlace(Transform pT, Position6D pPos)”””
return _almath.position6DFromTransformInPlace(*args)
def position6DFromTransform(*args):
“””position6DFromTransform(Transform pT) -> Position6D”””
return _almath.position6DFromTransform(*args)
def transformFromPose2DInPlace(*args):
“””transformFromPose2DInPlace(Pose2D pPose, Transform pT)”””
return _almath.transformFromPose2DInPlace(*args)
def transformFromPose2D(*args):
“””transformFromPose2D(Pose2D pPose) -> Transform”””
return _almath.transformFromPose2D(*args)
def pose2DFromTransformInPlace(*args):
“””pose2DFromTransformInPlace(Transform pT, Pose2D pPos)”””
return _almath.pose2DFromTransformInPlace(*args)
def pose2DFromTransform(*args):
“””pose2DFromTransform(Transform pT) -> Pose2D”””
return _almath.pose2DFromTransform(*args)
def transformFromRotation3D(*args):
“””transformFromRotation3D(Rotation3D pRotation) -> Transform”””
return _almath.transformFromRotation3D(*args)
def transformFromPosition6D(*args):
“””transformFromPosition6D(Position6D pPosition6D) -> Transform”””
return _almath.transformFromPosition6D(*args)
def position6DFromTransformDiffInPlace(*args):
“””position6DFromTransformDiffInPlace(Transform pCurrent, Transform pTarget, Position6D result)”””
return _almath.position6DFromTransformDiffInPlace(*args)
def position6DFromTransformDiff(*args):
“””position6DFromTransformDiff(Transform pCurrent, Transform pTarget) -> Position6D”””
return _almath.position6DFromTransformDiff(*args)
def position3DFromTransformInPlace(*args):
“””position3DFromTransformInPlace(Transform pT, Position3D pPos)”””
return _almath.position3DFromTransformInPlace(*args)
def position3DFromTransform(*args):
“””position3DFromTransform(Transform pT) -> Position3D”””
return _almath.position3DFromTransform(*args)
def rotation3DFromTransform(*args):
“””rotation3DFromTransform(Transform pT) -> Rotation3D”””
return _almath.rotation3DFromTransform(*args)
def transformFromQuaternion(*args):
“””transformFromQuaternion(Quaternion pQua) -> Transform”””
return _almath.transformFromQuaternion(*args)
def quaternionFromTransform(*args):
“””quaternionFromTransform(Transform pT) -> Quaternion”””
return _almath.quaternionFromTransform(*args)
def clipData(*args):
“””clipData(float pMin, float pMax, float pData) -> bool”””
return _almath.clipData(*args)
def position6DFromVelocity6D(*args):
“””position6DFromVelocity6D(Velocity6D pVel) -> Position6D”””
return _almath.position6DFromVelocity6D(*args)
_4_PI_ = cvar._4_PI_
_2_PI_ = cvar._2_PI_
PI = cvar.PI
PI_2 = cvar.PI_2
PI_4 = cvar.PI_4
TO_RAD = cvar.TO_RAD
TO_DEG = cvar.TO_DEG
def transformMean(*args):
“””
transformMean(Transform pTIn1, Transform pTIn2, float pVal = 0.5) -> Transform
transformMean(Transform pTIn1, Transform pTIn2) -> Transform
“””
return _almath.transformMean(*args)
def transformFromRotationPosition3D(*args):
“””
transformFromRotationPosition3D(Rotation pRot, float pX, float pY, float pZ) -> Transform
transformFromRotationPosition3D(Rotation pRot, Position3D pPos) -> Transform
“””
return _almath.transformFromRotationPosition3D(*args)
def transformFromRotVecInPlace(*args):
“””
transformFromRotVecInPlace(int pAxis, float pTheta, Position3D pPos, Transform pT)
transformFromRotVecInPlace(Position3D pPos, Transform pT)
“””
return _almath.transformFromRotVecInPlace(*args)
def transformFromRotVec(*args):
“””
transformFromRotVec(int pAxis, float pTheta, Position3D pPos) -> Transform
transformFromRotVec(Position3D pPos) -> Transform
transformFromRotVec(int pAxis, float pTheta) -> Transform
“””
return _almath.transformFromRotVec(*args)
def axisRotationProjection(*args):
“””
axisRotationProjection(Position3D pPos, Transform pT) -> Transform
axisRotationProjection(Position3D pAxis, Rotation pRot) -> Rotation
“””
return _almath.axisRotationProjection(*args)
def axisRotationProjectionInPlace(*args):
“””
axisRotationProjectionInPlace(Position3D pPos, Transform pT)
axisRotationProjectionInPlace(Position3D pPos, Rotation pRot)
“””
return _almath.axisRotationProjectionInPlace(*args)
def orthogonalSpace(*args):
“””
orthogonalSpace(Position3D pPos, Transform pTOut)
orthogonalSpace(Position3D pPos) -> Transform
“””
return _almath.orthogonalSpace(*args)
def __mul__(*args):
“””
__mul__(float pM, Position2D pPos1) -> Position2D
__mul__(float pM, Position3D pPos1) -> Position3D
__mul__(float pM, Velocity3D pVel1) -> Velocity3D
__mul__(float pVal, Velocity6D pVel) -> Velocity6D
__mul__(Transform pT, Position3D pPos) -> Position3D
__mul__(Rotation pRot, Position3D pPos) -> Position3D
__mul__(float pVal, Position6D pPos) -> Velocity6D
“””
return _almath.__mul__(*args)
def rotationFromAngleDirection(*args):
“””
rotationFromAngleDirection(float pAngle, float pX, float pY, float pZ) -> Rotation
rotationFromAngleDirection(float pTheta, Position3D pPos) -> Rotation
“””
return _almath.rotationFromAngleDirection(*args)

pynaoqi-python-2.6-naoqi-1.14-linux32/_allog.so

pynaoqi-python-2.6-naoqi-1.14-linux32/inaoqi.py
# This file was automatically generated by SWIG (http://www.swig.org).
# Version 1.3.40
#
# Do not make changes to this file unless you know what you are doing–modify
# the SWIG interface file instead.
# This file is compatible with both classic and new-style classes.
from sys import version_info
if version_info >= (2,6,0):
def swig_import_helper():
from os.path import dirname
import imp
fp = None
try:
fp, pathname, description = imp.find_module(‘_inaoqi’, [dirname(__file__)])
except ImportError:
import _inaoqi
return _inaoqi
if fp is not None:
try:
_mod = imp.load_module(‘_inaoqi’, fp, pathname, description)
finally:
fp.close()
return _mod
_inaoqi = swig_import_helper()
del swig_import_helper
else:
import _inaoqi
del version_info
try:
_swig_property = property
except NameError:
pass # Python < 2.2 doesn't have 'property'. 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__ == 'SwigPyObject': 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,)
try:
_object = object
_newclass = 1
except AttributeError:
class _object : pass
_newclass = 0

class SwigPyIterator(_object):
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, SwigPyIterator, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, SwigPyIterator, name)
def __init__(self, *args, **kwargs): raise AttributeError(“No constructor defined – class is abstract”)
__repr__ = _swig_repr
__swig_destroy__ = _inaoqi.delete_SwigPyIterator
__del__ = lambda self : None;
def value(self): return _inaoqi.SwigPyIterator_value(self)
def incr(self, n = 1): return _inaoqi.SwigPyIterator_incr(self, n)
def decr(self, n = 1): return _inaoqi.SwigPyIterator_decr(self, n)
def distance(self, *args): return _inaoqi.SwigPyIterator_distance(self, *args)
def equal(self, *args): return _inaoqi.SwigPyIterator_equal(self, *args)
def copy(self): return _inaoqi.SwigPyIterator_copy(self)
def next(self): return _inaoqi.SwigPyIterator_next(self)
def __next__(self): return _inaoqi.SwigPyIterator___next__(self)
def previous(self): return _inaoqi.SwigPyIterator_previous(self)
def advance(self, *args): return _inaoqi.SwigPyIterator_advance(self, *args)
def __eq__(self, *args): return _inaoqi.SwigPyIterator___eq__(self, *args)
def __ne__(self, *args): return _inaoqi.SwigPyIterator___ne__(self, *args)
def __iadd__(self, *args): return _inaoqi.SwigPyIterator___iadd__(self, *args)
def __isub__(self, *args): return _inaoqi.SwigPyIterator___isub__(self, *args)
def __add__(self, *args): return _inaoqi.SwigPyIterator___add__(self, *args)
def __sub__(self, *args): return _inaoqi.SwigPyIterator___sub__(self, *args)
def __iter__(self): return self
SwigPyIterator_swigregister = _inaoqi.SwigPyIterator_swigregister
SwigPyIterator_swigregister(SwigPyIterator)
class StringVector(_object):
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, StringVector, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, StringVector, name)
__repr__ = _swig_repr
def iterator(self): return _inaoqi.StringVector_iterator(self)
def __iter__(self): return self.iterator()
def __nonzero__(self): return _inaoqi.StringVector___nonzero__(self)
def __bool__(self): return _inaoqi.StringVector___bool__(self)
def __len__(self): return _inaoqi.StringVector___len__(self)
def pop(self): return _inaoqi.StringVector_pop(self)
def __getslice__(self, *args): return _inaoqi.StringVector___getslice__(self, *args)
def __setslice__(self, *args): return _inaoqi.StringVector___setslice__(self, *args)
def __delslice__(self, *args): return _inaoqi.StringVector___delslice__(self, *args)
def __delitem__(self, *args): return _inaoqi.StringVector___delitem__(self, *args)
def __getitem__(self, *args): return _inaoqi.StringVector___getitem__(self, *args)
def __setitem__(self, *args): return _inaoqi.StringVector___setitem__(self, *args)
def append(self, *args): return _inaoqi.StringVector_append(self, *args)
def empty(self): return _inaoqi.StringVector_empty(self)
def size(self): return _inaoqi.StringVector_size(self)
def clear(self): return _inaoqi.StringVector_clear(self)
def swap(self, *args): return _inaoqi.StringVector_swap(self, *args)
def get_allocator(self): return _inaoqi.StringVector_get_allocator(self)
def begin(self): return _inaoqi.StringVector_begin(self)
def end(self): return _inaoqi.StringVector_end(self)
def rbegin(self): return _inaoqi.StringVector_rbegin(self)
def rend(self): return _inaoqi.StringVector_rend(self)
def pop_back(self): return _inaoqi.StringVector_pop_back(self)
def erase(self, *args): return _inaoqi.StringVector_erase(self, *args)
def __init__(self, *args):
this = _inaoqi.new_StringVector(*args)
try: self.this.append(this)
except: self.this = this
def push_back(self, *args): return _inaoqi.StringVector_push_back(self, *args)
def front(self): return _inaoqi.StringVector_front(self)
def back(self): return _inaoqi.StringVector_back(self)
def assign(self, *args): return _inaoqi.StringVector_assign(self, *args)
def resize(self, *args): return _inaoqi.StringVector_resize(self, *args)
def insert(self, *args): return _inaoqi.StringVector_insert(self, *args)
def reserve(self, *args): return _inaoqi.StringVector_reserve(self, *args)
def capacity(self): return _inaoqi.StringVector_capacity(self)
__swig_destroy__ = _inaoqi.delete_StringVector
__del__ = lambda self : None;
StringVector_swigregister = _inaoqi.StringVector_swigregister
StringVector_swigregister(StringVector)

def setInstance(*args):
return _inaoqi.setInstance(*args)
setInstance = _inaoqi.setInstance
def getMemoryProxy():
return _inaoqi.getMemoryProxy()
getMemoryProxy = _inaoqi.getMemoryProxy
def _ALSystem(*args):
return _inaoqi._ALSystem(*args)
_ALSystem = _inaoqi._ALSystem
class broker(_object):
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, broker, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, broker, name)
__repr__ = _swig_repr
def __init__(self, *args):
this = _inaoqi.new_broker(*args)
try: self.this.append(this)
except: self.this = this
__swig_destroy__ = _inaoqi.delete_broker
__del__ = lambda self : None;
def shutdown(self): return _inaoqi.broker_shutdown(self)
def isModulePresent(self, *args): return _inaoqi.broker_isModulePresent(self, *args)
def getGlobalModuleList(self): return _inaoqi.broker_getGlobalModuleList(self)
broker_swigregister = _inaoqi.broker_swigregister
broker_swigregister(broker)
class baseModule(_object):
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, baseModule, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, baseModule, name)
__repr__ = _swig_repr
def __init__(self):
this = _inaoqi.new_baseModule()
try: self.this.append(this)
except: self.this = this
def BIND_PYTHON(self, *args): return _inaoqi.baseModule_BIND_PYTHON(self, *args)
def _bindWithParam(self, *args): return _inaoqi.baseModule__bindWithParam(self, *args)
def exit(self): return _inaoqi.baseModule_exit(self)
def getName(self): return _inaoqi.baseModule_getName(self)
def getBrokerName(self): return _inaoqi.baseModule_getBrokerName(self)
def setModuleDescription(self, *args): return _inaoqi.baseModule_setModuleDescription(self, *args)
def addParam(self, *args): return _inaoqi.baseModule_addParam(self, *args)
def functionName(self, *args): return _inaoqi.baseModule_functionName(self, *args)
def autoBind(self, *args): return _inaoqi.baseModule_autoBind(self, *args)
def _methodMissing0(self): return _inaoqi.baseModule__methodMissing0(self)
def _methodMissing1(self, *args): return _inaoqi.baseModule__methodMissing1(self, *args)
def _methodMissing2(self, *args): return _inaoqi.baseModule__methodMissing2(self, *args)
def _methodMissing3(self, *args): return _inaoqi.baseModule__methodMissing3(self, *args)
def _methodMissing4(self, *args): return _inaoqi.baseModule__methodMissing4(self, *args)
def _methodMissing5(self, *args): return _inaoqi.baseModule__methodMissing5(self, *args)
def _methodMissing6(self, *args): return _inaoqi.baseModule__methodMissing6(self, *args)
def _methodMissing(self): return _inaoqi.baseModule__methodMissing(self)
def version(self): return _inaoqi.baseModule_version(self)
__swig_destroy__ = _inaoqi.delete_baseModule
__del__ = lambda self : None;
baseModule_swigregister = _inaoqi.baseModule_swigregister
baseModule_swigregister(baseModule)
class module(baseModule):
__swig_setmethods__ = {}
for _s in [baseModule]: __swig_setmethods__.update(getattr(_s,’__swig_setmethods__’,{}))
__setattr__ = lambda self, name, value: _swig_setattr(self, module, name, value)
__swig_getmethods__ = {}
for _s in [baseModule]: __swig_getmethods__.update(getattr(_s,’__swig_getmethods__’,{}))
__getattr__ = lambda self, name: _swig_getattr(self, module, name)
__repr__ = _swig_repr
def __init__(self, *args):
this = _inaoqi.new_module(*args)
try: self.this.append(this)
except: self.this = this
def BIND_PYTHON(self, *args): return _inaoqi.module_BIND_PYTHON(self, *args)
def exit(self): return _inaoqi.module_exit(self)
def getName(self): return _inaoqi.module_getName(self)
def getBrokerName(self): return _inaoqi.module_getBrokerName(self)
def _methodMissing(self): return _inaoqi.module__methodMissing(self)
def version(self): return _inaoqi.module_version(self)
__swig_destroy__ = _inaoqi.delete_module
__del__ = lambda self : None;
module_swigregister = _inaoqi.module_swigregister
module_swigregister(module)
class timeline(_object):
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, timeline, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, timeline, name)
__repr__ = _swig_repr
def __init__(self, *args):
this = _inaoqi.new_timeline(*args)
try: self.this.append(this)
except: self.this = this
__swig_destroy__ = _inaoqi.delete_timeline
__del__ = lambda self : None;
def play(self): return _inaoqi.timeline_play(self)
def pause(self): return _inaoqi.timeline_pause(self)
def stop(self): return _inaoqi.timeline_stop(self)
def goTo(self, *args): return _inaoqi.timeline_goTo(self, *args)
def getSize(self): return _inaoqi.timeline_getSize(self)
def getFPS(self): return _inaoqi.timeline_getFPS(self)
def setFPS(self, *args): return _inaoqi.timeline_setFPS(self, *args)
timeline_swigregister = _inaoqi.timeline_swigregister
timeline_swigregister(timeline)
class behavior(baseModule):
__swig_setmethods__ = {}
for _s in [baseModule]: __swig_setmethods__.update(getattr(_s,’__swig_setmethods__’,{}))
__setattr__ = lambda self, name, value: _swig_setattr(self, behavior, name, value)
__swig_getmethods__ = {}
for _s in [baseModule]: __swig_getmethods__.update(getattr(_s,’__swig_getmethods__’,{}))
__getattr__ = lambda self, name: _swig_getattr(self, behavior, name)
__repr__ = _swig_repr
def __init__(self, *args):
this = _inaoqi.new_behavior(*args)
try: self.this.append(this)
except: self.this = this
__swig_destroy__ = _inaoqi.delete_behavior
__del__ = lambda self : None;
def setEnabled(self, *args): return _inaoqi.behavior_setEnabled(self, *args)
def isEnabled(self): return _inaoqi.behavior_isEnabled(self)
def setResources(self, *args): return _inaoqi.behavior_setResources(self, *args)
def waitFor(self, *args): return _inaoqi.behavior_waitFor(self, *args)
def waitResourcesCallback(self, *args): return _inaoqi.behavior_waitResourcesCallback(self, *args)
def isResourceFree(self, *args): return _inaoqi.behavior_isResourceFree(self, *args)
def waitResourceFree(self): return _inaoqi.behavior_waitResourceFree(self)
def waitResources(self): return _inaoqi.behavior_waitResources(self)
def releaseResource(self): return _inaoqi.behavior_releaseResource(self)
def addInput(self, *args): return _inaoqi.behavior_addInput(self, *args)
def addOutput(self, *args): return _inaoqi.behavior_addOutput(self, *args)
def addParameter(self, *args): return _inaoqi.behavior_addParameter(self, *args)
def getParameter(self, *args): return _inaoqi.behavior_getParameter(self, *args)
def getParametersList(self): return _inaoqi.behavior_getParametersList(self)
def setParameter(self, *args): return _inaoqi.behavior_setParameter(self, *args)
def stimulateIO(self, *args): return _inaoqi.behavior_stimulateIO(self, *args)
def BIND_PYTHON(self, *args): return _inaoqi.behavior_BIND_PYTHON(self, *args)
def setModuleDescription(self, *args): return _inaoqi.behavior_setModuleDescription(self, *args)
def addParam(self, *args): return _inaoqi.behavior_addParam(self, *args)
def exit(self): return _inaoqi.behavior_exit(self)
def getName(self): return _inaoqi.behavior_getName(self)
def getBrokerName(self): return _inaoqi.behavior_getBrokerName(self)
def _methodMissing(self): return _inaoqi.behavior__methodMissing(self)
def version(self): return _inaoqi.behavior_version(self)
def hasTimeline(self): return _inaoqi.behavior_hasTimeline(self)
def getTimeline(self): return _inaoqi.behavior_getTimeline(self)
def hasParentTimeline(self): return _inaoqi.behavior_hasParentTimeline(self)
def getParentTimeline(self): return _inaoqi.behavior_getParentTimeline(self)
behavior_swigregister = _inaoqi.behavior_swigregister
behavior_swigregister(behavior)
class proxy(_object):
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, proxy, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, proxy, name)
__repr__ = _swig_repr
def __init__(self, *args):
this = _inaoqi.new_proxy(*args)
try: self.this.append(this)
except: self.this = this
def pythonCall(self, *args): return _inaoqi.proxy_pythonCall(self, *args)
def pythonPCall(self, *args): return _inaoqi.proxy_pythonPCall(self, *args)
def wait(self, *args): return _inaoqi.proxy_wait(self, *args)
def stop(self, *args): return _inaoqi.proxy_stop(self, *args)
def isRunning(self, *args): return _inaoqi.proxy_isRunning(self, *args)
__swig_destroy__ = _inaoqi.delete_proxy
__del__ = lambda self : None;
proxy_swigregister = _inaoqi.proxy_swigregister
proxy_swigregister(proxy)
class ALMemoryProxy(_object):
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, ALMemoryProxy, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, ALMemoryProxy, name)
__repr__ = _swig_repr
def __init__(self, *args):
this = _inaoqi.new_ALMemoryProxy(*args)
try: self.this.append(this)
except: self.this = this
__swig_setmethods__[“post”] = _inaoqi.ALMemoryProxy_post_set
__swig_getmethods__[“post”] = _inaoqi.ALMemoryProxy_post_get
if _newclass:post = _swig_property(_inaoqi.ALMemoryProxy_post_get, _inaoqi.ALMemoryProxy_post_set)
def getGenericProxy(self): return _inaoqi.ALMemoryProxy_getGenericProxy(self)
def declareEvent(self, *args): return _inaoqi.ALMemoryProxy_declareEvent(self, *args)
def exit(self): return _inaoqi.ALMemoryProxy_exit(self)
def getBrokerName(self): return _inaoqi.ALMemoryProxy_getBrokerName(self)
def getData(self, *args): return _inaoqi.ALMemoryProxy_getData(self, *args)
def getDataList(self, *args): return _inaoqi.ALMemoryProxy_getDataList(self, *args)
def getDataListName(self): return _inaoqi.ALMemoryProxy_getDataListName(self)
def getDataOnChange(self, *args): return _inaoqi.ALMemoryProxy_getDataOnChange(self, *args)
def getDataPtr(self, *args): return _inaoqi.ALMemoryProxy_getDataPtr(self, *args)
def getDescriptionList(self, *args): return _inaoqi.ALMemoryProxy_getDescriptionList(self, *args)
def getEventHistory(self, *args): return _inaoqi.ALMemoryProxy_getEventHistory(self, *args)
def getEventList(self): return _inaoqi.ALMemoryProxy_getEventList(self)
def getExtractorEvent(self, *args): return _inaoqi.ALMemoryProxy_getExtractorEvent(self, *args)
def getListData(self, *args): return _inaoqi.ALMemoryProxy_getListData(self, *args)
def getMethodHelp(self, *args): return _inaoqi.ALMemoryProxy_getMethodHelp(self, *args)
def getMethodList(self): return _inaoqi.ALMemoryProxy_getMethodList(self)
def getMicroEventList(self): return _inaoqi.ALMemoryProxy_getMicroEventList(self)
def getModuleHelp(self): return _inaoqi.ALMemoryProxy_getModuleHelp(self)
def getSubscribers(self, *args): return _inaoqi.ALMemoryProxy_getSubscribers(self, *args)
def getTimestamp(self, *args): return _inaoqi.ALMemoryProxy_getTimestamp(self, *args)
def getType(self, *args): return _inaoqi.ALMemoryProxy_getType(self, *args)
def getUsage(self, *args): return _inaoqi.ALMemoryProxy_getUsage(self, *args)
def insertData(self, *args): return _inaoqi.ALMemoryProxy_insertData(self, *args)
def insertListData(self, *args): return _inaoqi.ALMemoryProxy_insertListData(self, *args)
def isRunning(self, *args): return _inaoqi.ALMemoryProxy_isRunning(self, *args)
def ping(self): return _inaoqi.ALMemoryProxy_ping(self)
def raiseEvent(self, *args): return _inaoqi.ALMemoryProxy_raiseEvent(self, *args)
def raiseMicroEvent(self, *args): return _inaoqi.ALMemoryProxy_raiseMicroEvent(self, *args)
def removeData(self, *args): return _inaoqi.ALMemoryProxy_removeData(self, *args)
def removeMicroEvent(self, *args): return _inaoqi.ALMemoryProxy_removeMicroEvent(self, *args)
def setDescription(self, *args): return _inaoqi.ALMemoryProxy_setDescription(self, *args)
def stop(self, *args): return _inaoqi.ALMemoryProxy_stop(self, *args)
def subscribeToEvent(self, *args): return _inaoqi.ALMemoryProxy_subscribeToEvent(self, *args)
def subscribeToMicroEvent(self, *args): return _inaoqi.ALMemoryProxy_subscribeToMicroEvent(self, *args)
def unregisterModuleReference(self, *args): return _inaoqi.ALMemoryProxy_unregisterModuleReference(self, *args)
def unsubscribeToEvent(self, *args): return _inaoqi.ALMemoryProxy_unsubscribeToEvent(self, *args)
def unsubscribeToMicroEvent(self, *args): return _inaoqi.ALMemoryProxy_unsubscribeToMicroEvent(self, *args)
def version(self): return _inaoqi.ALMemoryProxy_version(self)
def wait(self, *args): return _inaoqi.ALMemoryProxy_wait(self, *args)
__swig_destroy__ = _inaoqi.delete_ALMemoryProxy
__del__ = lambda self : None;
ALMemoryProxy_swigregister = _inaoqi.ALMemoryProxy_swigregister
ALMemoryProxy_swigregister(ALMemoryProxy)

pynaoqi-python-2.6-naoqi-1.14-linux32/motion.py
# Class Motion for storing useful ALMotion constants
# SPACES
SPACE_TORSO = 0
SPACE_WORLD = 1
SPACE_NAO = 2
# NEW in 1.14
FRAME_TORSO = 0
FRAME_WORLD = 1
FRAME_ROBOT = 2
# MOVEMENT
MVT_RELATIVE = 0
MVT_ABSOLUTE = 1
#ANGLE TYPE
COMMANDS = 0,
SENSORS = 1
# AXIS MASK
AXIS_MASK_X = 1
AXIS_MASK_Y = 2
AXIS_MASK_Z = 4
AXIS_MASK_WX = 8
AXIS_MASK_WY = 16
AXIS_MASK_WZ = 32
AXIS_MASK_ALL = 63
AXIS_MASK_VEL = 7
AXIS_MASK_ROT = 56
# COMPUTING
TO_RAD = 0.01745329
TO_DEG = 57.295779513082323

pynaoqi-python-2.6-naoqi-1.14-linux32/vision_definitions.py
# Useful constants used by the Vision modules.
# Camera model
kOV7670 = 1 # VGA camera
kMT9M114 = 2 # HD wide angle camera
# Image format
k960p = 3 # 1280*960
k4VGA = 3 # 1280*960
kVGA = 2 # 640*480
kQVGA = 1 # 320*240
kQQVGA = 0 # 160*120
# Color Space
kYuvColorSpace = 0
kyUvColorSpace = 1
kyuVColorSpace = 2
kRgbColorSpace = 3
krGbColorSpace = 4
krgBColorSpace = 5
kHsvColorSpace = 6
khSvColorSpace = 7
khsVColorSpace = 8
kYUV422InterlacedColorSpace = 9 #deprecated
kYUV422ColorSpace = 9
kYUVColorSpace = 10
kRGBColorSpace = 11
kHSVColorSpace = 12
kBGRColorSpace = 13
kYYCbCrColorSpace = 14
kH2RGBColorSpace = 15
kHSMixedColorSpace = 16

# Scale methods
kSimpleScaleMethod = 0
kAverageScaleMethod = 1
kQualityScaleMethod = 2
kNoScaling = 3

# Standard Id
kCameraBrightnessID = 0
kCameraContrastID = 1
kCameraSaturationID = 2
kCameraHueID = 3
kCameraRedChromaID = 4
kCameraBlueChromaID = 5
kCameraGainID = 6
kCameraHFlipID = 7
kCameraVFlipID = 8
kCameraLensXID = 9
kCameraLensYID = 10
kCameraAutoExpositionID = 11
kCameraAutoWhiteBalanceID = 12
kCameraAutoGainID = 13
kCameraResolutionID = 14
kCameraFrameRateID = 15
kCameraBufferSizeID = 16
kCameraExposureID = 17
kCameraSelectID = 18
kCameraSetDefaultParamsID = 19
kCameraColorSpaceID = 20
kCameraExposureCorrectionID = 21
kCameraAecAlgorithmID = 22
kCameraFastSwitchID = 23
kCameraSharpnessID = 24
kCameraAwbGreenGainID = 25
kCameraAblcID = 26
kCameraAblcTargetID = 27
kCameraAblcStableRangeID = 28
kCameraBlcBlueID = 29
kCameraBlcRedID = 30
kCameraBlcGbID = 31
kCameraBlcGrID = 32
kCameraWhiteBalanceID = 33
kCameraBacklightCompensationID = 34

pynaoqi-python-2.6-naoqi-1.14-linux64/_inaoqi.so

pynaoqi-python-2.6-naoqi-1.14-linux64/_almath.so

pynaoqi-python-2.6-naoqi-1.14-linux64/naoqi.py
import os
import sys
import weakref
import logging

try:
import _inaoqi
except ImportError:
# quick hack to keep inaoqi.py happy
if sys.platform.startswith(“win”):
print “Could not find _inaoqi, trying with _inaoqi_d”
import _inaoqi_d as _inaoqi
else:
raise
import inaoqi
import motion
import allog
def autoBind(myClass, bindIfnoDocumented):
“””Show documentation for each
method of the class”””
# dir(myClass) is a list of the names of
# everything in class
myClass.setModuleDescription(myClass.__doc__)
for thing in dir(myClass):
# getattr(x, “y”) is exactly: x.y
function = getattr(myClass, thing)
if callable(function):
if (type(function) == type(myClass.__init__)):
if (bindIfnoDocumented or function.__doc__ != “”):
if (thing[0] != “_”): # private method
if (function.__doc__):
myClass.functionName(thing, myClass.getName(), function.__doc__)
else:
myClass.functionName(thing, myClass.getName(), “”)
for param in function.func_code.co_varnames:
if (param != “self”):
myClass.addParam(param)
myClass._bindWithParam(myClass.getName(),thing,len(function.func_code.co_varnames)-1)

class ALDocable():
def __init__(self, bindIfnoDocumented):
autoBind(self,bindIfnoDocumented)

# define the log handler to be used by the logging module
class ALLogHandler(logging.Handler):
def __init__(self):
logging.Handler.__init__(self)
def emit(self, record):
level_to_function = {
logging.DEBUG: allog.debug,
logging.INFO: allog.info,
logging.WARNING: allog.warning,
logging.ERROR: allog.error,
logging.CRITICAL: allog.fatal,
}
function = level_to_function.get(record.levelno, allog.debug)
function(record.getMessage(),
record.name,
record.filename,
record.funcName,
record.lineno)

# Same as above, but we force the category to be behavior.box
# *AND* we prefix the message with the module name
# look at errorInBox in choregraphe for explanation
class ALBehaviorLogHandler(logging.Handler):
def __init__(self):
logging.Handler.__init__(self)
def emit(self, record):
level_to_function = {
logging.DEBUG: allog.debug,
logging.INFO: allog.info,
logging.WARNING: allog.warning,
logging.ERROR: allog.error,
logging.CRITICAL: allog.fatal,
}
function = level_to_function.get(record.levelno, allog.debug)
function(record.name + “: ” + record.getMessage(),
“behavior.box”,
“”, # record.filename in this case is simply ‘‘
record.funcName,
record.lineno)
# define a class that will be inherited by both ALModule and ALBehavior, to store instances of modules, so a bound method can be called on them.
class NaoQiModule():
_modules = dict()
@classmethod
def getModule(cls, name):
# returns a reference a module, giving its string, if it exists !
if(name not in cls._modules):
raise RuntimeError(“Module ” + str(name) + ” does not exist”)
return cls._modules[name]()
def __init__(self, name, logger=True):
# keep a weak reference to ourself, so a proxy can be called on this module easily
self._modules[name] = weakref.ref(self)
self.loghandler = None
if logger:
self.logger = logging.getLogger(name)
self.loghandler = ALLogHandler()
self.logger.addHandler(self.loghandler)
self.logger.setLevel(logging.DEBUG)
def __del__(self):
# when object is deleted, clean up dictionnary so we do not keep a weak reference to it
del self._modules[self.getName()]
if(self.loghandler != None):
self.logger.removeHandler(self.loghandler)

class ALBroker(inaoqi.broker):
def init(self):
pass
class ALModule(inaoqi.module, ALDocable, NaoQiModule):
def __init__(self,param):
inaoqi.module.__init__(self, param)
ALDocable.__init__(self, False)
NaoQiModule.__init__(self, param)
def __del__(self):
NaoQiModule.__del__(self)
def methodtest(self):
pass
def pythonChanged(self, param1, param2, param3):
pass

class ALBehavior(inaoqi.behavior, NaoQiModule):
# class var in order not to build it each time
_noNeedToBind = set(dir(inaoqi.behavior))
_noNeedToBind.add(“getModule”)
_noNeedToBind.add(“onLoad”)
_noNeedToBind.add(“onUnload”)
# deprecated since 1.14 methods
_noNeedToBind.add(“log”)
_noNeedToBind.add(“playTimeline”)
_noNeedToBind.add(“stopTimeline”)
_noNeedToBind.add(“exitBehavior”)
_noNeedToBind.add(“gotoAndStop”)
_noNeedToBind.add(“gotoAndPlay”)
_noNeedToBind.add(“playTimelineParent”)
_noNeedToBind.add(“stopTimelineParent”)
_noNeedToBind.add(“exitBehaviorParent”)
_noNeedToBind.add(“gotoAndPlayParent”)
_noNeedToBind.add(“gotoAndStopParent”)
def __init__(self, param, autoBind):
inaoqi.behavior.__init__(self, param)
NaoQiModule.__init__(self, param, logger=False)
self.logger = logging.getLogger(param)
self.behaviorloghandler = ALBehaviorLogHandler()
self.logger.addHandler(self.behaviorloghandler)
self.logger.setLevel(logging.DEBUG)
self.resource = False
self.BIND_PYTHON(self.getName(), “__onLoad__”)
self.BIND_PYTHON(self.getName(), “__onUnload__”)
if(autoBind):
behName = self.getName()
userMethList = set(dir(self)) – self._noNeedToBind
for methName in userMethList:
function = getattr(self, methName)
if callable(function) and type(function) == type(self.__init__):
if (methName[0] != “_”): # private method
self.functionName(methName, behName, “”)
for param in function.func_code.co_varnames:
if (param != “self”):
self.addParam(param)
self._bindWithParam(behName,methName,len(function.func_code.co_varnames)-1)
def __del__(self):
NaoQiModule.__del__(self)
self.logger.removeHandler(self.behaviorloghandler)
self.behaviorloghandler.close()
def __onLoad__(self):
self._safeCallOfUserMethod(“onLoad”,None)
def __onUnload__(self):
if(self.resource):
self.releaseResource()
self._safeCallOfUserMethod(“onUnload”,None)
def setParameter(self, parameterName, newValue):
inaoqi.behavior.setParameter(self, parameterName, newValue)
def _safeCallOfUserMethod(self, functionName, functionArg):
try:
if(functionName in dir(self)):
func = getattr(self, functionName)
if(func.im_func.func_code.co_argcount == 2):
func(functionArg)
else:
func()
return True
except BaseException, err:
self.logger.error(str(err))
try:
if(“onError” in dir(self)):
self.onError(self.getName() + ‘:’ +str(err))
except BaseException, err2:
self.logger.error(str(err2))
return False
# Depreciate this!!! Same as self.logger.info(), but function is always “log”
def log(self, p):
self.logger.info(p)

class MethodMissingMixin(object):
“”” A Mixin’ to implement the ‘method_missing’ Ruby-like protocol. “””
def __getattribute__(self, attr):
try:
return object.__getattribute__(self, attr)
except:
class MethodMissing(object):
def __init__(self, wrapped, method):
self.__wrapped__ = wrapped
self.__method__ = method
def __call__(self, *args, **kwargs):
return self.__wrapped__.method_missing(self.__method__, *args, **kwargs)
return MethodMissing(self, attr)
def method_missing(self, *args, **kwargs):
“”” This method should be overridden in the derived class. “””
raise NotImplementedError(str(self.__wrapped__) + ” ‘method_missing’ method has not been implemented.”)

class postType(MethodMissingMixin):
def __init__(self):
“”
def setProxy(self, proxy):
self.proxy = weakref.ref(proxy)
# print name
def method_missing(self, method, *args, **kwargs):
list = []
list.append(method)
for arg in args:
list.append(arg)
result = 0
try:
p = self.proxy()
result = p.pythonPCall(list)
except RuntimeError,e:
raise e
return result

class ALProxy(inaoqi.proxy,MethodMissingMixin):
def __init__(self, *args):
self.post = postType()
self.post.setProxy(self)
if (len (args) == 1):
inaoqi.proxy.__init__(self, args[0])
elif (len (args) == 2):
inaoqi.proxy.__init__(self, args[0], args[1])
else:
inaoqi.proxy.__init__(self, args[0], args[1], args[2])
def call(self, *args):
list = []
for arg in args:
list.append(arg)
return self.pythonCall(list)

def pCall(self, *args):
list = []
for arg in args:
list.append(arg)
return self.pythonPCall(list)

def method_missing(self, method, *args, **kwargs):
list = []
list.append(method)
for arg in args:
list.append(arg)
result = 0
try:
result = self.pythonCall(list)
except RuntimeError,e:
raise e
#print e.args[0]
return result
@staticmethod
def initProxies():
#Warning: The use of these default proxies is deprecated.
global ALMemory
global ALMotion
global ALFrameManager
global ALLeds
global ALLogger
global ALSensors
try:
ALMemory = inaoqi.getMemoryProxy()
except:
ALMemory = ALProxy(“ALMemory”)
try:
ALFrameManager = ALProxy(“ALFrameManager”)
except:
print “No proxy to ALFrameManager”
try:
ALMotion = ALProxy(“ALMotion”)
except:
print “No proxy to ALMotion”
try:
ALLeds = ALProxy(“ALLeds”)
except:
pass
try:
ALLogger = ALProxy(“ALLogger”)
except:
print “No proxy to ALLogger”
try:
ALSensors = ALProxy(“ALSensors”)
except:
pass

def createModule(name):
global moduleList
str = “moduleList.append(“+ “module(\”” + name + “\”))”
exec(str)

pynaoqi-python-2.6-naoqi-1.14-linux64/license.rtf

End-
User Software License Agreement

This Limited End-User Software License Agreement (the “Agreement”) is a legal agreement between you (“Licensee”), the end-user, and Aldebaran Robotics SAS having its registered office at 168-170 Rue Raymond Losserand, 75014 Paris, France, registered with the trade and companies register of Paris under number 483 185 807 (hereinafter “Aldebaran”) for the use of the ” Aldebaran Software Toolkit ” (“Software”). By using this software or storing this program on a computer or robot hard drive (or other media), you are agreeing to be bound by the terms of this Agreement. If you do not agree to any of the terms of this agreement uninstall and delete the software from all storage media.

ARTICLE 1 – RIGHTS GRANTED

ALDEBARAN grants to the LICENSEE a personal, non-exclusive, non-transferable, non sub-licensable right to install and use the Software and the Documentation (if any), for the duration of the applicable intellectual property rights.

ALDEBARAN shall have the right to make update and/or upgrade of the Software. However this Agreement does not grant any right on any update or upgrade of the Software. In the event ALDEBARAN provided an upgrade or upgrade of the Software which is not used by Licensee will not benefit from warranties given by ALDABARAN within this Agreement (as far as permitted by the applicable law).

ALDEBARAN may discontinue or change the Software, at any time or for any reason, with or without notice. To avoid any misunderstanding it is agreed that ALDEBARAN has no right to operate a change on the LICENSEE‘s device where the Software is install without its consent.

This Agreement does not grant any right to any Third-Party Software.

Some Third-Party Software may be needed to permit the Software to operate properly. Even in such event ALDEBARAN is not granting any right on the Third-Party Software. The Third-Party Software remains subject to the specific licenses applicable to each Third-Party Software and as described in their related applicable documentation. Licensee shall on his owns decide to either accept or not the applicable terms and conditions related to Third-Party Software. Licensee accepts and understands that refusing the terms and conditions applicable to Third-Party Software may impact in whole or in part the use of the Software.

ARTICLE 2 – OBLIGATIONS OF THE LICENSEE

LICENSEE agrees to the following:

– The LICENSEE shall strictly comply with the user instructions set forth in the Documentation;

– Even if LICENSEE keeps its right of objectively critic the Software, the LICENSEE shall not take any action to impair the reputation of the Product, the trademarks of ALDEBARAN or its licensors and any other product of ALDEBARAN or its licensors;

– LICENSEE shall in no event use the Software for any illegal, defaming, pornographic or detrimental activities;

– The LICENSEE shall use the ALDEBARAN name and trademarks only in the manner prescribed by ALDEBARAN in writing;

– The LICENSEE shall inform ALDEBARAN of any potential defects discovered when using the Product;

– The LICENSEE shall notify ALDEBARAN promptly of any legal notices, claims or actions directly or indirectly relating to the Software against a third party and not enter into or compromise any legal action or other proceeding relating to the Software without the prior written consent of ALDEBARAN;

– The LICENSEE shall not use, without the prior written consent of ALDEBARAN, the Software for the benefit of third parties in any manner, and in particular:

(a) not sell, resell, lease, transfer, license or sublicense or otherwise provide the Software to any third party, and, in a more general manner, not communicate all or part of the Software to any third party;

(b) not charge or otherwise deal in or encumber the Software;

– The LICENSEE shall not delete, remove or in any way obscure the proprietary notices, labels or marks of ALDEBARAN or its licensors on the Software and conspicuously display the proprietary notices, labels or marks on any copy of the Software;

– Except otherwise expressly agreed the LICENSEE shall not alter, modify, decompile, disassemble, or reverse engineer the program code or any other part of the Software, in whole or in part, except in the events and only to the extent expressly provided by law. However, even if the law authorizes the above acts, LICENSEE shall give ALDEBARAN a written notice seven (7) calendar days prior to the date on which these acts are scheduled to take place and allow a representative of ALDEBARAN to be present during these acts;

– Except otherwise expressly agreed the LICENSEE shall not develop any other software programs or derivative works on the basis of the Software. Any such software program or derivative work shall in no case be sold, assigned or licensed by the LICENSEE;

– To avoid any misunderstanding it is agreed that LICENSEE shall have the right to use and exploit the result given by the use of the software in conformity of this license agreement.

– The LICENSEE shall not use the Software for illegal purposes or in illegal manner, including in violation of the intellectual property rights of ALDEBARAN or any third party;

– The LICENSEE shall provide ALDEBARAN promptly with any information, material, software or specification as may reasonably be required for the proper performance of this Agreement including access to appropriate members of the LICENSEE’s staff. The LICENSEE is responsible for the completeness and accuracy of such information, material, software or specification;

ARTICLE 3 – LIMITED WARRANTIES AND LIMITATION OF LIABILITY

3.1 ALDEBARAN warrants that it has full title and ownership to the Software. ALDEBARAN also warrants that it has the full power and authority to enter into this agreement and to grant the license conveyed in this Agreement. Aldebaran warrants that the use of the Software in conformity with this Agreement will in no way constitute an infringement or other violation of any Intellectual Property of any third party.
Should the Software give rise, or in ALDEBARAN opinion be likely to give rise to any such claim, ALDEBARAN shall, at its option and expense, either:

(i) procure for LICENSEE the right to continue using such Aldebaran Software; or
(ii) replace or modify the Aldebaran Software so that it does not infringe the intellectual property rights anymore; or
(iii) terminate the right of use of the Software.

Except as set out in this Agreement, all conditions, warranties and representations in relation to the Software are excluded to the extent permitted under applicable law.

3.2 AS FAR AS PERMITTED BY THE APPLICABLE LAW:

ALDEBARAN PROVIDES THE SOFTWARE “AS IS”, AND DOES NOT WARRANT THAT THE USE OF THE SOFTWARE, FUNCTIONALITY, THE OPERATION AND/OR CONTENT WILL BE: UNINTERRUPTED, ACCURATE, COMPLETE, FREE FROM ANY SOFTWARE VIRUS OR OTHER HARMFUL COMPONENT.

ALDEBARAN DOES NOT WARRANT THE INTERNAL CHARACTERISTICS, THE COMPATIBILITY FO THE SOFTWARE WITH OTHER SOFTWARE, THE ACCURACY, ADEQUACY, OR COMPLETENESS OF SOTWARE AND ITS RESULT AND DISCLAIMS LIABILITY FOR ERRORS OR OMISSIONS.

ALDEBARAN DISCLAIMS ANY REPRESENTATIONS, WARRANTIES OR CONDITIONS, EXPRESS OR IMPLIED, INCLUDING THOSE OF PERFORMANCE OR MERCHANTABILITY OR RELIABILITY USEFULNESS OR FITNESS FOR A PARTICULAR PURPOSE WITH RESPECT TO THE SOFTWARE AND ITS RESULTS.

3.3 IN NO EVENT WILL ALDEBARAN BE LIABLE FOR ANY DAMAGES (INCLUDING WITHOUT LIMITATION DIRECT, INDIRECT, PUNITIVE, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES, COST OF PROCURING SUBSTITUTE SERVICES, LOST PROFITS, LOSS OF DATA, LOSSES, OR OTHER EXPENSES) ARISING IN CONNECTION WITH THE PROVISION OR USE OF THE SOFTWARE, RELATED SERVICES OR INFORMATION PROVIDED PURSUANT TO THIS AGREEMENT, REGARDLESS OF WHETHER SUCH CLAIMS ARE BASED ON CONTRACT, TORT, STRICT LIABILITY, OR OTHERWISE, OR WHETHER PROVIDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES, LOSSES, OR EXPENSES.

WITHOUT LIMITING THE FOREGOING, THIS LIMITATION OF LIABILITY INCLUDES, BUT IS NOT LIMITED TO, THE UNAVAILABILITY OF THE APPLICATION(S), UNAUTHORIZED ACCESS, ANY FAILURE OF PERFORMANCE, INTERRUPTION, ERROR, OMISSION, DEFECT, DELAY IN OPERATION OR TRANSMISSION, COMPUTER VIRUS, OR SYSTEM FAILURE.

NOTWITHSTANDING ANYTHING TO THE CONTRARY IN THIS AGREEMENT OR ANY STATUTE OR RULE OF LAW TO THE CONTRARY, SUBJECT TO THIS ARTICLE, ALDEBARAN’S CUMULATIVE LIABILITY FOR ALL CLAIMS ARISING OUT OF OR IN CONNECTION WITH THIS AGREEMENT, WHETHER DIRECTLY OR INDIRECTLY, SHALL NOT EXCEED ALL FEES PAID TO ALDEBARAN BY THE LICENSEE FOR THE USE OF THE SOFTWARE. IN THE EVENT THE SOFTWARE IS GRANTED FOR FREE TO THE LICENSEE, ALDEBARAN’S CUMULATIVE LIABILITY FOR ALL CLAIMS ARISING OUT OF OR IN CONNECTION WITH THIS AGREEMENT, WHETHER DIRECTLY OR INDIRECTLY, SHALL NOT EXCEED 100 € (ONE HUNDRED EUROS).

WHENEVER THE ABOVE SECTIONS ARE NOT APPLICABLE UNDER THE APPLYING LAW ALDEBARAN AS SOLE REMEDY SHALL AT ITS OPTION AND EXPENSE EITHER (I) REPAIR THE DEFECTIVE OR INFRINGING SOFTWARE, OR (II) REPLACE THE DEFECTIVE OR INFRINGING SOFTWARE, OR (III) REIMBURSE THE FEE PAID TO ALDEBARAN FOR THE DEFECTIVE OR INFRINGING SOFTWARE. THESE REMEDIES ARE EXCLUSIVE OF ANY OTHER REMEDIES AND ANY OTHER WARRANTY IS EXCLUDED.

ANY INDEMNIFICATION BY ALDEBARAN UNDER THIS WARRANTY IS EXCLUDED IF THE CLAIM IS BASED UPON (I) A MODIFIED VERSION OF THE SOFTWARE FOR WHICH THE CHANGES HAVE NOT BEEN EXPRESSLY AUTHORIZED OR VALIDATED BY ALDEBARAN, OR (II) A COMBINATION, INSTALLATION OR USE OF ANY SOFTWARE COMPONENT EMBEDDED IN THE NAO ROBOT WITH ANY OTHER ELEMENT, MATERIAL OR ITEM THAT IS NOT EXPRESSLY PROVIDED BY ALDEBARAN FOR COMBINATION, INSTALLATION OR USE WITH THE SOFTWARE,
OR (III) A COMBINATION, INSTALLATION OR USE OF THE SOFTWARE WITH ANY OTHER ELEMENT, MATERIAL OR ITEM THAT IS NOT EXPRESSLY AUTHORIZED BY ALDEBARAN FOR COMBINATION, INSTALLATION OR USE WITH THE SOFTWARE, OR (IV) ANY OTHER FAULT OR NEGLIGENCE OF LICENSEE OR A THIRD PARTY.

This warranty does not cover incorrect installation or use by any third party; misuse of the Software voids the warranty.
The Third-Party Software is warranted only as provided in the specific licenses applicable to each.

ARTICLE 4 – INTELLECTUAL PROPERTY

ALDEBARAN is the owner or licensee of the Software. Title, copyright and any other proprietary and intellectual property right in the Software shall remain vested in ALDEBARAN or its licensors. The rights granted to the LICENSEE under this Agreement do not transfer to the LICENSEE title or any proprietary or intellectual property rights to the Software and do not constitute a sale of such rights;

ALDEBARAN shall retain the ownership of all rights in any inventions, discoveries, improvements, ideas, techniques or know-how embodied conceived by ALDEBARAN under this Agreement, including, without limitation, its methods of work, programs, methodologies and related documentation, including any derivative works of software code developed by ALDEBARAN in the course of performing this Agreement as well any knowledge and experience of ALDEBARAN’s directors, staff and consultants.

ARTICLE 5
–

COLLECTION AND USE OF PERSONAL INFORMATION

Privacy of the Licensee is important to ALDEBARAN. Therefore ALDEBARAN is not collecting any personal data except as expressly agreed by the Licensee.

ALDEBARAN will abide any applicable law, rules, or regulations relating to the privacy of personal information. Such data shall only be used for the purposes for which it was provided. Licensee understands that Third Party software may have their own privacy policy which may be less secure than the Aldebaran’s privacy policy.

ALDEBARAN will do its best to ensure that any personal data which may be collected from the Licensee will remain confidential.

Licensee hereby agrees and consents that the following data maybe collected by ALDEBARAN in order permit a network-enhanced services, improve the general quality and/or functionality of its products and/or software, permit development of new version of its products and/or software, fix bug or defect, develop patch and other solution, permit to install new version, update or upgrade, monitor and/or permit the maintenance of Aldebaran products and/or software:
Crash reporting, robot ID, robot health metrics, hardware-specific preferences, application install history, user preferences.

Licensee expressly consents that Aldebaran may generate statistical data from the information provided through the Software without identifying Licensee.
Licensee understands and agrees that, within the course of the use of the software, some voice data and/or video data could transit through ALDEBARAN and/or other third party network.

ARTICLE 6 – NO TRANSFER OR ASSIGNMENT

In no event shall LICENSEE sublicense, assign or otherwise transfer all or part of its rights and obligations under this Agreement to any third party. Any such sublicensing, assignment or transfer shall be null and void, unless expressly agreed to by ALDEBARAN in writing.

ARTICLE 7 – MISCELLEANEOUS

Termination. Either party may terminate this Agreement without advance notice. In case of breach of this Agreement by the Licensee, the authorization to access and use the Software will automatically terminate absent Aldebaran’s written waiver of such breach.

Survival. To the extent applicable, the following articles shall survive the termination, cancellation, expiration, and/or rescission of this Agreement: Articles 3.3, 4, 5, 7 and any provision that expressly states its survival and/or are necessary for the enforcement of this Agreement.

Headings. The headings referred to or used in this Agreement are for reference and convenience purposes only and shall not in any way limit or affect the meaning or interpretation of any of the terms hereof.

Severability. If any of the provisions of this Agreement are held or deemed to be invalid, illegal or unenforceable, the remaining provisions of this Agreement shall be unimpaired, and the invalid, illegal or unenforceable provision shall be replaced by a mutually acceptable provision, which being valid, legal and enforceable, comes closest to the intention of the Parties underlying the invalid, illegal or unenforceable provision.

Waiver. Any failure or delay by either Party in exercising its right under any provisions of the Agreement shall not be construed as a waiver of those rights at any time now or in the future unless an express declaration in writing from the Party concerned.

Governing law and Jurisdiction. Parties agree that all matters arising from or relating to the Software and this Agreement, shall be governed by the laws of France, without regard to conflict of laws principles. In the event of any dispute between the Parties, the Parties agreed to meet to discuss their dispute before resorting to formal dispute resolution procedures.

BY CLICKING “AGREE”, YOU AS LICENSEE ACKNOWLEDGE THAT YOU HAVE READ, UNDERSTAND AND ACCEPT THIS LIMITED END-USER SOFTWARE LICENSE AGREEMENT.

BY CLICKING “AGREE” YOU AS LICENSEE AGREE TO BE BOUND BY ALL OF ITS TERMS AND CONDITIONS OF THIS LIMITED END-USER SOFTWARE LICENSE AGREEMENT.

IF YOU AS A LICENSEE DO NOT AGREE TO ANY TERMS AND CONDITIONS, OF THIS LIMITED END-USER SOFTWARE LICENSE AGREEMENT DO NOT INSTALL OR USE THE SOFTWARE AND CLICK ON “DISAGREE”. By CLICKING ON “DESAGREE” YOU WILL NOT BE ABLE TO USE THE SOFTWARE.

pynaoqi-python-2.6-naoqi-1.14-linux64/allog.py
# This file was automatically generated by SWIG (http://www.swig.org).
# Version 1.3.40
#
# Do not make changes to this file unless you know what you are doing–modify
# the SWIG interface file instead.
# This file is compatible with both classic and new-style classes.
from sys import version_info
if version_info >= (2,6,0):
def swig_import_helper():
from os.path import dirname
import imp
fp = None
try:
fp, pathname, description = imp.find_module(‘_allog’, [dirname(__file__)])
except ImportError:
import _allog
return _allog
if fp is not None:
try:
_mod = imp.load_module(‘_allog’, fp, pathname, description)
finally:
fp.close()
return _mod
_allog = swig_import_helper()
del swig_import_helper
else:
import _allog
del version_info
try:
_swig_property = property
except NameError:
pass # Python < 2.2 doesn't have 'property'. 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__ == 'SwigPyObject': 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,)
try:
_object = object
_newclass = 1
except AttributeError:
class _object : pass
_newclass = 0

def debug(*args):
return _allog.debug(*args)
debug = _allog.debug
def info(*args):
return _allog.info(*args)
info = _allog.info
def warning(*args):
return _allog.warning(*args)
warning = _allog.warning
def error(*args):
return _allog.error(*args)
error = _allog.error
def fatal(*args):
return _allog.fatal(*args)
fatal = _allog.fatal

pynaoqi-python-2.6-naoqi-1.14-linux64/almath.py
# This file was automatically generated by SWIG (http://www.swig.org).
# Version 1.3.40
#
# Do not make changes to this file unless you know what you are doing–modify
# the SWIG interface file instead.
# This file is compatible with both classic and new-style classes.
from sys import version_info
if version_info >= (2,6,0):
def swig_import_helper():
from os.path import dirname
import imp
fp = None
try:
fp, pathname, description = imp.find_module(‘_almath’, [dirname(__file__)])
except ImportError:
import _almath
return _almath
if fp is not None:
try:
_mod = imp.load_module(‘_almath’, fp, pathname, description)
finally:
fp.close()
return _mod
_almath = swig_import_helper()
del swig_import_helper
else:
import _almath
del version_info
try:
_swig_property = property
except NameError:
pass # Python < 2.2 doesn't have 'property'. 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__ == 'SwigPyObject': 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,)
try:
_object = object
_newclass = 1
except AttributeError:
class _object : pass
_newclass = 0

class SwigPyIterator(_object):
“””Proxy of C++ swig::SwigPyIterator class”””
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, SwigPyIterator, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, SwigPyIterator, name)
def __init__(self, *args, **kwargs): raise AttributeError(“No constructor defined – class is abstract”)
__repr__ = _swig_repr
__swig_destroy__ = _almath.delete_SwigPyIterator
__del__ = lambda self : None;
def value(self):
“””value(self) -> PyObject”””
return _almath.SwigPyIterator_value(self)
def incr(self, n = 1):
“””
incr(self, size_t n = 1) -> SwigPyIterator
incr(self) -> SwigPyIterator
“””
return _almath.SwigPyIterator_incr(self, n)
def decr(self, n = 1):
“””
decr(self, size_t n = 1) -> SwigPyIterator
decr(self) -> SwigPyIterator
“””
return _almath.SwigPyIterator_decr(self, n)
def distance(self, *args):
“””distance(self, SwigPyIterator x) -> ptrdiff_t”””
return _almath.SwigPyIterator_distance(self, *args)
def equal(self, *args):
“””equal(self, SwigPyIterator x) -> bool”””
return _almath.SwigPyIterator_equal(self, *args)
def copy(self):
“””copy(self) -> SwigPyIterator”””
return _almath.SwigPyIterator_copy(self)
def next(self):
“””next(self) -> PyObject”””
return _almath.SwigPyIterator_next(self)
def __next__(self):
“””__next__(self) -> PyObject”””
return _almath.SwigPyIterator___next__(self)
def previous(self):
“””previous(self) -> PyObject”””
return _almath.SwigPyIterator_previous(self)
def advance(self, *args):
“””advance(self, ptrdiff_t n) -> SwigPyIterator”””
return _almath.SwigPyIterator_advance(self, *args)
def __eq__(self, *args):
“””__eq__(self, SwigPyIterator x) -> bool”””
return _almath.SwigPyIterator___eq__(self, *args)
def __ne__(self, *args):
“””__ne__(self, SwigPyIterator x) -> bool”””
return _almath.SwigPyIterator___ne__(self, *args)
def __iadd__(self, *args):
“””__iadd__(self, ptrdiff_t n) -> SwigPyIterator”””
return _almath.SwigPyIterator___iadd__(self, *args)
def __isub__(self, *args):
“””__isub__(self, ptrdiff_t n) -> SwigPyIterator”””
return _almath.SwigPyIterator___isub__(self, *args)
def __add__(self, *args):
“””__add__(self, ptrdiff_t n) -> SwigPyIterator”””
return _almath.SwigPyIterator___add__(self, *args)
def __sub__(self, *args):
“””
__sub__(self, ptrdiff_t n) -> SwigPyIterator
__sub__(self, SwigPyIterator x) -> ptrdiff_t
“””
return _almath.SwigPyIterator___sub__(self, *args)
def __iter__(self): return self
SwigPyIterator_swigregister = _almath.SwigPyIterator_swigregister
SwigPyIterator_swigregister(SwigPyIterator)
class vectorFloat(_object):
“””Proxy of C++ std::vector<(float)> class”””
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, vectorFloat, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, vectorFloat, name)
def iterator(self):
“””iterator(self) -> SwigPyIterator”””
return _almath.vectorFloat_iterator(self)
def __iter__(self): return self.iterator()
def __nonzero__(self):
“””__nonzero__(self) -> bool”””
return _almath.vectorFloat___nonzero__(self)
def __bool__(self):
“””__bool__(self) -> bool”””
return _almath.vectorFloat___bool__(self)
def __len__(self):
“””__len__(self) -> size_type”””
return _almath.vectorFloat___len__(self)
def pop(self):
“””pop(self) -> value_type”””
return _almath.vectorFloat_pop(self)
def __getslice__(self, *args):
“””__getslice__(self, difference_type i, difference_type j) -> vectorFloat”””
return _almath.vectorFloat___getslice__(self, *args)
def __setslice__(self, *args):
“””__setslice__(self, difference_type i, difference_type j, vectorFloat v)”””
return _almath.vectorFloat___setslice__(self, *args)
def __delslice__(self, *args):
“””__delslice__(self, difference_type i, difference_type j)”””
return _almath.vectorFloat___delslice__(self, *args)
def __delitem__(self, *args):
“””
__delitem__(self, difference_type i)
__delitem__(self, PySliceObject slice)
“””
return _almath.vectorFloat___delitem__(self, *args)
def __getitem__(self, *args):
“””
__getitem__(self, PySliceObject slice) -> vectorFloat
__getitem__(self, difference_type i) -> value_type
“””
return _almath.vectorFloat___getitem__(self, *args)
def __setitem__(self, *args):
“””
__setitem__(self, PySliceObject slice, vectorFloat v)
__setitem__(self, difference_type i, value_type x)
“””
return _almath.vectorFloat___setitem__(self, *args)
def append(self, *args):
“””append(self, value_type x)”””
return _almath.vectorFloat_append(self, *args)
def empty(self):
“””empty(self) -> bool”””
return _almath.vectorFloat_empty(self)
def size(self):
“””size(self) -> size_type”””
return _almath.vectorFloat_size(self)
def clear(self):
“””clear(self)”””
return _almath.vectorFloat_clear(self)
def swap(self, *args):
“””swap(self, vectorFloat v)”””
return _almath.vectorFloat_swap(self, *args)
def get_allocator(self):
“””get_allocator(self) -> allocator_type”””
return _almath.vectorFloat_get_allocator(self)
def begin(self):
“””begin(self) -> const_iterator”””
return _almath.vectorFloat_begin(self)
def end(self):
“””end(self) -> const_iterator”””
return _almath.vectorFloat_end(self)
def rbegin(self):
“””rbegin(self) -> const_reverse_iterator”””
return _almath.vectorFloat_rbegin(self)
def rend(self):
“””rend(self) -> const_reverse_iterator”””
return _almath.vectorFloat_rend(self)
def pop_back(self):
“””pop_back(self)”””
return _almath.vectorFloat_pop_back(self)
def erase(self, *args):
“””
erase(self, iterator pos) -> iterator
erase(self, iterator first, iterator last) -> iterator
“””
return _almath.vectorFloat_erase(self, *args)
def __init__(self, *args):
“””
__init__(self) -> vectorFloat
__init__(self, vectorFloat arg0) -> vectorFloat
__init__(self, size_type size) -> vectorFloat
__init__(self, size_type size, value_type value) -> vectorFloat
“””
this = _almath.new_vectorFloat(*args)
try: self.this.append(this)
except: self.this = this
def push_back(self, *args):
“””push_back(self, value_type x)”””
return _almath.vectorFloat_push_back(self, *args)
def front(self):
“””front(self) -> value_type”””
return _almath.vectorFloat_front(self)
def back(self):
“””back(self) -> value_type”””
return _almath.vectorFloat_back(self)
def assign(self, *args):
“””assign(self, size_type n, value_type x)”””
return _almath.vectorFloat_assign(self, *args)
def resize(self, *args):
“””
resize(self, size_type new_size)
resize(self, size_type new_size, value_type x)
“””
return _almath.vectorFloat_resize(self, *args)
def insert(self, *args):
“””
insert(self, iterator pos, value_type x) -> iterator
insert(self, iterator pos, size_type n, value_type x)
“””
return _almath.vectorFloat_insert(self, *args)
def reserve(self, *args):
“””reserve(self, size_type n)”””
return _almath.vectorFloat_reserve(self, *args)
def capacity(self):
“””capacity(self) -> size_type”””
return _almath.vectorFloat_capacity(self)
def __repr__(self):
“””__repr__(self) -> string”””
return _almath.vectorFloat___repr__(self)
__swig_destroy__ = _almath.delete_vectorFloat
__del__ = lambda self : None;
vectorFloat_swigregister = _almath.vectorFloat_swigregister
vectorFloat_swigregister(vectorFloat)
class vectorPosition2D(_object):
“””Proxy of C++ std::vector<(AL::Math::Position2D)> class”””
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, vectorPosition2D, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, vectorPosition2D, name)
def iterator(self):
“””iterator(self) -> SwigPyIterator”””
return _almath.vectorPosition2D_iterator(self)
def __iter__(self): return self.iterator()
def __nonzero__(self):
“””__nonzero__(self) -> bool”””
return _almath.vectorPosition2D___nonzero__(self)
def __bool__(self):
“””__bool__(self) -> bool”””
return _almath.vectorPosition2D___bool__(self)
def __len__(self):
“””__len__(self) -> size_type”””
return _almath.vectorPosition2D___len__(self)
def pop(self):
“””pop(self) -> value_type”””
return _almath.vectorPosition2D_pop(self)
def __getslice__(self, *args):
“””__getslice__(self, difference_type i, difference_type j) -> vectorPosition2D”””
return _almath.vectorPosition2D___getslice__(self, *args)
def __setslice__(self, *args):
“””__setslice__(self, difference_type i, difference_type j, vectorPosition2D v)”””
return _almath.vectorPosition2D___setslice__(self, *args)
def __delslice__(self, *args):
“””__delslice__(self, difference_type i, difference_type j)”””
return _almath.vectorPosition2D___delslice__(self, *args)
def __delitem__(self, *args):
“””
__delitem__(self, difference_type i)
__delitem__(self, PySliceObject slice)
“””
return _almath.vectorPosition2D___delitem__(self, *args)
def __getitem__(self, *args):
“””
__getitem__(self, PySliceObject slice) -> vectorPosition2D
__getitem__(self, difference_type i) -> value_type
“””
return _almath.vectorPosition2D___getitem__(self, *args)
def __setitem__(self, *args):
“””
__setitem__(self, PySliceObject slice, vectorPosition2D v)
__setitem__(self, difference_type i, value_type x)
“””
return _almath.vectorPosition2D___setitem__(self, *args)
def append(self, *args):
“””append(self, value_type x)”””
return _almath.vectorPosition2D_append(self, *args)
def empty(self):
“””empty(self) -> bool”””
return _almath.vectorPosition2D_empty(self)
def size(self):
“””size(self) -> size_type”””
return _almath.vectorPosition2D_size(self)
def clear(self):
“””clear(self)”””
return _almath.vectorPosition2D_clear(self)
def swap(self, *args):
“””swap(self, vectorPosition2D v)”””
return _almath.vectorPosition2D_swap(self, *args)
def get_allocator(self):
“””get_allocator(self) -> allocator_type”””
return _almath.vectorPosition2D_get_allocator(self)
def begin(self):
“””begin(self) -> const_iterator”””
return _almath.vectorPosition2D_begin(self)
def end(self):
“””end(self) -> const_iterator”””
return _almath.vectorPosition2D_end(self)
def rbegin(self):
“””rbegin(self) -> const_reverse_iterator”””
return _almath.vectorPosition2D_rbegin(self)
def rend(self):
“””rend(self) -> const_reverse_iterator”””
return _almath.vectorPosition2D_rend(self)
def pop_back(self):
“””pop_back(self)”””
return _almath.vectorPosition2D_pop_back(self)
def erase(self, *args):
“””
erase(self, iterator pos) -> iterator
erase(self, iterator first, iterator last) -> iterator
“””
return _almath.vectorPosition2D_erase(self, *args)
def __init__(self, *args):
“””
__init__(self) -> vectorPosition2D
__init__(self, vectorPosition2D arg0) -> vectorPosition2D
__init__(self, size_type size) -> vectorPosition2D
__init__(self, size_type size, value_type value) -> vectorPosition2D
“””
this = _almath.new_vectorPosition2D(*args)
try: self.this.append(this)
except: self.this = this
def push_back(self, *args):
“””push_back(self, value_type x)”””
return _almath.vectorPosition2D_push_back(self, *args)
def front(self):
“””front(self) -> value_type”””
return _almath.vectorPosition2D_front(self)
def back(self):
“””back(self) -> value_type”””
return _almath.vectorPosition2D_back(self)
def assign(self, *args):
“””assign(self, size_type n, value_type x)”””
return _almath.vectorPosition2D_assign(self, *args)
def resize(self, *args):
“””
resize(self, size_type new_size)
resize(self, size_type new_size, value_type x)
“””
return _almath.vectorPosition2D_resize(self, *args)
def insert(self, *args):
“””
insert(self, iterator pos, value_type x) -> iterator
insert(self, iterator pos, size_type n, value_type x)
“””
return _almath.vectorPosition2D_insert(self, *args)
def reserve(self, *args):
“””reserve(self, size_type n)”””
return _almath.vectorPosition2D_reserve(self, *args)
def capacity(self):
“””capacity(self) -> size_type”””
return _almath.vectorPosition2D_capacity(self)
def __repr__(self):
“””__repr__(self) -> string”””
return _almath.vectorPosition2D___repr__(self)
__swig_destroy__ = _almath.delete_vectorPosition2D
__del__ = lambda self : None;
vectorPosition2D_swigregister = _almath.vectorPosition2D_swigregister
vectorPosition2D_swigregister(vectorPosition2D)
class vectorPose2D(_object):
“””Proxy of C++ std::vector<(AL::Math::Pose2D)> class”””
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, vectorPose2D, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, vectorPose2D, name)
def iterator(self):
“””iterator(self) -> SwigPyIterator”””
return _almath.vectorPose2D_iterator(self)
def __iter__(self): return self.iterator()
def __nonzero__(self):
“””__nonzero__(self) -> bool”””
return _almath.vectorPose2D___nonzero__(self)
def __bool__(self):
“””__bool__(self) -> bool”””
return _almath.vectorPose2D___bool__(self)
def __len__(self):
“””__len__(self) -> size_type”””
return _almath.vectorPose2D___len__(self)
def pop(self):
“””pop(self) -> value_type”””
return _almath.vectorPose2D_pop(self)
def __getslice__(self, *args):
“””__getslice__(self, difference_type i, difference_type j) -> vectorPose2D”””
return _almath.vectorPose2D___getslice__(self, *args)
def __setslice__(self, *args):
“””__setslice__(self, difference_type i, difference_type j, vectorPose2D v)”””
return _almath.vectorPose2D___setslice__(self, *args)
def __delslice__(self, *args):
“””__delslice__(self, difference_type i, difference_type j)”””
return _almath.vectorPose2D___delslice__(self, *args)
def __delitem__(self, *args):
“””
__delitem__(self, difference_type i)
__delitem__(self, PySliceObject slice)
“””
return _almath.vectorPose2D___delitem__(self, *args)
def __getitem__(self, *args):
“””
__getitem__(self, PySliceObject slice) -> vectorPose2D
__getitem__(self, difference_type i) -> value_type
“””
return _almath.vectorPose2D___getitem__(self, *args)
def __setitem__(self, *args):
“””
__setitem__(self, PySliceObject slice, vectorPose2D v)
__setitem__(self, difference_type i, value_type x)
“””
return _almath.vectorPose2D___setitem__(self, *args)
def append(self, *args):
“””append(self, value_type x)”””
return _almath.vectorPose2D_append(self, *args)
def empty(self):
“””empty(self) -> bool”””
return _almath.vectorPose2D_empty(self)
def size(self):
“””size(self) -> size_type”””
return _almath.vectorPose2D_size(self)
def clear(self):
“””clear(self)”””
return _almath.vectorPose2D_clear(self)
def swap(self, *args):
“””swap(self, vectorPose2D v)”””
return _almath.vectorPose2D_swap(self, *args)
def get_allocator(self):
“””get_allocator(self) -> allocator_type”””
return _almath.vectorPose2D_get_allocator(self)
def begin(self):
“””begin(self) -> const_iterator”””
return _almath.vectorPose2D_begin(self)
def end(self):
“””end(self) -> const_iterator”””
return _almath.vectorPose2D_end(self)
def rbegin(self):
“””rbegin(self) -> const_reverse_iterator”””
return _almath.vectorPose2D_rbegin(self)
def rend(self):
“””rend(self) -> const_reverse_iterator”””
return _almath.vectorPose2D_rend(self)
def pop_back(self):
“””pop_back(self)”””
return _almath.vectorPose2D_pop_back(self)
def erase(self, *args):
“””
erase(self, iterator pos) -> iterator
erase(self, iterator first, iterator last) -> iterator
“””
return _almath.vectorPose2D_erase(self, *args)
def __init__(self, *args):
“””
__init__(self) -> vectorPose2D
__init__(self, vectorPose2D arg0) -> vectorPose2D
__init__(self, size_type size) -> vectorPose2D
__init__(self, size_type size, value_type value) -> vectorPose2D
“””
this = _almath.new_vectorPose2D(*args)
try: self.this.append(this)
except: self.this = this
def push_back(self, *args):
“””push_back(self, value_type x)”””
return _almath.vectorPose2D_push_back(self, *args)
def front(self):
“””front(self) -> value_type”””
return _almath.vectorPose2D_front(self)
def back(self):
“””back(self) -> value_type”””
return _almath.vectorPose2D_back(self)
def assign(self, *args):
“””assign(self, size_type n, value_type x)”””
return _almath.vectorPose2D_assign(self, *args)
def resize(self, *args):
“””
resize(self, size_type new_size)
resize(self, size_type new_size, value_type x)
“””
return _almath.vectorPose2D_resize(self, *args)
def insert(self, *args):
“””
insert(self, iterator pos, value_type x) -> iterator
insert(self, iterator pos, size_type n, value_type x)
“””
return _almath.vectorPose2D_insert(self, *args)
def reserve(self, *args):
“””reserve(self, size_type n)”””
return _almath.vectorPose2D_reserve(self, *args)
def capacity(self):
“””capacity(self) -> size_type”””
return _almath.vectorPose2D_capacity(self)
def __repr__(self):
“””__repr__(self) -> string”””
return _almath.vectorPose2D___repr__(self)
__swig_destroy__ = _almath.delete_vectorPose2D
__del__ = lambda self : None;
vectorPose2D_swigregister = _almath.vectorPose2D_swigregister
vectorPose2D_swigregister(vectorPose2D)
class vectorPosition6D(_object):
“””Proxy of C++ std::vector<(AL::Math::Position6D)> class”””
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, vectorPosition6D, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, vectorPosition6D, name)
def iterator(self):
“””iterator(self) -> SwigPyIterator”””
return _almath.vectorPosition6D_iterator(self)
def __iter__(self): return self.iterator()
def __nonzero__(self):
“””__nonzero__(self) -> bool”””
return _almath.vectorPosition6D___nonzero__(self)
def __bool__(self):
“””__bool__(self) -> bool”””
return _almath.vectorPosition6D___bool__(self)
def __len__(self):
“””__len__(self) -> size_type”””
return _almath.vectorPosition6D___len__(self)
def pop(self):
“””pop(self) -> value_type”””
return _almath.vectorPosition6D_pop(self)
def __getslice__(self, *args):
“””__getslice__(self, difference_type i, difference_type j) -> vectorPosition6D”””
return _almath.vectorPosition6D___getslice__(self, *args)
def __setslice__(self, *args):
“””__setslice__(self, difference_type i, difference_type j, vectorPosition6D v)”””
return _almath.vectorPosition6D___setslice__(self, *args)
def __delslice__(self, *args):
“””__delslice__(self, difference_type i, difference_type j)”””
return _almath.vectorPosition6D___delslice__(self, *args)
def __delitem__(self, *args):
“””
__delitem__(self, difference_type i)
__delitem__(self, PySliceObject slice)
“””
return _almath.vectorPosition6D___delitem__(self, *args)
def __getitem__(self, *args):
“””
__getitem__(self, PySliceObject slice) -> vectorPosition6D
__getitem__(self, difference_type i) -> value_type
“””
return _almath.vectorPosition6D___getitem__(self, *args)
def __setitem__(self, *args):
“””
__setitem__(self, PySliceObject slice, vectorPosition6D v)
__setitem__(self, difference_type i, value_type x)
“””
return _almath.vectorPosition6D___setitem__(self, *args)
def append(self, *args):
“””append(self, value_type x)”””
return _almath.vectorPosition6D_append(self, *args)
def empty(self):
“””empty(self) -> bool”””
return _almath.vectorPosition6D_empty(self)
def size(self):
“””size(self) -> size_type”””
return _almath.vectorPosition6D_size(self)
def clear(self):
“””clear(self)”””
return _almath.vectorPosition6D_clear(self)
def swap(self, *args):
“””swap(self, vectorPosition6D v)”””
return _almath.vectorPosition6D_swap(self, *args)
def get_allocator(self):
“””get_allocator(self) -> allocator_type”””
return _almath.vectorPosition6D_get_allocator(self)
def begin(self):
“””begin(self) -> const_iterator”””
return _almath.vectorPosition6D_begin(self)
def end(self):
“””end(self) -> const_iterator”””
return _almath.vectorPosition6D_end(self)
def rbegin(self):
“””rbegin(self) -> const_reverse_iterator”””
return _almath.vectorPosition6D_rbegin(self)
def rend(self):
“””rend(self) -> const_reverse_iterator”””
return _almath.vectorPosition6D_rend(self)
def pop_back(self):
“””pop_back(self)”””
return _almath.vectorPosition6D_pop_back(self)
def erase(self, *args):
“””
erase(self, iterator pos) -> iterator
erase(self, iterator first, iterator last) -> iterator
“””
return _almath.vectorPosition6D_erase(self, *args)
def __init__(self, *args):
“””
__init__(self) -> vectorPosition6D
__init__(self, vectorPosition6D arg0) -> vectorPosition6D
__init__(self, size_type size) -> vectorPosition6D
__init__(self, size_type size, value_type value) -> vectorPosition6D
“””
this = _almath.new_vectorPosition6D(*args)
try: self.this.append(this)
except: self.this = this
def push_back(self, *args):
“””push_back(self, value_type x)”””
return _almath.vectorPosition6D_push_back(self, *args)
def front(self):
“””front(self) -> value_type”””
return _almath.vectorPosition6D_front(self)
def back(self):
“””back(self) -> value_type”””
return _almath.vectorPosition6D_back(self)
def assign(self, *args):
“””assign(self, size_type n, value_type x)”””
return _almath.vectorPosition6D_assign(self, *args)
def resize(self, *args):
“””
resize(self, size_type new_size)
resize(self, size_type new_size, value_type x)
“””
return _almath.vectorPosition6D_resize(self, *args)
def insert(self, *args):
“””
insert(self, iterator pos, value_type x) -> iterator
insert(self, iterator pos, size_type n, value_type x)
“””
return _almath.vectorPosition6D_insert(self, *args)
def reserve(self, *args):
“””reserve(self, size_type n)”””
return _almath.vectorPosition6D_reserve(self, *args)
def capacity(self):
“””capacity(self) -> size_type”””
return _almath.vectorPosition6D_capacity(self)
def __repr__(self):
“””__repr__(self) -> string”””
return _almath.vectorPosition6D___repr__(self)
__swig_destroy__ = _almath.delete_vectorPosition6D
__del__ = lambda self : None;
vectorPosition6D_swigregister = _almath.vectorPosition6D_swigregister
vectorPosition6D_swigregister(vectorPosition6D)
class Pose2D(_object):
“””Proxy of C++ AL::Math::Pose2D class”””
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, Pose2D, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, Pose2D, name)
__swig_setmethods__[“x”] = _almath.Pose2D_x_set
__swig_getmethods__[“x”] = _almath.Pose2D_x_get
if _newclass:x = _swig_property(_almath.Pose2D_x_get, _almath.Pose2D_x_set)
__swig_setmethods__[“y”] = _almath.Pose2D_y_set
__swig_getmethods__[“y”] = _almath.Pose2D_y_get
if _newclass:y = _swig_property(_almath.Pose2D_y_get, _almath.Pose2D_y_set)
__swig_setmethods__[“theta”] = _almath.Pose2D_theta_set
__swig_getmethods__[“theta”] = _almath.Pose2D_theta_get
if _newclass:theta = _swig_property(_almath.Pose2D_theta_get, _almath.Pose2D_theta_set)
def __init__(self, *args):
“””
__init__(self) -> Pose2D
__init__(self, float pInit) -> Pose2D
__init__(self, float pX, float pY, float pTheta) -> Pose2D
__init__(self, vectorFloat pFloats) -> Pose2D
“””
this = _almath.new_Pose2D(*args)
try: self.this.append(this)
except: self.this = this
def __add__(self, *args):
“””__add__(self, Pose2D pPos2) -> Pose2D”””
return _almath.Pose2D___add__(self, *args)
def __sub__(self, *args):
“””__sub__(self, Pose2D pPos2) -> Pose2D”””
return _almath.Pose2D___sub__(self, *args)
def __pos__(self):
“””__pos__(self) -> Pose2D”””
return _almath.Pose2D___pos__(self)
def __neg__(self):
“””__neg__(self) -> Pose2D”””
return _almath.Pose2D___neg__(self)
def __iadd__(self, *args):
“””__iadd__(self, Pose2D pPos2) -> Pose2D”””
return _almath.Pose2D___iadd__(self, *args)
def __isub__(self, *args):
“””__isub__(self, Pose2D pPos2) -> Pose2D”””
return _almath.Pose2D___isub__(self, *args)
def __eq__(self, *args):
“””__eq__(self, Pose2D pPos2) -> bool”””
return _almath.Pose2D___eq__(self, *args)
def __ne__(self, *args):
“””__ne__(self, Pose2D pPos2) -> bool”””
return _almath.Pose2D___ne__(self, *args)
def __mul__(self, *args):
“””
__mul__(self, Pose2D pPos2) -> Pose2D
__mul__(self, float pVal) -> Pose2D
“””
return _almath.Pose2D___mul__(self, *args)
def __div__(self, *args):
“””__div__(self, float pVal) -> Pose2D”””
return _almath.Pose2D___div__(self, *args)
def __imul__(self, *args):
“””
__imul__(self, Pose2D pPos2) -> Pose2D
__imul__(self, float pVal) -> Pose2D
“””
return _almath.Pose2D___imul__(self, *args)
def __idiv__(self, *args):
“””__idiv__(self, float pVal) -> Pose2D”””
return _almath.Pose2D___idiv__(self, *args)
def distanceSquared(self, *args):
“””distanceSquared(self, Pose2D pPos2) -> float”””
return _almath.Pose2D_distanceSquared(self, *args)
def distance(self, *args):
“””distance(self, Pose2D pPos2) -> float”””
return _almath.Pose2D_distance(self, *args)
def inverse(self):
“””inverse(self) -> Pose2D”””
return _almath.Pose2D_inverse(self)
def isNear(self, *args):
“””
isNear(self, Pose2D pPos2, float pEpsilon = 0.0001) -> bool
isNear(self, Pose2D pPos2) -> bool
“””
return _almath.Pose2D_isNear(self, *args)
def toVector(self):
“””toVector(self) -> vectorFloat”””
return _almath.Pose2D_toVector(self)
def __repr__(self):
“””__repr__(self) -> char”””
return _almath.Pose2D___repr__(self)
def __rmul__(self, *args):
“””__rmul__(self, float lhs) -> Pose2D”””
return _almath.Pose2D___rmul__(self, *args)
__swig_destroy__ = _almath.delete_Pose2D
__del__ = lambda self : None;
Pose2D_swigregister = _almath.Pose2D_swigregister
Pose2D_swigregister(Pose2D)
cvar = _almath.cvar
AXIS_MASK_X = cvar.AXIS_MASK_X
AXIS_MASK_Y = cvar.AXIS_MASK_Y
AXIS_MASK_XY = cvar.AXIS_MASK_XY
AXIS_MASK_Z = cvar.AXIS_MASK_Z
AXIS_MASK_WX = cvar.AXIS_MASK_WX
AXIS_MASK_WY = cvar.AXIS_MASK_WY
AXIS_MASK_WZ = cvar.AXIS_MASK_WZ
AXIS_MASK_WYWZ = cvar.AXIS_MASK_WYWZ
AXIS_MASK_ALL = cvar.AXIS_MASK_ALL
AXIS_MASK_VEL = cvar.AXIS_MASK_VEL
AXIS_MASK_ROT = cvar.AXIS_MASK_ROT
AXIS_MASK_NONE = cvar.AXIS_MASK_NONE
class Position2D(_object):
“””Proxy of C++ AL::Math::Position2D class”””
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, Position2D, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, Position2D, name)
__swig_setmethods__[“x”] = _almath.Position2D_x_set
__swig_getmethods__[“x”] = _almath.Position2D_x_get
if _newclass:x = _swig_property(_almath.Position2D_x_get, _almath.Position2D_x_set)
__swig_setmethods__[“y”] = _almath.Position2D_y_set
__swig_getmethods__[“y”] = _almath.Position2D_y_get
if _newclass:y = _swig_property(_almath.Position2D_y_get, _almath.Position2D_y_set)
def __init__(self, *args):
“””
__init__(self) -> Position2D
__init__(self, float pInit) -> Position2D
__init__(self, float pX, float pY) -> Position2D
__init__(self, vectorFloat pFloats) -> Position2D
“””
this = _almath.new_Position2D(*args)
try: self.this.append(this)
except: self.this = this
def __add__(self, *args):
“””__add__(self, Position2D pPos2) -> Position2D”””
return _almath.Position2D___add__(self, *args)
def __sub__(self, *args):
“””__sub__(self, Position2D pPos2) -> Position2D”””
return _almath.Position2D___sub__(self, *args)
def __pos__(self):
“””__pos__(self) -> Position2D”””
return _almath.Position2D___pos__(self)
def __neg__(self):
“””__neg__(self) -> Position2D”””
return _almath.Position2D___neg__(self)
def __iadd__(self, *args):
“””__iadd__(self, Position2D pPos2) -> Position2D”””
return _almath.Position2D___iadd__(self, *args)
def __isub__(self, *args):
“””__isub__(self, Position2D pPos2) -> Position2D”””
return _almath.Position2D___isub__(self, *args)
def __eq__(self, *args):
“””__eq__(self, Position2D pPos2) -> bool”””
return _almath.Position2D___eq__(self, *args)
def __ne__(self, *args):
“””__ne__(self, Position2D pPos2) -> bool”””
return _almath.Position2D___ne__(self, *args)
def __mul__(self, *args):
“””__mul__(self, float pVal) -> Position2D”””
return _almath.Position2D___mul__(self, *args)
def __div__(self, *args):
“””__div__(self, float pVal) -> Position2D”””
return _almath.Position2D___div__(self, *args)
def __imul__(self, *args):
“””__imul__(self, float pVal) -> Position2D”””
return _almath.Position2D___imul__(self, *args)
def __idiv__(self, *args):
“””__idiv__(self, float pVal) -> Position2D”””
return _almath.Position2D___idiv__(self, *args)
def distanceSquared(self, *args):
“””distanceSquared(self, Position2D pPos2) -> float”””
return _almath.Position2D_distanceSquared(self, *args)
def distance(self, *args):
“””distance(self, Position2D pPos2) -> float”””
return _almath.Position2D_distance(self, *args)
def isNear(self, *args):
“””
isNear(self, Position2D pPos2, float pEpsilon = 0.0001) -> bool
isNear(self, Position2D pPos2) -> bool
“””
return _almath.Position2D_isNear(self, *args)
def norm(self):
“””norm(self) -> float”””
return _almath.Position2D_norm(self)
def normalize(self):
“””normalize(self) -> Position2D”””
return _almath.Position2D_normalize(self)
def crossProduct(self, *args):
“””crossProduct(self, Position2D pPos2) -> float”””
return _almath.Position2D_crossProduct(self, *args)
def toVector(self):
“””toVector(self) -> vectorFloat”””
return _almath.Position2D_toVector(self)
def __repr__(self):
“””__repr__(self) -> char”””
return _almath.Position2D___repr__(self)
def __rmul__(self, *args):
“””__rmul__(self, float lhs) -> Position2D”””
return _almath.Position2D___rmul__(self, *args)
__swig_destroy__ = _almath.delete_Position2D
__del__ = lambda self : None;
Position2D_swigregister = _almath.Position2D_swigregister
Position2D_swigregister(Position2D)
def pose2DInverse(*args):
“””
pose2DInverse(Pose2D pPos) -> Pose2D
pose2DInverse(Pose2D pPos, Pose2D pRes)
“””
return _almath.pose2DInverse(*args)
class Position3D(_object):
“””Proxy of C++ AL::Math::Position3D class”””
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, Position3D, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, Position3D, name)
__swig_setmethods__[“x”] = _almath.Position3D_x_set
__swig_getmethods__[“x”] = _almath.Position3D_x_get
if _newclass:x = _swig_property(_almath.Position3D_x_get, _almath.Position3D_x_set)
__swig_setmethods__[“y”] = _almath.Position3D_y_set
__swig_getmethods__[“y”] = _almath.Position3D_y_get
if _newclass:y = _swig_property(_almath.Position3D_y_get, _almath.Position3D_y_set)
__swig_setmethods__[“z”] = _almath.Position3D_z_set
__swig_getmethods__[“z”] = _almath.Position3D_z_get
if _newclass:z = _swig_property(_almath.Position3D_z_get, _almath.Position3D_z_set)
def __init__(self, *args):
“””
__init__(self) -> Position3D
__init__(self, float pInit) -> Position3D
__init__(self, float pX, float pY, float pZ) -> Position3D
__init__(self, vectorFloat pFloats) -> Position3D
“””
this = _almath.new_Position3D(*args)
try: self.this.append(this)
except: self.this = this
def __add__(self, *args):
“””__add__(self, Position3D pPos2) -> Position3D”””
return _almath.Position3D___add__(self, *args)
def __sub__(self, *args):
“””__sub__(self, Position3D pPos2) -> Position3D”””
return _almath.Position3D___sub__(self, *args)
def __pos__(self):
“””__pos__(self) -> Position3D”””
return _almath.Position3D___pos__(self)
def __neg__(self):
“””__neg__(self) -> Position3D”””
return _almath.Position3D___neg__(self)
def __iadd__(self, *args):
“””__iadd__(self, Position3D pPos2) -> Position3D”””
return _almath.Position3D___iadd__(self, *args)
def __isub__(self, *args):
“””__isub__(self, Position3D pPos2) -> Position3D”””
return _almath.Position3D___isub__(self, *args)
def __eq__(self, *args):
“””__eq__(self, Position3D pPos2) -> bool”””
return _almath.Position3D___eq__(self, *args)
def __ne__(self, *args):
“””__ne__(self, Position3D pPos2) -> bool”””
return _almath.Position3D___ne__(self, *args)
def __mul__(self, *args):
“””__mul__(self, float pVal) -> Position3D”””
return _almath.Position3D___mul__(self, *args)
def __div__(self, *args):
“””__div__(self, float pVal) -> Position3D”””
return _almath.Position3D___div__(self, *args)
def __imul__(self, *args):
“””__imul__(self, float pVal) -> Position3D”””
return _almath.Position3D___imul__(self, *args)
def __idiv__(self, *args):
“””__idiv__(self, float pVal) -> Position3D”””
return _almath.Position3D___idiv__(self, *args)
def distanceSquared(self, *args):
“””distanceSquared(self, Position3D pPos2) -> float”””
return _almath.Position3D_distanceSquared(self, *args)
def distance(self, *args):
“””distance(self, Position3D pPos2) -> float”””
return _almath.Position3D_distance(self, *args)
def isNear(self, *args):
“””
isNear(self, Position3D pPos2, float pEpsilon = 0.0001) -> bool
isNear(self, Position3D pPos2) -> bool
“””
return _almath.Position3D_isNear(self, *args)
def norm(self):
“””norm(self) -> float”””
return _almath.Position3D_norm(self)
def normalize(self):
“””normalize(self) -> Position3D”””
return _almath.Position3D_normalize(self)
def dotProduct(self, *args):
“””dotProduct(self, Position3D pPos2) -> float”””
return _almath.Position3D_dotProduct(self, *args)
def crossProduct(self, *args):
“””crossProduct(self, Position3D pPos2) -> Position3D”””
return _almath.Position3D_crossProduct(self, *args)
def toVector(self):
“””toVector(self) -> vectorFloat”””
return _almath.Position3D_toVector(self)
def __repr__(self):
“””__repr__(self) -> char”””
return _almath.Position3D___repr__(self)
def __rmul__(self, *args):
“””__rmul__(self, float lhs) -> Position3D”””
return _almath.Position3D___rmul__(self, *args)
__swig_destroy__ = _almath.delete_Position3D
__del__ = lambda self : None;
Position3D_swigregister = _almath.Position3D_swigregister
Position3D_swigregister(Position3D)

def __div__(*args):
“””__div__(float pM, Position3D pPos1) -> Position3D”””
return _almath.__div__(*args)
def dotProduct(*args):
“””dotProduct(Position3D pPos1, Position3D pPos2) -> float”””
return _almath.dotProduct(*args)
class Position6D(_object):
“””Proxy of C++ AL::Math::Position6D class”””
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, Position6D, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, Position6D, name)
__swig_setmethods__[“x”] = _almath.Position6D_x_set
__swig_getmethods__[“x”] = _almath.Position6D_x_get
if _newclass:x = _swig_property(_almath.Position6D_x_get, _almath.Position6D_x_set)
__swig_setmethods__[“y”] = _almath.Position6D_y_set
__swig_getmethods__[“y”] = _almath.Position6D_y_get
if _newclass:y = _swig_property(_almath.Position6D_y_get, _almath.Position6D_y_set)
__swig_setmethods__[“z”] = _almath.Position6D_z_set
__swig_getmethods__[“z”] = _almath.Position6D_z_get
if _newclass:z = _swig_property(_almath.Position6D_z_get, _almath.Position6D_z_set)
__swig_setmethods__[“wx”] = _almath.Position6D_wx_set
__swig_getmethods__[“wx”] = _almath.Position6D_wx_get
if _newclass:wx = _swig_property(_almath.Position6D_wx_get, _almath.Position6D_wx_set)
__swig_setmethods__[“wy”] = _almath.Position6D_wy_set
__swig_getmethods__[“wy”] = _almath.Position6D_wy_get
if _newclass:wy = _swig_property(_almath.Position6D_wy_get, _almath.Position6D_wy_set)
__swig_setmethods__[“wz”] = _almath.Position6D_wz_set
__swig_getmethods__[“wz”] = _almath.Position6D_wz_get
if _newclass:wz = _swig_property(_almath.Position6D_wz_get, _almath.Position6D_wz_set)
def __init__(self, *args):
“””
__init__(self) -> Position6D
__init__(self, float pInit) -> Position6D
__init__(self, float pX, float pY, float pZ, float pWx, float pWy,
float pWz) -> Position6D
__init__(self, vectorFloat pFloats) -> Position6D
“””
this = _almath.new_Position6D(*args)
try: self.this.append(this)
except: self.this = this
def __add__(self, *args):
“””__add__(self, Position6D pPos2) -> Position6D”””
return _almath.Position6D___add__(self, *args)
def __sub__(self, *args):
“””__sub__(self, Position6D pPos2) -> Position6D”””
return _almath.Position6D___sub__(self, *args)
def __pos__(self):
“””__pos__(self) -> Position6D”””
return _almath.Position6D___pos__(self)
def __neg__(self):
“””__neg__(self) -> Position6D”””
return _almath.Position6D___neg__(self)
def __iadd__(self, *args):
“””__iadd__(self, Position6D pPos2) -> Position6D”””
return _almath.Position6D___iadd__(self, *args)
def __isub__(self, *args):
“””__isub__(self, Position6D pPos2) -> Position6D”””
return _almath.Position6D___isub__(self, *args)
def __eq__(self, *args):
“””__eq__(self, Position6D pPos2) -> bool”””
return _almath.Position6D___eq__(self, *args)
def __ne__(self, *args):
“””__ne__(self, Position6D pPos2) -> bool”””
return _almath.Position6D___ne__(self, *args)
def __mul__(self, *args):
“””__mul__(self, float pVal) -> Position6D”””
return _almath.Position6D___mul__(self, *args)
def __div__(self, *args):
“””__div__(self, float pVal) -> Position6D”””
return _almath.Position6D___div__(self, *args)
def __imul__(self, *args):
“””__imul__(self, float pVal) -> Position6D”””
return _almath.Position6D___imul__(self, *args)
def __idiv__(self, *args):
“””__idiv__(self, float pVal) -> Position6D”””
return _almath.Position6D___idiv__(self, *args)
def isNear(self, *args):
“””
isNear(self, Position6D pPos2, float pEpsilon = 0.0001) -> bool
isNear(self, Position6D pPos2) -> bool
“””
return _almath.Position6D_isNear(self, *args)
def distanceSquared(self, *args):
“””distanceSquared(self, Position6D pPos2) -> float”””
return _almath.Position6D_distanceSquared(self, *args)
def distance(self, *args):
“””distance(self, Position6D pPos2) -> float”””
return _almath.Position6D_distance(self, *args)
def norm(self):
“””norm(self) -> float”””
return _almath.Position6D_norm(self)
def toVector(self):
“””toVector(self) -> vectorFloat”””
return _almath.Position6D_toVector(self)
def __repr__(self):
“””__repr__(self) -> char”””
return _almath.Position6D___repr__(self)
def __rmul__(self, *args):
“””__rmul__(self, float lhs) -> Position6D”””
return _almath.Position6D___rmul__(self, *args)
__swig_destroy__ = _almath.delete_Position6D
__del__ = lambda self : None;
Position6D_swigregister = _almath.Position6D_swigregister
Position6D_swigregister(Position6D)
def crossProduct(*args):
“””
crossProduct(Position2D pPos1, Position2D pPos2) -> float
crossProduct(Position2D pPos1, Position2D pPos2, float pRes)
crossProduct(Position3D pPos1, Position3D pPos2) -> Position3D
crossProduct(Position3D pPos1, Position3D pPos2, Position3D pRes)
“””
return _almath.crossProduct(*args)
class PositionAndVelocity(_object):
“””Proxy of C++ AL::Math::PositionAndVelocity class”””
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, PositionAndVelocity, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, PositionAndVelocity, name)
__swig_setmethods__[“q”] = _almath.PositionAndVelocity_q_set
__swig_getmethods__[“q”] = _almath.PositionAndVelocity_q_get
if _newclass:q = _swig_property(_almath.PositionAndVelocity_q_get, _almath.PositionAndVelocity_q_set)
__swig_setmethods__[“dq”] = _almath.PositionAndVelocity_dq_set
__swig_getmethods__[“dq”] = _almath.PositionAndVelocity_dq_get
if _newclass:dq = _swig_property(_almath.PositionAndVelocity_dq_get, _almath.PositionAndVelocity_dq_set)
def __init__(self, pq = 0.0, pdq = 0.0):
“””
__init__(self, float pq = 0.0, float pdq = 0.0) -> PositionAndVelocity
__init__(self, float pq = 0.0) -> PositionAndVelocity
__init__(self) -> PositionAndVelocity
“””
this = _almath.new_PositionAndVelocity(pq, pdq)
try: self.this.append(this)
except: self.this = this
def isNear(self, *args):
“””
isNear(self, PositionAndVelocity pDat2, float pEpsilon = 0.0001) -> bool
isNear(self, PositionAndVelocity pDat2) -> bool
“””
return _almath.PositionAndVelocity_isNear(self, *args)
def __repr__(self):
“””__repr__(self) -> char”””
return _almath.PositionAndVelocity___repr__(self)
__swig_destroy__ = _almath.delete_PositionAndVelocity
__del__ = lambda self : None;
PositionAndVelocity_swigregister = _almath.PositionAndVelocity_swigregister
PositionAndVelocity_swigregister(PositionAndVelocity)
def distanceSquared(*args):
“””
distanceSquared(Pose2D pPos1, Pose2D pPos2) -> float
distanceSquared(Position2D pPos1, Position2D pPos2) -> float
distanceSquared(Position3D pPos1, Position3D pPos2) -> float
distanceSquared(Position6D pPos1, Position6D pPos2) -> float
“””
return _almath.distanceSquared(*args)
def distance(*args):
“””
distance(Pose2D pPos1, Pose2D pPos2) -> float
distance(Position2D pPos1, Position2D pPos2) -> float
distance(Position3D pPos1, Position3D pPos2) -> float
distance(Position6D pPos1, Position6D pPos2) -> float
“””
return _almath.distance(*args)
class Quaternion(_object):
“””Proxy of C++ AL::Math::Quaternion class”””
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, Quaternion, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, Quaternion, name)
__swig_setmethods__[“w”] = _almath.Quaternion_w_set
__swig_getmethods__[“w”] = _almath.Quaternion_w_get
if _newclass:w = _swig_property(_almath.Quaternion_w_get, _almath.Quaternion_w_set)
__swig_setmethods__[“x”] = _almath.Quaternion_x_set
__swig_getmethods__[“x”] = _almath.Quaternion_x_get
if _newclass:x = _swig_property(_almath.Quaternion_x_get, _almath.Quaternion_x_set)
__swig_setmethods__[“y”] = _almath.Quaternion_y_set
__swig_getmethods__[“y”] = _almath.Quaternion_y_get
if _newclass:y = _swig_property(_almath.Quaternion_y_get, _almath.Quaternion_y_set)
__swig_setmethods__[“z”] = _almath.Quaternion_z_set
__swig_getmethods__[“z”] = _almath.Quaternion_z_get
if _newclass:z = _swig_property(_almath.Quaternion_z_get, _almath.Quaternion_z_set)
def __init__(self, *args):
“””
__init__(self) -> Quaternion
__init__(self, float pW, float pX, float pY, float pZ) -> Quaternion
__init__(self, vectorFloat pFloats) -> Quaternion
“””
this = _almath.new_Quaternion(*args)
try: self.this.append(this)
except: self.this = this
def __mul__(self, *args):
“””__mul__(self, Quaternion pQua2) -> Quaternion”””
return _almath.Quaternion___mul__(self, *args)
def __eq__(self, *args):
“””__eq__(self, Quaternion pQua2) -> bool”””
return _almath.Quaternion___eq__(self, *args)
def __ne__(self, *args):
“””__ne__(self, Quaternion pQua2) -> bool”””
return _almath.Quaternion___ne__(self, *args)
def __imul__(self, *args):
“””
__imul__(self, Quaternion pQu2) -> Quaternion
__imul__(self, float pVal) -> Quaternion
“””
return _almath.Quaternion___imul__(self, *args)
def __idiv__(self, *args):
“””__idiv__(self, float pVal) -> Quaternion”””
return _almath.Quaternion___idiv__(self, *args)
def isNear(self, *args):
“””
isNear(self, Quaternion pQua2, float pEpsilon = 0.0001) -> bool
isNear(self, Quaternion pQua2) -> bool
“””
return _almath.Quaternion_isNear(self, *args)
def norm(self):
“””norm(self) -> float”””
return _almath.Quaternion_norm(self)
def normalize(self):
“””normalize(self) -> Quaternion”””
return _almath.Quaternion_normalize(self)
def inverse(self):
“””inverse(self) -> Quaternion”””
return _almath.Quaternion_inverse(self)
def fromAngleAndAxisRotation(*args):
“””fromAngleAndAxisRotation(float pAngle, float pAxisX, float pAxisY, float pAxisZ) -> Quaternion”””
return _almath.Quaternion_fromAngleAndAxisRotation(*args)
if _newclass:fromAngleAndAxisRotation = staticmethod(fromAngleAndAxisRotation)
__swig_getmethods__[“fromAngleAndAxisRotation”] = lambda x: fromAngleAndAxisRotation
def toVector(self):
“””toVector(self) -> vectorFloat”””
return _almath.Quaternion_toVector(self)
def __repr__(self):
“””__repr__(self) -> char”””
return _almath.Quaternion___repr__(self)
__swig_destroy__ = _almath.delete_Quaternion
__del__ = lambda self : None;
Quaternion_swigregister = _almath.Quaternion_swigregister
Quaternion_swigregister(Quaternion)
def Quaternion_fromAngleAndAxisRotation(*args):
“””Quaternion_fromAngleAndAxisRotation(float pAngle, float pAxisX, float pAxisY, float pAxisZ) -> Quaternion”””
return _almath.Quaternion_fromAngleAndAxisRotation(*args)

def quaternionFromAngleAndAxisRotation(*args):
“””quaternionFromAngleAndAxisRotation(float pAngle, float pAxisX, float pAxisY, float pAxisZ) -> Quaternion”””
return _almath.quaternionFromAngleAndAxisRotation(*args)
def angleAndAxisRotationFromQuaternion(*args):
“””
angleAndAxisRotationFromQuaternion(Quaternion pQuaternion, float pAngle, float pAxisX,
float pAxisY, float pAxisZ)
“””
return _almath.angleAndAxisRotationFromQuaternion(*args)
class Rotation(_object):
“””Proxy of C++ AL::Math::Rotation class”””
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, Rotation, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, Rotation, name)
__swig_setmethods__[“r1_c1”] = _almath.Rotation_r1_c1_set
__swig_getmethods__[“r1_c1”] = _almath.Rotation_r1_c1_get
if _newclass:r1_c1 = _swig_property(_almath.Rotation_r1_c1_get, _almath.Rotation_r1_c1_set)
__swig_setmethods__[“r1_c2”] = _almath.Rotation_r1_c2_set
__swig_getmethods__[“r1_c2”] = _almath.Rotation_r1_c2_get
if _newclass:r1_c2 = _swig_property(_almath.Rotation_r1_c2_get, _almath.Rotation_r1_c2_set)
__swig_setmethods__[“r1_c3”] = _almath.Rotation_r1_c3_set
__swig_getmethods__[“r1_c3”] = _almath.Rotation_r1_c3_get
if _newclass:r1_c3 = _swig_property(_almath.Rotation_r1_c3_get, _almath.Rotation_r1_c3_set)
__swig_setmethods__[“r2_c1”] = _almath.Rotation_r2_c1_set
__swig_getmethods__[“r2_c1”] = _almath.Rotation_r2_c1_get
if _newclass:r2_c1 = _swig_property(_almath.Rotation_r2_c1_get, _almath.Rotation_r2_c1_set)
__swig_setmethods__[“r2_c2”] = _almath.Rotation_r2_c2_set
__swig_getmethods__[“r2_c2”] = _almath.Rotation_r2_c2_get
if _newclass:r2_c2 = _swig_property(_almath.Rotation_r2_c2_get, _almath.Rotation_r2_c2_set)
__swig_setmethods__[“r2_c3”] = _almath.Rotation_r2_c3_set
__swig_getmethods__[“r2_c3”] = _almath.Rotation_r2_c3_get
if _newclass:r2_c3 = _swig_property(_almath.Rotation_r2_c3_get, _almath.Rotation_r2_c3_set)
__swig_setmethods__[“r3_c1”] = _almath.Rotation_r3_c1_set
__swig_getmethods__[“r3_c1”] = _almath.Rotation_r3_c1_get
if _newclass:r3_c1 = _swig_property(_almath.Rotation_r3_c1_get, _almath.Rotation_r3_c1_set)
__swig_setmethods__[“r3_c2”] = _almath.Rotation_r3_c2_set
__swig_getmethods__[“r3_c2”] = _almath.Rotation_r3_c2_get
if _newclass:r3_c2 = _swig_property(_almath.Rotation_r3_c2_get, _almath.Rotation_r3_c2_set)
__swig_setmethods__[“r3_c3”] = _almath.Rotation_r3_c3_set
__swig_getmethods__[“r3_c3”] = _almath.Rotation_r3_c3_get
if _newclass:r3_c3 = _swig_property(_almath.Rotation_r3_c3_get, _almath.Rotation_r3_c3_set)
def __init__(self, *args):
“””
__init__(self) -> Rotation
__init__(self, vectorFloat pFloats) -> Rotation
“””
this = _almath.new_Rotation(*args)
try: self.this.append(this)
except: self.this = this
def __imul__(self, *args):
“””__imul__(self, Rotation pRot2) -> Rotation”””
return _almath.Rotation___imul__(self, *args)
def __eq__(self, *args):
“””__eq__(self, Rotation pRot2) -> bool”””
return _almath.Rotation___eq__(self, *args)
def __ne__(self, *args):
“””__ne__(self, Rotation pRot2) -> bool”””
return _almath.Rotation___ne__(self, *args)
def isNear(self, *args):
“””
isNear(self, Rotation pRot2, float pEpsilon = 0.0001) -> bool
isNear(self, Rotation pRot2) -> bool
“””
return _almath.Rotation_isNear(self, *args)
def transpose(self):
“””transpose(self) -> Rotation”””
return _almath.Rotation_transpose(self)
def determinant(self):
“””determinant(self) -> float”””
return _almath.Rotation_determinant(self)
def fromQuaternion(*args):
“””fromQuaternion(float pA, float pB, float pC, float pD) -> Rotation”””
return _almath.Rotation_fromQuaternion(*args)
if _newclass:fromQuaternion = staticmethod(fromQuaternion)
__swig_getmethods__[“fromQuaternion”] = lambda x: fromQuaternion
def fromAngleDirection(*args):
“””fromAngleDirection(float pAngle, float pX, float pY, float pZ) -> Rotation”””
return _almath.Rotation_fromAngleDirection(*args)
if _newclass:fromAngleDirection = staticmethod(fromAngleDirection)
__swig_getmethods__[“fromAngleDirection”] = lambda x: fromAngleDirection
def fromRotX(*args):
“””fromRotX(float pRotX) -> Rotation”””
return _almath.Rotation_fromRotX(*args)
if _newclass:fromRotX = staticmethod(fromRotX)
__swig_getmethods__[“fromRotX”] = lambda x: fromRotX
def fromRotY(*args):
“””fromRotY(float pRotY) -> Rotation”””
return _almath.Rotation_fromRotY(*args)
if _newclass:fromRotY = staticmethod(fromRotY)
__swig_getmethods__[“fromRotY”] = lambda x: fromRotY
def fromRotZ(*args):
“””fromRotZ(float pRotZ) -> Rotation”””
return _almath.Rotation_fromRotZ(*args)
if _newclass:fromRotZ = staticmethod(fromRotZ)
__swig_getmethods__[“fromRotZ”] = lambda x: fromRotZ
def from3DRotation(*args):
“””from3DRotation(float pWX, float pWY, float pWZ) -> Rotation”””
return _almath.Rotation_from3DRotation(*args)
if _newclass:from3DRotation = staticmethod(from3DRotation)
__swig_getmethods__[“from3DRotation”] = lambda x: from3DRotation
def toVector(self):
“””toVector(self) -> vectorFloat”””
return _almath.Rotation_toVector(self)
def __str__(self):
“””__str__(self) -> char”””
return _almath.Rotation___str__(self)
def __repr__(self):
“””__repr__(self) -> char”””
return _almath.Rotation___repr__(self)
def __mul__(self, *args):
“””
__mul__(self, Rotation pRot2) -> Rotation
__mul__(self, Position3D rhs) -> Position3D
“””
return _almath.Rotation___mul__(self, *args)
__swig_destroy__ = _almath.delete_Rotation
__del__ = lambda self : None;
Rotation_swigregister = _almath.Rotation_swigregister
Rotation_swigregister(Rotation)
def quaternionInverse(*args):
“””
quaternionInverse(Quaternion pQua, Quaternion pQuaOut)
quaternionInverse(Quaternion pQua) -> Quaternion
“””
return _almath.quaternionInverse(*args)
def Rotation_fromQuaternion(*args):
“””Rotation_fromQuaternion(float pA, float pB, float pC, float pD) -> Rotation”””
return _almath.Rotation_fromQuaternion(*args)
def Rotation_fromAngleDirection(*args):
“””Rotation_fromAngleDirection(float pAngle, float pX, float pY, float pZ) -> Rotation”””
return _almath.Rotation_fromAngleDirection(*args)
def Rotation_fromRotX(*args):
“””Rotation_fromRotX(float pRotX) -> Rotation”””
return _almath.Rotation_fromRotX(*args)
def Rotation_fromRotY(*args):
“””Rotation_fromRotY(float pRotY) -> Rotation”””
return _almath.Rotation_fromRotY(*args)
def Rotation_fromRotZ(*args):
“””Rotation_fromRotZ(float pRotZ) -> Rotation”””
return _almath.Rotation_fromRotZ(*args)
def Rotation_from3DRotation(*args):
“””Rotation_from3DRotation(float pWX, float pWY, float pWZ) -> Rotation”””
return _almath.Rotation_from3DRotation(*args)

def transpose(*args):
“””transpose(Rotation pRot) -> Rotation”””
return _almath.transpose(*args)
def rotationFromQuaternion(*args):
“””rotationFromQuaternion(float pA, float pB, float pC, float pD) -> Rotation”””
return _almath.rotationFromQuaternion(*args)
def applyRotation(*args):
“””applyRotation(Rotation pRot, float pX, float pY, float pZ)”””
return _almath.applyRotation(*args)
def rotationFromRotX(*args):
“””rotationFromRotX(float pRotX) -> Rotation”””
return _almath.rotationFromRotX(*args)
def rotationFromRotY(*args):
“””rotationFromRotY(float pRotY) -> Rotation”””
return _almath.rotationFromRotY(*args)
def rotationFromRotZ(*args):
“””rotationFromRotZ(float pRotZ) -> Rotation”””
return _almath.rotationFromRotZ(*args)
def rotationFrom3DRotation(*args):
“””rotationFrom3DRotation(float pWX, float pWY, float pWZ) -> Rotation”””
return _almath.rotationFrom3DRotation(*args)
class Rotation3D(_object):
“””Proxy of C++ AL::Math::Rotation3D class”””
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, Rotation3D, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, Rotation3D, name)
__swig_setmethods__[“wx”] = _almath.Rotation3D_wx_set
__swig_getmethods__[“wx”] = _almath.Rotation3D_wx_get
if _newclass:wx = _swig_property(_almath.Rotation3D_wx_get, _almath.Rotation3D_wx_set)
__swig_setmethods__[“wy”] = _almath.Rotation3D_wy_set
__swig_getmethods__[“wy”] = _almath.Rotation3D_wy_get
if _newclass:wy = _swig_property(_almath.Rotation3D_wy_get, _almath.Rotation3D_wy_set)
__swig_setmethods__[“wz”] = _almath.Rotation3D_wz_set
__swig_getmethods__[“wz”] = _almath.Rotation3D_wz_get
if _newclass:wz = _swig_property(_almath.Rotation3D_wz_get, _almath.Rotation3D_wz_set)
def __init__(self, *args):
“””
__init__(self) -> Rotation3D
__init__(self, float pInit) -> Rotation3D
__init__(self, float pWx, float pWy, float pWz) -> Rotation3D
__init__(self, vectorFloat pFloats) -> Rotation3D
“””
this = _almath.new_Rotation3D(*args)
try: self.this.append(this)
except: self.this = this
def __add__(self, *args):
“””__add__(self, Rotation3D pRot2) -> Rotation3D”””
return _almath.Rotation3D___add__(self, *args)
def __sub__(self, *args):
“””__sub__(self, Rotation3D pRot2) -> Rotation3D”””
return _almath.Rotation3D___sub__(self, *args)
def __iadd__(self, *args):
“””__iadd__(self, Rotation3D pRot2) -> Rotation3D”””
return _almath.Rotation3D___iadd__(self, *args)
def __isub__(self, *args):
“””__isub__(self, Rotation3D pRot2) -> Rotation3D”””
return _almath.Rotation3D___isub__(self, *args)
def __eq__(self, *args):
“””__eq__(self, Rotation3D pRot2) -> bool”””
return _almath.Rotation3D___eq__(self, *args)
def __ne__(self, *args):
“””__ne__(self, Rotation3D pRot2) -> bool”””
return _almath.Rotation3D___ne__(self, *args)
def __mul__(self, *args):
“””__mul__(self, float pVal) -> Rotation3D”””
return _almath.Rotation3D___mul__(self, *args)
def __div__(self, *args):
“””__div__(self, float pVal) -> Rotation3D”””
return _almath.Rotation3D___div__(self, *args)
def __imul__(self, *args):
“””__imul__(self, float pVal) -> Rotation3D”””
return _almath.Rotation3D___imul__(self, *args)
def __idiv__(self, *args):
“””__idiv__(self, float pVal) -> Rotation3D”””
return _almath.Rotation3D___idiv__(self, *args)
def isNear(self, *args):
“””
isNear(self, Rotation3D pRot2, float pEpsilon = 0.0001) -> bool
isNear(self, Rotation3D pRot2) -> bool
“””
return _almath.Rotation3D_isNear(self, *args)
def norm(self):
“””norm(self) -> float”””
return _almath.Rotation3D_norm(self)
def toVector(self):
“””toVector(self) -> vectorFloat”””
return _almath.Rotation3D_toVector(self)
def __repr__(self):
“””__repr__(self) -> char”””
return _almath.Rotation3D___repr__(self)
__swig_destroy__ = _almath.delete_Rotation3D
__del__ = lambda self : None;
Rotation3D_swigregister = _almath.Rotation3D_swigregister
Rotation3D_swigregister(Rotation3D)
class Transform(_object):
“””Proxy of C++ AL::Math::Transform class”””
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, Transform, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, Transform, name)
__swig_setmethods__[“r1_c1”] = _almath.Transform_r1_c1_set
__swig_getmethods__[“r1_c1”] = _almath.Transform_r1_c1_get
if _newclass:r1_c1 = _swig_property(_almath.Transform_r1_c1_get, _almath.Transform_r1_c1_set)
__swig_setmethods__[“r1_c2”] = _almath.Transform_r1_c2_set
__swig_getmethods__[“r1_c2”] = _almath.Transform_r1_c2_get
if _newclass:r1_c2 = _swig_property(_almath.Transform_r1_c2_get, _almath.Transform_r1_c2_set)
__swig_setmethods__[“r1_c3”] = _almath.Transform_r1_c3_set
__swig_getmethods__[“r1_c3”] = _almath.Transform_r1_c3_get
if _newclass:r1_c3 = _swig_property(_almath.Transform_r1_c3_get, _almath.Transform_r1_c3_set)
__swig_setmethods__[“r1_c4”] = _almath.Transform_r1_c4_set
__swig_getmethods__[“r1_c4”] = _almath.Transform_r1_c4_get
if _newclass:r1_c4 = _swig_property(_almath.Transform_r1_c4_get, _almath.Transform_r1_c4_set)
__swig_setmethods__[“r2_c1”] = _almath.Transform_r2_c1_set
__swig_getmethods__[“r2_c1”] = _almath.Transform_r2_c1_get
if _newclass:r2_c1 = _swig_property(_almath.Transform_r2_c1_get, _almath.Transform_r2_c1_set)
__swig_setmethods__[“r2_c2”] = _almath.Transform_r2_c2_set
__swig_getmethods__[“r2_c2”] = _almath.Transform_r2_c2_get
if _newclass:r2_c2 = _swig_property(_almath.Transform_r2_c2_get, _almath.Transform_r2_c2_set)
__swig_setmethods__[“r2_c3”] = _almath.Transform_r2_c3_set
__swig_getmethods__[“r2_c3”] = _almath.Transform_r2_c3_get
if _newclass:r2_c3 = _swig_property(_almath.Transform_r2_c3_get, _almath.Transform_r2_c3_set)
__swig_setmethods__[“r2_c4”] = _almath.Transform_r2_c4_set
__swig_getmethods__[“r2_c4”] = _almath.Transform_r2_c4_get
if _newclass:r2_c4 = _swig_property(_almath.Transform_r2_c4_get, _almath.Transform_r2_c4_set)
__swig_setmethods__[“r3_c1”] = _almath.Transform_r3_c1_set
__swig_getmethods__[“r3_c1”] = _almath.Transform_r3_c1_get
if _newclass:r3_c1 = _swig_property(_almath.Transform_r3_c1_get, _almath.Transform_r3_c1_set)
__swig_setmethods__[“r3_c2”] = _almath.Transform_r3_c2_set
__swig_getmethods__[“r3_c2”] = _almath.Transform_r3_c2_get
if _newclass:r3_c2 = _swig_property(_almath.Transform_r3_c2_get, _almath.Transform_r3_c2_set)
__swig_setmethods__[“r3_c3”] = _almath.Transform_r3_c3_set
__swig_getmethods__[“r3_c3”] = _almath.Transform_r3_c3_get
if _newclass:r3_c3 = _swig_property(_almath.Transform_r3_c3_get, _almath.Transform_r3_c3_set)
__swig_setmethods__[“r3_c4”] = _almath.Transform_r3_c4_set
__swig_getmethods__[“r3_c4”] = _almath.Transform_r3_c4_get
if _newclass:r3_c4 = _swig_property(_almath.Transform_r3_c4_get, _almath.Transform_r3_c4_set)
def __init__(self, *args):
“””
__init__(self) -> Transform
__init__(self, vectorFloat pFloats) -> Transform
__init__(self, float pPosX, float pPosY, float pPosZ) -> Transform
“””
this = _almath.new_Transform(*args)
try: self.this.append(this)
except: self.this = this
def __imul__(self, *args):
“””__imul__(self, Transform pT2) -> Transform”””
return _almath.Transform___imul__(self, *args)
def __eq__(self, *args):
“””__eq__(self, Transform pT2) -> bool”””
return _almath.Transform___eq__(self, *args)
def __ne__(self, *args):
“””__ne__(self, Transform pT2) -> bool”””
return _almath.Transform___ne__(self, *args)
def isNear(self, *args):
“””
isNear(self, Transform pT2, float pEpsilon = 0.0001) -> bool
isNear(self, Transform pT2) -> bool
“””
return _almath.Transform_isNear(self, *args)
def isTransform(self, pEpsilon = 0.0001):
“””
isTransform(self, float pEpsilon = 0.0001) -> bool
isTransform(self) -> bool
“””
return _almath.Transform_isTransform(self, pEpsilon)
def norm(self):
“””norm(self) -> float”””
return _almath.Transform_norm(self)
def determinant(self):
“””determinant(self) -> float”””
return _almath.Transform_determinant(self)
def inverse(self):
“””inverse(self) -> Transform”””
return _almath.Transform_inverse(self)
def fromRotX(*args):
“””fromRotX(float pRotX) -> Transform”””
return _almath.Transform_fromRotX(*args)
if _newclass:fromRotX = staticmethod(fromRotX)
__swig_getmethods__[“fromRotX”] = lambda x: fromRotX
def fromRotY(*args):
“””fromRotY(float pRotY) -> Transform”””
return _almath.Transform_fromRotY(*args)
if _newclass:fromRotY = staticmethod(fromRotY)
__swig_getmethods__[“fromRotY”] = lambda x: fromRotY
def fromRotZ(*args):
“””fromRotZ(float pRotZ) -> Transform”””
return _almath.Transform_fromRotZ(*args)
if _newclass:fromRotZ = staticmethod(fromRotZ)
__swig_getmethods__[“fromRotZ”] = lambda x: fromRotZ
def from3DRotation(*args):
“””from3DRotation(float pWX, float pWY, float pWZ) -> Transform”””
return _almath.Transform_from3DRotation(*args)
if _newclass:from3DRotation = staticmethod(from3DRotation)
__swig_getmethods__[“from3DRotation”] = lambda x: from3DRotation
def fromPosition(*args):
“””
fromPosition(float pX, float pY, float pZ) -> Transform
fromPosition(float pX, float pY, float pZ, float pWX, float pWY,
float pWZ) -> Transform
“””
return _almath.Transform_fromPosition(*args)
if _newclass:fromPosition = staticmethod(fromPosition)
__swig_getmethods__[“fromPosition”] = lambda x: fromPosition
def diff(self, *args):
“””diff(self, Transform pT2) -> Transform”””
return _almath.Transform_diff(self, *args)
def distanceSquared(self, *args):
“””distanceSquared(self, Transform pT2) -> float”””
return _almath.Transform_distanceSquared(self, *args)
def distance(self, *args):
“””distance(self, Transform pT2) -> float”””
return _almath.Transform_distance(self, *args)
def toVector(self):
“””toVector(self) -> vectorFloat”””
return _almath.Transform_toVector(self)
def __str__(self):
“””__str__(self) -> char”””
return _almath.Transform___str__(self)
def __repr__(self):
“””__repr__(self) -> char”””
return _almath.Transform___repr__(self)
def __mul__(self, *args):
“””
__mul__(self, Transform pT2) -> Transform
__mul__(self, Position3D rhs) -> Position3D
“””
return _almath.Transform___mul__(self, *args)
__swig_destroy__ = _almath.delete_Transform
__del__ = lambda self : None;
Transform_swigregister = _almath.Transform_swigregister
Transform_swigregister(Transform)
def Transform_fromRotX(*args):
“””Transform_fromRotX(float pRotX) -> Transform”””
return _almath.Transform_fromRotX(*args)
def Transform_fromRotY(*args):
“””Transform_fromRotY(float pRotY) -> Transform”””
return _almath.Transform_fromRotY(*args)
def Transform_fromRotZ(*args):
“””Transform_fromRotZ(float pRotZ) -> Transform”””
return _almath.Transform_fromRotZ(*args)
def Transform_from3DRotation(*args):
“””Transform_from3DRotation(float pWX, float pWY, float pWZ) -> Transform”””
return _almath.Transform_from3DRotation(*args)
def Transform_fromPosition(*args):
“””
fromPosition(float pX, float pY, float pZ) -> Transform
Transform_fromPosition(float pX, float pY, float pZ, float pWX, float pWY,
float pWZ) -> Transform
“””
return _almath.Transform_fromPosition(*args)

def transformPreMultiply(*args):
“””transformPreMultiply(Transform pT, Transform pTOut)”””
return _almath.transformPreMultiply(*args)
def transformFromRotX(*args):
“””transformFromRotX(float pRotX) -> Transform”””
return _almath.transformFromRotX(*args)
def transformFromRotY(*args):
“””transformFromRotY(float pRotY) -> Transform”””
return _almath.transformFromRotY(*args)
def transformFromRotZ(*args):
“””transformFromRotZ(float pRotZ) -> Transform”””
return _almath.transformFromRotZ(*args)
def transformFrom3DRotation(*args):
“””transformFrom3DRotation(float pWX, float pWY, float pWZ) -> Transform”””
return _almath.transformFrom3DRotation(*args)
def transformInvertInPlace(*args):
“””transformInvertInPlace(Transform pT)”””
return _almath.transformInvertInPlace(*args)
def pinv(*args):
“””pinv(Transform pT) -> Transform”””
return _almath.pinv(*args)
def transformDiff(*args):
“””transformDiff(Transform pT1, Transform pT2) -> Transform”””
return _almath.transformDiff(*args)
def transformDistanceSquared(*args):
“””transformDistanceSquared(Transform pT1, Transform pT2) -> float”””
return _almath.transformDistanceSquared(*args)
def transformDistance(*args):
“””transformDistance(Transform pT1, Transform pT2) -> float”””
return _almath.transformDistance(*args)
class Velocity3D(_object):
“””Proxy of C++ AL::Math::Velocity3D class”””
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, Velocity3D, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, Velocity3D, name)
__swig_setmethods__[“xd”] = _almath.Velocity3D_xd_set
__swig_getmethods__[“xd”] = _almath.Velocity3D_xd_get
if _newclass:xd = _swig_property(_almath.Velocity3D_xd_get, _almath.Velocity3D_xd_set)
__swig_setmethods__[“yd”] = _almath.Velocity3D_yd_set
__swig_getmethods__[“yd”] = _almath.Velocity3D_yd_get
if _newclass:yd = _swig_property(_almath.Velocity3D_yd_get, _almath.Velocity3D_yd_set)
__swig_setmethods__[“zd”] = _almath.Velocity3D_zd_set
__swig_getmethods__[“zd”] = _almath.Velocity3D_zd_get
if _newclass:zd = _swig_property(_almath.Velocity3D_zd_get, _almath.Velocity3D_zd_set)
def __init__(self, *args):
“””
__init__(self) -> Velocity3D
__init__(self, float pInit) -> Velocity3D
__init__(self, float pXd, float pYd, float pZd) -> Velocity3D
__init__(self, vectorFloat pFloats) -> Velocity3D
“””
this = _almath.new_Velocity3D(*args)
try: self.this.append(this)
except: self.this = this
def __add__(self, *args):
“””__add__(self, Velocity3D pVel2) -> Velocity3D”””
return _almath.Velocity3D___add__(self, *args)
def __sub__(self, *args):
“””__sub__(self, Velocity3D pVel2) -> Velocity3D”””
return _almath.Velocity3D___sub__(self, *args)
def __pos__(self):
“””__pos__(self) -> Velocity3D”””
return _almath.Velocity3D___pos__(self)
def __neg__(self):
“””__neg__(self) -> Velocity3D”””
return _almath.Velocity3D___neg__(self)
def __iadd__(self, *args):
“””__iadd__(self, Velocity3D pVel2) -> Velocity3D”””
return _almath.Velocity3D___iadd__(self, *args)
def __isub__(self, *args):
“””__isub__(self, Velocity3D pVel2) -> Velocity3D”””
return _almath.Velocity3D___isub__(self, *args)
def __eq__(self, *args):
“””__eq__(self, Velocity3D pVel2) -> bool”””
return _almath.Velocity3D___eq__(self, *args)
def __ne__(self, *args):
“””__ne__(self, Velocity3D pVel2) -> bool”””
return _almath.Velocity3D___ne__(self, *args)
def __mul__(self, *args):
“””__mul__(self, float pVal) -> Velocity3D”””
return _almath.Velocity3D___mul__(self, *args)
def __div__(self, *args):
“””__div__(self, float pVal) -> Velocity3D”””
return _almath.Velocity3D___div__(self, *args)
def __imul__(self, *args):
“””__imul__(self, float pVal) -> Velocity3D”””
return _almath.Velocity3D___imul__(self, *args)
def __idiv__(self, *args):
“””__idiv__(self, float pVal) -> Velocity3D”””
return _almath.Velocity3D___idiv__(self, *args)
def isNear(self, *args):
“””
isNear(self, Velocity3D pVel2, float pEpsilon = 0.0001) -> bool
isNear(self, Velocity3D pVel2) -> bool
“””
return _almath.Velocity3D_isNear(self, *args)
def norm(self):
“””norm(self) -> float”””
return _almath.Velocity3D_norm(self)
def normalize(self):
“””normalize(self) -> Velocity3D”””
return _almath.Velocity3D_normalize(self)
def toVector(self):
“””toVector(self) -> vectorFloat”””
return _almath.Velocity3D_toVector(self)
def __repr__(self):
“””__repr__(self) -> char”””
return _almath.Velocity3D___repr__(self)
def __rmul__(self, *args):
“””__rmul__(self, float lhs) -> Velocity3D”””
return _almath.Velocity3D___rmul__(self, *args)
__swig_destroy__ = _almath.delete_Velocity3D
__del__ = lambda self : None;
Velocity3D_swigregister = _almath.Velocity3D_swigregister
Velocity3D_swigregister(Velocity3D)
def transformToFloatVector(*args):
“””
transformToFloatVector(Transform pT, vectorFloat pTOut)
transformToFloatVector(Transform pT) -> vectorFloat
“””
return _almath.transformToFloatVector(*args)
def determinant(*args):
“””
determinant(Rotation pRot) -> float
determinant(Transform pT) -> float
determinant(vectorFloat pFloats) -> float
“””
return _almath.determinant(*args)
def transformInverse(*args):
“””
transformInverse(Transform pT, Transform pTOut)
transformInverse(Transform pT) -> Transform
“””
return _almath.transformInverse(*args)
def transformFromPosition(*args):
“””
transformFromPosition(float pX, float pY, float pZ) -> Transform
transformFromPosition(float pX, float pY, float pZ, float pWX, float pWY,
float pWZ) -> Transform
“””
return _almath.transformFromPosition(*args)
class Velocity6D(_object):
“””Proxy of C++ AL::Math::Velocity6D class”””
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, Velocity6D, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, Velocity6D, name)
__swig_setmethods__[“xd”] = _almath.Velocity6D_xd_set
__swig_getmethods__[“xd”] = _almath.Velocity6D_xd_get
if _newclass:xd = _swig_property(_almath.Velocity6D_xd_get, _almath.Velocity6D_xd_set)
__swig_setmethods__[“yd”] = _almath.Velocity6D_yd_set
__swig_getmethods__[“yd”] = _almath.Velocity6D_yd_get
if _newclass:yd = _swig_property(_almath.Velocity6D_yd_get, _almath.Velocity6D_yd_set)
__swig_setmethods__[“zd”] = _almath.Velocity6D_zd_set
__swig_getmethods__[“zd”] = _almath.Velocity6D_zd_get
if _newclass:zd = _swig_property(_almath.Velocity6D_zd_get, _almath.Velocity6D_zd_set)
__swig_setmethods__[“wxd”] = _almath.Velocity6D_wxd_set
__swig_getmethods__[“wxd”] = _almath.Velocity6D_wxd_get
if _newclass:wxd = _swig_property(_almath.Velocity6D_wxd_get, _almath.Velocity6D_wxd_set)
__swig_setmethods__[“wyd”] = _almath.Velocity6D_wyd_set
__swig_getmethods__[“wyd”] = _almath.Velocity6D_wyd_get
if _newclass:wyd = _swig_property(_almath.Velocity6D_wyd_get, _almath.Velocity6D_wyd_set)
__swig_setmethods__[“wzd”] = _almath.Velocity6D_wzd_set
__swig_getmethods__[“wzd”] = _almath.Velocity6D_wzd_get
if _newclass:wzd = _swig_property(_almath.Velocity6D_wzd_get, _almath.Velocity6D_wzd_set)
def __init__(self, *args):
“””
__init__(self) -> Velocity6D
__init__(self, float pInit) -> Velocity6D
__init__(self, float pXd, float pYd, float pZd, float pWxd, float pWyd,
float pWzd) -> Velocity6D
__init__(self, vectorFloat pFloats) -> Velocity6D
“””
this = _almath.new_Velocity6D(*args)
try: self.this.append(this)
except: self.this = this
def __add__(self, *args):
“””__add__(self, Velocity6D pVel2) -> Velocity6D”””
return _almath.Velocity6D___add__(self, *args)
def __sub__(self, *args):
“””__sub__(self, Velocity6D pVel2) -> Velocity6D”””
return _almath.Velocity6D___sub__(self, *args)
def __pos__(self):
“””__pos__(self) -> Velocity6D”””
return _almath.Velocity6D___pos__(self)
def __neg__(self):
“””__neg__(self) -> Velocity6D”””
return _almath.Velocity6D___neg__(self)
def __mul__(self, *args):
“””__mul__(self, float pVal) -> Velocity6D”””
return _almath.Velocity6D___mul__(self, *args)
def __div__(self, *args):
“””__div__(self, float pVal) -> Velocity6D”””
return _almath.Velocity6D___div__(self, *args)
def __eq__(self, *args):
“””__eq__(self, Velocity6D pVel2) -> bool”””
return _almath.Velocity6D___eq__(self, *args)
def __ne__(self, *args):
“””__ne__(self, Velocity6D pVel2) -> bool”””
return _almath.Velocity6D___ne__(self, *args)
def __imul__(self, *args):
“””__imul__(self, float pVal) -> Velocity6D”””
return _almath.Velocity6D___imul__(self, *args)
def __idiv__(self, *args):
“””__idiv__(self, float pVal) -> Velocity6D”””
return _almath.Velocity6D___idiv__(self, *args)
def isNear(self, *args):
“””
isNear(self, Velocity6D pVel2, float pEpsilon = 0.0001) -> bool
isNear(self, Velocity6D pVel2) -> bool
“””
return _almath.Velocity6D_isNear(self, *args)
def norm(self):
“””norm(self) -> float”””
return _almath.Velocity6D_norm(self)
def normalize(self):
“””normalize(self) -> Velocity6D”””
return _almath.Velocity6D_normalize(self)
def toVector(self):
“””toVector(self) -> vectorFloat”””
return _almath.Velocity6D_toVector(self)
def __repr__(self):
“””__repr__(self) -> char”””
return _almath.Velocity6D___repr__(self)
def __rmul__(self, *args):
“””__rmul__(self, float lhs) -> Velocity6D”””
return _almath.Velocity6D___rmul__(self, *args)
__swig_destroy__ = _almath.delete_Velocity6D
__del__ = lambda self : None;
Velocity6D_swigregister = _almath.Velocity6D_swigregister
Velocity6D_swigregister(Velocity6D)
class TransformAndVelocity6D(_object):
“””Proxy of C++ AL::Math::TransformAndVelocity6D class”””
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, TransformAndVelocity6D, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, TransformAndVelocity6D, name)
__swig_setmethods__[“T”] = _almath.TransformAndVelocity6D_T_set
__swig_getmethods__[“T”] = _almath.TransformAndVelocity6D_T_get
if _newclass:T = _swig_property(_almath.TransformAndVelocity6D_T_get, _almath.TransformAndVelocity6D_T_set)
__swig_setmethods__[“V”] = _almath.TransformAndVelocity6D_V_set
__swig_getmethods__[“V”] = _almath.TransformAndVelocity6D_V_get
if _newclass:V = _swig_property(_almath.TransformAndVelocity6D_V_get, _almath.TransformAndVelocity6D_V_set)
def isNear(self, *args):
“””
isNear(self, TransformAndVelocity6D pTV2, float pEpsilon = 0.0001) -> bool
isNear(self, TransformAndVelocity6D pTV2) -> bool
“””
return _almath.TransformAndVelocity6D_isNear(self, *args)
def __repr__(self):
“””__repr__(self) -> char”””
return _almath.TransformAndVelocity6D___repr__(self)
def __init__(self):
“””__init__(self) -> TransformAndVelocity6D”””
this = _almath.new_TransformAndVelocity6D()
try: self.this.append(this)
except: self.this = this
__swig_destroy__ = _almath.delete_TransformAndVelocity6D
__del__ = lambda self : None;
TransformAndVelocity6D_swigregister = _almath.TransformAndVelocity6D_swigregister
TransformAndVelocity6D_swigregister(TransformAndVelocity6D)
def norm(*args):
“””
norm(Position2D pPos) -> float
norm(Position3D pPos) -> float
norm(Position6D pPos) -> float
norm(Quaternion pQua) -> float
norm(Rotation3D pRot) -> float
norm(Transform pT) -> float
norm(Velocity3D pVel) -> float
norm(Velocity6D pVel) -> float
“””
return _almath.norm(*args)
def normalize(*args):
“””
normalize(Position2D pPos) -> Position2D
normalize(Position3D pPos) -> Position3D
normalize(Position6D pPos) -> Position6D
normalize(Quaternion pQua) -> Quaternion
normalize(Velocity3D pVel) -> Velocity3D
normalize(Velocity6D pVel) -> Velocity6D
“””
return _almath.normalize(*args)

def getDubinsSolutions(*args):
“””getDubinsSolutions(Pose2D pTargetPose, float pCircleRadius) -> vectorPose2D”””
return _almath.getDubinsSolutions(*args)
def avoidFootCollision(*args):
“””
avoidFootCollision(vectorPose2D pLFootBoundingBox, vectorPose2D pRFootBoundingBox,
bool pIsLeftSupport, Pose2D pMove) -> bool
“””
return _almath.avoidFootCollision(*args)
def clipFootWithEllipse(*args):
“””clipFootWithEllipse(float pMaxFootX, float pMaxFootY, Pose2D pMove) -> bool”””
return _almath.clipFootWithEllipse(*args)
def transformLogarithmInPlace(*args):
“””transformLogarithmInPlace(Transform pT, Velocity6D pVel)”””
return _almath.transformLogarithmInPlace(*args)
def transformLogarithm(*args):
“””transformLogarithm(Transform pT) -> Velocity6D”””
return _almath.transformLogarithm(*args)
def velocityExponential(*args):
“””velocityExponential(Velocity6D pVel) -> Transform”””
return _almath.velocityExponential(*args)
def velocityExponentialInPlace(*args):
“””velocityExponentialInPlace(Velocity6D pVel, Transform pT)”””
return _almath.velocityExponentialInPlace(*args)
def changeReferenceVelocity6D(*args):
“””changeReferenceVelocity6D(Transform pT, Velocity6D pVelIn, Velocity6D pVelOut)”””
return _almath.changeReferenceVelocity6D(*args)
def changeReferencePosition6D(*args):
“””changeReferencePosition6D(Transform pT, Position6D pPosIn, Position6D pPosOut)”””
return _almath.changeReferencePosition6D(*args)
def changeReferencePosition3DInPlace(*args):
“””changeReferencePosition3DInPlace(Transform pT, Position3D pPosOut)”””
return _almath.changeReferencePosition3DInPlace(*args)
def changeReferenceTransposePosition3DInPlace(*args):
“””changeReferenceTransposePosition3DInPlace(Transform pT, Position3D pPosOut)”””
return _almath.changeReferenceTransposePosition3DInPlace(*args)
def changeReferencePosition3D(*args):
“””changeReferencePosition3D(Transform pT, Position3D pPosIn, Position3D pPosOut)”””
return _almath.changeReferencePosition3D(*args)
def changeReferenceTransposePosition3D(*args):
“””changeReferenceTransposePosition3D(Transform pT, Position3D pPosIn, Position3D pPosOut)”””
return _almath.changeReferenceTransposePosition3D(*args)
def changeReferenceTransform(*args):
“””changeReferenceTransform(Transform pT, Transform pTIn, Transform pTOut)”””
return _almath.changeReferenceTransform(*args)
def changeReferenceTransposeTransform(*args):
“””changeReferenceTransposeTransform(Transform pT, Transform pTIn, Transform pTOut)”””
return _almath.changeReferenceTransposeTransform(*args)
def changeReferenceTransposeVelocity6D(*args):
“””changeReferenceTransposeVelocity6D(Transform pT, Velocity6D pVelIn, Velocity6D pVelOut)”””
return _almath.changeReferenceTransposeVelocity6D(*args)
def changeReferenceTransposePosition6D(*args):
“””changeReferenceTransposePosition6D(Transform pT, Position6D pPosIn, Position6D pPosOut)”””
return _almath.changeReferenceTransposePosition6D(*args)
def transformMeanInPlace(*args):
“””transformMeanInPlace(Transform pTIn1, Transform pTIn2, float pVal, Transform pTOut)”””
return _almath.transformMeanInPlace(*args)
def transformFromPosition3DInPlace(*args):
“””transformFromPosition3DInPlace(Position3D pPosition, Transform pTransform)”””
return _almath.transformFromPosition3DInPlace(*args)
def transformFromPosition3D(*args):
“””transformFromPosition3D(Position3D pPosition) -> Transform”””
return _almath.transformFromPosition3D(*args)
def transformFromRotationInPlace(*args):
“””transformFromRotationInPlace(Rotation pRotation, Transform pTransform)”””
return _almath.transformFromRotationInPlace(*args)
def transformFromRotation(*args):
“””transformFromRotation(Rotation pRotation) -> Transform”””
return _almath.transformFromRotation(*args)
def rotationFromTransformInPlace(*args):
“””rotationFromTransformInPlace(Transform pTransform, Rotation pRotation)”””
return _almath.rotationFromTransformInPlace(*args)
def rotationFromTransform(*args):
“””rotationFromTransform(Transform pTransform) -> Rotation”””
return _almath.rotationFromTransform(*args)
def rotation3DFromRotation(*args):
“””rotation3DFromRotation(Rotation pRotation) -> Rotation3D”””
return _almath.rotation3DFromRotation(*args)
def position6DFromTransformInPlace(*args):
“””position6DFromTransformInPlace(Transform pT, Position6D pPos)”””
return _almath.position6DFromTransformInPlace(*args)
def position6DFromTransform(*args):
“””position6DFromTransform(Transform pT) -> Position6D”””
return _almath.position6DFromTransform(*args)
def transformFromPose2DInPlace(*args):
“””transformFromPose2DInPlace(Pose2D pPose, Transform pT)”””
return _almath.transformFromPose2DInPlace(*args)
def transformFromPose2D(*args):
“””transformFromPose2D(Pose2D pPose) -> Transform”””
return _almath.transformFromPose2D(*args)
def pose2DFromTransformInPlace(*args):
“””pose2DFromTransformInPlace(Transform pT, Pose2D pPos)”””
return _almath.pose2DFromTransformInPlace(*args)
def pose2DFromTransform(*args):
“””pose2DFromTransform(Transform pT) -> Pose2D”””
return _almath.pose2DFromTransform(*args)
def transformFromRotation3D(*args):
“””transformFromRotation3D(Rotation3D pRotation) -> Transform”””
return _almath.transformFromRotation3D(*args)
def transformFromPosition6D(*args):
“””transformFromPosition6D(Position6D pPosition6D) -> Transform”””
return _almath.transformFromPosition6D(*args)
def position6DFromTransformDiffInPlace(*args):
“””position6DFromTransformDiffInPlace(Transform pCurrent, Transform pTarget, Position6D result)”””
return _almath.position6DFromTransformDiffInPlace(*args)
def position6DFromTransformDiff(*args):
“””position6DFromTransformDiff(Transform pCurrent, Transform pTarget) -> Position6D”””
return _almath.position6DFromTransformDiff(*args)
def position3DFromTransformInPlace(*args):
“””position3DFromTransformInPlace(Transform pT, Position3D pPos)”””
return _almath.position3DFromTransformInPlace(*args)
def position3DFromTransform(*args):
“””position3DFromTransform(Transform pT) -> Position3D”””
return _almath.position3DFromTransform(*args)
def rotation3DFromTransform(*args):
“””rotation3DFromTransform(Transform pT) -> Rotation3D”””
return _almath.rotation3DFromTransform(*args)
def transformFromQuaternion(*args):
“””transformFromQuaternion(Quaternion pQua) -> Transform”””
return _almath.transformFromQuaternion(*args)
def quaternionFromTransform(*args):
“””quaternionFromTransform(Transform pT) -> Quaternion”””
return _almath.quaternionFromTransform(*args)
def clipData(*args):
“””clipData(float pMin, float pMax, float pData) -> bool”””
return _almath.clipData(*args)
def position6DFromVelocity6D(*args):
“””position6DFromVelocity6D(Velocity6D pVel) -> Position6D”””
return _almath.position6DFromVelocity6D(*args)
_4_PI_ = cvar._4_PI_
_2_PI_ = cvar._2_PI_
PI = cvar.PI
PI_2 = cvar.PI_2
PI_4 = cvar.PI_4
TO_RAD = cvar.TO_RAD
TO_DEG = cvar.TO_DEG
def transformMean(*args):
“””
transformMean(Transform pTIn1, Transform pTIn2, float pVal = 0.5) -> Transform
transformMean(Transform pTIn1, Transform pTIn2) -> Transform
“””
return _almath.transformMean(*args)
def transformFromRotationPosition3D(*args):
“””
transformFromRotationPosition3D(Rotation pRot, float pX, float pY, float pZ) -> Transform
transformFromRotationPosition3D(Rotation pRot, Position3D pPos) -> Transform
“””
return _almath.transformFromRotationPosition3D(*args)
def transformFromRotVecInPlace(*args):
“””
transformFromRotVecInPlace(int pAxis, float pTheta, Position3D pPos, Transform pT)
transformFromRotVecInPlace(Position3D pPos, Transform pT)
“””
return _almath.transformFromRotVecInPlace(*args)
def transformFromRotVec(*args):
“””
transformFromRotVec(int pAxis, float pTheta, Position3D pPos) -> Transform
transformFromRotVec(Position3D pPos) -> Transform
transformFromRotVec(int pAxis, float pTheta) -> Transform
“””
return _almath.transformFromRotVec(*args)
def axisRotationProjection(*args):
“””
axisRotationProjection(Position3D pPos, Transform pT) -> Transform
axisRotationProjection(Position3D pAxis, Rotation pRot) -> Rotation
“””
return _almath.axisRotationProjection(*args)
def axisRotationProjectionInPlace(*args):
“””
axisRotationProjectionInPlace(Position3D pPos, Transform pT)
axisRotationProjectionInPlace(Position3D pPos, Rotation pRot)
“””
return _almath.axisRotationProjectionInPlace(*args)
def orthogonalSpace(*args):
“””
orthogonalSpace(Position3D pPos, Transform pTOut)
orthogonalSpace(Position3D pPos) -> Transform
“””
return _almath.orthogonalSpace(*args)
def __mul__(*args):
“””
__mul__(float pM, Position2D pPos1) -> Position2D
__mul__(float pM, Position3D pPos1) -> Position3D
__mul__(float pM, Velocity3D pVel1) -> Velocity3D
__mul__(float pVal, Velocity6D pVel) -> Velocity6D
__mul__(Transform pT, Position3D pPos) -> Position3D
__mul__(Rotation pRot, Position3D pPos) -> Position3D
__mul__(float pVal, Position6D pPos) -> Velocity6D
“””
return _almath.__mul__(*args)
def rotationFromAngleDirection(*args):
“””
rotationFromAngleDirection(float pAngle, float pX, float pY, float pZ) -> Rotation
rotationFromAngleDirection(float pTheta, Position3D pPos) -> Rotation
“””
return _almath.rotationFromAngleDirection(*args)

pynaoqi-python-2.6-naoqi-1.14-linux64/_allog.so

pynaoqi-python-2.6-naoqi-1.14-linux64/inaoqi.py
# This file was automatically generated by SWIG (http://www.swig.org).
# Version 1.3.40
#
# Do not make changes to this file unless you know what you are doing–modify
# the SWIG interface file instead.
# This file is compatible with both classic and new-style classes.
from sys import version_info
if version_info >= (2,6,0):
def swig_import_helper():
from os.path import dirname
import imp
fp = None
try:
fp, pathname, description = imp.find_module(‘_inaoqi’, [dirname(__file__)])
except ImportError:
import _inaoqi
return _inaoqi
if fp is not None:
try:
_mod = imp.load_module(‘_inaoqi’, fp, pathname, description)
finally:
fp.close()
return _mod
_inaoqi = swig_import_helper()
del swig_import_helper
else:
import _inaoqi
del version_info
try:
_swig_property = property
except NameError:
pass # Python < 2.2 doesn't have 'property'. 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__ == 'SwigPyObject': 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,)
try:
_object = object
_newclass = 1
except AttributeError:
class _object : pass
_newclass = 0

class SwigPyIterator(_object):
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, SwigPyIterator, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, SwigPyIterator, name)
def __init__(self, *args, **kwargs): raise AttributeError(“No constructor defined – class is abstract”)
__repr__ = _swig_repr
__swig_destroy__ = _inaoqi.delete_SwigPyIterator
__del__ = lambda self : None;
def value(self): return _inaoqi.SwigPyIterator_value(self)
def incr(self, n = 1): return _inaoqi.SwigPyIterator_incr(self, n)
def decr(self, n = 1): return _inaoqi.SwigPyIterator_decr(self, n)
def distance(self, *args): return _inaoqi.SwigPyIterator_distance(self, *args)
def equal(self, *args): return _inaoqi.SwigPyIterator_equal(self, *args)
def copy(self): return _inaoqi.SwigPyIterator_copy(self)
def next(self): return _inaoqi.SwigPyIterator_next(self)
def __next__(self): return _inaoqi.SwigPyIterator___next__(self)
def previous(self): return _inaoqi.SwigPyIterator_previous(self)
def advance(self, *args): return _inaoqi.SwigPyIterator_advance(self, *args)
def __eq__(self, *args): return _inaoqi.SwigPyIterator___eq__(self, *args)
def __ne__(self, *args): return _inaoqi.SwigPyIterator___ne__(self, *args)
def __iadd__(self, *args): return _inaoqi.SwigPyIterator___iadd__(self, *args)
def __isub__(self, *args): return _inaoqi.SwigPyIterator___isub__(self, *args)
def __add__(self, *args): return _inaoqi.SwigPyIterator___add__(self, *args)
def __sub__(self, *args): return _inaoqi.SwigPyIterator___sub__(self, *args)
def __iter__(self): return self
SwigPyIterator_swigregister = _inaoqi.SwigPyIterator_swigregister
SwigPyIterator_swigregister(SwigPyIterator)
class StringVector(_object):
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, StringVector, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, StringVector, name)
__repr__ = _swig_repr
def iterator(self): return _inaoqi.StringVector_iterator(self)
def __iter__(self): return self.iterator()
def __nonzero__(self): return _inaoqi.StringVector___nonzero__(self)
def __bool__(self): return _inaoqi.StringVector___bool__(self)
def __len__(self): return _inaoqi.StringVector___len__(self)
def pop(self): return _inaoqi.StringVector_pop(self)
def __getslice__(self, *args): return _inaoqi.StringVector___getslice__(self, *args)
def __setslice__(self, *args): return _inaoqi.StringVector___setslice__(self, *args)
def __delslice__(self, *args): return _inaoqi.StringVector___delslice__(self, *args)
def __delitem__(self, *args): return _inaoqi.StringVector___delitem__(self, *args)
def __getitem__(self, *args): return _inaoqi.StringVector___getitem__(self, *args)
def __setitem__(self, *args): return _inaoqi.StringVector___setitem__(self, *args)
def append(self, *args): return _inaoqi.StringVector_append(self, *args)
def empty(self): return _inaoqi.StringVector_empty(self)
def size(self): return _inaoqi.StringVector_size(self)
def clear(self): return _inaoqi.StringVector_clear(self)
def swap(self, *args): return _inaoqi.StringVector_swap(self, *args)
def get_allocator(self): return _inaoqi.StringVector_get_allocator(self)
def begin(self): return _inaoqi.StringVector_begin(self)
def end(self): return _inaoqi.StringVector_end(self)
def rbegin(self): return _inaoqi.StringVector_rbegin(self)
def rend(self): return _inaoqi.StringVector_rend(self)
def pop_back(self): return _inaoqi.StringVector_pop_back(self)
def erase(self, *args): return _inaoqi.StringVector_erase(self, *args)
def __init__(self, *args):
this = _inaoqi.new_StringVector(*args)
try: self.this.append(this)
except: self.this = this
def push_back(self, *args): return _inaoqi.StringVector_push_back(self, *args)
def front(self): return _inaoqi.StringVector_front(self)
def back(self): return _inaoqi.StringVector_back(self)
def assign(self, *args): return _inaoqi.StringVector_assign(self, *args)
def resize(self, *args): return _inaoqi.StringVector_resize(self, *args)
def insert(self, *args): return _inaoqi.StringVector_insert(self, *args)
def reserve(self, *args): return _inaoqi.StringVector_reserve(self, *args)
def capacity(self): return _inaoqi.StringVector_capacity(self)
__swig_destroy__ = _inaoqi.delete_StringVector
__del__ = lambda self : None;
StringVector_swigregister = _inaoqi.StringVector_swigregister
StringVector_swigregister(StringVector)

def setInstance(*args):
return _inaoqi.setInstance(*args)
setInstance = _inaoqi.setInstance
def getMemoryProxy():
return _inaoqi.getMemoryProxy()
getMemoryProxy = _inaoqi.getMemoryProxy
def _ALSystem(*args):
return _inaoqi._ALSystem(*args)
_ALSystem = _inaoqi._ALSystem
class broker(_object):
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, broker, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, broker, name)
__repr__ = _swig_repr
def __init__(self, *args):
this = _inaoqi.new_broker(*args)
try: self.this.append(this)
except: self.this = this
__swig_destroy__ = _inaoqi.delete_broker
__del__ = lambda self : None;
def shutdown(self): return _inaoqi.broker_shutdown(self)
def isModulePresent(self, *args): return _inaoqi.broker_isModulePresent(self, *args)
def getGlobalModuleList(self): return _inaoqi.broker_getGlobalModuleList(self)
broker_swigregister = _inaoqi.broker_swigregister
broker_swigregister(broker)
class baseModule(_object):
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, baseModule, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, baseModule, name)
__repr__ = _swig_repr
def __init__(self):
this = _inaoqi.new_baseModule()
try: self.this.append(this)
except: self.this = this
def BIND_PYTHON(self, *args): return _inaoqi.baseModule_BIND_PYTHON(self, *args)
def _bindWithParam(self, *args): return _inaoqi.baseModule__bindWithParam(self, *args)
def exit(self): return _inaoqi.baseModule_exit(self)
def getName(self): return _inaoqi.baseModule_getName(self)
def getBrokerName(self): return _inaoqi.baseModule_getBrokerName(self)
def setModuleDescription(self, *args): return _inaoqi.baseModule_setModuleDescription(self, *args)
def addParam(self, *args): return _inaoqi.baseModule_addParam(self, *args)
def functionName(self, *args): return _inaoqi.baseModule_functionName(self, *args)
def autoBind(self, *args): return _inaoqi.baseModule_autoBind(self, *args)
def _methodMissing0(self): return _inaoqi.baseModule__methodMissing0(self)
def _methodMissing1(self, *args): return _inaoqi.baseModule__methodMissing1(self, *args)
def _methodMissing2(self, *args): return _inaoqi.baseModule__methodMissing2(self, *args)
def _methodMissing3(self, *args): return _inaoqi.baseModule__methodMissing3(self, *args)
def _methodMissing4(self, *args): return _inaoqi.baseModule__methodMissing4(self, *args)
def _methodMissing5(self, *args): return _inaoqi.baseModule__methodMissing5(self, *args)
def _methodMissing6(self, *args): return _inaoqi.baseModule__methodMissing6(self, *args)
def _methodMissing(self): return _inaoqi.baseModule__methodMissing(self)
def version(self): return _inaoqi.baseModule_version(self)
__swig_destroy__ = _inaoqi.delete_baseModule
__del__ = lambda self : None;
baseModule_swigregister = _inaoqi.baseModule_swigregister
baseModule_swigregister(baseModule)
class module(baseModule):
__swig_setmethods__ = {}
for _s in [baseModule]: __swig_setmethods__.update(getattr(_s,’__swig_setmethods__’,{}))
__setattr__ = lambda self, name, value: _swig_setattr(self, module, name, value)
__swig_getmethods__ = {}
for _s in [baseModule]: __swig_getmethods__.update(getattr(_s,’__swig_getmethods__’,{}))
__getattr__ = lambda self, name: _swig_getattr(self, module, name)
__repr__ = _swig_repr
def __init__(self, *args):
this = _inaoqi.new_module(*args)
try: self.this.append(this)
except: self.this = this
def BIND_PYTHON(self, *args): return _inaoqi.module_BIND_PYTHON(self, *args)
def exit(self): return _inaoqi.module_exit(self)
def getName(self): return _inaoqi.module_getName(self)
def getBrokerName(self): return _inaoqi.module_getBrokerName(self)
def _methodMissing(self): return _inaoqi.module__methodMissing(self)
def version(self): return _inaoqi.module_version(self)
__swig_destroy__ = _inaoqi.delete_module
__del__ = lambda self : None;
module_swigregister = _inaoqi.module_swigregister
module_swigregister(module)
class timeline(_object):
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, timeline, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, timeline, name)
__repr__ = _swig_repr
def __init__(self, *args):
this = _inaoqi.new_timeline(*args)
try: self.this.append(this)
except: self.this = this
__swig_destroy__ = _inaoqi.delete_timeline
__del__ = lambda self : None;
def play(self): return _inaoqi.timeline_play(self)
def pause(self): return _inaoqi.timeline_pause(self)
def stop(self): return _inaoqi.timeline_stop(self)
def goTo(self, *args): return _inaoqi.timeline_goTo(self, *args)
def getSize(self): return _inaoqi.timeline_getSize(self)
def getFPS(self): return _inaoqi.timeline_getFPS(self)
def setFPS(self, *args): return _inaoqi.timeline_setFPS(self, *args)
timeline_swigregister = _inaoqi.timeline_swigregister
timeline_swigregister(timeline)
class behavior(baseModule):
__swig_setmethods__ = {}
for _s in [baseModule]: __swig_setmethods__.update(getattr(_s,’__swig_setmethods__’,{}))
__setattr__ = lambda self, name, value: _swig_setattr(self, behavior, name, value)
__swig_getmethods__ = {}
for _s in [baseModule]: __swig_getmethods__.update(getattr(_s,’__swig_getmethods__’,{}))
__getattr__ = lambda self, name: _swig_getattr(self, behavior, name)
__repr__ = _swig_repr
def __init__(self, *args):
this = _inaoqi.new_behavior(*args)
try: self.this.append(this)
except: self.this = this
__swig_destroy__ = _inaoqi.delete_behavior
__del__ = lambda self : None;
def setEnabled(self, *args): return _inaoqi.behavior_setEnabled(self, *args)
def isEnabled(self): return _inaoqi.behavior_isEnabled(self)
def setResources(self, *args): return _inaoqi.behavior_setResources(self, *args)
def waitFor(self, *args): return _inaoqi.behavior_waitFor(self, *args)
def waitResourcesCallback(self, *args): return _inaoqi.behavior_waitResourcesCallback(self, *args)
def isResourceFree(self, *args): return _inaoqi.behavior_isResourceFree(self, *args)
def waitResourceFree(self): return _inaoqi.behavior_waitResourceFree(self)
def waitResources(self): return _inaoqi.behavior_waitResources(self)
def releaseResource(self): return _inaoqi.behavior_releaseResource(self)
def addInput(self, *args): return _inaoqi.behavior_addInput(self, *args)
def addOutput(self, *args): return _inaoqi.behavior_addOutput(self, *args)
def addParameter(self, *args): return _inaoqi.behavior_addParameter(self, *args)
def getParameter(self, *args): return _inaoqi.behavior_getParameter(self, *args)
def getParametersList(self): return _inaoqi.behavior_getParametersList(self)
def setParameter(self, *args): return _inaoqi.behavior_setParameter(self, *args)
def stimulateIO(self, *args): return _inaoqi.behavior_stimulateIO(self, *args)
def BIND_PYTHON(self, *args): return _inaoqi.behavior_BIND_PYTHON(self, *args)
def setModuleDescription(self, *args): return _inaoqi.behavior_setModuleDescription(self, *args)
def addParam(self, *args): return _inaoqi.behavior_addParam(self, *args)
def exit(self): return _inaoqi.behavior_exit(self)
def getName(self): return _inaoqi.behavior_getName(self)
def getBrokerName(self): return _inaoqi.behavior_getBrokerName(self)
def _methodMissing(self): return _inaoqi.behavior__methodMissing(self)
def version(self): return _inaoqi.behavior_version(self)
def hasTimeline(self): return _inaoqi.behavior_hasTimeline(self)
def getTimeline(self): return _inaoqi.behavior_getTimeline(self)
def hasParentTimeline(self): return _inaoqi.behavior_hasParentTimeline(self)
def getParentTimeline(self): return _inaoqi.behavior_getParentTimeline(self)
behavior_swigregister = _inaoqi.behavior_swigregister
behavior_swigregister(behavior)
class proxy(_object):
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, proxy, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, proxy, name)
__repr__ = _swig_repr
def __init__(self, *args):
this = _inaoqi.new_proxy(*args)
try: self.this.append(this)
except: self.this = this
def pythonCall(self, *args): return _inaoqi.proxy_pythonCall(self, *args)
def pythonPCall(self, *args): return _inaoqi.proxy_pythonPCall(self, *args)
def wait(self, *args): return _inaoqi.proxy_wait(self, *args)
def stop(self, *args): return _inaoqi.proxy_stop(self, *args)
def isRunning(self, *args): return _inaoqi.proxy_isRunning(self, *args)
__swig_destroy__ = _inaoqi.delete_proxy
__del__ = lambda self : None;
proxy_swigregister = _inaoqi.proxy_swigregister
proxy_swigregister(proxy)
class ALMemoryProxy(_object):
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, ALMemoryProxy, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, ALMemoryProxy, name)
__repr__ = _swig_repr
def __init__(self, *args):
this = _inaoqi.new_ALMemoryProxy(*args)
try: self.this.append(this)
except: self.this = this
__swig_setmethods__[“post”] = _inaoqi.ALMemoryProxy_post_set
__swig_getmethods__[“post”] = _inaoqi.ALMemoryProxy_post_get
if _newclass:post = _swig_property(_inaoqi.ALMemoryProxy_post_get, _inaoqi.ALMemoryProxy_post_set)
def getGenericProxy(self): return _inaoqi.ALMemoryProxy_getGenericProxy(self)
def declareEvent(self, *args): return _inaoqi.ALMemoryProxy_declareEvent(self, *args)
def exit(self): return _inaoqi.ALMemoryProxy_exit(self)
def getBrokerName(self): return _inaoqi.ALMemoryProxy_getBrokerName(self)
def getData(self, *args): return _inaoqi.ALMemoryProxy_getData(self, *args)
def getDataList(self, *args): return _inaoqi.ALMemoryProxy_getDataList(self, *args)
def getDataListName(self): return _inaoqi.ALMemoryProxy_getDataListName(self)
def getDataOnChange(self, *args): return _inaoqi.ALMemoryProxy_getDataOnChange(self, *args)
def getDataPtr(self, *args): return _inaoqi.ALMemoryProxy_getDataPtr(self, *args)
def getDescriptionList(self, *args): return _inaoqi.ALMemoryProxy_getDescriptionList(self, *args)
def getEventHistory(self, *args): return _inaoqi.ALMemoryProxy_getEventHistory(self, *args)
def getEventList(self): return _inaoqi.ALMemoryProxy_getEventList(self)
def getExtractorEvent(self, *args): return _inaoqi.ALMemoryProxy_getExtractorEvent(self, *args)
def getListData(self, *args): return _inaoqi.ALMemoryProxy_getListData(self, *args)
def getMethodHelp(self, *args): return _inaoqi.ALMemoryProxy_getMethodHelp(self, *args)
def getMethodList(self): return _inaoqi.ALMemoryProxy_getMethodList(self)
def getMicroEventList(self): return _inaoqi.ALMemoryProxy_getMicroEventList(self)
def getModuleHelp(self): return _inaoqi.ALMemoryProxy_getModuleHelp(self)
def getSubscribers(self, *args): return _inaoqi.ALMemoryProxy_getSubscribers(self, *args)
def getTimestamp(self, *args): return _inaoqi.ALMemoryProxy_getTimestamp(self, *args)
def getType(self, *args): return _inaoqi.ALMemoryProxy_getType(self, *args)
def getUsage(self, *args): return _inaoqi.ALMemoryProxy_getUsage(self, *args)
def insertData(self, *args): return _inaoqi.ALMemoryProxy_insertData(self, *args)
def insertListData(self, *args): return _inaoqi.ALMemoryProxy_insertListData(self, *args)
def isRunning(self, *args): return _inaoqi.ALMemoryProxy_isRunning(self, *args)
def ping(self): return _inaoqi.ALMemoryProxy_ping(self)
def raiseEvent(self, *args): return _inaoqi.ALMemoryProxy_raiseEvent(self, *args)
def raiseMicroEvent(self, *args): return _inaoqi.ALMemoryProxy_raiseMicroEvent(self, *args)
def removeData(self, *args): return _inaoqi.ALMemoryProxy_removeData(self, *args)
def removeMicroEvent(self, *args): return _inaoqi.ALMemoryProxy_removeMicroEvent(self, *args)
def setDescription(self, *args): return _inaoqi.ALMemoryProxy_setDescription(self, *args)
def stop(self, *args): return _inaoqi.ALMemoryProxy_stop(self, *args)
def subscribeToEvent(self, *args): return _inaoqi.ALMemoryProxy_subscribeToEvent(self, *args)
def subscribeToMicroEvent(self, *args): return _inaoqi.ALMemoryProxy_subscribeToMicroEvent(self, *args)
def unregisterModuleReference(self, *args): return _inaoqi.ALMemoryProxy_unregisterModuleReference(self, *args)
def unsubscribeToEvent(self, *args): return _inaoqi.ALMemoryProxy_unsubscribeToEvent(self, *args)
def unsubscribeToMicroEvent(self, *args): return _inaoqi.ALMemoryProxy_unsubscribeToMicroEvent(self, *args)
def version(self): return _inaoqi.ALMemoryProxy_version(self)
def wait(self, *args): return _inaoqi.ALMemoryProxy_wait(self, *args)
__swig_destroy__ = _inaoqi.delete_ALMemoryProxy
__del__ = lambda self : None;
ALMemoryProxy_swigregister = _inaoqi.ALMemoryProxy_swigregister
ALMemoryProxy_swigregister(ALMemoryProxy)

pynaoqi-python-2.6-naoqi-1.14-linux64/motion.py
# Class Motion for storing useful ALMotion constants
# SPACES
SPACE_TORSO = 0
SPACE_WORLD = 1
SPACE_NAO = 2
# NEW in 1.14
FRAME_TORSO = 0
FRAME_WORLD = 1
FRAME_ROBOT = 2
# MOVEMENT
MVT_RELATIVE = 0
MVT_ABSOLUTE = 1
#ANGLE TYPE
COMMANDS = 0,
SENSORS = 1
# AXIS MASK
AXIS_MASK_X = 1
AXIS_MASK_Y = 2
AXIS_MASK_Z = 4
AXIS_MASK_WX = 8
AXIS_MASK_WY = 16
AXIS_MASK_WZ = 32
AXIS_MASK_ALL = 63
AXIS_MASK_VEL = 7
AXIS_MASK_ROT = 56
# COMPUTING
TO_RAD = 0.01745329
TO_DEG = 57.295779513082323

pynaoqi-python-2.6-naoqi-1.14-linux64/vision_definitions.py
# Useful constants used by the Vision modules.
# Camera model
kOV7670 = 1 # VGA camera
kMT9M114 = 2 # HD wide angle camera
# Image format
k960p = 3 # 1280*960
k4VGA = 3 # 1280*960
kVGA = 2 # 640*480
kQVGA = 1 # 320*240
kQQVGA = 0 # 160*120
# Color Space
kYuvColorSpace = 0
kyUvColorSpace = 1
kyuVColorSpace = 2
kRgbColorSpace = 3
krGbColorSpace = 4
krgBColorSpace = 5
kHsvColorSpace = 6
khSvColorSpace = 7
khsVColorSpace = 8
kYUV422InterlacedColorSpace = 9 #deprecated
kYUV422ColorSpace = 9
kYUVColorSpace = 10
kRGBColorSpace = 11
kHSVColorSpace = 12
kBGRColorSpace = 13
kYYCbCrColorSpace = 14
kH2RGBColorSpace = 15
kHSMixedColorSpace = 16

# Scale methods
kSimpleScaleMethod = 0
kAverageScaleMethod = 1
kQualityScaleMethod = 2
kNoScaling = 3

# Standard Id
kCameraBrightnessID = 0
kCameraContrastID = 1
kCameraSaturationID = 2
kCameraHueID = 3
kCameraRedChromaID = 4
kCameraBlueChromaID = 5
kCameraGainID = 6
kCameraHFlipID = 7
kCameraVFlipID = 8
kCameraLensXID = 9
kCameraLensYID = 10
kCameraAutoExpositionID = 11
kCameraAutoWhiteBalanceID = 12
kCameraAutoGainID = 13
kCameraResolutionID = 14
kCameraFrameRateID = 15
kCameraBufferSizeID = 16
kCameraExposureID = 17
kCameraSelectID = 18
kCameraSetDefaultParamsID = 19
kCameraColorSpaceID = 20
kCameraExposureCorrectionID = 21
kCameraAecAlgorithmID = 22
kCameraFastSwitchID = 23
kCameraSharpnessID = 24
kCameraAwbGreenGainID = 25
kCameraAblcID = 26
kCameraAblcTargetID = 27
kCameraAblcStableRangeID = 28
kCameraBlcBlueID = 29
kCameraBlcRedID = 30
kCameraBlcGbID = 31
kCameraBlcGrID = 32
kCameraWhiteBalanceID = 33
kCameraBacklightCompensationID = 34

pynaoqi-python-2.6-naoqi-1.14-mac64/_inaoqi.so

pynaoqi-python-2.6-naoqi-1.14-mac64/_almath.so

pynaoqi-python-2.6-naoqi-1.14-mac64/naoqi.py
import os
import sys
import weakref
import logging

try:
import _inaoqi
except ImportError:
# quick hack to keep inaoqi.py happy
if sys.platform.startswith(“win”):
print “Could not find _inaoqi, trying with _inaoqi_d”
import _inaoqi_d as _inaoqi
else:
raise
import inaoqi
import motion
import allog
def autoBind(myClass, bindIfnoDocumented):
“””Show documentation for each
method of the class”””
# dir(myClass) is a list of the names of
# everything in class
myClass.setModuleDescription(myClass.__doc__)
for thing in dir(myClass):
# getattr(x, “y”) is exactly: x.y
function = getattr(myClass, thing)
if callable(function):
if (type(function) == type(myClass.__init__)):
if (bindIfnoDocumented or function.__doc__ != “”):
if (thing[0] != “_”): # private method
if (function.__doc__):
myClass.functionName(thing, myClass.getName(), function.__doc__)
else:
myClass.functionName(thing, myClass.getName(), “”)
for param in function.func_code.co_varnames:
if (param != “self”):
myClass.addParam(param)
myClass._bindWithParam(myClass.getName(),thing,len(function.func_code.co_varnames)-1)

class ALDocable():
def __init__(self, bindIfnoDocumented):
autoBind(self,bindIfnoDocumented)

# define the log handler to be used by the logging module
class ALLogHandler(logging.Handler):
def __init__(self):
logging.Handler.__init__(self)
def emit(self, record):
level_to_function = {
logging.DEBUG: allog.debug,
logging.INFO: allog.info,
logging.WARNING: allog.warning,
logging.ERROR: allog.error,
logging.CRITICAL: allog.fatal,
}
function = level_to_function.get(record.levelno, allog.debug)
function(record.getMessage(),
record.name,
record.filename,
record.funcName,
record.lineno)

# Same as above, but we force the category to be behavior.box
# *AND* we prefix the message with the module name
# look at errorInBox in choregraphe for explanation
class ALBehaviorLogHandler(logging.Handler):
def __init__(self):
logging.Handler.__init__(self)
def emit(self, record):
level_to_function = {
logging.DEBUG: allog.debug,
logging.INFO: allog.info,
logging.WARNING: allog.warning,
logging.ERROR: allog.error,
logging.CRITICAL: allog.fatal,
}
function = level_to_function.get(record.levelno, allog.debug)
function(record.name + “: ” + record.getMessage(),
“behavior.box”,
“”, # record.filename in this case is simply ‘‘
record.funcName,
record.lineno)
# define a class that will be inherited by both ALModule and ALBehavior, to store instances of modules, so a bound method can be called on them.
class NaoQiModule():
_modules = dict()
@classmethod
def getModule(cls, name):
# returns a reference a module, giving its string, if it exists !
if(name not in cls._modules):
raise RuntimeError(“Module ” + str(name) + ” does not exist”)
return cls._modules[name]()
def __init__(self, name, logger=True):
# keep a weak reference to ourself, so a proxy can be called on this module easily
self._modules[name] = weakref.ref(self)
self.loghandler = None
if logger:
self.logger = logging.getLogger(name)
self.loghandler = ALLogHandler()
self.logger.addHandler(self.loghandler)
self.logger.setLevel(logging.DEBUG)
def __del__(self):
# when object is deleted, clean up dictionnary so we do not keep a weak reference to it
del self._modules[self.getName()]
if(self.loghandler != None):
self.logger.removeHandler(self.loghandler)

class ALBroker(inaoqi.broker):
def init(self):
pass
class ALModule(inaoqi.module, ALDocable, NaoQiModule):
def __init__(self,param):
inaoqi.module.__init__(self, param)
ALDocable.__init__(self, False)
NaoQiModule.__init__(self, param)
def __del__(self):
NaoQiModule.__del__(self)
def methodtest(self):
pass
def pythonChanged(self, param1, param2, param3):
pass

class ALBehavior(inaoqi.behavior, NaoQiModule):
# class var in order not to build it each time
_noNeedToBind = set(dir(inaoqi.behavior))
_noNeedToBind.add(“getModule”)
_noNeedToBind.add(“onLoad”)
_noNeedToBind.add(“onUnload”)
# deprecated since 1.14 methods
_noNeedToBind.add(“log”)
_noNeedToBind.add(“playTimeline”)
_noNeedToBind.add(“stopTimeline”)
_noNeedToBind.add(“exitBehavior”)
_noNeedToBind.add(“gotoAndStop”)
_noNeedToBind.add(“gotoAndPlay”)
_noNeedToBind.add(“playTimelineParent”)
_noNeedToBind.add(“stopTimelineParent”)
_noNeedToBind.add(“exitBehaviorParent”)
_noNeedToBind.add(“gotoAndPlayParent”)
_noNeedToBind.add(“gotoAndStopParent”)
def __init__(self, param, autoBind):
inaoqi.behavior.__init__(self, param)
NaoQiModule.__init__(self, param, logger=False)
self.logger = logging.getLogger(param)
self.behaviorloghandler = ALBehaviorLogHandler()
self.logger.addHandler(self.behaviorloghandler)
self.logger.setLevel(logging.DEBUG)
self.resource = False
self.BIND_PYTHON(self.getName(), “__onLoad__”)
self.BIND_PYTHON(self.getName(), “__onUnload__”)
if(autoBind):
behName = self.getName()
userMethList = set(dir(self)) – self._noNeedToBind
for methName in userMethList:
function = getattr(self, methName)
if callable(function) and type(function) == type(self.__init__):
if (methName[0] != “_”): # private method
self.functionName(methName, behName, “”)
for param in function.func_code.co_varnames:
if (param != “self”):
self.addParam(param)
self._bindWithParam(behName,methName,len(function.func_code.co_varnames)-1)
def __del__(self):
NaoQiModule.__del__(self)
self.logger.removeHandler(self.behaviorloghandler)
self.behaviorloghandler.close()
def __onLoad__(self):
self._safeCallOfUserMethod(“onLoad”,None)
def __onUnload__(self):
if(self.resource):
self.releaseResource()
self._safeCallOfUserMethod(“onUnload”,None)
def setParameter(self, parameterName, newValue):
inaoqi.behavior.setParameter(self, parameterName, newValue)
def _safeCallOfUserMethod(self, functionName, functionArg):
try:
if(functionName in dir(self)):
func = getattr(self, functionName)
if(func.im_func.func_code.co_argcount == 2):
func(functionArg)
else:
func()
return True
except BaseException, err:
self.logger.error(str(err))
try:
if(“onError” in dir(self)):
self.onError(self.getName() + ‘:’ +str(err))
except BaseException, err2:
self.logger.error(str(err2))
return False
# Depreciate this!!! Same as self.logger.info(), but function is always “log”
def log(self, p):
self.logger.info(p)

class MethodMissingMixin(object):
“”” A Mixin’ to implement the ‘method_missing’ Ruby-like protocol. “””
def __getattribute__(self, attr):
try:
return object.__getattribute__(self, attr)
except:
class MethodMissing(object):
def __init__(self, wrapped, method):
self.__wrapped__ = wrapped
self.__method__ = method
def __call__(self, *args, **kwargs):
return self.__wrapped__.method_missing(self.__method__, *args, **kwargs)
return MethodMissing(self, attr)
def method_missing(self, *args, **kwargs):
“”” This method should be overridden in the derived class. “””
raise NotImplementedError(str(self.__wrapped__) + ” ‘method_missing’ method has not been implemented.”)

class postType(MethodMissingMixin):
def __init__(self):
“”
def setProxy(self, proxy):
self.proxy = weakref.ref(proxy)
# print name
def method_missing(self, method, *args, **kwargs):
list = []
list.append(method)
for arg in args:
list.append(arg)
result = 0
try:
p = self.proxy()
result = p.pythonPCall(list)
except RuntimeError,e:
raise e
return result

class ALProxy(inaoqi.proxy,MethodMissingMixin):
def __init__(self, *args):
self.post = postType()
self.post.setProxy(self)
if (len (args) == 1):
inaoqi.proxy.__init__(self, args[0])
elif (len (args) == 2):
inaoqi.proxy.__init__(self, args[0], args[1])
else:
inaoqi.proxy.__init__(self, args[0], args[1], args[2])
def call(self, *args):
list = []
for arg in args:
list.append(arg)
return self.pythonCall(list)

def pCall(self, *args):
list = []
for arg in args:
list.append(arg)
return self.pythonPCall(list)

def method_missing(self, method, *args, **kwargs):
list = []
list.append(method)
for arg in args:
list.append(arg)
result = 0
try:
result = self.pythonCall(list)
except RuntimeError,e:
raise e
#print e.args[0]
return result
@staticmethod
def initProxies():
#Warning: The use of these default proxies is deprecated.
global ALMemory
global ALMotion
global ALFrameManager
global ALLeds
global ALLogger
global ALSensors
try:
ALMemory = inaoqi.getMemoryProxy()
except:
ALMemory = ALProxy(“ALMemory”)
try:
ALFrameManager = ALProxy(“ALFrameManager”)
except:
print “No proxy to ALFrameManager”
try:
ALMotion = ALProxy(“ALMotion”)
except:
print “No proxy to ALMotion”
try:
ALLeds = ALProxy(“ALLeds”)
except:
pass
try:
ALLogger = ALProxy(“ALLogger”)
except:
print “No proxy to ALLogger”
try:
ALSensors = ALProxy(“ALSensors”)
except:
pass

def createModule(name):
global moduleList
str = “moduleList.append(“+ “module(\”” + name + “\”))”
exec(str)

pynaoqi-python-2.6-naoqi-1.14-mac64/license.rtf

End-
User Software License Agreement

This Limited End-User Software License Agreement (the “Agreement”) is a legal agreement between you (“Licensee”), the end-user, and Aldebaran Robotics SAS having its registered office at 168-170 Rue Raymond Losserand, 75014 Paris, France, registered with the trade and companies register of Paris under number 483 185 807 (hereinafter “Aldebaran”) for the use of the ” Aldebaran Software Toolkit ” (“Software”). By using this software or storing this program on a computer or robot hard drive (or other media), you are agreeing to be bound by the terms of this Agreement. If you do not agree to any of the terms of this agreement uninstall and delete the software from all storage media.

ARTICLE 1 – RIGHTS GRANTED

ALDEBARAN grants to the LICENSEE a personal, non-exclusive, non-transferable, non sub-licensable right to install and use the Software and the Documentation (if any), for the duration of the applicable intellectual property rights.

ALDEBARAN shall have the right to make update and/or upgrade of the Software. However this Agreement does not grant any right on any update or upgrade of the Software. In the event ALDEBARAN provided an upgrade or upgrade of the Software which is not used by Licensee will not benefit from warranties given by ALDABARAN within this Agreement (as far as permitted by the applicable law).

ALDEBARAN may discontinue or change the Software, at any time or for any reason, with or without notice. To avoid any misunderstanding it is agreed that ALDEBARAN has no right to operate a change on the LICENSEE‘s device where the Software is install without its consent.

This Agreement does not grant any right to any Third-Party Software.

Some Third-Party Software may be needed to permit the Software to operate properly. Even in such event ALDEBARAN is not granting any right on the Third-Party Software. The Third-Party Software remains subject to the specific licenses applicable to each Third-Party Software and as described in their related applicable documentation. Licensee shall on his owns decide to either accept or not the applicable terms and conditions related to Third-Party Software. Licensee accepts and understands that refusing the terms and conditions applicable to Third-Party Software may impact in whole or in part the use of the Software.

ARTICLE 2 – OBLIGATIONS OF THE LICENSEE

LICENSEE agrees to the following:

– The LICENSEE shall strictly comply with the user instructions set forth in the Documentation;

– Even if LICENSEE keeps its right of objectively critic the Software, the LICENSEE shall not take any action to impair the reputation of the Product, the trademarks of ALDEBARAN or its licensors and any other product of ALDEBARAN or its licensors;

– LICENSEE shall in no event use the Software for any illegal, defaming, pornographic or detrimental activities;

– The LICENSEE shall use the ALDEBARAN name and trademarks only in the manner prescribed by ALDEBARAN in writing;

– The LICENSEE shall inform ALDEBARAN of any potential defects discovered when using the Product;

– The LICENSEE shall notify ALDEBARAN promptly of any legal notices, claims or actions directly or indirectly relating to the Software against a third party and not enter into or compromise any legal action or other proceeding relating to the Software without the prior written consent of ALDEBARAN;

– The LICENSEE shall not use, without the prior written consent of ALDEBARAN, the Software for the benefit of third parties in any manner, and in particular:

(a) not sell, resell, lease, transfer, license or sublicense or otherwise provide the Software to any third party, and, in a more general manner, not communicate all or part of the Software to any third party;

(b) not charge or otherwise deal in or encumber the Software;

– The LICENSEE shall not delete, remove or in any way obscure the proprietary notices, labels or marks of ALDEBARAN or its licensors on the Software and conspicuously display the proprietary notices, labels or marks on any copy of the Software;

– Except otherwise expressly agreed the LICENSEE shall not alter, modify, decompile, disassemble, or reverse engineer the program code or any other part of the Software, in whole or in part, except in the events and only to the extent expressly provided by law. However, even if the law authorizes the above acts, LICENSEE shall give ALDEBARAN a written notice seven (7) calendar days prior to the date on which these acts are scheduled to take place and allow a representative of ALDEBARAN to be present during these acts;

– Except otherwise expressly agreed the LICENSEE shall not develop any other software programs or derivative works on the basis of the Software. Any such software program or derivative work shall in no case be sold, assigned or licensed by the LICENSEE;

– To avoid any misunderstanding it is agreed that LICENSEE shall have the right to use and exploit the result given by the use of the software in conformity of this license agreement.

– The LICENSEE shall not use the Software for illegal purposes or in illegal manner, including in violation of the intellectual property rights of ALDEBARAN or any third party;

– The LICENSEE shall provide ALDEBARAN promptly with any information, material, software or specification as may reasonably be required for the proper performance of this Agreement including access to appropriate members of the LICENSEE’s staff. The LICENSEE is responsible for the completeness and accuracy of such information, material, software or specification;

ARTICLE 3 – LIMITED WARRANTIES AND LIMITATION OF LIABILITY

3.1 ALDEBARAN warrants that it has full title and ownership to the Software. ALDEBARAN also warrants that it has the full power and authority to enter into this agreement and to grant the license conveyed in this Agreement. Aldebaran warrants that the use of the Software in conformity with this Agreement will in no way constitute an infringement or other violation of any Intellectual Property of any third party.
Should the Software give rise, or in ALDEBARAN opinion be likely to give rise to any such claim, ALDEBARAN shall, at its option and expense, either:

(i) procure for LICENSEE the right to continue using such Aldebaran Software; or
(ii) replace or modify the Aldebaran Software so that it does not infringe the intellectual property rights anymore; or
(iii) terminate the right of use of the Software.

Except as set out in this Agreement, all conditions, warranties and representations in relation to the Software are excluded to the extent permitted under applicable law.

3.2 AS FAR AS PERMITTED BY THE APPLICABLE LAW:

ALDEBARAN PROVIDES THE SOFTWARE “AS IS”, AND DOES NOT WARRANT THAT THE USE OF THE SOFTWARE, FUNCTIONALITY, THE OPERATION AND/OR CONTENT WILL BE: UNINTERRUPTED, ACCURATE, COMPLETE, FREE FROM ANY SOFTWARE VIRUS OR OTHER HARMFUL COMPONENT.

ALDEBARAN DOES NOT WARRANT THE INTERNAL CHARACTERISTICS, THE COMPATIBILITY FO THE SOFTWARE WITH OTHER SOFTWARE, THE ACCURACY, ADEQUACY, OR COMPLETENESS OF SOTWARE AND ITS RESULT AND DISCLAIMS LIABILITY FOR ERRORS OR OMISSIONS.

ALDEBARAN DISCLAIMS ANY REPRESENTATIONS, WARRANTIES OR CONDITIONS, EXPRESS OR IMPLIED, INCLUDING THOSE OF PERFORMANCE OR MERCHANTABILITY OR RELIABILITY USEFULNESS OR FITNESS FOR A PARTICULAR PURPOSE WITH RESPECT TO THE SOFTWARE AND ITS RESULTS.

3.3 IN NO EVENT WILL ALDEBARAN BE LIABLE FOR ANY DAMAGES (INCLUDING WITHOUT LIMITATION DIRECT, INDIRECT, PUNITIVE, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES, COST OF PROCURING SUBSTITUTE SERVICES, LOST PROFITS, LOSS OF DATA, LOSSES, OR OTHER EXPENSES) ARISING IN CONNECTION WITH THE PROVISION OR USE OF THE SOFTWARE, RELATED SERVICES OR INFORMATION PROVIDED PURSUANT TO THIS AGREEMENT, REGARDLESS OF WHETHER SUCH CLAIMS ARE BASED ON CONTRACT, TORT, STRICT LIABILITY, OR OTHERWISE, OR WHETHER PROVIDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES, LOSSES, OR EXPENSES.

WITHOUT LIMITING THE FOREGOING, THIS LIMITATION OF LIABILITY INCLUDES, BUT IS NOT LIMITED TO, THE UNAVAILABILITY OF THE APPLICATION(S), UNAUTHORIZED ACCESS, ANY FAILURE OF PERFORMANCE, INTERRUPTION, ERROR, OMISSION, DEFECT, DELAY IN OPERATION OR TRANSMISSION, COMPUTER VIRUS, OR SYSTEM FAILURE.

NOTWITHSTANDING ANYTHING TO THE CONTRARY IN THIS AGREEMENT OR ANY STATUTE OR RULE OF LAW TO THE CONTRARY, SUBJECT TO THIS ARTICLE, ALDEBARAN’S CUMULATIVE LIABILITY FOR ALL CLAIMS ARISING OUT OF OR IN CONNECTION WITH THIS AGREEMENT, WHETHER DIRECTLY OR INDIRECTLY, SHALL NOT EXCEED ALL FEES PAID TO ALDEBARAN BY THE LICENSEE FOR THE USE OF THE SOFTWARE. IN THE EVENT THE SOFTWARE IS GRANTED FOR FREE TO THE LICENSEE, ALDEBARAN’S CUMULATIVE LIABILITY FOR ALL CLAIMS ARISING OUT OF OR IN CONNECTION WITH THIS AGREEMENT, WHETHER DIRECTLY OR INDIRECTLY, SHALL NOT EXCEED 100 € (ONE HUNDRED EUROS).

WHENEVER THE ABOVE SECTIONS ARE NOT APPLICABLE UNDER THE APPLYING LAW ALDEBARAN AS SOLE REMEDY SHALL AT ITS OPTION AND EXPENSE EITHER (I) REPAIR THE DEFECTIVE OR INFRINGING SOFTWARE, OR (II) REPLACE THE DEFECTIVE OR INFRINGING SOFTWARE, OR (III) REIMBURSE THE FEE PAID TO ALDEBARAN FOR THE DEFECTIVE OR INFRINGING SOFTWARE. THESE REMEDIES ARE EXCLUSIVE OF ANY OTHER REMEDIES AND ANY OTHER WARRANTY IS EXCLUDED.

ANY INDEMNIFICATION BY ALDEBARAN UNDER THIS WARRANTY IS EXCLUDED IF THE CLAIM IS BASED UPON (I) A MODIFIED VERSION OF THE SOFTWARE FOR WHICH THE CHANGES HAVE NOT BEEN EXPRESSLY AUTHORIZED OR VALIDATED BY ALDEBARAN, OR (II) A COMBINATION, INSTALLATION OR USE OF ANY SOFTWARE COMPONENT EMBEDDED IN THE NAO ROBOT WITH ANY OTHER ELEMENT, MATERIAL OR ITEM THAT IS NOT EXPRESSLY PROVIDED BY ALDEBARAN FOR COMBINATION, INSTALLATION OR USE WITH THE SOFTWARE,
OR (III) A COMBINATION, INSTALLATION OR USE OF THE SOFTWARE WITH ANY OTHER ELEMENT, MATERIAL OR ITEM THAT IS NOT EXPRESSLY AUTHORIZED BY ALDEBARAN FOR COMBINATION, INSTALLATION OR USE WITH THE SOFTWARE, OR (IV) ANY OTHER FAULT OR NEGLIGENCE OF LICENSEE OR A THIRD PARTY.

This warranty does not cover incorrect installation or use by any third party; misuse of the Software voids the warranty.
The Third-Party Software is warranted only as provided in the specific licenses applicable to each.

ARTICLE 4 – INTELLECTUAL PROPERTY

ALDEBARAN is the owner or licensee of the Software. Title, copyright and any other proprietary and intellectual property right in the Software shall remain vested in ALDEBARAN or its licensors. The rights granted to the LICENSEE under this Agreement do not transfer to the LICENSEE title or any proprietary or intellectual property rights to the Software and do not constitute a sale of such rights;

ALDEBARAN shall retain the ownership of all rights in any inventions, discoveries, improvements, ideas, techniques or know-how embodied conceived by ALDEBARAN under this Agreement, including, without limitation, its methods of work, programs, methodologies and related documentation, including any derivative works of software code developed by ALDEBARAN in the course of performing this Agreement as well any knowledge and experience of ALDEBARAN’s directors, staff and consultants.

ARTICLE 5
–

COLLECTION AND USE OF PERSONAL INFORMATION

Privacy of the Licensee is important to ALDEBARAN. Therefore ALDEBARAN is not collecting any personal data except as expressly agreed by the Licensee.

ALDEBARAN will abide any applicable law, rules, or regulations relating to the privacy of personal information. Such data shall only be used for the purposes for which it was provided. Licensee understands that Third Party software may have their own privacy policy which may be less secure than the Aldebaran’s privacy policy.

ALDEBARAN will do its best to ensure that any personal data which may be collected from the Licensee will remain confidential.

Licensee hereby agrees and consents that the following data maybe collected by ALDEBARAN in order permit a network-enhanced services, improve the general quality and/or functionality of its products and/or software, permit development of new version of its products and/or software, fix bug or defect, develop patch and other solution, permit to install new version, update or upgrade, monitor and/or permit the maintenance of Aldebaran products and/or software:
Crash reporting, robot ID, robot health metrics, hardware-specific preferences, application install history, user preferences.

Licensee expressly consents that Aldebaran may generate statistical data from the information provided through the Software without identifying Licensee.
Licensee understands and agrees that, within the course of the use of the software, some voice data and/or video data could transit through ALDEBARAN and/or other third party network.

ARTICLE 6 – NO TRANSFER OR ASSIGNMENT

In no event shall LICENSEE sublicense, assign or otherwise transfer all or part of its rights and obligations under this Agreement to any third party. Any such sublicensing, assignment or transfer shall be null and void, unless expressly agreed to by ALDEBARAN in writing.

ARTICLE 7 – MISCELLEANEOUS

Termination. Either party may terminate this Agreement without advance notice. In case of breach of this Agreement by the Licensee, the authorization to access and use the Software will automatically terminate absent Aldebaran’s written waiver of such breach.

Survival. To the extent applicable, the following articles shall survive the termination, cancellation, expiration, and/or rescission of this Agreement: Articles 3.3, 4, 5, 7 and any provision that expressly states its survival and/or are necessary for the enforcement of this Agreement.

Headings. The headings referred to or used in this Agreement are for reference and convenience purposes only and shall not in any way limit or affect the meaning or interpretation of any of the terms hereof.

Severability. If any of the provisions of this Agreement are held or deemed to be invalid, illegal or unenforceable, the remaining provisions of this Agreement shall be unimpaired, and the invalid, illegal or unenforceable provision shall be replaced by a mutually acceptable provision, which being valid, legal and enforceable, comes closest to the intention of the Parties underlying the invalid, illegal or unenforceable provision.

Waiver. Any failure or delay by either Party in exercising its right under any provisions of the Agreement shall not be construed as a waiver of those rights at any time now or in the future unless an express declaration in writing from the Party concerned.

Governing law and Jurisdiction. Parties agree that all matters arising from or relating to the Software and this Agreement, shall be governed by the laws of France, without regard to conflict of laws principles. In the event of any dispute between the Parties, the Parties agreed to meet to discuss their dispute before resorting to formal dispute resolution procedures.

BY CLICKING “AGREE”, YOU AS LICENSEE ACKNOWLEDGE THAT YOU HAVE READ, UNDERSTAND AND ACCEPT THIS LIMITED END-USER SOFTWARE LICENSE AGREEMENT.

BY CLICKING “AGREE” YOU AS LICENSEE AGREE TO BE BOUND BY ALL OF ITS TERMS AND CONDITIONS OF THIS LIMITED END-USER SOFTWARE LICENSE AGREEMENT.

IF YOU AS A LICENSEE DO NOT AGREE TO ANY TERMS AND CONDITIONS, OF THIS LIMITED END-USER SOFTWARE LICENSE AGREEMENT DO NOT INSTALL OR USE THE SOFTWARE AND CLICK ON “DISAGREE”. By CLICKING ON “DESAGREE” YOU WILL NOT BE ABLE TO USE THE SOFTWARE.

pynaoqi-python-2.6-naoqi-1.14-mac64/allog.py
# This file was automatically generated by SWIG (http://www.swig.org).
# Version 1.3.31
#
# Don’t modify this file, modify the SWIG interface instead.
# This file is compatible with both classic and new-style classes.
import _allog
import new
new_instancemethod = new.instancemethod
try:
_swig_property = property
except NameError:
pass # Python < 2.2 doesn't have 'property'. 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

debug = _allog.debug
info = _allog.info
warning = _allog.warning
error = _allog.error
fatal = _allog.fatal

pynaoqi-python-2.6-naoqi-1.14-mac64/almath.py
# This file was automatically generated by SWIG (http://www.swig.org).
# Version 1.3.31
#
# Don’t modify this file, modify the SWIG interface instead.
# This file is compatible with both classic and new-style classes.
import _almath
import new
new_instancemethod = new.instancemethod
try:
_swig_property = property
except NameError:
pass # Python < 2.2 doesn't have 'property'. 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

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__ = _almath.delete_PySwigIterator
__del__ = lambda self : None;
def value(*args):
“””value(self) -> PyObject”””
return _almath.PySwigIterator_value(*args)
def incr(*args):
“””
incr(self, size_t n=1) -> PySwigIterator
incr(self) -> PySwigIterator
“””
return _almath.PySwigIterator_incr(*args)
def decr(*args):
“””
decr(self, size_t n=1) -> PySwigIterator
decr(self) -> PySwigIterator
“””
return _almath.PySwigIterator_decr(*args)
def distance(*args):
“””distance(self, PySwigIterator x) -> ptrdiff_t”””
return _almath.PySwigIterator_distance(*args)
def equal(*args):
“””equal(self, PySwigIterator x) -> bool”””
return _almath.PySwigIterator_equal(*args)
def copy(*args):
“””copy(self) -> PySwigIterator”””
return _almath.PySwigIterator_copy(*args)
def next(*args):
“””next(self) -> PyObject”””
return _almath.PySwigIterator_next(*args)
def previous(*args):
“””previous(self) -> PyObject”””
return _almath.PySwigIterator_previous(*args)
def advance(*args):
“””advance(self, ptrdiff_t n) -> PySwigIterator”””
return _almath.PySwigIterator_advance(*args)
def __eq__(*args):
“””__eq__(self, PySwigIterator x) -> bool”””
return _almath.PySwigIterator___eq__(*args)
def __ne__(*args):
“””__ne__(self, PySwigIterator x) -> bool”””
return _almath.PySwigIterator___ne__(*args)
def __iadd__(*args):
“””__iadd__(self, ptrdiff_t n) -> PySwigIterator”””
return _almath.PySwigIterator___iadd__(*args)
def __isub__(*args):
“””__isub__(self, ptrdiff_t n) -> PySwigIterator”””
return _almath.PySwigIterator___isub__(*args)
def __add__(*args):
“””__add__(self, ptrdiff_t n) -> PySwigIterator”””
return _almath.PySwigIterator___add__(*args)
def __sub__(*args):
“””
__sub__(self, ptrdiff_t n) -> PySwigIterator
__sub__(self, PySwigIterator x) -> ptrdiff_t
“””
return _almath.PySwigIterator___sub__(*args)
def __iter__(self): return self
PySwigIterator_swigregister = _almath.PySwigIterator_swigregister
PySwigIterator_swigregister(PySwigIterator)
class vectorFloat(_object):
“””Proxy of C++ vectorFloat class”””
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, vectorFloat, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, vectorFloat, name)
def iterator(*args):
“””iterator(self, PyObject PYTHON_SELF) -> PySwigIterator”””
return _almath.vectorFloat_iterator(*args)
def __iter__(self): return self.iterator()
def __nonzero__(*args):
“””__nonzero__(self) -> bool”””
return _almath.vectorFloat___nonzero__(*args)
def __len__(*args):
“””__len__(self) -> size_type”””
return _almath.vectorFloat___len__(*args)
def pop(*args):
“””pop(self) -> value_type”””
return _almath.vectorFloat_pop(*args)
def __getslice__(*args):
“””__getslice__(self, difference_type i, difference_type j) -> vectorFloat”””
return _almath.vectorFloat___getslice__(*args)
def __setslice__(*args):
“””__setslice__(self, difference_type i, difference_type j, vectorFloat v)”””
return _almath.vectorFloat___setslice__(*args)
def __delslice__(*args):
“””__delslice__(self, difference_type i, difference_type j)”””
return _almath.vectorFloat___delslice__(*args)
def __delitem__(*args):
“””__delitem__(self, difference_type i)”””
return _almath.vectorFloat___delitem__(*args)
def __getitem__(*args):
“””__getitem__(self, difference_type i) -> value_type”””
return _almath.vectorFloat___getitem__(*args)
def __setitem__(*args):
“””__setitem__(self, difference_type i, value_type x)”””
return _almath.vectorFloat___setitem__(*args)
def append(*args):
“””append(self, value_type x)”””
return _almath.vectorFloat_append(*args)
def empty(*args):
“””empty(self) -> bool”””
return _almath.vectorFloat_empty(*args)
def size(*args):
“””size(self) -> size_type”””
return _almath.vectorFloat_size(*args)
def clear(*args):
“””clear(self)”””
return _almath.vectorFloat_clear(*args)
def swap(*args):
“””swap(self, vectorFloat v)”””
return _almath.vectorFloat_swap(*args)
def get_allocator(*args):
“””get_allocator(self) -> allocator_type”””
return _almath.vectorFloat_get_allocator(*args)
def begin(*args):
“””
begin(self) -> iterator
begin(self) -> const_iterator
“””
return _almath.vectorFloat_begin(*args)
def end(*args):
“””
end(self) -> iterator
end(self) -> const_iterator
“””
return _almath.vectorFloat_end(*args)
def rbegin(*args):
“””
rbegin(self) -> reverse_iterator
rbegin(self) -> const_reverse_iterator
“””
return _almath.vectorFloat_rbegin(*args)
def rend(*args):
“””
rend(self) -> reverse_iterator
rend(self) -> const_reverse_iterator
“””
return _almath.vectorFloat_rend(*args)
def pop_back(*args):
“””pop_back(self)”””
return _almath.vectorFloat_pop_back(*args)
def erase(*args):
“””
erase(self, iterator pos) -> iterator
erase(self, iterator first, iterator last) -> iterator
“””
return _almath.vectorFloat_erase(*args)
def __init__(self, *args):
“””
__init__(self) -> vectorFloat
__init__(self, vectorFloat ?) -> vectorFloat
__init__(self, size_type size) -> vectorFloat
__init__(self, size_type size, value_type value) -> vectorFloat
“””
this = _almath.new_vectorFloat(*args)
try: self.this.append(this)
except: self.this = this
def push_back(*args):
“””push_back(self, value_type x)”””
return _almath.vectorFloat_push_back(*args)
def front(*args):
“””front(self) -> value_type”””
return _almath.vectorFloat_front(*args)
def back(*args):
“””back(self) -> value_type”””
return _almath.vectorFloat_back(*args)
def assign(*args):
“””assign(self, size_type n, value_type x)”””
return _almath.vectorFloat_assign(*args)
def resize(*args):
“””
resize(self, size_type new_size)
resize(self, size_type new_size, value_type x)
“””
return _almath.vectorFloat_resize(*args)
def insert(*args):
“””
insert(self, iterator pos, value_type x) -> iterator
insert(self, iterator pos, size_type n, value_type x)
“””
return _almath.vectorFloat_insert(*args)
def reserve(*args):
“””reserve(self, size_type n)”””
return _almath.vectorFloat_reserve(*args)
def capacity(*args):
“””capacity(self) -> size_type”””
return _almath.vectorFloat_capacity(*args)
def __repr__(*args):
“””__repr__(self) -> string”””
return _almath.vectorFloat___repr__(*args)
__swig_destroy__ = _almath.delete_vectorFloat
__del__ = lambda self : None;
vectorFloat_swigregister = _almath.vectorFloat_swigregister
vectorFloat_swigregister(vectorFloat)
class vectorPosition2D(_object):
“””Proxy of C++ vectorPosition2D class”””
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, vectorPosition2D, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, vectorPosition2D, name)
def iterator(*args):
“””iterator(self, PyObject PYTHON_SELF) -> PySwigIterator”””
return _almath.vectorPosition2D_iterator(*args)
def __iter__(self): return self.iterator()
def __nonzero__(*args):
“””__nonzero__(self) -> bool”””
return _almath.vectorPosition2D___nonzero__(*args)
def __len__(*args):
“””__len__(self) -> size_type”””
return _almath.vectorPosition2D___len__(*args)
def pop(*args):
“””pop(self) -> value_type”””
return _almath.vectorPosition2D_pop(*args)
def __getslice__(*args):
“””__getslice__(self, difference_type i, difference_type j) -> vectorPosition2D”””
return _almath.vectorPosition2D___getslice__(*args)
def __setslice__(*args):
“””__setslice__(self, difference_type i, difference_type j, vectorPosition2D v)”””
return _almath.vectorPosition2D___setslice__(*args)
def __delslice__(*args):
“””__delslice__(self, difference_type i, difference_type j)”””
return _almath.vectorPosition2D___delslice__(*args)
def __delitem__(*args):
“””__delitem__(self, difference_type i)”””
return _almath.vectorPosition2D___delitem__(*args)
def __getitem__(*args):
“””__getitem__(self, difference_type i) -> value_type”””
return _almath.vectorPosition2D___getitem__(*args)
def __setitem__(*args):
“””__setitem__(self, difference_type i, value_type x)”””
return _almath.vectorPosition2D___setitem__(*args)
def append(*args):
“””append(self, value_type x)”””
return _almath.vectorPosition2D_append(*args)
def empty(*args):
“””empty(self) -> bool”””
return _almath.vectorPosition2D_empty(*args)
def size(*args):
“””size(self) -> size_type”””
return _almath.vectorPosition2D_size(*args)
def clear(*args):
“””clear(self)”””
return _almath.vectorPosition2D_clear(*args)
def swap(*args):
“””swap(self, vectorPosition2D v)”””
return _almath.vectorPosition2D_swap(*args)
def get_allocator(*args):
“””get_allocator(self) -> allocator_type”””
return _almath.vectorPosition2D_get_allocator(*args)
def begin(*args):
“””
begin(self) -> iterator
begin(self) -> const_iterator
“””
return _almath.vectorPosition2D_begin(*args)
def end(*args):
“””
end(self) -> iterator
end(self) -> const_iterator
“””
return _almath.vectorPosition2D_end(*args)
def rbegin(*args):
“””
rbegin(self) -> reverse_iterator
rbegin(self) -> const_reverse_iterator
“””
return _almath.vectorPosition2D_rbegin(*args)
def rend(*args):
“””
rend(self) -> reverse_iterator
rend(self) -> const_reverse_iterator
“””
return _almath.vectorPosition2D_rend(*args)
def pop_back(*args):
“””pop_back(self)”””
return _almath.vectorPosition2D_pop_back(*args)
def erase(*args):
“””
erase(self, iterator pos) -> iterator
erase(self, iterator first, iterator last) -> iterator
“””
return _almath.vectorPosition2D_erase(*args)
def __init__(self, *args):
“””
__init__(self) -> vectorPosition2D
__init__(self, vectorPosition2D ?) -> vectorPosition2D
__init__(self, size_type size) -> vectorPosition2D
__init__(self, size_type size, value_type value) -> vectorPosition2D
“””
this = _almath.new_vectorPosition2D(*args)
try: self.this.append(this)
except: self.this = this
def push_back(*args):
“””push_back(self, value_type x)”””
return _almath.vectorPosition2D_push_back(*args)
def front(*args):
“””front(self) -> value_type”””
return _almath.vectorPosition2D_front(*args)
def back(*args):
“””back(self) -> value_type”””
return _almath.vectorPosition2D_back(*args)
def assign(*args):
“””assign(self, size_type n, value_type x)”””
return _almath.vectorPosition2D_assign(*args)
def resize(*args):
“””
resize(self, size_type new_size)
resize(self, size_type new_size, value_type x)
“””
return _almath.vectorPosition2D_resize(*args)
def insert(*args):
“””
insert(self, iterator pos, value_type x) -> iterator
insert(self, iterator pos, size_type n, value_type x)
“””
return _almath.vectorPosition2D_insert(*args)
def reserve(*args):
“””reserve(self, size_type n)”””
return _almath.vectorPosition2D_reserve(*args)
def capacity(*args):
“””capacity(self) -> size_type”””
return _almath.vectorPosition2D_capacity(*args)
def __repr__(*args):
“””__repr__(self) -> string”””
return _almath.vectorPosition2D___repr__(*args)
__swig_destroy__ = _almath.delete_vectorPosition2D
__del__ = lambda self : None;
vectorPosition2D_swigregister = _almath.vectorPosition2D_swigregister
vectorPosition2D_swigregister(vectorPosition2D)
class vectorPose2D(_object):
“””Proxy of C++ vectorPose2D class”””
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, vectorPose2D, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, vectorPose2D, name)
def iterator(*args):
“””iterator(self, PyObject PYTHON_SELF) -> PySwigIterator”””
return _almath.vectorPose2D_iterator(*args)
def __iter__(self): return self.iterator()
def __nonzero__(*args):
“””__nonzero__(self) -> bool”””
return _almath.vectorPose2D___nonzero__(*args)
def __len__(*args):
“””__len__(self) -> size_type”””
return _almath.vectorPose2D___len__(*args)
def pop(*args):
“””pop(self) -> value_type”””
return _almath.vectorPose2D_pop(*args)
def __getslice__(*args):
“””__getslice__(self, difference_type i, difference_type j) -> vectorPose2D”””
return _almath.vectorPose2D___getslice__(*args)
def __setslice__(*args):
“””__setslice__(self, difference_type i, difference_type j, vectorPose2D v)”””
return _almath.vectorPose2D___setslice__(*args)
def __delslice__(*args):
“””__delslice__(self, difference_type i, difference_type j)”””
return _almath.vectorPose2D___delslice__(*args)
def __delitem__(*args):
“””__delitem__(self, difference_type i)”””
return _almath.vectorPose2D___delitem__(*args)
def __getitem__(*args):
“””__getitem__(self, difference_type i) -> value_type”””
return _almath.vectorPose2D___getitem__(*args)
def __setitem__(*args):
“””__setitem__(self, difference_type i, value_type x)”””
return _almath.vectorPose2D___setitem__(*args)
def append(*args):
“””append(self, value_type x)”””
return _almath.vectorPose2D_append(*args)
def empty(*args):
“””empty(self) -> bool”””
return _almath.vectorPose2D_empty(*args)
def size(*args):
“””size(self) -> size_type”””
return _almath.vectorPose2D_size(*args)
def clear(*args):
“””clear(self)”””
return _almath.vectorPose2D_clear(*args)
def swap(*args):
“””swap(self, vectorPose2D v)”””
return _almath.vectorPose2D_swap(*args)
def get_allocator(*args):
“””get_allocator(self) -> allocator_type”””
return _almath.vectorPose2D_get_allocator(*args)
def begin(*args):
“””
begin(self) -> iterator
begin(self) -> const_iterator
“””
return _almath.vectorPose2D_begin(*args)
def end(*args):
“””
end(self) -> iterator
end(self) -> const_iterator
“””
return _almath.vectorPose2D_end(*args)
def rbegin(*args):
“””
rbegin(self) -> reverse_iterator
rbegin(self) -> const_reverse_iterator
“””
return _almath.vectorPose2D_rbegin(*args)
def rend(*args):
“””
rend(self) -> reverse_iterator
rend(self) -> const_reverse_iterator
“””
return _almath.vectorPose2D_rend(*args)
def pop_back(*args):
“””pop_back(self)”””
return _almath.vectorPose2D_pop_back(*args)
def erase(*args):
“””
erase(self, iterator pos) -> iterator
erase(self, iterator first, iterator last) -> iterator
“””
return _almath.vectorPose2D_erase(*args)
def __init__(self, *args):
“””
__init__(self) -> vectorPose2D
__init__(self, vectorPose2D ?) -> vectorPose2D
__init__(self, size_type size) -> vectorPose2D
__init__(self, size_type size, value_type value) -> vectorPose2D
“””
this = _almath.new_vectorPose2D(*args)
try: self.this.append(this)
except: self.this = this
def push_back(*args):
“””push_back(self, value_type x)”””
return _almath.vectorPose2D_push_back(*args)
def front(*args):
“””front(self) -> value_type”””
return _almath.vectorPose2D_front(*args)
def back(*args):
“””back(self) -> value_type”””
return _almath.vectorPose2D_back(*args)
def assign(*args):
“””assign(self, size_type n, value_type x)”””
return _almath.vectorPose2D_assign(*args)
def resize(*args):
“””
resize(self, size_type new_size)
resize(self, size_type new_size, value_type x)
“””
return _almath.vectorPose2D_resize(*args)
def insert(*args):
“””
insert(self, iterator pos, value_type x) -> iterator
insert(self, iterator pos, size_type n, value_type x)
“””
return _almath.vectorPose2D_insert(*args)
def reserve(*args):
“””reserve(self, size_type n)”””
return _almath.vectorPose2D_reserve(*args)
def capacity(*args):
“””capacity(self) -> size_type”””
return _almath.vectorPose2D_capacity(*args)
def __repr__(*args):
“””__repr__(self) -> string”””
return _almath.vectorPose2D___repr__(*args)
__swig_destroy__ = _almath.delete_vectorPose2D
__del__ = lambda self : None;
vectorPose2D_swigregister = _almath.vectorPose2D_swigregister
vectorPose2D_swigregister(vectorPose2D)
class vectorPosition6D(_object):
“””Proxy of C++ vectorPosition6D class”””
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, vectorPosition6D, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, vectorPosition6D, name)
def iterator(*args):
“””iterator(self, PyObject PYTHON_SELF) -> PySwigIterator”””
return _almath.vectorPosition6D_iterator(*args)
def __iter__(self): return self.iterator()
def __nonzero__(*args):
“””__nonzero__(self) -> bool”””
return _almath.vectorPosition6D___nonzero__(*args)
def __len__(*args):
“””__len__(self) -> size_type”””
return _almath.vectorPosition6D___len__(*args)
def pop(*args):
“””pop(self) -> value_type”””
return _almath.vectorPosition6D_pop(*args)
def __getslice__(*args):
“””__getslice__(self, difference_type i, difference_type j) -> vectorPosition6D”””
return _almath.vectorPosition6D___getslice__(*args)
def __setslice__(*args):
“””__setslice__(self, difference_type i, difference_type j, vectorPosition6D v)”””
return _almath.vectorPosition6D___setslice__(*args)
def __delslice__(*args):
“””__delslice__(self, difference_type i, difference_type j)”””
return _almath.vectorPosition6D___delslice__(*args)
def __delitem__(*args):
“””__delitem__(self, difference_type i)”””
return _almath.vectorPosition6D___delitem__(*args)
def __getitem__(*args):
“””__getitem__(self, difference_type i) -> value_type”””
return _almath.vectorPosition6D___getitem__(*args)
def __setitem__(*args):
“””__setitem__(self, difference_type i, value_type x)”””
return _almath.vectorPosition6D___setitem__(*args)
def append(*args):
“””append(self, value_type x)”””
return _almath.vectorPosition6D_append(*args)
def empty(*args):
“””empty(self) -> bool”””
return _almath.vectorPosition6D_empty(*args)
def size(*args):
“””size(self) -> size_type”””
return _almath.vectorPosition6D_size(*args)
def clear(*args):
“””clear(self)”””
return _almath.vectorPosition6D_clear(*args)
def swap(*args):
“””swap(self, vectorPosition6D v)”””
return _almath.vectorPosition6D_swap(*args)
def get_allocator(*args):
“””get_allocator(self) -> allocator_type”””
return _almath.vectorPosition6D_get_allocator(*args)
def begin(*args):
“””
begin(self) -> iterator
begin(self) -> const_iterator
“””
return _almath.vectorPosition6D_begin(*args)
def end(*args):
“””
end(self) -> iterator
end(self) -> const_iterator
“””
return _almath.vectorPosition6D_end(*args)
def rbegin(*args):
“””
rbegin(self) -> reverse_iterator
rbegin(self) -> const_reverse_iterator
“””
return _almath.vectorPosition6D_rbegin(*args)
def rend(*args):
“””
rend(self) -> reverse_iterator
rend(self) -> const_reverse_iterator
“””
return _almath.vectorPosition6D_rend(*args)
def pop_back(*args):
“””pop_back(self)”””
return _almath.vectorPosition6D_pop_back(*args)
def erase(*args):
“””
erase(self, iterator pos) -> iterator
erase(self, iterator first, iterator last) -> iterator
“””
return _almath.vectorPosition6D_erase(*args)
def __init__(self, *args):
“””
__init__(self) -> vectorPosition6D
__init__(self, vectorPosition6D ?) -> vectorPosition6D
__init__(self, size_type size) -> vectorPosition6D
__init__(self, size_type size, value_type value) -> vectorPosition6D
“””
this = _almath.new_vectorPosition6D(*args)
try: self.this.append(this)
except: self.this = this
def push_back(*args):
“””push_back(self, value_type x)”””
return _almath.vectorPosition6D_push_back(*args)
def front(*args):
“””front(self) -> value_type”””
return _almath.vectorPosition6D_front(*args)
def back(*args):
“””back(self) -> value_type”””
return _almath.vectorPosition6D_back(*args)
def assign(*args):
“””assign(self, size_type n, value_type x)”””
return _almath.vectorPosition6D_assign(*args)
def resize(*args):
“””
resize(self, size_type new_size)
resize(self, size_type new_size, value_type x)
“””
return _almath.vectorPosition6D_resize(*args)
def insert(*args):
“””
insert(self, iterator pos, value_type x) -> iterator
insert(self, iterator pos, size_type n, value_type x)
“””
return _almath.vectorPosition6D_insert(*args)
def reserve(*args):
“””reserve(self, size_type n)”””
return _almath.vectorPosition6D_reserve(*args)
def capacity(*args):
“””capacity(self) -> size_type”””
return _almath.vectorPosition6D_capacity(*args)
def __repr__(*args):
“””__repr__(self) -> string”””
return _almath.vectorPosition6D___repr__(*args)
__swig_destroy__ = _almath.delete_vectorPosition6D
__del__ = lambda self : None;
vectorPosition6D_swigregister = _almath.vectorPosition6D_swigregister
vectorPosition6D_swigregister(vectorPosition6D)
class Pose2D(_object):
“””Proxy of C++ Pose2D class”””
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, Pose2D, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, Pose2D, name)
__swig_setmethods__[“x”] = _almath.Pose2D_x_set
__swig_getmethods__[“x”] = _almath.Pose2D_x_get
if _newclass:x = _swig_property(_almath.Pose2D_x_get, _almath.Pose2D_x_set)
__swig_setmethods__[“y”] = _almath.Pose2D_y_set
__swig_getmethods__[“y”] = _almath.Pose2D_y_get
if _newclass:y = _swig_property(_almath.Pose2D_y_get, _almath.Pose2D_y_set)
__swig_setmethods__[“theta”] = _almath.Pose2D_theta_set
__swig_getmethods__[“theta”] = _almath.Pose2D_theta_get
if _newclass:theta = _swig_property(_almath.Pose2D_theta_get, _almath.Pose2D_theta_set)
def __init__(self, *args):
“””
__init__(self) -> Pose2D
__init__(self, float pInit) -> Pose2D
__init__(self, float pX, float pY, float pTheta) -> Pose2D
__init__(self, vectorFloat pFloats) -> Pose2D
“””
this = _almath.new_Pose2D(*args)
try: self.this.append(this)
except: self.this = this
def __add__(*args):
“””__add__(self, Pose2D pPos2) -> Pose2D”””
return _almath.Pose2D___add__(*args)
def __sub__(*args):
“””__sub__(self, Pose2D pPos2) -> Pose2D”””
return _almath.Pose2D___sub__(*args)
def __pos__(*args):
“””__pos__(self) -> Pose2D”””
return _almath.Pose2D___pos__(*args)
def __neg__(*args):
“””__neg__(self) -> Pose2D”””
return _almath.Pose2D___neg__(*args)
def __iadd__(*args):
“””__iadd__(self, Pose2D pPos2) -> Pose2D”””
return _almath.Pose2D___iadd__(*args)
def __isub__(*args):
“””__isub__(self, Pose2D pPos2) -> Pose2D”””
return _almath.Pose2D___isub__(*args)
def __eq__(*args):
“””__eq__(self, Pose2D pPos2) -> bool”””
return _almath.Pose2D___eq__(*args)
def __ne__(*args):
“””__ne__(self, Pose2D pPos2) -> bool”””
return _almath.Pose2D___ne__(*args)
def __mul__(*args):
“””
__mul__(self, Pose2D pPos2) -> Pose2D
__mul__(self, float pVal) -> Pose2D
“””
return _almath.Pose2D___mul__(*args)
def __div__(*args):
“””__div__(self, float pVal) -> Pose2D”””
return _almath.Pose2D___div__(*args)
def __imul__(*args):
“””
__imul__(self, Pose2D pPos2) -> Pose2D
__imul__(self, float pVal) -> Pose2D
“””
return _almath.Pose2D___imul__(*args)
def __idiv__(*args):
“””__idiv__(self, float pVal) -> Pose2D”””
return _almath.Pose2D___idiv__(*args)
def distanceSquared(*args):
“””distanceSquared(self, Pose2D pPos2) -> float”””
return _almath.Pose2D_distanceSquared(*args)
def distance(*args):
“””distance(self, Pose2D pPos2) -> float”””
return _almath.Pose2D_distance(*args)
def inverse(*args):
“””inverse(self) -> Pose2D”””
return _almath.Pose2D_inverse(*args)
def isNear(*args):
“””
isNear(self, Pose2D pPos2, float pEpsilon=0.0001f) -> bool
isNear(self, Pose2D pPos2) -> bool
“””
return _almath.Pose2D_isNear(*args)
def toVector(*args):
“””toVector(self) -> vectorFloat”””
return _almath.Pose2D_toVector(*args)
def __repr__(*args):
“””__repr__(self) -> char”””
return _almath.Pose2D___repr__(*args)
def __rmul__(*args):
“””__rmul__(self, float lhs) -> Pose2D”””
return _almath.Pose2D___rmul__(*args)
__swig_destroy__ = _almath.delete_Pose2D
__del__ = lambda self : None;
Pose2D_swigregister = _almath.Pose2D_swigregister
Pose2D_swigregister(Pose2D)
cvar = _almath.cvar
AXIS_MASK_X = cvar.AXIS_MASK_X
AXIS_MASK_Y = cvar.AXIS_MASK_Y
AXIS_MASK_XY = cvar.AXIS_MASK_XY
AXIS_MASK_Z = cvar.AXIS_MASK_Z
AXIS_MASK_WX = cvar.AXIS_MASK_WX
AXIS_MASK_WY = cvar.AXIS_MASK_WY
AXIS_MASK_WZ = cvar.AXIS_MASK_WZ
AXIS_MASK_WYWZ = cvar.AXIS_MASK_WYWZ
AXIS_MASK_ALL = cvar.AXIS_MASK_ALL
AXIS_MASK_VEL = cvar.AXIS_MASK_VEL
AXIS_MASK_ROT = cvar.AXIS_MASK_ROT
AXIS_MASK_NONE = cvar.AXIS_MASK_NONE
class Position2D(_object):
“””Proxy of C++ Position2D class”””
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, Position2D, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, Position2D, name)
__swig_setmethods__[“x”] = _almath.Position2D_x_set
__swig_getmethods__[“x”] = _almath.Position2D_x_get
if _newclass:x = _swig_property(_almath.Position2D_x_get, _almath.Position2D_x_set)
__swig_setmethods__[“y”] = _almath.Position2D_y_set
__swig_getmethods__[“y”] = _almath.Position2D_y_get
if _newclass:y = _swig_property(_almath.Position2D_y_get, _almath.Position2D_y_set)
def __init__(self, *args):
“””
__init__(self) -> Position2D
__init__(self, float pInit) -> Position2D
__init__(self, float pX, float pY) -> Position2D
__init__(self, vectorFloat pFloats) -> Position2D
“””
this = _almath.new_Position2D(*args)
try: self.this.append(this)
except: self.this = this
def __add__(*args):
“””__add__(self, Position2D pPos2) -> Position2D”””
return _almath.Position2D___add__(*args)
def __sub__(*args):
“””__sub__(self, Position2D pPos2) -> Position2D”””
return _almath.Position2D___sub__(*args)
def __pos__(*args):
“””__pos__(self) -> Position2D”””
return _almath.Position2D___pos__(*args)
def __neg__(*args):
“””__neg__(self) -> Position2D”””
return _almath.Position2D___neg__(*args)
def __iadd__(*args):
“””__iadd__(self, Position2D pPos2) -> Position2D”””
return _almath.Position2D___iadd__(*args)
def __isub__(*args):
“””__isub__(self, Position2D pPos2) -> Position2D”””
return _almath.Position2D___isub__(*args)
def __eq__(*args):
“””__eq__(self, Position2D pPos2) -> bool”””
return _almath.Position2D___eq__(*args)
def __ne__(*args):
“””__ne__(self, Position2D pPos2) -> bool”””
return _almath.Position2D___ne__(*args)
def __mul__(*args):
“””__mul__(self, float pVal) -> Position2D”””
return _almath.Position2D___mul__(*args)
def __div__(*args):
“””__div__(self, float pVal) -> Position2D”””
return _almath.Position2D___div__(*args)
def __imul__(*args):
“””__imul__(self, float pVal) -> Position2D”””
return _almath.Position2D___imul__(*args)
def __idiv__(*args):
“””__idiv__(self, float pVal) -> Position2D”””
return _almath.Position2D___idiv__(*args)
def distanceSquared(*args):
“””distanceSquared(self, Position2D pPos2) -> float”””
return _almath.Position2D_distanceSquared(*args)
def distance(*args):
“””distance(self, Position2D pPos2) -> float”””
return _almath.Position2D_distance(*args)
def isNear(*args):
“””
isNear(self, Position2D pPos2, float pEpsilon=0.0001f) -> bool
isNear(self, Position2D pPos2) -> bool
“””
return _almath.Position2D_isNear(*args)
def norm(*args):
“””norm(self) -> float”””
return _almath.Position2D_norm(*args)
def normalize(*args):
“””normalize(self) -> Position2D”””
return _almath.Position2D_normalize(*args)
def crossProduct(*args):
“””crossProduct(self, Position2D pPos2) -> float”””
return _almath.Position2D_crossProduct(*args)
def toVector(*args):
“””toVector(self) -> vectorFloat”””
return _almath.Position2D_toVector(*args)
def __repr__(*args):
“””__repr__(self) -> char”””
return _almath.Position2D___repr__(*args)
def __rmul__(*args):
“””__rmul__(self, float lhs) -> Position2D”””
return _almath.Position2D___rmul__(*args)
__swig_destroy__ = _almath.delete_Position2D
__del__ = lambda self : None;
Position2D_swigregister = _almath.Position2D_swigregister
Position2D_swigregister(Position2D)
def pose2DInverse(*args):
“””
pose2DInverse(Pose2D pPos) -> Pose2D
pose2DInverse(Pose2D pPos, Pose2D pRes)
“””
return _almath.pose2DInverse(*args)
class Position3D(_object):
“””Proxy of C++ Position3D class”””
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, Position3D, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, Position3D, name)
__swig_setmethods__[“x”] = _almath.Position3D_x_set
__swig_getmethods__[“x”] = _almath.Position3D_x_get
if _newclass:x = _swig_property(_almath.Position3D_x_get, _almath.Position3D_x_set)
__swig_setmethods__[“y”] = _almath.Position3D_y_set
__swig_getmethods__[“y”] = _almath.Position3D_y_get
if _newclass:y = _swig_property(_almath.Position3D_y_get, _almath.Position3D_y_set)
__swig_setmethods__[“z”] = _almath.Position3D_z_set
__swig_getmethods__[“z”] = _almath.Position3D_z_get
if _newclass:z = _swig_property(_almath.Position3D_z_get, _almath.Position3D_z_set)
def __init__(self, *args):
“””
__init__(self) -> Position3D
__init__(self, float pInit) -> Position3D
__init__(self, float pX, float pY, float pZ) -> Position3D
__init__(self, vectorFloat pFloats) -> Position3D
“””
this = _almath.new_Position3D(*args)
try: self.this.append(this)
except: self.this = this
def __add__(*args):
“””__add__(self, Position3D pPos2) -> Position3D”””
return _almath.Position3D___add__(*args)
def __sub__(*args):
“””__sub__(self, Position3D pPos2) -> Position3D”””
return _almath.Position3D___sub__(*args)
def __pos__(*args):
“””__pos__(self) -> Position3D”””
return _almath.Position3D___pos__(*args)
def __neg__(*args):
“””__neg__(self) -> Position3D”””
return _almath.Position3D___neg__(*args)
def __iadd__(*args):
“””__iadd__(self, Position3D pPos2) -> Position3D”””
return _almath.Position3D___iadd__(*args)
def __isub__(*args):
“””__isub__(self, Position3D pPos2) -> Position3D”””
return _almath.Position3D___isub__(*args)
def __eq__(*args):
“””__eq__(self, Position3D pPos2) -> bool”””
return _almath.Position3D___eq__(*args)
def __ne__(*args):
“””__ne__(self, Position3D pPos2) -> bool”””
return _almath.Position3D___ne__(*args)
def __mul__(*args):
“””__mul__(self, float pVal) -> Position3D”””
return _almath.Position3D___mul__(*args)
def __div__(*args):
“””__div__(self, float pVal) -> Position3D”””
return _almath.Position3D___div__(*args)
def __imul__(*args):
“””__imul__(self, float pVal) -> Position3D”””
return _almath.Position3D___imul__(*args)
def __idiv__(*args):
“””__idiv__(self, float pVal) -> Position3D”””
return _almath.Position3D___idiv__(*args)
def distanceSquared(*args):
“””distanceSquared(self, Position3D pPos2) -> float”””
return _almath.Position3D_distanceSquared(*args)
def distance(*args):
“””distance(self, Position3D pPos2) -> float”””
return _almath.Position3D_distance(*args)
def isNear(*args):
“””
isNear(self, Position3D pPos2, float pEpsilon=0.0001f) -> bool
isNear(self, Position3D pPos2) -> bool
“””
return _almath.Position3D_isNear(*args)
def norm(*args):
“””norm(self) -> float”””
return _almath.Position3D_norm(*args)
def normalize(*args):
“””normalize(self) -> Position3D”””
return _almath.Position3D_normalize(*args)
def dotProduct(*args):
“””dotProduct(self, Position3D pPos2) -> float”””
return _almath.Position3D_dotProduct(*args)
def crossProduct(*args):
“””crossProduct(self, Position3D pPos2) -> Position3D”””
return _almath.Position3D_crossProduct(*args)
def toVector(*args):
“””toVector(self) -> vectorFloat”””
return _almath.Position3D_toVector(*args)
def __repr__(*args):
“””__repr__(self) -> char”””
return _almath.Position3D___repr__(*args)
def __rmul__(*args):
“””__rmul__(self, float lhs) -> Position3D”””
return _almath.Position3D___rmul__(*args)
__swig_destroy__ = _almath.delete_Position3D
__del__ = lambda self : None;
Position3D_swigregister = _almath.Position3D_swigregister
Position3D_swigregister(Position3D)

def __div__(*args):
“””__div__(float pM, Position3D pPos1) -> Position3D”””
return _almath.__div__(*args)
def dotProduct(*args):
“””dotProduct(Position3D pPos1, Position3D pPos2) -> float”””
return _almath.dotProduct(*args)
class Position6D(_object):
“””Proxy of C++ Position6D class”””
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, Position6D, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, Position6D, name)
__swig_setmethods__[“x”] = _almath.Position6D_x_set
__swig_getmethods__[“x”] = _almath.Position6D_x_get
if _newclass:x = _swig_property(_almath.Position6D_x_get, _almath.Position6D_x_set)
__swig_setmethods__[“y”] = _almath.Position6D_y_set
__swig_getmethods__[“y”] = _almath.Position6D_y_get
if _newclass:y = _swig_property(_almath.Position6D_y_get, _almath.Position6D_y_set)
__swig_setmethods__[“z”] = _almath.Position6D_z_set
__swig_getmethods__[“z”] = _almath.Position6D_z_get
if _newclass:z = _swig_property(_almath.Position6D_z_get, _almath.Position6D_z_set)
__swig_setmethods__[“wx”] = _almath.Position6D_wx_set
__swig_getmethods__[“wx”] = _almath.Position6D_wx_get
if _newclass:wx = _swig_property(_almath.Position6D_wx_get, _almath.Position6D_wx_set)
__swig_setmethods__[“wy”] = _almath.Position6D_wy_set
__swig_getmethods__[“wy”] = _almath.Position6D_wy_get
if _newclass:wy = _swig_property(_almath.Position6D_wy_get, _almath.Position6D_wy_set)
__swig_setmethods__[“wz”] = _almath.Position6D_wz_set
__swig_getmethods__[“wz”] = _almath.Position6D_wz_get
if _newclass:wz = _swig_property(_almath.Position6D_wz_get, _almath.Position6D_wz_set)
def __init__(self, *args):
“””
__init__(self) -> Position6D
__init__(self, float pInit) -> Position6D
__init__(self, float pX, float pY, float pZ, float pWx, float pWy,
float pWz) -> Position6D
__init__(self, vectorFloat pFloats) -> Position6D
“””
this = _almath.new_Position6D(*args)
try: self.this.append(this)
except: self.this = this
def __add__(*args):
“””__add__(self, Position6D pPos2) -> Position6D”””
return _almath.Position6D___add__(*args)
def __sub__(*args):
“””__sub__(self, Position6D pPos2) -> Position6D”””
return _almath.Position6D___sub__(*args)
def __pos__(*args):
“””__pos__(self) -> Position6D”””
return _almath.Position6D___pos__(*args)
def __neg__(*args):
“””__neg__(self) -> Position6D”””
return _almath.Position6D___neg__(*args)
def __iadd__(*args):
“””__iadd__(self, Position6D pPos2) -> Position6D”””
return _almath.Position6D___iadd__(*args)
def __isub__(*args):
“””__isub__(self, Position6D pPos2) -> Position6D”””
return _almath.Position6D___isub__(*args)
def __eq__(*args):
“””__eq__(self, Position6D pPos2) -> bool”””
return _almath.Position6D___eq__(*args)
def __ne__(*args):
“””__ne__(self, Position6D pPos2) -> bool”””
return _almath.Position6D___ne__(*args)
def __mul__(*args):
“””__mul__(self, float pVal) -> Position6D”””
return _almath.Position6D___mul__(*args)
def __div__(*args):
“””__div__(self, float pVal) -> Position6D”””
return _almath.Position6D___div__(*args)
def __imul__(*args):
“””__imul__(self, float pVal) -> Position6D”””
return _almath.Position6D___imul__(*args)
def __idiv__(*args):
“””__idiv__(self, float pVal) -> Position6D”””
return _almath.Position6D___idiv__(*args)
def isNear(*args):
“””
isNear(self, Position6D pPos2, float pEpsilon=0.0001f) -> bool
isNear(self, Position6D pPos2) -> bool
“””
return _almath.Position6D_isNear(*args)
def distanceSquared(*args):
“””distanceSquared(self, Position6D pPos2) -> float”””
return _almath.Position6D_distanceSquared(*args)
def distance(*args):
“””distance(self, Position6D pPos2) -> float”””
return _almath.Position6D_distance(*args)
def norm(*args):
“””norm(self) -> float”””
return _almath.Position6D_norm(*args)
def toVector(*args):
“””toVector(self) -> vectorFloat”””
return _almath.Position6D_toVector(*args)
def __repr__(*args):
“””__repr__(self) -> char”””
return _almath.Position6D___repr__(*args)
def __rmul__(*args):
“””__rmul__(self, float lhs) -> Position6D”””
return _almath.Position6D___rmul__(*args)
__swig_destroy__ = _almath.delete_Position6D
__del__ = lambda self : None;
Position6D_swigregister = _almath.Position6D_swigregister
Position6D_swigregister(Position6D)
def crossProduct(*args):
“””
crossProduct(Position2D pPos1, Position2D pPos2) -> float
crossProduct(Position2D pPos1, Position2D pPos2, float pRes)
crossProduct(Position3D pPos1, Position3D pPos2) -> Position3D
crossProduct(Position3D pPos1, Position3D pPos2, Position3D pRes)
“””
return _almath.crossProduct(*args)
class PositionAndVelocity(_object):
“””Proxy of C++ PositionAndVelocity class”””
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, PositionAndVelocity, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, PositionAndVelocity, name)
__swig_setmethods__[“q”] = _almath.PositionAndVelocity_q_set
__swig_getmethods__[“q”] = _almath.PositionAndVelocity_q_get
if _newclass:q = _swig_property(_almath.PositionAndVelocity_q_get, _almath.PositionAndVelocity_q_set)
__swig_setmethods__[“dq”] = _almath.PositionAndVelocity_dq_set
__swig_getmethods__[“dq”] = _almath.PositionAndVelocity_dq_get
if _newclass:dq = _swig_property(_almath.PositionAndVelocity_dq_get, _almath.PositionAndVelocity_dq_set)
def __init__(self, *args):
“””
__init__(self, float pq=0.0f, float pdq=0.0f) -> PositionAndVelocity
__init__(self, float pq=0.0f) -> PositionAndVelocity
__init__(self) -> PositionAndVelocity
“””
this = _almath.new_PositionAndVelocity(*args)
try: self.this.append(this)
except: self.this = this
def isNear(*args):
“””
isNear(self, PositionAndVelocity pDat2, float pEpsilon=0.0001f) -> bool
isNear(self, PositionAndVelocity pDat2) -> bool
“””
return _almath.PositionAndVelocity_isNear(*args)
def __repr__(*args):
“””__repr__(self) -> char”””
return _almath.PositionAndVelocity___repr__(*args)
__swig_destroy__ = _almath.delete_PositionAndVelocity
__del__ = lambda self : None;
PositionAndVelocity_swigregister = _almath.PositionAndVelocity_swigregister
PositionAndVelocity_swigregister(PositionAndVelocity)
def distanceSquared(*args):
“””
distanceSquared(Pose2D pPos1, Pose2D pPos2) -> float
distanceSquared(Position2D pPos1, Position2D pPos2) -> float
distanceSquared(Position3D pPos1, Position3D pPos2) -> float
distanceSquared(Position6D pPos1, Position6D pPos2) -> float
“””
return _almath.distanceSquared(*args)
def distance(*args):
“””
distance(Pose2D pPos1, Pose2D pPos2) -> float
distance(Position2D pPos1, Position2D pPos2) -> float
distance(Position3D pPos1, Position3D pPos2) -> float
distance(Position6D pPos1, Position6D pPos2) -> float
“””
return _almath.distance(*args)
class Quaternion(_object):
“””Proxy of C++ Quaternion class”””
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, Quaternion, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, Quaternion, name)
__swig_setmethods__[“w”] = _almath.Quaternion_w_set
__swig_getmethods__[“w”] = _almath.Quaternion_w_get
if _newclass:w = _swig_property(_almath.Quaternion_w_get, _almath.Quaternion_w_set)
__swig_setmethods__[“x”] = _almath.Quaternion_x_set
__swig_getmethods__[“x”] = _almath.Quaternion_x_get
if _newclass:x = _swig_property(_almath.Quaternion_x_get, _almath.Quaternion_x_set)
__swig_setmethods__[“y”] = _almath.Quaternion_y_set
__swig_getmethods__[“y”] = _almath.Quaternion_y_get
if _newclass:y = _swig_property(_almath.Quaternion_y_get, _almath.Quaternion_y_set)
__swig_setmethods__[“z”] = _almath.Quaternion_z_set
__swig_getmethods__[“z”] = _almath.Quaternion_z_get
if _newclass:z = _swig_property(_almath.Quaternion_z_get, _almath.Quaternion_z_set)
def __init__(self, *args):
“””
__init__(self) -> Quaternion
__init__(self, float pW, float pX, float pY, float pZ) -> Quaternion
__init__(self, vectorFloat pFloats) -> Quaternion
“””
this = _almath.new_Quaternion(*args)
try: self.this.append(this)
except: self.this = this
def __mul__(*args):
“””__mul__(self, Quaternion pQua2) -> Quaternion”””
return _almath.Quaternion___mul__(*args)
def __eq__(*args):
“””__eq__(self, Quaternion pQua2) -> bool”””
return _almath.Quaternion___eq__(*args)
def __ne__(*args):
“””__ne__(self, Quaternion pQua2) -> bool”””
return _almath.Quaternion___ne__(*args)
def __imul__(*args):
“””
__imul__(self, Quaternion pQu2) -> Quaternion
__imul__(self, float pVal) -> Quaternion
“””
return _almath.Quaternion___imul__(*args)
def __idiv__(*args):
“””__idiv__(self, float pVal) -> Quaternion”””
return _almath.Quaternion___idiv__(*args)
def isNear(*args):
“””
isNear(self, Quaternion pQua2, float pEpsilon=0.0001f) -> bool
isNear(self, Quaternion pQua2) -> bool
“””
return _almath.Quaternion_isNear(*args)
def norm(*args):
“””norm(self) -> float”””
return _almath.Quaternion_norm(*args)
def normalize(*args):
“””normalize(self) -> Quaternion”””
return _almath.Quaternion_normalize(*args)
def inverse(*args):
“””inverse(self) -> Quaternion”””
return _almath.Quaternion_inverse(*args)
def fromAngleAndAxisRotation(*args):
“””fromAngleAndAxisRotation(float pAngle, float pAxisX, float pAxisY, float pAxisZ) -> Quaternion”””
return _almath.Quaternion_fromAngleAndAxisRotation(*args)
if _newclass:fromAngleAndAxisRotation = staticmethod(fromAngleAndAxisRotation)
__swig_getmethods__[“fromAngleAndAxisRotation”] = lambda x: fromAngleAndAxisRotation
def toVector(*args):
“””toVector(self) -> vectorFloat”””
return _almath.Quaternion_toVector(*args)
def __repr__(*args):
“””__repr__(self) -> char”””
return _almath.Quaternion___repr__(*args)
__swig_destroy__ = _almath.delete_Quaternion
__del__ = lambda self : None;
Quaternion_swigregister = _almath.Quaternion_swigregister
Quaternion_swigregister(Quaternion)
def Quaternion_fromAngleAndAxisRotation(*args):
“””Quaternion_fromAngleAndAxisRotation(float pAngle, float pAxisX, float pAxisY, float pAxisZ) -> Quaternion”””
return _almath.Quaternion_fromAngleAndAxisRotation(*args)

def quaternionFromAngleAndAxisRotation(*args):
“””quaternionFromAngleAndAxisRotation(float pAngle, float pAxisX, float pAxisY, float pAxisZ) -> Quaternion”””
return _almath.quaternionFromAngleAndAxisRotation(*args)
def angleAndAxisRotationFromQuaternion(*args):
“””
angleAndAxisRotationFromQuaternion(Quaternion pQuaternion, float pAngle, float pAxisX,
float pAxisY, float pAxisZ)
“””
return _almath.angleAndAxisRotationFromQuaternion(*args)
class Rotation(_object):
“””Proxy of C++ Rotation class”””
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, Rotation, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, Rotation, name)
__swig_setmethods__[“r1_c1”] = _almath.Rotation_r1_c1_set
__swig_getmethods__[“r1_c1”] = _almath.Rotation_r1_c1_get
if _newclass:r1_c1 = _swig_property(_almath.Rotation_r1_c1_get, _almath.Rotation_r1_c1_set)
__swig_setmethods__[“r1_c2”] = _almath.Rotation_r1_c2_set
__swig_getmethods__[“r1_c2”] = _almath.Rotation_r1_c2_get
if _newclass:r1_c2 = _swig_property(_almath.Rotation_r1_c2_get, _almath.Rotation_r1_c2_set)
__swig_setmethods__[“r1_c3”] = _almath.Rotation_r1_c3_set
__swig_getmethods__[“r1_c3”] = _almath.Rotation_r1_c3_get
if _newclass:r1_c3 = _swig_property(_almath.Rotation_r1_c3_get, _almath.Rotation_r1_c3_set)
__swig_setmethods__[“r2_c1”] = _almath.Rotation_r2_c1_set
__swig_getmethods__[“r2_c1”] = _almath.Rotation_r2_c1_get
if _newclass:r2_c1 = _swig_property(_almath.Rotation_r2_c1_get, _almath.Rotation_r2_c1_set)
__swig_setmethods__[“r2_c2”] = _almath.Rotation_r2_c2_set
__swig_getmethods__[“r2_c2”] = _almath.Rotation_r2_c2_get
if _newclass:r2_c2 = _swig_property(_almath.Rotation_r2_c2_get, _almath.Rotation_r2_c2_set)
__swig_setmethods__[“r2_c3”] = _almath.Rotation_r2_c3_set
__swig_getmethods__[“r2_c3”] = _almath.Rotation_r2_c3_get
if _newclass:r2_c3 = _swig_property(_almath.Rotation_r2_c3_get, _almath.Rotation_r2_c3_set)
__swig_setmethods__[“r3_c1”] = _almath.Rotation_r3_c1_set
__swig_getmethods__[“r3_c1”] = _almath.Rotation_r3_c1_get
if _newclass:r3_c1 = _swig_property(_almath.Rotation_r3_c1_get, _almath.Rotation_r3_c1_set)
__swig_setmethods__[“r3_c2”] = _almath.Rotation_r3_c2_set
__swig_getmethods__[“r3_c2”] = _almath.Rotation_r3_c2_get
if _newclass:r3_c2 = _swig_property(_almath.Rotation_r3_c2_get, _almath.Rotation_r3_c2_set)
__swig_setmethods__[“r3_c3”] = _almath.Rotation_r3_c3_set
__swig_getmethods__[“r3_c3”] = _almath.Rotation_r3_c3_get
if _newclass:r3_c3 = _swig_property(_almath.Rotation_r3_c3_get, _almath.Rotation_r3_c3_set)
def __init__(self, *args):
“””
__init__(self) -> Rotation
__init__(self, vectorFloat pFloats) -> Rotation
“””
this = _almath.new_Rotation(*args)
try: self.this.append(this)
except: self.this = this
def __imul__(*args):
“””__imul__(self, Rotation pRot2) -> Rotation”””
return _almath.Rotation___imul__(*args)
def __eq__(*args):
“””__eq__(self, Rotation pRot2) -> bool”””
return _almath.Rotation___eq__(*args)
def __ne__(*args):
“””__ne__(self, Rotation pRot2) -> bool”””
return _almath.Rotation___ne__(*args)
def isNear(*args):
“””
isNear(self, Rotation pRot2, float pEpsilon=0.0001f) -> bool
isNear(self, Rotation pRot2) -> bool
“””
return _almath.Rotation_isNear(*args)
def transpose(*args):
“””transpose(self) -> Rotation”””
return _almath.Rotation_transpose(*args)
def determinant(*args):
“””determinant(self) -> float”””
return _almath.Rotation_determinant(*args)
def fromQuaternion(*args):
“””fromQuaternion(float pA, float pB, float pC, float pD) -> Rotation”””
return _almath.Rotation_fromQuaternion(*args)
if _newclass:fromQuaternion = staticmethod(fromQuaternion)
__swig_getmethods__[“fromQuaternion”] = lambda x: fromQuaternion
def fromAngleDirection(*args):
“””fromAngleDirection(float pAngle, float pX, float pY, float pZ) -> Rotation”””
return _almath.Rotation_fromAngleDirection(*args)
if _newclass:fromAngleDirection = staticmethod(fromAngleDirection)
__swig_getmethods__[“fromAngleDirection”] = lambda x: fromAngleDirection
def fromRotX(*args):
“””fromRotX(float pRotX) -> Rotation”””
return _almath.Rotation_fromRotX(*args)
if _newclass:fromRotX = staticmethod(fromRotX)
__swig_getmethods__[“fromRotX”] = lambda x: fromRotX
def fromRotY(*args):
“””fromRotY(float pRotY) -> Rotation”””
return _almath.Rotation_fromRotY(*args)
if _newclass:fromRotY = staticmethod(fromRotY)
__swig_getmethods__[“fromRotY”] = lambda x: fromRotY
def fromRotZ(*args):
“””fromRotZ(float pRotZ) -> Rotation”””
return _almath.Rotation_fromRotZ(*args)
if _newclass:fromRotZ = staticmethod(fromRotZ)
__swig_getmethods__[“fromRotZ”] = lambda x: fromRotZ
def from3DRotation(*args):
“””from3DRotation(float pWX, float pWY, float pWZ) -> Rotation”””
return _almath.Rotation_from3DRotation(*args)
if _newclass:from3DRotation = staticmethod(from3DRotation)
__swig_getmethods__[“from3DRotation”] = lambda x: from3DRotation
def toVector(*args):
“””toVector(self) -> vectorFloat”””
return _almath.Rotation_toVector(*args)
def __str__(*args):
“””__str__(self) -> char”””
return _almath.Rotation___str__(*args)
def __repr__(*args):
“””__repr__(self) -> char”””
return _almath.Rotation___repr__(*args)
def __mul__(*args):
“””
__mul__(self, Rotation pRot2) -> Rotation
__mul__(self, Position3D rhs) -> Position3D
“””
return _almath.Rotation___mul__(*args)
__swig_destroy__ = _almath.delete_Rotation
__del__ = lambda self : None;
Rotation_swigregister = _almath.Rotation_swigregister
Rotation_swigregister(Rotation)
def quaternionInverse(*args):
“””
quaternionInverse(Quaternion pQua, Quaternion pQuaOut)
quaternionInverse(Quaternion pQua) -> Quaternion
“””
return _almath.quaternionInverse(*args)
def Rotation_fromQuaternion(*args):
“””Rotation_fromQuaternion(float pA, float pB, float pC, float pD) -> Rotation”””
return _almath.Rotation_fromQuaternion(*args)
def Rotation_fromAngleDirection(*args):
“””Rotation_fromAngleDirection(float pAngle, float pX, float pY, float pZ) -> Rotation”””
return _almath.Rotation_fromAngleDirection(*args)
def Rotation_fromRotX(*args):
“””Rotation_fromRotX(float pRotX) -> Rotation”””
return _almath.Rotation_fromRotX(*args)
def Rotation_fromRotY(*args):
“””Rotation_fromRotY(float pRotY) -> Rotation”””
return _almath.Rotation_fromRotY(*args)
def Rotation_fromRotZ(*args):
“””Rotation_fromRotZ(float pRotZ) -> Rotation”””
return _almath.Rotation_fromRotZ(*args)
def Rotation_from3DRotation(*args):
“””Rotation_from3DRotation(float pWX, float pWY, float pWZ) -> Rotation”””
return _almath.Rotation_from3DRotation(*args)

def transpose(*args):
“””transpose(Rotation pRot) -> Rotation”””
return _almath.transpose(*args)
def rotationFromQuaternion(*args):
“””rotationFromQuaternion(float pA, float pB, float pC, float pD) -> Rotation”””
return _almath.rotationFromQuaternion(*args)
def applyRotation(*args):
“””applyRotation(Rotation pRot, float pX, float pY, float pZ)”””
return _almath.applyRotation(*args)
def rotationFromRotX(*args):
“””rotationFromRotX(float pRotX) -> Rotation”””
return _almath.rotationFromRotX(*args)
def rotationFromRotY(*args):
“””rotationFromRotY(float pRotY) -> Rotation”””
return _almath.rotationFromRotY(*args)
def rotationFromRotZ(*args):
“””rotationFromRotZ(float pRotZ) -> Rotation”””
return _almath.rotationFromRotZ(*args)
def rotationFrom3DRotation(*args):
“””rotationFrom3DRotation(float pWX, float pWY, float pWZ) -> Rotation”””
return _almath.rotationFrom3DRotation(*args)
class Rotation3D(_object):
“””Proxy of C++ Rotation3D class”””
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, Rotation3D, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, Rotation3D, name)
__swig_setmethods__[“wx”] = _almath.Rotation3D_wx_set
__swig_getmethods__[“wx”] = _almath.Rotation3D_wx_get
if _newclass:wx = _swig_property(_almath.Rotation3D_wx_get, _almath.Rotation3D_wx_set)
__swig_setmethods__[“wy”] = _almath.Rotation3D_wy_set
__swig_getmethods__[“wy”] = _almath.Rotation3D_wy_get
if _newclass:wy = _swig_property(_almath.Rotation3D_wy_get, _almath.Rotation3D_wy_set)
__swig_setmethods__[“wz”] = _almath.Rotation3D_wz_set
__swig_getmethods__[“wz”] = _almath.Rotation3D_wz_get
if _newclass:wz = _swig_property(_almath.Rotation3D_wz_get, _almath.Rotation3D_wz_set)
def __init__(self, *args):
“””
__init__(self) -> Rotation3D
__init__(self, float pInit) -> Rotation3D
__init__(self, float pWx, float pWy, float pWz) -> Rotation3D
__init__(self, vectorFloat pFloats) -> Rotation3D
“””
this = _almath.new_Rotation3D(*args)
try: self.this.append(this)
except: self.this = this
def __add__(*args):
“””__add__(self, Rotation3D pRot2) -> Rotation3D”””
return _almath.Rotation3D___add__(*args)
def __sub__(*args):
“””__sub__(self, Rotation3D pRot2) -> Rotation3D”””
return _almath.Rotation3D___sub__(*args)
def __iadd__(*args):
“””__iadd__(self, Rotation3D pRot2) -> Rotation3D”””
return _almath.Rotation3D___iadd__(*args)
def __isub__(*args):
“””__isub__(self, Rotation3D pRot2) -> Rotation3D”””
return _almath.Rotation3D___isub__(*args)
def __eq__(*args):
“””__eq__(self, Rotation3D pRot2) -> bool”””
return _almath.Rotation3D___eq__(*args)
def __ne__(*args):
“””__ne__(self, Rotation3D pRot2) -> bool”””
return _almath.Rotation3D___ne__(*args)
def __mul__(*args):
“””__mul__(self, float pVal) -> Rotation3D”””
return _almath.Rotation3D___mul__(*args)
def __div__(*args):
“””__div__(self, float pVal) -> Rotation3D”””
return _almath.Rotation3D___div__(*args)
def __imul__(*args):
“””__imul__(self, float pVal) -> Rotation3D”””
return _almath.Rotation3D___imul__(*args)
def __idiv__(*args):
“””__idiv__(self, float pVal) -> Rotation3D”””
return _almath.Rotation3D___idiv__(*args)
def isNear(*args):
“””
isNear(self, Rotation3D pRot2, float pEpsilon=0.0001f) -> bool
isNear(self, Rotation3D pRot2) -> bool
“””
return _almath.Rotation3D_isNear(*args)
def norm(*args):
“””norm(self) -> float”””
return _almath.Rotation3D_norm(*args)
def toVector(*args):
“””toVector(self) -> vectorFloat”””
return _almath.Rotation3D_toVector(*args)
def __repr__(*args):
“””__repr__(self) -> char”””
return _almath.Rotation3D___repr__(*args)
__swig_destroy__ = _almath.delete_Rotation3D
__del__ = lambda self : None;
Rotation3D_swigregister = _almath.Rotation3D_swigregister
Rotation3D_swigregister(Rotation3D)
class Transform(_object):
“””Proxy of C++ Transform class”””
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, Transform, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, Transform, name)
__swig_setmethods__[“r1_c1”] = _almath.Transform_r1_c1_set
__swig_getmethods__[“r1_c1”] = _almath.Transform_r1_c1_get
if _newclass:r1_c1 = _swig_property(_almath.Transform_r1_c1_get, _almath.Transform_r1_c1_set)
__swig_setmethods__[“r1_c2”] = _almath.Transform_r1_c2_set
__swig_getmethods__[“r1_c2”] = _almath.Transform_r1_c2_get
if _newclass:r1_c2 = _swig_property(_almath.Transform_r1_c2_get, _almath.Transform_r1_c2_set)
__swig_setmethods__[“r1_c3”] = _almath.Transform_r1_c3_set
__swig_getmethods__[“r1_c3”] = _almath.Transform_r1_c3_get
if _newclass:r1_c3 = _swig_property(_almath.Transform_r1_c3_get, _almath.Transform_r1_c3_set)
__swig_setmethods__[“r1_c4”] = _almath.Transform_r1_c4_set
__swig_getmethods__[“r1_c4”] = _almath.Transform_r1_c4_get
if _newclass:r1_c4 = _swig_property(_almath.Transform_r1_c4_get, _almath.Transform_r1_c4_set)
__swig_setmethods__[“r2_c1”] = _almath.Transform_r2_c1_set
__swig_getmethods__[“r2_c1”] = _almath.Transform_r2_c1_get
if _newclass:r2_c1 = _swig_property(_almath.Transform_r2_c1_get, _almath.Transform_r2_c1_set)
__swig_setmethods__[“r2_c2”] = _almath.Transform_r2_c2_set
__swig_getmethods__[“r2_c2”] = _almath.Transform_r2_c2_get
if _newclass:r2_c2 = _swig_property(_almath.Transform_r2_c2_get, _almath.Transform_r2_c2_set)
__swig_setmethods__[“r2_c3”] = _almath.Transform_r2_c3_set
__swig_getmethods__[“r2_c3”] = _almath.Transform_r2_c3_get
if _newclass:r2_c3 = _swig_property(_almath.Transform_r2_c3_get, _almath.Transform_r2_c3_set)
__swig_setmethods__[“r2_c4”] = _almath.Transform_r2_c4_set
__swig_getmethods__[“r2_c4”] = _almath.Transform_r2_c4_get
if _newclass:r2_c4 = _swig_property(_almath.Transform_r2_c4_get, _almath.Transform_r2_c4_set)
__swig_setmethods__[“r3_c1”] = _almath.Transform_r3_c1_set
__swig_getmethods__[“r3_c1”] = _almath.Transform_r3_c1_get
if _newclass:r3_c1 = _swig_property(_almath.Transform_r3_c1_get, _almath.Transform_r3_c1_set)
__swig_setmethods__[“r3_c2”] = _almath.Transform_r3_c2_set
__swig_getmethods__[“r3_c2”] = _almath.Transform_r3_c2_get
if _newclass:r3_c2 = _swig_property(_almath.Transform_r3_c2_get, _almath.Transform_r3_c2_set)
__swig_setmethods__[“r3_c3”] = _almath.Transform_r3_c3_set
__swig_getmethods__[“r3_c3”] = _almath.Transform_r3_c3_get
if _newclass:r3_c3 = _swig_property(_almath.Transform_r3_c3_get, _almath.Transform_r3_c3_set)
__swig_setmethods__[“r3_c4”] = _almath.Transform_r3_c4_set
__swig_getmethods__[“r3_c4”] = _almath.Transform_r3_c4_get
if _newclass:r3_c4 = _swig_property(_almath.Transform_r3_c4_get, _almath.Transform_r3_c4_set)
def __init__(self, *args):
“””
__init__(self) -> Transform
__init__(self, vectorFloat pFloats) -> Transform
__init__(self, float pPosX, float pPosY, float pPosZ) -> Transform
“””
this = _almath.new_Transform(*args)
try: self.this.append(this)
except: self.this = this
def __imul__(*args):
“””__imul__(self, Transform pT2) -> Transform”””
return _almath.Transform___imul__(*args)
def __eq__(*args):
“””__eq__(self, Transform pT2) -> bool”””
return _almath.Transform___eq__(*args)
def __ne__(*args):
“””__ne__(self, Transform pT2) -> bool”””
return _almath.Transform___ne__(*args)
def isNear(*args):
“””
isNear(self, Transform pT2, float pEpsilon=0.0001f) -> bool
isNear(self, Transform pT2) -> bool
“””
return _almath.Transform_isNear(*args)
def isTransform(*args):
“””
isTransform(self, float pEpsilon=0.0001f) -> bool
isTransform(self) -> bool
“””
return _almath.Transform_isTransform(*args)
def norm(*args):
“””norm(self) -> float”””
return _almath.Transform_norm(*args)
def determinant(*args):
“””determinant(self) -> float”””
return _almath.Transform_determinant(*args)
def inverse(*args):
“””inverse(self) -> Transform”””
return _almath.Transform_inverse(*args)
def fromRotX(*args):
“””fromRotX(float pRotX) -> Transform”””
return _almath.Transform_fromRotX(*args)
if _newclass:fromRotX = staticmethod(fromRotX)
__swig_getmethods__[“fromRotX”] = lambda x: fromRotX
def fromRotY(*args):
“””fromRotY(float pRotY) -> Transform”””
return _almath.Transform_fromRotY(*args)
if _newclass:fromRotY = staticmethod(fromRotY)
__swig_getmethods__[“fromRotY”] = lambda x: fromRotY
def fromRotZ(*args):
“””fromRotZ(float pRotZ) -> Transform”””
return _almath.Transform_fromRotZ(*args)
if _newclass:fromRotZ = staticmethod(fromRotZ)
__swig_getmethods__[“fromRotZ”] = lambda x: fromRotZ
def from3DRotation(*args):
“””from3DRotation(float pWX, float pWY, float pWZ) -> Transform”””
return _almath.Transform_from3DRotation(*args)
if _newclass:from3DRotation = staticmethod(from3DRotation)
__swig_getmethods__[“from3DRotation”] = lambda x: from3DRotation
def fromPosition(*args):
“””
fromPosition(float pX, float pY, float pZ) -> Transform
fromPosition(float pX, float pY, float pZ, float pWX, float pWY,
float pWZ) -> Transform
“””
return _almath.Transform_fromPosition(*args)
if _newclass:fromPosition = staticmethod(fromPosition)
__swig_getmethods__[“fromPosition”] = lambda x: fromPosition
def diff(*args):
“””diff(self, Transform pT2) -> Transform”””
return _almath.Transform_diff(*args)
def distanceSquared(*args):
“””distanceSquared(self, Transform pT2) -> float”””
return _almath.Transform_distanceSquared(*args)
def distance(*args):
“””distance(self, Transform pT2) -> float”””
return _almath.Transform_distance(*args)
def toVector(*args):
“””toVector(self) -> vectorFloat”””
return _almath.Transform_toVector(*args)
def __str__(*args):
“””__str__(self) -> char”””
return _almath.Transform___str__(*args)
def __repr__(*args):
“””__repr__(self) -> char”””
return _almath.Transform___repr__(*args)
def __mul__(*args):
“””
__mul__(self, Transform pT2) -> Transform
__mul__(self, Position3D rhs) -> Position3D
“””
return _almath.Transform___mul__(*args)
__swig_destroy__ = _almath.delete_Transform
__del__ = lambda self : None;
Transform_swigregister = _almath.Transform_swigregister
Transform_swigregister(Transform)
def Transform_fromRotX(*args):
“””Transform_fromRotX(float pRotX) -> Transform”””
return _almath.Transform_fromRotX(*args)
def Transform_fromRotY(*args):
“””Transform_fromRotY(float pRotY) -> Transform”””
return _almath.Transform_fromRotY(*args)
def Transform_fromRotZ(*args):
“””Transform_fromRotZ(float pRotZ) -> Transform”””
return _almath.Transform_fromRotZ(*args)
def Transform_from3DRotation(*args):
“””Transform_from3DRotation(float pWX, float pWY, float pWZ) -> Transform”””
return _almath.Transform_from3DRotation(*args)
def Transform_fromPosition(*args):
“””
fromPosition(float pX, float pY, float pZ) -> Transform
Transform_fromPosition(float pX, float pY, float pZ, float pWX, float pWY,
float pWZ) -> Transform
“””
return _almath.Transform_fromPosition(*args)

def transformPreMultiply(*args):
“””transformPreMultiply(Transform pT, Transform pTOut)”””
return _almath.transformPreMultiply(*args)
def transformFromRotX(*args):
“””transformFromRotX(float pRotX) -> Transform”””
return _almath.transformFromRotX(*args)
def transformFromRotY(*args):
“””transformFromRotY(float pRotY) -> Transform”””
return _almath.transformFromRotY(*args)
def transformFromRotZ(*args):
“””transformFromRotZ(float pRotZ) -> Transform”””
return _almath.transformFromRotZ(*args)
def transformFrom3DRotation(*args):
“””transformFrom3DRotation(float pWX, float pWY, float pWZ) -> Transform”””
return _almath.transformFrom3DRotation(*args)
def transformInvertInPlace(*args):
“””transformInvertInPlace(Transform pT)”””
return _almath.transformInvertInPlace(*args)
def pinv(*args):
“””pinv(Transform pT) -> Transform”””
return _almath.pinv(*args)
def transformDiff(*args):
“””transformDiff(Transform pT1, Transform pT2) -> Transform”””
return _almath.transformDiff(*args)
def transformDistanceSquared(*args):
“””transformDistanceSquared(Transform pT1, Transform pT2) -> float”””
return _almath.transformDistanceSquared(*args)
def transformDistance(*args):
“””transformDistance(Transform pT1, Transform pT2) -> float”””
return _almath.transformDistance(*args)
class Velocity3D(_object):
“””Proxy of C++ Velocity3D class”””
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, Velocity3D, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, Velocity3D, name)
__swig_setmethods__[“xd”] = _almath.Velocity3D_xd_set
__swig_getmethods__[“xd”] = _almath.Velocity3D_xd_get
if _newclass:xd = _swig_property(_almath.Velocity3D_xd_get, _almath.Velocity3D_xd_set)
__swig_setmethods__[“yd”] = _almath.Velocity3D_yd_set
__swig_getmethods__[“yd”] = _almath.Velocity3D_yd_get
if _newclass:yd = _swig_property(_almath.Velocity3D_yd_get, _almath.Velocity3D_yd_set)
__swig_setmethods__[“zd”] = _almath.Velocity3D_zd_set
__swig_getmethods__[“zd”] = _almath.Velocity3D_zd_get
if _newclass:zd = _swig_property(_almath.Velocity3D_zd_get, _almath.Velocity3D_zd_set)
def __init__(self, *args):
“””
__init__(self) -> Velocity3D
__init__(self, float pInit) -> Velocity3D
__init__(self, float pXd, float pYd, float pZd) -> Velocity3D
__init__(self, vectorFloat pFloats) -> Velocity3D
“””
this = _almath.new_Velocity3D(*args)
try: self.this.append(this)
except: self.this = this
def __add__(*args):
“””__add__(self, Velocity3D pVel2) -> Velocity3D”””
return _almath.Velocity3D___add__(*args)
def __sub__(*args):
“””__sub__(self, Velocity3D pVel2) -> Velocity3D”””
return _almath.Velocity3D___sub__(*args)
def __pos__(*args):
“””__pos__(self) -> Velocity3D”””
return _almath.Velocity3D___pos__(*args)
def __neg__(*args):
“””__neg__(self) -> Velocity3D”””
return _almath.Velocity3D___neg__(*args)
def __iadd__(*args):
“””__iadd__(self, Velocity3D pVel2) -> Velocity3D”””
return _almath.Velocity3D___iadd__(*args)
def __isub__(*args):
“””__isub__(self, Velocity3D pVel2) -> Velocity3D”””
return _almath.Velocity3D___isub__(*args)
def __eq__(*args):
“””__eq__(self, Velocity3D pVel2) -> bool”””
return _almath.Velocity3D___eq__(*args)
def __ne__(*args):
“””__ne__(self, Velocity3D pVel2) -> bool”””
return _almath.Velocity3D___ne__(*args)
def __mul__(*args):
“””__mul__(self, float pVal) -> Velocity3D”””
return _almath.Velocity3D___mul__(*args)
def __div__(*args):
“””__div__(self, float pVal) -> Velocity3D”””
return _almath.Velocity3D___div__(*args)
def __imul__(*args):
“””__imul__(self, float pVal) -> Velocity3D”””
return _almath.Velocity3D___imul__(*args)
def __idiv__(*args):
“””__idiv__(self, float pVal) -> Velocity3D”””
return _almath.Velocity3D___idiv__(*args)
def isNear(*args):
“””
isNear(self, Velocity3D pVel2, float pEpsilon=0.0001f) -> bool
isNear(self, Velocity3D pVel2) -> bool
“””
return _almath.Velocity3D_isNear(*args)
def norm(*args):
“””norm(self) -> float”””
return _almath.Velocity3D_norm(*args)
def normalize(*args):
“””normalize(self) -> Velocity3D”””
return _almath.Velocity3D_normalize(*args)
def toVector(*args):
“””toVector(self) -> vectorFloat”””
return _almath.Velocity3D_toVector(*args)
def __repr__(*args):
“””__repr__(self) -> char”””
return _almath.Velocity3D___repr__(*args)
def __rmul__(*args):
“””__rmul__(self, float lhs) -> Velocity3D”””
return _almath.Velocity3D___rmul__(*args)
__swig_destroy__ = _almath.delete_Velocity3D
__del__ = lambda self : None;
Velocity3D_swigregister = _almath.Velocity3D_swigregister
Velocity3D_swigregister(Velocity3D)
def transformToFloatVector(*args):
“””
transformToFloatVector(Transform pT, vectorFloat pTOut)
transformToFloatVector(Transform pT) -> vectorFloat
“””
return _almath.transformToFloatVector(*args)
def determinant(*args):
“””
determinant(Rotation pRot) -> float
determinant(Transform pT) -> float
determinant(vectorFloat pFloats) -> float
“””
return _almath.determinant(*args)
def transformInverse(*args):
“””
transformInverse(Transform pT, Transform pTOut)
transformInverse(Transform pT) -> Transform
“””
return _almath.transformInverse(*args)
def transformFromPosition(*args):
“””
transformFromPosition(float pX, float pY, float pZ) -> Transform
transformFromPosition(float pX, float pY, float pZ, float pWX, float pWY,
float pWZ) -> Transform
“””
return _almath.transformFromPosition(*args)
class Velocity6D(_object):
“””Proxy of C++ Velocity6D class”””
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, Velocity6D, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, Velocity6D, name)
__swig_setmethods__[“xd”] = _almath.Velocity6D_xd_set
__swig_getmethods__[“xd”] = _almath.Velocity6D_xd_get
if _newclass:xd = _swig_property(_almath.Velocity6D_xd_get, _almath.Velocity6D_xd_set)
__swig_setmethods__[“yd”] = _almath.Velocity6D_yd_set
__swig_getmethods__[“yd”] = _almath.Velocity6D_yd_get
if _newclass:yd = _swig_property(_almath.Velocity6D_yd_get, _almath.Velocity6D_yd_set)
__swig_setmethods__[“zd”] = _almath.Velocity6D_zd_set
__swig_getmethods__[“zd”] = _almath.Velocity6D_zd_get
if _newclass:zd = _swig_property(_almath.Velocity6D_zd_get, _almath.Velocity6D_zd_set)
__swig_setmethods__[“wxd”] = _almath.Velocity6D_wxd_set
__swig_getmethods__[“wxd”] = _almath.Velocity6D_wxd_get
if _newclass:wxd = _swig_property(_almath.Velocity6D_wxd_get, _almath.Velocity6D_wxd_set)
__swig_setmethods__[“wyd”] = _almath.Velocity6D_wyd_set
__swig_getmethods__[“wyd”] = _almath.Velocity6D_wyd_get
if _newclass:wyd = _swig_property(_almath.Velocity6D_wyd_get, _almath.Velocity6D_wyd_set)
__swig_setmethods__[“wzd”] = _almath.Velocity6D_wzd_set
__swig_getmethods__[“wzd”] = _almath.Velocity6D_wzd_get
if _newclass:wzd = _swig_property(_almath.Velocity6D_wzd_get, _almath.Velocity6D_wzd_set)
def __init__(self, *args):
“””
__init__(self) -> Velocity6D
__init__(self, float pInit) -> Velocity6D
__init__(self, float pXd, float pYd, float pZd, float pWxd, float pWyd,
float pWzd) -> Velocity6D
__init__(self, vectorFloat pFloats) -> Velocity6D
“””
this = _almath.new_Velocity6D(*args)
try: self.this.append(this)
except: self.this = this
def __add__(*args):
“””__add__(self, Velocity6D pVel2) -> Velocity6D”””
return _almath.Velocity6D___add__(*args)
def __sub__(*args):
“””__sub__(self, Velocity6D pVel2) -> Velocity6D”””
return _almath.Velocity6D___sub__(*args)
def __pos__(*args):
“””__pos__(self) -> Velocity6D”””
return _almath.Velocity6D___pos__(*args)
def __neg__(*args):
“””__neg__(self) -> Velocity6D”””
return _almath.Velocity6D___neg__(*args)
def __mul__(*args):
“””__mul__(self, float pVal) -> Velocity6D”””
return _almath.Velocity6D___mul__(*args)
def __div__(*args):
“””__div__(self, float pVal) -> Velocity6D”””
return _almath.Velocity6D___div__(*args)
def __eq__(*args):
“””__eq__(self, Velocity6D pVel2) -> bool”””
return _almath.Velocity6D___eq__(*args)
def __ne__(*args):
“””__ne__(self, Velocity6D pVel2) -> bool”””
return _almath.Velocity6D___ne__(*args)
def __imul__(*args):
“””__imul__(self, float pVal) -> Velocity6D”””
return _almath.Velocity6D___imul__(*args)
def __idiv__(*args):
“””__idiv__(self, float pVal) -> Velocity6D”””
return _almath.Velocity6D___idiv__(*args)
def isNear(*args):
“””
isNear(self, Velocity6D pVel2, float pEpsilon=0.0001f) -> bool
isNear(self, Velocity6D pVel2) -> bool
“””
return _almath.Velocity6D_isNear(*args)
def norm(*args):
“””norm(self) -> float”””
return _almath.Velocity6D_norm(*args)
def normalize(*args):
“””normalize(self) -> Velocity6D”””
return _almath.Velocity6D_normalize(*args)
def toVector(*args):
“””toVector(self) -> vectorFloat”””
return _almath.Velocity6D_toVector(*args)
def __repr__(*args):
“””__repr__(self) -> char”””
return _almath.Velocity6D___repr__(*args)
def __rmul__(*args):
“””__rmul__(self, float lhs) -> Velocity6D”””
return _almath.Velocity6D___rmul__(*args)
__swig_destroy__ = _almath.delete_Velocity6D
__del__ = lambda self : None;
Velocity6D_swigregister = _almath.Velocity6D_swigregister
Velocity6D_swigregister(Velocity6D)
class TransformAndVelocity6D(_object):
“””Proxy of C++ TransformAndVelocity6D class”””
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, TransformAndVelocity6D, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, TransformAndVelocity6D, name)
__swig_setmethods__[“T”] = _almath.TransformAndVelocity6D_T_set
__swig_getmethods__[“T”] = _almath.TransformAndVelocity6D_T_get
if _newclass:T = _swig_property(_almath.TransformAndVelocity6D_T_get, _almath.TransformAndVelocity6D_T_set)
__swig_setmethods__[“V”] = _almath.TransformAndVelocity6D_V_set
__swig_getmethods__[“V”] = _almath.TransformAndVelocity6D_V_get
if _newclass:V = _swig_property(_almath.TransformAndVelocity6D_V_get, _almath.TransformAndVelocity6D_V_set)
def isNear(*args):
“””
isNear(self, TransformAndVelocity6D pTV2, float pEpsilon=0.0001f) -> bool
isNear(self, TransformAndVelocity6D pTV2) -> bool
“””
return _almath.TransformAndVelocity6D_isNear(*args)
def __repr__(*args):
“””__repr__(self) -> char”””
return _almath.TransformAndVelocity6D___repr__(*args)
def __init__(self, *args):
“””__init__(self) -> TransformAndVelocity6D”””
this = _almath.new_TransformAndVelocity6D(*args)
try: self.this.append(this)
except: self.this = this
__swig_destroy__ = _almath.delete_TransformAndVelocity6D
__del__ = lambda self : None;
TransformAndVelocity6D_swigregister = _almath.TransformAndVelocity6D_swigregister
TransformAndVelocity6D_swigregister(TransformAndVelocity6D)
def norm(*args):
“””
norm(Position2D pPos) -> float
norm(Position3D pPos) -> float
norm(Position6D pPos) -> float
norm(Quaternion pQua) -> float
norm(Rotation3D pRot) -> float
norm(Transform pT) -> float
norm(Velocity3D pVel) -> float
norm(Velocity6D pVel) -> float
“””
return _almath.norm(*args)
def normalize(*args):
“””
normalize(Position2D pPos) -> Position2D
normalize(Position3D pPos) -> Position3D
normalize(Position6D pPos) -> Position6D
normalize(Quaternion pQua) -> Quaternion
normalize(Velocity3D pVel) -> Velocity3D
normalize(Velocity6D pVel) -> Velocity6D
“””
return _almath.normalize(*args)

def getDubinsSolutions(*args):
“””getDubinsSolutions(Pose2D pTargetPose, float pCircleRadius) -> vectorPose2D”””
return _almath.getDubinsSolutions(*args)
def avoidFootCollision(*args):
“””
avoidFootCollision(vectorPose2D pLFootBoundingBox, vectorPose2D pRFootBoundingBox,
bool pIsLeftSupport, Pose2D pMove) -> bool
“””
return _almath.avoidFootCollision(*args)
def clipFootWithEllipse(*args):
“””clipFootWithEllipse(float pMaxFootX, float pMaxFootY, Pose2D pMove) -> bool”””
return _almath.clipFootWithEllipse(*args)
def transformLogarithmInPlace(*args):
“””transformLogarithmInPlace(Transform pT, Velocity6D pVel)”””
return _almath.transformLogarithmInPlace(*args)
def transformLogarithm(*args):
“””transformLogarithm(Transform pT) -> Velocity6D”””
return _almath.transformLogarithm(*args)
def velocityExponential(*args):
“””velocityExponential(Velocity6D pVel) -> Transform”””
return _almath.velocityExponential(*args)
def velocityExponentialInPlace(*args):
“””velocityExponentialInPlace(Velocity6D pVel, Transform pT)”””
return _almath.velocityExponentialInPlace(*args)
def changeReferenceVelocity6D(*args):
“””changeReferenceVelocity6D(Transform pT, Velocity6D pVelIn, Velocity6D pVelOut)”””
return _almath.changeReferenceVelocity6D(*args)
def changeReferencePosition6D(*args):
“””changeReferencePosition6D(Transform pT, Position6D pPosIn, Position6D pPosOut)”””
return _almath.changeReferencePosition6D(*args)
def changeReferencePosition3DInPlace(*args):
“””changeReferencePosition3DInPlace(Transform pT, Position3D pPosOut)”””
return _almath.changeReferencePosition3DInPlace(*args)
def changeReferenceTransposePosition3DInPlace(*args):
“””changeReferenceTransposePosition3DInPlace(Transform pT, Position3D pPosOut)”””
return _almath.changeReferenceTransposePosition3DInPlace(*args)
def changeReferencePosition3D(*args):
“””changeReferencePosition3D(Transform pT, Position3D pPosIn, Position3D pPosOut)”””
return _almath.changeReferencePosition3D(*args)
def changeReferenceTransposePosition3D(*args):
“””changeReferenceTransposePosition3D(Transform pT, Position3D pPosIn, Position3D pPosOut)”””
return _almath.changeReferenceTransposePosition3D(*args)
def changeReferenceTransform(*args):
“””changeReferenceTransform(Transform pT, Transform pTIn, Transform pTOut)”””
return _almath.changeReferenceTransform(*args)
def changeReferenceTransposeTransform(*args):
“””changeReferenceTransposeTransform(Transform pT, Transform pTIn, Transform pTOut)”””
return _almath.changeReferenceTransposeTransform(*args)
def changeReferenceTransposeVelocity6D(*args):
“””changeReferenceTransposeVelocity6D(Transform pT, Velocity6D pVelIn, Velocity6D pVelOut)”””
return _almath.changeReferenceTransposeVelocity6D(*args)
def changeReferenceTransposePosition6D(*args):
“””changeReferenceTransposePosition6D(Transform pT, Position6D pPosIn, Position6D pPosOut)”””
return _almath.changeReferenceTransposePosition6D(*args)
def transformMeanInPlace(*args):
“””transformMeanInPlace(Transform pTIn1, Transform pTIn2, float pVal, Transform pTOut)”””
return _almath.transformMeanInPlace(*args)
def transformFromPosition3DInPlace(*args):
“””transformFromPosition3DInPlace(Position3D pPosition, Transform pTransform)”””
return _almath.transformFromPosition3DInPlace(*args)
def transformFromPosition3D(*args):
“””transformFromPosition3D(Position3D pPosition) -> Transform”””
return _almath.transformFromPosition3D(*args)
def transformFromRotationInPlace(*args):
“””transformFromRotationInPlace(Rotation pRotation, Transform pTransform)”””
return _almath.transformFromRotationInPlace(*args)
def transformFromRotation(*args):
“””transformFromRotation(Rotation pRotation) -> Transform”””
return _almath.transformFromRotation(*args)
def rotationFromTransformInPlace(*args):
“””rotationFromTransformInPlace(Transform pTransform, Rotation pRotation)”””
return _almath.rotationFromTransformInPlace(*args)
def rotationFromTransform(*args):
“””rotationFromTransform(Transform pTransform) -> Rotation”””
return _almath.rotationFromTransform(*args)
def rotation3DFromRotation(*args):
“””rotation3DFromRotation(Rotation pRotation) -> Rotation3D”””
return _almath.rotation3DFromRotation(*args)
def position6DFromTransformInPlace(*args):
“””position6DFromTransformInPlace(Transform pT, Position6D pPos)”””
return _almath.position6DFromTransformInPlace(*args)
def position6DFromTransform(*args):
“””position6DFromTransform(Transform pT) -> Position6D”””
return _almath.position6DFromTransform(*args)
def transformFromPose2DInPlace(*args):
“””transformFromPose2DInPlace(Pose2D pPose, Transform pT)”””
return _almath.transformFromPose2DInPlace(*args)
def transformFromPose2D(*args):
“””transformFromPose2D(Pose2D pPose) -> Transform”””
return _almath.transformFromPose2D(*args)
def pose2DFromTransformInPlace(*args):
“””pose2DFromTransformInPlace(Transform pT, Pose2D pPos)”””
return _almath.pose2DFromTransformInPlace(*args)
def pose2DFromTransform(*args):
“””pose2DFromTransform(Transform pT) -> Pose2D”””
return _almath.pose2DFromTransform(*args)
def transformFromRotation3D(*args):
“””transformFromRotation3D(Rotation3D pRotation) -> Transform”””
return _almath.transformFromRotation3D(*args)
def transformFromPosition6D(*args):
“””transformFromPosition6D(Position6D pPosition6D) -> Transform”””
return _almath.transformFromPosition6D(*args)
def position6DFromTransformDiffInPlace(*args):
“””position6DFromTransformDiffInPlace(Transform pCurrent, Transform pTarget, Position6D result)”””
return _almath.position6DFromTransformDiffInPlace(*args)
def position6DFromTransformDiff(*args):
“””position6DFromTransformDiff(Transform pCurrent, Transform pTarget) -> Position6D”””
return _almath.position6DFromTransformDiff(*args)
def position3DFromTransformInPlace(*args):
“””position3DFromTransformInPlace(Transform pT, Position3D pPos)”””
return _almath.position3DFromTransformInPlace(*args)
def position3DFromTransform(*args):
“””position3DFromTransform(Transform pT) -> Position3D”””
return _almath.position3DFromTransform(*args)
def rotation3DFromTransform(*args):
“””rotation3DFromTransform(Transform pT) -> Rotation3D”””
return _almath.rotation3DFromTransform(*args)
def transformFromQuaternion(*args):
“””transformFromQuaternion(Quaternion pQua) -> Transform”””
return _almath.transformFromQuaternion(*args)
def quaternionFromTransform(*args):
“””quaternionFromTransform(Transform pT) -> Quaternion”””
return _almath.quaternionFromTransform(*args)
def clipData(*args):
“””clipData(float pMin, float pMax, float pData) -> bool”””
return _almath.clipData(*args)
def position6DFromVelocity6D(*args):
“””position6DFromVelocity6D(Velocity6D pVel) -> Position6D”””
return _almath.position6DFromVelocity6D(*args)
_4_PI_ = cvar._4_PI_
_2_PI_ = cvar._2_PI_
PI = cvar.PI
PI_2 = cvar.PI_2
PI_4 = cvar.PI_4
TO_RAD = cvar.TO_RAD
TO_DEG = cvar.TO_DEG
def transformMean(*args):
“””
transformMean(Transform pTIn1, Transform pTIn2, float pVal=0.5f) -> Transform
transformMean(Transform pTIn1, Transform pTIn2) -> Transform
“””
return _almath.transformMean(*args)
def transformFromRotationPosition3D(*args):
“””
transformFromRotationPosition3D(Rotation pRot, float pX, float pY, float pZ) -> Transform
transformFromRotationPosition3D(Rotation pRot, Position3D pPos) -> Transform
“””
return _almath.transformFromRotationPosition3D(*args)
def transformFromRotVecInPlace(*args):
“””
transformFromRotVecInPlace(int pAxis, float pTheta, Position3D pPos, Transform pT)
transformFromRotVecInPlace(Position3D pPos, Transform pT)
“””
return _almath.transformFromRotVecInPlace(*args)
def transformFromRotVec(*args):
“””
transformFromRotVec(int pAxis, float pTheta, Position3D pPos) -> Transform
transformFromRotVec(Position3D pPos) -> Transform
transformFromRotVec(int pAxis, float pTheta) -> Transform
“””
return _almath.transformFromRotVec(*args)
def axisRotationProjection(*args):
“””
axisRotationProjection(Position3D pPos, Transform pT) -> Transform
axisRotationProjection(Position3D pAxis, Rotation pRot) -> Rotation
“””
return _almath.axisRotationProjection(*args)
def axisRotationProjectionInPlace(*args):
“””
axisRotationProjectionInPlace(Position3D pPos, Transform pT)
axisRotationProjectionInPlace(Position3D pPos, Rotation pRot)
“””
return _almath.axisRotationProjectionInPlace(*args)
def orthogonalSpace(*args):
“””
orthogonalSpace(Position3D pPos, Transform pTOut)
orthogonalSpace(Position3D pPos) -> Transform
“””
return _almath.orthogonalSpace(*args)
def __mul__(*args):
“””
__mul__(float pM, Position2D pPos1) -> Position2D
__mul__(float pM, Position3D pPos1) -> Position3D
__mul__(float pM, Velocity3D pVel1) -> Velocity3D
__mul__(float pVal, Velocity6D pVel) -> Velocity6D
__mul__(Transform pT, Position3D pPos) -> Position3D
__mul__(Rotation pRot, Position3D pPos) -> Position3D
__mul__(float pVal, Position6D pPos) -> Velocity6D
“””
return _almath.__mul__(*args)
def rotationFromAngleDirection(*args):
“””
rotationFromAngleDirection(float pAngle, float pX, float pY, float pZ) -> Rotation
rotationFromAngleDirection(float pTheta, Position3D pPos) -> Rotation
“””
return _almath.rotationFromAngleDirection(*args)

pynaoqi-python-2.6-naoqi-1.14-mac64/_allog.so

pynaoqi-python-2.6-naoqi-1.14-mac64/inaoqi.py
# This file was automatically generated by SWIG (http://www.swig.org).
# Version 1.3.31
#
# Don’t modify this file, modify the SWIG interface instead.
# This file is compatible with both classic and new-style classes.
import _inaoqi
import new
new_instancemethod = new.instancemethod
try:
_swig_property = property
except NameError:
pass # Python < 2.2 doesn't have 'property'. 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

class PySwigIterator(_object):
__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__ = _inaoqi.delete_PySwigIterator
__del__ = lambda self : None;
def value(*args): return _inaoqi.PySwigIterator_value(*args)
def incr(*args): return _inaoqi.PySwigIterator_incr(*args)
def decr(*args): return _inaoqi.PySwigIterator_decr(*args)
def distance(*args): return _inaoqi.PySwigIterator_distance(*args)
def equal(*args): return _inaoqi.PySwigIterator_equal(*args)
def copy(*args): return _inaoqi.PySwigIterator_copy(*args)
def next(*args): return _inaoqi.PySwigIterator_next(*args)
def previous(*args): return _inaoqi.PySwigIterator_previous(*args)
def advance(*args): return _inaoqi.PySwigIterator_advance(*args)
def __eq__(*args): return _inaoqi.PySwigIterator___eq__(*args)
def __ne__(*args): return _inaoqi.PySwigIterator___ne__(*args)
def __iadd__(*args): return _inaoqi.PySwigIterator___iadd__(*args)
def __isub__(*args): return _inaoqi.PySwigIterator___isub__(*args)
def __add__(*args): return _inaoqi.PySwigIterator___add__(*args)
def __sub__(*args): return _inaoqi.PySwigIterator___sub__(*args)
def __iter__(self): return self
PySwigIterator_swigregister = _inaoqi.PySwigIterator_swigregister
PySwigIterator_swigregister(PySwigIterator)
class StringVector(_object):
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, StringVector, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, StringVector, name)
__repr__ = _swig_repr
def iterator(*args): return _inaoqi.StringVector_iterator(*args)
def __iter__(self): return self.iterator()
def __nonzero__(*args): return _inaoqi.StringVector___nonzero__(*args)
def __len__(*args): return _inaoqi.StringVector___len__(*args)
def pop(*args): return _inaoqi.StringVector_pop(*args)
def __getslice__(*args): return _inaoqi.StringVector___getslice__(*args)
def __setslice__(*args): return _inaoqi.StringVector___setslice__(*args)
def __delslice__(*args): return _inaoqi.StringVector___delslice__(*args)
def __delitem__(*args): return _inaoqi.StringVector___delitem__(*args)
def __getitem__(*args): return _inaoqi.StringVector___getitem__(*args)
def __setitem__(*args): return _inaoqi.StringVector___setitem__(*args)
def append(*args): return _inaoqi.StringVector_append(*args)
def empty(*args): return _inaoqi.StringVector_empty(*args)
def size(*args): return _inaoqi.StringVector_size(*args)
def clear(*args): return _inaoqi.StringVector_clear(*args)
def swap(*args): return _inaoqi.StringVector_swap(*args)
def get_allocator(*args): return _inaoqi.StringVector_get_allocator(*args)
def begin(*args): return _inaoqi.StringVector_begin(*args)
def end(*args): return _inaoqi.StringVector_end(*args)
def rbegin(*args): return _inaoqi.StringVector_rbegin(*args)
def rend(*args): return _inaoqi.StringVector_rend(*args)
def pop_back(*args): return _inaoqi.StringVector_pop_back(*args)
def erase(*args): return _inaoqi.StringVector_erase(*args)
def __init__(self, *args):
this = _inaoqi.new_StringVector(*args)
try: self.this.append(this)
except: self.this = this
def push_back(*args): return _inaoqi.StringVector_push_back(*args)
def front(*args): return _inaoqi.StringVector_front(*args)
def back(*args): return _inaoqi.StringVector_back(*args)
def assign(*args): return _inaoqi.StringVector_assign(*args)
def resize(*args): return _inaoqi.StringVector_resize(*args)
def insert(*args): return _inaoqi.StringVector_insert(*args)
def reserve(*args): return _inaoqi.StringVector_reserve(*args)
def capacity(*args): return _inaoqi.StringVector_capacity(*args)
__swig_destroy__ = _inaoqi.delete_StringVector
__del__ = lambda self : None;
StringVector_swigregister = _inaoqi.StringVector_swigregister
StringVector_swigregister(StringVector)
setInstance = _inaoqi.setInstance
getMemoryProxy = _inaoqi.getMemoryProxy
_ALSystem = _inaoqi._ALSystem
class broker(_object):
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, broker, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, broker, name)
__repr__ = _swig_repr
def __init__(self, *args):
this = _inaoqi.new_broker(*args)
try: self.this.append(this)
except: self.this = this
__swig_destroy__ = _inaoqi.delete_broker
__del__ = lambda self : None;
def shutdown(*args): return _inaoqi.broker_shutdown(*args)
def isModulePresent(*args): return _inaoqi.broker_isModulePresent(*args)
def getGlobalModuleList(*args): return _inaoqi.broker_getGlobalModuleList(*args)
broker_swigregister = _inaoqi.broker_swigregister
broker_swigregister(broker)
class baseModule(_object):
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, baseModule, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, baseModule, name)
__repr__ = _swig_repr
def __init__(self, *args):
this = _inaoqi.new_baseModule(*args)
try: self.this.append(this)
except: self.this = this
def BIND_PYTHON(*args): return _inaoqi.baseModule_BIND_PYTHON(*args)
def _bindWithParam(*args): return _inaoqi.baseModule__bindWithParam(*args)
def exit(*args): return _inaoqi.baseModule_exit(*args)
def getName(*args): return _inaoqi.baseModule_getName(*args)
def getBrokerName(*args): return _inaoqi.baseModule_getBrokerName(*args)
def setModuleDescription(*args): return _inaoqi.baseModule_setModuleDescription(*args)
def addParam(*args): return _inaoqi.baseModule_addParam(*args)
def functionName(*args): return _inaoqi.baseModule_functionName(*args)
def autoBind(*args): return _inaoqi.baseModule_autoBind(*args)
def _methodMissing0(*args): return _inaoqi.baseModule__methodMissing0(*args)
def _methodMissing1(*args): return _inaoqi.baseModule__methodMissing1(*args)
def _methodMissing2(*args): return _inaoqi.baseModule__methodMissing2(*args)
def _methodMissing3(*args): return _inaoqi.baseModule__methodMissing3(*args)
def _methodMissing4(*args): return _inaoqi.baseModule__methodMissing4(*args)
def _methodMissing5(*args): return _inaoqi.baseModule__methodMissing5(*args)
def _methodMissing6(*args): return _inaoqi.baseModule__methodMissing6(*args)
def _methodMissing(*args): return _inaoqi.baseModule__methodMissing(*args)
def version(*args): return _inaoqi.baseModule_version(*args)
__swig_destroy__ = _inaoqi.delete_baseModule
__del__ = lambda self : None;
baseModule_swigregister = _inaoqi.baseModule_swigregister
baseModule_swigregister(baseModule)
class module(baseModule):
__swig_setmethods__ = {}
for _s in [baseModule]: __swig_setmethods__.update(getattr(_s,’__swig_setmethods__’,{}))
__setattr__ = lambda self, name, value: _swig_setattr(self, module, name, value)
__swig_getmethods__ = {}
for _s in [baseModule]: __swig_getmethods__.update(getattr(_s,’__swig_getmethods__’,{}))
__getattr__ = lambda self, name: _swig_getattr(self, module, name)
__repr__ = _swig_repr
def __init__(self, *args):
this = _inaoqi.new_module(*args)
try: self.this.append(this)
except: self.this = this
def BIND_PYTHON(*args): return _inaoqi.module_BIND_PYTHON(*args)
def exit(*args): return _inaoqi.module_exit(*args)
def getName(*args): return _inaoqi.module_getName(*args)
def getBrokerName(*args): return _inaoqi.module_getBrokerName(*args)
def _methodMissing(*args): return _inaoqi.module__methodMissing(*args)
def version(*args): return _inaoqi.module_version(*args)
__swig_destroy__ = _inaoqi.delete_module
__del__ = lambda self : None;
module_swigregister = _inaoqi.module_swigregister
module_swigregister(module)
class timeline(_object):
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, timeline, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, timeline, name)
__repr__ = _swig_repr
def __init__(self, *args):
this = _inaoqi.new_timeline(*args)
try: self.this.append(this)
except: self.this = this
__swig_destroy__ = _inaoqi.delete_timeline
__del__ = lambda self : None;
def play(*args): return _inaoqi.timeline_play(*args)
def pause(*args): return _inaoqi.timeline_pause(*args)
def stop(*args): return _inaoqi.timeline_stop(*args)
def goTo(*args): return _inaoqi.timeline_goTo(*args)
def getSize(*args): return _inaoqi.timeline_getSize(*args)
def getFPS(*args): return _inaoqi.timeline_getFPS(*args)
def setFPS(*args): return _inaoqi.timeline_setFPS(*args)
timeline_swigregister = _inaoqi.timeline_swigregister
timeline_swigregister(timeline)
class behavior(baseModule):
__swig_setmethods__ = {}
for _s in [baseModule]: __swig_setmethods__.update(getattr(_s,’__swig_setmethods__’,{}))
__setattr__ = lambda self, name, value: _swig_setattr(self, behavior, name, value)
__swig_getmethods__ = {}
for _s in [baseModule]: __swig_getmethods__.update(getattr(_s,’__swig_getmethods__’,{}))
__getattr__ = lambda self, name: _swig_getattr(self, behavior, name)
__repr__ = _swig_repr
def __init__(self, *args):
this = _inaoqi.new_behavior(*args)
try: self.this.append(this)
except: self.this = this
__swig_destroy__ = _inaoqi.delete_behavior
__del__ = lambda self : None;
def setEnabled(*args): return _inaoqi.behavior_setEnabled(*args)
def isEnabled(*args): return _inaoqi.behavior_isEnabled(*args)
def setResources(*args): return _inaoqi.behavior_setResources(*args)
def waitFor(*args): return _inaoqi.behavior_waitFor(*args)
def waitResourcesCallback(*args): return _inaoqi.behavior_waitResourcesCallback(*args)
def isResourceFree(*args): return _inaoqi.behavior_isResourceFree(*args)
def waitResourceFree(*args): return _inaoqi.behavior_waitResourceFree(*args)
def waitResources(*args): return _inaoqi.behavior_waitResources(*args)
def releaseResource(*args): return _inaoqi.behavior_releaseResource(*args)
def addInput(*args): return _inaoqi.behavior_addInput(*args)
def addOutput(*args): return _inaoqi.behavior_addOutput(*args)
def addParameter(*args): return _inaoqi.behavior_addParameter(*args)
def getParameter(*args): return _inaoqi.behavior_getParameter(*args)
def getParametersList(*args): return _inaoqi.behavior_getParametersList(*args)
def setParameter(*args): return _inaoqi.behavior_setParameter(*args)
def stimulateIO(*args): return _inaoqi.behavior_stimulateIO(*args)
def BIND_PYTHON(*args): return _inaoqi.behavior_BIND_PYTHON(*args)
def setModuleDescription(*args): return _inaoqi.behavior_setModuleDescription(*args)
def addParam(*args): return _inaoqi.behavior_addParam(*args)
def exit(*args): return _inaoqi.behavior_exit(*args)
def getName(*args): return _inaoqi.behavior_getName(*args)
def getBrokerName(*args): return _inaoqi.behavior_getBrokerName(*args)
def _methodMissing(*args): return _inaoqi.behavior__methodMissing(*args)
def version(*args): return _inaoqi.behavior_version(*args)
def hasTimeline(*args): return _inaoqi.behavior_hasTimeline(*args)
def getTimeline(*args): return _inaoqi.behavior_getTimeline(*args)
def hasParentTimeline(*args): return _inaoqi.behavior_hasParentTimeline(*args)
def getParentTimeline(*args): return _inaoqi.behavior_getParentTimeline(*args)
behavior_swigregister = _inaoqi.behavior_swigregister
behavior_swigregister(behavior)
class proxy(_object):
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, proxy, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, proxy, name)
__repr__ = _swig_repr
def __init__(self, *args):
this = _inaoqi.new_proxy(*args)
try: self.this.append(this)
except: self.this = this
def pythonCall(*args): return _inaoqi.proxy_pythonCall(*args)
def pythonPCall(*args): return _inaoqi.proxy_pythonPCall(*args)
def wait(*args): return _inaoqi.proxy_wait(*args)
def stop(*args): return _inaoqi.proxy_stop(*args)
def isRunning(*args): return _inaoqi.proxy_isRunning(*args)
__swig_destroy__ = _inaoqi.delete_proxy
__del__ = lambda self : None;
proxy_swigregister = _inaoqi.proxy_swigregister
proxy_swigregister(proxy)
class ALMemoryProxy(_object):
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, ALMemoryProxy, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, ALMemoryProxy, name)
__repr__ = _swig_repr
def __init__(self, *args):
this = _inaoqi.new_ALMemoryProxy(*args)
try: self.this.append(this)
except: self.this = this
__swig_setmethods__[“post”] = _inaoqi.ALMemoryProxy_post_set
__swig_getmethods__[“post”] = _inaoqi.ALMemoryProxy_post_get
if _newclass:post = _swig_property(_inaoqi.ALMemoryProxy_post_get, _inaoqi.ALMemoryProxy_post_set)
def getGenericProxy(*args): return _inaoqi.ALMemoryProxy_getGenericProxy(*args)
def declareEvent(*args): return _inaoqi.ALMemoryProxy_declareEvent(*args)
def exit(*args): return _inaoqi.ALMemoryProxy_exit(*args)
def getBrokerName(*args): return _inaoqi.ALMemoryProxy_getBrokerName(*args)
def getData(*args): return _inaoqi.ALMemoryProxy_getData(*args)
def getDataList(*args): return _inaoqi.ALMemoryProxy_getDataList(*args)
def getDataListName(*args): return _inaoqi.ALMemoryProxy_getDataListName(*args)
def getDataOnChange(*args): return _inaoqi.ALMemoryProxy_getDataOnChange(*args)
def getDataPtr(*args): return _inaoqi.ALMemoryProxy_getDataPtr(*args)
def getDescriptionList(*args): return _inaoqi.ALMemoryProxy_getDescriptionList(*args)
def getEventHistory(*args): return _inaoqi.ALMemoryProxy_getEventHistory(*args)
def getEventList(*args): return _inaoqi.ALMemoryProxy_getEventList(*args)
def getExtractorEvent(*args): return _inaoqi.ALMemoryProxy_getExtractorEvent(*args)
def getListData(*args): return _inaoqi.ALMemoryProxy_getListData(*args)
def getMethodHelp(*args): return _inaoqi.ALMemoryProxy_getMethodHelp(*args)
def getMethodList(*args): return _inaoqi.ALMemoryProxy_getMethodList(*args)
def getMicroEventList(*args): return _inaoqi.ALMemoryProxy_getMicroEventList(*args)
def getModuleHelp(*args): return _inaoqi.ALMemoryProxy_getModuleHelp(*args)
def getSubscribers(*args): return _inaoqi.ALMemoryProxy_getSubscribers(*args)
def getTimestamp(*args): return _inaoqi.ALMemoryProxy_getTimestamp(*args)
def getType(*args): return _inaoqi.ALMemoryProxy_getType(*args)
def getUsage(*args): return _inaoqi.ALMemoryProxy_getUsage(*args)
def insertData(*args): return _inaoqi.ALMemoryProxy_insertData(*args)
def insertListData(*args): return _inaoqi.ALMemoryProxy_insertListData(*args)
def isRunning(*args): return _inaoqi.ALMemoryProxy_isRunning(*args)
def ping(*args): return _inaoqi.ALMemoryProxy_ping(*args)
def raiseEvent(*args): return _inaoqi.ALMemoryProxy_raiseEvent(*args)
def raiseMicroEvent(*args): return _inaoqi.ALMemoryProxy_raiseMicroEvent(*args)
def removeData(*args): return _inaoqi.ALMemoryProxy_removeData(*args)
def removeMicroEvent(*args): return _inaoqi.ALMemoryProxy_removeMicroEvent(*args)
def setDescription(*args): return _inaoqi.ALMemoryProxy_setDescription(*args)
def stop(*args): return _inaoqi.ALMemoryProxy_stop(*args)
def subscribeToEvent(*args): return _inaoqi.ALMemoryProxy_subscribeToEvent(*args)
def subscribeToMicroEvent(*args): return _inaoqi.ALMemoryProxy_subscribeToMicroEvent(*args)
def unregisterModuleReference(*args): return _inaoqi.ALMemoryProxy_unregisterModuleReference(*args)
def unsubscribeToEvent(*args): return _inaoqi.ALMemoryProxy_unsubscribeToEvent(*args)
def unsubscribeToMicroEvent(*args): return _inaoqi.ALMemoryProxy_unsubscribeToMicroEvent(*args)
def version(*args): return _inaoqi.ALMemoryProxy_version(*args)
def wait(*args): return _inaoqi.ALMemoryProxy_wait(*args)
__swig_destroy__ = _inaoqi.delete_ALMemoryProxy
__del__ = lambda self : None;
ALMemoryProxy_swigregister = _inaoqi.ALMemoryProxy_swigregister
ALMemoryProxy_swigregister(ALMemoryProxy)

pynaoqi-python-2.6-naoqi-1.14-mac64/motion.py
# Class Motion for storing useful ALMotion constants
# SPACES
SPACE_TORSO = 0
SPACE_WORLD = 1
SPACE_NAO = 2
# NEW in 1.14
FRAME_TORSO = 0
FRAME_WORLD = 1
FRAME_ROBOT = 2
# MOVEMENT
MVT_RELATIVE = 0
MVT_ABSOLUTE = 1
#ANGLE TYPE
COMMANDS = 0,
SENSORS = 1
# AXIS MASK
AXIS_MASK_X = 1
AXIS_MASK_Y = 2
AXIS_MASK_Z = 4
AXIS_MASK_WX = 8
AXIS_MASK_WY = 16
AXIS_MASK_WZ = 32
AXIS_MASK_ALL = 63
AXIS_MASK_VEL = 7
AXIS_MASK_ROT = 56
# COMPUTING
TO_RAD = 0.01745329
TO_DEG = 57.295779513082323

pynaoqi-python-2.6-naoqi-1.14-mac64/vision_definitions.py
# Useful constants used by the Vision modules.
# Camera model
kOV7670 = 1 # VGA camera
kMT9M114 = 2 # HD wide angle camera
# Image format
k960p = 3 # 1280*960
k4VGA = 3 # 1280*960
kVGA = 2 # 640*480
kQVGA = 1 # 320*240
kQQVGA = 0 # 160*120
# Color Space
kYuvColorSpace = 0
kyUvColorSpace = 1
kyuVColorSpace = 2
kRgbColorSpace = 3
krGbColorSpace = 4
krgBColorSpace = 5
kHsvColorSpace = 6
khSvColorSpace = 7
khsVColorSpace = 8
kYUV422InterlacedColorSpace = 9 #deprecated
kYUV422ColorSpace = 9
kYUVColorSpace = 10
kRGBColorSpace = 11
kHSVColorSpace = 12
kBGRColorSpace = 13
kYYCbCrColorSpace = 14
kH2RGBColorSpace = 15
kHSMixedColorSpace = 16

# Scale methods
kSimpleScaleMethod = 0
kAverageScaleMethod = 1
kQualityScaleMethod = 2
kNoScaling = 3

# Standard Id
kCameraBrightnessID = 0
kCameraContrastID = 1
kCameraSaturationID = 2
kCameraHueID = 3
kCameraRedChromaID = 4
kCameraBlueChromaID = 5
kCameraGainID = 6
kCameraHFlipID = 7
kCameraVFlipID = 8
kCameraLensXID = 9
kCameraLensYID = 10
kCameraAutoExpositionID = 11
kCameraAutoWhiteBalanceID = 12
kCameraAutoGainID = 13
kCameraResolutionID = 14
kCameraFrameRateID = 15
kCameraBufferSizeID = 16
kCameraExposureID = 17
kCameraSelectID = 18
kCameraSetDefaultParamsID = 19
kCameraColorSpaceID = 20
kCameraExposureCorrectionID = 21
kCameraAecAlgorithmID = 22
kCameraFastSwitchID = 23
kCameraSharpnessID = 24
kCameraAwbGreenGainID = 25
kCameraAblcID = 26
kCameraAblcTargetID = 27
kCameraAblcStableRangeID = 28
kCameraBlcBlueID = 29
kCameraBlcRedID = 30
kCameraBlcGbID = 31
kCameraBlcGrID = 32
kCameraWhiteBalanceID = 33
kCameraBacklightCompensationID = 34

pynaoqi-python-2.7-naoqi-1.14-linux32/_inaoqi.so

pynaoqi-python-2.7-naoqi-1.14-linux32/_almath.so

pynaoqi-python-2.7-naoqi-1.14-linux32/naoqi.py
import os
import sys
import weakref
import logging

try:
import _inaoqi
except ImportError:
# quick hack to keep inaoqi.py happy
if sys.platform.startswith(“win”):
print “Could not find _inaoqi, trying with _inaoqi_d”
import _inaoqi_d as _inaoqi
else:
raise
import inaoqi
import motion
import allog
def autoBind(myClass, bindIfnoDocumented):
“””Show documentation for each
method of the class”””
# dir(myClass) is a list of the names of
# everything in class
myClass.setModuleDescription(myClass.__doc__)
for thing in dir(myClass):
# getattr(x, “y”) is exactly: x.y
function = getattr(myClass, thing)
if callable(function):
if (type(function) == type(myClass.__init__)):
if (bindIfnoDocumented or function.__doc__ != “”):
if (thing[0] != “_”): # private method
if (function.__doc__):
myClass.functionName(thing, myClass.getName(), function.__doc__)
else:
myClass.functionName(thing, myClass.getName(), “”)
for param in function.func_code.co_varnames:
if (param != “self”):
myClass.addParam(param)
myClass._bindWithParam(myClass.getName(),thing,len(function.func_code.co_varnames)-1)

class ALDocable():
def __init__(self, bindIfnoDocumented):
autoBind(self,bindIfnoDocumented)

# define the log handler to be used by the logging module
class ALLogHandler(logging.Handler):
def __init__(self):
logging.Handler.__init__(self)
def emit(self, record):
level_to_function = {
logging.DEBUG: allog.debug,
logging.INFO: allog.info,
logging.WARNING: allog.warning,
logging.ERROR: allog.error,
logging.CRITICAL: allog.fatal,
}
function = level_to_function.get(record.levelno, allog.debug)
function(record.getMessage(),
record.name,
record.filename,
record.funcName,
record.lineno)

# Same as above, but we force the category to be behavior.box
# *AND* we prefix the message with the module name
# look at errorInBox in choregraphe for explanation
class ALBehaviorLogHandler(logging.Handler):
def __init__(self):
logging.Handler.__init__(self)
def emit(self, record):
level_to_function = {
logging.DEBUG: allog.debug,
logging.INFO: allog.info,
logging.WARNING: allog.warning,
logging.ERROR: allog.error,
logging.CRITICAL: allog.fatal,
}
function = level_to_function.get(record.levelno, allog.debug)
function(record.name + “: ” + record.getMessage(),
“behavior.box”,
“”, # record.filename in this case is simply ‘‘
record.funcName,
record.lineno)
# define a class that will be inherited by both ALModule and ALBehavior, to store instances of modules, so a bound method can be called on them.
class NaoQiModule():
_modules = dict()
@classmethod
def getModule(cls, name):
# returns a reference a module, giving its string, if it exists !
if(name not in cls._modules):
raise RuntimeError(“Module ” + str(name) + ” does not exist”)
return cls._modules[name]()
def __init__(self, name, logger=True):
# keep a weak reference to ourself, so a proxy can be called on this module easily
self._modules[name] = weakref.ref(self)
self.loghandler = None
if logger:
self.logger = logging.getLogger(name)
self.loghandler = ALLogHandler()
self.logger.addHandler(self.loghandler)
self.logger.setLevel(logging.DEBUG)
def __del__(self):
# when object is deleted, clean up dictionnary so we do not keep a weak reference to it
del self._modules[self.getName()]
if(self.loghandler != None):
self.logger.removeHandler(self.loghandler)

class ALBroker(inaoqi.broker):
def init(self):
pass
class ALModule(inaoqi.module, ALDocable, NaoQiModule):
def __init__(self,param):
inaoqi.module.__init__(self, param)
ALDocable.__init__(self, False)
NaoQiModule.__init__(self, param)
def __del__(self):
NaoQiModule.__del__(self)
def methodtest(self):
pass
def pythonChanged(self, param1, param2, param3):
pass

class ALBehavior(inaoqi.behavior, NaoQiModule):
# class var in order not to build it each time
_noNeedToBind = set(dir(inaoqi.behavior))
_noNeedToBind.add(“getModule”)
_noNeedToBind.add(“onLoad”)
_noNeedToBind.add(“onUnload”)
# deprecated since 1.14 methods
_noNeedToBind.add(“log”)
_noNeedToBind.add(“playTimeline”)
_noNeedToBind.add(“stopTimeline”)
_noNeedToBind.add(“exitBehavior”)
_noNeedToBind.add(“gotoAndStop”)
_noNeedToBind.add(“gotoAndPlay”)
_noNeedToBind.add(“playTimelineParent”)
_noNeedToBind.add(“stopTimelineParent”)
_noNeedToBind.add(“exitBehaviorParent”)
_noNeedToBind.add(“gotoAndPlayParent”)
_noNeedToBind.add(“gotoAndStopParent”)
def __init__(self, param, autoBind):
inaoqi.behavior.__init__(self, param)
NaoQiModule.__init__(self, param, logger=False)
self.logger = logging.getLogger(param)
self.behaviorloghandler = ALBehaviorLogHandler()
self.logger.addHandler(self.behaviorloghandler)
self.logger.setLevel(logging.DEBUG)
self.resource = False
self.BIND_PYTHON(self.getName(), “__onLoad__”)
self.BIND_PYTHON(self.getName(), “__onUnload__”)
if(autoBind):
behName = self.getName()
userMethList = set(dir(self)) – self._noNeedToBind
for methName in userMethList:
function = getattr(self, methName)
if callable(function) and type(function) == type(self.__init__):
if (methName[0] != “_”): # private method
self.functionName(methName, behName, “”)
for param in function.func_code.co_varnames:
if (param != “self”):
self.addParam(param)
self._bindWithParam(behName,methName,len(function.func_code.co_varnames)-1)
def __del__(self):
NaoQiModule.__del__(self)
self.logger.removeHandler(self.behaviorloghandler)
self.behaviorloghandler.close()
def __onLoad__(self):
self._safeCallOfUserMethod(“onLoad”,None)
def __onUnload__(self):
if(self.resource):
self.releaseResource()
self._safeCallOfUserMethod(“onUnload”,None)
def setParameter(self, parameterName, newValue):
inaoqi.behavior.setParameter(self, parameterName, newValue)
def _safeCallOfUserMethod(self, functionName, functionArg):
try:
if(functionName in dir(self)):
func = getattr(self, functionName)
if(func.im_func.func_code.co_argcount == 2):
func(functionArg)
else:
func()
return True
except BaseException, err:
self.logger.error(str(err))
try:
if(“onError” in dir(self)):
self.onError(self.getName() + ‘:’ +str(err))
except BaseException, err2:
self.logger.error(str(err2))
return False
# Depreciate this!!! Same as self.logger.info(), but function is always “log”
def log(self, p):
self.logger.info(p)

class MethodMissingMixin(object):
“”” A Mixin’ to implement the ‘method_missing’ Ruby-like protocol. “””
def __getattribute__(self, attr):
try:
return object.__getattribute__(self, attr)
except:
class MethodMissing(object):
def __init__(self, wrapped, method):
self.__wrapped__ = wrapped
self.__method__ = method
def __call__(self, *args, **kwargs):
return self.__wrapped__.method_missing(self.__method__, *args, **kwargs)
return MethodMissing(self, attr)
def method_missing(self, *args, **kwargs):
“”” This method should be overridden in the derived class. “””
raise NotImplementedError(str(self.__wrapped__) + ” ‘method_missing’ method has not been implemented.”)

class postType(MethodMissingMixin):
def __init__(self):
“”
def setProxy(self, proxy):
self.proxy = weakref.ref(proxy)
# print name
def method_missing(self, method, *args, **kwargs):
list = []
list.append(method)
for arg in args:
list.append(arg)
result = 0
try:
p = self.proxy()
result = p.pythonPCall(list)
except RuntimeError,e:
raise e
return result

class ALProxy(inaoqi.proxy,MethodMissingMixin):
def __init__(self, *args):
self.post = postType()
self.post.setProxy(self)
if (len (args) == 1):
inaoqi.proxy.__init__(self, args[0])
elif (len (args) == 2):
inaoqi.proxy.__init__(self, args[0], args[1])
else:
inaoqi.proxy.__init__(self, args[0], args[1], args[2])
def call(self, *args):
list = []
for arg in args:
list.append(arg)
return self.pythonCall(list)

def pCall(self, *args):
list = []
for arg in args:
list.append(arg)
return self.pythonPCall(list)

def method_missing(self, method, *args, **kwargs):
list = []
list.append(method)
for arg in args:
list.append(arg)
result = 0
try:
result = self.pythonCall(list)
except RuntimeError,e:
raise e
#print e.args[0]
return result
@staticmethod
def initProxies():
#Warning: The use of these default proxies is deprecated.
global ALMemory
global ALMotion
global ALFrameManager
global ALLeds
global ALLogger
global ALSensors
try:
ALMemory = inaoqi.getMemoryProxy()
except:
ALMemory = ALProxy(“ALMemory”)
try:
ALFrameManager = ALProxy(“ALFrameManager”)
except:
print “No proxy to ALFrameManager”
try:
ALMotion = ALProxy(“ALMotion”)
except:
print “No proxy to ALMotion”
try:
ALLeds = ALProxy(“ALLeds”)
except:
pass
try:
ALLogger = ALProxy(“ALLogger”)
except:
print “No proxy to ALLogger”
try:
ALSensors = ALProxy(“ALSensors”)
except:
pass

def createModule(name):
global moduleList
str = “moduleList.append(“+ “module(\”” + name + “\”))”
exec(str)

pynaoqi-python-2.7-naoqi-1.14-linux32/license.rtf

End-
User Software License Agreement

This Limited End-User Software License Agreement (the “Agreement”) is a legal agreement between you (“Licensee”), the end-user, and Aldebaran Robotics SAS having its registered office at 168-170 Rue Raymond Losserand, 75014 Paris, France, registered with the trade and companies register of Paris under number 483 185 807 (hereinafter “Aldebaran”) for the use of the ” Aldebaran Software Toolkit ” (“Software”). By using this software or storing this program on a computer or robot hard drive (or other media), you are agreeing to be bound by the terms of this Agreement. If you do not agree to any of the terms of this agreement uninstall and delete the software from all storage media.

ARTICLE 1 – RIGHTS GRANTED

ALDEBARAN grants to the LICENSEE a personal, non-exclusive, non-transferable, non sub-licensable right to install and use the Software and the Documentation (if any), for the duration of the applicable intellectual property rights.

ALDEBARAN shall have the right to make update and/or upgrade of the Software. However this Agreement does not grant any right on any update or upgrade of the Software. In the event ALDEBARAN provided an upgrade or upgrade of the Software which is not used by Licensee will not benefit from warranties given by ALDABARAN within this Agreement (as far as permitted by the applicable law).

ALDEBARAN may discontinue or change the Software, at any time or for any reason, with or without notice. To avoid any misunderstanding it is agreed that ALDEBARAN has no right to operate a change on the LICENSEE‘s device where the Software is install without its consent.

This Agreement does not grant any right to any Third-Party Software.

Some Third-Party Software may be needed to permit the Software to operate properly. Even in such event ALDEBARAN is not granting any right on the Third-Party Software. The Third-Party Software remains subject to the specific licenses applicable to each Third-Party Software and as described in their related applicable documentation. Licensee shall on his owns decide to either accept or not the applicable terms and conditions related to Third-Party Software. Licensee accepts and understands that refusing the terms and conditions applicable to Third-Party Software may impact in whole or in part the use of the Software.

ARTICLE 2 – OBLIGATIONS OF THE LICENSEE

LICENSEE agrees to the following:

– The LICENSEE shall strictly comply with the user instructions set forth in the Documentation;

– Even if LICENSEE keeps its right of objectively critic the Software, the LICENSEE shall not take any action to impair the reputation of the Product, the trademarks of ALDEBARAN or its licensors and any other product of ALDEBARAN or its licensors;

– LICENSEE shall in no event use the Software for any illegal, defaming, pornographic or detrimental activities;

– The LICENSEE shall use the ALDEBARAN name and trademarks only in the manner prescribed by ALDEBARAN in writing;

– The LICENSEE shall inform ALDEBARAN of any potential defects discovered when using the Product;

– The LICENSEE shall notify ALDEBARAN promptly of any legal notices, claims or actions directly or indirectly relating to the Software against a third party and not enter into or compromise any legal action or other proceeding relating to the Software without the prior written consent of ALDEBARAN;

– The LICENSEE shall not use, without the prior written consent of ALDEBARAN, the Software for the benefit of third parties in any manner, and in particular:

(a) not sell, resell, lease, transfer, license or sublicense or otherwise provide the Software to any third party, and, in a more general manner, not communicate all or part of the Software to any third party;

(b) not charge or otherwise deal in or encumber the Software;

– The LICENSEE shall not delete, remove or in any way obscure the proprietary notices, labels or marks of ALDEBARAN or its licensors on the Software and conspicuously display the proprietary notices, labels or marks on any copy of the Software;

– Except otherwise expressly agreed the LICENSEE shall not alter, modify, decompile, disassemble, or reverse engineer the program code or any other part of the Software, in whole or in part, except in the events and only to the extent expressly provided by law. However, even if the law authorizes the above acts, LICENSEE shall give ALDEBARAN a written notice seven (7) calendar days prior to the date on which these acts are scheduled to take place and allow a representative of ALDEBARAN to be present during these acts;

– Except otherwise expressly agreed the LICENSEE shall not develop any other software programs or derivative works on the basis of the Software. Any such software program or derivative work shall in no case be sold, assigned or licensed by the LICENSEE;

– To avoid any misunderstanding it is agreed that LICENSEE shall have the right to use and exploit the result given by the use of the software in conformity of this license agreement.

– The LICENSEE shall not use the Software for illegal purposes or in illegal manner, including in violation of the intellectual property rights of ALDEBARAN or any third party;

– The LICENSEE shall provide ALDEBARAN promptly with any information, material, software or specification as may reasonably be required for the proper performance of this Agreement including access to appropriate members of the LICENSEE’s staff. The LICENSEE is responsible for the completeness and accuracy of such information, material, software or specification;

ARTICLE 3 – LIMITED WARRANTIES AND LIMITATION OF LIABILITY

3.1 ALDEBARAN warrants that it has full title and ownership to the Software. ALDEBARAN also warrants that it has the full power and authority to enter into this agreement and to grant the license conveyed in this Agreement. Aldebaran warrants that the use of the Software in conformity with this Agreement will in no way constitute an infringement or other violation of any Intellectual Property of any third party.
Should the Software give rise, or in ALDEBARAN opinion be likely to give rise to any such claim, ALDEBARAN shall, at its option and expense, either:

(i) procure for LICENSEE the right to continue using such Aldebaran Software; or
(ii) replace or modify the Aldebaran Software so that it does not infringe the intellectual property rights anymore; or
(iii) terminate the right of use of the Software.

Except as set out in this Agreement, all conditions, warranties and representations in relation to the Software are excluded to the extent permitted under applicable law.

3.2 AS FAR AS PERMITTED BY THE APPLICABLE LAW:

ALDEBARAN PROVIDES THE SOFTWARE “AS IS”, AND DOES NOT WARRANT THAT THE USE OF THE SOFTWARE, FUNCTIONALITY, THE OPERATION AND/OR CONTENT WILL BE: UNINTERRUPTED, ACCURATE, COMPLETE, FREE FROM ANY SOFTWARE VIRUS OR OTHER HARMFUL COMPONENT.

ALDEBARAN DOES NOT WARRANT THE INTERNAL CHARACTERISTICS, THE COMPATIBILITY FO THE SOFTWARE WITH OTHER SOFTWARE, THE ACCURACY, ADEQUACY, OR COMPLETENESS OF SOTWARE AND ITS RESULT AND DISCLAIMS LIABILITY FOR ERRORS OR OMISSIONS.

ALDEBARAN DISCLAIMS ANY REPRESENTATIONS, WARRANTIES OR CONDITIONS, EXPRESS OR IMPLIED, INCLUDING THOSE OF PERFORMANCE OR MERCHANTABILITY OR RELIABILITY USEFULNESS OR FITNESS FOR A PARTICULAR PURPOSE WITH RESPECT TO THE SOFTWARE AND ITS RESULTS.

3.3 IN NO EVENT WILL ALDEBARAN BE LIABLE FOR ANY DAMAGES (INCLUDING WITHOUT LIMITATION DIRECT, INDIRECT, PUNITIVE, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES, COST OF PROCURING SUBSTITUTE SERVICES, LOST PROFITS, LOSS OF DATA, LOSSES, OR OTHER EXPENSES) ARISING IN CONNECTION WITH THE PROVISION OR USE OF THE SOFTWARE, RELATED SERVICES OR INFORMATION PROVIDED PURSUANT TO THIS AGREEMENT, REGARDLESS OF WHETHER SUCH CLAIMS ARE BASED ON CONTRACT, TORT, STRICT LIABILITY, OR OTHERWISE, OR WHETHER PROVIDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES, LOSSES, OR EXPENSES.

WITHOUT LIMITING THE FOREGOING, THIS LIMITATION OF LIABILITY INCLUDES, BUT IS NOT LIMITED TO, THE UNAVAILABILITY OF THE APPLICATION(S), UNAUTHORIZED ACCESS, ANY FAILURE OF PERFORMANCE, INTERRUPTION, ERROR, OMISSION, DEFECT, DELAY IN OPERATION OR TRANSMISSION, COMPUTER VIRUS, OR SYSTEM FAILURE.

NOTWITHSTANDING ANYTHING TO THE CONTRARY IN THIS AGREEMENT OR ANY STATUTE OR RULE OF LAW TO THE CONTRARY, SUBJECT TO THIS ARTICLE, ALDEBARAN’S CUMULATIVE LIABILITY FOR ALL CLAIMS ARISING OUT OF OR IN CONNECTION WITH THIS AGREEMENT, WHETHER DIRECTLY OR INDIRECTLY, SHALL NOT EXCEED ALL FEES PAID TO ALDEBARAN BY THE LICENSEE FOR THE USE OF THE SOFTWARE. IN THE EVENT THE SOFTWARE IS GRANTED FOR FREE TO THE LICENSEE, ALDEBARAN’S CUMULATIVE LIABILITY FOR ALL CLAIMS ARISING OUT OF OR IN CONNECTION WITH THIS AGREEMENT, WHETHER DIRECTLY OR INDIRECTLY, SHALL NOT EXCEED 100 € (ONE HUNDRED EUROS).

WHENEVER THE ABOVE SECTIONS ARE NOT APPLICABLE UNDER THE APPLYING LAW ALDEBARAN AS SOLE REMEDY SHALL AT ITS OPTION AND EXPENSE EITHER (I) REPAIR THE DEFECTIVE OR INFRINGING SOFTWARE, OR (II) REPLACE THE DEFECTIVE OR INFRINGING SOFTWARE, OR (III) REIMBURSE THE FEE PAID TO ALDEBARAN FOR THE DEFECTIVE OR INFRINGING SOFTWARE. THESE REMEDIES ARE EXCLUSIVE OF ANY OTHER REMEDIES AND ANY OTHER WARRANTY IS EXCLUDED.

ANY INDEMNIFICATION BY ALDEBARAN UNDER THIS WARRANTY IS EXCLUDED IF THE CLAIM IS BASED UPON (I) A MODIFIED VERSION OF THE SOFTWARE FOR WHICH THE CHANGES HAVE NOT BEEN EXPRESSLY AUTHORIZED OR VALIDATED BY ALDEBARAN, OR (II) A COMBINATION, INSTALLATION OR USE OF ANY SOFTWARE COMPONENT EMBEDDED IN THE NAO ROBOT WITH ANY OTHER ELEMENT, MATERIAL OR ITEM THAT IS NOT EXPRESSLY PROVIDED BY ALDEBARAN FOR COMBINATION, INSTALLATION OR USE WITH THE SOFTWARE,
OR (III) A COMBINATION, INSTALLATION OR USE OF THE SOFTWARE WITH ANY OTHER ELEMENT, MATERIAL OR ITEM THAT IS NOT EXPRESSLY AUTHORIZED BY ALDEBARAN FOR COMBINATION, INSTALLATION OR USE WITH THE SOFTWARE, OR (IV) ANY OTHER FAULT OR NEGLIGENCE OF LICENSEE OR A THIRD PARTY.

This warranty does not cover incorrect installation or use by any third party; misuse of the Software voids the warranty.
The Third-Party Software is warranted only as provided in the specific licenses applicable to each.

ARTICLE 4 – INTELLECTUAL PROPERTY

ALDEBARAN is the owner or licensee of the Software. Title, copyright and any other proprietary and intellectual property right in the Software shall remain vested in ALDEBARAN or its licensors. The rights granted to the LICENSEE under this Agreement do not transfer to the LICENSEE title or any proprietary or intellectual property rights to the Software and do not constitute a sale of such rights;

ALDEBARAN shall retain the ownership of all rights in any inventions, discoveries, improvements, ideas, techniques or know-how embodied conceived by ALDEBARAN under this Agreement, including, without limitation, its methods of work, programs, methodologies and related documentation, including any derivative works of software code developed by ALDEBARAN in the course of performing this Agreement as well any knowledge and experience of ALDEBARAN’s directors, staff and consultants.

ARTICLE 5
–

COLLECTION AND USE OF PERSONAL INFORMATION

Privacy of the Licensee is important to ALDEBARAN. Therefore ALDEBARAN is not collecting any personal data except as expressly agreed by the Licensee.

ALDEBARAN will abide any applicable law, rules, or regulations relating to the privacy of personal information. Such data shall only be used for the purposes for which it was provided. Licensee understands that Third Party software may have their own privacy policy which may be less secure than the Aldebaran’s privacy policy.

ALDEBARAN will do its best to ensure that any personal data which may be collected from the Licensee will remain confidential.

Licensee hereby agrees and consents that the following data maybe collected by ALDEBARAN in order permit a network-enhanced services, improve the general quality and/or functionality of its products and/or software, permit development of new version of its products and/or software, fix bug or defect, develop patch and other solution, permit to install new version, update or upgrade, monitor and/or permit the maintenance of Aldebaran products and/or software:
Crash reporting, robot ID, robot health metrics, hardware-specific preferences, application install history, user preferences.

Licensee expressly consents that Aldebaran may generate statistical data from the information provided through the Software without identifying Licensee.
Licensee understands and agrees that, within the course of the use of the software, some voice data and/or video data could transit through ALDEBARAN and/or other third party network.

ARTICLE 6 – NO TRANSFER OR ASSIGNMENT

In no event shall LICENSEE sublicense, assign or otherwise transfer all or part of its rights and obligations under this Agreement to any third party. Any such sublicensing, assignment or transfer shall be null and void, unless expressly agreed to by ALDEBARAN in writing.

ARTICLE 7 – MISCELLEANEOUS

Termination. Either party may terminate this Agreement without advance notice. In case of breach of this Agreement by the Licensee, the authorization to access and use the Software will automatically terminate absent Aldebaran’s written waiver of such breach.

Survival. To the extent applicable, the following articles shall survive the termination, cancellation, expiration, and/or rescission of this Agreement: Articles 3.3, 4, 5, 7 and any provision that expressly states its survival and/or are necessary for the enforcement of this Agreement.

Headings. The headings referred to or used in this Agreement are for reference and convenience purposes only and shall not in any way limit or affect the meaning or interpretation of any of the terms hereof.

Severability. If any of the provisions of this Agreement are held or deemed to be invalid, illegal or unenforceable, the remaining provisions of this Agreement shall be unimpaired, and the invalid, illegal or unenforceable provision shall be replaced by a mutually acceptable provision, which being valid, legal and enforceable, comes closest to the intention of the Parties underlying the invalid, illegal or unenforceable provision.

Waiver. Any failure or delay by either Party in exercising its right under any provisions of the Agreement shall not be construed as a waiver of those rights at any time now or in the future unless an express declaration in writing from the Party concerned.

Governing law and Jurisdiction. Parties agree that all matters arising from or relating to the Software and this Agreement, shall be governed by the laws of France, without regard to conflict of laws principles. In the event of any dispute between the Parties, the Parties agreed to meet to discuss their dispute before resorting to formal dispute resolution procedures.

BY CLICKING “AGREE”, YOU AS LICENSEE ACKNOWLEDGE THAT YOU HAVE READ, UNDERSTAND AND ACCEPT THIS LIMITED END-USER SOFTWARE LICENSE AGREEMENT.

BY CLICKING “AGREE” YOU AS LICENSEE AGREE TO BE BOUND BY ALL OF ITS TERMS AND CONDITIONS OF THIS LIMITED END-USER SOFTWARE LICENSE AGREEMENT.

IF YOU AS A LICENSEE DO NOT AGREE TO ANY TERMS AND CONDITIONS, OF THIS LIMITED END-USER SOFTWARE LICENSE AGREEMENT DO NOT INSTALL OR USE THE SOFTWARE AND CLICK ON “DISAGREE”. By CLICKING ON “DESAGREE” YOU WILL NOT BE ABLE TO USE THE SOFTWARE.

pynaoqi-python-2.7-naoqi-1.14-linux32/allog.py
# This file was automatically generated by SWIG (http://www.swig.org).
# Version 1.3.40
#
# Do not make changes to this file unless you know what you are doing–modify
# the SWIG interface file instead.
# This file is compatible with both classic and new-style classes.
from sys import version_info
if version_info >= (2,6,0):
def swig_import_helper():
from os.path import dirname
import imp
fp = None
try:
fp, pathname, description = imp.find_module(‘_allog’, [dirname(__file__)])
except ImportError:
import _allog
return _allog
if fp is not None:
try:
_mod = imp.load_module(‘_allog’, fp, pathname, description)
finally:
fp.close()
return _mod
_allog = swig_import_helper()
del swig_import_helper
else:
import _allog
del version_info
try:
_swig_property = property
except NameError:
pass # Python < 2.2 doesn't have 'property'. 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__ == 'SwigPyObject': 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,)
try:
_object = object
_newclass = 1
except AttributeError:
class _object : pass
_newclass = 0

def debug(*args):
return _allog.debug(*args)
debug = _allog.debug
def info(*args):
return _allog.info(*args)
info = _allog.info
def warning(*args):
return _allog.warning(*args)
warning = _allog.warning
def error(*args):
return _allog.error(*args)
error = _allog.error
def fatal(*args):
return _allog.fatal(*args)
fatal = _allog.fatal

pynaoqi-python-2.7-naoqi-1.14-linux32/almath.py
# This file was automatically generated by SWIG (http://www.swig.org).
# Version 1.3.40
#
# Do not make changes to this file unless you know what you are doing–modify
# the SWIG interface file instead.
# This file is compatible with both classic and new-style classes.
from sys import version_info
if version_info >= (2,6,0):
def swig_import_helper():
from os.path import dirname
import imp
fp = None
try:
fp, pathname, description = imp.find_module(‘_almath’, [dirname(__file__)])
except ImportError:
import _almath
return _almath
if fp is not None:
try:
_mod = imp.load_module(‘_almath’, fp, pathname, description)
finally:
fp.close()
return _mod
_almath = swig_import_helper()
del swig_import_helper
else:
import _almath
del version_info
try:
_swig_property = property
except NameError:
pass # Python < 2.2 doesn't have 'property'. 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__ == 'SwigPyObject': 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,)
try:
_object = object
_newclass = 1
except AttributeError:
class _object : pass
_newclass = 0

class SwigPyIterator(_object):
“””Proxy of C++ swig::SwigPyIterator class”””
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, SwigPyIterator, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, SwigPyIterator, name)
def __init__(self, *args, **kwargs): raise AttributeError(“No constructor defined – class is abstract”)
__repr__ = _swig_repr
__swig_destroy__ = _almath.delete_SwigPyIterator
__del__ = lambda self : None;
def value(self):
“””value(self) -> PyObject”””
return _almath.SwigPyIterator_value(self)
def incr(self, n = 1):
“””
incr(self, size_t n = 1) -> SwigPyIterator
incr(self) -> SwigPyIterator
“””
return _almath.SwigPyIterator_incr(self, n)
def decr(self, n = 1):
“””
decr(self, size_t n = 1) -> SwigPyIterator
decr(self) -> SwigPyIterator
“””
return _almath.SwigPyIterator_decr(self, n)
def distance(self, *args):
“””distance(self, SwigPyIterator x) -> ptrdiff_t”””
return _almath.SwigPyIterator_distance(self, *args)
def equal(self, *args):
“””equal(self, SwigPyIterator x) -> bool”””
return _almath.SwigPyIterator_equal(self, *args)
def copy(self):
“””copy(self) -> SwigPyIterator”””
return _almath.SwigPyIterator_copy(self)
def next(self):
“””next(self) -> PyObject”””
return _almath.SwigPyIterator_next(self)
def __next__(self):
“””__next__(self) -> PyObject”””
return _almath.SwigPyIterator___next__(self)
def previous(self):
“””previous(self) -> PyObject”””
return _almath.SwigPyIterator_previous(self)
def advance(self, *args):
“””advance(self, ptrdiff_t n) -> SwigPyIterator”””
return _almath.SwigPyIterator_advance(self, *args)
def __eq__(self, *args):
“””__eq__(self, SwigPyIterator x) -> bool”””
return _almath.SwigPyIterator___eq__(self, *args)
def __ne__(self, *args):
“””__ne__(self, SwigPyIterator x) -> bool”””
return _almath.SwigPyIterator___ne__(self, *args)
def __iadd__(self, *args):
“””__iadd__(self, ptrdiff_t n) -> SwigPyIterator”””
return _almath.SwigPyIterator___iadd__(self, *args)
def __isub__(self, *args):
“””__isub__(self, ptrdiff_t n) -> SwigPyIterator”””
return _almath.SwigPyIterator___isub__(self, *args)
def __add__(self, *args):
“””__add__(self, ptrdiff_t n) -> SwigPyIterator”””
return _almath.SwigPyIterator___add__(self, *args)
def __sub__(self, *args):
“””
__sub__(self, ptrdiff_t n) -> SwigPyIterator
__sub__(self, SwigPyIterator x) -> ptrdiff_t
“””
return _almath.SwigPyIterator___sub__(self, *args)
def __iter__(self): return self
SwigPyIterator_swigregister = _almath.SwigPyIterator_swigregister
SwigPyIterator_swigregister(SwigPyIterator)
class vectorFloat(_object):
“””Proxy of C++ std::vector<(float)> class”””
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, vectorFloat, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, vectorFloat, name)
def iterator(self):
“””iterator(self) -> SwigPyIterator”””
return _almath.vectorFloat_iterator(self)
def __iter__(self): return self.iterator()
def __nonzero__(self):
“””__nonzero__(self) -> bool”””
return _almath.vectorFloat___nonzero__(self)
def __bool__(self):
“””__bool__(self) -> bool”””
return _almath.vectorFloat___bool__(self)
def __len__(self):
“””__len__(self) -> size_type”””
return _almath.vectorFloat___len__(self)
def pop(self):
“””pop(self) -> value_type”””
return _almath.vectorFloat_pop(self)
def __getslice__(self, *args):
“””__getslice__(self, difference_type i, difference_type j) -> vectorFloat”””
return _almath.vectorFloat___getslice__(self, *args)
def __setslice__(self, *args):
“””__setslice__(self, difference_type i, difference_type j, vectorFloat v)”””
return _almath.vectorFloat___setslice__(self, *args)
def __delslice__(self, *args):
“””__delslice__(self, difference_type i, difference_type j)”””
return _almath.vectorFloat___delslice__(self, *args)
def __delitem__(self, *args):
“””
__delitem__(self, difference_type i)
__delitem__(self, PySliceObject slice)
“””
return _almath.vectorFloat___delitem__(self, *args)
def __getitem__(self, *args):
“””
__getitem__(self, PySliceObject slice) -> vectorFloat
__getitem__(self, difference_type i) -> value_type
“””
return _almath.vectorFloat___getitem__(self, *args)
def __setitem__(self, *args):
“””
__setitem__(self, PySliceObject slice, vectorFloat v)
__setitem__(self, difference_type i, value_type x)
“””
return _almath.vectorFloat___setitem__(self, *args)
def append(self, *args):
“””append(self, value_type x)”””
return _almath.vectorFloat_append(self, *args)
def empty(self):
“””empty(self) -> bool”””
return _almath.vectorFloat_empty(self)
def size(self):
“””size(self) -> size_type”””
return _almath.vectorFloat_size(self)
def clear(self):
“””clear(self)”””
return _almath.vectorFloat_clear(self)
def swap(self, *args):
“””swap(self, vectorFloat v)”””
return _almath.vectorFloat_swap(self, *args)
def get_allocator(self):
“””get_allocator(self) -> allocator_type”””
return _almath.vectorFloat_get_allocator(self)
def begin(self):
“””begin(self) -> const_iterator”””
return _almath.vectorFloat_begin(self)
def end(self):
“””end(self) -> const_iterator”””
return _almath.vectorFloat_end(self)
def rbegin(self):
“””rbegin(self) -> const_reverse_iterator”””
return _almath.vectorFloat_rbegin(self)
def rend(self):
“””rend(self) -> const_reverse_iterator”””
return _almath.vectorFloat_rend(self)
def pop_back(self):
“””pop_back(self)”””
return _almath.vectorFloat_pop_back(self)
def erase(self, *args):
“””
erase(self, iterator pos) -> iterator
erase(self, iterator first, iterator last) -> iterator
“””
return _almath.vectorFloat_erase(self, *args)
def __init__(self, *args):
“””
__init__(self) -> vectorFloat
__init__(self, vectorFloat arg0) -> vectorFloat
__init__(self, size_type size) -> vectorFloat
__init__(self, size_type size, value_type value) -> vectorFloat
“””
this = _almath.new_vectorFloat(*args)
try: self.this.append(this)
except: self.this = this
def push_back(self, *args):
“””push_back(self, value_type x)”””
return _almath.vectorFloat_push_back(self, *args)
def front(self):
“””front(self) -> value_type”””
return _almath.vectorFloat_front(self)
def back(self):
“””back(self) -> value_type”””
return _almath.vectorFloat_back(self)
def assign(self, *args):
“””assign(self, size_type n, value_type x)”””
return _almath.vectorFloat_assign(self, *args)
def resize(self, *args):
“””
resize(self, size_type new_size)
resize(self, size_type new_size, value_type x)
“””
return _almath.vectorFloat_resize(self, *args)
def insert(self, *args):
“””
insert(self, iterator pos, value_type x) -> iterator
insert(self, iterator pos, size_type n, value_type x)
“””
return _almath.vectorFloat_insert(self, *args)
def reserve(self, *args):
“””reserve(self, size_type n)”””
return _almath.vectorFloat_reserve(self, *args)
def capacity(self):
“””capacity(self) -> size_type”””
return _almath.vectorFloat_capacity(self)
def __repr__(self):
“””__repr__(self) -> string”””
return _almath.vectorFloat___repr__(self)
__swig_destroy__ = _almath.delete_vectorFloat
__del__ = lambda self : None;
vectorFloat_swigregister = _almath.vectorFloat_swigregister
vectorFloat_swigregister(vectorFloat)
class vectorPosition2D(_object):
“””Proxy of C++ std::vector<(AL::Math::Position2D)> class”””
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, vectorPosition2D, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, vectorPosition2D, name)
def iterator(self):
“””iterator(self) -> SwigPyIterator”””
return _almath.vectorPosition2D_iterator(self)
def __iter__(self): return self.iterator()
def __nonzero__(self):
“””__nonzero__(self) -> bool”””
return _almath.vectorPosition2D___nonzero__(self)
def __bool__(self):
“””__bool__(self) -> bool”””
return _almath.vectorPosition2D___bool__(self)
def __len__(self):
“””__len__(self) -> size_type”””
return _almath.vectorPosition2D___len__(self)
def pop(self):
“””pop(self) -> value_type”””
return _almath.vectorPosition2D_pop(self)
def __getslice__(self, *args):
“””__getslice__(self, difference_type i, difference_type j) -> vectorPosition2D”””
return _almath.vectorPosition2D___getslice__(self, *args)
def __setslice__(self, *args):
“””__setslice__(self, difference_type i, difference_type j, vectorPosition2D v)”””
return _almath.vectorPosition2D___setslice__(self, *args)
def __delslice__(self, *args):
“””__delslice__(self, difference_type i, difference_type j)”””
return _almath.vectorPosition2D___delslice__(self, *args)
def __delitem__(self, *args):
“””
__delitem__(self, difference_type i)
__delitem__(self, PySliceObject slice)
“””
return _almath.vectorPosition2D___delitem__(self, *args)
def __getitem__(self, *args):
“””
__getitem__(self, PySliceObject slice) -> vectorPosition2D
__getitem__(self, difference_type i) -> value_type
“””
return _almath.vectorPosition2D___getitem__(self, *args)
def __setitem__(self, *args):
“””
__setitem__(self, PySliceObject slice, vectorPosition2D v)
__setitem__(self, difference_type i, value_type x)
“””
return _almath.vectorPosition2D___setitem__(self, *args)
def append(self, *args):
“””append(self, value_type x)”””
return _almath.vectorPosition2D_append(self, *args)
def empty(self):
“””empty(self) -> bool”””
return _almath.vectorPosition2D_empty(self)
def size(self):
“””size(self) -> size_type”””
return _almath.vectorPosition2D_size(self)
def clear(self):
“””clear(self)”””
return _almath.vectorPosition2D_clear(self)
def swap(self, *args):
“””swap(self, vectorPosition2D v)”””
return _almath.vectorPosition2D_swap(self, *args)
def get_allocator(self):
“””get_allocator(self) -> allocator_type”””
return _almath.vectorPosition2D_get_allocator(self)
def begin(self):
“””begin(self) -> const_iterator”””
return _almath.vectorPosition2D_begin(self)
def end(self):
“””end(self) -> const_iterator”””
return _almath.vectorPosition2D_end(self)
def rbegin(self):
“””rbegin(self) -> const_reverse_iterator”””
return _almath.vectorPosition2D_rbegin(self)
def rend(self):
“””rend(self) -> const_reverse_iterator”””
return _almath.vectorPosition2D_rend(self)
def pop_back(self):
“””pop_back(self)”””
return _almath.vectorPosition2D_pop_back(self)
def erase(self, *args):
“””
erase(self, iterator pos) -> iterator
erase(self, iterator first, iterator last) -> iterator
“””
return _almath.vectorPosition2D_erase(self, *args)
def __init__(self, *args):
“””
__init__(self) -> vectorPosition2D
__init__(self, vectorPosition2D arg0) -> vectorPosition2D
__init__(self, size_type size) -> vectorPosition2D
__init__(self, size_type size, value_type value) -> vectorPosition2D
“””
this = _almath.new_vectorPosition2D(*args)
try: self.this.append(this)
except: self.this = this
def push_back(self, *args):
“””push_back(self, value_type x)”””
return _almath.vectorPosition2D_push_back(self, *args)
def front(self):
“””front(self) -> value_type”””
return _almath.vectorPosition2D_front(self)
def back(self):
“””back(self) -> value_type”””
return _almath.vectorPosition2D_back(self)
def assign(self, *args):
“””assign(self, size_type n, value_type x)”””
return _almath.vectorPosition2D_assign(self, *args)
def resize(self, *args):
“””
resize(self, size_type new_size)
resize(self, size_type new_size, value_type x)
“””
return _almath.vectorPosition2D_resize(self, *args)
def insert(self, *args):
“””
insert(self, iterator pos, value_type x) -> iterator
insert(self, iterator pos, size_type n, value_type x)
“””
return _almath.vectorPosition2D_insert(self, *args)
def reserve(self, *args):
“””reserve(self, size_type n)”””
return _almath.vectorPosition2D_reserve(self, *args)
def capacity(self):
“””capacity(self) -> size_type”””
return _almath.vectorPosition2D_capacity(self)
def __repr__(self):
“””__repr__(self) -> string”””
return _almath.vectorPosition2D___repr__(self)
__swig_destroy__ = _almath.delete_vectorPosition2D
__del__ = lambda self : None;
vectorPosition2D_swigregister = _almath.vectorPosition2D_swigregister
vectorPosition2D_swigregister(vectorPosition2D)
class vectorPose2D(_object):
“””Proxy of C++ std::vector<(AL::Math::Pose2D)> class”””
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, vectorPose2D, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, vectorPose2D, name)
def iterator(self):
“””iterator(self) -> SwigPyIterator”””
return _almath.vectorPose2D_iterator(self)
def __iter__(self): return self.iterator()
def __nonzero__(self):
“””__nonzero__(self) -> bool”””
return _almath.vectorPose2D___nonzero__(self)
def __bool__(self):
“””__bool__(self) -> bool”””
return _almath.vectorPose2D___bool__(self)
def __len__(self):
“””__len__(self) -> size_type”””
return _almath.vectorPose2D___len__(self)
def pop(self):
“””pop(self) -> value_type”””
return _almath.vectorPose2D_pop(self)
def __getslice__(self, *args):
“””__getslice__(self, difference_type i, difference_type j) -> vectorPose2D”””
return _almath.vectorPose2D___getslice__(self, *args)
def __setslice__(self, *args):
“””__setslice__(self, difference_type i, difference_type j, vectorPose2D v)”””
return _almath.vectorPose2D___setslice__(self, *args)
def __delslice__(self, *args):
“””__delslice__(self, difference_type i, difference_type j)”””
return _almath.vectorPose2D___delslice__(self, *args)
def __delitem__(self, *args):
“””
__delitem__(self, difference_type i)
__delitem__(self, PySliceObject slice)
“””
return _almath.vectorPose2D___delitem__(self, *args)
def __getitem__(self, *args):
“””
__getitem__(self, PySliceObject slice) -> vectorPose2D
__getitem__(self, difference_type i) -> value_type
“””
return _almath.vectorPose2D___getitem__(self, *args)
def __setitem__(self, *args):
“””
__setitem__(self, PySliceObject slice, vectorPose2D v)
__setitem__(self, difference_type i, value_type x)
“””
return _almath.vectorPose2D___setitem__(self, *args)
def append(self, *args):
“””append(self, value_type x)”””
return _almath.vectorPose2D_append(self, *args)
def empty(self):
“””empty(self) -> bool”””
return _almath.vectorPose2D_empty(self)
def size(self):
“””size(self) -> size_type”””
return _almath.vectorPose2D_size(self)
def clear(self):
“””clear(self)”””
return _almath.vectorPose2D_clear(self)
def swap(self, *args):
“””swap(self, vectorPose2D v)”””
return _almath.vectorPose2D_swap(self, *args)
def get_allocator(self):
“””get_allocator(self) -> allocator_type”””
return _almath.vectorPose2D_get_allocator(self)
def begin(self):
“””begin(self) -> const_iterator”””
return _almath.vectorPose2D_begin(self)
def end(self):
“””end(self) -> const_iterator”””
return _almath.vectorPose2D_end(self)
def rbegin(self):
“””rbegin(self) -> const_reverse_iterator”””
return _almath.vectorPose2D_rbegin(self)
def rend(self):
“””rend(self) -> const_reverse_iterator”””
return _almath.vectorPose2D_rend(self)
def pop_back(self):
“””pop_back(self)”””
return _almath.vectorPose2D_pop_back(self)
def erase(self, *args):
“””
erase(self, iterator pos) -> iterator
erase(self, iterator first, iterator last) -> iterator
“””
return _almath.vectorPose2D_erase(self, *args)
def __init__(self, *args):
“””
__init__(self) -> vectorPose2D
__init__(self, vectorPose2D arg0) -> vectorPose2D
__init__(self, size_type size) -> vectorPose2D
__init__(self, size_type size, value_type value) -> vectorPose2D
“””
this = _almath.new_vectorPose2D(*args)
try: self.this.append(this)
except: self.this = this
def push_back(self, *args):
“””push_back(self, value_type x)”””
return _almath.vectorPose2D_push_back(self, *args)
def front(self):
“””front(self) -> value_type”””
return _almath.vectorPose2D_front(self)
def back(self):
“””back(self) -> value_type”””
return _almath.vectorPose2D_back(self)
def assign(self, *args):
“””assign(self, size_type n, value_type x)”””
return _almath.vectorPose2D_assign(self, *args)
def resize(self, *args):
“””
resize(self, size_type new_size)
resize(self, size_type new_size, value_type x)
“””
return _almath.vectorPose2D_resize(self, *args)
def insert(self, *args):
“””
insert(self, iterator pos, value_type x) -> iterator
insert(self, iterator pos, size_type n, value_type x)
“””
return _almath.vectorPose2D_insert(self, *args)
def reserve(self, *args):
“””reserve(self, size_type n)”””
return _almath.vectorPose2D_reserve(self, *args)
def capacity(self):
“””capacity(self) -> size_type”””
return _almath.vectorPose2D_capacity(self)
def __repr__(self):
“””__repr__(self) -> string”””
return _almath.vectorPose2D___repr__(self)
__swig_destroy__ = _almath.delete_vectorPose2D
__del__ = lambda self : None;
vectorPose2D_swigregister = _almath.vectorPose2D_swigregister
vectorPose2D_swigregister(vectorPose2D)
class vectorPosition6D(_object):
“””Proxy of C++ std::vector<(AL::Math::Position6D)> class”””
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, vectorPosition6D, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, vectorPosition6D, name)
def iterator(self):
“””iterator(self) -> SwigPyIterator”””
return _almath.vectorPosition6D_iterator(self)
def __iter__(self): return self.iterator()
def __nonzero__(self):
“””__nonzero__(self) -> bool”””
return _almath.vectorPosition6D___nonzero__(self)
def __bool__(self):
“””__bool__(self) -> bool”””
return _almath.vectorPosition6D___bool__(self)
def __len__(self):
“””__len__(self) -> size_type”””
return _almath.vectorPosition6D___len__(self)
def pop(self):
“””pop(self) -> value_type”””
return _almath.vectorPosition6D_pop(self)
def __getslice__(self, *args):
“””__getslice__(self, difference_type i, difference_type j) -> vectorPosition6D”””
return _almath.vectorPosition6D___getslice__(self, *args)
def __setslice__(self, *args):
“””__setslice__(self, difference_type i, difference_type j, vectorPosition6D v)”””
return _almath.vectorPosition6D___setslice__(self, *args)
def __delslice__(self, *args):
“””__delslice__(self, difference_type i, difference_type j)”””
return _almath.vectorPosition6D___delslice__(self, *args)
def __delitem__(self, *args):
“””
__delitem__(self, difference_type i)
__delitem__(self, PySliceObject slice)
“””
return _almath.vectorPosition6D___delitem__(self, *args)
def __getitem__(self, *args):
“””
__getitem__(self, PySliceObject slice) -> vectorPosition6D
__getitem__(self, difference_type i) -> value_type
“””
return _almath.vectorPosition6D___getitem__(self, *args)
def __setitem__(self, *args):
“””
__setitem__(self, PySliceObject slice, vectorPosition6D v)
__setitem__(self, difference_type i, value_type x)
“””
return _almath.vectorPosition6D___setitem__(self, *args)
def append(self, *args):
“””append(self, value_type x)”””
return _almath.vectorPosition6D_append(self, *args)
def empty(self):
“””empty(self) -> bool”””
return _almath.vectorPosition6D_empty(self)
def size(self):
“””size(self) -> size_type”””
return _almath.vectorPosition6D_size(self)
def clear(self):
“””clear(self)”””
return _almath.vectorPosition6D_clear(self)
def swap(self, *args):
“””swap(self, vectorPosition6D v)”””
return _almath.vectorPosition6D_swap(self, *args)
def get_allocator(self):
“””get_allocator(self) -> allocator_type”””
return _almath.vectorPosition6D_get_allocator(self)
def begin(self):
“””begin(self) -> const_iterator”””
return _almath.vectorPosition6D_begin(self)
def end(self):
“””end(self) -> const_iterator”””
return _almath.vectorPosition6D_end(self)
def rbegin(self):
“””rbegin(self) -> const_reverse_iterator”””
return _almath.vectorPosition6D_rbegin(self)
def rend(self):
“””rend(self) -> const_reverse_iterator”””
return _almath.vectorPosition6D_rend(self)
def pop_back(self):
“””pop_back(self)”””
return _almath.vectorPosition6D_pop_back(self)
def erase(self, *args):
“””
erase(self, iterator pos) -> iterator
erase(self, iterator first, iterator last) -> iterator
“””
return _almath.vectorPosition6D_erase(self, *args)
def __init__(self, *args):
“””
__init__(self) -> vectorPosition6D
__init__(self, vectorPosition6D arg0) -> vectorPosition6D
__init__(self, size_type size) -> vectorPosition6D
__init__(self, size_type size, value_type value) -> vectorPosition6D
“””
this = _almath.new_vectorPosition6D(*args)
try: self.this.append(this)
except: self.this = this
def push_back(self, *args):
“””push_back(self, value_type x)”””
return _almath.vectorPosition6D_push_back(self, *args)
def front(self):
“””front(self) -> value_type”””
return _almath.vectorPosition6D_front(self)
def back(self):
“””back(self) -> value_type”””
return _almath.vectorPosition6D_back(self)
def assign(self, *args):
“””assign(self, size_type n, value_type x)”””
return _almath.vectorPosition6D_assign(self, *args)
def resize(self, *args):
“””
resize(self, size_type new_size)
resize(self, size_type new_size, value_type x)
“””
return _almath.vectorPosition6D_resize(self, *args)
def insert(self, *args):
“””
insert(self, iterator pos, value_type x) -> iterator
insert(self, iterator pos, size_type n, value_type x)
“””
return _almath.vectorPosition6D_insert(self, *args)
def reserve(self, *args):
“””reserve(self, size_type n)”””
return _almath.vectorPosition6D_reserve(self, *args)
def capacity(self):
“””capacity(self) -> size_type”””
return _almath.vectorPosition6D_capacity(self)
def __repr__(self):
“””__repr__(self) -> string”””
return _almath.vectorPosition6D___repr__(self)
__swig_destroy__ = _almath.delete_vectorPosition6D
__del__ = lambda self : None;
vectorPosition6D_swigregister = _almath.vectorPosition6D_swigregister
vectorPosition6D_swigregister(vectorPosition6D)
class Pose2D(_object):
“””Proxy of C++ AL::Math::Pose2D class”””
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, Pose2D, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, Pose2D, name)
__swig_setmethods__[“x”] = _almath.Pose2D_x_set
__swig_getmethods__[“x”] = _almath.Pose2D_x_get
if _newclass:x = _swig_property(_almath.Pose2D_x_get, _almath.Pose2D_x_set)
__swig_setmethods__[“y”] = _almath.Pose2D_y_set
__swig_getmethods__[“y”] = _almath.Pose2D_y_get
if _newclass:y = _swig_property(_almath.Pose2D_y_get, _almath.Pose2D_y_set)
__swig_setmethods__[“theta”] = _almath.Pose2D_theta_set
__swig_getmethods__[“theta”] = _almath.Pose2D_theta_get
if _newclass:theta = _swig_property(_almath.Pose2D_theta_get, _almath.Pose2D_theta_set)
def __init__(self, *args):
“””
__init__(self) -> Pose2D
__init__(self, float pInit) -> Pose2D
__init__(self, float pX, float pY, float pTheta) -> Pose2D
__init__(self, vectorFloat pFloats) -> Pose2D
“””
this = _almath.new_Pose2D(*args)
try: self.this.append(this)
except: self.this = this
def __add__(self, *args):
“””__add__(self, Pose2D pPos2) -> Pose2D”””
return _almath.Pose2D___add__(self, *args)
def __sub__(self, *args):
“””__sub__(self, Pose2D pPos2) -> Pose2D”””
return _almath.Pose2D___sub__(self, *args)
def __pos__(self):
“””__pos__(self) -> Pose2D”””
return _almath.Pose2D___pos__(self)
def __neg__(self):
“””__neg__(self) -> Pose2D”””
return _almath.Pose2D___neg__(self)
def __iadd__(self, *args):
“””__iadd__(self, Pose2D pPos2) -> Pose2D”””
return _almath.Pose2D___iadd__(self, *args)
def __isub__(self, *args):
“””__isub__(self, Pose2D pPos2) -> Pose2D”””
return _almath.Pose2D___isub__(self, *args)
def __eq__(self, *args):
“””__eq__(self, Pose2D pPos2) -> bool”””
return _almath.Pose2D___eq__(self, *args)
def __ne__(self, *args):
“””__ne__(self, Pose2D pPos2) -> bool”””
return _almath.Pose2D___ne__(self, *args)
def __mul__(self, *args):
“””
__mul__(self, Pose2D pPos2) -> Pose2D
__mul__(self, float pVal) -> Pose2D
“””
return _almath.Pose2D___mul__(self, *args)
def __div__(self, *args):
“””__div__(self, float pVal) -> Pose2D”””
return _almath.Pose2D___div__(self, *args)
def __imul__(self, *args):
“””
__imul__(self, Pose2D pPos2) -> Pose2D
__imul__(self, float pVal) -> Pose2D
“””
return _almath.Pose2D___imul__(self, *args)
def __idiv__(self, *args):
“””__idiv__(self, float pVal) -> Pose2D”””
return _almath.Pose2D___idiv__(self, *args)
def distanceSquared(self, *args):
“””distanceSquared(self, Pose2D pPos2) -> float”””
return _almath.Pose2D_distanceSquared(self, *args)
def distance(self, *args):
“””distance(self, Pose2D pPos2) -> float”””
return _almath.Pose2D_distance(self, *args)
def inverse(self):
“””inverse(self) -> Pose2D”””
return _almath.Pose2D_inverse(self)
def isNear(self, *args):
“””
isNear(self, Pose2D pPos2, float pEpsilon = 0.0001) -> bool
isNear(self, Pose2D pPos2) -> bool
“””
return _almath.Pose2D_isNear(self, *args)
def toVector(self):
“””toVector(self) -> vectorFloat”””
return _almath.Pose2D_toVector(self)
def __repr__(self):
“””__repr__(self) -> char”””
return _almath.Pose2D___repr__(self)
def __rmul__(self, *args):
“””__rmul__(self, float lhs) -> Pose2D”””
return _almath.Pose2D___rmul__(self, *args)
__swig_destroy__ = _almath.delete_Pose2D
__del__ = lambda self : None;
Pose2D_swigregister = _almath.Pose2D_swigregister
Pose2D_swigregister(Pose2D)
cvar = _almath.cvar
AXIS_MASK_X = cvar.AXIS_MASK_X
AXIS_MASK_Y = cvar.AXIS_MASK_Y
AXIS_MASK_XY = cvar.AXIS_MASK_XY
AXIS_MASK_Z = cvar.AXIS_MASK_Z
AXIS_MASK_WX = cvar.AXIS_MASK_WX
AXIS_MASK_WY = cvar.AXIS_MASK_WY
AXIS_MASK_WZ = cvar.AXIS_MASK_WZ
AXIS_MASK_WYWZ = cvar.AXIS_MASK_WYWZ
AXIS_MASK_ALL = cvar.AXIS_MASK_ALL
AXIS_MASK_VEL = cvar.AXIS_MASK_VEL
AXIS_MASK_ROT = cvar.AXIS_MASK_ROT
AXIS_MASK_NONE = cvar.AXIS_MASK_NONE
class Position2D(_object):
“””Proxy of C++ AL::Math::Position2D class”””
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, Position2D, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, Position2D, name)
__swig_setmethods__[“x”] = _almath.Position2D_x_set
__swig_getmethods__[“x”] = _almath.Position2D_x_get
if _newclass:x = _swig_property(_almath.Position2D_x_get, _almath.Position2D_x_set)
__swig_setmethods__[“y”] = _almath.Position2D_y_set
__swig_getmethods__[“y”] = _almath.Position2D_y_get
if _newclass:y = _swig_property(_almath.Position2D_y_get, _almath.Position2D_y_set)
def __init__(self, *args):
“””
__init__(self) -> Position2D
__init__(self, float pInit) -> Position2D
__init__(self, float pX, float pY) -> Position2D
__init__(self, vectorFloat pFloats) -> Position2D
“””
this = _almath.new_Position2D(*args)
try: self.this.append(this)
except: self.this = this
def __add__(self, *args):
“””__add__(self, Position2D pPos2) -> Position2D”””
return _almath.Position2D___add__(self, *args)
def __sub__(self, *args):
“””__sub__(self, Position2D pPos2) -> Position2D”””
return _almath.Position2D___sub__(self, *args)
def __pos__(self):
“””__pos__(self) -> Position2D”””
return _almath.Position2D___pos__(self)
def __neg__(self):
“””__neg__(self) -> Position2D”””
return _almath.Position2D___neg__(self)
def __iadd__(self, *args):
“””__iadd__(self, Position2D pPos2) -> Position2D”””
return _almath.Position2D___iadd__(self, *args)
def __isub__(self, *args):
“””__isub__(self, Position2D pPos2) -> Position2D”””
return _almath.Position2D___isub__(self, *args)
def __eq__(self, *args):
“””__eq__(self, Position2D pPos2) -> bool”””
return _almath.Position2D___eq__(self, *args)
def __ne__(self, *args):
“””__ne__(self, Position2D pPos2) -> bool”””
return _almath.Position2D___ne__(self, *args)
def __mul__(self, *args):
“””__mul__(self, float pVal) -> Position2D”””
return _almath.Position2D___mul__(self, *args)
def __div__(self, *args):
“””__div__(self, float pVal) -> Position2D”””
return _almath.Position2D___div__(self, *args)
def __imul__(self, *args):
“””__imul__(self, float pVal) -> Position2D”””
return _almath.Position2D___imul__(self, *args)
def __idiv__(self, *args):
“””__idiv__(self, float pVal) -> Position2D”””
return _almath.Position2D___idiv__(self, *args)
def distanceSquared(self, *args):
“””distanceSquared(self, Position2D pPos2) -> float”””
return _almath.Position2D_distanceSquared(self, *args)
def distance(self, *args):
“””distance(self, Position2D pPos2) -> float”””
return _almath.Position2D_distance(self, *args)
def isNear(self, *args):
“””
isNear(self, Position2D pPos2, float pEpsilon = 0.0001) -> bool
isNear(self, Position2D pPos2) -> bool
“””
return _almath.Position2D_isNear(self, *args)
def norm(self):
“””norm(self) -> float”””
return _almath.Position2D_norm(self)
def normalize(self):
“””normalize(self) -> Position2D”””
return _almath.Position2D_normalize(self)
def crossProduct(self, *args):
“””crossProduct(self, Position2D pPos2) -> float”””
return _almath.Position2D_crossProduct(self, *args)
def toVector(self):
“””toVector(self) -> vectorFloat”””
return _almath.Position2D_toVector(self)
def __repr__(self):
“””__repr__(self) -> char”””
return _almath.Position2D___repr__(self)
def __rmul__(self, *args):
“””__rmul__(self, float lhs) -> Position2D”””
return _almath.Position2D___rmul__(self, *args)
__swig_destroy__ = _almath.delete_Position2D
__del__ = lambda self : None;
Position2D_swigregister = _almath.Position2D_swigregister
Position2D_swigregister(Position2D)
def pose2DInverse(*args):
“””
pose2DInverse(Pose2D pPos) -> Pose2D
pose2DInverse(Pose2D pPos, Pose2D pRes)
“””
return _almath.pose2DInverse(*args)
class Position3D(_object):
“””Proxy of C++ AL::Math::Position3D class”””
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, Position3D, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, Position3D, name)
__swig_setmethods__[“x”] = _almath.Position3D_x_set
__swig_getmethods__[“x”] = _almath.Position3D_x_get
if _newclass:x = _swig_property(_almath.Position3D_x_get, _almath.Position3D_x_set)
__swig_setmethods__[“y”] = _almath.Position3D_y_set
__swig_getmethods__[“y”] = _almath.Position3D_y_get
if _newclass:y = _swig_property(_almath.Position3D_y_get, _almath.Position3D_y_set)
__swig_setmethods__[“z”] = _almath.Position3D_z_set
__swig_getmethods__[“z”] = _almath.Position3D_z_get
if _newclass:z = _swig_property(_almath.Position3D_z_get, _almath.Position3D_z_set)
def __init__(self, *args):
“””
__init__(self) -> Position3D
__init__(self, float pInit) -> Position3D
__init__(self, float pX, float pY, float pZ) -> Position3D
__init__(self, vectorFloat pFloats) -> Position3D
“””
this = _almath.new_Position3D(*args)
try: self.this.append(this)
except: self.this = this
def __add__(self, *args):
“””__add__(self, Position3D pPos2) -> Position3D”””
return _almath.Position3D___add__(self, *args)
def __sub__(self, *args):
“””__sub__(self, Position3D pPos2) -> Position3D”””
return _almath.Position3D___sub__(self, *args)
def __pos__(self):
“””__pos__(self) -> Position3D”””
return _almath.Position3D___pos__(self)
def __neg__(self):
“””__neg__(self) -> Position3D”””
return _almath.Position3D___neg__(self)
def __iadd__(self, *args):
“””__iadd__(self, Position3D pPos2) -> Position3D”””
return _almath.Position3D___iadd__(self, *args)
def __isub__(self, *args):
“””__isub__(self, Position3D pPos2) -> Position3D”””
return _almath.Position3D___isub__(self, *args)
def __eq__(self, *args):
“””__eq__(self, Position3D pPos2) -> bool”””
return _almath.Position3D___eq__(self, *args)
def __ne__(self, *args):
“””__ne__(self, Position3D pPos2) -> bool”””
return _almath.Position3D___ne__(self, *args)
def __mul__(self, *args):
“””__mul__(self, float pVal) -> Position3D”””
return _almath.Position3D___mul__(self, *args)
def __div__(self, *args):
“””__div__(self, float pVal) -> Position3D”””
return _almath.Position3D___div__(self, *args)
def __imul__(self, *args):
“””__imul__(self, float pVal) -> Position3D”””
return _almath.Position3D___imul__(self, *args)
def __idiv__(self, *args):
“””__idiv__(self, float pVal) -> Position3D”””
return _almath.Position3D___idiv__(self, *args)
def distanceSquared(self, *args):
“””distanceSquared(self, Position3D pPos2) -> float”””
return _almath.Position3D_distanceSquared(self, *args)
def distance(self, *args):
“””distance(self, Position3D pPos2) -> float”””
return _almath.Position3D_distance(self, *args)
def isNear(self, *args):
“””
isNear(self, Position3D pPos2, float pEpsilon = 0.0001) -> bool
isNear(self, Position3D pPos2) -> bool
“””
return _almath.Position3D_isNear(self, *args)
def norm(self):
“””norm(self) -> float”””
return _almath.Position3D_norm(self)
def normalize(self):
“””normalize(self) -> Position3D”””
return _almath.Position3D_normalize(self)
def dotProduct(self, *args):
“””dotProduct(self, Position3D pPos2) -> float”””
return _almath.Position3D_dotProduct(self, *args)
def crossProduct(self, *args):
“””crossProduct(self, Position3D pPos2) -> Position3D”””
return _almath.Position3D_crossProduct(self, *args)
def toVector(self):
“””toVector(self) -> vectorFloat”””
return _almath.Position3D_toVector(self)
def __repr__(self):
“””__repr__(self) -> char”””
return _almath.Position3D___repr__(self)
def __rmul__(self, *args):
“””__rmul__(self, float lhs) -> Position3D”””
return _almath.Position3D___rmul__(self, *args)
__swig_destroy__ = _almath.delete_Position3D
__del__ = lambda self : None;
Position3D_swigregister = _almath.Position3D_swigregister
Position3D_swigregister(Position3D)

def __div__(*args):
“””__div__(float pM, Position3D pPos1) -> Position3D”””
return _almath.__div__(*args)
def dotProduct(*args):
“””dotProduct(Position3D pPos1, Position3D pPos2) -> float”””
return _almath.dotProduct(*args)
class Position6D(_object):
“””Proxy of C++ AL::Math::Position6D class”””
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, Position6D, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, Position6D, name)
__swig_setmethods__[“x”] = _almath.Position6D_x_set
__swig_getmethods__[“x”] = _almath.Position6D_x_get
if _newclass:x = _swig_property(_almath.Position6D_x_get, _almath.Position6D_x_set)
__swig_setmethods__[“y”] = _almath.Position6D_y_set
__swig_getmethods__[“y”] = _almath.Position6D_y_get
if _newclass:y = _swig_property(_almath.Position6D_y_get, _almath.Position6D_y_set)
__swig_setmethods__[“z”] = _almath.Position6D_z_set
__swig_getmethods__[“z”] = _almath.Position6D_z_get
if _newclass:z = _swig_property(_almath.Position6D_z_get, _almath.Position6D_z_set)
__swig_setmethods__[“wx”] = _almath.Position6D_wx_set
__swig_getmethods__[“wx”] = _almath.Position6D_wx_get
if _newclass:wx = _swig_property(_almath.Position6D_wx_get, _almath.Position6D_wx_set)
__swig_setmethods__[“wy”] = _almath.Position6D_wy_set
__swig_getmethods__[“wy”] = _almath.Position6D_wy_get
if _newclass:wy = _swig_property(_almath.Position6D_wy_get, _almath.Position6D_wy_set)
__swig_setmethods__[“wz”] = _almath.Position6D_wz_set
__swig_getmethods__[“wz”] = _almath.Position6D_wz_get
if _newclass:wz = _swig_property(_almath.Position6D_wz_get, _almath.Position6D_wz_set)
def __init__(self, *args):
“””
__init__(self) -> Position6D
__init__(self, float pInit) -> Position6D
__init__(self, float pX, float pY, float pZ, float pWx, float pWy,
float pWz) -> Position6D
__init__(self, vectorFloat pFloats) -> Position6D
“””
this = _almath.new_Position6D(*args)
try: self.this.append(this)
except: self.this = this
def __add__(self, *args):
“””__add__(self, Position6D pPos2) -> Position6D”””
return _almath.Position6D___add__(self, *args)
def __sub__(self, *args):
“””__sub__(self, Position6D pPos2) -> Position6D”””
return _almath.Position6D___sub__(self, *args)
def __pos__(self):
“””__pos__(self) -> Position6D”””
return _almath.Position6D___pos__(self)
def __neg__(self):
“””__neg__(self) -> Position6D”””
return _almath.Position6D___neg__(self)
def __iadd__(self, *args):
“””__iadd__(self, Position6D pPos2) -> Position6D”””
return _almath.Position6D___iadd__(self, *args)
def __isub__(self, *args):
“””__isub__(self, Position6D pPos2) -> Position6D”””
return _almath.Position6D___isub__(self, *args)
def __eq__(self, *args):
“””__eq__(self, Position6D pPos2) -> bool”””
return _almath.Position6D___eq__(self, *args)
def __ne__(self, *args):
“””__ne__(self, Position6D pPos2) -> bool”””
return _almath.Position6D___ne__(self, *args)
def __mul__(self, *args):
“””__mul__(self, float pVal) -> Position6D”””
return _almath.Position6D___mul__(self, *args)
def __div__(self, *args):
“””__div__(self, float pVal) -> Position6D”””
return _almath.Position6D___div__(self, *args)
def __imul__(self, *args):
“””__imul__(self, float pVal) -> Position6D”””
return _almath.Position6D___imul__(self, *args)
def __idiv__(self, *args):
“””__idiv__(self, float pVal) -> Position6D”””
return _almath.Position6D___idiv__(self, *args)
def isNear(self, *args):
“””
isNear(self, Position6D pPos2, float pEpsilon = 0.0001) -> bool
isNear(self, Position6D pPos2) -> bool
“””
return _almath.Position6D_isNear(self, *args)
def distanceSquared(self, *args):
“””distanceSquared(self, Position6D pPos2) -> float”””
return _almath.Position6D_distanceSquared(self, *args)
def distance(self, *args):
“””distance(self, Position6D pPos2) -> float”””
return _almath.Position6D_distance(self, *args)
def norm(self):
“””norm(self) -> float”””
return _almath.Position6D_norm(self)
def toVector(self):
“””toVector(self) -> vectorFloat”””
return _almath.Position6D_toVector(self)
def __repr__(self):
“””__repr__(self) -> char”””
return _almath.Position6D___repr__(self)
def __rmul__(self, *args):
“””__rmul__(self, float lhs) -> Position6D”””
return _almath.Position6D___rmul__(self, *args)
__swig_destroy__ = _almath.delete_Position6D
__del__ = lambda self : None;
Position6D_swigregister = _almath.Position6D_swigregister
Position6D_swigregister(Position6D)
def crossProduct(*args):
“””
crossProduct(Position2D pPos1, Position2D pPos2) -> float
crossProduct(Position2D pPos1, Position2D pPos2, float pRes)
crossProduct(Position3D pPos1, Position3D pPos2) -> Position3D
crossProduct(Position3D pPos1, Position3D pPos2, Position3D pRes)
“””
return _almath.crossProduct(*args)
class PositionAndVelocity(_object):
“””Proxy of C++ AL::Math::PositionAndVelocity class”””
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, PositionAndVelocity, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, PositionAndVelocity, name)
__swig_setmethods__[“q”] = _almath.PositionAndVelocity_q_set
__swig_getmethods__[“q”] = _almath.PositionAndVelocity_q_get
if _newclass:q = _swig_property(_almath.PositionAndVelocity_q_get, _almath.PositionAndVelocity_q_set)
__swig_setmethods__[“dq”] = _almath.PositionAndVelocity_dq_set
__swig_getmethods__[“dq”] = _almath.PositionAndVelocity_dq_get
if _newclass:dq = _swig_property(_almath.PositionAndVelocity_dq_get, _almath.PositionAndVelocity_dq_set)
def __init__(self, pq = 0.0, pdq = 0.0):
“””
__init__(self, float pq = 0.0, float pdq = 0.0) -> PositionAndVelocity
__init__(self, float pq = 0.0) -> PositionAndVelocity
__init__(self) -> PositionAndVelocity
“””
this = _almath.new_PositionAndVelocity(pq, pdq)
try: self.this.append(this)
except: self.this = this
def isNear(self, *args):
“””
isNear(self, PositionAndVelocity pDat2, float pEpsilon = 0.0001) -> bool
isNear(self, PositionAndVelocity pDat2) -> bool
“””
return _almath.PositionAndVelocity_isNear(self, *args)
def __repr__(self):
“””__repr__(self) -> char”””
return _almath.PositionAndVelocity___repr__(self)
__swig_destroy__ = _almath.delete_PositionAndVelocity
__del__ = lambda self : None;
PositionAndVelocity_swigregister = _almath.PositionAndVelocity_swigregister
PositionAndVelocity_swigregister(PositionAndVelocity)
def distanceSquared(*args):
“””
distanceSquared(Pose2D pPos1, Pose2D pPos2) -> float
distanceSquared(Position2D pPos1, Position2D pPos2) -> float
distanceSquared(Position3D pPos1, Position3D pPos2) -> float
distanceSquared(Position6D pPos1, Position6D pPos2) -> float
“””
return _almath.distanceSquared(*args)
def distance(*args):
“””
distance(Pose2D pPos1, Pose2D pPos2) -> float
distance(Position2D pPos1, Position2D pPos2) -> float
distance(Position3D pPos1, Position3D pPos2) -> float
distance(Position6D pPos1, Position6D pPos2) -> float
“””
return _almath.distance(*args)
class Quaternion(_object):
“””Proxy of C++ AL::Math::Quaternion class”””
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, Quaternion, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, Quaternion, name)
__swig_setmethods__[“w”] = _almath.Quaternion_w_set
__swig_getmethods__[“w”] = _almath.Quaternion_w_get
if _newclass:w = _swig_property(_almath.Quaternion_w_get, _almath.Quaternion_w_set)
__swig_setmethods__[“x”] = _almath.Quaternion_x_set
__swig_getmethods__[“x”] = _almath.Quaternion_x_get
if _newclass:x = _swig_property(_almath.Quaternion_x_get, _almath.Quaternion_x_set)
__swig_setmethods__[“y”] = _almath.Quaternion_y_set
__swig_getmethods__[“y”] = _almath.Quaternion_y_get
if _newclass:y = _swig_property(_almath.Quaternion_y_get, _almath.Quaternion_y_set)
__swig_setmethods__[“z”] = _almath.Quaternion_z_set
__swig_getmethods__[“z”] = _almath.Quaternion_z_get
if _newclass:z = _swig_property(_almath.Quaternion_z_get, _almath.Quaternion_z_set)
def __init__(self, *args):
“””
__init__(self) -> Quaternion
__init__(self, float pW, float pX, float pY, float pZ) -> Quaternion
__init__(self, vectorFloat pFloats) -> Quaternion
“””
this = _almath.new_Quaternion(*args)
try: self.this.append(this)
except: self.this = this
def __mul__(self, *args):
“””__mul__(self, Quaternion pQua2) -> Quaternion”””
return _almath.Quaternion___mul__(self, *args)
def __eq__(self, *args):
“””__eq__(self, Quaternion pQua2) -> bool”””
return _almath.Quaternion___eq__(self, *args)
def __ne__(self, *args):
“””__ne__(self, Quaternion pQua2) -> bool”””
return _almath.Quaternion___ne__(self, *args)
def __imul__(self, *args):
“””
__imul__(self, Quaternion pQu2) -> Quaternion
__imul__(self, float pVal) -> Quaternion
“””
return _almath.Quaternion___imul__(self, *args)
def __idiv__(self, *args):
“””__idiv__(self, float pVal) -> Quaternion”””
return _almath.Quaternion___idiv__(self, *args)
def isNear(self, *args):
“””
isNear(self, Quaternion pQua2, float pEpsilon = 0.0001) -> bool
isNear(self, Quaternion pQua2) -> bool
“””
return _almath.Quaternion_isNear(self, *args)
def norm(self):
“””norm(self) -> float”””
return _almath.Quaternion_norm(self)
def normalize(self):
“””normalize(self) -> Quaternion”””
return _almath.Quaternion_normalize(self)
def inverse(self):
“””inverse(self) -> Quaternion”””
return _almath.Quaternion_inverse(self)
def fromAngleAndAxisRotation(*args):
“””fromAngleAndAxisRotation(float pAngle, float pAxisX, float pAxisY, float pAxisZ) -> Quaternion”””
return _almath.Quaternion_fromAngleAndAxisRotation(*args)
if _newclass:fromAngleAndAxisRotation = staticmethod(fromAngleAndAxisRotation)
__swig_getmethods__[“fromAngleAndAxisRotation”] = lambda x: fromAngleAndAxisRotation
def toVector(self):
“””toVector(self) -> vectorFloat”””
return _almath.Quaternion_toVector(self)
def __repr__(self):
“””__repr__(self) -> char”””
return _almath.Quaternion___repr__(self)
__swig_destroy__ = _almath.delete_Quaternion
__del__ = lambda self : None;
Quaternion_swigregister = _almath.Quaternion_swigregister
Quaternion_swigregister(Quaternion)
def Quaternion_fromAngleAndAxisRotation(*args):
“””Quaternion_fromAngleAndAxisRotation(float pAngle, float pAxisX, float pAxisY, float pAxisZ) -> Quaternion”””
return _almath.Quaternion_fromAngleAndAxisRotation(*args)

def quaternionFromAngleAndAxisRotation(*args):
“””quaternionFromAngleAndAxisRotation(float pAngle, float pAxisX, float pAxisY, float pAxisZ) -> Quaternion”””
return _almath.quaternionFromAngleAndAxisRotation(*args)
def angleAndAxisRotationFromQuaternion(*args):
“””
angleAndAxisRotationFromQuaternion(Quaternion pQuaternion, float pAngle, float pAxisX,
float pAxisY, float pAxisZ)
“””
return _almath.angleAndAxisRotationFromQuaternion(*args)
class Rotation(_object):
“””Proxy of C++ AL::Math::Rotation class”””
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, Rotation, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, Rotation, name)
__swig_setmethods__[“r1_c1”] = _almath.Rotation_r1_c1_set
__swig_getmethods__[“r1_c1”] = _almath.Rotation_r1_c1_get
if _newclass:r1_c1 = _swig_property(_almath.Rotation_r1_c1_get, _almath.Rotation_r1_c1_set)
__swig_setmethods__[“r1_c2”] = _almath.Rotation_r1_c2_set
__swig_getmethods__[“r1_c2”] = _almath.Rotation_r1_c2_get
if _newclass:r1_c2 = _swig_property(_almath.Rotation_r1_c2_get, _almath.Rotation_r1_c2_set)
__swig_setmethods__[“r1_c3”] = _almath.Rotation_r1_c3_set
__swig_getmethods__[“r1_c3”] = _almath.Rotation_r1_c3_get
if _newclass:r1_c3 = _swig_property(_almath.Rotation_r1_c3_get, _almath.Rotation_r1_c3_set)
__swig_setmethods__[“r2_c1”] = _almath.Rotation_r2_c1_set
__swig_getmethods__[“r2_c1”] = _almath.Rotation_r2_c1_get
if _newclass:r2_c1 = _swig_property(_almath.Rotation_r2_c1_get, _almath.Rotation_r2_c1_set)
__swig_setmethods__[“r2_c2”] = _almath.Rotation_r2_c2_set
__swig_getmethods__[“r2_c2”] = _almath.Rotation_r2_c2_get
if _newclass:r2_c2 = _swig_property(_almath.Rotation_r2_c2_get, _almath.Rotation_r2_c2_set)
__swig_setmethods__[“r2_c3”] = _almath.Rotation_r2_c3_set
__swig_getmethods__[“r2_c3”] = _almath.Rotation_r2_c3_get
if _newclass:r2_c3 = _swig_property(_almath.Rotation_r2_c3_get, _almath.Rotation_r2_c3_set)
__swig_setmethods__[“r3_c1”] = _almath.Rotation_r3_c1_set
__swig_getmethods__[“r3_c1”] = _almath.Rotation_r3_c1_get
if _newclass:r3_c1 = _swig_property(_almath.Rotation_r3_c1_get, _almath.Rotation_r3_c1_set)
__swig_setmethods__[“r3_c2”] = _almath.Rotation_r3_c2_set
__swig_getmethods__[“r3_c2”] = _almath.Rotation_r3_c2_get
if _newclass:r3_c2 = _swig_property(_almath.Rotation_r3_c2_get, _almath.Rotation_r3_c2_set)
__swig_setmethods__[“r3_c3”] = _almath.Rotation_r3_c3_set
__swig_getmethods__[“r3_c3”] = _almath.Rotation_r3_c3_get
if _newclass:r3_c3 = _swig_property(_almath.Rotation_r3_c3_get, _almath.Rotation_r3_c3_set)
def __init__(self, *args):
“””
__init__(self) -> Rotation
__init__(self, vectorFloat pFloats) -> Rotation
“””
this = _almath.new_Rotation(*args)
try: self.this.append(this)
except: self.this = this
def __imul__(self, *args):
“””__imul__(self, Rotation pRot2) -> Rotation”””
return _almath.Rotation___imul__(self, *args)
def __eq__(self, *args):
“””__eq__(self, Rotation pRot2) -> bool”””
return _almath.Rotation___eq__(self, *args)
def __ne__(self, *args):
“””__ne__(self, Rotation pRot2) -> bool”””
return _almath.Rotation___ne__(self, *args)
def isNear(self, *args):
“””
isNear(self, Rotation pRot2, float pEpsilon = 0.0001) -> bool
isNear(self, Rotation pRot2) -> bool
“””
return _almath.Rotation_isNear(self, *args)
def transpose(self):
“””transpose(self) -> Rotation”””
return _almath.Rotation_transpose(self)
def determinant(self):
“””determinant(self) -> float”””
return _almath.Rotation_determinant(self)
def fromQuaternion(*args):
“””fromQuaternion(float pA, float pB, float pC, float pD) -> Rotation”””
return _almath.Rotation_fromQuaternion(*args)
if _newclass:fromQuaternion = staticmethod(fromQuaternion)
__swig_getmethods__[“fromQuaternion”] = lambda x: fromQuaternion
def fromAngleDirection(*args):
“””fromAngleDirection(float pAngle, float pX, float pY, float pZ) -> Rotation”””
return _almath.Rotation_fromAngleDirection(*args)
if _newclass:fromAngleDirection = staticmethod(fromAngleDirection)
__swig_getmethods__[“fromAngleDirection”] = lambda x: fromAngleDirection
def fromRotX(*args):
“””fromRotX(float pRotX) -> Rotation”””
return _almath.Rotation_fromRotX(*args)
if _newclass:fromRotX = staticmethod(fromRotX)
__swig_getmethods__[“fromRotX”] = lambda x: fromRotX
def fromRotY(*args):
“””fromRotY(float pRotY) -> Rotation”””
return _almath.Rotation_fromRotY(*args)
if _newclass:fromRotY = staticmethod(fromRotY)
__swig_getmethods__[“fromRotY”] = lambda x: fromRotY
def fromRotZ(*args):
“””fromRotZ(float pRotZ) -> Rotation”””
return _almath.Rotation_fromRotZ(*args)
if _newclass:fromRotZ = staticmethod(fromRotZ)
__swig_getmethods__[“fromRotZ”] = lambda x: fromRotZ
def from3DRotation(*args):
“””from3DRotation(float pWX, float pWY, float pWZ) -> Rotation”””
return _almath.Rotation_from3DRotation(*args)
if _newclass:from3DRotation = staticmethod(from3DRotation)
__swig_getmethods__[“from3DRotation”] = lambda x: from3DRotation
def toVector(self):
“””toVector(self) -> vectorFloat”””
return _almath.Rotation_toVector(self)
def __str__(self):
“””__str__(self) -> char”””
return _almath.Rotation___str__(self)
def __repr__(self):
“””__repr__(self) -> char”””
return _almath.Rotation___repr__(self)
def __mul__(self, *args):
“””
__mul__(self, Rotation pRot2) -> Rotation
__mul__(self, Position3D rhs) -> Position3D
“””
return _almath.Rotation___mul__(self, *args)
__swig_destroy__ = _almath.delete_Rotation
__del__ = lambda self : None;
Rotation_swigregister = _almath.Rotation_swigregister
Rotation_swigregister(Rotation)
def quaternionInverse(*args):
“””
quaternionInverse(Quaternion pQua, Quaternion pQuaOut)
quaternionInverse(Quaternion pQua) -> Quaternion
“””
return _almath.quaternionInverse(*args)
def Rotation_fromQuaternion(*args):
“””Rotation_fromQuaternion(float pA, float pB, float pC, float pD) -> Rotation”””
return _almath.Rotation_fromQuaternion(*args)
def Rotation_fromAngleDirection(*args):
“””Rotation_fromAngleDirection(float pAngle, float pX, float pY, float pZ) -> Rotation”””
return _almath.Rotation_fromAngleDirection(*args)
def Rotation_fromRotX(*args):
“””Rotation_fromRotX(float pRotX) -> Rotation”””
return _almath.Rotation_fromRotX(*args)
def Rotation_fromRotY(*args):
“””Rotation_fromRotY(float pRotY) -> Rotation”””
return _almath.Rotation_fromRotY(*args)
def Rotation_fromRotZ(*args):
“””Rotation_fromRotZ(float pRotZ) -> Rotation”””
return _almath.Rotation_fromRotZ(*args)
def Rotation_from3DRotation(*args):
“””Rotation_from3DRotation(float pWX, float pWY, float pWZ) -> Rotation”””
return _almath.Rotation_from3DRotation(*args)

def transpose(*args):
“””transpose(Rotation pRot) -> Rotation”””
return _almath.transpose(*args)
def rotationFromQuaternion(*args):
“””rotationFromQuaternion(float pA, float pB, float pC, float pD) -> Rotation”””
return _almath.rotationFromQuaternion(*args)
def applyRotation(*args):
“””applyRotation(Rotation pRot, float pX, float pY, float pZ)”””
return _almath.applyRotation(*args)
def rotationFromRotX(*args):
“””rotationFromRotX(float pRotX) -> Rotation”””
return _almath.rotationFromRotX(*args)
def rotationFromRotY(*args):
“””rotationFromRotY(float pRotY) -> Rotation”””
return _almath.rotationFromRotY(*args)
def rotationFromRotZ(*args):
“””rotationFromRotZ(float pRotZ) -> Rotation”””
return _almath.rotationFromRotZ(*args)
def rotationFrom3DRotation(*args):
“””rotationFrom3DRotation(float pWX, float pWY, float pWZ) -> Rotation”””
return _almath.rotationFrom3DRotation(*args)
class Rotation3D(_object):
“””Proxy of C++ AL::Math::Rotation3D class”””
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, Rotation3D, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, Rotation3D, name)
__swig_setmethods__[“wx”] = _almath.Rotation3D_wx_set
__swig_getmethods__[“wx”] = _almath.Rotation3D_wx_get
if _newclass:wx = _swig_property(_almath.Rotation3D_wx_get, _almath.Rotation3D_wx_set)
__swig_setmethods__[“wy”] = _almath.Rotation3D_wy_set
__swig_getmethods__[“wy”] = _almath.Rotation3D_wy_get
if _newclass:wy = _swig_property(_almath.Rotation3D_wy_get, _almath.Rotation3D_wy_set)
__swig_setmethods__[“wz”] = _almath.Rotation3D_wz_set
__swig_getmethods__[“wz”] = _almath.Rotation3D_wz_get
if _newclass:wz = _swig_property(_almath.Rotation3D_wz_get, _almath.Rotation3D_wz_set)
def __init__(self, *args):
“””
__init__(self) -> Rotation3D
__init__(self, float pInit) -> Rotation3D
__init__(self, float pWx, float pWy, float pWz) -> Rotation3D
__init__(self, vectorFloat pFloats) -> Rotation3D
“””
this = _almath.new_Rotation3D(*args)
try: self.this.append(this)
except: self.this = this
def __add__(self, *args):
“””__add__(self, Rotation3D pRot2) -> Rotation3D”””
return _almath.Rotation3D___add__(self, *args)
def __sub__(self, *args):
“””__sub__(self, Rotation3D pRot2) -> Rotation3D”””
return _almath.Rotation3D___sub__(self, *args)
def __iadd__(self, *args):
“””__iadd__(self, Rotation3D pRot2) -> Rotation3D”””
return _almath.Rotation3D___iadd__(self, *args)
def __isub__(self, *args):
“””__isub__(self, Rotation3D pRot2) -> Rotation3D”””
return _almath.Rotation3D___isub__(self, *args)
def __eq__(self, *args):
“””__eq__(self, Rotation3D pRot2) -> bool”””
return _almath.Rotation3D___eq__(self, *args)
def __ne__(self, *args):
“””__ne__(self, Rotation3D pRot2) -> bool”””
return _almath.Rotation3D___ne__(self, *args)
def __mul__(self, *args):
“””__mul__(self, float pVal) -> Rotation3D”””
return _almath.Rotation3D___mul__(self, *args)
def __div__(self, *args):
“””__div__(self, float pVal) -> Rotation3D”””
return _almath.Rotation3D___div__(self, *args)
def __imul__(self, *args):
“””__imul__(self, float pVal) -> Rotation3D”””
return _almath.Rotation3D___imul__(self, *args)
def __idiv__(self, *args):
“””__idiv__(self, float pVal) -> Rotation3D”””
return _almath.Rotation3D___idiv__(self, *args)
def isNear(self, *args):
“””
isNear(self, Rotation3D pRot2, float pEpsilon = 0.0001) -> bool
isNear(self, Rotation3D pRot2) -> bool
“””
return _almath.Rotation3D_isNear(self, *args)
def norm(self):
“””norm(self) -> float”””
return _almath.Rotation3D_norm(self)
def toVector(self):
“””toVector(self) -> vectorFloat”””
return _almath.Rotation3D_toVector(self)
def __repr__(self):
“””__repr__(self) -> char”””
return _almath.Rotation3D___repr__(self)
__swig_destroy__ = _almath.delete_Rotation3D
__del__ = lambda self : None;
Rotation3D_swigregister = _almath.Rotation3D_swigregister
Rotation3D_swigregister(Rotation3D)
class Transform(_object):
“””Proxy of C++ AL::Math::Transform class”””
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, Transform, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, Transform, name)
__swig_setmethods__[“r1_c1”] = _almath.Transform_r1_c1_set
__swig_getmethods__[“r1_c1”] = _almath.Transform_r1_c1_get
if _newclass:r1_c1 = _swig_property(_almath.Transform_r1_c1_get, _almath.Transform_r1_c1_set)
__swig_setmethods__[“r1_c2”] = _almath.Transform_r1_c2_set
__swig_getmethods__[“r1_c2”] = _almath.Transform_r1_c2_get
if _newclass:r1_c2 = _swig_property(_almath.Transform_r1_c2_get, _almath.Transform_r1_c2_set)
__swig_setmethods__[“r1_c3”] = _almath.Transform_r1_c3_set
__swig_getmethods__[“r1_c3”] = _almath.Transform_r1_c3_get
if _newclass:r1_c3 = _swig_property(_almath.Transform_r1_c3_get, _almath.Transform_r1_c3_set)
__swig_setmethods__[“r1_c4”] = _almath.Transform_r1_c4_set
__swig_getmethods__[“r1_c4”] = _almath.Transform_r1_c4_get
if _newclass:r1_c4 = _swig_property(_almath.Transform_r1_c4_get, _almath.Transform_r1_c4_set)
__swig_setmethods__[“r2_c1”] = _almath.Transform_r2_c1_set
__swig_getmethods__[“r2_c1”] = _almath.Transform_r2_c1_get
if _newclass:r2_c1 = _swig_property(_almath.Transform_r2_c1_get, _almath.Transform_r2_c1_set)
__swig_setmethods__[“r2_c2”] = _almath.Transform_r2_c2_set
__swig_getmethods__[“r2_c2”] = _almath.Transform_r2_c2_get
if _newclass:r2_c2 = _swig_property(_almath.Transform_r2_c2_get, _almath.Transform_r2_c2_set)
__swig_setmethods__[“r2_c3”] = _almath.Transform_r2_c3_set
__swig_getmethods__[“r2_c3”] = _almath.Transform_r2_c3_get
if _newclass:r2_c3 = _swig_property(_almath.Transform_r2_c3_get, _almath.Transform_r2_c3_set)
__swig_setmethods__[“r2_c4”] = _almath.Transform_r2_c4_set
__swig_getmethods__[“r2_c4”] = _almath.Transform_r2_c4_get
if _newclass:r2_c4 = _swig_property(_almath.Transform_r2_c4_get, _almath.Transform_r2_c4_set)
__swig_setmethods__[“r3_c1”] = _almath.Transform_r3_c1_set
__swig_getmethods__[“r3_c1”] = _almath.Transform_r3_c1_get
if _newclass:r3_c1 = _swig_property(_almath.Transform_r3_c1_get, _almath.Transform_r3_c1_set)
__swig_setmethods__[“r3_c2”] = _almath.Transform_r3_c2_set
__swig_getmethods__[“r3_c2”] = _almath.Transform_r3_c2_get
if _newclass:r3_c2 = _swig_property(_almath.Transform_r3_c2_get, _almath.Transform_r3_c2_set)
__swig_setmethods__[“r3_c3”] = _almath.Transform_r3_c3_set
__swig_getmethods__[“r3_c3”] = _almath.Transform_r3_c3_get
if _newclass:r3_c3 = _swig_property(_almath.Transform_r3_c3_get, _almath.Transform_r3_c3_set)
__swig_setmethods__[“r3_c4”] = _almath.Transform_r3_c4_set
__swig_getmethods__[“r3_c4”] = _almath.Transform_r3_c4_get
if _newclass:r3_c4 = _swig_property(_almath.Transform_r3_c4_get, _almath.Transform_r3_c4_set)
def __init__(self, *args):
“””
__init__(self) -> Transform
__init__(self, vectorFloat pFloats) -> Transform
__init__(self, float pPosX, float pPosY, float pPosZ) -> Transform
“””
this = _almath.new_Transform(*args)
try: self.this.append(this)
except: self.this = this
def __imul__(self, *args):
“””__imul__(self, Transform pT2) -> Transform”””
return _almath.Transform___imul__(self, *args)
def __eq__(self, *args):
“””__eq__(self, Transform pT2) -> bool”””
return _almath.Transform___eq__(self, *args)
def __ne__(self, *args):
“””__ne__(self, Transform pT2) -> bool”””
return _almath.Transform___ne__(self, *args)
def isNear(self, *args):
“””
isNear(self, Transform pT2, float pEpsilon = 0.0001) -> bool
isNear(self, Transform pT2) -> bool
“””
return _almath.Transform_isNear(self, *args)
def isTransform(self, pEpsilon = 0.0001):
“””
isTransform(self, float pEpsilon = 0.0001) -> bool
isTransform(self) -> bool
“””
return _almath.Transform_isTransform(self, pEpsilon)
def norm(self):
“””norm(self) -> float”””
return _almath.Transform_norm(self)
def determinant(self):
“””determinant(self) -> float”””
return _almath.Transform_determinant(self)
def inverse(self):
“””inverse(self) -> Transform”””
return _almath.Transform_inverse(self)
def fromRotX(*args):
“””fromRotX(float pRotX) -> Transform”””
return _almath.Transform_fromRotX(*args)
if _newclass:fromRotX = staticmethod(fromRotX)
__swig_getmethods__[“fromRotX”] = lambda x: fromRotX
def fromRotY(*args):
“””fromRotY(float pRotY) -> Transform”””
return _almath.Transform_fromRotY(*args)
if _newclass:fromRotY = staticmethod(fromRotY)
__swig_getmethods__[“fromRotY”] = lambda x: fromRotY
def fromRotZ(*args):
“””fromRotZ(float pRotZ) -> Transform”””
return _almath.Transform_fromRotZ(*args)
if _newclass:fromRotZ = staticmethod(fromRotZ)
__swig_getmethods__[“fromRotZ”] = lambda x: fromRotZ
def from3DRotation(*args):
“””from3DRotation(float pWX, float pWY, float pWZ) -> Transform”””
return _almath.Transform_from3DRotation(*args)
if _newclass:from3DRotation = staticmethod(from3DRotation)
__swig_getmethods__[“from3DRotation”] = lambda x: from3DRotation
def fromPosition(*args):
“””
fromPosition(float pX, float pY, float pZ) -> Transform
fromPosition(float pX, float pY, float pZ, float pWX, float pWY,
float pWZ) -> Transform
“””
return _almath.Transform_fromPosition(*args)
if _newclass:fromPosition = staticmethod(fromPosition)
__swig_getmethods__[“fromPosition”] = lambda x: fromPosition
def diff(self, *args):
“””diff(self, Transform pT2) -> Transform”””
return _almath.Transform_diff(self, *args)
def distanceSquared(self, *args):
“””distanceSquared(self, Transform pT2) -> float”””
return _almath.Transform_distanceSquared(self, *args)
def distance(self, *args):
“””distance(self, Transform pT2) -> float”””
return _almath.Transform_distance(self, *args)
def toVector(self):
“””toVector(self) -> vectorFloat”””
return _almath.Transform_toVector(self)
def __str__(self):
“””__str__(self) -> char”””
return _almath.Transform___str__(self)
def __repr__(self):
“””__repr__(self) -> char”””
return _almath.Transform___repr__(self)
def __mul__(self, *args):
“””
__mul__(self, Transform pT2) -> Transform
__mul__(self, Position3D rhs) -> Position3D
“””
return _almath.Transform___mul__(self, *args)
__swig_destroy__ = _almath.delete_Transform
__del__ = lambda self : None;
Transform_swigregister = _almath.Transform_swigregister
Transform_swigregister(Transform)
def Transform_fromRotX(*args):
“””Transform_fromRotX(float pRotX) -> Transform”””
return _almath.Transform_fromRotX(*args)
def Transform_fromRotY(*args):
“””Transform_fromRotY(float pRotY) -> Transform”””
return _almath.Transform_fromRotY(*args)
def Transform_fromRotZ(*args):
“””Transform_fromRotZ(float pRotZ) -> Transform”””
return _almath.Transform_fromRotZ(*args)
def Transform_from3DRotation(*args):
“””Transform_from3DRotation(float pWX, float pWY, float pWZ) -> Transform”””
return _almath.Transform_from3DRotation(*args)
def Transform_fromPosition(*args):
“””
fromPosition(float pX, float pY, float pZ) -> Transform
Transform_fromPosition(float pX, float pY, float pZ, float pWX, float pWY,
float pWZ) -> Transform
“””
return _almath.Transform_fromPosition(*args)

def transformPreMultiply(*args):
“””transformPreMultiply(Transform pT, Transform pTOut)”””
return _almath.transformPreMultiply(*args)
def transformFromRotX(*args):
“””transformFromRotX(float pRotX) -> Transform”””
return _almath.transformFromRotX(*args)
def transformFromRotY(*args):
“””transformFromRotY(float pRotY) -> Transform”””
return _almath.transformFromRotY(*args)
def transformFromRotZ(*args):
“””transformFromRotZ(float pRotZ) -> Transform”””
return _almath.transformFromRotZ(*args)
def transformFrom3DRotation(*args):
“””transformFrom3DRotation(float pWX, float pWY, float pWZ) -> Transform”””
return _almath.transformFrom3DRotation(*args)
def transformInvertInPlace(*args):
“””transformInvertInPlace(Transform pT)”””
return _almath.transformInvertInPlace(*args)
def pinv(*args):
“””pinv(Transform pT) -> Transform”””
return _almath.pinv(*args)
def transformDiff(*args):
“””transformDiff(Transform pT1, Transform pT2) -> Transform”””
return _almath.transformDiff(*args)
def transformDistanceSquared(*args):
“””transformDistanceSquared(Transform pT1, Transform pT2) -> float”””
return _almath.transformDistanceSquared(*args)
def transformDistance(*args):
“””transformDistance(Transform pT1, Transform pT2) -> float”””
return _almath.transformDistance(*args)
class Velocity3D(_object):
“””Proxy of C++ AL::Math::Velocity3D class”””
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, Velocity3D, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, Velocity3D, name)
__swig_setmethods__[“xd”] = _almath.Velocity3D_xd_set
__swig_getmethods__[“xd”] = _almath.Velocity3D_xd_get
if _newclass:xd = _swig_property(_almath.Velocity3D_xd_get, _almath.Velocity3D_xd_set)
__swig_setmethods__[“yd”] = _almath.Velocity3D_yd_set
__swig_getmethods__[“yd”] = _almath.Velocity3D_yd_get
if _newclass:yd = _swig_property(_almath.Velocity3D_yd_get, _almath.Velocity3D_yd_set)
__swig_setmethods__[“zd”] = _almath.Velocity3D_zd_set
__swig_getmethods__[“zd”] = _almath.Velocity3D_zd_get
if _newclass:zd = _swig_property(_almath.Velocity3D_zd_get, _almath.Velocity3D_zd_set)
def __init__(self, *args):
“””
__init__(self) -> Velocity3D
__init__(self, float pInit) -> Velocity3D
__init__(self, float pXd, float pYd, float pZd) -> Velocity3D
__init__(self, vectorFloat pFloats) -> Velocity3D
“””
this = _almath.new_Velocity3D(*args)
try: self.this.append(this)
except: self.this = this
def __add__(self, *args):
“””__add__(self, Velocity3D pVel2) -> Velocity3D”””
return _almath.Velocity3D___add__(self, *args)
def __sub__(self, *args):
“””__sub__(self, Velocity3D pVel2) -> Velocity3D”””
return _almath.Velocity3D___sub__(self, *args)
def __pos__(self):
“””__pos__(self) -> Velocity3D”””
return _almath.Velocity3D___pos__(self)
def __neg__(self):
“””__neg__(self) -> Velocity3D”””
return _almath.Velocity3D___neg__(self)
def __iadd__(self, *args):
“””__iadd__(self, Velocity3D pVel2) -> Velocity3D”””
return _almath.Velocity3D___iadd__(self, *args)
def __isub__(self, *args):
“””__isub__(self, Velocity3D pVel2) -> Velocity3D”””
return _almath.Velocity3D___isub__(self, *args)
def __eq__(self, *args):
“””__eq__(self, Velocity3D pVel2) -> bool”””
return _almath.Velocity3D___eq__(self, *args)
def __ne__(self, *args):
“””__ne__(self, Velocity3D pVel2) -> bool”””
return _almath.Velocity3D___ne__(self, *args)
def __mul__(self, *args):
“””__mul__(self, float pVal) -> Velocity3D”””
return _almath.Velocity3D___mul__(self, *args)
def __div__(self, *args):
“””__div__(self, float pVal) -> Velocity3D”””
return _almath.Velocity3D___div__(self, *args)
def __imul__(self, *args):
“””__imul__(self, float pVal) -> Velocity3D”””
return _almath.Velocity3D___imul__(self, *args)
def __idiv__(self, *args):
“””__idiv__(self, float pVal) -> Velocity3D”””
return _almath.Velocity3D___idiv__(self, *args)
def isNear(self, *args):
“””
isNear(self, Velocity3D pVel2, float pEpsilon = 0.0001) -> bool
isNear(self, Velocity3D pVel2) -> bool
“””
return _almath.Velocity3D_isNear(self, *args)
def norm(self):
“””norm(self) -> float”””
return _almath.Velocity3D_norm(self)
def normalize(self):
“””normalize(self) -> Velocity3D”””
return _almath.Velocity3D_normalize(self)
def toVector(self):
“””toVector(self) -> vectorFloat”””
return _almath.Velocity3D_toVector(self)
def __repr__(self):
“””__repr__(self) -> char”””
return _almath.Velocity3D___repr__(self)
def __rmul__(self, *args):
“””__rmul__(self, float lhs) -> Velocity3D”””
return _almath.Velocity3D___rmul__(self, *args)
__swig_destroy__ = _almath.delete_Velocity3D
__del__ = lambda self : None;
Velocity3D_swigregister = _almath.Velocity3D_swigregister
Velocity3D_swigregister(Velocity3D)
def transformToFloatVector(*args):
“””
transformToFloatVector(Transform pT, vectorFloat pTOut)
transformToFloatVector(Transform pT) -> vectorFloat
“””
return _almath.transformToFloatVector(*args)
def determinant(*args):
“””
determinant(Rotation pRot) -> float
determinant(Transform pT) -> float
determinant(vectorFloat pFloats) -> float
“””
return _almath.determinant(*args)
def transformInverse(*args):
“””
transformInverse(Transform pT, Transform pTOut)
transformInverse(Transform pT) -> Transform
“””
return _almath.transformInverse(*args)
def transformFromPosition(*args):
“””
transformFromPosition(float pX, float pY, float pZ) -> Transform
transformFromPosition(float pX, float pY, float pZ, float pWX, float pWY,
float pWZ) -> Transform
“””
return _almath.transformFromPosition(*args)
class Velocity6D(_object):
“””Proxy of C++ AL::Math::Velocity6D class”””
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, Velocity6D, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, Velocity6D, name)
__swig_setmethods__[“xd”] = _almath.Velocity6D_xd_set
__swig_getmethods__[“xd”] = _almath.Velocity6D_xd_get
if _newclass:xd = _swig_property(_almath.Velocity6D_xd_get, _almath.Velocity6D_xd_set)
__swig_setmethods__[“yd”] = _almath.Velocity6D_yd_set
__swig_getmethods__[“yd”] = _almath.Velocity6D_yd_get
if _newclass:yd = _swig_property(_almath.Velocity6D_yd_get, _almath.Velocity6D_yd_set)
__swig_setmethods__[“zd”] = _almath.Velocity6D_zd_set
__swig_getmethods__[“zd”] = _almath.Velocity6D_zd_get
if _newclass:zd = _swig_property(_almath.Velocity6D_zd_get, _almath.Velocity6D_zd_set)
__swig_setmethods__[“wxd”] = _almath.Velocity6D_wxd_set
__swig_getmethods__[“wxd”] = _almath.Velocity6D_wxd_get
if _newclass:wxd = _swig_property(_almath.Velocity6D_wxd_get, _almath.Velocity6D_wxd_set)
__swig_setmethods__[“wyd”] = _almath.Velocity6D_wyd_set
__swig_getmethods__[“wyd”] = _almath.Velocity6D_wyd_get
if _newclass:wyd = _swig_property(_almath.Velocity6D_wyd_get, _almath.Velocity6D_wyd_set)
__swig_setmethods__[“wzd”] = _almath.Velocity6D_wzd_set
__swig_getmethods__[“wzd”] = _almath.Velocity6D_wzd_get
if _newclass:wzd = _swig_property(_almath.Velocity6D_wzd_get, _almath.Velocity6D_wzd_set)
def __init__(self, *args):
“””
__init__(self) -> Velocity6D
__init__(self, float pInit) -> Velocity6D
__init__(self, float pXd, float pYd, float pZd, float pWxd, float pWyd,
float pWzd) -> Velocity6D
__init__(self, vectorFloat pFloats) -> Velocity6D
“””
this = _almath.new_Velocity6D(*args)
try: self.this.append(this)
except: self.this = this
def __add__(self, *args):
“””__add__(self, Velocity6D pVel2) -> Velocity6D”””
return _almath.Velocity6D___add__(self, *args)
def __sub__(self, *args):
“””__sub__(self, Velocity6D pVel2) -> Velocity6D”””
return _almath.Velocity6D___sub__(self, *args)
def __pos__(self):
“””__pos__(self) -> Velocity6D”””
return _almath.Velocity6D___pos__(self)
def __neg__(self):
“””__neg__(self) -> Velocity6D”””
return _almath.Velocity6D___neg__(self)
def __mul__(self, *args):
“””__mul__(self, float pVal) -> Velocity6D”””
return _almath.Velocity6D___mul__(self, *args)
def __div__(self, *args):
“””__div__(self, float pVal) -> Velocity6D”””
return _almath.Velocity6D___div__(self, *args)
def __eq__(self, *args):
“””__eq__(self, Velocity6D pVel2) -> bool”””
return _almath.Velocity6D___eq__(self, *args)
def __ne__(self, *args):
“””__ne__(self, Velocity6D pVel2) -> bool”””
return _almath.Velocity6D___ne__(self, *args)
def __imul__(self, *args):
“””__imul__(self, float pVal) -> Velocity6D”””
return _almath.Velocity6D___imul__(self, *args)
def __idiv__(self, *args):
“””__idiv__(self, float pVal) -> Velocity6D”””
return _almath.Velocity6D___idiv__(self, *args)
def isNear(self, *args):
“””
isNear(self, Velocity6D pVel2, float pEpsilon = 0.0001) -> bool
isNear(self, Velocity6D pVel2) -> bool
“””
return _almath.Velocity6D_isNear(self, *args)
def norm(self):
“””norm(self) -> float”””
return _almath.Velocity6D_norm(self)
def normalize(self):
“””normalize(self) -> Velocity6D”””
return _almath.Velocity6D_normalize(self)
def toVector(self):
“””toVector(self) -> vectorFloat”””
return _almath.Velocity6D_toVector(self)
def __repr__(self):
“””__repr__(self) -> char”””
return _almath.Velocity6D___repr__(self)
def __rmul__(self, *args):
“””__rmul__(self, float lhs) -> Velocity6D”””
return _almath.Velocity6D___rmul__(self, *args)
__swig_destroy__ = _almath.delete_Velocity6D
__del__ = lambda self : None;
Velocity6D_swigregister = _almath.Velocity6D_swigregister
Velocity6D_swigregister(Velocity6D)
class TransformAndVelocity6D(_object):
“””Proxy of C++ AL::Math::TransformAndVelocity6D class”””
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, TransformAndVelocity6D, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, TransformAndVelocity6D, name)
__swig_setmethods__[“T”] = _almath.TransformAndVelocity6D_T_set
__swig_getmethods__[“T”] = _almath.TransformAndVelocity6D_T_get
if _newclass:T = _swig_property(_almath.TransformAndVelocity6D_T_get, _almath.TransformAndVelocity6D_T_set)
__swig_setmethods__[“V”] = _almath.TransformAndVelocity6D_V_set
__swig_getmethods__[“V”] = _almath.TransformAndVelocity6D_V_get
if _newclass:V = _swig_property(_almath.TransformAndVelocity6D_V_get, _almath.TransformAndVelocity6D_V_set)
def isNear(self, *args):
“””
isNear(self, TransformAndVelocity6D pTV2, float pEpsilon = 0.0001) -> bool
isNear(self, TransformAndVelocity6D pTV2) -> bool
“””
return _almath.TransformAndVelocity6D_isNear(self, *args)
def __repr__(self):
“””__repr__(self) -> char”””
return _almath.TransformAndVelocity6D___repr__(self)
def __init__(self):
“””__init__(self) -> TransformAndVelocity6D”””
this = _almath.new_TransformAndVelocity6D()
try: self.this.append(this)
except: self.this = this
__swig_destroy__ = _almath.delete_TransformAndVelocity6D
__del__ = lambda self : None;
TransformAndVelocity6D_swigregister = _almath.TransformAndVelocity6D_swigregister
TransformAndVelocity6D_swigregister(TransformAndVelocity6D)
def norm(*args):
“””
norm(Position2D pPos) -> float
norm(Position3D pPos) -> float
norm(Position6D pPos) -> float
norm(Quaternion pQua) -> float
norm(Rotation3D pRot) -> float
norm(Transform pT) -> float
norm(Velocity3D pVel) -> float
norm(Velocity6D pVel) -> float
“””
return _almath.norm(*args)
def normalize(*args):
“””
normalize(Position2D pPos) -> Position2D
normalize(Position3D pPos) -> Position3D
normalize(Position6D pPos) -> Position6D
normalize(Quaternion pQua) -> Quaternion
normalize(Velocity3D pVel) -> Velocity3D
normalize(Velocity6D pVel) -> Velocity6D
“””
return _almath.normalize(*args)

def getDubinsSolutions(*args):
“””getDubinsSolutions(Pose2D pTargetPose, float pCircleRadius) -> vectorPose2D”””
return _almath.getDubinsSolutions(*args)
def avoidFootCollision(*args):
“””
avoidFootCollision(vectorPose2D pLFootBoundingBox, vectorPose2D pRFootBoundingBox,
bool pIsLeftSupport, Pose2D pMove) -> bool
“””
return _almath.avoidFootCollision(*args)
def clipFootWithEllipse(*args):
“””clipFootWithEllipse(float pMaxFootX, float pMaxFootY, Pose2D pMove) -> bool”””
return _almath.clipFootWithEllipse(*args)
def transformLogarithmInPlace(*args):
“””transformLogarithmInPlace(Transform pT, Velocity6D pVel)”””
return _almath.transformLogarithmInPlace(*args)
def transformLogarithm(*args):
“””transformLogarithm(Transform pT) -> Velocity6D”””
return _almath.transformLogarithm(*args)
def velocityExponential(*args):
“””velocityExponential(Velocity6D pVel) -> Transform”””
return _almath.velocityExponential(*args)
def velocityExponentialInPlace(*args):
“””velocityExponentialInPlace(Velocity6D pVel, Transform pT)”””
return _almath.velocityExponentialInPlace(*args)
def changeReferenceVelocity6D(*args):
“””changeReferenceVelocity6D(Transform pT, Velocity6D pVelIn, Velocity6D pVelOut)”””
return _almath.changeReferenceVelocity6D(*args)
def changeReferencePosition6D(*args):
“””changeReferencePosition6D(Transform pT, Position6D pPosIn, Position6D pPosOut)”””
return _almath.changeReferencePosition6D(*args)
def changeReferencePosition3DInPlace(*args):
“””changeReferencePosition3DInPlace(Transform pT, Position3D pPosOut)”””
return _almath.changeReferencePosition3DInPlace(*args)
def changeReferenceTransposePosition3DInPlace(*args):
“””changeReferenceTransposePosition3DInPlace(Transform pT, Position3D pPosOut)”””
return _almath.changeReferenceTransposePosition3DInPlace(*args)
def changeReferencePosition3D(*args):
“””changeReferencePosition3D(Transform pT, Position3D pPosIn, Position3D pPosOut)”””
return _almath.changeReferencePosition3D(*args)
def changeReferenceTransposePosition3D(*args):
“””changeReferenceTransposePosition3D(Transform pT, Position3D pPosIn, Position3D pPosOut)”””
return _almath.changeReferenceTransposePosition3D(*args)
def changeReferenceTransform(*args):
“””changeReferenceTransform(Transform pT, Transform pTIn, Transform pTOut)”””
return _almath.changeReferenceTransform(*args)
def changeReferenceTransposeTransform(*args):
“””changeReferenceTransposeTransform(Transform pT, Transform pTIn, Transform pTOut)”””
return _almath.changeReferenceTransposeTransform(*args)
def changeReferenceTransposeVelocity6D(*args):
“””changeReferenceTransposeVelocity6D(Transform pT, Velocity6D pVelIn, Velocity6D pVelOut)”””
return _almath.changeReferenceTransposeVelocity6D(*args)
def changeReferenceTransposePosition6D(*args):
“””changeReferenceTransposePosition6D(Transform pT, Position6D pPosIn, Position6D pPosOut)”””
return _almath.changeReferenceTransposePosition6D(*args)
def transformMeanInPlace(*args):
“””transformMeanInPlace(Transform pTIn1, Transform pTIn2, float pVal, Transform pTOut)”””
return _almath.transformMeanInPlace(*args)
def transformFromPosition3DInPlace(*args):
“””transformFromPosition3DInPlace(Position3D pPosition, Transform pTransform)”””
return _almath.transformFromPosition3DInPlace(*args)
def transformFromPosition3D(*args):
“””transformFromPosition3D(Position3D pPosition) -> Transform”””
return _almath.transformFromPosition3D(*args)
def transformFromRotationInPlace(*args):
“””transformFromRotationInPlace(Rotation pRotation, Transform pTransform)”””
return _almath.transformFromRotationInPlace(*args)
def transformFromRotation(*args):
“””transformFromRotation(Rotation pRotation) -> Transform”””
return _almath.transformFromRotation(*args)
def rotationFromTransformInPlace(*args):
“””rotationFromTransformInPlace(Transform pTransform, Rotation pRotation)”””
return _almath.rotationFromTransformInPlace(*args)
def rotationFromTransform(*args):
“””rotationFromTransform(Transform pTransform) -> Rotation”””
return _almath.rotationFromTransform(*args)
def rotation3DFromRotation(*args):
“””rotation3DFromRotation(Rotation pRotation) -> Rotation3D”””
return _almath.rotation3DFromRotation(*args)
def position6DFromTransformInPlace(*args):
“””position6DFromTransformInPlace(Transform pT, Position6D pPos)”””
return _almath.position6DFromTransformInPlace(*args)
def position6DFromTransform(*args):
“””position6DFromTransform(Transform pT) -> Position6D”””
return _almath.position6DFromTransform(*args)
def transformFromPose2DInPlace(*args):
“””transformFromPose2DInPlace(Pose2D pPose, Transform pT)”””
return _almath.transformFromPose2DInPlace(*args)
def transformFromPose2D(*args):
“””transformFromPose2D(Pose2D pPose) -> Transform”””
return _almath.transformFromPose2D(*args)
def pose2DFromTransformInPlace(*args):
“””pose2DFromTransformInPlace(Transform pT, Pose2D pPos)”””
return _almath.pose2DFromTransformInPlace(*args)
def pose2DFromTransform(*args):
“””pose2DFromTransform(Transform pT) -> Pose2D”””
return _almath.pose2DFromTransform(*args)
def transformFromRotation3D(*args):
“””transformFromRotation3D(Rotation3D pRotation) -> Transform”””
return _almath.transformFromRotation3D(*args)
def transformFromPosition6D(*args):
“””transformFromPosition6D(Position6D pPosition6D) -> Transform”””
return _almath.transformFromPosition6D(*args)
def position6DFromTransformDiffInPlace(*args):
“””position6DFromTransformDiffInPlace(Transform pCurrent, Transform pTarget, Position6D result)”””
return _almath.position6DFromTransformDiffInPlace(*args)
def position6DFromTransformDiff(*args):
“””position6DFromTransformDiff(Transform pCurrent, Transform pTarget) -> Position6D”””
return _almath.position6DFromTransformDiff(*args)
def position3DFromTransformInPlace(*args):
“””position3DFromTransformInPlace(Transform pT, Position3D pPos)”””
return _almath.position3DFromTransformInPlace(*args)
def position3DFromTransform(*args):
“””position3DFromTransform(Transform pT) -> Position3D”””
return _almath.position3DFromTransform(*args)
def rotation3DFromTransform(*args):
“””rotation3DFromTransform(Transform pT) -> Rotation3D”””
return _almath.rotation3DFromTransform(*args)
def transformFromQuaternion(*args):
“””transformFromQuaternion(Quaternion pQua) -> Transform”””
return _almath.transformFromQuaternion(*args)
def quaternionFromTransform(*args):
“””quaternionFromTransform(Transform pT) -> Quaternion”””
return _almath.quaternionFromTransform(*args)
def clipData(*args):
“””clipData(float pMin, float pMax, float pData) -> bool”””
return _almath.clipData(*args)
def position6DFromVelocity6D(*args):
“””position6DFromVelocity6D(Velocity6D pVel) -> Position6D”””
return _almath.position6DFromVelocity6D(*args)
_4_PI_ = cvar._4_PI_
_2_PI_ = cvar._2_PI_
PI = cvar.PI
PI_2 = cvar.PI_2
PI_4 = cvar.PI_4
TO_RAD = cvar.TO_RAD
TO_DEG = cvar.TO_DEG
def transformMean(*args):
“””
transformMean(Transform pTIn1, Transform pTIn2, float pVal = 0.5) -> Transform
transformMean(Transform pTIn1, Transform pTIn2) -> Transform
“””
return _almath.transformMean(*args)
def transformFromRotationPosition3D(*args):
“””
transformFromRotationPosition3D(Rotation pRot, float pX, float pY, float pZ) -> Transform
transformFromRotationPosition3D(Rotation pRot, Position3D pPos) -> Transform
“””
return _almath.transformFromRotationPosition3D(*args)
def transformFromRotVecInPlace(*args):
“””
transformFromRotVecInPlace(int pAxis, float pTheta, Position3D pPos, Transform pT)
transformFromRotVecInPlace(Position3D pPos, Transform pT)
“””
return _almath.transformFromRotVecInPlace(*args)
def transformFromRotVec(*args):
“””
transformFromRotVec(int pAxis, float pTheta, Position3D pPos) -> Transform
transformFromRotVec(Position3D pPos) -> Transform
transformFromRotVec(int pAxis, float pTheta) -> Transform
“””
return _almath.transformFromRotVec(*args)
def axisRotationProjection(*args):
“””
axisRotationProjection(Position3D pPos, Transform pT) -> Transform
axisRotationProjection(Position3D pAxis, Rotation pRot) -> Rotation
“””
return _almath.axisRotationProjection(*args)
def axisRotationProjectionInPlace(*args):
“””
axisRotationProjectionInPlace(Position3D pPos, Transform pT)
axisRotationProjectionInPlace(Position3D pPos, Rotation pRot)
“””
return _almath.axisRotationProjectionInPlace(*args)
def orthogonalSpace(*args):
“””
orthogonalSpace(Position3D pPos, Transform pTOut)
orthogonalSpace(Position3D pPos) -> Transform
“””
return _almath.orthogonalSpace(*args)
def __mul__(*args):
“””
__mul__(float pM, Position2D pPos1) -> Position2D
__mul__(float pM, Position3D pPos1) -> Position3D
__mul__(float pM, Velocity3D pVel1) -> Velocity3D
__mul__(float pVal, Velocity6D pVel) -> Velocity6D
__mul__(Transform pT, Position3D pPos) -> Position3D
__mul__(Rotation pRot, Position3D pPos) -> Position3D
__mul__(float pVal, Position6D pPos) -> Velocity6D
“””
return _almath.__mul__(*args)
def rotationFromAngleDirection(*args):
“””
rotationFromAngleDirection(float pAngle, float pX, float pY, float pZ) -> Rotation
rotationFromAngleDirection(float pTheta, Position3D pPos) -> Rotation
“””
return _almath.rotationFromAngleDirection(*args)

pynaoqi-python-2.7-naoqi-1.14-linux32/_allog.so

pynaoqi-python-2.7-naoqi-1.14-linux32/inaoqi.py
# This file was automatically generated by SWIG (http://www.swig.org).
# Version 1.3.40
#
# Do not make changes to this file unless you know what you are doing–modify
# the SWIG interface file instead.
# This file is compatible with both classic and new-style classes.
from sys import version_info
if version_info >= (2,6,0):
def swig_import_helper():
from os.path import dirname
import imp
fp = None
try:
fp, pathname, description = imp.find_module(‘_inaoqi’, [dirname(__file__)])
except ImportError:
import _inaoqi
return _inaoqi
if fp is not None:
try:
_mod = imp.load_module(‘_inaoqi’, fp, pathname, description)
finally:
fp.close()
return _mod
_inaoqi = swig_import_helper()
del swig_import_helper
else:
import _inaoqi
del version_info
try:
_swig_property = property
except NameError:
pass # Python < 2.2 doesn't have 'property'. 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__ == 'SwigPyObject': 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,)
try:
_object = object
_newclass = 1
except AttributeError:
class _object : pass
_newclass = 0

class SwigPyIterator(_object):
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, SwigPyIterator, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, SwigPyIterator, name)
def __init__(self, *args, **kwargs): raise AttributeError(“No constructor defined – class is abstract”)
__repr__ = _swig_repr
__swig_destroy__ = _inaoqi.delete_SwigPyIterator
__del__ = lambda self : None;
def value(self): return _inaoqi.SwigPyIterator_value(self)
def incr(self, n = 1): return _inaoqi.SwigPyIterator_incr(self, n)
def decr(self, n = 1): return _inaoqi.SwigPyIterator_decr(self, n)
def distance(self, *args): return _inaoqi.SwigPyIterator_distance(self, *args)
def equal(self, *args): return _inaoqi.SwigPyIterator_equal(self, *args)
def copy(self): return _inaoqi.SwigPyIterator_copy(self)
def next(self): return _inaoqi.SwigPyIterator_next(self)
def __next__(self): return _inaoqi.SwigPyIterator___next__(self)
def previous(self): return _inaoqi.SwigPyIterator_previous(self)
def advance(self, *args): return _inaoqi.SwigPyIterator_advance(self, *args)
def __eq__(self, *args): return _inaoqi.SwigPyIterator___eq__(self, *args)
def __ne__(self, *args): return _inaoqi.SwigPyIterator___ne__(self, *args)
def __iadd__(self, *args): return _inaoqi.SwigPyIterator___iadd__(self, *args)
def __isub__(self, *args): return _inaoqi.SwigPyIterator___isub__(self, *args)
def __add__(self, *args): return _inaoqi.SwigPyIterator___add__(self, *args)
def __sub__(self, *args): return _inaoqi.SwigPyIterator___sub__(self, *args)
def __iter__(self): return self
SwigPyIterator_swigregister = _inaoqi.SwigPyIterator_swigregister
SwigPyIterator_swigregister(SwigPyIterator)
class StringVector(_object):
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, StringVector, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, StringVector, name)
__repr__ = _swig_repr
def iterator(self): return _inaoqi.StringVector_iterator(self)
def __iter__(self): return self.iterator()
def __nonzero__(self): return _inaoqi.StringVector___nonzero__(self)
def __bool__(self): return _inaoqi.StringVector___bool__(self)
def __len__(self): return _inaoqi.StringVector___len__(self)
def pop(self): return _inaoqi.StringVector_pop(self)
def __getslice__(self, *args): return _inaoqi.StringVector___getslice__(self, *args)
def __setslice__(self, *args): return _inaoqi.StringVector___setslice__(self, *args)
def __delslice__(self, *args): return _inaoqi.StringVector___delslice__(self, *args)
def __delitem__(self, *args): return _inaoqi.StringVector___delitem__(self, *args)
def __getitem__(self, *args): return _inaoqi.StringVector___getitem__(self, *args)
def __setitem__(self, *args): return _inaoqi.StringVector___setitem__(self, *args)
def append(self, *args): return _inaoqi.StringVector_append(self, *args)
def empty(self): return _inaoqi.StringVector_empty(self)
def size(self): return _inaoqi.StringVector_size(self)
def clear(self): return _inaoqi.StringVector_clear(self)
def swap(self, *args): return _inaoqi.StringVector_swap(self, *args)
def get_allocator(self): return _inaoqi.StringVector_get_allocator(self)
def begin(self): return _inaoqi.StringVector_begin(self)
def end(self): return _inaoqi.StringVector_end(self)
def rbegin(self): return _inaoqi.StringVector_rbegin(self)
def rend(self): return _inaoqi.StringVector_rend(self)
def pop_back(self): return _inaoqi.StringVector_pop_back(self)
def erase(self, *args): return _inaoqi.StringVector_erase(self, *args)
def __init__(self, *args):
this = _inaoqi.new_StringVector(*args)
try: self.this.append(this)
except: self.this = this
def push_back(self, *args): return _inaoqi.StringVector_push_back(self, *args)
def front(self): return _inaoqi.StringVector_front(self)
def back(self): return _inaoqi.StringVector_back(self)
def assign(self, *args): return _inaoqi.StringVector_assign(self, *args)
def resize(self, *args): return _inaoqi.StringVector_resize(self, *args)
def insert(self, *args): return _inaoqi.StringVector_insert(self, *args)
def reserve(self, *args): return _inaoqi.StringVector_reserve(self, *args)
def capacity(self): return _inaoqi.StringVector_capacity(self)
__swig_destroy__ = _inaoqi.delete_StringVector
__del__ = lambda self : None;
StringVector_swigregister = _inaoqi.StringVector_swigregister
StringVector_swigregister(StringVector)

def setInstance(*args):
return _inaoqi.setInstance(*args)
setInstance = _inaoqi.setInstance
def getMemoryProxy():
return _inaoqi.getMemoryProxy()
getMemoryProxy = _inaoqi.getMemoryProxy
def _ALSystem(*args):
return _inaoqi._ALSystem(*args)
_ALSystem = _inaoqi._ALSystem
class broker(_object):
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, broker, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, broker, name)
__repr__ = _swig_repr
def __init__(self, *args):
this = _inaoqi.new_broker(*args)
try: self.this.append(this)
except: self.this = this
__swig_destroy__ = _inaoqi.delete_broker
__del__ = lambda self : None;
def shutdown(self): return _inaoqi.broker_shutdown(self)
def isModulePresent(self, *args): return _inaoqi.broker_isModulePresent(self, *args)
def getGlobalModuleList(self): return _inaoqi.broker_getGlobalModuleList(self)
broker_swigregister = _inaoqi.broker_swigregister
broker_swigregister(broker)
class baseModule(_object):
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, baseModule, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, baseModule, name)
__repr__ = _swig_repr
def __init__(self):
this = _inaoqi.new_baseModule()
try: self.this.append(this)
except: self.this = this
def BIND_PYTHON(self, *args): return _inaoqi.baseModule_BIND_PYTHON(self, *args)
def _bindWithParam(self, *args): return _inaoqi.baseModule__bindWithParam(self, *args)
def exit(self): return _inaoqi.baseModule_exit(self)
def getName(self): return _inaoqi.baseModule_getName(self)
def getBrokerName(self): return _inaoqi.baseModule_getBrokerName(self)
def setModuleDescription(self, *args): return _inaoqi.baseModule_setModuleDescription(self, *args)
def addParam(self, *args): return _inaoqi.baseModule_addParam(self, *args)
def functionName(self, *args): return _inaoqi.baseModule_functionName(self, *args)
def autoBind(self, *args): return _inaoqi.baseModule_autoBind(self, *args)
def _methodMissing0(self): return _inaoqi.baseModule__methodMissing0(self)
def _methodMissing1(self, *args): return _inaoqi.baseModule__methodMissing1(self, *args)
def _methodMissing2(self, *args): return _inaoqi.baseModule__methodMissing2(self, *args)
def _methodMissing3(self, *args): return _inaoqi.baseModule__methodMissing3(self, *args)
def _methodMissing4(self, *args): return _inaoqi.baseModule__methodMissing4(self, *args)
def _methodMissing5(self, *args): return _inaoqi.baseModule__methodMissing5(self, *args)
def _methodMissing6(self, *args): return _inaoqi.baseModule__methodMissing6(self, *args)
def _methodMissing(self): return _inaoqi.baseModule__methodMissing(self)
def version(self): return _inaoqi.baseModule_version(self)
__swig_destroy__ = _inaoqi.delete_baseModule
__del__ = lambda self : None;
baseModule_swigregister = _inaoqi.baseModule_swigregister
baseModule_swigregister(baseModule)
class module(baseModule):
__swig_setmethods__ = {}
for _s in [baseModule]: __swig_setmethods__.update(getattr(_s,’__swig_setmethods__’,{}))
__setattr__ = lambda self, name, value: _swig_setattr(self, module, name, value)
__swig_getmethods__ = {}
for _s in [baseModule]: __swig_getmethods__.update(getattr(_s,’__swig_getmethods__’,{}))
__getattr__ = lambda self, name: _swig_getattr(self, module, name)
__repr__ = _swig_repr
def __init__(self, *args):
this = _inaoqi.new_module(*args)
try: self.this.append(this)
except: self.this = this
def BIND_PYTHON(self, *args): return _inaoqi.module_BIND_PYTHON(self, *args)
def exit(self): return _inaoqi.module_exit(self)
def getName(self): return _inaoqi.module_getName(self)
def getBrokerName(self): return _inaoqi.module_getBrokerName(self)
def _methodMissing(self): return _inaoqi.module__methodMissing(self)
def version(self): return _inaoqi.module_version(self)
__swig_destroy__ = _inaoqi.delete_module
__del__ = lambda self : None;
module_swigregister = _inaoqi.module_swigregister
module_swigregister(module)
class timeline(_object):
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, timeline, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, timeline, name)
__repr__ = _swig_repr
def __init__(self, *args):
this = _inaoqi.new_timeline(*args)
try: self.this.append(this)
except: self.this = this
__swig_destroy__ = _inaoqi.delete_timeline
__del__ = lambda self : None;
def play(self): return _inaoqi.timeline_play(self)
def pause(self): return _inaoqi.timeline_pause(self)
def stop(self): return _inaoqi.timeline_stop(self)
def goTo(self, *args): return _inaoqi.timeline_goTo(self, *args)
def getSize(self): return _inaoqi.timeline_getSize(self)
def getFPS(self): return _inaoqi.timeline_getFPS(self)
def setFPS(self, *args): return _inaoqi.timeline_setFPS(self, *args)
timeline_swigregister = _inaoqi.timeline_swigregister
timeline_swigregister(timeline)
class behavior(baseModule):
__swig_setmethods__ = {}
for _s in [baseModule]: __swig_setmethods__.update(getattr(_s,’__swig_setmethods__’,{}))
__setattr__ = lambda self, name, value: _swig_setattr(self, behavior, name, value)
__swig_getmethods__ = {}
for _s in [baseModule]: __swig_getmethods__.update(getattr(_s,’__swig_getmethods__’,{}))
__getattr__ = lambda self, name: _swig_getattr(self, behavior, name)
__repr__ = _swig_repr
def __init__(self, *args):
this = _inaoqi.new_behavior(*args)
try: self.this.append(this)
except: self.this = this
__swig_destroy__ = _inaoqi.delete_behavior
__del__ = lambda self : None;
def setEnabled(self, *args): return _inaoqi.behavior_setEnabled(self, *args)
def isEnabled(self): return _inaoqi.behavior_isEnabled(self)
def setResources(self, *args): return _inaoqi.behavior_setResources(self, *args)
def waitFor(self, *args): return _inaoqi.behavior_waitFor(self, *args)
def waitResourcesCallback(self, *args): return _inaoqi.behavior_waitResourcesCallback(self, *args)
def isResourceFree(self, *args): return _inaoqi.behavior_isResourceFree(self, *args)
def waitResourceFree(self): return _inaoqi.behavior_waitResourceFree(self)
def waitResources(self): return _inaoqi.behavior_waitResources(self)
def releaseResource(self): return _inaoqi.behavior_releaseResource(self)
def addInput(self, *args): return _inaoqi.behavior_addInput(self, *args)
def addOutput(self, *args): return _inaoqi.behavior_addOutput(self, *args)
def addParameter(self, *args): return _inaoqi.behavior_addParameter(self, *args)
def getParameter(self, *args): return _inaoqi.behavior_getParameter(self, *args)
def getParametersList(self): return _inaoqi.behavior_getParametersList(self)
def setParameter(self, *args): return _inaoqi.behavior_setParameter(self, *args)
def stimulateIO(self, *args): return _inaoqi.behavior_stimulateIO(self, *args)
def BIND_PYTHON(self, *args): return _inaoqi.behavior_BIND_PYTHON(self, *args)
def setModuleDescription(self, *args): return _inaoqi.behavior_setModuleDescription(self, *args)
def addParam(self, *args): return _inaoqi.behavior_addParam(self, *args)
def exit(self): return _inaoqi.behavior_exit(self)
def getName(self): return _inaoqi.behavior_getName(self)
def getBrokerName(self): return _inaoqi.behavior_getBrokerName(self)
def _methodMissing(self): return _inaoqi.behavior__methodMissing(self)
def version(self): return _inaoqi.behavior_version(self)
def hasTimeline(self): return _inaoqi.behavior_hasTimeline(self)
def getTimeline(self): return _inaoqi.behavior_getTimeline(self)
def hasParentTimeline(self): return _inaoqi.behavior_hasParentTimeline(self)
def getParentTimeline(self): return _inaoqi.behavior_getParentTimeline(self)
behavior_swigregister = _inaoqi.behavior_swigregister
behavior_swigregister(behavior)
class proxy(_object):
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, proxy, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, proxy, name)
__repr__ = _swig_repr
def __init__(self, *args):
this = _inaoqi.new_proxy(*args)
try: self.this.append(this)
except: self.this = this
def pythonCall(self, *args): return _inaoqi.proxy_pythonCall(self, *args)
def pythonPCall(self, *args): return _inaoqi.proxy_pythonPCall(self, *args)
def wait(self, *args): return _inaoqi.proxy_wait(self, *args)
def stop(self, *args): return _inaoqi.proxy_stop(self, *args)
def isRunning(self, *args): return _inaoqi.proxy_isRunning(self, *args)
__swig_destroy__ = _inaoqi.delete_proxy
__del__ = lambda self : None;
proxy_swigregister = _inaoqi.proxy_swigregister
proxy_swigregister(proxy)
class ALMemoryProxy(_object):
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, ALMemoryProxy, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, ALMemoryProxy, name)
__repr__ = _swig_repr
def __init__(self, *args):
this = _inaoqi.new_ALMemoryProxy(*args)
try: self.this.append(this)
except: self.this = this
__swig_setmethods__[“post”] = _inaoqi.ALMemoryProxy_post_set
__swig_getmethods__[“post”] = _inaoqi.ALMemoryProxy_post_get
if _newclass:post = _swig_property(_inaoqi.ALMemoryProxy_post_get, _inaoqi.ALMemoryProxy_post_set)
def getGenericProxy(self): return _inaoqi.ALMemoryProxy_getGenericProxy(self)
def declareEvent(self, *args): return _inaoqi.ALMemoryProxy_declareEvent(self, *args)
def exit(self): return _inaoqi.ALMemoryProxy_exit(self)
def getBrokerName(self): return _inaoqi.ALMemoryProxy_getBrokerName(self)
def getData(self, *args): return _inaoqi.ALMemoryProxy_getData(self, *args)
def getDataList(self, *args): return _inaoqi.ALMemoryProxy_getDataList(self, *args)
def getDataListName(self): return _inaoqi.ALMemoryProxy_getDataListName(self)
def getDataOnChange(self, *args): return _inaoqi.ALMemoryProxy_getDataOnChange(self, *args)
def getDataPtr(self, *args): return _inaoqi.ALMemoryProxy_getDataPtr(self, *args)
def getDescriptionList(self, *args): return _inaoqi.ALMemoryProxy_getDescriptionList(self, *args)
def getEventHistory(self, *args): return _inaoqi.ALMemoryProxy_getEventHistory(self, *args)
def getEventList(self): return _inaoqi.ALMemoryProxy_getEventList(self)
def getExtractorEvent(self, *args): return _inaoqi.ALMemoryProxy_getExtractorEvent(self, *args)
def getListData(self, *args): return _inaoqi.ALMemoryProxy_getListData(self, *args)
def getMethodHelp(self, *args): return _inaoqi.ALMemoryProxy_getMethodHelp(self, *args)
def getMethodList(self): return _inaoqi.ALMemoryProxy_getMethodList(self)
def getMicroEventList(self): return _inaoqi.ALMemoryProxy_getMicroEventList(self)
def getModuleHelp(self): return _inaoqi.ALMemoryProxy_getModuleHelp(self)
def getSubscribers(self, *args): return _inaoqi.ALMemoryProxy_getSubscribers(self, *args)
def getTimestamp(self, *args): return _inaoqi.ALMemoryProxy_getTimestamp(self, *args)
def getType(self, *args): return _inaoqi.ALMemoryProxy_getType(self, *args)
def getUsage(self, *args): return _inaoqi.ALMemoryProxy_getUsage(self, *args)
def insertData(self, *args): return _inaoqi.ALMemoryProxy_insertData(self, *args)
def insertListData(self, *args): return _inaoqi.ALMemoryProxy_insertListData(self, *args)
def isRunning(self, *args): return _inaoqi.ALMemoryProxy_isRunning(self, *args)
def ping(self): return _inaoqi.ALMemoryProxy_ping(self)
def raiseEvent(self, *args): return _inaoqi.ALMemoryProxy_raiseEvent(self, *args)
def raiseMicroEvent(self, *args): return _inaoqi.ALMemoryProxy_raiseMicroEvent(self, *args)
def removeData(self, *args): return _inaoqi.ALMemoryProxy_removeData(self, *args)
def removeMicroEvent(self, *args): return _inaoqi.ALMemoryProxy_removeMicroEvent(self, *args)
def setDescription(self, *args): return _inaoqi.ALMemoryProxy_setDescription(self, *args)
def stop(self, *args): return _inaoqi.ALMemoryProxy_stop(self, *args)
def subscribeToEvent(self, *args): return _inaoqi.ALMemoryProxy_subscribeToEvent(self, *args)
def subscribeToMicroEvent(self, *args): return _inaoqi.ALMemoryProxy_subscribeToMicroEvent(self, *args)
def unregisterModuleReference(self, *args): return _inaoqi.ALMemoryProxy_unregisterModuleReference(self, *args)
def unsubscribeToEvent(self, *args): return _inaoqi.ALMemoryProxy_unsubscribeToEvent(self, *args)
def unsubscribeToMicroEvent(self, *args): return _inaoqi.ALMemoryProxy_unsubscribeToMicroEvent(self, *args)
def version(self): return _inaoqi.ALMemoryProxy_version(self)
def wait(self, *args): return _inaoqi.ALMemoryProxy_wait(self, *args)
__swig_destroy__ = _inaoqi.delete_ALMemoryProxy
__del__ = lambda self : None;
ALMemoryProxy_swigregister = _inaoqi.ALMemoryProxy_swigregister
ALMemoryProxy_swigregister(ALMemoryProxy)

pynaoqi-python-2.7-naoqi-1.14-linux32/motion.py
# Class Motion for storing useful ALMotion constants
# SPACES
SPACE_TORSO = 0
SPACE_WORLD = 1
SPACE_NAO = 2
# NEW in 1.14
FRAME_TORSO = 0
FRAME_WORLD = 1
FRAME_ROBOT = 2
# MOVEMENT
MVT_RELATIVE = 0
MVT_ABSOLUTE = 1
#ANGLE TYPE
COMMANDS = 0,
SENSORS = 1
# AXIS MASK
AXIS_MASK_X = 1
AXIS_MASK_Y = 2
AXIS_MASK_Z = 4
AXIS_MASK_WX = 8
AXIS_MASK_WY = 16
AXIS_MASK_WZ = 32
AXIS_MASK_ALL = 63
AXIS_MASK_VEL = 7
AXIS_MASK_ROT = 56
# COMPUTING
TO_RAD = 0.01745329
TO_DEG = 57.295779513082323

pynaoqi-python-2.7-naoqi-1.14-linux32/vision_definitions.py
# Useful constants used by the Vision modules.
# Camera model
kOV7670 = 1 # VGA camera
kMT9M114 = 2 # HD wide angle camera
# Image format
k960p = 3 # 1280*960
k4VGA = 3 # 1280*960
kVGA = 2 # 640*480
kQVGA = 1 # 320*240
kQQVGA = 0 # 160*120
# Color Space
kYuvColorSpace = 0
kyUvColorSpace = 1
kyuVColorSpace = 2
kRgbColorSpace = 3
krGbColorSpace = 4
krgBColorSpace = 5
kHsvColorSpace = 6
khSvColorSpace = 7
khsVColorSpace = 8
kYUV422InterlacedColorSpace = 9 #deprecated
kYUV422ColorSpace = 9
kYUVColorSpace = 10
kRGBColorSpace = 11
kHSVColorSpace = 12
kBGRColorSpace = 13
kYYCbCrColorSpace = 14
kH2RGBColorSpace = 15
kHSMixedColorSpace = 16

# Scale methods
kSimpleScaleMethod = 0
kAverageScaleMethod = 1
kQualityScaleMethod = 2
kNoScaling = 3

# Standard Id
kCameraBrightnessID = 0
kCameraContrastID = 1
kCameraSaturationID = 2
kCameraHueID = 3
kCameraRedChromaID = 4
kCameraBlueChromaID = 5
kCameraGainID = 6
kCameraHFlipID = 7
kCameraVFlipID = 8
kCameraLensXID = 9
kCameraLensYID = 10
kCameraAutoExpositionID = 11
kCameraAutoWhiteBalanceID = 12
kCameraAutoGainID = 13
kCameraResolutionID = 14
kCameraFrameRateID = 15
kCameraBufferSizeID = 16
kCameraExposureID = 17
kCameraSelectID = 18
kCameraSetDefaultParamsID = 19
kCameraColorSpaceID = 20
kCameraExposureCorrectionID = 21
kCameraAecAlgorithmID = 22
kCameraFastSwitchID = 23
kCameraSharpnessID = 24
kCameraAwbGreenGainID = 25
kCameraAblcID = 26
kCameraAblcTargetID = 27
kCameraAblcStableRangeID = 28
kCameraBlcBlueID = 29
kCameraBlcRedID = 30
kCameraBlcGbID = 31
kCameraBlcGrID = 32
kCameraWhiteBalanceID = 33
kCameraBacklightCompensationID = 34

pynaoqi-python-2.7-naoqi-1.14-linux64/_inaoqi.so

pynaoqi-python-2.7-naoqi-1.14-linux64/_almath.so

pynaoqi-python-2.7-naoqi-1.14-linux64/naoqi.py
import os
import sys
import weakref
import logging

try:
import _inaoqi
except ImportError:
# quick hack to keep inaoqi.py happy
if sys.platform.startswith(“win”):
print “Could not find _inaoqi, trying with _inaoqi_d”
import _inaoqi_d as _inaoqi
else:
raise
import inaoqi
import motion
import allog
def autoBind(myClass, bindIfnoDocumented):
“””Show documentation for each
method of the class”””
# dir(myClass) is a list of the names of
# everything in class
myClass.setModuleDescription(myClass.__doc__)
for thing in dir(myClass):
# getattr(x, “y”) is exactly: x.y
function = getattr(myClass, thing)
if callable(function):
if (type(function) == type(myClass.__init__)):
if (bindIfnoDocumented or function.__doc__ != “”):
if (thing[0] != “_”): # private method
if (function.__doc__):
myClass.functionName(thing, myClass.getName(), function.__doc__)
else:
myClass.functionName(thing, myClass.getName(), “”)
for param in function.func_code.co_varnames:
if (param != “self”):
myClass.addParam(param)
myClass._bindWithParam(myClass.getName(),thing,len(function.func_code.co_varnames)-1)

class ALDocable():
def __init__(self, bindIfnoDocumented):
autoBind(self,bindIfnoDocumented)

# define the log handler to be used by the logging module
class ALLogHandler(logging.Handler):
def __init__(self):
logging.Handler.__init__(self)
def emit(self, record):
level_to_function = {
logging.DEBUG: allog.debug,
logging.INFO: allog.info,
logging.WARNING: allog.warning,
logging.ERROR: allog.error,
logging.CRITICAL: allog.fatal,
}
function = level_to_function.get(record.levelno, allog.debug)
function(record.getMessage(),
record.name,
record.filename,
record.funcName,
record.lineno)

# Same as above, but we force the category to be behavior.box
# *AND* we prefix the message with the module name
# look at errorInBox in choregraphe for explanation
class ALBehaviorLogHandler(logging.Handler):
def __init__(self):
logging.Handler.__init__(self)
def emit(self, record):
level_to_function = {
logging.DEBUG: allog.debug,
logging.INFO: allog.info,
logging.WARNING: allog.warning,
logging.ERROR: allog.error,
logging.CRITICAL: allog.fatal,
}
function = level_to_function.get(record.levelno, allog.debug)
function(record.name + “: ” + record.getMessage(),
“behavior.box”,
“”, # record.filename in this case is simply ‘‘
record.funcName,
record.lineno)
# define a class that will be inherited by both ALModule and ALBehavior, to store instances of modules, so a bound method can be called on them.
class NaoQiModule():
_modules = dict()
@classmethod
def getModule(cls, name):
# returns a reference a module, giving its string, if it exists !
if(name not in cls._modules):
raise RuntimeError(“Module ” + str(name) + ” does not exist”)
return cls._modules[name]()
def __init__(self, name, logger=True):
# keep a weak reference to ourself, so a proxy can be called on this module easily
self._modules[name] = weakref.ref(self)
self.loghandler = None
if logger:
self.logger = logging.getLogger(name)
self.loghandler = ALLogHandler()
self.logger.addHandler(self.loghandler)
self.logger.setLevel(logging.DEBUG)
def __del__(self):
# when object is deleted, clean up dictionnary so we do not keep a weak reference to it
del self._modules[self.getName()]
if(self.loghandler != None):
self.logger.removeHandler(self.loghandler)

class ALBroker(inaoqi.broker):
def init(self):
pass
class ALModule(inaoqi.module, ALDocable, NaoQiModule):
def __init__(self,param):
inaoqi.module.__init__(self, param)
ALDocable.__init__(self, False)
NaoQiModule.__init__(self, param)
def __del__(self):
NaoQiModule.__del__(self)
def methodtest(self):
pass
def pythonChanged(self, param1, param2, param3):
pass

class ALBehavior(inaoqi.behavior, NaoQiModule):
# class var in order not to build it each time
_noNeedToBind = set(dir(inaoqi.behavior))
_noNeedToBind.add(“getModule”)
_noNeedToBind.add(“onLoad”)
_noNeedToBind.add(“onUnload”)
# deprecated since 1.14 methods
_noNeedToBind.add(“log”)
_noNeedToBind.add(“playTimeline”)
_noNeedToBind.add(“stopTimeline”)
_noNeedToBind.add(“exitBehavior”)
_noNeedToBind.add(“gotoAndStop”)
_noNeedToBind.add(“gotoAndPlay”)
_noNeedToBind.add(“playTimelineParent”)
_noNeedToBind.add(“stopTimelineParent”)
_noNeedToBind.add(“exitBehaviorParent”)
_noNeedToBind.add(“gotoAndPlayParent”)
_noNeedToBind.add(“gotoAndStopParent”)
def __init__(self, param, autoBind):
inaoqi.behavior.__init__(self, param)
NaoQiModule.__init__(self, param, logger=False)
self.logger = logging.getLogger(param)
self.behaviorloghandler = ALBehaviorLogHandler()
self.logger.addHandler(self.behaviorloghandler)
self.logger.setLevel(logging.DEBUG)
self.resource = False
self.BIND_PYTHON(self.getName(), “__onLoad__”)
self.BIND_PYTHON(self.getName(), “__onUnload__”)
if(autoBind):
behName = self.getName()
userMethList = set(dir(self)) – self._noNeedToBind
for methName in userMethList:
function = getattr(self, methName)
if callable(function) and type(function) == type(self.__init__):
if (methName[0] != “_”): # private method
self.functionName(methName, behName, “”)
for param in function.func_code.co_varnames:
if (param != “self”):
self.addParam(param)
self._bindWithParam(behName,methName,len(function.func_code.co_varnames)-1)
def __del__(self):
NaoQiModule.__del__(self)
self.logger.removeHandler(self.behaviorloghandler)
self.behaviorloghandler.close()
def __onLoad__(self):
self._safeCallOfUserMethod(“onLoad”,None)
def __onUnload__(self):
if(self.resource):
self.releaseResource()
self._safeCallOfUserMethod(“onUnload”,None)
def setParameter(self, parameterName, newValue):
inaoqi.behavior.setParameter(self, parameterName, newValue)
def _safeCallOfUserMethod(self, functionName, functionArg):
try:
if(functionName in dir(self)):
func = getattr(self, functionName)
if(func.im_func.func_code.co_argcount == 2):
func(functionArg)
else:
func()
return True
except BaseException, err:
self.logger.error(str(err))
try:
if(“onError” in dir(self)):
self.onError(self.getName() + ‘:’ +str(err))
except BaseException, err2:
self.logger.error(str(err2))
return False
# Depreciate this!!! Same as self.logger.info(), but function is always “log”
def log(self, p):
self.logger.info(p)

class MethodMissingMixin(object):
“”” A Mixin’ to implement the ‘method_missing’ Ruby-like protocol. “””
def __getattribute__(self, attr):
try:
return object.__getattribute__(self, attr)
except:
class MethodMissing(object):
def __init__(self, wrapped, method):
self.__wrapped__ = wrapped
self.__method__ = method
def __call__(self, *args, **kwargs):
return self.__wrapped__.method_missing(self.__method__, *args, **kwargs)
return MethodMissing(self, attr)
def method_missing(self, *args, **kwargs):
“”” This method should be overridden in the derived class. “””
raise NotImplementedError(str(self.__wrapped__) + ” ‘method_missing’ method has not been implemented.”)

class postType(MethodMissingMixin):
def __init__(self):
“”
def setProxy(self, proxy):
self.proxy = weakref.ref(proxy)
# print name
def method_missing(self, method, *args, **kwargs):
list = []
list.append(method)
for arg in args:
list.append(arg)
result = 0
try:
p = self.proxy()
result = p.pythonPCall(list)
except RuntimeError,e:
raise e
return result

class ALProxy(inaoqi.proxy,MethodMissingMixin):
def __init__(self, *args):
self.post = postType()
self.post.setProxy(self)
if (len (args) == 1):
inaoqi.proxy.__init__(self, args[0])
elif (len (args) == 2):
inaoqi.proxy.__init__(self, args[0], args[1])
else:
inaoqi.proxy.__init__(self, args[0], args[1], args[2])
def call(self, *args):
list = []
for arg in args:
list.append(arg)
return self.pythonCall(list)

def pCall(self, *args):
list = []
for arg in args:
list.append(arg)
return self.pythonPCall(list)

def method_missing(self, method, *args, **kwargs):
list = []
list.append(method)
for arg in args:
list.append(arg)
result = 0
try:
result = self.pythonCall(list)
except RuntimeError,e:
raise e
#print e.args[0]
return result
@staticmethod
def initProxies():
#Warning: The use of these default proxies is deprecated.
global ALMemory
global ALMotion
global ALFrameManager
global ALLeds
global ALLogger
global ALSensors
try:
ALMemory = inaoqi.getMemoryProxy()
except:
ALMemory = ALProxy(“ALMemory”)
try:
ALFrameManager = ALProxy(“ALFrameManager”)
except:
print “No proxy to ALFrameManager”
try:
ALMotion = ALProxy(“ALMotion”)
except:
print “No proxy to ALMotion”
try:
ALLeds = ALProxy(“ALLeds”)
except:
pass
try:
ALLogger = ALProxy(“ALLogger”)
except:
print “No proxy to ALLogger”
try:
ALSensors = ALProxy(“ALSensors”)
except:
pass

def createModule(name):
global moduleList
str = “moduleList.append(“+ “module(\”” + name + “\”))”
exec(str)

pynaoqi-python-2.7-naoqi-1.14-linux64/license.rtf

End-
User Software License Agreement

This Limited End-User Software License Agreement (the “Agreement”) is a legal agreement between you (“Licensee”), the end-user, and Aldebaran Robotics SAS having its registered office at 168-170 Rue Raymond Losserand, 75014 Paris, France, registered with the trade and companies register of Paris under number 483 185 807 (hereinafter “Aldebaran”) for the use of the ” Aldebaran Software Toolkit ” (“Software”). By using this software or storing this program on a computer or robot hard drive (or other media), you are agreeing to be bound by the terms of this Agreement. If you do not agree to any of the terms of this agreement uninstall and delete the software from all storage media.

ARTICLE 1 – RIGHTS GRANTED

ALDEBARAN grants to the LICENSEE a personal, non-exclusive, non-transferable, non sub-licensable right to install and use the Software and the Documentation (if any), for the duration of the applicable intellectual property rights.

ALDEBARAN shall have the right to make update and/or upgrade of the Software. However this Agreement does not grant any right on any update or upgrade of the Software. In the event ALDEBARAN provided an upgrade or upgrade of the Software which is not used by Licensee will not benefit from warranties given by ALDABARAN within this Agreement (as far as permitted by the applicable law).

ALDEBARAN may discontinue or change the Software, at any time or for any reason, with or without notice. To avoid any misunderstanding it is agreed that ALDEBARAN has no right to operate a change on the LICENSEE‘s device where the Software is install without its consent.

This Agreement does not grant any right to any Third-Party Software.

Some Third-Party Software may be needed to permit the Software to operate properly. Even in such event ALDEBARAN is not granting any right on the Third-Party Software. The Third-Party Software remains subject to the specific licenses applicable to each Third-Party Software and as described in their related applicable documentation. Licensee shall on his owns decide to either accept or not the applicable terms and conditions related to Third-Party Software. Licensee accepts and understands that refusing the terms and conditions applicable to Third-Party Software may impact in whole or in part the use of the Software.

ARTICLE 2 – OBLIGATIONS OF THE LICENSEE

LICENSEE agrees to the following:

– The LICENSEE shall strictly comply with the user instructions set forth in the Documentation;

– Even if LICENSEE keeps its right of objectively critic the Software, the LICENSEE shall not take any action to impair the reputation of the Product, the trademarks of ALDEBARAN or its licensors and any other product of ALDEBARAN or its licensors;

– LICENSEE shall in no event use the Software for any illegal, defaming, pornographic or detrimental activities;

– The LICENSEE shall use the ALDEBARAN name and trademarks only in the manner prescribed by ALDEBARAN in writing;

– The LICENSEE shall inform ALDEBARAN of any potential defects discovered when using the Product;

– The LICENSEE shall notify ALDEBARAN promptly of any legal notices, claims or actions directly or indirectly relating to the Software against a third party and not enter into or compromise any legal action or other proceeding relating to the Software without the prior written consent of ALDEBARAN;

– The LICENSEE shall not use, without the prior written consent of ALDEBARAN, the Software for the benefit of third parties in any manner, and in particular:

(a) not sell, resell, lease, transfer, license or sublicense or otherwise provide the Software to any third party, and, in a more general manner, not communicate all or part of the Software to any third party;

(b) not charge or otherwise deal in or encumber the Software;

– The LICENSEE shall not delete, remove or in any way obscure the proprietary notices, labels or marks of ALDEBARAN or its licensors on the Software and conspicuously display the proprietary notices, labels or marks on any copy of the Software;

– Except otherwise expressly agreed the LICENSEE shall not alter, modify, decompile, disassemble, or reverse engineer the program code or any other part of the Software, in whole or in part, except in the events and only to the extent expressly provided by law. However, even if the law authorizes the above acts, LICENSEE shall give ALDEBARAN a written notice seven (7) calendar days prior to the date on which these acts are scheduled to take place and allow a representative of ALDEBARAN to be present during these acts;

– Except otherwise expressly agreed the LICENSEE shall not develop any other software programs or derivative works on the basis of the Software. Any such software program or derivative work shall in no case be sold, assigned or licensed by the LICENSEE;

– To avoid any misunderstanding it is agreed that LICENSEE shall have the right to use and exploit the result given by the use of the software in conformity of this license agreement.

– The LICENSEE shall not use the Software for illegal purposes or in illegal manner, including in violation of the intellectual property rights of ALDEBARAN or any third party;

– The LICENSEE shall provide ALDEBARAN promptly with any information, material, software or specification as may reasonably be required for the proper performance of this Agreement including access to appropriate members of the LICENSEE’s staff. The LICENSEE is responsible for the completeness and accuracy of such information, material, software or specification;

ARTICLE 3 – LIMITED WARRANTIES AND LIMITATION OF LIABILITY

3.1 ALDEBARAN warrants that it has full title and ownership to the Software. ALDEBARAN also warrants that it has the full power and authority to enter into this agreement and to grant the license conveyed in this Agreement. Aldebaran warrants that the use of the Software in conformity with this Agreement will in no way constitute an infringement or other violation of any Intellectual Property of any third party.
Should the Software give rise, or in ALDEBARAN opinion be likely to give rise to any such claim, ALDEBARAN shall, at its option and expense, either:

(i) procure for LICENSEE the right to continue using such Aldebaran Software; or
(ii) replace or modify the Aldebaran Software so that it does not infringe the intellectual property rights anymore; or
(iii) terminate the right of use of the Software.

Except as set out in this Agreement, all conditions, warranties and representations in relation to the Software are excluded to the extent permitted under applicable law.

3.2 AS FAR AS PERMITTED BY THE APPLICABLE LAW:

ALDEBARAN PROVIDES THE SOFTWARE “AS IS”, AND DOES NOT WARRANT THAT THE USE OF THE SOFTWARE, FUNCTIONALITY, THE OPERATION AND/OR CONTENT WILL BE: UNINTERRUPTED, ACCURATE, COMPLETE, FREE FROM ANY SOFTWARE VIRUS OR OTHER HARMFUL COMPONENT.

ALDEBARAN DOES NOT WARRANT THE INTERNAL CHARACTERISTICS, THE COMPATIBILITY FO THE SOFTWARE WITH OTHER SOFTWARE, THE ACCURACY, ADEQUACY, OR COMPLETENESS OF SOTWARE AND ITS RESULT AND DISCLAIMS LIABILITY FOR ERRORS OR OMISSIONS.

ALDEBARAN DISCLAIMS ANY REPRESENTATIONS, WARRANTIES OR CONDITIONS, EXPRESS OR IMPLIED, INCLUDING THOSE OF PERFORMANCE OR MERCHANTABILITY OR RELIABILITY USEFULNESS OR FITNESS FOR A PARTICULAR PURPOSE WITH RESPECT TO THE SOFTWARE AND ITS RESULTS.

3.3 IN NO EVENT WILL ALDEBARAN BE LIABLE FOR ANY DAMAGES (INCLUDING WITHOUT LIMITATION DIRECT, INDIRECT, PUNITIVE, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES, COST OF PROCURING SUBSTITUTE SERVICES, LOST PROFITS, LOSS OF DATA, LOSSES, OR OTHER EXPENSES) ARISING IN CONNECTION WITH THE PROVISION OR USE OF THE SOFTWARE, RELATED SERVICES OR INFORMATION PROVIDED PURSUANT TO THIS AGREEMENT, REGARDLESS OF WHETHER SUCH CLAIMS ARE BASED ON CONTRACT, TORT, STRICT LIABILITY, OR OTHERWISE, OR WHETHER PROVIDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES, LOSSES, OR EXPENSES.

WITHOUT LIMITING THE FOREGOING, THIS LIMITATION OF LIABILITY INCLUDES, BUT IS NOT LIMITED TO, THE UNAVAILABILITY OF THE APPLICATION(S), UNAUTHORIZED ACCESS, ANY FAILURE OF PERFORMANCE, INTERRUPTION, ERROR, OMISSION, DEFECT, DELAY IN OPERATION OR TRANSMISSION, COMPUTER VIRUS, OR SYSTEM FAILURE.

NOTWITHSTANDING ANYTHING TO THE CONTRARY IN THIS AGREEMENT OR ANY STATUTE OR RULE OF LAW TO THE CONTRARY, SUBJECT TO THIS ARTICLE, ALDEBARAN’S CUMULATIVE LIABILITY FOR ALL CLAIMS ARISING OUT OF OR IN CONNECTION WITH THIS AGREEMENT, WHETHER DIRECTLY OR INDIRECTLY, SHALL NOT EXCEED ALL FEES PAID TO ALDEBARAN BY THE LICENSEE FOR THE USE OF THE SOFTWARE. IN THE EVENT THE SOFTWARE IS GRANTED FOR FREE TO THE LICENSEE, ALDEBARAN’S CUMULATIVE LIABILITY FOR ALL CLAIMS ARISING OUT OF OR IN CONNECTION WITH THIS AGREEMENT, WHETHER DIRECTLY OR INDIRECTLY, SHALL NOT EXCEED 100 € (ONE HUNDRED EUROS).

WHENEVER THE ABOVE SECTIONS ARE NOT APPLICABLE UNDER THE APPLYING LAW ALDEBARAN AS SOLE REMEDY SHALL AT ITS OPTION AND EXPENSE EITHER (I) REPAIR THE DEFECTIVE OR INFRINGING SOFTWARE, OR (II) REPLACE THE DEFECTIVE OR INFRINGING SOFTWARE, OR (III) REIMBURSE THE FEE PAID TO ALDEBARAN FOR THE DEFECTIVE OR INFRINGING SOFTWARE. THESE REMEDIES ARE EXCLUSIVE OF ANY OTHER REMEDIES AND ANY OTHER WARRANTY IS EXCLUDED.

ANY INDEMNIFICATION BY ALDEBARAN UNDER THIS WARRANTY IS EXCLUDED IF THE CLAIM IS BASED UPON (I) A MODIFIED VERSION OF THE SOFTWARE FOR WHICH THE CHANGES HAVE NOT BEEN EXPRESSLY AUTHORIZED OR VALIDATED BY ALDEBARAN, OR (II) A COMBINATION, INSTALLATION OR USE OF ANY SOFTWARE COMPONENT EMBEDDED IN THE NAO ROBOT WITH ANY OTHER ELEMENT, MATERIAL OR ITEM THAT IS NOT EXPRESSLY PROVIDED BY ALDEBARAN FOR COMBINATION, INSTALLATION OR USE WITH THE SOFTWARE,
OR (III) A COMBINATION, INSTALLATION OR USE OF THE SOFTWARE WITH ANY OTHER ELEMENT, MATERIAL OR ITEM THAT IS NOT EXPRESSLY AUTHORIZED BY ALDEBARAN FOR COMBINATION, INSTALLATION OR USE WITH THE SOFTWARE, OR (IV) ANY OTHER FAULT OR NEGLIGENCE OF LICENSEE OR A THIRD PARTY.

This warranty does not cover incorrect installation or use by any third party; misuse of the Software voids the warranty.
The Third-Party Software is warranted only as provided in the specific licenses applicable to each.

ARTICLE 4 – INTELLECTUAL PROPERTY

ALDEBARAN is the owner or licensee of the Software. Title, copyright and any other proprietary and intellectual property right in the Software shall remain vested in ALDEBARAN or its licensors. The rights granted to the LICENSEE under this Agreement do not transfer to the LICENSEE title or any proprietary or intellectual property rights to the Software and do not constitute a sale of such rights;

ALDEBARAN shall retain the ownership of all rights in any inventions, discoveries, improvements, ideas, techniques or know-how embodied conceived by ALDEBARAN under this Agreement, including, without limitation, its methods of work, programs, methodologies and related documentation, including any derivative works of software code developed by ALDEBARAN in the course of performing this Agreement as well any knowledge and experience of ALDEBARAN’s directors, staff and consultants.

ARTICLE 5
–

COLLECTION AND USE OF PERSONAL INFORMATION

Privacy of the Licensee is important to ALDEBARAN. Therefore ALDEBARAN is not collecting any personal data except as expressly agreed by the Licensee.

ALDEBARAN will abide any applicable law, rules, or regulations relating to the privacy of personal information. Such data shall only be used for the purposes for which it was provided. Licensee understands that Third Party software may have their own privacy policy which may be less secure than the Aldebaran’s privacy policy.

ALDEBARAN will do its best to ensure that any personal data which may be collected from the Licensee will remain confidential.

Licensee hereby agrees and consents that the following data maybe collected by ALDEBARAN in order permit a network-enhanced services, improve the general quality and/or functionality of its products and/or software, permit development of new version of its products and/or software, fix bug or defect, develop patch and other solution, permit to install new version, update or upgrade, monitor and/or permit the maintenance of Aldebaran products and/or software:
Crash reporting, robot ID, robot health metrics, hardware-specific preferences, application install history, user preferences.

Licensee expressly consents that Aldebaran may generate statistical data from the information provided through the Software without identifying Licensee.
Licensee understands and agrees that, within the course of the use of the software, some voice data and/or video data could transit through ALDEBARAN and/or other third party network.

ARTICLE 6 – NO TRANSFER OR ASSIGNMENT

In no event shall LICENSEE sublicense, assign or otherwise transfer all or part of its rights and obligations under this Agreement to any third party. Any such sublicensing, assignment or transfer shall be null and void, unless expressly agreed to by ALDEBARAN in writing.

ARTICLE 7 – MISCELLEANEOUS

Termination. Either party may terminate this Agreement without advance notice. In case of breach of this Agreement by the Licensee, the authorization to access and use the Software will automatically terminate absent Aldebaran’s written waiver of such breach.

Survival. To the extent applicable, the following articles shall survive the termination, cancellation, expiration, and/or rescission of this Agreement: Articles 3.3, 4, 5, 7 and any provision that expressly states its survival and/or are necessary for the enforcement of this Agreement.

Headings. The headings referred to or used in this Agreement are for reference and convenience purposes only and shall not in any way limit or affect the meaning or interpretation of any of the terms hereof.

Severability. If any of the provisions of this Agreement are held or deemed to be invalid, illegal or unenforceable, the remaining provisions of this Agreement shall be unimpaired, and the invalid, illegal or unenforceable provision shall be replaced by a mutually acceptable provision, which being valid, legal and enforceable, comes closest to the intention of the Parties underlying the invalid, illegal or unenforceable provision.

Waiver. Any failure or delay by either Party in exercising its right under any provisions of the Agreement shall not be construed as a waiver of those rights at any time now or in the future unless an express declaration in writing from the Party concerned.

Governing law and Jurisdiction. Parties agree that all matters arising from or relating to the Software and this Agreement, shall be governed by the laws of France, without regard to conflict of laws principles. In the event of any dispute between the Parties, the Parties agreed to meet to discuss their dispute before resorting to formal dispute resolution procedures.

BY CLICKING “AGREE”, YOU AS LICENSEE ACKNOWLEDGE THAT YOU HAVE READ, UNDERSTAND AND ACCEPT THIS LIMITED END-USER SOFTWARE LICENSE AGREEMENT.

BY CLICKING “AGREE” YOU AS LICENSEE AGREE TO BE BOUND BY ALL OF ITS TERMS AND CONDITIONS OF THIS LIMITED END-USER SOFTWARE LICENSE AGREEMENT.

IF YOU AS A LICENSEE DO NOT AGREE TO ANY TERMS AND CONDITIONS, OF THIS LIMITED END-USER SOFTWARE LICENSE AGREEMENT DO NOT INSTALL OR USE THE SOFTWARE AND CLICK ON “DISAGREE”. By CLICKING ON “DESAGREE” YOU WILL NOT BE ABLE TO USE THE SOFTWARE.

pynaoqi-python-2.7-naoqi-1.14-linux64/allog.py
# This file was automatically generated by SWIG (http://www.swig.org).
# Version 1.3.40
#
# Do not make changes to this file unless you know what you are doing–modify
# the SWIG interface file instead.
# This file is compatible with both classic and new-style classes.
from sys import version_info
if version_info >= (2,6,0):
def swig_import_helper():
from os.path import dirname
import imp
fp = None
try:
fp, pathname, description = imp.find_module(‘_allog’, [dirname(__file__)])
except ImportError:
import _allog
return _allog
if fp is not None:
try:
_mod = imp.load_module(‘_allog’, fp, pathname, description)
finally:
fp.close()
return _mod
_allog = swig_import_helper()
del swig_import_helper
else:
import _allog
del version_info
try:
_swig_property = property
except NameError:
pass # Python < 2.2 doesn't have 'property'. 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__ == 'SwigPyObject': 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,)
try:
_object = object
_newclass = 1
except AttributeError:
class _object : pass
_newclass = 0

def debug(*args):
return _allog.debug(*args)
debug = _allog.debug
def info(*args):
return _allog.info(*args)
info = _allog.info
def warning(*args):
return _allog.warning(*args)
warning = _allog.warning
def error(*args):
return _allog.error(*args)
error = _allog.error
def fatal(*args):
return _allog.fatal(*args)
fatal = _allog.fatal

pynaoqi-python-2.7-naoqi-1.14-linux64/almath.py
# This file was automatically generated by SWIG (http://www.swig.org).
# Version 1.3.40
#
# Do not make changes to this file unless you know what you are doing–modify
# the SWIG interface file instead.
# This file is compatible with both classic and new-style classes.
from sys import version_info
if version_info >= (2,6,0):
def swig_import_helper():
from os.path import dirname
import imp
fp = None
try:
fp, pathname, description = imp.find_module(‘_almath’, [dirname(__file__)])
except ImportError:
import _almath
return _almath
if fp is not None:
try:
_mod = imp.load_module(‘_almath’, fp, pathname, description)
finally:
fp.close()
return _mod
_almath = swig_import_helper()
del swig_import_helper
else:
import _almath
del version_info
try:
_swig_property = property
except NameError:
pass # Python < 2.2 doesn't have 'property'. 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__ == 'SwigPyObject': 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,)
try:
_object = object
_newclass = 1
except AttributeError:
class _object : pass
_newclass = 0

class SwigPyIterator(_object):
“””Proxy of C++ swig::SwigPyIterator class”””
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, SwigPyIterator, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, SwigPyIterator, name)
def __init__(self, *args, **kwargs): raise AttributeError(“No constructor defined – class is abstract”)
__repr__ = _swig_repr
__swig_destroy__ = _almath.delete_SwigPyIterator
__del__ = lambda self : None;
def value(self):
“””value(self) -> PyObject”””
return _almath.SwigPyIterator_value(self)
def incr(self, n = 1):
“””
incr(self, size_t n = 1) -> SwigPyIterator
incr(self) -> SwigPyIterator
“””
return _almath.SwigPyIterator_incr(self, n)
def decr(self, n = 1):
“””
decr(self, size_t n = 1) -> SwigPyIterator
decr(self) -> SwigPyIterator
“””
return _almath.SwigPyIterator_decr(self, n)
def distance(self, *args):
“””distance(self, SwigPyIterator x) -> ptrdiff_t”””
return _almath.SwigPyIterator_distance(self, *args)
def equal(self, *args):
“””equal(self, SwigPyIterator x) -> bool”””
return _almath.SwigPyIterator_equal(self, *args)
def copy(self):
“””copy(self) -> SwigPyIterator”””
return _almath.SwigPyIterator_copy(self)
def next(self):
“””next(self) -> PyObject”””
return _almath.SwigPyIterator_next(self)
def __next__(self):
“””__next__(self) -> PyObject”””
return _almath.SwigPyIterator___next__(self)
def previous(self):
“””previous(self) -> PyObject”””
return _almath.SwigPyIterator_previous(self)
def advance(self, *args):
“””advance(self, ptrdiff_t n) -> SwigPyIterator”””
return _almath.SwigPyIterator_advance(self, *args)
def __eq__(self, *args):
“””__eq__(self, SwigPyIterator x) -> bool”””
return _almath.SwigPyIterator___eq__(self, *args)
def __ne__(self, *args):
“””__ne__(self, SwigPyIterator x) -> bool”””
return _almath.SwigPyIterator___ne__(self, *args)
def __iadd__(self, *args):
“””__iadd__(self, ptrdiff_t n) -> SwigPyIterator”””
return _almath.SwigPyIterator___iadd__(self, *args)
def __isub__(self, *args):
“””__isub__(self, ptrdiff_t n) -> SwigPyIterator”””
return _almath.SwigPyIterator___isub__(self, *args)
def __add__(self, *args):
“””__add__(self, ptrdiff_t n) -> SwigPyIterator”””
return _almath.SwigPyIterator___add__(self, *args)
def __sub__(self, *args):
“””
__sub__(self, ptrdiff_t n) -> SwigPyIterator
__sub__(self, SwigPyIterator x) -> ptrdiff_t
“””
return _almath.SwigPyIterator___sub__(self, *args)
def __iter__(self): return self
SwigPyIterator_swigregister = _almath.SwigPyIterator_swigregister
SwigPyIterator_swigregister(SwigPyIterator)
class vectorFloat(_object):
“””Proxy of C++ std::vector<(float)> class”””
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, vectorFloat, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, vectorFloat, name)
def iterator(self):
“””iterator(self) -> SwigPyIterator”””
return _almath.vectorFloat_iterator(self)
def __iter__(self): return self.iterator()
def __nonzero__(self):
“””__nonzero__(self) -> bool”””
return _almath.vectorFloat___nonzero__(self)
def __bool__(self):
“””__bool__(self) -> bool”””
return _almath.vectorFloat___bool__(self)
def __len__(self):
“””__len__(self) -> size_type”””
return _almath.vectorFloat___len__(self)
def pop(self):
“””pop(self) -> value_type”””
return _almath.vectorFloat_pop(self)
def __getslice__(self, *args):
“””__getslice__(self, difference_type i, difference_type j) -> vectorFloat”””
return _almath.vectorFloat___getslice__(self, *args)
def __setslice__(self, *args):
“””__setslice__(self, difference_type i, difference_type j, vectorFloat v)”””
return _almath.vectorFloat___setslice__(self, *args)
def __delslice__(self, *args):
“””__delslice__(self, difference_type i, difference_type j)”””
return _almath.vectorFloat___delslice__(self, *args)
def __delitem__(self, *args):
“””
__delitem__(self, difference_type i)
__delitem__(self, PySliceObject slice)
“””
return _almath.vectorFloat___delitem__(self, *args)
def __getitem__(self, *args):
“””
__getitem__(self, PySliceObject slice) -> vectorFloat
__getitem__(self, difference_type i) -> value_type
“””
return _almath.vectorFloat___getitem__(self, *args)
def __setitem__(self, *args):
“””
__setitem__(self, PySliceObject slice, vectorFloat v)
__setitem__(self, difference_type i, value_type x)
“””
return _almath.vectorFloat___setitem__(self, *args)
def append(self, *args):
“””append(self, value_type x)”””
return _almath.vectorFloat_append(self, *args)
def empty(self):
“””empty(self) -> bool”””
return _almath.vectorFloat_empty(self)
def size(self):
“””size(self) -> size_type”””
return _almath.vectorFloat_size(self)
def clear(self):
“””clear(self)”””
return _almath.vectorFloat_clear(self)
def swap(self, *args):
“””swap(self, vectorFloat v)”””
return _almath.vectorFloat_swap(self, *args)
def get_allocator(self):
“””get_allocator(self) -> allocator_type”””
return _almath.vectorFloat_get_allocator(self)
def begin(self):
“””begin(self) -> const_iterator”””
return _almath.vectorFloat_begin(self)
def end(self):
“””end(self) -> const_iterator”””
return _almath.vectorFloat_end(self)
def rbegin(self):
“””rbegin(self) -> const_reverse_iterator”””
return _almath.vectorFloat_rbegin(self)
def rend(self):
“””rend(self) -> const_reverse_iterator”””
return _almath.vectorFloat_rend(self)
def pop_back(self):
“””pop_back(self)”””
return _almath.vectorFloat_pop_back(self)
def erase(self, *args):
“””
erase(self, iterator pos) -> iterator
erase(self, iterator first, iterator last) -> iterator
“””
return _almath.vectorFloat_erase(self, *args)
def __init__(self, *args):
“””
__init__(self) -> vectorFloat
__init__(self, vectorFloat arg0) -> vectorFloat
__init__(self, size_type size) -> vectorFloat
__init__(self, size_type size, value_type value) -> vectorFloat
“””
this = _almath.new_vectorFloat(*args)
try: self.this.append(this)
except: self.this = this
def push_back(self, *args):
“””push_back(self, value_type x)”””
return _almath.vectorFloat_push_back(self, *args)
def front(self):
“””front(self) -> value_type”””
return _almath.vectorFloat_front(self)
def back(self):
“””back(self) -> value_type”””
return _almath.vectorFloat_back(self)
def assign(self, *args):
“””assign(self, size_type n, value_type x)”””
return _almath.vectorFloat_assign(self, *args)
def resize(self, *args):
“””
resize(self, size_type new_size)
resize(self, size_type new_size, value_type x)
“””
return _almath.vectorFloat_resize(self, *args)
def insert(self, *args):
“””
insert(self, iterator pos, value_type x) -> iterator
insert(self, iterator pos, size_type n, value_type x)
“””
return _almath.vectorFloat_insert(self, *args)
def reserve(self, *args):
“””reserve(self, size_type n)”””
return _almath.vectorFloat_reserve(self, *args)
def capacity(self):
“””capacity(self) -> size_type”””
return _almath.vectorFloat_capacity(self)
def __repr__(self):
“””__repr__(self) -> string”””
return _almath.vectorFloat___repr__(self)
__swig_destroy__ = _almath.delete_vectorFloat
__del__ = lambda self : None;
vectorFloat_swigregister = _almath.vectorFloat_swigregister
vectorFloat_swigregister(vectorFloat)
class vectorPosition2D(_object):
“””Proxy of C++ std::vector<(AL::Math::Position2D)> class”””
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, vectorPosition2D, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, vectorPosition2D, name)
def iterator(self):
“””iterator(self) -> SwigPyIterator”””
return _almath.vectorPosition2D_iterator(self)
def __iter__(self): return self.iterator()
def __nonzero__(self):
“””__nonzero__(self) -> bool”””
return _almath.vectorPosition2D___nonzero__(self)
def __bool__(self):
“””__bool__(self) -> bool”””
return _almath.vectorPosition2D___bool__(self)
def __len__(self):
“””__len__(self) -> size_type”””
return _almath.vectorPosition2D___len__(self)
def pop(self):
“””pop(self) -> value_type”””
return _almath.vectorPosition2D_pop(self)
def __getslice__(self, *args):
“””__getslice__(self, difference_type i, difference_type j) -> vectorPosition2D”””
return _almath.vectorPosition2D___getslice__(self, *args)
def __setslice__(self, *args):
“””__setslice__(self, difference_type i, difference_type j, vectorPosition2D v)”””
return _almath.vectorPosition2D___setslice__(self, *args)
def __delslice__(self, *args):
“””__delslice__(self, difference_type i, difference_type j)”””
return _almath.vectorPosition2D___delslice__(self, *args)
def __delitem__(self, *args):
“””
__delitem__(self, difference_type i)
__delitem__(self, PySliceObject slice)
“””
return _almath.vectorPosition2D___delitem__(self, *args)
def __getitem__(self, *args):
“””
__getitem__(self, PySliceObject slice) -> vectorPosition2D
__getitem__(self, difference_type i) -> value_type
“””
return _almath.vectorPosition2D___getitem__(self, *args)
def __setitem__(self, *args):
“””
__setitem__(self, PySliceObject slice, vectorPosition2D v)
__setitem__(self, difference_type i, value_type x)
“””
return _almath.vectorPosition2D___setitem__(self, *args)
def append(self, *args):
“””append(self, value_type x)”””
return _almath.vectorPosition2D_append(self, *args)
def empty(self):
“””empty(self) -> bool”””
return _almath.vectorPosition2D_empty(self)
def size(self):
“””size(self) -> size_type”””
return _almath.vectorPosition2D_size(self)
def clear(self):
“””clear(self)”””
return _almath.vectorPosition2D_clear(self)
def swap(self, *args):
“””swap(self, vectorPosition2D v)”””
return _almath.vectorPosition2D_swap(self, *args)
def get_allocator(self):
“””get_allocator(self) -> allocator_type”””
return _almath.vectorPosition2D_get_allocator(self)
def begin(self):
“””begin(self) -> const_iterator”””
return _almath.vectorPosition2D_begin(self)
def end(self):
“””end(self) -> const_iterator”””
return _almath.vectorPosition2D_end(self)
def rbegin(self):
“””rbegin(self) -> const_reverse_iterator”””
return _almath.vectorPosition2D_rbegin(self)
def rend(self):
“””rend(self) -> const_reverse_iterator”””
return _almath.vectorPosition2D_rend(self)
def pop_back(self):
“””pop_back(self)”””
return _almath.vectorPosition2D_pop_back(self)
def erase(self, *args):
“””
erase(self, iterator pos) -> iterator
erase(self, iterator first, iterator last) -> iterator
“””
return _almath.vectorPosition2D_erase(self, *args)
def __init__(self, *args):
“””
__init__(self) -> vectorPosition2D
__init__(self, vectorPosition2D arg0) -> vectorPosition2D
__init__(self, size_type size) -> vectorPosition2D
__init__(self, size_type size, value_type value) -> vectorPosition2D
“””
this = _almath.new_vectorPosition2D(*args)
try: self.this.append(this)
except: self.this = this
def push_back(self, *args):
“””push_back(self, value_type x)”””
return _almath.vectorPosition2D_push_back(self, *args)
def front(self):
“””front(self) -> value_type”””
return _almath.vectorPosition2D_front(self)
def back(self):
“””back(self) -> value_type”””
return _almath.vectorPosition2D_back(self)
def assign(self, *args):
“””assign(self, size_type n, value_type x)”””
return _almath.vectorPosition2D_assign(self, *args)
def resize(self, *args):
“””
resize(self, size_type new_size)
resize(self, size_type new_size, value_type x)
“””
return _almath.vectorPosition2D_resize(self, *args)
def insert(self, *args):
“””
insert(self, iterator pos, value_type x) -> iterator
insert(self, iterator pos, size_type n, value_type x)
“””
return _almath.vectorPosition2D_insert(self, *args)
def reserve(self, *args):
“””reserve(self, size_type n)”””
return _almath.vectorPosition2D_reserve(self, *args)
def capacity(self):
“””capacity(self) -> size_type”””
return _almath.vectorPosition2D_capacity(self)
def __repr__(self):
“””__repr__(self) -> string”””
return _almath.vectorPosition2D___repr__(self)
__swig_destroy__ = _almath.delete_vectorPosition2D
__del__ = lambda self : None;
vectorPosition2D_swigregister = _almath.vectorPosition2D_swigregister
vectorPosition2D_swigregister(vectorPosition2D)
class vectorPose2D(_object):
“””Proxy of C++ std::vector<(AL::Math::Pose2D)> class”””
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, vectorPose2D, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, vectorPose2D, name)
def iterator(self):
“””iterator(self) -> SwigPyIterator”””
return _almath.vectorPose2D_iterator(self)
def __iter__(self): return self.iterator()
def __nonzero__(self):
“””__nonzero__(self) -> bool”””
return _almath.vectorPose2D___nonzero__(self)
def __bool__(self):
“””__bool__(self) -> bool”””
return _almath.vectorPose2D___bool__(self)
def __len__(self):
“””__len__(self) -> size_type”””
return _almath.vectorPose2D___len__(self)
def pop(self):
“””pop(self) -> value_type”””
return _almath.vectorPose2D_pop(self)
def __getslice__(self, *args):
“””__getslice__(self, difference_type i, difference_type j) -> vectorPose2D”””
return _almath.vectorPose2D___getslice__(self, *args)
def __setslice__(self, *args):
“””__setslice__(self, difference_type i, difference_type j, vectorPose2D v)”””
return _almath.vectorPose2D___setslice__(self, *args)
def __delslice__(self, *args):
“””__delslice__(self, difference_type i, difference_type j)”””
return _almath.vectorPose2D___delslice__(self, *args)
def __delitem__(self, *args):
“””
__delitem__(self, difference_type i)
__delitem__(self, PySliceObject slice)
“””
return _almath.vectorPose2D___delitem__(self, *args)
def __getitem__(self, *args):
“””
__getitem__(self, PySliceObject slice) -> vectorPose2D
__getitem__(self, difference_type i) -> value_type
“””
return _almath.vectorPose2D___getitem__(self, *args)
def __setitem__(self, *args):
“””
__setitem__(self, PySliceObject slice, vectorPose2D v)
__setitem__(self, difference_type i, value_type x)
“””
return _almath.vectorPose2D___setitem__(self, *args)
def append(self, *args):
“””append(self, value_type x)”””
return _almath.vectorPose2D_append(self, *args)
def empty(self):
“””empty(self) -> bool”””
return _almath.vectorPose2D_empty(self)
def size(self):
“””size(self) -> size_type”””
return _almath.vectorPose2D_size(self)
def clear(self):
“””clear(self)”””
return _almath.vectorPose2D_clear(self)
def swap(self, *args):
“””swap(self, vectorPose2D v)”””
return _almath.vectorPose2D_swap(self, *args)
def get_allocator(self):
“””get_allocator(self) -> allocator_type”””
return _almath.vectorPose2D_get_allocator(self)
def begin(self):
“””begin(self) -> const_iterator”””
return _almath.vectorPose2D_begin(self)
def end(self):
“””end(self) -> const_iterator”””
return _almath.vectorPose2D_end(self)
def rbegin(self):
“””rbegin(self) -> const_reverse_iterator”””
return _almath.vectorPose2D_rbegin(self)
def rend(self):
“””rend(self) -> const_reverse_iterator”””
return _almath.vectorPose2D_rend(self)
def pop_back(self):
“””pop_back(self)”””
return _almath.vectorPose2D_pop_back(self)
def erase(self, *args):
“””
erase(self, iterator pos) -> iterator
erase(self, iterator first, iterator last) -> iterator
“””
return _almath.vectorPose2D_erase(self, *args)
def __init__(self, *args):
“””
__init__(self) -> vectorPose2D
__init__(self, vectorPose2D arg0) -> vectorPose2D
__init__(self, size_type size) -> vectorPose2D
__init__(self, size_type size, value_type value) -> vectorPose2D
“””
this = _almath.new_vectorPose2D(*args)
try: self.this.append(this)
except: self.this = this
def push_back(self, *args):
“””push_back(self, value_type x)”””
return _almath.vectorPose2D_push_back(self, *args)
def front(self):
“””front(self) -> value_type”””
return _almath.vectorPose2D_front(self)
def back(self):
“””back(self) -> value_type”””
return _almath.vectorPose2D_back(self)
def assign(self, *args):
“””assign(self, size_type n, value_type x)”””
return _almath.vectorPose2D_assign(self, *args)
def resize(self, *args):
“””
resize(self, size_type new_size)
resize(self, size_type new_size, value_type x)
“””
return _almath.vectorPose2D_resize(self, *args)
def insert(self, *args):
“””
insert(self, iterator pos, value_type x) -> iterator
insert(self, iterator pos, size_type n, value_type x)
“””
return _almath.vectorPose2D_insert(self, *args)
def reserve(self, *args):
“””reserve(self, size_type n)”””
return _almath.vectorPose2D_reserve(self, *args)
def capacity(self):
“””capacity(self) -> size_type”””
return _almath.vectorPose2D_capacity(self)
def __repr__(self):
“””__repr__(self) -> string”””
return _almath.vectorPose2D___repr__(self)
__swig_destroy__ = _almath.delete_vectorPose2D
__del__ = lambda self : None;
vectorPose2D_swigregister = _almath.vectorPose2D_swigregister
vectorPose2D_swigregister(vectorPose2D)
class vectorPosition6D(_object):
“””Proxy of C++ std::vector<(AL::Math::Position6D)> class”””
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, vectorPosition6D, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, vectorPosition6D, name)
def iterator(self):
“””iterator(self) -> SwigPyIterator”””
return _almath.vectorPosition6D_iterator(self)
def __iter__(self): return self.iterator()
def __nonzero__(self):
“””__nonzero__(self) -> bool”””
return _almath.vectorPosition6D___nonzero__(self)
def __bool__(self):
“””__bool__(self) -> bool”””
return _almath.vectorPosition6D___bool__(self)
def __len__(self):
“””__len__(self) -> size_type”””
return _almath.vectorPosition6D___len__(self)
def pop(self):
“””pop(self) -> value_type”””
return _almath.vectorPosition6D_pop(self)
def __getslice__(self, *args):
“””__getslice__(self, difference_type i, difference_type j) -> vectorPosition6D”””
return _almath.vectorPosition6D___getslice__(self, *args)
def __setslice__(self, *args):
“””__setslice__(self, difference_type i, difference_type j, vectorPosition6D v)”””
return _almath.vectorPosition6D___setslice__(self, *args)
def __delslice__(self, *args):
“””__delslice__(self, difference_type i, difference_type j)”””
return _almath.vectorPosition6D___delslice__(self, *args)
def __delitem__(self, *args):
“””
__delitem__(self, difference_type i)
__delitem__(self, PySliceObject slice)
“””
return _almath.vectorPosition6D___delitem__(self, *args)
def __getitem__(self, *args):
“””
__getitem__(self, PySliceObject slice) -> vectorPosition6D
__getitem__(self, difference_type i) -> value_type
“””
return _almath.vectorPosition6D___getitem__(self, *args)
def __setitem__(self, *args):
“””
__setitem__(self, PySliceObject slice, vectorPosition6D v)
__setitem__(self, difference_type i, value_type x)
“””
return _almath.vectorPosition6D___setitem__(self, *args)
def append(self, *args):
“””append(self, value_type x)”””
return _almath.vectorPosition6D_append(self, *args)
def empty(self):
“””empty(self) -> bool”””
return _almath.vectorPosition6D_empty(self)
def size(self):
“””size(self) -> size_type”””
return _almath.vectorPosition6D_size(self)
def clear(self):
“””clear(self)”””
return _almath.vectorPosition6D_clear(self)
def swap(self, *args):
“””swap(self, vectorPosition6D v)”””
return _almath.vectorPosition6D_swap(self, *args)
def get_allocator(self):
“””get_allocator(self) -> allocator_type”””
return _almath.vectorPosition6D_get_allocator(self)
def begin(self):
“””begin(self) -> const_iterator”””
return _almath.vectorPosition6D_begin(self)
def end(self):
“””end(self) -> const_iterator”””
return _almath.vectorPosition6D_end(self)
def rbegin(self):
“””rbegin(self) -> const_reverse_iterator”””
return _almath.vectorPosition6D_rbegin(self)
def rend(self):
“””rend(self) -> const_reverse_iterator”””
return _almath.vectorPosition6D_rend(self)
def pop_back(self):
“””pop_back(self)”””
return _almath.vectorPosition6D_pop_back(self)
def erase(self, *args):
“””
erase(self, iterator pos) -> iterator
erase(self, iterator first, iterator last) -> iterator
“””
return _almath.vectorPosition6D_erase(self, *args)
def __init__(self, *args):
“””
__init__(self) -> vectorPosition6D
__init__(self, vectorPosition6D arg0) -> vectorPosition6D
__init__(self, size_type size) -> vectorPosition6D
__init__(self, size_type size, value_type value) -> vectorPosition6D
“””
this = _almath.new_vectorPosition6D(*args)
try: self.this.append(this)
except: self.this = this
def push_back(self, *args):
“””push_back(self, value_type x)”””
return _almath.vectorPosition6D_push_back(self, *args)
def front(self):
“””front(self) -> value_type”””
return _almath.vectorPosition6D_front(self)
def back(self):
“””back(self) -> value_type”””
return _almath.vectorPosition6D_back(self)
def assign(self, *args):
“””assign(self, size_type n, value_type x)”””
return _almath.vectorPosition6D_assign(self, *args)
def resize(self, *args):
“””
resize(self, size_type new_size)
resize(self, size_type new_size, value_type x)
“””
return _almath.vectorPosition6D_resize(self, *args)
def insert(self, *args):
“””
insert(self, iterator pos, value_type x) -> iterator
insert(self, iterator pos, size_type n, value_type x)
“””
return _almath.vectorPosition6D_insert(self, *args)
def reserve(self, *args):
“””reserve(self, size_type n)”””
return _almath.vectorPosition6D_reserve(self, *args)
def capacity(self):
“””capacity(self) -> size_type”””
return _almath.vectorPosition6D_capacity(self)
def __repr__(self):
“””__repr__(self) -> string”””
return _almath.vectorPosition6D___repr__(self)
__swig_destroy__ = _almath.delete_vectorPosition6D
__del__ = lambda self : None;
vectorPosition6D_swigregister = _almath.vectorPosition6D_swigregister
vectorPosition6D_swigregister(vectorPosition6D)
class Pose2D(_object):
“””Proxy of C++ AL::Math::Pose2D class”””
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, Pose2D, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, Pose2D, name)
__swig_setmethods__[“x”] = _almath.Pose2D_x_set
__swig_getmethods__[“x”] = _almath.Pose2D_x_get
if _newclass:x = _swig_property(_almath.Pose2D_x_get, _almath.Pose2D_x_set)
__swig_setmethods__[“y”] = _almath.Pose2D_y_set
__swig_getmethods__[“y”] = _almath.Pose2D_y_get
if _newclass:y = _swig_property(_almath.Pose2D_y_get, _almath.Pose2D_y_set)
__swig_setmethods__[“theta”] = _almath.Pose2D_theta_set
__swig_getmethods__[“theta”] = _almath.Pose2D_theta_get
if _newclass:theta = _swig_property(_almath.Pose2D_theta_get, _almath.Pose2D_theta_set)
def __init__(self, *args):
“””
__init__(self) -> Pose2D
__init__(self, float pInit) -> Pose2D
__init__(self, float pX, float pY, float pTheta) -> Pose2D
__init__(self, vectorFloat pFloats) -> Pose2D
“””
this = _almath.new_Pose2D(*args)
try: self.this.append(this)
except: self.this = this
def __add__(self, *args):
“””__add__(self, Pose2D pPos2) -> Pose2D”””
return _almath.Pose2D___add__(self, *args)
def __sub__(self, *args):
“””__sub__(self, Pose2D pPos2) -> Pose2D”””
return _almath.Pose2D___sub__(self, *args)
def __pos__(self):
“””__pos__(self) -> Pose2D”””
return _almath.Pose2D___pos__(self)
def __neg__(self):
“””__neg__(self) -> Pose2D”””
return _almath.Pose2D___neg__(self)
def __iadd__(self, *args):
“””__iadd__(self, Pose2D pPos2) -> Pose2D”””
return _almath.Pose2D___iadd__(self, *args)
def __isub__(self, *args):
“””__isub__(self, Pose2D pPos2) -> Pose2D”””
return _almath.Pose2D___isub__(self, *args)
def __eq__(self, *args):
“””__eq__(self, Pose2D pPos2) -> bool”””
return _almath.Pose2D___eq__(self, *args)
def __ne__(self, *args):
“””__ne__(self, Pose2D pPos2) -> bool”””
return _almath.Pose2D___ne__(self, *args)
def __mul__(self, *args):
“””
__mul__(self, Pose2D pPos2) -> Pose2D
__mul__(self, float pVal) -> Pose2D
“””
return _almath.Pose2D___mul__(self, *args)
def __div__(self, *args):
“””__div__(self, float pVal) -> Pose2D”””
return _almath.Pose2D___div__(self, *args)
def __imul__(self, *args):
“””
__imul__(self, Pose2D pPos2) -> Pose2D
__imul__(self, float pVal) -> Pose2D
“””
return _almath.Pose2D___imul__(self, *args)
def __idiv__(self, *args):
“””__idiv__(self, float pVal) -> Pose2D”””
return _almath.Pose2D___idiv__(self, *args)
def distanceSquared(self, *args):
“””distanceSquared(self, Pose2D pPos2) -> float”””
return _almath.Pose2D_distanceSquared(self, *args)
def distance(self, *args):
“””distance(self, Pose2D pPos2) -> float”””
return _almath.Pose2D_distance(self, *args)
def inverse(self):
“””inverse(self) -> Pose2D”””
return _almath.Pose2D_inverse(self)
def isNear(self, *args):
“””
isNear(self, Pose2D pPos2, float pEpsilon = 0.0001) -> bool
isNear(self, Pose2D pPos2) -> bool
“””
return _almath.Pose2D_isNear(self, *args)
def toVector(self):
“””toVector(self) -> vectorFloat”””
return _almath.Pose2D_toVector(self)
def __repr__(self):
“””__repr__(self) -> char”””
return _almath.Pose2D___repr__(self)
def __rmul__(self, *args):
“””__rmul__(self, float lhs) -> Pose2D”””
return _almath.Pose2D___rmul__(self, *args)
__swig_destroy__ = _almath.delete_Pose2D
__del__ = lambda self : None;
Pose2D_swigregister = _almath.Pose2D_swigregister
Pose2D_swigregister(Pose2D)
cvar = _almath.cvar
AXIS_MASK_X = cvar.AXIS_MASK_X
AXIS_MASK_Y = cvar.AXIS_MASK_Y
AXIS_MASK_XY = cvar.AXIS_MASK_XY
AXIS_MASK_Z = cvar.AXIS_MASK_Z
AXIS_MASK_WX = cvar.AXIS_MASK_WX
AXIS_MASK_WY = cvar.AXIS_MASK_WY
AXIS_MASK_WZ = cvar.AXIS_MASK_WZ
AXIS_MASK_WYWZ = cvar.AXIS_MASK_WYWZ
AXIS_MASK_ALL = cvar.AXIS_MASK_ALL
AXIS_MASK_VEL = cvar.AXIS_MASK_VEL
AXIS_MASK_ROT = cvar.AXIS_MASK_ROT
AXIS_MASK_NONE = cvar.AXIS_MASK_NONE
class Position2D(_object):
“””Proxy of C++ AL::Math::Position2D class”””
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, Position2D, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, Position2D, name)
__swig_setmethods__[“x”] = _almath.Position2D_x_set
__swig_getmethods__[“x”] = _almath.Position2D_x_get
if _newclass:x = _swig_property(_almath.Position2D_x_get, _almath.Position2D_x_set)
__swig_setmethods__[“y”] = _almath.Position2D_y_set
__swig_getmethods__[“y”] = _almath.Position2D_y_get
if _newclass:y = _swig_property(_almath.Position2D_y_get, _almath.Position2D_y_set)
def __init__(self, *args):
“””
__init__(self) -> Position2D
__init__(self, float pInit) -> Position2D
__init__(self, float pX, float pY) -> Position2D
__init__(self, vectorFloat pFloats) -> Position2D
“””
this = _almath.new_Position2D(*args)
try: self.this.append(this)
except: self.this = this
def __add__(self, *args):
“””__add__(self, Position2D pPos2) -> Position2D”””
return _almath.Position2D___add__(self, *args)
def __sub__(self, *args):
“””__sub__(self, Position2D pPos2) -> Position2D”””
return _almath.Position2D___sub__(self, *args)
def __pos__(self):
“””__pos__(self) -> Position2D”””
return _almath.Position2D___pos__(self)
def __neg__(self):
“””__neg__(self) -> Position2D”””
return _almath.Position2D___neg__(self)
def __iadd__(self, *args):
“””__iadd__(self, Position2D pPos2) -> Position2D”””
return _almath.Position2D___iadd__(self, *args)
def __isub__(self, *args):
“””__isub__(self, Position2D pPos2) -> Position2D”””
return _almath.Position2D___isub__(self, *args)
def __eq__(self, *args):
“””__eq__(self, Position2D pPos2) -> bool”””
return _almath.Position2D___eq__(self, *args)
def __ne__(self, *args):
“””__ne__(self, Position2D pPos2) -> bool”””
return _almath.Position2D___ne__(self, *args)
def __mul__(self, *args):
“””__mul__(self, float pVal) -> Position2D”””
return _almath.Position2D___mul__(self, *args)
def __div__(self, *args):
“””__div__(self, float pVal) -> Position2D”””
return _almath.Position2D___div__(self, *args)
def __imul__(self, *args):
“””__imul__(self, float pVal) -> Position2D”””
return _almath.Position2D___imul__(self, *args)
def __idiv__(self, *args):
“””__idiv__(self, float pVal) -> Position2D”””
return _almath.Position2D___idiv__(self, *args)
def distanceSquared(self, *args):
“””distanceSquared(self, Position2D pPos2) -> float”””
return _almath.Position2D_distanceSquared(self, *args)
def distance(self, *args):
“””distance(self, Position2D pPos2) -> float”””
return _almath.Position2D_distance(self, *args)
def isNear(self, *args):
“””
isNear(self, Position2D pPos2, float pEpsilon = 0.0001) -> bool
isNear(self, Position2D pPos2) -> bool
“””
return _almath.Position2D_isNear(self, *args)
def norm(self):
“””norm(self) -> float”””
return _almath.Position2D_norm(self)
def normalize(self):
“””normalize(self) -> Position2D”””
return _almath.Position2D_normalize(self)
def crossProduct(self, *args):
“””crossProduct(self, Position2D pPos2) -> float”””
return _almath.Position2D_crossProduct(self, *args)
def toVector(self):
“””toVector(self) -> vectorFloat”””
return _almath.Position2D_toVector(self)
def __repr__(self):
“””__repr__(self) -> char”””
return _almath.Position2D___repr__(self)
def __rmul__(self, *args):
“””__rmul__(self, float lhs) -> Position2D”””
return _almath.Position2D___rmul__(self, *args)
__swig_destroy__ = _almath.delete_Position2D
__del__ = lambda self : None;
Position2D_swigregister = _almath.Position2D_swigregister
Position2D_swigregister(Position2D)
def pose2DInverse(*args):
“””
pose2DInverse(Pose2D pPos) -> Pose2D
pose2DInverse(Pose2D pPos, Pose2D pRes)
“””
return _almath.pose2DInverse(*args)
class Position3D(_object):
“””Proxy of C++ AL::Math::Position3D class”””
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, Position3D, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, Position3D, name)
__swig_setmethods__[“x”] = _almath.Position3D_x_set
__swig_getmethods__[“x”] = _almath.Position3D_x_get
if _newclass:x = _swig_property(_almath.Position3D_x_get, _almath.Position3D_x_set)
__swig_setmethods__[“y”] = _almath.Position3D_y_set
__swig_getmethods__[“y”] = _almath.Position3D_y_get
if _newclass:y = _swig_property(_almath.Position3D_y_get, _almath.Position3D_y_set)
__swig_setmethods__[“z”] = _almath.Position3D_z_set
__swig_getmethods__[“z”] = _almath.Position3D_z_get
if _newclass:z = _swig_property(_almath.Position3D_z_get, _almath.Position3D_z_set)
def __init__(self, *args):
“””
__init__(self) -> Position3D
__init__(self, float pInit) -> Position3D
__init__(self, float pX, float pY, float pZ) -> Position3D
__init__(self, vectorFloat pFloats) -> Position3D
“””
this = _almath.new_Position3D(*args)
try: self.this.append(this)
except: self.this = this
def __add__(self, *args):
“””__add__(self, Position3D pPos2) -> Position3D”””
return _almath.Position3D___add__(self, *args)
def __sub__(self, *args):
“””__sub__(self, Position3D pPos2) -> Position3D”””
return _almath.Position3D___sub__(self, *args)
def __pos__(self):
“””__pos__(self) -> Position3D”””
return _almath.Position3D___pos__(self)
def __neg__(self):
“””__neg__(self) -> Position3D”””
return _almath.Position3D___neg__(self)
def __iadd__(self, *args):
“””__iadd__(self, Position3D pPos2) -> Position3D”””
return _almath.Position3D___iadd__(self, *args)
def __isub__(self, *args):
“””__isub__(self, Position3D pPos2) -> Position3D”””
return _almath.Position3D___isub__(self, *args)
def __eq__(self, *args):
“””__eq__(self, Position3D pPos2) -> bool”””
return _almath.Position3D___eq__(self, *args)
def __ne__(self, *args):
“””__ne__(self, Position3D pPos2) -> bool”””
return _almath.Position3D___ne__(self, *args)
def __mul__(self, *args):
“””__mul__(self, float pVal) -> Position3D”””
return _almath.Position3D___mul__(self, *args)
def __div__(self, *args):
“””__div__(self, float pVal) -> Position3D”””
return _almath.Position3D___div__(self, *args)
def __imul__(self, *args):
“””__imul__(self, float pVal) -> Position3D”””
return _almath.Position3D___imul__(self, *args)
def __idiv__(self, *args):
“””__idiv__(self, float pVal) -> Position3D”””
return _almath.Position3D___idiv__(self, *args)
def distanceSquared(self, *args):
“””distanceSquared(self, Position3D pPos2) -> float”””
return _almath.Position3D_distanceSquared(self, *args)
def distance(self, *args):
“””distance(self, Position3D pPos2) -> float”””
return _almath.Position3D_distance(self, *args)
def isNear(self, *args):
“””
isNear(self, Position3D pPos2, float pEpsilon = 0.0001) -> bool
isNear(self, Position3D pPos2) -> bool
“””
return _almath.Position3D_isNear(self, *args)
def norm(self):
“””norm(self) -> float”””
return _almath.Position3D_norm(self)
def normalize(self):
“””normalize(self) -> Position3D”””
return _almath.Position3D_normalize(self)
def dotProduct(self, *args):
“””dotProduct(self, Position3D pPos2) -> float”””
return _almath.Position3D_dotProduct(self, *args)
def crossProduct(self, *args):
“””crossProduct(self, Position3D pPos2) -> Position3D”””
return _almath.Position3D_crossProduct(self, *args)
def toVector(self):
“””toVector(self) -> vectorFloat”””
return _almath.Position3D_toVector(self)
def __repr__(self):
“””__repr__(self) -> char”””
return _almath.Position3D___repr__(self)
def __rmul__(self, *args):
“””__rmul__(self, float lhs) -> Position3D”””
return _almath.Position3D___rmul__(self, *args)
__swig_destroy__ = _almath.delete_Position3D
__del__ = lambda self : None;
Position3D_swigregister = _almath.Position3D_swigregister
Position3D_swigregister(Position3D)

def __div__(*args):
“””__div__(float pM, Position3D pPos1) -> Position3D”””
return _almath.__div__(*args)
def dotProduct(*args):
“””dotProduct(Position3D pPos1, Position3D pPos2) -> float”””
return _almath.dotProduct(*args)
class Position6D(_object):
“””Proxy of C++ AL::Math::Position6D class”””
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, Position6D, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, Position6D, name)
__swig_setmethods__[“x”] = _almath.Position6D_x_set
__swig_getmethods__[“x”] = _almath.Position6D_x_get
if _newclass:x = _swig_property(_almath.Position6D_x_get, _almath.Position6D_x_set)
__swig_setmethods__[“y”] = _almath.Position6D_y_set
__swig_getmethods__[“y”] = _almath.Position6D_y_get
if _newclass:y = _swig_property(_almath.Position6D_y_get, _almath.Position6D_y_set)
__swig_setmethods__[“z”] = _almath.Position6D_z_set
__swig_getmethods__[“z”] = _almath.Position6D_z_get
if _newclass:z = _swig_property(_almath.Position6D_z_get, _almath.Position6D_z_set)
__swig_setmethods__[“wx”] = _almath.Position6D_wx_set
__swig_getmethods__[“wx”] = _almath.Position6D_wx_get
if _newclass:wx = _swig_property(_almath.Position6D_wx_get, _almath.Position6D_wx_set)
__swig_setmethods__[“wy”] = _almath.Position6D_wy_set
__swig_getmethods__[“wy”] = _almath.Position6D_wy_get
if _newclass:wy = _swig_property(_almath.Position6D_wy_get, _almath.Position6D_wy_set)
__swig_setmethods__[“wz”] = _almath.Position6D_wz_set
__swig_getmethods__[“wz”] = _almath.Position6D_wz_get
if _newclass:wz = _swig_property(_almath.Position6D_wz_get, _almath.Position6D_wz_set)
def __init__(self, *args):
“””
__init__(self) -> Position6D
__init__(self, float pInit) -> Position6D
__init__(self, float pX, float pY, float pZ, float pWx, float pWy,
float pWz) -> Position6D
__init__(self, vectorFloat pFloats) -> Position6D
“””
this = _almath.new_Position6D(*args)
try: self.this.append(this)
except: self.this = this
def __add__(self, *args):
“””__add__(self, Position6D pPos2) -> Position6D”””
return _almath.Position6D___add__(self, *args)
def __sub__(self, *args):
“””__sub__(self, Position6D pPos2) -> Position6D”””
return _almath.Position6D___sub__(self, *args)
def __pos__(self):
“””__pos__(self) -> Position6D”””
return _almath.Position6D___pos__(self)
def __neg__(self):
“””__neg__(self) -> Position6D”””
return _almath.Position6D___neg__(self)
def __iadd__(self, *args):
“””__iadd__(self, Position6D pPos2) -> Position6D”””
return _almath.Position6D___iadd__(self, *args)
def __isub__(self, *args):
“””__isub__(self, Position6D pPos2) -> Position6D”””
return _almath.Position6D___isub__(self, *args)
def __eq__(self, *args):
“””__eq__(self, Position6D pPos2) -> bool”””
return _almath.Position6D___eq__(self, *args)
def __ne__(self, *args):
“””__ne__(self, Position6D pPos2) -> bool”””
return _almath.Position6D___ne__(self, *args)
def __mul__(self, *args):
“””__mul__(self, float pVal) -> Position6D”””
return _almath.Position6D___mul__(self, *args)
def __div__(self, *args):
“””__div__(self, float pVal) -> Position6D”””
return _almath.Position6D___div__(self, *args)
def __imul__(self, *args):
“””__imul__(self, float pVal) -> Position6D”””
return _almath.Position6D___imul__(self, *args)
def __idiv__(self, *args):
“””__idiv__(self, float pVal) -> Position6D”””
return _almath.Position6D___idiv__(self, *args)
def isNear(self, *args):
“””
isNear(self, Position6D pPos2, float pEpsilon = 0.0001) -> bool
isNear(self, Position6D pPos2) -> bool
“””
return _almath.Position6D_isNear(self, *args)
def distanceSquared(self, *args):
“””distanceSquared(self, Position6D pPos2) -> float”””
return _almath.Position6D_distanceSquared(self, *args)
def distance(self, *args):
“””distance(self, Position6D pPos2) -> float”””
return _almath.Position6D_distance(self, *args)
def norm(self):
“””norm(self) -> float”””
return _almath.Position6D_norm(self)
def toVector(self):
“””toVector(self) -> vectorFloat”””
return _almath.Position6D_toVector(self)
def __repr__(self):
“””__repr__(self) -> char”””
return _almath.Position6D___repr__(self)
def __rmul__(self, *args):
“””__rmul__(self, float lhs) -> Position6D”””
return _almath.Position6D___rmul__(self, *args)
__swig_destroy__ = _almath.delete_Position6D
__del__ = lambda self : None;
Position6D_swigregister = _almath.Position6D_swigregister
Position6D_swigregister(Position6D)
def crossProduct(*args):
“””
crossProduct(Position2D pPos1, Position2D pPos2) -> float
crossProduct(Position2D pPos1, Position2D pPos2, float pRes)
crossProduct(Position3D pPos1, Position3D pPos2) -> Position3D
crossProduct(Position3D pPos1, Position3D pPos2, Position3D pRes)
“””
return _almath.crossProduct(*args)
class PositionAndVelocity(_object):
“””Proxy of C++ AL::Math::PositionAndVelocity class”””
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, PositionAndVelocity, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, PositionAndVelocity, name)
__swig_setmethods__[“q”] = _almath.PositionAndVelocity_q_set
__swig_getmethods__[“q”] = _almath.PositionAndVelocity_q_get
if _newclass:q = _swig_property(_almath.PositionAndVelocity_q_get, _almath.PositionAndVelocity_q_set)
__swig_setmethods__[“dq”] = _almath.PositionAndVelocity_dq_set
__swig_getmethods__[“dq”] = _almath.PositionAndVelocity_dq_get
if _newclass:dq = _swig_property(_almath.PositionAndVelocity_dq_get, _almath.PositionAndVelocity_dq_set)
def __init__(self, pq = 0.0, pdq = 0.0):
“””
__init__(self, float pq = 0.0, float pdq = 0.0) -> PositionAndVelocity
__init__(self, float pq = 0.0) -> PositionAndVelocity
__init__(self) -> PositionAndVelocity
“””
this = _almath.new_PositionAndVelocity(pq, pdq)
try: self.this.append(this)
except: self.this = this
def isNear(self, *args):
“””
isNear(self, PositionAndVelocity pDat2, float pEpsilon = 0.0001) -> bool
isNear(self, PositionAndVelocity pDat2) -> bool
“””
return _almath.PositionAndVelocity_isNear(self, *args)
def __repr__(self):
“””__repr__(self) -> char”””
return _almath.PositionAndVelocity___repr__(self)
__swig_destroy__ = _almath.delete_PositionAndVelocity
__del__ = lambda self : None;
PositionAndVelocity_swigregister = _almath.PositionAndVelocity_swigregister
PositionAndVelocity_swigregister(PositionAndVelocity)
def distanceSquared(*args):
“””
distanceSquared(Pose2D pPos1, Pose2D pPos2) -> float
distanceSquared(Position2D pPos1, Position2D pPos2) -> float
distanceSquared(Position3D pPos1, Position3D pPos2) -> float
distanceSquared(Position6D pPos1, Position6D pPos2) -> float
“””
return _almath.distanceSquared(*args)
def distance(*args):
“””
distance(Pose2D pPos1, Pose2D pPos2) -> float
distance(Position2D pPos1, Position2D pPos2) -> float
distance(Position3D pPos1, Position3D pPos2) -> float
distance(Position6D pPos1, Position6D pPos2) -> float
“””
return _almath.distance(*args)
class Quaternion(_object):
“””Proxy of C++ AL::Math::Quaternion class”””
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, Quaternion, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, Quaternion, name)
__swig_setmethods__[“w”] = _almath.Quaternion_w_set
__swig_getmethods__[“w”] = _almath.Quaternion_w_get
if _newclass:w = _swig_property(_almath.Quaternion_w_get, _almath.Quaternion_w_set)
__swig_setmethods__[“x”] = _almath.Quaternion_x_set
__swig_getmethods__[“x”] = _almath.Quaternion_x_get
if _newclass:x = _swig_property(_almath.Quaternion_x_get, _almath.Quaternion_x_set)
__swig_setmethods__[“y”] = _almath.Quaternion_y_set
__swig_getmethods__[“y”] = _almath.Quaternion_y_get
if _newclass:y = _swig_property(_almath.Quaternion_y_get, _almath.Quaternion_y_set)
__swig_setmethods__[“z”] = _almath.Quaternion_z_set
__swig_getmethods__[“z”] = _almath.Quaternion_z_get
if _newclass:z = _swig_property(_almath.Quaternion_z_get, _almath.Quaternion_z_set)
def __init__(self, *args):
“””
__init__(self) -> Quaternion
__init__(self, float pW, float pX, float pY, float pZ) -> Quaternion
__init__(self, vectorFloat pFloats) -> Quaternion
“””
this = _almath.new_Quaternion(*args)
try: self.this.append(this)
except: self.this = this
def __mul__(self, *args):
“””__mul__(self, Quaternion pQua2) -> Quaternion”””
return _almath.Quaternion___mul__(self, *args)
def __eq__(self, *args):
“””__eq__(self, Quaternion pQua2) -> bool”””
return _almath.Quaternion___eq__(self, *args)
def __ne__(self, *args):
“””__ne__(self, Quaternion pQua2) -> bool”””
return _almath.Quaternion___ne__(self, *args)
def __imul__(self, *args):
“””
__imul__(self, Quaternion pQu2) -> Quaternion
__imul__(self, float pVal) -> Quaternion
“””
return _almath.Quaternion___imul__(self, *args)
def __idiv__(self, *args):
“””__idiv__(self, float pVal) -> Quaternion”””
return _almath.Quaternion___idiv__(self, *args)
def isNear(self, *args):
“””
isNear(self, Quaternion pQua2, float pEpsilon = 0.0001) -> bool
isNear(self, Quaternion pQua2) -> bool
“””
return _almath.Quaternion_isNear(self, *args)
def norm(self):
“””norm(self) -> float”””
return _almath.Quaternion_norm(self)
def normalize(self):
“””normalize(self) -> Quaternion”””
return _almath.Quaternion_normalize(self)
def inverse(self):
“””inverse(self) -> Quaternion”””
return _almath.Quaternion_inverse(self)
def fromAngleAndAxisRotation(*args):
“””fromAngleAndAxisRotation(float pAngle, float pAxisX, float pAxisY, float pAxisZ) -> Quaternion”””
return _almath.Quaternion_fromAngleAndAxisRotation(*args)
if _newclass:fromAngleAndAxisRotation = staticmethod(fromAngleAndAxisRotation)
__swig_getmethods__[“fromAngleAndAxisRotation”] = lambda x: fromAngleAndAxisRotation
def toVector(self):
“””toVector(self) -> vectorFloat”””
return _almath.Quaternion_toVector(self)
def __repr__(self):
“””__repr__(self) -> char”””
return _almath.Quaternion___repr__(self)
__swig_destroy__ = _almath.delete_Quaternion
__del__ = lambda self : None;
Quaternion_swigregister = _almath.Quaternion_swigregister
Quaternion_swigregister(Quaternion)
def Quaternion_fromAngleAndAxisRotation(*args):
“””Quaternion_fromAngleAndAxisRotation(float pAngle, float pAxisX, float pAxisY, float pAxisZ) -> Quaternion”””
return _almath.Quaternion_fromAngleAndAxisRotation(*args)

def quaternionFromAngleAndAxisRotation(*args):
“””quaternionFromAngleAndAxisRotation(float pAngle, float pAxisX, float pAxisY, float pAxisZ) -> Quaternion”””
return _almath.quaternionFromAngleAndAxisRotation(*args)
def angleAndAxisRotationFromQuaternion(*args):
“””
angleAndAxisRotationFromQuaternion(Quaternion pQuaternion, float pAngle, float pAxisX,
float pAxisY, float pAxisZ)
“””
return _almath.angleAndAxisRotationFromQuaternion(*args)
class Rotation(_object):
“””Proxy of C++ AL::Math::Rotation class”””
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, Rotation, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, Rotation, name)
__swig_setmethods__[“r1_c1”] = _almath.Rotation_r1_c1_set
__swig_getmethods__[“r1_c1”] = _almath.Rotation_r1_c1_get
if _newclass:r1_c1 = _swig_property(_almath.Rotation_r1_c1_get, _almath.Rotation_r1_c1_set)
__swig_setmethods__[“r1_c2”] = _almath.Rotation_r1_c2_set
__swig_getmethods__[“r1_c2”] = _almath.Rotation_r1_c2_get
if _newclass:r1_c2 = _swig_property(_almath.Rotation_r1_c2_get, _almath.Rotation_r1_c2_set)
__swig_setmethods__[“r1_c3”] = _almath.Rotation_r1_c3_set
__swig_getmethods__[“r1_c3”] = _almath.Rotation_r1_c3_get
if _newclass:r1_c3 = _swig_property(_almath.Rotation_r1_c3_get, _almath.Rotation_r1_c3_set)
__swig_setmethods__[“r2_c1”] = _almath.Rotation_r2_c1_set
__swig_getmethods__[“r2_c1”] = _almath.Rotation_r2_c1_get
if _newclass:r2_c1 = _swig_property(_almath.Rotation_r2_c1_get, _almath.Rotation_r2_c1_set)
__swig_setmethods__[“r2_c2”] = _almath.Rotation_r2_c2_set
__swig_getmethods__[“r2_c2”] = _almath.Rotation_r2_c2_get
if _newclass:r2_c2 = _swig_property(_almath.Rotation_r2_c2_get, _almath.Rotation_r2_c2_set)
__swig_setmethods__[“r2_c3”] = _almath.Rotation_r2_c3_set
__swig_getmethods__[“r2_c3”] = _almath.Rotation_r2_c3_get
if _newclass:r2_c3 = _swig_property(_almath.Rotation_r2_c3_get, _almath.Rotation_r2_c3_set)
__swig_setmethods__[“r3_c1”] = _almath.Rotation_r3_c1_set
__swig_getmethods__[“r3_c1”] = _almath.Rotation_r3_c1_get
if _newclass:r3_c1 = _swig_property(_almath.Rotation_r3_c1_get, _almath.Rotation_r3_c1_set)
__swig_setmethods__[“r3_c2”] = _almath.Rotation_r3_c2_set
__swig_getmethods__[“r3_c2”] = _almath.Rotation_r3_c2_get
if _newclass:r3_c2 = _swig_property(_almath.Rotation_r3_c2_get, _almath.Rotation_r3_c2_set)
__swig_setmethods__[“r3_c3”] = _almath.Rotation_r3_c3_set
__swig_getmethods__[“r3_c3”] = _almath.Rotation_r3_c3_get
if _newclass:r3_c3 = _swig_property(_almath.Rotation_r3_c3_get, _almath.Rotation_r3_c3_set)
def __init__(self, *args):
“””
__init__(self) -> Rotation
__init__(self, vectorFloat pFloats) -> Rotation
“””
this = _almath.new_Rotation(*args)
try: self.this.append(this)
except: self.this = this
def __imul__(self, *args):
“””__imul__(self, Rotation pRot2) -> Rotation”””
return _almath.Rotation___imul__(self, *args)
def __eq__(self, *args):
“””__eq__(self, Rotation pRot2) -> bool”””
return _almath.Rotation___eq__(self, *args)
def __ne__(self, *args):
“””__ne__(self, Rotation pRot2) -> bool”””
return _almath.Rotation___ne__(self, *args)
def isNear(self, *args):
“””
isNear(self, Rotation pRot2, float pEpsilon = 0.0001) -> bool
isNear(self, Rotation pRot2) -> bool
“””
return _almath.Rotation_isNear(self, *args)
def transpose(self):
“””transpose(self) -> Rotation”””
return _almath.Rotation_transpose(self)
def determinant(self):
“””determinant(self) -> float”””
return _almath.Rotation_determinant(self)
def fromQuaternion(*args):
“””fromQuaternion(float pA, float pB, float pC, float pD) -> Rotation”””
return _almath.Rotation_fromQuaternion(*args)
if _newclass:fromQuaternion = staticmethod(fromQuaternion)
__swig_getmethods__[“fromQuaternion”] = lambda x: fromQuaternion
def fromAngleDirection(*args):
“””fromAngleDirection(float pAngle, float pX, float pY, float pZ) -> Rotation”””
return _almath.Rotation_fromAngleDirection(*args)
if _newclass:fromAngleDirection = staticmethod(fromAngleDirection)
__swig_getmethods__[“fromAngleDirection”] = lambda x: fromAngleDirection
def fromRotX(*args):
“””fromRotX(float pRotX) -> Rotation”””
return _almath.Rotation_fromRotX(*args)
if _newclass:fromRotX = staticmethod(fromRotX)
__swig_getmethods__[“fromRotX”] = lambda x: fromRotX
def fromRotY(*args):
“””fromRotY(float pRotY) -> Rotation”””
return _almath.Rotation_fromRotY(*args)
if _newclass:fromRotY = staticmethod(fromRotY)
__swig_getmethods__[“fromRotY”] = lambda x: fromRotY
def fromRotZ(*args):
“””fromRotZ(float pRotZ) -> Rotation”””
return _almath.Rotation_fromRotZ(*args)
if _newclass:fromRotZ = staticmethod(fromRotZ)
__swig_getmethods__[“fromRotZ”] = lambda x: fromRotZ
def from3DRotation(*args):
“””from3DRotation(float pWX, float pWY, float pWZ) -> Rotation”””
return _almath.Rotation_from3DRotation(*args)
if _newclass:from3DRotation = staticmethod(from3DRotation)
__swig_getmethods__[“from3DRotation”] = lambda x: from3DRotation
def toVector(self):
“””toVector(self) -> vectorFloat”””
return _almath.Rotation_toVector(self)
def __str__(self):
“””__str__(self) -> char”””
return _almath.Rotation___str__(self)
def __repr__(self):
“””__repr__(self) -> char”””
return _almath.Rotation___repr__(self)
def __mul__(self, *args):
“””
__mul__(self, Rotation pRot2) -> Rotation
__mul__(self, Position3D rhs) -> Position3D
“””
return _almath.Rotation___mul__(self, *args)
__swig_destroy__ = _almath.delete_Rotation
__del__ = lambda self : None;
Rotation_swigregister = _almath.Rotation_swigregister
Rotation_swigregister(Rotation)
def quaternionInverse(*args):
“””
quaternionInverse(Quaternion pQua, Quaternion pQuaOut)
quaternionInverse(Quaternion pQua) -> Quaternion
“””
return _almath.quaternionInverse(*args)
def Rotation_fromQuaternion(*args):
“””Rotation_fromQuaternion(float pA, float pB, float pC, float pD) -> Rotation”””
return _almath.Rotation_fromQuaternion(*args)
def Rotation_fromAngleDirection(*args):
“””Rotation_fromAngleDirection(float pAngle, float pX, float pY, float pZ) -> Rotation”””
return _almath.Rotation_fromAngleDirection(*args)
def Rotation_fromRotX(*args):
“””Rotation_fromRotX(float pRotX) -> Rotation”””
return _almath.Rotation_fromRotX(*args)
def Rotation_fromRotY(*args):
“””Rotation_fromRotY(float pRotY) -> Rotation”””
return _almath.Rotation_fromRotY(*args)
def Rotation_fromRotZ(*args):
“””Rotation_fromRotZ(float pRotZ) -> Rotation”””
return _almath.Rotation_fromRotZ(*args)
def Rotation_from3DRotation(*args):
“””Rotation_from3DRotation(float pWX, float pWY, float pWZ) -> Rotation”””
return _almath.Rotation_from3DRotation(*args)

def transpose(*args):
“””transpose(Rotation pRot) -> Rotation”””
return _almath.transpose(*args)
def rotationFromQuaternion(*args):
“””rotationFromQuaternion(float pA, float pB, float pC, float pD) -> Rotation”””
return _almath.rotationFromQuaternion(*args)
def applyRotation(*args):
“””applyRotation(Rotation pRot, float pX, float pY, float pZ)”””
return _almath.applyRotation(*args)
def rotationFromRotX(*args):
“””rotationFromRotX(float pRotX) -> Rotation”””
return _almath.rotationFromRotX(*args)
def rotationFromRotY(*args):
“””rotationFromRotY(float pRotY) -> Rotation”””
return _almath.rotationFromRotY(*args)
def rotationFromRotZ(*args):
“””rotationFromRotZ(float pRotZ) -> Rotation”””
return _almath.rotationFromRotZ(*args)
def rotationFrom3DRotation(*args):
“””rotationFrom3DRotation(float pWX, float pWY, float pWZ) -> Rotation”””
return _almath.rotationFrom3DRotation(*args)
class Rotation3D(_object):
“””Proxy of C++ AL::Math::Rotation3D class”””
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, Rotation3D, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, Rotation3D, name)
__swig_setmethods__[“wx”] = _almath.Rotation3D_wx_set
__swig_getmethods__[“wx”] = _almath.Rotation3D_wx_get
if _newclass:wx = _swig_property(_almath.Rotation3D_wx_get, _almath.Rotation3D_wx_set)
__swig_setmethods__[“wy”] = _almath.Rotation3D_wy_set
__swig_getmethods__[“wy”] = _almath.Rotation3D_wy_get
if _newclass:wy = _swig_property(_almath.Rotation3D_wy_get, _almath.Rotation3D_wy_set)
__swig_setmethods__[“wz”] = _almath.Rotation3D_wz_set
__swig_getmethods__[“wz”] = _almath.Rotation3D_wz_get
if _newclass:wz = _swig_property(_almath.Rotation3D_wz_get, _almath.Rotation3D_wz_set)
def __init__(self, *args):
“””
__init__(self) -> Rotation3D
__init__(self, float pInit) -> Rotation3D
__init__(self, float pWx, float pWy, float pWz) -> Rotation3D
__init__(self, vectorFloat pFloats) -> Rotation3D
“””
this = _almath.new_Rotation3D(*args)
try: self.this.append(this)
except: self.this = this
def __add__(self, *args):
“””__add__(self, Rotation3D pRot2) -> Rotation3D”””
return _almath.Rotation3D___add__(self, *args)
def __sub__(self, *args):
“””__sub__(self, Rotation3D pRot2) -> Rotation3D”””
return _almath.Rotation3D___sub__(self, *args)
def __iadd__(self, *args):
“””__iadd__(self, Rotation3D pRot2) -> Rotation3D”””
return _almath.Rotation3D___iadd__(self, *args)
def __isub__(self, *args):
“””__isub__(self, Rotation3D pRot2) -> Rotation3D”””
return _almath.Rotation3D___isub__(self, *args)
def __eq__(self, *args):
“””__eq__(self, Rotation3D pRot2) -> bool”””
return _almath.Rotation3D___eq__(self, *args)
def __ne__(self, *args):
“””__ne__(self, Rotation3D pRot2) -> bool”””
return _almath.Rotation3D___ne__(self, *args)
def __mul__(self, *args):
“””__mul__(self, float pVal) -> Rotation3D”””
return _almath.Rotation3D___mul__(self, *args)
def __div__(self, *args):
“””__div__(self, float pVal) -> Rotation3D”””
return _almath.Rotation3D___div__(self, *args)
def __imul__(self, *args):
“””__imul__(self, float pVal) -> Rotation3D”””
return _almath.Rotation3D___imul__(self, *args)
def __idiv__(self, *args):
“””__idiv__(self, float pVal) -> Rotation3D”””
return _almath.Rotation3D___idiv__(self, *args)
def isNear(self, *args):
“””
isNear(self, Rotation3D pRot2, float pEpsilon = 0.0001) -> bool
isNear(self, Rotation3D pRot2) -> bool
“””
return _almath.Rotation3D_isNear(self, *args)
def norm(self):
“””norm(self) -> float”””
return _almath.Rotation3D_norm(self)
def toVector(self):
“””toVector(self) -> vectorFloat”””
return _almath.Rotation3D_toVector(self)
def __repr__(self):
“””__repr__(self) -> char”””
return _almath.Rotation3D___repr__(self)
__swig_destroy__ = _almath.delete_Rotation3D
__del__ = lambda self : None;
Rotation3D_swigregister = _almath.Rotation3D_swigregister
Rotation3D_swigregister(Rotation3D)
class Transform(_object):
“””Proxy of C++ AL::Math::Transform class”””
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, Transform, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, Transform, name)
__swig_setmethods__[“r1_c1”] = _almath.Transform_r1_c1_set
__swig_getmethods__[“r1_c1”] = _almath.Transform_r1_c1_get
if _newclass:r1_c1 = _swig_property(_almath.Transform_r1_c1_get, _almath.Transform_r1_c1_set)
__swig_setmethods__[“r1_c2”] = _almath.Transform_r1_c2_set
__swig_getmethods__[“r1_c2”] = _almath.Transform_r1_c2_get
if _newclass:r1_c2 = _swig_property(_almath.Transform_r1_c2_get, _almath.Transform_r1_c2_set)
__swig_setmethods__[“r1_c3”] = _almath.Transform_r1_c3_set
__swig_getmethods__[“r1_c3”] = _almath.Transform_r1_c3_get
if _newclass:r1_c3 = _swig_property(_almath.Transform_r1_c3_get, _almath.Transform_r1_c3_set)
__swig_setmethods__[“r1_c4”] = _almath.Transform_r1_c4_set
__swig_getmethods__[“r1_c4”] = _almath.Transform_r1_c4_get
if _newclass:r1_c4 = _swig_property(_almath.Transform_r1_c4_get, _almath.Transform_r1_c4_set)
__swig_setmethods__[“r2_c1”] = _almath.Transform_r2_c1_set
__swig_getmethods__[“r2_c1”] = _almath.Transform_r2_c1_get
if _newclass:r2_c1 = _swig_property(_almath.Transform_r2_c1_get, _almath.Transform_r2_c1_set)
__swig_setmethods__[“r2_c2”] = _almath.Transform_r2_c2_set
__swig_getmethods__[“r2_c2”] = _almath.Transform_r2_c2_get
if _newclass:r2_c2 = _swig_property(_almath.Transform_r2_c2_get, _almath.Transform_r2_c2_set)
__swig_setmethods__[“r2_c3”] = _almath.Transform_r2_c3_set
__swig_getmethods__[“r2_c3”] = _almath.Transform_r2_c3_get
if _newclass:r2_c3 = _swig_property(_almath.Transform_r2_c3_get, _almath.Transform_r2_c3_set)
__swig_setmethods__[“r2_c4”] = _almath.Transform_r2_c4_set
__swig_getmethods__[“r2_c4”] = _almath.Transform_r2_c4_get
if _newclass:r2_c4 = _swig_property(_almath.Transform_r2_c4_get, _almath.Transform_r2_c4_set)
__swig_setmethods__[“r3_c1”] = _almath.Transform_r3_c1_set
__swig_getmethods__[“r3_c1”] = _almath.Transform_r3_c1_get
if _newclass:r3_c1 = _swig_property(_almath.Transform_r3_c1_get, _almath.Transform_r3_c1_set)
__swig_setmethods__[“r3_c2”] = _almath.Transform_r3_c2_set
__swig_getmethods__[“r3_c2”] = _almath.Transform_r3_c2_get
if _newclass:r3_c2 = _swig_property(_almath.Transform_r3_c2_get, _almath.Transform_r3_c2_set)
__swig_setmethods__[“r3_c3”] = _almath.Transform_r3_c3_set
__swig_getmethods__[“r3_c3”] = _almath.Transform_r3_c3_get
if _newclass:r3_c3 = _swig_property(_almath.Transform_r3_c3_get, _almath.Transform_r3_c3_set)
__swig_setmethods__[“r3_c4”] = _almath.Transform_r3_c4_set
__swig_getmethods__[“r3_c4”] = _almath.Transform_r3_c4_get
if _newclass:r3_c4 = _swig_property(_almath.Transform_r3_c4_get, _almath.Transform_r3_c4_set)
def __init__(self, *args):
“””
__init__(self) -> Transform
__init__(self, vectorFloat pFloats) -> Transform
__init__(self, float pPosX, float pPosY, float pPosZ) -> Transform
“””
this = _almath.new_Transform(*args)
try: self.this.append(this)
except: self.this = this
def __imul__(self, *args):
“””__imul__(self, Transform pT2) -> Transform”””
return _almath.Transform___imul__(self, *args)
def __eq__(self, *args):
“””__eq__(self, Transform pT2) -> bool”””
return _almath.Transform___eq__(self, *args)
def __ne__(self, *args):
“””__ne__(self, Transform pT2) -> bool”””
return _almath.Transform___ne__(self, *args)
def isNear(self, *args):
“””
isNear(self, Transform pT2, float pEpsilon = 0.0001) -> bool
isNear(self, Transform pT2) -> bool
“””
return _almath.Transform_isNear(self, *args)
def isTransform(self, pEpsilon = 0.0001):
“””
isTransform(self, float pEpsilon = 0.0001) -> bool
isTransform(self) -> bool
“””
return _almath.Transform_isTransform(self, pEpsilon)
def norm(self):
“””norm(self) -> float”””
return _almath.Transform_norm(self)
def determinant(self):
“””determinant(self) -> float”””
return _almath.Transform_determinant(self)
def inverse(self):
“””inverse(self) -> Transform”””
return _almath.Transform_inverse(self)
def fromRotX(*args):
“””fromRotX(float pRotX) -> Transform”””
return _almath.Transform_fromRotX(*args)
if _newclass:fromRotX = staticmethod(fromRotX)
__swig_getmethods__[“fromRotX”] = lambda x: fromRotX
def fromRotY(*args):
“””fromRotY(float pRotY) -> Transform”””
return _almath.Transform_fromRotY(*args)
if _newclass:fromRotY = staticmethod(fromRotY)
__swig_getmethods__[“fromRotY”] = lambda x: fromRotY
def fromRotZ(*args):
“””fromRotZ(float pRotZ) -> Transform”””
return _almath.Transform_fromRotZ(*args)
if _newclass:fromRotZ = staticmethod(fromRotZ)
__swig_getmethods__[“fromRotZ”] = lambda x: fromRotZ
def from3DRotation(*args):
“””from3DRotation(float pWX, float pWY, float pWZ) -> Transform”””
return _almath.Transform_from3DRotation(*args)
if _newclass:from3DRotation = staticmethod(from3DRotation)
__swig_getmethods__[“from3DRotation”] = lambda x: from3DRotation
def fromPosition(*args):
“””
fromPosition(float pX, float pY, float pZ) -> Transform
fromPosition(float pX, float pY, float pZ, float pWX, float pWY,
float pWZ) -> Transform
“””
return _almath.Transform_fromPosition(*args)
if _newclass:fromPosition = staticmethod(fromPosition)
__swig_getmethods__[“fromPosition”] = lambda x: fromPosition
def diff(self, *args):
“””diff(self, Transform pT2) -> Transform”””
return _almath.Transform_diff(self, *args)
def distanceSquared(self, *args):
“””distanceSquared(self, Transform pT2) -> float”””
return _almath.Transform_distanceSquared(self, *args)
def distance(self, *args):
“””distance(self, Transform pT2) -> float”””
return _almath.Transform_distance(self, *args)
def toVector(self):
“””toVector(self) -> vectorFloat”””
return _almath.Transform_toVector(self)
def __str__(self):
“””__str__(self) -> char”””
return _almath.Transform___str__(self)
def __repr__(self):
“””__repr__(self) -> char”””
return _almath.Transform___repr__(self)
def __mul__(self, *args):
“””
__mul__(self, Transform pT2) -> Transform
__mul__(self, Position3D rhs) -> Position3D
“””
return _almath.Transform___mul__(self, *args)
__swig_destroy__ = _almath.delete_Transform
__del__ = lambda self : None;
Transform_swigregister = _almath.Transform_swigregister
Transform_swigregister(Transform)
def Transform_fromRotX(*args):
“””Transform_fromRotX(float pRotX) -> Transform”””
return _almath.Transform_fromRotX(*args)
def Transform_fromRotY(*args):
“””Transform_fromRotY(float pRotY) -> Transform”””
return _almath.Transform_fromRotY(*args)
def Transform_fromRotZ(*args):
“””Transform_fromRotZ(float pRotZ) -> Transform”””
return _almath.Transform_fromRotZ(*args)
def Transform_from3DRotation(*args):
“””Transform_from3DRotation(float pWX, float pWY, float pWZ) -> Transform”””
return _almath.Transform_from3DRotation(*args)
def Transform_fromPosition(*args):
“””
fromPosition(float pX, float pY, float pZ) -> Transform
Transform_fromPosition(float pX, float pY, float pZ, float pWX, float pWY,
float pWZ) -> Transform
“””
return _almath.Transform_fromPosition(*args)

def transformPreMultiply(*args):
“””transformPreMultiply(Transform pT, Transform pTOut)”””
return _almath.transformPreMultiply(*args)
def transformFromRotX(*args):
“””transformFromRotX(float pRotX) -> Transform”””
return _almath.transformFromRotX(*args)
def transformFromRotY(*args):
“””transformFromRotY(float pRotY) -> Transform”””
return _almath.transformFromRotY(*args)
def transformFromRotZ(*args):
“””transformFromRotZ(float pRotZ) -> Transform”””
return _almath.transformFromRotZ(*args)
def transformFrom3DRotation(*args):
“””transformFrom3DRotation(float pWX, float pWY, float pWZ) -> Transform”””
return _almath.transformFrom3DRotation(*args)
def transformInvertInPlace(*args):
“””transformInvertInPlace(Transform pT)”””
return _almath.transformInvertInPlace(*args)
def pinv(*args):
“””pinv(Transform pT) -> Transform”””
return _almath.pinv(*args)
def transformDiff(*args):
“””transformDiff(Transform pT1, Transform pT2) -> Transform”””
return _almath.transformDiff(*args)
def transformDistanceSquared(*args):
“””transformDistanceSquared(Transform pT1, Transform pT2) -> float”””
return _almath.transformDistanceSquared(*args)
def transformDistance(*args):
“””transformDistance(Transform pT1, Transform pT2) -> float”””
return _almath.transformDistance(*args)
class Velocity3D(_object):
“””Proxy of C++ AL::Math::Velocity3D class”””
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, Velocity3D, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, Velocity3D, name)
__swig_setmethods__[“xd”] = _almath.Velocity3D_xd_set
__swig_getmethods__[“xd”] = _almath.Velocity3D_xd_get
if _newclass:xd = _swig_property(_almath.Velocity3D_xd_get, _almath.Velocity3D_xd_set)
__swig_setmethods__[“yd”] = _almath.Velocity3D_yd_set
__swig_getmethods__[“yd”] = _almath.Velocity3D_yd_get
if _newclass:yd = _swig_property(_almath.Velocity3D_yd_get, _almath.Velocity3D_yd_set)
__swig_setmethods__[“zd”] = _almath.Velocity3D_zd_set
__swig_getmethods__[“zd”] = _almath.Velocity3D_zd_get
if _newclass:zd = _swig_property(_almath.Velocity3D_zd_get, _almath.Velocity3D_zd_set)
def __init__(self, *args):
“””
__init__(self) -> Velocity3D
__init__(self, float pInit) -> Velocity3D
__init__(self, float pXd, float pYd, float pZd) -> Velocity3D
__init__(self, vectorFloat pFloats) -> Velocity3D
“””
this = _almath.new_Velocity3D(*args)
try: self.this.append(this)
except: self.this = this
def __add__(self, *args):
“””__add__(self, Velocity3D pVel2) -> Velocity3D”””
return _almath.Velocity3D___add__(self, *args)
def __sub__(self, *args):
“””__sub__(self, Velocity3D pVel2) -> Velocity3D”””
return _almath.Velocity3D___sub__(self, *args)
def __pos__(self):
“””__pos__(self) -> Velocity3D”””
return _almath.Velocity3D___pos__(self)
def __neg__(self):
“””__neg__(self) -> Velocity3D”””
return _almath.Velocity3D___neg__(self)
def __iadd__(self, *args):
“””__iadd__(self, Velocity3D pVel2) -> Velocity3D”””
return _almath.Velocity3D___iadd__(self, *args)
def __isub__(self, *args):
“””__isub__(self, Velocity3D pVel2) -> Velocity3D”””
return _almath.Velocity3D___isub__(self, *args)
def __eq__(self, *args):
“””__eq__(self, Velocity3D pVel2) -> bool”””
return _almath.Velocity3D___eq__(self, *args)
def __ne__(self, *args):
“””__ne__(self, Velocity3D pVel2) -> bool”””
return _almath.Velocity3D___ne__(self, *args)
def __mul__(self, *args):
“””__mul__(self, float pVal) -> Velocity3D”””
return _almath.Velocity3D___mul__(self, *args)
def __div__(self, *args):
“””__div__(self, float pVal) -> Velocity3D”””
return _almath.Velocity3D___div__(self, *args)
def __imul__(self, *args):
“””__imul__(self, float pVal) -> Velocity3D”””
return _almath.Velocity3D___imul__(self, *args)
def __idiv__(self, *args):
“””__idiv__(self, float pVal) -> Velocity3D”””
return _almath.Velocity3D___idiv__(self, *args)
def isNear(self, *args):
“””
isNear(self, Velocity3D pVel2, float pEpsilon = 0.0001) -> bool
isNear(self, Velocity3D pVel2) -> bool
“””
return _almath.Velocity3D_isNear(self, *args)
def norm(self):
“””norm(self) -> float”””
return _almath.Velocity3D_norm(self)
def normalize(self):
“””normalize(self) -> Velocity3D”””
return _almath.Velocity3D_normalize(self)
def toVector(self):
“””toVector(self) -> vectorFloat”””
return _almath.Velocity3D_toVector(self)
def __repr__(self):
“””__repr__(self) -> char”””
return _almath.Velocity3D___repr__(self)
def __rmul__(self, *args):
“””__rmul__(self, float lhs) -> Velocity3D”””
return _almath.Velocity3D___rmul__(self, *args)
__swig_destroy__ = _almath.delete_Velocity3D
__del__ = lambda self : None;
Velocity3D_swigregister = _almath.Velocity3D_swigregister
Velocity3D_swigregister(Velocity3D)
def transformToFloatVector(*args):
“””
transformToFloatVector(Transform pT, vectorFloat pTOut)
transformToFloatVector(Transform pT) -> vectorFloat
“””
return _almath.transformToFloatVector(*args)
def determinant(*args):
“””
determinant(Rotation pRot) -> float
determinant(Transform pT) -> float
determinant(vectorFloat pFloats) -> float
“””
return _almath.determinant(*args)
def transformInverse(*args):
“””
transformInverse(Transform pT, Transform pTOut)
transformInverse(Transform pT) -> Transform
“””
return _almath.transformInverse(*args)
def transformFromPosition(*args):
“””
transformFromPosition(float pX, float pY, float pZ) -> Transform
transformFromPosition(float pX, float pY, float pZ, float pWX, float pWY,
float pWZ) -> Transform
“””
return _almath.transformFromPosition(*args)
class Velocity6D(_object):
“””Proxy of C++ AL::Math::Velocity6D class”””
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, Velocity6D, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, Velocity6D, name)
__swig_setmethods__[“xd”] = _almath.Velocity6D_xd_set
__swig_getmethods__[“xd”] = _almath.Velocity6D_xd_get
if _newclass:xd = _swig_property(_almath.Velocity6D_xd_get, _almath.Velocity6D_xd_set)
__swig_setmethods__[“yd”] = _almath.Velocity6D_yd_set
__swig_getmethods__[“yd”] = _almath.Velocity6D_yd_get
if _newclass:yd = _swig_property(_almath.Velocity6D_yd_get, _almath.Velocity6D_yd_set)
__swig_setmethods__[“zd”] = _almath.Velocity6D_zd_set
__swig_getmethods__[“zd”] = _almath.Velocity6D_zd_get
if _newclass:zd = _swig_property(_almath.Velocity6D_zd_get, _almath.Velocity6D_zd_set)
__swig_setmethods__[“wxd”] = _almath.Velocity6D_wxd_set
__swig_getmethods__[“wxd”] = _almath.Velocity6D_wxd_get
if _newclass:wxd = _swig_property(_almath.Velocity6D_wxd_get, _almath.Velocity6D_wxd_set)
__swig_setmethods__[“wyd”] = _almath.Velocity6D_wyd_set
__swig_getmethods__[“wyd”] = _almath.Velocity6D_wyd_get
if _newclass:wyd = _swig_property(_almath.Velocity6D_wyd_get, _almath.Velocity6D_wyd_set)
__swig_setmethods__[“wzd”] = _almath.Velocity6D_wzd_set
__swig_getmethods__[“wzd”] = _almath.Velocity6D_wzd_get
if _newclass:wzd = _swig_property(_almath.Velocity6D_wzd_get, _almath.Velocity6D_wzd_set)
def __init__(self, *args):
“””
__init__(self) -> Velocity6D
__init__(self, float pInit) -> Velocity6D
__init__(self, float pXd, float pYd, float pZd, float pWxd, float pWyd,
float pWzd) -> Velocity6D
__init__(self, vectorFloat pFloats) -> Velocity6D
“””
this = _almath.new_Velocity6D(*args)
try: self.this.append(this)
except: self.this = this
def __add__(self, *args):
“””__add__(self, Velocity6D pVel2) -> Velocity6D”””
return _almath.Velocity6D___add__(self, *args)
def __sub__(self, *args):
“””__sub__(self, Velocity6D pVel2) -> Velocity6D”””
return _almath.Velocity6D___sub__(self, *args)
def __pos__(self):
“””__pos__(self) -> Velocity6D”””
return _almath.Velocity6D___pos__(self)
def __neg__(self):
“””__neg__(self) -> Velocity6D”””
return _almath.Velocity6D___neg__(self)
def __mul__(self, *args):
“””__mul__(self, float pVal) -> Velocity6D”””
return _almath.Velocity6D___mul__(self, *args)
def __div__(self, *args):
“””__div__(self, float pVal) -> Velocity6D”””
return _almath.Velocity6D___div__(self, *args)
def __eq__(self, *args):
“””__eq__(self, Velocity6D pVel2) -> bool”””
return _almath.Velocity6D___eq__(self, *args)
def __ne__(self, *args):
“””__ne__(self, Velocity6D pVel2) -> bool”””
return _almath.Velocity6D___ne__(self, *args)
def __imul__(self, *args):
“””__imul__(self, float pVal) -> Velocity6D”””
return _almath.Velocity6D___imul__(self, *args)
def __idiv__(self, *args):
“””__idiv__(self, float pVal) -> Velocity6D”””
return _almath.Velocity6D___idiv__(self, *args)
def isNear(self, *args):
“””
isNear(self, Velocity6D pVel2, float pEpsilon = 0.0001) -> bool
isNear(self, Velocity6D pVel2) -> bool
“””
return _almath.Velocity6D_isNear(self, *args)
def norm(self):
“””norm(self) -> float”””
return _almath.Velocity6D_norm(self)
def normalize(self):
“””normalize(self) -> Velocity6D”””
return _almath.Velocity6D_normalize(self)
def toVector(self):
“””toVector(self) -> vectorFloat”””
return _almath.Velocity6D_toVector(self)
def __repr__(self):
“””__repr__(self) -> char”””
return _almath.Velocity6D___repr__(self)
def __rmul__(self, *args):
“””__rmul__(self, float lhs) -> Velocity6D”””
return _almath.Velocity6D___rmul__(self, *args)
__swig_destroy__ = _almath.delete_Velocity6D
__del__ = lambda self : None;
Velocity6D_swigregister = _almath.Velocity6D_swigregister
Velocity6D_swigregister(Velocity6D)
class TransformAndVelocity6D(_object):
“””Proxy of C++ AL::Math::TransformAndVelocity6D class”””
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, TransformAndVelocity6D, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, TransformAndVelocity6D, name)
__swig_setmethods__[“T”] = _almath.TransformAndVelocity6D_T_set
__swig_getmethods__[“T”] = _almath.TransformAndVelocity6D_T_get
if _newclass:T = _swig_property(_almath.TransformAndVelocity6D_T_get, _almath.TransformAndVelocity6D_T_set)
__swig_setmethods__[“V”] = _almath.TransformAndVelocity6D_V_set
__swig_getmethods__[“V”] = _almath.TransformAndVelocity6D_V_get
if _newclass:V = _swig_property(_almath.TransformAndVelocity6D_V_get, _almath.TransformAndVelocity6D_V_set)
def isNear(self, *args):
“””
isNear(self, TransformAndVelocity6D pTV2, float pEpsilon = 0.0001) -> bool
isNear(self, TransformAndVelocity6D pTV2) -> bool
“””
return _almath.TransformAndVelocity6D_isNear(self, *args)
def __repr__(self):
“””__repr__(self) -> char”””
return _almath.TransformAndVelocity6D___repr__(self)
def __init__(self):
“””__init__(self) -> TransformAndVelocity6D”””
this = _almath.new_TransformAndVelocity6D()
try: self.this.append(this)
except: self.this = this
__swig_destroy__ = _almath.delete_TransformAndVelocity6D
__del__ = lambda self : None;
TransformAndVelocity6D_swigregister = _almath.TransformAndVelocity6D_swigregister
TransformAndVelocity6D_swigregister(TransformAndVelocity6D)
def norm(*args):
“””
norm(Position2D pPos) -> float
norm(Position3D pPos) -> float
norm(Position6D pPos) -> float
norm(Quaternion pQua) -> float
norm(Rotation3D pRot) -> float
norm(Transform pT) -> float
norm(Velocity3D pVel) -> float
norm(Velocity6D pVel) -> float
“””
return _almath.norm(*args)
def normalize(*args):
“””
normalize(Position2D pPos) -> Position2D
normalize(Position3D pPos) -> Position3D
normalize(Position6D pPos) -> Position6D
normalize(Quaternion pQua) -> Quaternion
normalize(Velocity3D pVel) -> Velocity3D
normalize(Velocity6D pVel) -> Velocity6D
“””
return _almath.normalize(*args)

def getDubinsSolutions(*args):
“””getDubinsSolutions(Pose2D pTargetPose, float pCircleRadius) -> vectorPose2D”””
return _almath.getDubinsSolutions(*args)
def avoidFootCollision(*args):
“””
avoidFootCollision(vectorPose2D pLFootBoundingBox, vectorPose2D pRFootBoundingBox,
bool pIsLeftSupport, Pose2D pMove) -> bool
“””
return _almath.avoidFootCollision(*args)
def clipFootWithEllipse(*args):
“””clipFootWithEllipse(float pMaxFootX, float pMaxFootY, Pose2D pMove) -> bool”””
return _almath.clipFootWithEllipse(*args)
def transformLogarithmInPlace(*args):
“””transformLogarithmInPlace(Transform pT, Velocity6D pVel)”””
return _almath.transformLogarithmInPlace(*args)
def transformLogarithm(*args):
“””transformLogarithm(Transform pT) -> Velocity6D”””
return _almath.transformLogarithm(*args)
def velocityExponential(*args):
“””velocityExponential(Velocity6D pVel) -> Transform”””
return _almath.velocityExponential(*args)
def velocityExponentialInPlace(*args):
“””velocityExponentialInPlace(Velocity6D pVel, Transform pT)”””
return _almath.velocityExponentialInPlace(*args)
def changeReferenceVelocity6D(*args):
“””changeReferenceVelocity6D(Transform pT, Velocity6D pVelIn, Velocity6D pVelOut)”””
return _almath.changeReferenceVelocity6D(*args)
def changeReferencePosition6D(*args):
“””changeReferencePosition6D(Transform pT, Position6D pPosIn, Position6D pPosOut)”””
return _almath.changeReferencePosition6D(*args)
def changeReferencePosition3DInPlace(*args):
“””changeReferencePosition3DInPlace(Transform pT, Position3D pPosOut)”””
return _almath.changeReferencePosition3DInPlace(*args)
def changeReferenceTransposePosition3DInPlace(*args):
“””changeReferenceTransposePosition3DInPlace(Transform pT, Position3D pPosOut)”””
return _almath.changeReferenceTransposePosition3DInPlace(*args)
def changeReferencePosition3D(*args):
“””changeReferencePosition3D(Transform pT, Position3D pPosIn, Position3D pPosOut)”””
return _almath.changeReferencePosition3D(*args)
def changeReferenceTransposePosition3D(*args):
“””changeReferenceTransposePosition3D(Transform pT, Position3D pPosIn, Position3D pPosOut)”””
return _almath.changeReferenceTransposePosition3D(*args)
def changeReferenceTransform(*args):
“””changeReferenceTransform(Transform pT, Transform pTIn, Transform pTOut)”””
return _almath.changeReferenceTransform(*args)
def changeReferenceTransposeTransform(*args):
“””changeReferenceTransposeTransform(Transform pT, Transform pTIn, Transform pTOut)”””
return _almath.changeReferenceTransposeTransform(*args)
def changeReferenceTransposeVelocity6D(*args):
“””changeReferenceTransposeVelocity6D(Transform pT, Velocity6D pVelIn, Velocity6D pVelOut)”””
return _almath.changeReferenceTransposeVelocity6D(*args)
def changeReferenceTransposePosition6D(*args):
“””changeReferenceTransposePosition6D(Transform pT, Position6D pPosIn, Position6D pPosOut)”””
return _almath.changeReferenceTransposePosition6D(*args)
def transformMeanInPlace(*args):
“””transformMeanInPlace(Transform pTIn1, Transform pTIn2, float pVal, Transform pTOut)”””
return _almath.transformMeanInPlace(*args)
def transformFromPosition3DInPlace(*args):
“””transformFromPosition3DInPlace(Position3D pPosition, Transform pTransform)”””
return _almath.transformFromPosition3DInPlace(*args)
def transformFromPosition3D(*args):
“””transformFromPosition3D(Position3D pPosition) -> Transform”””
return _almath.transformFromPosition3D(*args)
def transformFromRotationInPlace(*args):
“””transformFromRotationInPlace(Rotation pRotation, Transform pTransform)”””
return _almath.transformFromRotationInPlace(*args)
def transformFromRotation(*args):
“””transformFromRotation(Rotation pRotation) -> Transform”””
return _almath.transformFromRotation(*args)
def rotationFromTransformInPlace(*args):
“””rotationFromTransformInPlace(Transform pTransform, Rotation pRotation)”””
return _almath.rotationFromTransformInPlace(*args)
def rotationFromTransform(*args):
“””rotationFromTransform(Transform pTransform) -> Rotation”””
return _almath.rotationFromTransform(*args)
def rotation3DFromRotation(*args):
“””rotation3DFromRotation(Rotation pRotation) -> Rotation3D”””
return _almath.rotation3DFromRotation(*args)
def position6DFromTransformInPlace(*args):
“””position6DFromTransformInPlace(Transform pT, Position6D pPos)”””
return _almath.position6DFromTransformInPlace(*args)
def position6DFromTransform(*args):
“””position6DFromTransform(Transform pT) -> Position6D”””
return _almath.position6DFromTransform(*args)
def transformFromPose2DInPlace(*args):
“””transformFromPose2DInPlace(Pose2D pPose, Transform pT)”””
return _almath.transformFromPose2DInPlace(*args)
def transformFromPose2D(*args):
“””transformFromPose2D(Pose2D pPose) -> Transform”””
return _almath.transformFromPose2D(*args)
def pose2DFromTransformInPlace(*args):
“””pose2DFromTransformInPlace(Transform pT, Pose2D pPos)”””
return _almath.pose2DFromTransformInPlace(*args)
def pose2DFromTransform(*args):
“””pose2DFromTransform(Transform pT) -> Pose2D”””
return _almath.pose2DFromTransform(*args)
def transformFromRotation3D(*args):
“””transformFromRotation3D(Rotation3D pRotation) -> Transform”””
return _almath.transformFromRotation3D(*args)
def transformFromPosition6D(*args):
“””transformFromPosition6D(Position6D pPosition6D) -> Transform”””
return _almath.transformFromPosition6D(*args)
def position6DFromTransformDiffInPlace(*args):
“””position6DFromTransformDiffInPlace(Transform pCurrent, Transform pTarget, Position6D result)”””
return _almath.position6DFromTransformDiffInPlace(*args)
def position6DFromTransformDiff(*args):
“””position6DFromTransformDiff(Transform pCurrent, Transform pTarget) -> Position6D”””
return _almath.position6DFromTransformDiff(*args)
def position3DFromTransformInPlace(*args):
“””position3DFromTransformInPlace(Transform pT, Position3D pPos)”””
return _almath.position3DFromTransformInPlace(*args)
def position3DFromTransform(*args):
“””position3DFromTransform(Transform pT) -> Position3D”””
return _almath.position3DFromTransform(*args)
def rotation3DFromTransform(*args):
“””rotation3DFromTransform(Transform pT) -> Rotation3D”””
return _almath.rotation3DFromTransform(*args)
def transformFromQuaternion(*args):
“””transformFromQuaternion(Quaternion pQua) -> Transform”””
return _almath.transformFromQuaternion(*args)
def quaternionFromTransform(*args):
“””quaternionFromTransform(Transform pT) -> Quaternion”””
return _almath.quaternionFromTransform(*args)
def clipData(*args):
“””clipData(float pMin, float pMax, float pData) -> bool”””
return _almath.clipData(*args)
def position6DFromVelocity6D(*args):
“””position6DFromVelocity6D(Velocity6D pVel) -> Position6D”””
return _almath.position6DFromVelocity6D(*args)
_4_PI_ = cvar._4_PI_
_2_PI_ = cvar._2_PI_
PI = cvar.PI
PI_2 = cvar.PI_2
PI_4 = cvar.PI_4
TO_RAD = cvar.TO_RAD
TO_DEG = cvar.TO_DEG
def transformMean(*args):
“””
transformMean(Transform pTIn1, Transform pTIn2, float pVal = 0.5) -> Transform
transformMean(Transform pTIn1, Transform pTIn2) -> Transform
“””
return _almath.transformMean(*args)
def transformFromRotationPosition3D(*args):
“””
transformFromRotationPosition3D(Rotation pRot, float pX, float pY, float pZ) -> Transform
transformFromRotationPosition3D(Rotation pRot, Position3D pPos) -> Transform
“””
return _almath.transformFromRotationPosition3D(*args)
def transformFromRotVecInPlace(*args):
“””
transformFromRotVecInPlace(int pAxis, float pTheta, Position3D pPos, Transform pT)
transformFromRotVecInPlace(Position3D pPos, Transform pT)
“””
return _almath.transformFromRotVecInPlace(*args)
def transformFromRotVec(*args):
“””
transformFromRotVec(int pAxis, float pTheta, Position3D pPos) -> Transform
transformFromRotVec(Position3D pPos) -> Transform
transformFromRotVec(int pAxis, float pTheta) -> Transform
“””
return _almath.transformFromRotVec(*args)
def axisRotationProjection(*args):
“””
axisRotationProjection(Position3D pPos, Transform pT) -> Transform
axisRotationProjection(Position3D pAxis, Rotation pRot) -> Rotation
“””
return _almath.axisRotationProjection(*args)
def axisRotationProjectionInPlace(*args):
“””
axisRotationProjectionInPlace(Position3D pPos, Transform pT)
axisRotationProjectionInPlace(Position3D pPos, Rotation pRot)
“””
return _almath.axisRotationProjectionInPlace(*args)
def orthogonalSpace(*args):
“””
orthogonalSpace(Position3D pPos, Transform pTOut)
orthogonalSpace(Position3D pPos) -> Transform
“””
return _almath.orthogonalSpace(*args)
def __mul__(*args):
“””
__mul__(float pM, Position2D pPos1) -> Position2D
__mul__(float pM, Position3D pPos1) -> Position3D
__mul__(float pM, Velocity3D pVel1) -> Velocity3D
__mul__(float pVal, Velocity6D pVel) -> Velocity6D
__mul__(Transform pT, Position3D pPos) -> Position3D
__mul__(Rotation pRot, Position3D pPos) -> Position3D
__mul__(float pVal, Position6D pPos) -> Velocity6D
“””
return _almath.__mul__(*args)
def rotationFromAngleDirection(*args):
“””
rotationFromAngleDirection(float pAngle, float pX, float pY, float pZ) -> Rotation
rotationFromAngleDirection(float pTheta, Position3D pPos) -> Rotation
“””
return _almath.rotationFromAngleDirection(*args)

pynaoqi-python-2.7-naoqi-1.14-linux64/_allog.so

pynaoqi-python-2.7-naoqi-1.14-linux64/inaoqi.py
# This file was automatically generated by SWIG (http://www.swig.org).
# Version 1.3.40
#
# Do not make changes to this file unless you know what you are doing–modify
# the SWIG interface file instead.
# This file is compatible with both classic and new-style classes.
from sys import version_info
if version_info >= (2,6,0):
def swig_import_helper():
from os.path import dirname
import imp
fp = None
try:
fp, pathname, description = imp.find_module(‘_inaoqi’, [dirname(__file__)])
except ImportError:
import _inaoqi
return _inaoqi
if fp is not None:
try:
_mod = imp.load_module(‘_inaoqi’, fp, pathname, description)
finally:
fp.close()
return _mod
_inaoqi = swig_import_helper()
del swig_import_helper
else:
import _inaoqi
del version_info
try:
_swig_property = property
except NameError:
pass # Python < 2.2 doesn't have 'property'. 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__ == 'SwigPyObject': 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,)
try:
_object = object
_newclass = 1
except AttributeError:
class _object : pass
_newclass = 0

class SwigPyIterator(_object):
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, SwigPyIterator, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, SwigPyIterator, name)
def __init__(self, *args, **kwargs): raise AttributeError(“No constructor defined – class is abstract”)
__repr__ = _swig_repr
__swig_destroy__ = _inaoqi.delete_SwigPyIterator
__del__ = lambda self : None;
def value(self): return _inaoqi.SwigPyIterator_value(self)
def incr(self, n = 1): return _inaoqi.SwigPyIterator_incr(self, n)
def decr(self, n = 1): return _inaoqi.SwigPyIterator_decr(self, n)
def distance(self, *args): return _inaoqi.SwigPyIterator_distance(self, *args)
def equal(self, *args): return _inaoqi.SwigPyIterator_equal(self, *args)
def copy(self): return _inaoqi.SwigPyIterator_copy(self)
def next(self): return _inaoqi.SwigPyIterator_next(self)
def __next__(self): return _inaoqi.SwigPyIterator___next__(self)
def previous(self): return _inaoqi.SwigPyIterator_previous(self)
def advance(self, *args): return _inaoqi.SwigPyIterator_advance(self, *args)
def __eq__(self, *args): return _inaoqi.SwigPyIterator___eq__(self, *args)
def __ne__(self, *args): return _inaoqi.SwigPyIterator___ne__(self, *args)
def __iadd__(self, *args): return _inaoqi.SwigPyIterator___iadd__(self, *args)
def __isub__(self, *args): return _inaoqi.SwigPyIterator___isub__(self, *args)
def __add__(self, *args): return _inaoqi.SwigPyIterator___add__(self, *args)
def __sub__(self, *args): return _inaoqi.SwigPyIterator___sub__(self, *args)
def __iter__(self): return self
SwigPyIterator_swigregister = _inaoqi.SwigPyIterator_swigregister
SwigPyIterator_swigregister(SwigPyIterator)
class StringVector(_object):
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, StringVector, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, StringVector, name)
__repr__ = _swig_repr
def iterator(self): return _inaoqi.StringVector_iterator(self)
def __iter__(self): return self.iterator()
def __nonzero__(self): return _inaoqi.StringVector___nonzero__(self)
def __bool__(self): return _inaoqi.StringVector___bool__(self)
def __len__(self): return _inaoqi.StringVector___len__(self)
def pop(self): return _inaoqi.StringVector_pop(self)
def __getslice__(self, *args): return _inaoqi.StringVector___getslice__(self, *args)
def __setslice__(self, *args): return _inaoqi.StringVector___setslice__(self, *args)
def __delslice__(self, *args): return _inaoqi.StringVector___delslice__(self, *args)
def __delitem__(self, *args): return _inaoqi.StringVector___delitem__(self, *args)
def __getitem__(self, *args): return _inaoqi.StringVector___getitem__(self, *args)
def __setitem__(self, *args): return _inaoqi.StringVector___setitem__(self, *args)
def append(self, *args): return _inaoqi.StringVector_append(self, *args)
def empty(self): return _inaoqi.StringVector_empty(self)
def size(self): return _inaoqi.StringVector_size(self)
def clear(self): return _inaoqi.StringVector_clear(self)
def swap(self, *args): return _inaoqi.StringVector_swap(self, *args)
def get_allocator(self): return _inaoqi.StringVector_get_allocator(self)
def begin(self): return _inaoqi.StringVector_begin(self)
def end(self): return _inaoqi.StringVector_end(self)
def rbegin(self): return _inaoqi.StringVector_rbegin(self)
def rend(self): return _inaoqi.StringVector_rend(self)
def pop_back(self): return _inaoqi.StringVector_pop_back(self)
def erase(self, *args): return _inaoqi.StringVector_erase(self, *args)
def __init__(self, *args):
this = _inaoqi.new_StringVector(*args)
try: self.this.append(this)
except: self.this = this
def push_back(self, *args): return _inaoqi.StringVector_push_back(self, *args)
def front(self): return _inaoqi.StringVector_front(self)
def back(self): return _inaoqi.StringVector_back(self)
def assign(self, *args): return _inaoqi.StringVector_assign(self, *args)
def resize(self, *args): return _inaoqi.StringVector_resize(self, *args)
def insert(self, *args): return _inaoqi.StringVector_insert(self, *args)
def reserve(self, *args): return _inaoqi.StringVector_reserve(self, *args)
def capacity(self): return _inaoqi.StringVector_capacity(self)
__swig_destroy__ = _inaoqi.delete_StringVector
__del__ = lambda self : None;
StringVector_swigregister = _inaoqi.StringVector_swigregister
StringVector_swigregister(StringVector)

def setInstance(*args):
return _inaoqi.setInstance(*args)
setInstance = _inaoqi.setInstance
def getMemoryProxy():
return _inaoqi.getMemoryProxy()
getMemoryProxy = _inaoqi.getMemoryProxy
def _ALSystem(*args):
return _inaoqi._ALSystem(*args)
_ALSystem = _inaoqi._ALSystem
class broker(_object):
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, broker, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, broker, name)
__repr__ = _swig_repr
def __init__(self, *args):
this = _inaoqi.new_broker(*args)
try: self.this.append(this)
except: self.this = this
__swig_destroy__ = _inaoqi.delete_broker
__del__ = lambda self : None;
def shutdown(self): return _inaoqi.broker_shutdown(self)
def isModulePresent(self, *args): return _inaoqi.broker_isModulePresent(self, *args)
def getGlobalModuleList(self): return _inaoqi.broker_getGlobalModuleList(self)
broker_swigregister = _inaoqi.broker_swigregister
broker_swigregister(broker)
class baseModule(_object):
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, baseModule, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, baseModule, name)
__repr__ = _swig_repr
def __init__(self):
this = _inaoqi.new_baseModule()
try: self.this.append(this)
except: self.this = this
def BIND_PYTHON(self, *args): return _inaoqi.baseModule_BIND_PYTHON(self, *args)
def _bindWithParam(self, *args): return _inaoqi.baseModule__bindWithParam(self, *args)
def exit(self): return _inaoqi.baseModule_exit(self)
def getName(self): return _inaoqi.baseModule_getName(self)
def getBrokerName(self): return _inaoqi.baseModule_getBrokerName(self)
def setModuleDescription(self, *args): return _inaoqi.baseModule_setModuleDescription(self, *args)
def addParam(self, *args): return _inaoqi.baseModule_addParam(self, *args)
def functionName(self, *args): return _inaoqi.baseModule_functionName(self, *args)
def autoBind(self, *args): return _inaoqi.baseModule_autoBind(self, *args)
def _methodMissing0(self): return _inaoqi.baseModule__methodMissing0(self)
def _methodMissing1(self, *args): return _inaoqi.baseModule__methodMissing1(self, *args)
def _methodMissing2(self, *args): return _inaoqi.baseModule__methodMissing2(self, *args)
def _methodMissing3(self, *args): return _inaoqi.baseModule__methodMissing3(self, *args)
def _methodMissing4(self, *args): return _inaoqi.baseModule__methodMissing4(self, *args)
def _methodMissing5(self, *args): return _inaoqi.baseModule__methodMissing5(self, *args)
def _methodMissing6(self, *args): return _inaoqi.baseModule__methodMissing6(self, *args)
def _methodMissing(self): return _inaoqi.baseModule__methodMissing(self)
def version(self): return _inaoqi.baseModule_version(self)
__swig_destroy__ = _inaoqi.delete_baseModule
__del__ = lambda self : None;
baseModule_swigregister = _inaoqi.baseModule_swigregister
baseModule_swigregister(baseModule)
class module(baseModule):
__swig_setmethods__ = {}
for _s in [baseModule]: __swig_setmethods__.update(getattr(_s,’__swig_setmethods__’,{}))
__setattr__ = lambda self, name, value: _swig_setattr(self, module, name, value)
__swig_getmethods__ = {}
for _s in [baseModule]: __swig_getmethods__.update(getattr(_s,’__swig_getmethods__’,{}))
__getattr__ = lambda self, name: _swig_getattr(self, module, name)
__repr__ = _swig_repr
def __init__(self, *args):
this = _inaoqi.new_module(*args)
try: self.this.append(this)
except: self.this = this
def BIND_PYTHON(self, *args): return _inaoqi.module_BIND_PYTHON(self, *args)
def exit(self): return _inaoqi.module_exit(self)
def getName(self): return _inaoqi.module_getName(self)
def getBrokerName(self): return _inaoqi.module_getBrokerName(self)
def _methodMissing(self): return _inaoqi.module__methodMissing(self)
def version(self): return _inaoqi.module_version(self)
__swig_destroy__ = _inaoqi.delete_module
__del__ = lambda self : None;
module_swigregister = _inaoqi.module_swigregister
module_swigregister(module)
class timeline(_object):
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, timeline, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, timeline, name)
__repr__ = _swig_repr
def __init__(self, *args):
this = _inaoqi.new_timeline(*args)
try: self.this.append(this)
except: self.this = this
__swig_destroy__ = _inaoqi.delete_timeline
__del__ = lambda self : None;
def play(self): return _inaoqi.timeline_play(self)
def pause(self): return _inaoqi.timeline_pause(self)
def stop(self): return _inaoqi.timeline_stop(self)
def goTo(self, *args): return _inaoqi.timeline_goTo(self, *args)
def getSize(self): return _inaoqi.timeline_getSize(self)
def getFPS(self): return _inaoqi.timeline_getFPS(self)
def setFPS(self, *args): return _inaoqi.timeline_setFPS(self, *args)
timeline_swigregister = _inaoqi.timeline_swigregister
timeline_swigregister(timeline)
class behavior(baseModule):
__swig_setmethods__ = {}
for _s in [baseModule]: __swig_setmethods__.update(getattr(_s,’__swig_setmethods__’,{}))
__setattr__ = lambda self, name, value: _swig_setattr(self, behavior, name, value)
__swig_getmethods__ = {}
for _s in [baseModule]: __swig_getmethods__.update(getattr(_s,’__swig_getmethods__’,{}))
__getattr__ = lambda self, name: _swig_getattr(self, behavior, name)
__repr__ = _swig_repr
def __init__(self, *args):
this = _inaoqi.new_behavior(*args)
try: self.this.append(this)
except: self.this = this
__swig_destroy__ = _inaoqi.delete_behavior
__del__ = lambda self : None;
def setEnabled(self, *args): return _inaoqi.behavior_setEnabled(self, *args)
def isEnabled(self): return _inaoqi.behavior_isEnabled(self)
def setResources(self, *args): return _inaoqi.behavior_setResources(self, *args)
def waitFor(self, *args): return _inaoqi.behavior_waitFor(self, *args)
def waitResourcesCallback(self, *args): return _inaoqi.behavior_waitResourcesCallback(self, *args)
def isResourceFree(self, *args): return _inaoqi.behavior_isResourceFree(self, *args)
def waitResourceFree(self): return _inaoqi.behavior_waitResourceFree(self)
def waitResources(self): return _inaoqi.behavior_waitResources(self)
def releaseResource(self): return _inaoqi.behavior_releaseResource(self)
def addInput(self, *args): return _inaoqi.behavior_addInput(self, *args)
def addOutput(self, *args): return _inaoqi.behavior_addOutput(self, *args)
def addParameter(self, *args): return _inaoqi.behavior_addParameter(self, *args)
def getParameter(self, *args): return _inaoqi.behavior_getParameter(self, *args)
def getParametersList(self): return _inaoqi.behavior_getParametersList(self)
def setParameter(self, *args): return _inaoqi.behavior_setParameter(self, *args)
def stimulateIO(self, *args): return _inaoqi.behavior_stimulateIO(self, *args)
def BIND_PYTHON(self, *args): return _inaoqi.behavior_BIND_PYTHON(self, *args)
def setModuleDescription(self, *args): return _inaoqi.behavior_setModuleDescription(self, *args)
def addParam(self, *args): return _inaoqi.behavior_addParam(self, *args)
def exit(self): return _inaoqi.behavior_exit(self)
def getName(self): return _inaoqi.behavior_getName(self)
def getBrokerName(self): return _inaoqi.behavior_getBrokerName(self)
def _methodMissing(self): return _inaoqi.behavior__methodMissing(self)
def version(self): return _inaoqi.behavior_version(self)
def hasTimeline(self): return _inaoqi.behavior_hasTimeline(self)
def getTimeline(self): return _inaoqi.behavior_getTimeline(self)
def hasParentTimeline(self): return _inaoqi.behavior_hasParentTimeline(self)
def getParentTimeline(self): return _inaoqi.behavior_getParentTimeline(self)
behavior_swigregister = _inaoqi.behavior_swigregister
behavior_swigregister(behavior)
class proxy(_object):
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, proxy, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, proxy, name)
__repr__ = _swig_repr
def __init__(self, *args):
this = _inaoqi.new_proxy(*args)
try: self.this.append(this)
except: self.this = this
def pythonCall(self, *args): return _inaoqi.proxy_pythonCall(self, *args)
def pythonPCall(self, *args): return _inaoqi.proxy_pythonPCall(self, *args)
def wait(self, *args): return _inaoqi.proxy_wait(self, *args)
def stop(self, *args): return _inaoqi.proxy_stop(self, *args)
def isRunning(self, *args): return _inaoqi.proxy_isRunning(self, *args)
__swig_destroy__ = _inaoqi.delete_proxy
__del__ = lambda self : None;
proxy_swigregister = _inaoqi.proxy_swigregister
proxy_swigregister(proxy)
class ALMemoryProxy(_object):
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, ALMemoryProxy, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, ALMemoryProxy, name)
__repr__ = _swig_repr
def __init__(self, *args):
this = _inaoqi.new_ALMemoryProxy(*args)
try: self.this.append(this)
except: self.this = this
__swig_setmethods__[“post”] = _inaoqi.ALMemoryProxy_post_set
__swig_getmethods__[“post”] = _inaoqi.ALMemoryProxy_post_get
if _newclass:post = _swig_property(_inaoqi.ALMemoryProxy_post_get, _inaoqi.ALMemoryProxy_post_set)
def getGenericProxy(self): return _inaoqi.ALMemoryProxy_getGenericProxy(self)
def declareEvent(self, *args): return _inaoqi.ALMemoryProxy_declareEvent(self, *args)
def exit(self): return _inaoqi.ALMemoryProxy_exit(self)
def getBrokerName(self): return _inaoqi.ALMemoryProxy_getBrokerName(self)
def getData(self, *args): return _inaoqi.ALMemoryProxy_getData(self, *args)
def getDataList(self, *args): return _inaoqi.ALMemoryProxy_getDataList(self, *args)
def getDataListName(self): return _inaoqi.ALMemoryProxy_getDataListName(self)
def getDataOnChange(self, *args): return _inaoqi.ALMemoryProxy_getDataOnChange(self, *args)
def getDataPtr(self, *args): return _inaoqi.ALMemoryProxy_getDataPtr(self, *args)
def getDescriptionList(self, *args): return _inaoqi.ALMemoryProxy_getDescriptionList(self, *args)
def getEventHistory(self, *args): return _inaoqi.ALMemoryProxy_getEventHistory(self, *args)
def getEventList(self): return _inaoqi.ALMemoryProxy_getEventList(self)
def getExtractorEvent(self, *args): return _inaoqi.ALMemoryProxy_getExtractorEvent(self, *args)
def getListData(self, *args): return _inaoqi.ALMemoryProxy_getListData(self, *args)
def getMethodHelp(self, *args): return _inaoqi.ALMemoryProxy_getMethodHelp(self, *args)
def getMethodList(self): return _inaoqi.ALMemoryProxy_getMethodList(self)
def getMicroEventList(self): return _inaoqi.ALMemoryProxy_getMicroEventList(self)
def getModuleHelp(self): return _inaoqi.ALMemoryProxy_getModuleHelp(self)
def getSubscribers(self, *args): return _inaoqi.ALMemoryProxy_getSubscribers(self, *args)
def getTimestamp(self, *args): return _inaoqi.ALMemoryProxy_getTimestamp(self, *args)
def getType(self, *args): return _inaoqi.ALMemoryProxy_getType(self, *args)
def getUsage(self, *args): return _inaoqi.ALMemoryProxy_getUsage(self, *args)
def insertData(self, *args): return _inaoqi.ALMemoryProxy_insertData(self, *args)
def insertListData(self, *args): return _inaoqi.ALMemoryProxy_insertListData(self, *args)
def isRunning(self, *args): return _inaoqi.ALMemoryProxy_isRunning(self, *args)
def ping(self): return _inaoqi.ALMemoryProxy_ping(self)
def raiseEvent(self, *args): return _inaoqi.ALMemoryProxy_raiseEvent(self, *args)
def raiseMicroEvent(self, *args): return _inaoqi.ALMemoryProxy_raiseMicroEvent(self, *args)
def removeData(self, *args): return _inaoqi.ALMemoryProxy_removeData(self, *args)
def removeMicroEvent(self, *args): return _inaoqi.ALMemoryProxy_removeMicroEvent(self, *args)
def setDescription(self, *args): return _inaoqi.ALMemoryProxy_setDescription(self, *args)
def stop(self, *args): return _inaoqi.ALMemoryProxy_stop(self, *args)
def subscribeToEvent(self, *args): return _inaoqi.ALMemoryProxy_subscribeToEvent(self, *args)
def subscribeToMicroEvent(self, *args): return _inaoqi.ALMemoryProxy_subscribeToMicroEvent(self, *args)
def unregisterModuleReference(self, *args): return _inaoqi.ALMemoryProxy_unregisterModuleReference(self, *args)
def unsubscribeToEvent(self, *args): return _inaoqi.ALMemoryProxy_unsubscribeToEvent(self, *args)
def unsubscribeToMicroEvent(self, *args): return _inaoqi.ALMemoryProxy_unsubscribeToMicroEvent(self, *args)
def version(self): return _inaoqi.ALMemoryProxy_version(self)
def wait(self, *args): return _inaoqi.ALMemoryProxy_wait(self, *args)
__swig_destroy__ = _inaoqi.delete_ALMemoryProxy
__del__ = lambda self : None;
ALMemoryProxy_swigregister = _inaoqi.ALMemoryProxy_swigregister
ALMemoryProxy_swigregister(ALMemoryProxy)

pynaoqi-python-2.7-naoqi-1.14-linux64/motion.py
# Class Motion for storing useful ALMotion constants
# SPACES
SPACE_TORSO = 0
SPACE_WORLD = 1
SPACE_NAO = 2
# NEW in 1.14
FRAME_TORSO = 0
FRAME_WORLD = 1
FRAME_ROBOT = 2
# MOVEMENT
MVT_RELATIVE = 0
MVT_ABSOLUTE = 1
#ANGLE TYPE
COMMANDS = 0,
SENSORS = 1
# AXIS MASK
AXIS_MASK_X = 1
AXIS_MASK_Y = 2
AXIS_MASK_Z = 4
AXIS_MASK_WX = 8
AXIS_MASK_WY = 16
AXIS_MASK_WZ = 32
AXIS_MASK_ALL = 63
AXIS_MASK_VEL = 7
AXIS_MASK_ROT = 56
# COMPUTING
TO_RAD = 0.01745329
TO_DEG = 57.295779513082323

pynaoqi-python-2.7-naoqi-1.14-linux64/vision_definitions.py
# Useful constants used by the Vision modules.
# Camera model
kOV7670 = 1 # VGA camera
kMT9M114 = 2 # HD wide angle camera
# Image format
k960p = 3 # 1280*960
k4VGA = 3 # 1280*960
kVGA = 2 # 640*480
kQVGA = 1 # 320*240
kQQVGA = 0 # 160*120
# Color Space
kYuvColorSpace = 0
kyUvColorSpace = 1
kyuVColorSpace = 2
kRgbColorSpace = 3
krGbColorSpace = 4
krgBColorSpace = 5
kHsvColorSpace = 6
khSvColorSpace = 7
khsVColorSpace = 8
kYUV422InterlacedColorSpace = 9 #deprecated
kYUV422ColorSpace = 9
kYUVColorSpace = 10
kRGBColorSpace = 11
kHSVColorSpace = 12
kBGRColorSpace = 13
kYYCbCrColorSpace = 14
kH2RGBColorSpace = 15
kHSMixedColorSpace = 16

# Scale methods
kSimpleScaleMethod = 0
kAverageScaleMethod = 1
kQualityScaleMethod = 2
kNoScaling = 3

# Standard Id
kCameraBrightnessID = 0
kCameraContrastID = 1
kCameraSaturationID = 2
kCameraHueID = 3
kCameraRedChromaID = 4
kCameraBlueChromaID = 5
kCameraGainID = 6
kCameraHFlipID = 7
kCameraVFlipID = 8
kCameraLensXID = 9
kCameraLensYID = 10
kCameraAutoExpositionID = 11
kCameraAutoWhiteBalanceID = 12
kCameraAutoGainID = 13
kCameraResolutionID = 14
kCameraFrameRateID = 15
kCameraBufferSizeID = 16
kCameraExposureID = 17
kCameraSelectID = 18
kCameraSetDefaultParamsID = 19
kCameraColorSpaceID = 20
kCameraExposureCorrectionID = 21
kCameraAecAlgorithmID = 22
kCameraFastSwitchID = 23
kCameraSharpnessID = 24
kCameraAwbGreenGainID = 25
kCameraAblcID = 26
kCameraAblcTargetID = 27
kCameraAblcStableRangeID = 28
kCameraBlcBlueID = 29
kCameraBlcRedID = 30
kCameraBlcGbID = 31
kCameraBlcGrID = 32
kCameraWhiteBalanceID = 33
kCameraBacklightCompensationID = 34

pynaoqi-python-2.7-naoqi-1.14-mac64/_inaoqi.so

pynaoqi-python-2.7-naoqi-1.14-mac64/_almath.so

pynaoqi-python-2.7-naoqi-1.14-mac64/naoqi.py
import os
import sys
import weakref
import logging

try:
import _inaoqi
except ImportError:
# quick hack to keep inaoqi.py happy
if sys.platform.startswith(“win”):
print “Could not find _inaoqi, trying with _inaoqi_d”
import _inaoqi_d as _inaoqi
else:
raise
import inaoqi
import motion
import allog
def autoBind(myClass, bindIfnoDocumented):
“””Show documentation for each
method of the class”””
# dir(myClass) is a list of the names of
# everything in class
myClass.setModuleDescription(myClass.__doc__)
for thing in dir(myClass):
# getattr(x, “y”) is exactly: x.y
function = getattr(myClass, thing)
if callable(function):
if (type(function) == type(myClass.__init__)):
if (bindIfnoDocumented or function.__doc__ != “”):
if (thing[0] != “_”): # private method
if (function.__doc__):
myClass.functionName(thing, myClass.getName(), function.__doc__)
else:
myClass.functionName(thing, myClass.getName(), “”)
for param in function.func_code.co_varnames:
if (param != “self”):
myClass.addParam(param)
myClass._bindWithParam(myClass.getName(),thing,len(function.func_code.co_varnames)-1)

class ALDocable():
def __init__(self, bindIfnoDocumented):
autoBind(self,bindIfnoDocumented)

# define the log handler to be used by the logging module
class ALLogHandler(logging.Handler):
def __init__(self):
logging.Handler.__init__(self)
def emit(self, record):
level_to_function = {
logging.DEBUG: allog.debug,
logging.INFO: allog.info,
logging.WARNING: allog.warning,
logging.ERROR: allog.error,
logging.CRITICAL: allog.fatal,
}
function = level_to_function.get(record.levelno, allog.debug)
function(record.getMessage(),
record.name,
record.filename,
record.funcName,
record.lineno)

# Same as above, but we force the category to be behavior.box
# *AND* we prefix the message with the module name
# look at errorInBox in choregraphe for explanation
class ALBehaviorLogHandler(logging.Handler):
def __init__(self):
logging.Handler.__init__(self)
def emit(self, record):
level_to_function = {
logging.DEBUG: allog.debug,
logging.INFO: allog.info,
logging.WARNING: allog.warning,
logging.ERROR: allog.error,
logging.CRITICAL: allog.fatal,
}
function = level_to_function.get(record.levelno, allog.debug)
function(record.name + “: ” + record.getMessage(),
“behavior.box”,
“”, # record.filename in this case is simply ‘‘
record.funcName,
record.lineno)
# define a class that will be inherited by both ALModule and ALBehavior, to store instances of modules, so a bound method can be called on them.
class NaoQiModule():
_modules = dict()
@classmethod
def getModule(cls, name):
# returns a reference a module, giving its string, if it exists !
if(name not in cls._modules):
raise RuntimeError(“Module ” + str(name) + ” does not exist”)
return cls._modules[name]()
def __init__(self, name, logger=True):
# keep a weak reference to ourself, so a proxy can be called on this module easily
self._modules[name] = weakref.ref(self)
self.loghandler = None
if logger:
self.logger = logging.getLogger(name)
self.loghandler = ALLogHandler()
self.logger.addHandler(self.loghandler)
self.logger.setLevel(logging.DEBUG)
def __del__(self):
# when object is deleted, clean up dictionnary so we do not keep a weak reference to it
del self._modules[self.getName()]
if(self.loghandler != None):
self.logger.removeHandler(self.loghandler)

class ALBroker(inaoqi.broker):
def init(self):
pass
class ALModule(inaoqi.module, ALDocable, NaoQiModule):
def __init__(self,param):
inaoqi.module.__init__(self, param)
ALDocable.__init__(self, False)
NaoQiModule.__init__(self, param)
def __del__(self):
NaoQiModule.__del__(self)
def methodtest(self):
pass
def pythonChanged(self, param1, param2, param3):
pass

class ALBehavior(inaoqi.behavior, NaoQiModule):
# class var in order not to build it each time
_noNeedToBind = set(dir(inaoqi.behavior))
_noNeedToBind.add(“getModule”)
_noNeedToBind.add(“onLoad”)
_noNeedToBind.add(“onUnload”)
# deprecated since 1.14 methods
_noNeedToBind.add(“log”)
_noNeedToBind.add(“playTimeline”)
_noNeedToBind.add(“stopTimeline”)
_noNeedToBind.add(“exitBehavior”)
_noNeedToBind.add(“gotoAndStop”)
_noNeedToBind.add(“gotoAndPlay”)
_noNeedToBind.add(“playTimelineParent”)
_noNeedToBind.add(“stopTimelineParent”)
_noNeedToBind.add(“exitBehaviorParent”)
_noNeedToBind.add(“gotoAndPlayParent”)
_noNeedToBind.add(“gotoAndStopParent”)
def __init__(self, param, autoBind):
inaoqi.behavior.__init__(self, param)
NaoQiModule.__init__(self, param, logger=False)
self.logger = logging.getLogger(param)
self.behaviorloghandler = ALBehaviorLogHandler()
self.logger.addHandler(self.behaviorloghandler)
self.logger.setLevel(logging.DEBUG)
self.resource = False
self.BIND_PYTHON(self.getName(), “__onLoad__”)
self.BIND_PYTHON(self.getName(), “__onUnload__”)
if(autoBind):
behName = self.getName()
userMethList = set(dir(self)) – self._noNeedToBind
for methName in userMethList:
function = getattr(self, methName)
if callable(function) and type(function) == type(self.__init__):
if (methName[0] != “_”): # private method
self.functionName(methName, behName, “”)
for param in function.func_code.co_varnames:
if (param != “self”):
self.addParam(param)
self._bindWithParam(behName,methName,len(function.func_code.co_varnames)-1)
def __del__(self):
NaoQiModule.__del__(self)
self.logger.removeHandler(self.behaviorloghandler)
self.behaviorloghandler.close()
def __onLoad__(self):
self._safeCallOfUserMethod(“onLoad”,None)
def __onUnload__(self):
if(self.resource):
self.releaseResource()
self._safeCallOfUserMethod(“onUnload”,None)
def setParameter(self, parameterName, newValue):
inaoqi.behavior.setParameter(self, parameterName, newValue)
def _safeCallOfUserMethod(self, functionName, functionArg):
try:
if(functionName in dir(self)):
func = getattr(self, functionName)
if(func.im_func.func_code.co_argcount == 2):
func(functionArg)
else:
func()
return True
except BaseException, err:
self.logger.error(str(err))
try:
if(“onError” in dir(self)):
self.onError(self.getName() + ‘:’ +str(err))
except BaseException, err2:
self.logger.error(str(err2))
return False
# Depreciate this!!! Same as self.logger.info(), but function is always “log”
def log(self, p):
self.logger.info(p)

class MethodMissingMixin(object):
“”” A Mixin’ to implement the ‘method_missing’ Ruby-like protocol. “””
def __getattribute__(self, attr):
try:
return object.__getattribute__(self, attr)
except:
class MethodMissing(object):
def __init__(self, wrapped, method):
self.__wrapped__ = wrapped
self.__method__ = method
def __call__(self, *args, **kwargs):
return self.__wrapped__.method_missing(self.__method__, *args, **kwargs)
return MethodMissing(self, attr)
def method_missing(self, *args, **kwargs):
“”” This method should be overridden in the derived class. “””
raise NotImplementedError(str(self.__wrapped__) + ” ‘method_missing’ method has not been implemented.”)

class postType(MethodMissingMixin):
def __init__(self):
“”
def setProxy(self, proxy):
self.proxy = weakref.ref(proxy)
# print name
def method_missing(self, method, *args, **kwargs):
list = []
list.append(method)
for arg in args:
list.append(arg)
result = 0
try:
p = self.proxy()
result = p.pythonPCall(list)
except RuntimeError,e:
raise e
return result

class ALProxy(inaoqi.proxy,MethodMissingMixin):
def __init__(self, *args):
self.post = postType()
self.post.setProxy(self)
if (len (args) == 1):
inaoqi.proxy.__init__(self, args[0])
elif (len (args) == 2):
inaoqi.proxy.__init__(self, args[0], args[1])
else:
inaoqi.proxy.__init__(self, args[0], args[1], args[2])
def call(self, *args):
list = []
for arg in args:
list.append(arg)
return self.pythonCall(list)

def pCall(self, *args):
list = []
for arg in args:
list.append(arg)
return self.pythonPCall(list)

def method_missing(self, method, *args, **kwargs):
list = []
list.append(method)
for arg in args:
list.append(arg)
result = 0
try:
result = self.pythonCall(list)
except RuntimeError,e:
raise e
#print e.args[0]
return result
@staticmethod
def initProxies():
#Warning: The use of these default proxies is deprecated.
global ALMemory
global ALMotion
global ALFrameManager
global ALLeds
global ALLogger
global ALSensors
try:
ALMemory = inaoqi.getMemoryProxy()
except:
ALMemory = ALProxy(“ALMemory”)
try:
ALFrameManager = ALProxy(“ALFrameManager”)
except:
print “No proxy to ALFrameManager”
try:
ALMotion = ALProxy(“ALMotion”)
except:
print “No proxy to ALMotion”
try:
ALLeds = ALProxy(“ALLeds”)
except:
pass
try:
ALLogger = ALProxy(“ALLogger”)
except:
print “No proxy to ALLogger”
try:
ALSensors = ALProxy(“ALSensors”)
except:
pass

def createModule(name):
global moduleList
str = “moduleList.append(“+ “module(\”” + name + “\”))”
exec(str)

pynaoqi-python-2.7-naoqi-1.14-mac64/license.rtf

End-
User Software License Agreement

This Limited End-User Software License Agreement (the “Agreement”) is a legal agreement between you (“Licensee”), the end-user, and Aldebaran Robotics SAS having its registered office at 168-170 Rue Raymond Losserand, 75014 Paris, France, registered with the trade and companies register of Paris under number 483 185 807 (hereinafter “Aldebaran”) for the use of the ” Aldebaran Software Toolkit ” (“Software”). By using this software or storing this program on a computer or robot hard drive (or other media), you are agreeing to be bound by the terms of this Agreement. If you do not agree to any of the terms of this agreement uninstall and delete the software from all storage media.

ARTICLE 1 – RIGHTS GRANTED

ALDEBARAN grants to the LICENSEE a personal, non-exclusive, non-transferable, non sub-licensable right to install and use the Software and the Documentation (if any), for the duration of the applicable intellectual property rights.

ALDEBARAN shall have the right to make update and/or upgrade of the Software. However this Agreement does not grant any right on any update or upgrade of the Software. In the event ALDEBARAN provided an upgrade or upgrade of the Software which is not used by Licensee will not benefit from warranties given by ALDABARAN within this Agreement (as far as permitted by the applicable law).

ALDEBARAN may discontinue or change the Software, at any time or for any reason, with or without notice. To avoid any misunderstanding it is agreed that ALDEBARAN has no right to operate a change on the LICENSEE‘s device where the Software is install without its consent.

This Agreement does not grant any right to any Third-Party Software.

Some Third-Party Software may be needed to permit the Software to operate properly. Even in such event ALDEBARAN is not granting any right on the Third-Party Software. The Third-Party Software remains subject to the specific licenses applicable to each Third-Party Software and as described in their related applicable documentation. Licensee shall on his owns decide to either accept or not the applicable terms and conditions related to Third-Party Software. Licensee accepts and understands that refusing the terms and conditions applicable to Third-Party Software may impact in whole or in part the use of the Software.

ARTICLE 2 – OBLIGATIONS OF THE LICENSEE

LICENSEE agrees to the following:

– The LICENSEE shall strictly comply with the user instructions set forth in the Documentation;

– Even if LICENSEE keeps its right of objectively critic the Software, the LICENSEE shall not take any action to impair the reputation of the Product, the trademarks of ALDEBARAN or its licensors and any other product of ALDEBARAN or its licensors;

– LICENSEE shall in no event use the Software for any illegal, defaming, pornographic or detrimental activities;

– The LICENSEE shall use the ALDEBARAN name and trademarks only in the manner prescribed by ALDEBARAN in writing;

– The LICENSEE shall inform ALDEBARAN of any potential defects discovered when using the Product;

– The LICENSEE shall notify ALDEBARAN promptly of any legal notices, claims or actions directly or indirectly relating to the Software against a third party and not enter into or compromise any legal action or other proceeding relating to the Software without the prior written consent of ALDEBARAN;

– The LICENSEE shall not use, without the prior written consent of ALDEBARAN, the Software for the benefit of third parties in any manner, and in particular:

(a) not sell, resell, lease, transfer, license or sublicense or otherwise provide the Software to any third party, and, in a more general manner, not communicate all or part of the Software to any third party;

(b) not charge or otherwise deal in or encumber the Software;

– The LICENSEE shall not delete, remove or in any way obscure the proprietary notices, labels or marks of ALDEBARAN or its licensors on the Software and conspicuously display the proprietary notices, labels or marks on any copy of the Software;

– Except otherwise expressly agreed the LICENSEE shall not alter, modify, decompile, disassemble, or reverse engineer the program code or any other part of the Software, in whole or in part, except in the events and only to the extent expressly provided by law. However, even if the law authorizes the above acts, LICENSEE shall give ALDEBARAN a written notice seven (7) calendar days prior to the date on which these acts are scheduled to take place and allow a representative of ALDEBARAN to be present during these acts;

– Except otherwise expressly agreed the LICENSEE shall not develop any other software programs or derivative works on the basis of the Software. Any such software program or derivative work shall in no case be sold, assigned or licensed by the LICENSEE;

– To avoid any misunderstanding it is agreed that LICENSEE shall have the right to use and exploit the result given by the use of the software in conformity of this license agreement.

– The LICENSEE shall not use the Software for illegal purposes or in illegal manner, including in violation of the intellectual property rights of ALDEBARAN or any third party;

– The LICENSEE shall provide ALDEBARAN promptly with any information, material, software or specification as may reasonably be required for the proper performance of this Agreement including access to appropriate members of the LICENSEE’s staff. The LICENSEE is responsible for the completeness and accuracy of such information, material, software or specification;

ARTICLE 3 – LIMITED WARRANTIES AND LIMITATION OF LIABILITY

3.1 ALDEBARAN warrants that it has full title and ownership to the Software. ALDEBARAN also warrants that it has the full power and authority to enter into this agreement and to grant the license conveyed in this Agreement. Aldebaran warrants that the use of the Software in conformity with this Agreement will in no way constitute an infringement or other violation of any Intellectual Property of any third party.
Should the Software give rise, or in ALDEBARAN opinion be likely to give rise to any such claim, ALDEBARAN shall, at its option and expense, either:

(i) procure for LICENSEE the right to continue using such Aldebaran Software; or
(ii) replace or modify the Aldebaran Software so that it does not infringe the intellectual property rights anymore; or
(iii) terminate the right of use of the Software.

Except as set out in this Agreement, all conditions, warranties and representations in relation to the Software are excluded to the extent permitted under applicable law.

3.2 AS FAR AS PERMITTED BY THE APPLICABLE LAW:

ALDEBARAN PROVIDES THE SOFTWARE “AS IS”, AND DOES NOT WARRANT THAT THE USE OF THE SOFTWARE, FUNCTIONALITY, THE OPERATION AND/OR CONTENT WILL BE: UNINTERRUPTED, ACCURATE, COMPLETE, FREE FROM ANY SOFTWARE VIRUS OR OTHER HARMFUL COMPONENT.

ALDEBARAN DOES NOT WARRANT THE INTERNAL CHARACTERISTICS, THE COMPATIBILITY FO THE SOFTWARE WITH OTHER SOFTWARE, THE ACCURACY, ADEQUACY, OR COMPLETENESS OF SOTWARE AND ITS RESULT AND DISCLAIMS LIABILITY FOR ERRORS OR OMISSIONS.

ALDEBARAN DISCLAIMS ANY REPRESENTATIONS, WARRANTIES OR CONDITIONS, EXPRESS OR IMPLIED, INCLUDING THOSE OF PERFORMANCE OR MERCHANTABILITY OR RELIABILITY USEFULNESS OR FITNESS FOR A PARTICULAR PURPOSE WITH RESPECT TO THE SOFTWARE AND ITS RESULTS.

3.3 IN NO EVENT WILL ALDEBARAN BE LIABLE FOR ANY DAMAGES (INCLUDING WITHOUT LIMITATION DIRECT, INDIRECT, PUNITIVE, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES, COST OF PROCURING SUBSTITUTE SERVICES, LOST PROFITS, LOSS OF DATA, LOSSES, OR OTHER EXPENSES) ARISING IN CONNECTION WITH THE PROVISION OR USE OF THE SOFTWARE, RELATED SERVICES OR INFORMATION PROVIDED PURSUANT TO THIS AGREEMENT, REGARDLESS OF WHETHER SUCH CLAIMS ARE BASED ON CONTRACT, TORT, STRICT LIABILITY, OR OTHERWISE, OR WHETHER PROVIDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES, LOSSES, OR EXPENSES.

WITHOUT LIMITING THE FOREGOING, THIS LIMITATION OF LIABILITY INCLUDES, BUT IS NOT LIMITED TO, THE UNAVAILABILITY OF THE APPLICATION(S), UNAUTHORIZED ACCESS, ANY FAILURE OF PERFORMANCE, INTERRUPTION, ERROR, OMISSION, DEFECT, DELAY IN OPERATION OR TRANSMISSION, COMPUTER VIRUS, OR SYSTEM FAILURE.

NOTWITHSTANDING ANYTHING TO THE CONTRARY IN THIS AGREEMENT OR ANY STATUTE OR RULE OF LAW TO THE CONTRARY, SUBJECT TO THIS ARTICLE, ALDEBARAN’S CUMULATIVE LIABILITY FOR ALL CLAIMS ARISING OUT OF OR IN CONNECTION WITH THIS AGREEMENT, WHETHER DIRECTLY OR INDIRECTLY, SHALL NOT EXCEED ALL FEES PAID TO ALDEBARAN BY THE LICENSEE FOR THE USE OF THE SOFTWARE. IN THE EVENT THE SOFTWARE IS GRANTED FOR FREE TO THE LICENSEE, ALDEBARAN’S CUMULATIVE LIABILITY FOR ALL CLAIMS ARISING OUT OF OR IN CONNECTION WITH THIS AGREEMENT, WHETHER DIRECTLY OR INDIRECTLY, SHALL NOT EXCEED 100 € (ONE HUNDRED EUROS).

WHENEVER THE ABOVE SECTIONS ARE NOT APPLICABLE UNDER THE APPLYING LAW ALDEBARAN AS SOLE REMEDY SHALL AT ITS OPTION AND EXPENSE EITHER (I) REPAIR THE DEFECTIVE OR INFRINGING SOFTWARE, OR (II) REPLACE THE DEFECTIVE OR INFRINGING SOFTWARE, OR (III) REIMBURSE THE FEE PAID TO ALDEBARAN FOR THE DEFECTIVE OR INFRINGING SOFTWARE. THESE REMEDIES ARE EXCLUSIVE OF ANY OTHER REMEDIES AND ANY OTHER WARRANTY IS EXCLUDED.

ANY INDEMNIFICATION BY ALDEBARAN UNDER THIS WARRANTY IS EXCLUDED IF THE CLAIM IS BASED UPON (I) A MODIFIED VERSION OF THE SOFTWARE FOR WHICH THE CHANGES HAVE NOT BEEN EXPRESSLY AUTHORIZED OR VALIDATED BY ALDEBARAN, OR (II) A COMBINATION, INSTALLATION OR USE OF ANY SOFTWARE COMPONENT EMBEDDED IN THE NAO ROBOT WITH ANY OTHER ELEMENT, MATERIAL OR ITEM THAT IS NOT EXPRESSLY PROVIDED BY ALDEBARAN FOR COMBINATION, INSTALLATION OR USE WITH THE SOFTWARE,
OR (III) A COMBINATION, INSTALLATION OR USE OF THE SOFTWARE WITH ANY OTHER ELEMENT, MATERIAL OR ITEM THAT IS NOT EXPRESSLY AUTHORIZED BY ALDEBARAN FOR COMBINATION, INSTALLATION OR USE WITH THE SOFTWARE, OR (IV) ANY OTHER FAULT OR NEGLIGENCE OF LICENSEE OR A THIRD PARTY.

This warranty does not cover incorrect installation or use by any third party; misuse of the Software voids the warranty.
The Third-Party Software is warranted only as provided in the specific licenses applicable to each.

ARTICLE 4 – INTELLECTUAL PROPERTY

ALDEBARAN is the owner or licensee of the Software. Title, copyright and any other proprietary and intellectual property right in the Software shall remain vested in ALDEBARAN or its licensors. The rights granted to the LICENSEE under this Agreement do not transfer to the LICENSEE title or any proprietary or intellectual property rights to the Software and do not constitute a sale of such rights;

ALDEBARAN shall retain the ownership of all rights in any inventions, discoveries, improvements, ideas, techniques or know-how embodied conceived by ALDEBARAN under this Agreement, including, without limitation, its methods of work, programs, methodologies and related documentation, including any derivative works of software code developed by ALDEBARAN in the course of performing this Agreement as well any knowledge and experience of ALDEBARAN’s directors, staff and consultants.

ARTICLE 5
–

COLLECTION AND USE OF PERSONAL INFORMATION

Privacy of the Licensee is important to ALDEBARAN. Therefore ALDEBARAN is not collecting any personal data except as expressly agreed by the Licensee.

ALDEBARAN will abide any applicable law, rules, or regulations relating to the privacy of personal information. Such data shall only be used for the purposes for which it was provided. Licensee understands that Third Party software may have their own privacy policy which may be less secure than the Aldebaran’s privacy policy.

ALDEBARAN will do its best to ensure that any personal data which may be collected from the Licensee will remain confidential.

Licensee hereby agrees and consents that the following data maybe collected by ALDEBARAN in order permit a network-enhanced services, improve the general quality and/or functionality of its products and/or software, permit development of new version of its products and/or software, fix bug or defect, develop patch and other solution, permit to install new version, update or upgrade, monitor and/or permit the maintenance of Aldebaran products and/or software:
Crash reporting, robot ID, robot health metrics, hardware-specific preferences, application install history, user preferences.

Licensee expressly consents that Aldebaran may generate statistical data from the information provided through the Software without identifying Licensee.
Licensee understands and agrees that, within the course of the use of the software, some voice data and/or video data could transit through ALDEBARAN and/or other third party network.

ARTICLE 6 – NO TRANSFER OR ASSIGNMENT

In no event shall LICENSEE sublicense, assign or otherwise transfer all or part of its rights and obligations under this Agreement to any third party. Any such sublicensing, assignment or transfer shall be null and void, unless expressly agreed to by ALDEBARAN in writing.

ARTICLE 7 – MISCELLEANEOUS

Termination. Either party may terminate this Agreement without advance notice. In case of breach of this Agreement by the Licensee, the authorization to access and use the Software will automatically terminate absent Aldebaran’s written waiver of such breach.

Survival. To the extent applicable, the following articles shall survive the termination, cancellation, expiration, and/or rescission of this Agreement: Articles 3.3, 4, 5, 7 and any provision that expressly states its survival and/or are necessary for the enforcement of this Agreement.

Headings. The headings referred to or used in this Agreement are for reference and convenience purposes only and shall not in any way limit or affect the meaning or interpretation of any of the terms hereof.

Severability. If any of the provisions of this Agreement are held or deemed to be invalid, illegal or unenforceable, the remaining provisions of this Agreement shall be unimpaired, and the invalid, illegal or unenforceable provision shall be replaced by a mutually acceptable provision, which being valid, legal and enforceable, comes closest to the intention of the Parties underlying the invalid, illegal or unenforceable provision.

Waiver. Any failure or delay by either Party in exercising its right under any provisions of the Agreement shall not be construed as a waiver of those rights at any time now or in the future unless an express declaration in writing from the Party concerned.

Governing law and Jurisdiction. Parties agree that all matters arising from or relating to the Software and this Agreement, shall be governed by the laws of France, without regard to conflict of laws principles. In the event of any dispute between the Parties, the Parties agreed to meet to discuss their dispute before resorting to formal dispute resolution procedures.

BY CLICKING “AGREE”, YOU AS LICENSEE ACKNOWLEDGE THAT YOU HAVE READ, UNDERSTAND AND ACCEPT THIS LIMITED END-USER SOFTWARE LICENSE AGREEMENT.

BY CLICKING “AGREE” YOU AS LICENSEE AGREE TO BE BOUND BY ALL OF ITS TERMS AND CONDITIONS OF THIS LIMITED END-USER SOFTWARE LICENSE AGREEMENT.

IF YOU AS A LICENSEE DO NOT AGREE TO ANY TERMS AND CONDITIONS, OF THIS LIMITED END-USER SOFTWARE LICENSE AGREEMENT DO NOT INSTALL OR USE THE SOFTWARE AND CLICK ON “DISAGREE”. By CLICKING ON “DESAGREE” YOU WILL NOT BE ABLE TO USE THE SOFTWARE.

pynaoqi-python-2.7-naoqi-1.14-mac64/allog.py
# This file was automatically generated by SWIG (http://www.swig.org).
# Version 1.3.31
#
# Don’t modify this file, modify the SWIG interface instead.
# This file is compatible with both classic and new-style classes.
import _allog
import new
new_instancemethod = new.instancemethod
try:
_swig_property = property
except NameError:
pass # Python < 2.2 doesn't have 'property'. 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

debug = _allog.debug
info = _allog.info
warning = _allog.warning
error = _allog.error
fatal = _allog.fatal

pynaoqi-python-2.7-naoqi-1.14-mac64/almath.py
# This file was automatically generated by SWIG (http://www.swig.org).
# Version 1.3.31
#
# Don’t modify this file, modify the SWIG interface instead.
# This file is compatible with both classic and new-style classes.
import _almath
import new
new_instancemethod = new.instancemethod
try:
_swig_property = property
except NameError:
pass # Python < 2.2 doesn't have 'property'. 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

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__ = _almath.delete_PySwigIterator
__del__ = lambda self : None;
def value(*args):
“””value(self) -> PyObject”””
return _almath.PySwigIterator_value(*args)
def incr(*args):
“””
incr(self, size_t n=1) -> PySwigIterator
incr(self) -> PySwigIterator
“””
return _almath.PySwigIterator_incr(*args)
def decr(*args):
“””
decr(self, size_t n=1) -> PySwigIterator
decr(self) -> PySwigIterator
“””
return _almath.PySwigIterator_decr(*args)
def distance(*args):
“””distance(self, PySwigIterator x) -> ptrdiff_t”””
return _almath.PySwigIterator_distance(*args)
def equal(*args):
“””equal(self, PySwigIterator x) -> bool”””
return _almath.PySwigIterator_equal(*args)
def copy(*args):
“””copy(self) -> PySwigIterator”””
return _almath.PySwigIterator_copy(*args)
def next(*args):
“””next(self) -> PyObject”””
return _almath.PySwigIterator_next(*args)
def previous(*args):
“””previous(self) -> PyObject”””
return _almath.PySwigIterator_previous(*args)
def advance(*args):
“””advance(self, ptrdiff_t n) -> PySwigIterator”””
return _almath.PySwigIterator_advance(*args)
def __eq__(*args):
“””__eq__(self, PySwigIterator x) -> bool”””
return _almath.PySwigIterator___eq__(*args)
def __ne__(*args):
“””__ne__(self, PySwigIterator x) -> bool”””
return _almath.PySwigIterator___ne__(*args)
def __iadd__(*args):
“””__iadd__(self, ptrdiff_t n) -> PySwigIterator”””
return _almath.PySwigIterator___iadd__(*args)
def __isub__(*args):
“””__isub__(self, ptrdiff_t n) -> PySwigIterator”””
return _almath.PySwigIterator___isub__(*args)
def __add__(*args):
“””__add__(self, ptrdiff_t n) -> PySwigIterator”””
return _almath.PySwigIterator___add__(*args)
def __sub__(*args):
“””
__sub__(self, ptrdiff_t n) -> PySwigIterator
__sub__(self, PySwigIterator x) -> ptrdiff_t
“””
return _almath.PySwigIterator___sub__(*args)
def __iter__(self): return self
PySwigIterator_swigregister = _almath.PySwigIterator_swigregister
PySwigIterator_swigregister(PySwigIterator)
class vectorFloat(_object):
“””Proxy of C++ vectorFloat class”””
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, vectorFloat, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, vectorFloat, name)
def iterator(*args):
“””iterator(self, PyObject PYTHON_SELF) -> PySwigIterator”””
return _almath.vectorFloat_iterator(*args)
def __iter__(self): return self.iterator()
def __nonzero__(*args):
“””__nonzero__(self) -> bool”””
return _almath.vectorFloat___nonzero__(*args)
def __len__(*args):
“””__len__(self) -> size_type”””
return _almath.vectorFloat___len__(*args)
def pop(*args):
“””pop(self) -> value_type”””
return _almath.vectorFloat_pop(*args)
def __getslice__(*args):
“””__getslice__(self, difference_type i, difference_type j) -> vectorFloat”””
return _almath.vectorFloat___getslice__(*args)
def __setslice__(*args):
“””__setslice__(self, difference_type i, difference_type j, vectorFloat v)”””
return _almath.vectorFloat___setslice__(*args)
def __delslice__(*args):
“””__delslice__(self, difference_type i, difference_type j)”””
return _almath.vectorFloat___delslice__(*args)
def __delitem__(*args):
“””__delitem__(self, difference_type i)”””
return _almath.vectorFloat___delitem__(*args)
def __getitem__(*args):
“””__getitem__(self, difference_type i) -> value_type”””
return _almath.vectorFloat___getitem__(*args)
def __setitem__(*args):
“””__setitem__(self, difference_type i, value_type x)”””
return _almath.vectorFloat___setitem__(*args)
def append(*args):
“””append(self, value_type x)”””
return _almath.vectorFloat_append(*args)
def empty(*args):
“””empty(self) -> bool”””
return _almath.vectorFloat_empty(*args)
def size(*args):
“””size(self) -> size_type”””
return _almath.vectorFloat_size(*args)
def clear(*args):
“””clear(self)”””
return _almath.vectorFloat_clear(*args)
def swap(*args):
“””swap(self, vectorFloat v)”””
return _almath.vectorFloat_swap(*args)
def get_allocator(*args):
“””get_allocator(self) -> allocator_type”””
return _almath.vectorFloat_get_allocator(*args)
def begin(*args):
“””
begin(self) -> iterator
begin(self) -> const_iterator
“””
return _almath.vectorFloat_begin(*args)
def end(*args):
“””
end(self) -> iterator
end(self) -> const_iterator
“””
return _almath.vectorFloat_end(*args)
def rbegin(*args):
“””
rbegin(self) -> reverse_iterator
rbegin(self) -> const_reverse_iterator
“””
return _almath.vectorFloat_rbegin(*args)
def rend(*args):
“””
rend(self) -> reverse_iterator
rend(self) -> const_reverse_iterator
“””
return _almath.vectorFloat_rend(*args)
def pop_back(*args):
“””pop_back(self)”””
return _almath.vectorFloat_pop_back(*args)
def erase(*args):
“””
erase(self, iterator pos) -> iterator
erase(self, iterator first, iterator last) -> iterator
“””
return _almath.vectorFloat_erase(*args)
def __init__(self, *args):
“””
__init__(self) -> vectorFloat
__init__(self, vectorFloat ?) -> vectorFloat
__init__(self, size_type size) -> vectorFloat
__init__(self, size_type size, value_type value) -> vectorFloat
“””
this = _almath.new_vectorFloat(*args)
try: self.this.append(this)
except: self.this = this
def push_back(*args):
“””push_back(self, value_type x)”””
return _almath.vectorFloat_push_back(*args)
def front(*args):
“””front(self) -> value_type”””
return _almath.vectorFloat_front(*args)
def back(*args):
“””back(self) -> value_type”””
return _almath.vectorFloat_back(*args)
def assign(*args):
“””assign(self, size_type n, value_type x)”””
return _almath.vectorFloat_assign(*args)
def resize(*args):
“””
resize(self, size_type new_size)
resize(self, size_type new_size, value_type x)
“””
return _almath.vectorFloat_resize(*args)
def insert(*args):
“””
insert(self, iterator pos, value_type x) -> iterator
insert(self, iterator pos, size_type n, value_type x)
“””
return _almath.vectorFloat_insert(*args)
def reserve(*args):
“””reserve(self, size_type n)”””
return _almath.vectorFloat_reserve(*args)
def capacity(*args):
“””capacity(self) -> size_type”””
return _almath.vectorFloat_capacity(*args)
def __repr__(*args):
“””__repr__(self) -> string”””
return _almath.vectorFloat___repr__(*args)
__swig_destroy__ = _almath.delete_vectorFloat
__del__ = lambda self : None;
vectorFloat_swigregister = _almath.vectorFloat_swigregister
vectorFloat_swigregister(vectorFloat)
class vectorPosition2D(_object):
“””Proxy of C++ vectorPosition2D class”””
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, vectorPosition2D, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, vectorPosition2D, name)
def iterator(*args):
“””iterator(self, PyObject PYTHON_SELF) -> PySwigIterator”””
return _almath.vectorPosition2D_iterator(*args)
def __iter__(self): return self.iterator()
def __nonzero__(*args):
“””__nonzero__(self) -> bool”””
return _almath.vectorPosition2D___nonzero__(*args)
def __len__(*args):
“””__len__(self) -> size_type”””
return _almath.vectorPosition2D___len__(*args)
def pop(*args):
“””pop(self) -> value_type”””
return _almath.vectorPosition2D_pop(*args)
def __getslice__(*args):
“””__getslice__(self, difference_type i, difference_type j) -> vectorPosition2D”””
return _almath.vectorPosition2D___getslice__(*args)
def __setslice__(*args):
“””__setslice__(self, difference_type i, difference_type j, vectorPosition2D v)”””
return _almath.vectorPosition2D___setslice__(*args)
def __delslice__(*args):
“””__delslice__(self, difference_type i, difference_type j)”””
return _almath.vectorPosition2D___delslice__(*args)
def __delitem__(*args):
“””__delitem__(self, difference_type i)”””
return _almath.vectorPosition2D___delitem__(*args)
def __getitem__(*args):
“””__getitem__(self, difference_type i) -> value_type”””
return _almath.vectorPosition2D___getitem__(*args)
def __setitem__(*args):
“””__setitem__(self, difference_type i, value_type x)”””
return _almath.vectorPosition2D___setitem__(*args)
def append(*args):
“””append(self, value_type x)”””
return _almath.vectorPosition2D_append(*args)
def empty(*args):
“””empty(self) -> bool”””
return _almath.vectorPosition2D_empty(*args)
def size(*args):
“””size(self) -> size_type”””
return _almath.vectorPosition2D_size(*args)
def clear(*args):
“””clear(self)”””
return _almath.vectorPosition2D_clear(*args)
def swap(*args):
“””swap(self, vectorPosition2D v)”””
return _almath.vectorPosition2D_swap(*args)
def get_allocator(*args):
“””get_allocator(self) -> allocator_type”””
return _almath.vectorPosition2D_get_allocator(*args)
def begin(*args):
“””
begin(self) -> iterator
begin(self) -> const_iterator
“””
return _almath.vectorPosition2D_begin(*args)
def end(*args):
“””
end(self) -> iterator
end(self) -> const_iterator
“””
return _almath.vectorPosition2D_end(*args)
def rbegin(*args):
“””
rbegin(self) -> reverse_iterator
rbegin(self) -> const_reverse_iterator
“””
return _almath.vectorPosition2D_rbegin(*args)
def rend(*args):
“””
rend(self) -> reverse_iterator
rend(self) -> const_reverse_iterator
“””
return _almath.vectorPosition2D_rend(*args)
def pop_back(*args):
“””pop_back(self)”””
return _almath.vectorPosition2D_pop_back(*args)
def erase(*args):
“””
erase(self, iterator pos) -> iterator
erase(self, iterator first, iterator last) -> iterator
“””
return _almath.vectorPosition2D_erase(*args)
def __init__(self, *args):
“””
__init__(self) -> vectorPosition2D
__init__(self, vectorPosition2D ?) -> vectorPosition2D
__init__(self, size_type size) -> vectorPosition2D
__init__(self, size_type size, value_type value) -> vectorPosition2D
“””
this = _almath.new_vectorPosition2D(*args)
try: self.this.append(this)
except: self.this = this
def push_back(*args):
“””push_back(self, value_type x)”””
return _almath.vectorPosition2D_push_back(*args)
def front(*args):
“””front(self) -> value_type”””
return _almath.vectorPosition2D_front(*args)
def back(*args):
“””back(self) -> value_type”””
return _almath.vectorPosition2D_back(*args)
def assign(*args):
“””assign(self, size_type n, value_type x)”””
return _almath.vectorPosition2D_assign(*args)
def resize(*args):
“””
resize(self, size_type new_size)
resize(self, size_type new_size, value_type x)
“””
return _almath.vectorPosition2D_resize(*args)
def insert(*args):
“””
insert(self, iterator pos, value_type x) -> iterator
insert(self, iterator pos, size_type n, value_type x)
“””
return _almath.vectorPosition2D_insert(*args)
def reserve(*args):
“””reserve(self, size_type n)”””
return _almath.vectorPosition2D_reserve(*args)
def capacity(*args):
“””capacity(self) -> size_type”””
return _almath.vectorPosition2D_capacity(*args)
def __repr__(*args):
“””__repr__(self) -> string”””
return _almath.vectorPosition2D___repr__(*args)
__swig_destroy__ = _almath.delete_vectorPosition2D
__del__ = lambda self : None;
vectorPosition2D_swigregister = _almath.vectorPosition2D_swigregister
vectorPosition2D_swigregister(vectorPosition2D)
class vectorPose2D(_object):
“””Proxy of C++ vectorPose2D class”””
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, vectorPose2D, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, vectorPose2D, name)
def iterator(*args):
“””iterator(self, PyObject PYTHON_SELF) -> PySwigIterator”””
return _almath.vectorPose2D_iterator(*args)
def __iter__(self): return self.iterator()
def __nonzero__(*args):
“””__nonzero__(self) -> bool”””
return _almath.vectorPose2D___nonzero__(*args)
def __len__(*args):
“””__len__(self) -> size_type”””
return _almath.vectorPose2D___len__(*args)
def pop(*args):
“””pop(self) -> value_type”””
return _almath.vectorPose2D_pop(*args)
def __getslice__(*args):
“””__getslice__(self, difference_type i, difference_type j) -> vectorPose2D”””
return _almath.vectorPose2D___getslice__(*args)
def __setslice__(*args):
“””__setslice__(self, difference_type i, difference_type j, vectorPose2D v)”””
return _almath.vectorPose2D___setslice__(*args)
def __delslice__(*args):
“””__delslice__(self, difference_type i, difference_type j)”””
return _almath.vectorPose2D___delslice__(*args)
def __delitem__(*args):
“””__delitem__(self, difference_type i)”””
return _almath.vectorPose2D___delitem__(*args)
def __getitem__(*args):
“””__getitem__(self, difference_type i) -> value_type”””
return _almath.vectorPose2D___getitem__(*args)
def __setitem__(*args):
“””__setitem__(self, difference_type i, value_type x)”””
return _almath.vectorPose2D___setitem__(*args)
def append(*args):
“””append(self, value_type x)”””
return _almath.vectorPose2D_append(*args)
def empty(*args):
“””empty(self) -> bool”””
return _almath.vectorPose2D_empty(*args)
def size(*args):
“””size(self) -> size_type”””
return _almath.vectorPose2D_size(*args)
def clear(*args):
“””clear(self)”””
return _almath.vectorPose2D_clear(*args)
def swap(*args):
“””swap(self, vectorPose2D v)”””
return _almath.vectorPose2D_swap(*args)
def get_allocator(*args):
“””get_allocator(self) -> allocator_type”””
return _almath.vectorPose2D_get_allocator(*args)
def begin(*args):
“””
begin(self) -> iterator
begin(self) -> const_iterator
“””
return _almath.vectorPose2D_begin(*args)
def end(*args):
“””
end(self) -> iterator
end(self) -> const_iterator
“””
return _almath.vectorPose2D_end(*args)
def rbegin(*args):
“””
rbegin(self) -> reverse_iterator
rbegin(self) -> const_reverse_iterator
“””
return _almath.vectorPose2D_rbegin(*args)
def rend(*args):
“””
rend(self) -> reverse_iterator
rend(self) -> const_reverse_iterator
“””
return _almath.vectorPose2D_rend(*args)
def pop_back(*args):
“””pop_back(self)”””
return _almath.vectorPose2D_pop_back(*args)
def erase(*args):
“””
erase(self, iterator pos) -> iterator
erase(self, iterator first, iterator last) -> iterator
“””
return _almath.vectorPose2D_erase(*args)
def __init__(self, *args):
“””
__init__(self) -> vectorPose2D
__init__(self, vectorPose2D ?) -> vectorPose2D
__init__(self, size_type size) -> vectorPose2D
__init__(self, size_type size, value_type value) -> vectorPose2D
“””
this = _almath.new_vectorPose2D(*args)
try: self.this.append(this)
except: self.this = this
def push_back(*args):
“””push_back(self, value_type x)”””
return _almath.vectorPose2D_push_back(*args)
def front(*args):
“””front(self) -> value_type”””
return _almath.vectorPose2D_front(*args)
def back(*args):
“””back(self) -> value_type”””
return _almath.vectorPose2D_back(*args)
def assign(*args):
“””assign(self, size_type n, value_type x)”””
return _almath.vectorPose2D_assign(*args)
def resize(*args):
“””
resize(self, size_type new_size)
resize(self, size_type new_size, value_type x)
“””
return _almath.vectorPose2D_resize(*args)
def insert(*args):
“””
insert(self, iterator pos, value_type x) -> iterator
insert(self, iterator pos, size_type n, value_type x)
“””
return _almath.vectorPose2D_insert(*args)
def reserve(*args):
“””reserve(self, size_type n)”””
return _almath.vectorPose2D_reserve(*args)
def capacity(*args):
“””capacity(self) -> size_type”””
return _almath.vectorPose2D_capacity(*args)
def __repr__(*args):
“””__repr__(self) -> string”””
return _almath.vectorPose2D___repr__(*args)
__swig_destroy__ = _almath.delete_vectorPose2D
__del__ = lambda self : None;
vectorPose2D_swigregister = _almath.vectorPose2D_swigregister
vectorPose2D_swigregister(vectorPose2D)
class vectorPosition6D(_object):
“””Proxy of C++ vectorPosition6D class”””
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, vectorPosition6D, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, vectorPosition6D, name)
def iterator(*args):
“””iterator(self, PyObject PYTHON_SELF) -> PySwigIterator”””
return _almath.vectorPosition6D_iterator(*args)
def __iter__(self): return self.iterator()
def __nonzero__(*args):
“””__nonzero__(self) -> bool”””
return _almath.vectorPosition6D___nonzero__(*args)
def __len__(*args):
“””__len__(self) -> size_type”””
return _almath.vectorPosition6D___len__(*args)
def pop(*args):
“””pop(self) -> value_type”””
return _almath.vectorPosition6D_pop(*args)
def __getslice__(*args):
“””__getslice__(self, difference_type i, difference_type j) -> vectorPosition6D”””
return _almath.vectorPosition6D___getslice__(*args)
def __setslice__(*args):
“””__setslice__(self, difference_type i, difference_type j, vectorPosition6D v)”””
return _almath.vectorPosition6D___setslice__(*args)
def __delslice__(*args):
“””__delslice__(self, difference_type i, difference_type j)”””
return _almath.vectorPosition6D___delslice__(*args)
def __delitem__(*args):
“””__delitem__(self, difference_type i)”””
return _almath.vectorPosition6D___delitem__(*args)
def __getitem__(*args):
“””__getitem__(self, difference_type i) -> value_type”””
return _almath.vectorPosition6D___getitem__(*args)
def __setitem__(*args):
“””__setitem__(self, difference_type i, value_type x)”””
return _almath.vectorPosition6D___setitem__(*args)
def append(*args):
“””append(self, value_type x)”””
return _almath.vectorPosition6D_append(*args)
def empty(*args):
“””empty(self) -> bool”””
return _almath.vectorPosition6D_empty(*args)
def size(*args):
“””size(self) -> size_type”””
return _almath.vectorPosition6D_size(*args)
def clear(*args):
“””clear(self)”””
return _almath.vectorPosition6D_clear(*args)
def swap(*args):
“””swap(self, vectorPosition6D v)”””
return _almath.vectorPosition6D_swap(*args)
def get_allocator(*args):
“””get_allocator(self) -> allocator_type”””
return _almath.vectorPosition6D_get_allocator(*args)
def begin(*args):
“””
begin(self) -> iterator
begin(self) -> const_iterator
“””
return _almath.vectorPosition6D_begin(*args)
def end(*args):
“””
end(self) -> iterator
end(self) -> const_iterator
“””
return _almath.vectorPosition6D_end(*args)
def rbegin(*args):
“””
rbegin(self) -> reverse_iterator
rbegin(self) -> const_reverse_iterator
“””
return _almath.vectorPosition6D_rbegin(*args)
def rend(*args):
“””
rend(self) -> reverse_iterator
rend(self) -> const_reverse_iterator
“””
return _almath.vectorPosition6D_rend(*args)
def pop_back(*args):
“””pop_back(self)”””
return _almath.vectorPosition6D_pop_back(*args)
def erase(*args):
“””
erase(self, iterator pos) -> iterator
erase(self, iterator first, iterator last) -> iterator
“””
return _almath.vectorPosition6D_erase(*args)
def __init__(self, *args):
“””
__init__(self) -> vectorPosition6D
__init__(self, vectorPosition6D ?) -> vectorPosition6D
__init__(self, size_type size) -> vectorPosition6D
__init__(self, size_type size, value_type value) -> vectorPosition6D
“””
this = _almath.new_vectorPosition6D(*args)
try: self.this.append(this)
except: self.this = this
def push_back(*args):
“””push_back(self, value_type x)”””
return _almath.vectorPosition6D_push_back(*args)
def front(*args):
“””front(self) -> value_type”””
return _almath.vectorPosition6D_front(*args)
def back(*args):
“””back(self) -> value_type”””
return _almath.vectorPosition6D_back(*args)
def assign(*args):
“””assign(self, size_type n, value_type x)”””
return _almath.vectorPosition6D_assign(*args)
def resize(*args):
“””
resize(self, size_type new_size)
resize(self, size_type new_size, value_type x)
“””
return _almath.vectorPosition6D_resize(*args)
def insert(*args):
“””
insert(self, iterator pos, value_type x) -> iterator
insert(self, iterator pos, size_type n, value_type x)
“””
return _almath.vectorPosition6D_insert(*args)
def reserve(*args):
“””reserve(self, size_type n)”””
return _almath.vectorPosition6D_reserve(*args)
def capacity(*args):
“””capacity(self) -> size_type”””
return _almath.vectorPosition6D_capacity(*args)
def __repr__(*args):
“””__repr__(self) -> string”””
return _almath.vectorPosition6D___repr__(*args)
__swig_destroy__ = _almath.delete_vectorPosition6D
__del__ = lambda self : None;
vectorPosition6D_swigregister = _almath.vectorPosition6D_swigregister
vectorPosition6D_swigregister(vectorPosition6D)
class Pose2D(_object):
“””Proxy of C++ Pose2D class”””
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, Pose2D, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, Pose2D, name)
__swig_setmethods__[“x”] = _almath.Pose2D_x_set
__swig_getmethods__[“x”] = _almath.Pose2D_x_get
if _newclass:x = _swig_property(_almath.Pose2D_x_get, _almath.Pose2D_x_set)
__swig_setmethods__[“y”] = _almath.Pose2D_y_set
__swig_getmethods__[“y”] = _almath.Pose2D_y_get
if _newclass:y = _swig_property(_almath.Pose2D_y_get, _almath.Pose2D_y_set)
__swig_setmethods__[“theta”] = _almath.Pose2D_theta_set
__swig_getmethods__[“theta”] = _almath.Pose2D_theta_get
if _newclass:theta = _swig_property(_almath.Pose2D_theta_get, _almath.Pose2D_theta_set)
def __init__(self, *args):
“””
__init__(self) -> Pose2D
__init__(self, float pInit) -> Pose2D
__init__(self, float pX, float pY, float pTheta) -> Pose2D
__init__(self, vectorFloat pFloats) -> Pose2D
“””
this = _almath.new_Pose2D(*args)
try: self.this.append(this)
except: self.this = this
def __add__(*args):
“””__add__(self, Pose2D pPos2) -> Pose2D”””
return _almath.Pose2D___add__(*args)
def __sub__(*args):
“””__sub__(self, Pose2D pPos2) -> Pose2D”””
return _almath.Pose2D___sub__(*args)
def __pos__(*args):
“””__pos__(self) -> Pose2D”””
return _almath.Pose2D___pos__(*args)
def __neg__(*args):
“””__neg__(self) -> Pose2D”””
return _almath.Pose2D___neg__(*args)
def __iadd__(*args):
“””__iadd__(self, Pose2D pPos2) -> Pose2D”””
return _almath.Pose2D___iadd__(*args)
def __isub__(*args):
“””__isub__(self, Pose2D pPos2) -> Pose2D”””
return _almath.Pose2D___isub__(*args)
def __eq__(*args):
“””__eq__(self, Pose2D pPos2) -> bool”””
return _almath.Pose2D___eq__(*args)
def __ne__(*args):
“””__ne__(self, Pose2D pPos2) -> bool”””
return _almath.Pose2D___ne__(*args)
def __mul__(*args):
“””
__mul__(self, Pose2D pPos2) -> Pose2D
__mul__(self, float pVal) -> Pose2D
“””
return _almath.Pose2D___mul__(*args)
def __div__(*args):
“””__div__(self, float pVal) -> Pose2D”””
return _almath.Pose2D___div__(*args)
def __imul__(*args):
“””
__imul__(self, Pose2D pPos2) -> Pose2D
__imul__(self, float pVal) -> Pose2D
“””
return _almath.Pose2D___imul__(*args)
def __idiv__(*args):
“””__idiv__(self, float pVal) -> Pose2D”””
return _almath.Pose2D___idiv__(*args)
def distanceSquared(*args):
“””distanceSquared(self, Pose2D pPos2) -> float”””
return _almath.Pose2D_distanceSquared(*args)
def distance(*args):
“””distance(self, Pose2D pPos2) -> float”””
return _almath.Pose2D_distance(*args)
def inverse(*args):
“””inverse(self) -> Pose2D”””
return _almath.Pose2D_inverse(*args)
def isNear(*args):
“””
isNear(self, Pose2D pPos2, float pEpsilon=0.0001f) -> bool
isNear(self, Pose2D pPos2) -> bool
“””
return _almath.Pose2D_isNear(*args)
def toVector(*args):
“””toVector(self) -> vectorFloat”””
return _almath.Pose2D_toVector(*args)
def __repr__(*args):
“””__repr__(self) -> char”””
return _almath.Pose2D___repr__(*args)
def __rmul__(*args):
“””__rmul__(self, float lhs) -> Pose2D”””
return _almath.Pose2D___rmul__(*args)
__swig_destroy__ = _almath.delete_Pose2D
__del__ = lambda self : None;
Pose2D_swigregister = _almath.Pose2D_swigregister
Pose2D_swigregister(Pose2D)
cvar = _almath.cvar
AXIS_MASK_X = cvar.AXIS_MASK_X
AXIS_MASK_Y = cvar.AXIS_MASK_Y
AXIS_MASK_XY = cvar.AXIS_MASK_XY
AXIS_MASK_Z = cvar.AXIS_MASK_Z
AXIS_MASK_WX = cvar.AXIS_MASK_WX
AXIS_MASK_WY = cvar.AXIS_MASK_WY
AXIS_MASK_WZ = cvar.AXIS_MASK_WZ
AXIS_MASK_WYWZ = cvar.AXIS_MASK_WYWZ
AXIS_MASK_ALL = cvar.AXIS_MASK_ALL
AXIS_MASK_VEL = cvar.AXIS_MASK_VEL
AXIS_MASK_ROT = cvar.AXIS_MASK_ROT
AXIS_MASK_NONE = cvar.AXIS_MASK_NONE
class Position2D(_object):
“””Proxy of C++ Position2D class”””
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, Position2D, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, Position2D, name)
__swig_setmethods__[“x”] = _almath.Position2D_x_set
__swig_getmethods__[“x”] = _almath.Position2D_x_get
if _newclass:x = _swig_property(_almath.Position2D_x_get, _almath.Position2D_x_set)
__swig_setmethods__[“y”] = _almath.Position2D_y_set
__swig_getmethods__[“y”] = _almath.Position2D_y_get
if _newclass:y = _swig_property(_almath.Position2D_y_get, _almath.Position2D_y_set)
def __init__(self, *args):
“””
__init__(self) -> Position2D
__init__(self, float pInit) -> Position2D
__init__(self, float pX, float pY) -> Position2D
__init__(self, vectorFloat pFloats) -> Position2D
“””
this = _almath.new_Position2D(*args)
try: self.this.append(this)
except: self.this = this
def __add__(*args):
“””__add__(self, Position2D pPos2) -> Position2D”””
return _almath.Position2D___add__(*args)
def __sub__(*args):
“””__sub__(self, Position2D pPos2) -> Position2D”””
return _almath.Position2D___sub__(*args)
def __pos__(*args):
“””__pos__(self) -> Position2D”””
return _almath.Position2D___pos__(*args)
def __neg__(*args):
“””__neg__(self) -> Position2D”””
return _almath.Position2D___neg__(*args)
def __iadd__(*args):
“””__iadd__(self, Position2D pPos2) -> Position2D”””
return _almath.Position2D___iadd__(*args)
def __isub__(*args):
“””__isub__(self, Position2D pPos2) -> Position2D”””
return _almath.Position2D___isub__(*args)
def __eq__(*args):
“””__eq__(self, Position2D pPos2) -> bool”””
return _almath.Position2D___eq__(*args)
def __ne__(*args):
“””__ne__(self, Position2D pPos2) -> bool”””
return _almath.Position2D___ne__(*args)
def __mul__(*args):
“””__mul__(self, float pVal) -> Position2D”””
return _almath.Position2D___mul__(*args)
def __div__(*args):
“””__div__(self, float pVal) -> Position2D”””
return _almath.Position2D___div__(*args)
def __imul__(*args):
“””__imul__(self, float pVal) -> Position2D”””
return _almath.Position2D___imul__(*args)
def __idiv__(*args):
“””__idiv__(self, float pVal) -> Position2D”””
return _almath.Position2D___idiv__(*args)
def distanceSquared(*args):
“””distanceSquared(self, Position2D pPos2) -> float”””
return _almath.Position2D_distanceSquared(*args)
def distance(*args):
“””distance(self, Position2D pPos2) -> float”””
return _almath.Position2D_distance(*args)
def isNear(*args):
“””
isNear(self, Position2D pPos2, float pEpsilon=0.0001f) -> bool
isNear(self, Position2D pPos2) -> bool
“””
return _almath.Position2D_isNear(*args)
def norm(*args):
“””norm(self) -> float”””
return _almath.Position2D_norm(*args)
def normalize(*args):
“””normalize(self) -> Position2D”””
return _almath.Position2D_normalize(*args)
def crossProduct(*args):
“””crossProduct(self, Position2D pPos2) -> float”””
return _almath.Position2D_crossProduct(*args)
def toVector(*args):
“””toVector(self) -> vectorFloat”””
return _almath.Position2D_toVector(*args)
def __repr__(*args):
“””__repr__(self) -> char”””
return _almath.Position2D___repr__(*args)
def __rmul__(*args):
“””__rmul__(self, float lhs) -> Position2D”””
return _almath.Position2D___rmul__(*args)
__swig_destroy__ = _almath.delete_Position2D
__del__ = lambda self : None;
Position2D_swigregister = _almath.Position2D_swigregister
Position2D_swigregister(Position2D)
def pose2DInverse(*args):
“””
pose2DInverse(Pose2D pPos) -> Pose2D
pose2DInverse(Pose2D pPos, Pose2D pRes)
“””
return _almath.pose2DInverse(*args)
class Position3D(_object):
“””Proxy of C++ Position3D class”””
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, Position3D, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, Position3D, name)
__swig_setmethods__[“x”] = _almath.Position3D_x_set
__swig_getmethods__[“x”] = _almath.Position3D_x_get
if _newclass:x = _swig_property(_almath.Position3D_x_get, _almath.Position3D_x_set)
__swig_setmethods__[“y”] = _almath.Position3D_y_set
__swig_getmethods__[“y”] = _almath.Position3D_y_get
if _newclass:y = _swig_property(_almath.Position3D_y_get, _almath.Position3D_y_set)
__swig_setmethods__[“z”] = _almath.Position3D_z_set
__swig_getmethods__[“z”] = _almath.Position3D_z_get
if _newclass:z = _swig_property(_almath.Position3D_z_get, _almath.Position3D_z_set)
def __init__(self, *args):
“””
__init__(self) -> Position3D
__init__(self, float pInit) -> Position3D
__init__(self, float pX, float pY, float pZ) -> Position3D
__init__(self, vectorFloat pFloats) -> Position3D
“””
this = _almath.new_Position3D(*args)
try: self.this.append(this)
except: self.this = this
def __add__(*args):
“””__add__(self, Position3D pPos2) -> Position3D”””
return _almath.Position3D___add__(*args)
def __sub__(*args):
“””__sub__(self, Position3D pPos2) -> Position3D”””
return _almath.Position3D___sub__(*args)
def __pos__(*args):
“””__pos__(self) -> Position3D”””
return _almath.Position3D___pos__(*args)
def __neg__(*args):
“””__neg__(self) -> Position3D”””
return _almath.Position3D___neg__(*args)
def __iadd__(*args):
“””__iadd__(self, Position3D pPos2) -> Position3D”””
return _almath.Position3D___iadd__(*args)
def __isub__(*args):
“””__isub__(self, Position3D pPos2) -> Position3D”””
return _almath.Position3D___isub__(*args)
def __eq__(*args):
“””__eq__(self, Position3D pPos2) -> bool”””
return _almath.Position3D___eq__(*args)
def __ne__(*args):
“””__ne__(self, Position3D pPos2) -> bool”””
return _almath.Position3D___ne__(*args)
def __mul__(*args):
“””__mul__(self, float pVal) -> Position3D”””
return _almath.Position3D___mul__(*args)
def __div__(*args):
“””__div__(self, float pVal) -> Position3D”””
return _almath.Position3D___div__(*args)
def __imul__(*args):
“””__imul__(self, float pVal) -> Position3D”””
return _almath.Position3D___imul__(*args)
def __idiv__(*args):
“””__idiv__(self, float pVal) -> Position3D”””
return _almath.Position3D___idiv__(*args)
def distanceSquared(*args):
“””distanceSquared(self, Position3D pPos2) -> float”””
return _almath.Position3D_distanceSquared(*args)
def distance(*args):
“””distance(self, Position3D pPos2) -> float”””
return _almath.Position3D_distance(*args)
def isNear(*args):
“””
isNear(self, Position3D pPos2, float pEpsilon=0.0001f) -> bool
isNear(self, Position3D pPos2) -> bool
“””
return _almath.Position3D_isNear(*args)
def norm(*args):
“””norm(self) -> float”””
return _almath.Position3D_norm(*args)
def normalize(*args):
“””normalize(self) -> Position3D”””
return _almath.Position3D_normalize(*args)
def dotProduct(*args):
“””dotProduct(self, Position3D pPos2) -> float”””
return _almath.Position3D_dotProduct(*args)
def crossProduct(*args):
“””crossProduct(self, Position3D pPos2) -> Position3D”””
return _almath.Position3D_crossProduct(*args)
def toVector(*args):
“””toVector(self) -> vectorFloat”””
return _almath.Position3D_toVector(*args)
def __repr__(*args):
“””__repr__(self) -> char”””
return _almath.Position3D___repr__(*args)
def __rmul__(*args):
“””__rmul__(self, float lhs) -> Position3D”””
return _almath.Position3D___rmul__(*args)
__swig_destroy__ = _almath.delete_Position3D
__del__ = lambda self : None;
Position3D_swigregister = _almath.Position3D_swigregister
Position3D_swigregister(Position3D)

def __div__(*args):
“””__div__(float pM, Position3D pPos1) -> Position3D”””
return _almath.__div__(*args)
def dotProduct(*args):
“””dotProduct(Position3D pPos1, Position3D pPos2) -> float”””
return _almath.dotProduct(*args)
class Position6D(_object):
“””Proxy of C++ Position6D class”””
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, Position6D, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, Position6D, name)
__swig_setmethods__[“x”] = _almath.Position6D_x_set
__swig_getmethods__[“x”] = _almath.Position6D_x_get
if _newclass:x = _swig_property(_almath.Position6D_x_get, _almath.Position6D_x_set)
__swig_setmethods__[“y”] = _almath.Position6D_y_set
__swig_getmethods__[“y”] = _almath.Position6D_y_get
if _newclass:y = _swig_property(_almath.Position6D_y_get, _almath.Position6D_y_set)
__swig_setmethods__[“z”] = _almath.Position6D_z_set
__swig_getmethods__[“z”] = _almath.Position6D_z_get
if _newclass:z = _swig_property(_almath.Position6D_z_get, _almath.Position6D_z_set)
__swig_setmethods__[“wx”] = _almath.Position6D_wx_set
__swig_getmethods__[“wx”] = _almath.Position6D_wx_get
if _newclass:wx = _swig_property(_almath.Position6D_wx_get, _almath.Position6D_wx_set)
__swig_setmethods__[“wy”] = _almath.Position6D_wy_set
__swig_getmethods__[“wy”] = _almath.Position6D_wy_get
if _newclass:wy = _swig_property(_almath.Position6D_wy_get, _almath.Position6D_wy_set)
__swig_setmethods__[“wz”] = _almath.Position6D_wz_set
__swig_getmethods__[“wz”] = _almath.Position6D_wz_get
if _newclass:wz = _swig_property(_almath.Position6D_wz_get, _almath.Position6D_wz_set)
def __init__(self, *args):
“””
__init__(self) -> Position6D
__init__(self, float pInit) -> Position6D
__init__(self, float pX, float pY, float pZ, float pWx, float pWy,
float pWz) -> Position6D
__init__(self, vectorFloat pFloats) -> Position6D
“””
this = _almath.new_Position6D(*args)
try: self.this.append(this)
except: self.this = this
def __add__(*args):
“””__add__(self, Position6D pPos2) -> Position6D”””
return _almath.Position6D___add__(*args)
def __sub__(*args):
“””__sub__(self, Position6D pPos2) -> Position6D”””
return _almath.Position6D___sub__(*args)
def __pos__(*args):
“””__pos__(self) -> Position6D”””
return _almath.Position6D___pos__(*args)
def __neg__(*args):
“””__neg__(self) -> Position6D”””
return _almath.Position6D___neg__(*args)
def __iadd__(*args):
“””__iadd__(self, Position6D pPos2) -> Position6D”””
return _almath.Position6D___iadd__(*args)
def __isub__(*args):
“””__isub__(self, Position6D pPos2) -> Position6D”””
return _almath.Position6D___isub__(*args)
def __eq__(*args):
“””__eq__(self, Position6D pPos2) -> bool”””
return _almath.Position6D___eq__(*args)
def __ne__(*args):
“””__ne__(self, Position6D pPos2) -> bool”””
return _almath.Position6D___ne__(*args)
def __mul__(*args):
“””__mul__(self, float pVal) -> Position6D”””
return _almath.Position6D___mul__(*args)
def __div__(*args):
“””__div__(self, float pVal) -> Position6D”””
return _almath.Position6D___div__(*args)
def __imul__(*args):
“””__imul__(self, float pVal) -> Position6D”””
return _almath.Position6D___imul__(*args)
def __idiv__(*args):
“””__idiv__(self, float pVal) -> Position6D”””
return _almath.Position6D___idiv__(*args)
def isNear(*args):
“””
isNear(self, Position6D pPos2, float pEpsilon=0.0001f) -> bool
isNear(self, Position6D pPos2) -> bool
“””
return _almath.Position6D_isNear(*args)
def distanceSquared(*args):
“””distanceSquared(self, Position6D pPos2) -> float”””
return _almath.Position6D_distanceSquared(*args)
def distance(*args):
“””distance(self, Position6D pPos2) -> float”””
return _almath.Position6D_distance(*args)
def norm(*args):
“””norm(self) -> float”””
return _almath.Position6D_norm(*args)
def toVector(*args):
“””toVector(self) -> vectorFloat”””
return _almath.Position6D_toVector(*args)
def __repr__(*args):
“””__repr__(self) -> char”””
return _almath.Position6D___repr__(*args)
def __rmul__(*args):
“””__rmul__(self, float lhs) -> Position6D”””
return _almath.Position6D___rmul__(*args)
__swig_destroy__ = _almath.delete_Position6D
__del__ = lambda self : None;
Position6D_swigregister = _almath.Position6D_swigregister
Position6D_swigregister(Position6D)
def crossProduct(*args):
“””
crossProduct(Position2D pPos1, Position2D pPos2) -> float
crossProduct(Position2D pPos1, Position2D pPos2, float pRes)
crossProduct(Position3D pPos1, Position3D pPos2) -> Position3D
crossProduct(Position3D pPos1, Position3D pPos2, Position3D pRes)
“””
return _almath.crossProduct(*args)
class PositionAndVelocity(_object):
“””Proxy of C++ PositionAndVelocity class”””
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, PositionAndVelocity, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, PositionAndVelocity, name)
__swig_setmethods__[“q”] = _almath.PositionAndVelocity_q_set
__swig_getmethods__[“q”] = _almath.PositionAndVelocity_q_get
if _newclass:q = _swig_property(_almath.PositionAndVelocity_q_get, _almath.PositionAndVelocity_q_set)
__swig_setmethods__[“dq”] = _almath.PositionAndVelocity_dq_set
__swig_getmethods__[“dq”] = _almath.PositionAndVelocity_dq_get
if _newclass:dq = _swig_property(_almath.PositionAndVelocity_dq_get, _almath.PositionAndVelocity_dq_set)
def __init__(self, *args):
“””
__init__(self, float pq=0.0f, float pdq=0.0f) -> PositionAndVelocity
__init__(self, float pq=0.0f) -> PositionAndVelocity
__init__(self) -> PositionAndVelocity
“””
this = _almath.new_PositionAndVelocity(*args)
try: self.this.append(this)
except: self.this = this
def isNear(*args):
“””
isNear(self, PositionAndVelocity pDat2, float pEpsilon=0.0001f) -> bool
isNear(self, PositionAndVelocity pDat2) -> bool
“””
return _almath.PositionAndVelocity_isNear(*args)
def __repr__(*args):
“””__repr__(self) -> char”””
return _almath.PositionAndVelocity___repr__(*args)
__swig_destroy__ = _almath.delete_PositionAndVelocity
__del__ = lambda self : None;
PositionAndVelocity_swigregister = _almath.PositionAndVelocity_swigregister
PositionAndVelocity_swigregister(PositionAndVelocity)
def distanceSquared(*args):
“””
distanceSquared(Pose2D pPos1, Pose2D pPos2) -> float
distanceSquared(Position2D pPos1, Position2D pPos2) -> float
distanceSquared(Position3D pPos1, Position3D pPos2) -> float
distanceSquared(Position6D pPos1, Position6D pPos2) -> float
“””
return _almath.distanceSquared(*args)
def distance(*args):
“””
distance(Pose2D pPos1, Pose2D pPos2) -> float
distance(Position2D pPos1, Position2D pPos2) -> float
distance(Position3D pPos1, Position3D pPos2) -> float
distance(Position6D pPos1, Position6D pPos2) -> float
“””
return _almath.distance(*args)
class Quaternion(_object):
“””Proxy of C++ Quaternion class”””
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, Quaternion, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, Quaternion, name)
__swig_setmethods__[“w”] = _almath.Quaternion_w_set
__swig_getmethods__[“w”] = _almath.Quaternion_w_get
if _newclass:w = _swig_property(_almath.Quaternion_w_get, _almath.Quaternion_w_set)
__swig_setmethods__[“x”] = _almath.Quaternion_x_set
__swig_getmethods__[“x”] = _almath.Quaternion_x_get
if _newclass:x = _swig_property(_almath.Quaternion_x_get, _almath.Quaternion_x_set)
__swig_setmethods__[“y”] = _almath.Quaternion_y_set
__swig_getmethods__[“y”] = _almath.Quaternion_y_get
if _newclass:y = _swig_property(_almath.Quaternion_y_get, _almath.Quaternion_y_set)
__swig_setmethods__[“z”] = _almath.Quaternion_z_set
__swig_getmethods__[“z”] = _almath.Quaternion_z_get
if _newclass:z = _swig_property(_almath.Quaternion_z_get, _almath.Quaternion_z_set)
def __init__(self, *args):
“””
__init__(self) -> Quaternion
__init__(self, float pW, float pX, float pY, float pZ) -> Quaternion
__init__(self, vectorFloat pFloats) -> Quaternion
“””
this = _almath.new_Quaternion(*args)
try: self.this.append(this)
except: self.this = this
def __mul__(*args):
“””__mul__(self, Quaternion pQua2) -> Quaternion”””
return _almath.Quaternion___mul__(*args)
def __eq__(*args):
“””__eq__(self, Quaternion pQua2) -> bool”””
return _almath.Quaternion___eq__(*args)
def __ne__(*args):
“””__ne__(self, Quaternion pQua2) -> bool”””
return _almath.Quaternion___ne__(*args)
def __imul__(*args):
“””
__imul__(self, Quaternion pQu2) -> Quaternion
__imul__(self, float pVal) -> Quaternion
“””
return _almath.Quaternion___imul__(*args)
def __idiv__(*args):
“””__idiv__(self, float pVal) -> Quaternion”””
return _almath.Quaternion___idiv__(*args)
def isNear(*args):
“””
isNear(self, Quaternion pQua2, float pEpsilon=0.0001f) -> bool
isNear(self, Quaternion pQua2) -> bool
“””
return _almath.Quaternion_isNear(*args)
def norm(*args):
“””norm(self) -> float”””
return _almath.Quaternion_norm(*args)
def normalize(*args):
“””normalize(self) -> Quaternion”””
return _almath.Quaternion_normalize(*args)
def inverse(*args):
“””inverse(self) -> Quaternion”””
return _almath.Quaternion_inverse(*args)
def fromAngleAndAxisRotation(*args):
“””fromAngleAndAxisRotation(float pAngle, float pAxisX, float pAxisY, float pAxisZ) -> Quaternion”””
return _almath.Quaternion_fromAngleAndAxisRotation(*args)
if _newclass:fromAngleAndAxisRotation = staticmethod(fromAngleAndAxisRotation)
__swig_getmethods__[“fromAngleAndAxisRotation”] = lambda x: fromAngleAndAxisRotation
def toVector(*args):
“””toVector(self) -> vectorFloat”””
return _almath.Quaternion_toVector(*args)
def __repr__(*args):
“””__repr__(self) -> char”””
return _almath.Quaternion___repr__(*args)
__swig_destroy__ = _almath.delete_Quaternion
__del__ = lambda self : None;
Quaternion_swigregister = _almath.Quaternion_swigregister
Quaternion_swigregister(Quaternion)
def Quaternion_fromAngleAndAxisRotation(*args):
“””Quaternion_fromAngleAndAxisRotation(float pAngle, float pAxisX, float pAxisY, float pAxisZ) -> Quaternion”””
return _almath.Quaternion_fromAngleAndAxisRotation(*args)

def quaternionFromAngleAndAxisRotation(*args):
“””quaternionFromAngleAndAxisRotation(float pAngle, float pAxisX, float pAxisY, float pAxisZ) -> Quaternion”””
return _almath.quaternionFromAngleAndAxisRotation(*args)
def angleAndAxisRotationFromQuaternion(*args):
“””
angleAndAxisRotationFromQuaternion(Quaternion pQuaternion, float pAngle, float pAxisX,
float pAxisY, float pAxisZ)
“””
return _almath.angleAndAxisRotationFromQuaternion(*args)
class Rotation(_object):
“””Proxy of C++ Rotation class”””
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, Rotation, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, Rotation, name)
__swig_setmethods__[“r1_c1”] = _almath.Rotation_r1_c1_set
__swig_getmethods__[“r1_c1”] = _almath.Rotation_r1_c1_get
if _newclass:r1_c1 = _swig_property(_almath.Rotation_r1_c1_get, _almath.Rotation_r1_c1_set)
__swig_setmethods__[“r1_c2”] = _almath.Rotation_r1_c2_set
__swig_getmethods__[“r1_c2”] = _almath.Rotation_r1_c2_get
if _newclass:r1_c2 = _swig_property(_almath.Rotation_r1_c2_get, _almath.Rotation_r1_c2_set)
__swig_setmethods__[“r1_c3”] = _almath.Rotation_r1_c3_set
__swig_getmethods__[“r1_c3”] = _almath.Rotation_r1_c3_get
if _newclass:r1_c3 = _swig_property(_almath.Rotation_r1_c3_get, _almath.Rotation_r1_c3_set)
__swig_setmethods__[“r2_c1”] = _almath.Rotation_r2_c1_set
__swig_getmethods__[“r2_c1”] = _almath.Rotation_r2_c1_get
if _newclass:r2_c1 = _swig_property(_almath.Rotation_r2_c1_get, _almath.Rotation_r2_c1_set)
__swig_setmethods__[“r2_c2”] = _almath.Rotation_r2_c2_set
__swig_getmethods__[“r2_c2”] = _almath.Rotation_r2_c2_get
if _newclass:r2_c2 = _swig_property(_almath.Rotation_r2_c2_get, _almath.Rotation_r2_c2_set)
__swig_setmethods__[“r2_c3”] = _almath.Rotation_r2_c3_set
__swig_getmethods__[“r2_c3”] = _almath.Rotation_r2_c3_get
if _newclass:r2_c3 = _swig_property(_almath.Rotation_r2_c3_get, _almath.Rotation_r2_c3_set)
__swig_setmethods__[“r3_c1”] = _almath.Rotation_r3_c1_set
__swig_getmethods__[“r3_c1”] = _almath.Rotation_r3_c1_get
if _newclass:r3_c1 = _swig_property(_almath.Rotation_r3_c1_get, _almath.Rotation_r3_c1_set)
__swig_setmethods__[“r3_c2”] = _almath.Rotation_r3_c2_set
__swig_getmethods__[“r3_c2”] = _almath.Rotation_r3_c2_get
if _newclass:r3_c2 = _swig_property(_almath.Rotation_r3_c2_get, _almath.Rotation_r3_c2_set)
__swig_setmethods__[“r3_c3”] = _almath.Rotation_r3_c3_set
__swig_getmethods__[“r3_c3”] = _almath.Rotation_r3_c3_get
if _newclass:r3_c3 = _swig_property(_almath.Rotation_r3_c3_get, _almath.Rotation_r3_c3_set)
def __init__(self, *args):
“””
__init__(self) -> Rotation
__init__(self, vectorFloat pFloats) -> Rotation
“””
this = _almath.new_Rotation(*args)
try: self.this.append(this)
except: self.this = this
def __imul__(*args):
“””__imul__(self, Rotation pRot2) -> Rotation”””
return _almath.Rotation___imul__(*args)
def __eq__(*args):
“””__eq__(self, Rotation pRot2) -> bool”””
return _almath.Rotation___eq__(*args)
def __ne__(*args):
“””__ne__(self, Rotation pRot2) -> bool”””
return _almath.Rotation___ne__(*args)
def isNear(*args):
“””
isNear(self, Rotation pRot2, float pEpsilon=0.0001f) -> bool
isNear(self, Rotation pRot2) -> bool
“””
return _almath.Rotation_isNear(*args)
def transpose(*args):
“””transpose(self) -> Rotation”””
return _almath.Rotation_transpose(*args)
def determinant(*args):
“””determinant(self) -> float”””
return _almath.Rotation_determinant(*args)
def fromQuaternion(*args):
“””fromQuaternion(float pA, float pB, float pC, float pD) -> Rotation”””
return _almath.Rotation_fromQuaternion(*args)
if _newclass:fromQuaternion = staticmethod(fromQuaternion)
__swig_getmethods__[“fromQuaternion”] = lambda x: fromQuaternion
def fromAngleDirection(*args):
“””fromAngleDirection(float pAngle, float pX, float pY, float pZ) -> Rotation”””
return _almath.Rotation_fromAngleDirection(*args)
if _newclass:fromAngleDirection = staticmethod(fromAngleDirection)
__swig_getmethods__[“fromAngleDirection”] = lambda x: fromAngleDirection
def fromRotX(*args):
“””fromRotX(float pRotX) -> Rotation”””
return _almath.Rotation_fromRotX(*args)
if _newclass:fromRotX = staticmethod(fromRotX)
__swig_getmethods__[“fromRotX”] = lambda x: fromRotX
def fromRotY(*args):
“””fromRotY(float pRotY) -> Rotation”””
return _almath.Rotation_fromRotY(*args)
if _newclass:fromRotY = staticmethod(fromRotY)
__swig_getmethods__[“fromRotY”] = lambda x: fromRotY
def fromRotZ(*args):
“””fromRotZ(float pRotZ) -> Rotation”””
return _almath.Rotation_fromRotZ(*args)
if _newclass:fromRotZ = staticmethod(fromRotZ)
__swig_getmethods__[“fromRotZ”] = lambda x: fromRotZ
def from3DRotation(*args):
“””from3DRotation(float pWX, float pWY, float pWZ) -> Rotation”””
return _almath.Rotation_from3DRotation(*args)
if _newclass:from3DRotation = staticmethod(from3DRotation)
__swig_getmethods__[“from3DRotation”] = lambda x: from3DRotation
def toVector(*args):
“””toVector(self) -> vectorFloat”””
return _almath.Rotation_toVector(*args)
def __str__(*args):
“””__str__(self) -> char”””
return _almath.Rotation___str__(*args)
def __repr__(*args):
“””__repr__(self) -> char”””
return _almath.Rotation___repr__(*args)
def __mul__(*args):
“””
__mul__(self, Rotation pRot2) -> Rotation
__mul__(self, Position3D rhs) -> Position3D
“””
return _almath.Rotation___mul__(*args)
__swig_destroy__ = _almath.delete_Rotation
__del__ = lambda self : None;
Rotation_swigregister = _almath.Rotation_swigregister
Rotation_swigregister(Rotation)
def quaternionInverse(*args):
“””
quaternionInverse(Quaternion pQua, Quaternion pQuaOut)
quaternionInverse(Quaternion pQua) -> Quaternion
“””
return _almath.quaternionInverse(*args)
def Rotation_fromQuaternion(*args):
“””Rotation_fromQuaternion(float pA, float pB, float pC, float pD) -> Rotation”””
return _almath.Rotation_fromQuaternion(*args)
def Rotation_fromAngleDirection(*args):
“””Rotation_fromAngleDirection(float pAngle, float pX, float pY, float pZ) -> Rotation”””
return _almath.Rotation_fromAngleDirection(*args)
def Rotation_fromRotX(*args):
“””Rotation_fromRotX(float pRotX) -> Rotation”””
return _almath.Rotation_fromRotX(*args)
def Rotation_fromRotY(*args):
“””Rotation_fromRotY(float pRotY) -> Rotation”””
return _almath.Rotation_fromRotY(*args)
def Rotation_fromRotZ(*args):
“””Rotation_fromRotZ(float pRotZ) -> Rotation”””
return _almath.Rotation_fromRotZ(*args)
def Rotation_from3DRotation(*args):
“””Rotation_from3DRotation(float pWX, float pWY, float pWZ) -> Rotation”””
return _almath.Rotation_from3DRotation(*args)

def transpose(*args):
“””transpose(Rotation pRot) -> Rotation”””
return _almath.transpose(*args)
def rotationFromQuaternion(*args):
“””rotationFromQuaternion(float pA, float pB, float pC, float pD) -> Rotation”””
return _almath.rotationFromQuaternion(*args)
def applyRotation(*args):
“””applyRotation(Rotation pRot, float pX, float pY, float pZ)”””
return _almath.applyRotation(*args)
def rotationFromRotX(*args):
“””rotationFromRotX(float pRotX) -> Rotation”””
return _almath.rotationFromRotX(*args)
def rotationFromRotY(*args):
“””rotationFromRotY(float pRotY) -> Rotation”””
return _almath.rotationFromRotY(*args)
def rotationFromRotZ(*args):
“””rotationFromRotZ(float pRotZ) -> Rotation”””
return _almath.rotationFromRotZ(*args)
def rotationFrom3DRotation(*args):
“””rotationFrom3DRotation(float pWX, float pWY, float pWZ) -> Rotation”””
return _almath.rotationFrom3DRotation(*args)
class Rotation3D(_object):
“””Proxy of C++ Rotation3D class”””
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, Rotation3D, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, Rotation3D, name)
__swig_setmethods__[“wx”] = _almath.Rotation3D_wx_set
__swig_getmethods__[“wx”] = _almath.Rotation3D_wx_get
if _newclass:wx = _swig_property(_almath.Rotation3D_wx_get, _almath.Rotation3D_wx_set)
__swig_setmethods__[“wy”] = _almath.Rotation3D_wy_set
__swig_getmethods__[“wy”] = _almath.Rotation3D_wy_get
if _newclass:wy = _swig_property(_almath.Rotation3D_wy_get, _almath.Rotation3D_wy_set)
__swig_setmethods__[“wz”] = _almath.Rotation3D_wz_set
__swig_getmethods__[“wz”] = _almath.Rotation3D_wz_get
if _newclass:wz = _swig_property(_almath.Rotation3D_wz_get, _almath.Rotation3D_wz_set)
def __init__(self, *args):
“””
__init__(self) -> Rotation3D
__init__(self, float pInit) -> Rotation3D
__init__(self, float pWx, float pWy, float pWz) -> Rotation3D
__init__(self, vectorFloat pFloats) -> Rotation3D
“””
this = _almath.new_Rotation3D(*args)
try: self.this.append(this)
except: self.this = this
def __add__(*args):
“””__add__(self, Rotation3D pRot2) -> Rotation3D”””
return _almath.Rotation3D___add__(*args)
def __sub__(*args):
“””__sub__(self, Rotation3D pRot2) -> Rotation3D”””
return _almath.Rotation3D___sub__(*args)
def __iadd__(*args):
“””__iadd__(self, Rotation3D pRot2) -> Rotation3D”””
return _almath.Rotation3D___iadd__(*args)
def __isub__(*args):
“””__isub__(self, Rotation3D pRot2) -> Rotation3D”””
return _almath.Rotation3D___isub__(*args)
def __eq__(*args):
“””__eq__(self, Rotation3D pRot2) -> bool”””
return _almath.Rotation3D___eq__(*args)
def __ne__(*args):
“””__ne__(self, Rotation3D pRot2) -> bool”””
return _almath.Rotation3D___ne__(*args)
def __mul__(*args):
“””__mul__(self, float pVal) -> Rotation3D”””
return _almath.Rotation3D___mul__(*args)
def __div__(*args):
“””__div__(self, float pVal) -> Rotation3D”””
return _almath.Rotation3D___div__(*args)
def __imul__(*args):
“””__imul__(self, float pVal) -> Rotation3D”””
return _almath.Rotation3D___imul__(*args)
def __idiv__(*args):
“””__idiv__(self, float pVal) -> Rotation3D”””
return _almath.Rotation3D___idiv__(*args)
def isNear(*args):
“””
isNear(self, Rotation3D pRot2, float pEpsilon=0.0001f) -> bool
isNear(self, Rotation3D pRot2) -> bool
“””
return _almath.Rotation3D_isNear(*args)
def norm(*args):
“””norm(self) -> float”””
return _almath.Rotation3D_norm(*args)
def toVector(*args):
“””toVector(self) -> vectorFloat”””
return _almath.Rotation3D_toVector(*args)
def __repr__(*args):
“””__repr__(self) -> char”””
return _almath.Rotation3D___repr__(*args)
__swig_destroy__ = _almath.delete_Rotation3D
__del__ = lambda self : None;
Rotation3D_swigregister = _almath.Rotation3D_swigregister
Rotation3D_swigregister(Rotation3D)
class Transform(_object):
“””Proxy of C++ Transform class”””
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, Transform, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, Transform, name)
__swig_setmethods__[“r1_c1”] = _almath.Transform_r1_c1_set
__swig_getmethods__[“r1_c1”] = _almath.Transform_r1_c1_get
if _newclass:r1_c1 = _swig_property(_almath.Transform_r1_c1_get, _almath.Transform_r1_c1_set)
__swig_setmethods__[“r1_c2”] = _almath.Transform_r1_c2_set
__swig_getmethods__[“r1_c2”] = _almath.Transform_r1_c2_get
if _newclass:r1_c2 = _swig_property(_almath.Transform_r1_c2_get, _almath.Transform_r1_c2_set)
__swig_setmethods__[“r1_c3”] = _almath.Transform_r1_c3_set
__swig_getmethods__[“r1_c3”] = _almath.Transform_r1_c3_get
if _newclass:r1_c3 = _swig_property(_almath.Transform_r1_c3_get, _almath.Transform_r1_c3_set)
__swig_setmethods__[“r1_c4”] = _almath.Transform_r1_c4_set
__swig_getmethods__[“r1_c4”] = _almath.Transform_r1_c4_get
if _newclass:r1_c4 = _swig_property(_almath.Transform_r1_c4_get, _almath.Transform_r1_c4_set)
__swig_setmethods__[“r2_c1”] = _almath.Transform_r2_c1_set
__swig_getmethods__[“r2_c1”] = _almath.Transform_r2_c1_get
if _newclass:r2_c1 = _swig_property(_almath.Transform_r2_c1_get, _almath.Transform_r2_c1_set)
__swig_setmethods__[“r2_c2”] = _almath.Transform_r2_c2_set
__swig_getmethods__[“r2_c2”] = _almath.Transform_r2_c2_get
if _newclass:r2_c2 = _swig_property(_almath.Transform_r2_c2_get, _almath.Transform_r2_c2_set)
__swig_setmethods__[“r2_c3”] = _almath.Transform_r2_c3_set
__swig_getmethods__[“r2_c3”] = _almath.Transform_r2_c3_get
if _newclass:r2_c3 = _swig_property(_almath.Transform_r2_c3_get, _almath.Transform_r2_c3_set)
__swig_setmethods__[“r2_c4”] = _almath.Transform_r2_c4_set
__swig_getmethods__[“r2_c4”] = _almath.Transform_r2_c4_get
if _newclass:r2_c4 = _swig_property(_almath.Transform_r2_c4_get, _almath.Transform_r2_c4_set)
__swig_setmethods__[“r3_c1”] = _almath.Transform_r3_c1_set
__swig_getmethods__[“r3_c1”] = _almath.Transform_r3_c1_get
if _newclass:r3_c1 = _swig_property(_almath.Transform_r3_c1_get, _almath.Transform_r3_c1_set)
__swig_setmethods__[“r3_c2”] = _almath.Transform_r3_c2_set
__swig_getmethods__[“r3_c2”] = _almath.Transform_r3_c2_get
if _newclass:r3_c2 = _swig_property(_almath.Transform_r3_c2_get, _almath.Transform_r3_c2_set)
__swig_setmethods__[“r3_c3”] = _almath.Transform_r3_c3_set
__swig_getmethods__[“r3_c3”] = _almath.Transform_r3_c3_get
if _newclass:r3_c3 = _swig_property(_almath.Transform_r3_c3_get, _almath.Transform_r3_c3_set)
__swig_setmethods__[“r3_c4”] = _almath.Transform_r3_c4_set
__swig_getmethods__[“r3_c4”] = _almath.Transform_r3_c4_get
if _newclass:r3_c4 = _swig_property(_almath.Transform_r3_c4_get, _almath.Transform_r3_c4_set)
def __init__(self, *args):
“””
__init__(self) -> Transform
__init__(self, vectorFloat pFloats) -> Transform
__init__(self, float pPosX, float pPosY, float pPosZ) -> Transform
“””
this = _almath.new_Transform(*args)
try: self.this.append(this)
except: self.this = this
def __imul__(*args):
“””__imul__(self, Transform pT2) -> Transform”””
return _almath.Transform___imul__(*args)
def __eq__(*args):
“””__eq__(self, Transform pT2) -> bool”””
return _almath.Transform___eq__(*args)
def __ne__(*args):
“””__ne__(self, Transform pT2) -> bool”””
return _almath.Transform___ne__(*args)
def isNear(*args):
“””
isNear(self, Transform pT2, float pEpsilon=0.0001f) -> bool
isNear(self, Transform pT2) -> bool
“””
return _almath.Transform_isNear(*args)
def isTransform(*args):
“””
isTransform(self, float pEpsilon=0.0001f) -> bool
isTransform(self) -> bool
“””
return _almath.Transform_isTransform(*args)
def norm(*args):
“””norm(self) -> float”””
return _almath.Transform_norm(*args)
def determinant(*args):
“””determinant(self) -> float”””
return _almath.Transform_determinant(*args)
def inverse(*args):
“””inverse(self) -> Transform”””
return _almath.Transform_inverse(*args)
def fromRotX(*args):
“””fromRotX(float pRotX) -> Transform”””
return _almath.Transform_fromRotX(*args)
if _newclass:fromRotX = staticmethod(fromRotX)
__swig_getmethods__[“fromRotX”] = lambda x: fromRotX
def fromRotY(*args):
“””fromRotY(float pRotY) -> Transform”””
return _almath.Transform_fromRotY(*args)
if _newclass:fromRotY = staticmethod(fromRotY)
__swig_getmethods__[“fromRotY”] = lambda x: fromRotY
def fromRotZ(*args):
“””fromRotZ(float pRotZ) -> Transform”””
return _almath.Transform_fromRotZ(*args)
if _newclass:fromRotZ = staticmethod(fromRotZ)
__swig_getmethods__[“fromRotZ”] = lambda x: fromRotZ
def from3DRotation(*args):
“””from3DRotation(float pWX, float pWY, float pWZ) -> Transform”””
return _almath.Transform_from3DRotation(*args)
if _newclass:from3DRotation = staticmethod(from3DRotation)
__swig_getmethods__[“from3DRotation”] = lambda x: from3DRotation
def fromPosition(*args):
“””
fromPosition(float pX, float pY, float pZ) -> Transform
fromPosition(float pX, float pY, float pZ, float pWX, float pWY,
float pWZ) -> Transform
“””
return _almath.Transform_fromPosition(*args)
if _newclass:fromPosition = staticmethod(fromPosition)
__swig_getmethods__[“fromPosition”] = lambda x: fromPosition
def diff(*args):
“””diff(self, Transform pT2) -> Transform”””
return _almath.Transform_diff(*args)
def distanceSquared(*args):
“””distanceSquared(self, Transform pT2) -> float”””
return _almath.Transform_distanceSquared(*args)
def distance(*args):
“””distance(self, Transform pT2) -> float”””
return _almath.Transform_distance(*args)
def toVector(*args):
“””toVector(self) -> vectorFloat”””
return _almath.Transform_toVector(*args)
def __str__(*args):
“””__str__(self) -> char”””
return _almath.Transform___str__(*args)
def __repr__(*args):
“””__repr__(self) -> char”””
return _almath.Transform___repr__(*args)
def __mul__(*args):
“””
__mul__(self, Transform pT2) -> Transform
__mul__(self, Position3D rhs) -> Position3D
“””
return _almath.Transform___mul__(*args)
__swig_destroy__ = _almath.delete_Transform
__del__ = lambda self : None;
Transform_swigregister = _almath.Transform_swigregister
Transform_swigregister(Transform)
def Transform_fromRotX(*args):
“””Transform_fromRotX(float pRotX) -> Transform”””
return _almath.Transform_fromRotX(*args)
def Transform_fromRotY(*args):
“””Transform_fromRotY(float pRotY) -> Transform”””
return _almath.Transform_fromRotY(*args)
def Transform_fromRotZ(*args):
“””Transform_fromRotZ(float pRotZ) -> Transform”””
return _almath.Transform_fromRotZ(*args)
def Transform_from3DRotation(*args):
“””Transform_from3DRotation(float pWX, float pWY, float pWZ) -> Transform”””
return _almath.Transform_from3DRotation(*args)
def Transform_fromPosition(*args):
“””
fromPosition(float pX, float pY, float pZ) -> Transform
Transform_fromPosition(float pX, float pY, float pZ, float pWX, float pWY,
float pWZ) -> Transform
“””
return _almath.Transform_fromPosition(*args)

def transformPreMultiply(*args):
“””transformPreMultiply(Transform pT, Transform pTOut)”””
return _almath.transformPreMultiply(*args)
def transformFromRotX(*args):
“””transformFromRotX(float pRotX) -> Transform”””
return _almath.transformFromRotX(*args)
def transformFromRotY(*args):
“””transformFromRotY(float pRotY) -> Transform”””
return _almath.transformFromRotY(*args)
def transformFromRotZ(*args):
“””transformFromRotZ(float pRotZ) -> Transform”””
return _almath.transformFromRotZ(*args)
def transformFrom3DRotation(*args):
“””transformFrom3DRotation(float pWX, float pWY, float pWZ) -> Transform”””
return _almath.transformFrom3DRotation(*args)
def transformInvertInPlace(*args):
“””transformInvertInPlace(Transform pT)”””
return _almath.transformInvertInPlace(*args)
def pinv(*args):
“””pinv(Transform pT) -> Transform”””
return _almath.pinv(*args)
def transformDiff(*args):
“””transformDiff(Transform pT1, Transform pT2) -> Transform”””
return _almath.transformDiff(*args)
def transformDistanceSquared(*args):
“””transformDistanceSquared(Transform pT1, Transform pT2) -> float”””
return _almath.transformDistanceSquared(*args)
def transformDistance(*args):
“””transformDistance(Transform pT1, Transform pT2) -> float”””
return _almath.transformDistance(*args)
class Velocity3D(_object):
“””Proxy of C++ Velocity3D class”””
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, Velocity3D, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, Velocity3D, name)
__swig_setmethods__[“xd”] = _almath.Velocity3D_xd_set
__swig_getmethods__[“xd”] = _almath.Velocity3D_xd_get
if _newclass:xd = _swig_property(_almath.Velocity3D_xd_get, _almath.Velocity3D_xd_set)
__swig_setmethods__[“yd”] = _almath.Velocity3D_yd_set
__swig_getmethods__[“yd”] = _almath.Velocity3D_yd_get
if _newclass:yd = _swig_property(_almath.Velocity3D_yd_get, _almath.Velocity3D_yd_set)
__swig_setmethods__[“zd”] = _almath.Velocity3D_zd_set
__swig_getmethods__[“zd”] = _almath.Velocity3D_zd_get
if _newclass:zd = _swig_property(_almath.Velocity3D_zd_get, _almath.Velocity3D_zd_set)
def __init__(self, *args):
“””
__init__(self) -> Velocity3D
__init__(self, float pInit) -> Velocity3D
__init__(self, float pXd, float pYd, float pZd) -> Velocity3D
__init__(self, vectorFloat pFloats) -> Velocity3D
“””
this = _almath.new_Velocity3D(*args)
try: self.this.append(this)
except: self.this = this
def __add__(*args):
“””__add__(self, Velocity3D pVel2) -> Velocity3D”””
return _almath.Velocity3D___add__(*args)
def __sub__(*args):
“””__sub__(self, Velocity3D pVel2) -> Velocity3D”””
return _almath.Velocity3D___sub__(*args)
def __pos__(*args):
“””__pos__(self) -> Velocity3D”””
return _almath.Velocity3D___pos__(*args)
def __neg__(*args):
“””__neg__(self) -> Velocity3D”””
return _almath.Velocity3D___neg__(*args)
def __iadd__(*args):
“””__iadd__(self, Velocity3D pVel2) -> Velocity3D”””
return _almath.Velocity3D___iadd__(*args)
def __isub__(*args):
“””__isub__(self, Velocity3D pVel2) -> Velocity3D”””
return _almath.Velocity3D___isub__(*args)
def __eq__(*args):
“””__eq__(self, Velocity3D pVel2) -> bool”””
return _almath.Velocity3D___eq__(*args)
def __ne__(*args):
“””__ne__(self, Velocity3D pVel2) -> bool”””
return _almath.Velocity3D___ne__(*args)
def __mul__(*args):
“””__mul__(self, float pVal) -> Velocity3D”””
return _almath.Velocity3D___mul__(*args)
def __div__(*args):
“””__div__(self, float pVal) -> Velocity3D”””
return _almath.Velocity3D___div__(*args)
def __imul__(*args):
“””__imul__(self, float pVal) -> Velocity3D”””
return _almath.Velocity3D___imul__(*args)
def __idiv__(*args):
“””__idiv__(self, float pVal) -> Velocity3D”””
return _almath.Velocity3D___idiv__(*args)
def isNear(*args):
“””
isNear(self, Velocity3D pVel2, float pEpsilon=0.0001f) -> bool
isNear(self, Velocity3D pVel2) -> bool
“””
return _almath.Velocity3D_isNear(*args)
def norm(*args):
“””norm(self) -> float”””
return _almath.Velocity3D_norm(*args)
def normalize(*args):
“””normalize(self) -> Velocity3D”””
return _almath.Velocity3D_normalize(*args)
def toVector(*args):
“””toVector(self) -> vectorFloat”””
return _almath.Velocity3D_toVector(*args)
def __repr__(*args):
“””__repr__(self) -> char”””
return _almath.Velocity3D___repr__(*args)
def __rmul__(*args):
“””__rmul__(self, float lhs) -> Velocity3D”””
return _almath.Velocity3D___rmul__(*args)
__swig_destroy__ = _almath.delete_Velocity3D
__del__ = lambda self : None;
Velocity3D_swigregister = _almath.Velocity3D_swigregister
Velocity3D_swigregister(Velocity3D)
def transformToFloatVector(*args):
“””
transformToFloatVector(Transform pT, vectorFloat pTOut)
transformToFloatVector(Transform pT) -> vectorFloat
“””
return _almath.transformToFloatVector(*args)
def determinant(*args):
“””
determinant(Rotation pRot) -> float
determinant(Transform pT) -> float
determinant(vectorFloat pFloats) -> float
“””
return _almath.determinant(*args)
def transformInverse(*args):
“””
transformInverse(Transform pT, Transform pTOut)
transformInverse(Transform pT) -> Transform
“””
return _almath.transformInverse(*args)
def transformFromPosition(*args):
“””
transformFromPosition(float pX, float pY, float pZ) -> Transform
transformFromPosition(float pX, float pY, float pZ, float pWX, float pWY,
float pWZ) -> Transform
“””
return _almath.transformFromPosition(*args)
class Velocity6D(_object):
“””Proxy of C++ Velocity6D class”””
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, Velocity6D, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, Velocity6D, name)
__swig_setmethods__[“xd”] = _almath.Velocity6D_xd_set
__swig_getmethods__[“xd”] = _almath.Velocity6D_xd_get
if _newclass:xd = _swig_property(_almath.Velocity6D_xd_get, _almath.Velocity6D_xd_set)
__swig_setmethods__[“yd”] = _almath.Velocity6D_yd_set
__swig_getmethods__[“yd”] = _almath.Velocity6D_yd_get
if _newclass:yd = _swig_property(_almath.Velocity6D_yd_get, _almath.Velocity6D_yd_set)
__swig_setmethods__[“zd”] = _almath.Velocity6D_zd_set
__swig_getmethods__[“zd”] = _almath.Velocity6D_zd_get
if _newclass:zd = _swig_property(_almath.Velocity6D_zd_get, _almath.Velocity6D_zd_set)
__swig_setmethods__[“wxd”] = _almath.Velocity6D_wxd_set
__swig_getmethods__[“wxd”] = _almath.Velocity6D_wxd_get
if _newclass:wxd = _swig_property(_almath.Velocity6D_wxd_get, _almath.Velocity6D_wxd_set)
__swig_setmethods__[“wyd”] = _almath.Velocity6D_wyd_set
__swig_getmethods__[“wyd”] = _almath.Velocity6D_wyd_get
if _newclass:wyd = _swig_property(_almath.Velocity6D_wyd_get, _almath.Velocity6D_wyd_set)
__swig_setmethods__[“wzd”] = _almath.Velocity6D_wzd_set
__swig_getmethods__[“wzd”] = _almath.Velocity6D_wzd_get
if _newclass:wzd = _swig_property(_almath.Velocity6D_wzd_get, _almath.Velocity6D_wzd_set)
def __init__(self, *args):
“””
__init__(self) -> Velocity6D
__init__(self, float pInit) -> Velocity6D
__init__(self, float pXd, float pYd, float pZd, float pWxd, float pWyd,
float pWzd) -> Velocity6D
__init__(self, vectorFloat pFloats) -> Velocity6D
“””
this = _almath.new_Velocity6D(*args)
try: self.this.append(this)
except: self.this = this
def __add__(*args):
“””__add__(self, Velocity6D pVel2) -> Velocity6D”””
return _almath.Velocity6D___add__(*args)
def __sub__(*args):
“””__sub__(self, Velocity6D pVel2) -> Velocity6D”””
return _almath.Velocity6D___sub__(*args)
def __pos__(*args):
“””__pos__(self) -> Velocity6D”””
return _almath.Velocity6D___pos__(*args)
def __neg__(*args):
“””__neg__(self) -> Velocity6D”””
return _almath.Velocity6D___neg__(*args)
def __mul__(*args):
“””__mul__(self, float pVal) -> Velocity6D”””
return _almath.Velocity6D___mul__(*args)
def __div__(*args):
“””__div__(self, float pVal) -> Velocity6D”””
return _almath.Velocity6D___div__(*args)
def __eq__(*args):
“””__eq__(self, Velocity6D pVel2) -> bool”””
return _almath.Velocity6D___eq__(*args)
def __ne__(*args):
“””__ne__(self, Velocity6D pVel2) -> bool”””
return _almath.Velocity6D___ne__(*args)
def __imul__(*args):
“””__imul__(self, float pVal) -> Velocity6D”””
return _almath.Velocity6D___imul__(*args)
def __idiv__(*args):
“””__idiv__(self, float pVal) -> Velocity6D”””
return _almath.Velocity6D___idiv__(*args)
def isNear(*args):
“””
isNear(self, Velocity6D pVel2, float pEpsilon=0.0001f) -> bool
isNear(self, Velocity6D pVel2) -> bool
“””
return _almath.Velocity6D_isNear(*args)
def norm(*args):
“””norm(self) -> float”””
return _almath.Velocity6D_norm(*args)
def normalize(*args):
“””normalize(self) -> Velocity6D”””
return _almath.Velocity6D_normalize(*args)
def toVector(*args):
“””toVector(self) -> vectorFloat”””
return _almath.Velocity6D_toVector(*args)
def __repr__(*args):
“””__repr__(self) -> char”””
return _almath.Velocity6D___repr__(*args)
def __rmul__(*args):
“””__rmul__(self, float lhs) -> Velocity6D”””
return _almath.Velocity6D___rmul__(*args)
__swig_destroy__ = _almath.delete_Velocity6D
__del__ = lambda self : None;
Velocity6D_swigregister = _almath.Velocity6D_swigregister
Velocity6D_swigregister(Velocity6D)
class TransformAndVelocity6D(_object):
“””Proxy of C++ TransformAndVelocity6D class”””
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, TransformAndVelocity6D, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, TransformAndVelocity6D, name)
__swig_setmethods__[“T”] = _almath.TransformAndVelocity6D_T_set
__swig_getmethods__[“T”] = _almath.TransformAndVelocity6D_T_get
if _newclass:T = _swig_property(_almath.TransformAndVelocity6D_T_get, _almath.TransformAndVelocity6D_T_set)
__swig_setmethods__[“V”] = _almath.TransformAndVelocity6D_V_set
__swig_getmethods__[“V”] = _almath.TransformAndVelocity6D_V_get
if _newclass:V = _swig_property(_almath.TransformAndVelocity6D_V_get, _almath.TransformAndVelocity6D_V_set)
def isNear(*args):
“””
isNear(self, TransformAndVelocity6D pTV2, float pEpsilon=0.0001f) -> bool
isNear(self, TransformAndVelocity6D pTV2) -> bool
“””
return _almath.TransformAndVelocity6D_isNear(*args)
def __repr__(*args):
“””__repr__(self) -> char”””
return _almath.TransformAndVelocity6D___repr__(*args)
def __init__(self, *args):
“””__init__(self) -> TransformAndVelocity6D”””
this = _almath.new_TransformAndVelocity6D(*args)
try: self.this.append(this)
except: self.this = this
__swig_destroy__ = _almath.delete_TransformAndVelocity6D
__del__ = lambda self : None;
TransformAndVelocity6D_swigregister = _almath.TransformAndVelocity6D_swigregister
TransformAndVelocity6D_swigregister(TransformAndVelocity6D)
def norm(*args):
“””
norm(Position2D pPos) -> float
norm(Position3D pPos) -> float
norm(Position6D pPos) -> float
norm(Quaternion pQua) -> float
norm(Rotation3D pRot) -> float
norm(Transform pT) -> float
norm(Velocity3D pVel) -> float
norm(Velocity6D pVel) -> float
“””
return _almath.norm(*args)
def normalize(*args):
“””
normalize(Position2D pPos) -> Position2D
normalize(Position3D pPos) -> Position3D
normalize(Position6D pPos) -> Position6D
normalize(Quaternion pQua) -> Quaternion
normalize(Velocity3D pVel) -> Velocity3D
normalize(Velocity6D pVel) -> Velocity6D
“””
return _almath.normalize(*args)

def getDubinsSolutions(*args):
“””getDubinsSolutions(Pose2D pTargetPose, float pCircleRadius) -> vectorPose2D”””
return _almath.getDubinsSolutions(*args)
def avoidFootCollision(*args):
“””
avoidFootCollision(vectorPose2D pLFootBoundingBox, vectorPose2D pRFootBoundingBox,
bool pIsLeftSupport, Pose2D pMove) -> bool
“””
return _almath.avoidFootCollision(*args)
def clipFootWithEllipse(*args):
“””clipFootWithEllipse(float pMaxFootX, float pMaxFootY, Pose2D pMove) -> bool”””
return _almath.clipFootWithEllipse(*args)
def transformLogarithmInPlace(*args):
“””transformLogarithmInPlace(Transform pT, Velocity6D pVel)”””
return _almath.transformLogarithmInPlace(*args)
def transformLogarithm(*args):
“””transformLogarithm(Transform pT) -> Velocity6D”””
return _almath.transformLogarithm(*args)
def velocityExponential(*args):
“””velocityExponential(Velocity6D pVel) -> Transform”””
return _almath.velocityExponential(*args)
def velocityExponentialInPlace(*args):
“””velocityExponentialInPlace(Velocity6D pVel, Transform pT)”””
return _almath.velocityExponentialInPlace(*args)
def changeReferenceVelocity6D(*args):
“””changeReferenceVelocity6D(Transform pT, Velocity6D pVelIn, Velocity6D pVelOut)”””
return _almath.changeReferenceVelocity6D(*args)
def changeReferencePosition6D(*args):
“””changeReferencePosition6D(Transform pT, Position6D pPosIn, Position6D pPosOut)”””
return _almath.changeReferencePosition6D(*args)
def changeReferencePosition3DInPlace(*args):
“””changeReferencePosition3DInPlace(Transform pT, Position3D pPosOut)”””
return _almath.changeReferencePosition3DInPlace(*args)
def changeReferenceTransposePosition3DInPlace(*args):
“””changeReferenceTransposePosition3DInPlace(Transform pT, Position3D pPosOut)”””
return _almath.changeReferenceTransposePosition3DInPlace(*args)
def changeReferencePosition3D(*args):
“””changeReferencePosition3D(Transform pT, Position3D pPosIn, Position3D pPosOut)”””
return _almath.changeReferencePosition3D(*args)
def changeReferenceTransposePosition3D(*args):
“””changeReferenceTransposePosition3D(Transform pT, Position3D pPosIn, Position3D pPosOut)”””
return _almath.changeReferenceTransposePosition3D(*args)
def changeReferenceTransform(*args):
“””changeReferenceTransform(Transform pT, Transform pTIn, Transform pTOut)”””
return _almath.changeReferenceTransform(*args)
def changeReferenceTransposeTransform(*args):
“””changeReferenceTransposeTransform(Transform pT, Transform pTIn, Transform pTOut)”””
return _almath.changeReferenceTransposeTransform(*args)
def changeReferenceTransposeVelocity6D(*args):
“””changeReferenceTransposeVelocity6D(Transform pT, Velocity6D pVelIn, Velocity6D pVelOut)”””
return _almath.changeReferenceTransposeVelocity6D(*args)
def changeReferenceTransposePosition6D(*args):
“””changeReferenceTransposePosition6D(Transform pT, Position6D pPosIn, Position6D pPosOut)”””
return _almath.changeReferenceTransposePosition6D(*args)
def transformMeanInPlace(*args):
“””transformMeanInPlace(Transform pTIn1, Transform pTIn2, float pVal, Transform pTOut)”””
return _almath.transformMeanInPlace(*args)
def transformFromPosition3DInPlace(*args):
“””transformFromPosition3DInPlace(Position3D pPosition, Transform pTransform)”””
return _almath.transformFromPosition3DInPlace(*args)
def transformFromPosition3D(*args):
“””transformFromPosition3D(Position3D pPosition) -> Transform”””
return _almath.transformFromPosition3D(*args)
def transformFromRotationInPlace(*args):
“””transformFromRotationInPlace(Rotation pRotation, Transform pTransform)”””
return _almath.transformFromRotationInPlace(*args)
def transformFromRotation(*args):
“””transformFromRotation(Rotation pRotation) -> Transform”””
return _almath.transformFromRotation(*args)
def rotationFromTransformInPlace(*args):
“””rotationFromTransformInPlace(Transform pTransform, Rotation pRotation)”””
return _almath.rotationFromTransformInPlace(*args)
def rotationFromTransform(*args):
“””rotationFromTransform(Transform pTransform) -> Rotation”””
return _almath.rotationFromTransform(*args)
def rotation3DFromRotation(*args):
“””rotation3DFromRotation(Rotation pRotation) -> Rotation3D”””
return _almath.rotation3DFromRotation(*args)
def position6DFromTransformInPlace(*args):
“””position6DFromTransformInPlace(Transform pT, Position6D pPos)”””
return _almath.position6DFromTransformInPlace(*args)
def position6DFromTransform(*args):
“””position6DFromTransform(Transform pT) -> Position6D”””
return _almath.position6DFromTransform(*args)
def transformFromPose2DInPlace(*args):
“””transformFromPose2DInPlace(Pose2D pPose, Transform pT)”””
return _almath.transformFromPose2DInPlace(*args)
def transformFromPose2D(*args):
“””transformFromPose2D(Pose2D pPose) -> Transform”””
return _almath.transformFromPose2D(*args)
def pose2DFromTransformInPlace(*args):
“””pose2DFromTransformInPlace(Transform pT, Pose2D pPos)”””
return _almath.pose2DFromTransformInPlace(*args)
def pose2DFromTransform(*args):
“””pose2DFromTransform(Transform pT) -> Pose2D”””
return _almath.pose2DFromTransform(*args)
def transformFromRotation3D(*args):
“””transformFromRotation3D(Rotation3D pRotation) -> Transform”””
return _almath.transformFromRotation3D(*args)
def transformFromPosition6D(*args):
“””transformFromPosition6D(Position6D pPosition6D) -> Transform”””
return _almath.transformFromPosition6D(*args)
def position6DFromTransformDiffInPlace(*args):
“””position6DFromTransformDiffInPlace(Transform pCurrent, Transform pTarget, Position6D result)”””
return _almath.position6DFromTransformDiffInPlace(*args)
def position6DFromTransformDiff(*args):
“””position6DFromTransformDiff(Transform pCurrent, Transform pTarget) -> Position6D”””
return _almath.position6DFromTransformDiff(*args)
def position3DFromTransformInPlace(*args):
“””position3DFromTransformInPlace(Transform pT, Position3D pPos)”””
return _almath.position3DFromTransformInPlace(*args)
def position3DFromTransform(*args):
“””position3DFromTransform(Transform pT) -> Position3D”””
return _almath.position3DFromTransform(*args)
def rotation3DFromTransform(*args):
“””rotation3DFromTransform(Transform pT) -> Rotation3D”””
return _almath.rotation3DFromTransform(*args)
def transformFromQuaternion(*args):
“””transformFromQuaternion(Quaternion pQua) -> Transform”””
return _almath.transformFromQuaternion(*args)
def quaternionFromTransform(*args):
“””quaternionFromTransform(Transform pT) -> Quaternion”””
return _almath.quaternionFromTransform(*args)
def clipData(*args):
“””clipData(float pMin, float pMax, float pData) -> bool”””
return _almath.clipData(*args)
def position6DFromVelocity6D(*args):
“””position6DFromVelocity6D(Velocity6D pVel) -> Position6D”””
return _almath.position6DFromVelocity6D(*args)
_4_PI_ = cvar._4_PI_
_2_PI_ = cvar._2_PI_
PI = cvar.PI
PI_2 = cvar.PI_2
PI_4 = cvar.PI_4
TO_RAD = cvar.TO_RAD
TO_DEG = cvar.TO_DEG
def transformMean(*args):
“””
transformMean(Transform pTIn1, Transform pTIn2, float pVal=0.5f) -> Transform
transformMean(Transform pTIn1, Transform pTIn2) -> Transform
“””
return _almath.transformMean(*args)
def transformFromRotationPosition3D(*args):
“””
transformFromRotationPosition3D(Rotation pRot, float pX, float pY, float pZ) -> Transform
transformFromRotationPosition3D(Rotation pRot, Position3D pPos) -> Transform
“””
return _almath.transformFromRotationPosition3D(*args)
def transformFromRotVecInPlace(*args):
“””
transformFromRotVecInPlace(int pAxis, float pTheta, Position3D pPos, Transform pT)
transformFromRotVecInPlace(Position3D pPos, Transform pT)
“””
return _almath.transformFromRotVecInPlace(*args)
def transformFromRotVec(*args):
“””
transformFromRotVec(int pAxis, float pTheta, Position3D pPos) -> Transform
transformFromRotVec(Position3D pPos) -> Transform
transformFromRotVec(int pAxis, float pTheta) -> Transform
“””
return _almath.transformFromRotVec(*args)
def axisRotationProjection(*args):
“””
axisRotationProjection(Position3D pPos, Transform pT) -> Transform
axisRotationProjection(Position3D pAxis, Rotation pRot) -> Rotation
“””
return _almath.axisRotationProjection(*args)
def axisRotationProjectionInPlace(*args):
“””
axisRotationProjectionInPlace(Position3D pPos, Transform pT)
axisRotationProjectionInPlace(Position3D pPos, Rotation pRot)
“””
return _almath.axisRotationProjectionInPlace(*args)
def orthogonalSpace(*args):
“””
orthogonalSpace(Position3D pPos, Transform pTOut)
orthogonalSpace(Position3D pPos) -> Transform
“””
return _almath.orthogonalSpace(*args)
def __mul__(*args):
“””
__mul__(float pM, Position2D pPos1) -> Position2D
__mul__(float pM, Position3D pPos1) -> Position3D
__mul__(float pM, Velocity3D pVel1) -> Velocity3D
__mul__(float pVal, Velocity6D pVel) -> Velocity6D
__mul__(Transform pT, Position3D pPos) -> Position3D
__mul__(Rotation pRot, Position3D pPos) -> Position3D
__mul__(float pVal, Position6D pPos) -> Velocity6D
“””
return _almath.__mul__(*args)
def rotationFromAngleDirection(*args):
“””
rotationFromAngleDirection(float pAngle, float pX, float pY, float pZ) -> Rotation
rotationFromAngleDirection(float pTheta, Position3D pPos) -> Rotation
“””
return _almath.rotationFromAngleDirection(*args)

pynaoqi-python-2.7-naoqi-1.14-mac64/_allog.so

pynaoqi-python-2.7-naoqi-1.14-mac64/inaoqi.py
# This file was automatically generated by SWIG (http://www.swig.org).
# Version 1.3.31
#
# Don’t modify this file, modify the SWIG interface instead.
# This file is compatible with both classic and new-style classes.
import _inaoqi
import new
new_instancemethod = new.instancemethod
try:
_swig_property = property
except NameError:
pass # Python < 2.2 doesn't have 'property'. 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

class PySwigIterator(_object):
__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__ = _inaoqi.delete_PySwigIterator
__del__ = lambda self : None;
def value(*args): return _inaoqi.PySwigIterator_value(*args)
def incr(*args): return _inaoqi.PySwigIterator_incr(*args)
def decr(*args): return _inaoqi.PySwigIterator_decr(*args)
def distance(*args): return _inaoqi.PySwigIterator_distance(*args)
def equal(*args): return _inaoqi.PySwigIterator_equal(*args)
def copy(*args): return _inaoqi.PySwigIterator_copy(*args)
def next(*args): return _inaoqi.PySwigIterator_next(*args)
def previous(*args): return _inaoqi.PySwigIterator_previous(*args)
def advance(*args): return _inaoqi.PySwigIterator_advance(*args)
def __eq__(*args): return _inaoqi.PySwigIterator___eq__(*args)
def __ne__(*args): return _inaoqi.PySwigIterator___ne__(*args)
def __iadd__(*args): return _inaoqi.PySwigIterator___iadd__(*args)
def __isub__(*args): return _inaoqi.PySwigIterator___isub__(*args)
def __add__(*args): return _inaoqi.PySwigIterator___add__(*args)
def __sub__(*args): return _inaoqi.PySwigIterator___sub__(*args)
def __iter__(self): return self
PySwigIterator_swigregister = _inaoqi.PySwigIterator_swigregister
PySwigIterator_swigregister(PySwigIterator)
class StringVector(_object):
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, StringVector, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, StringVector, name)
__repr__ = _swig_repr
def iterator(*args): return _inaoqi.StringVector_iterator(*args)
def __iter__(self): return self.iterator()
def __nonzero__(*args): return _inaoqi.StringVector___nonzero__(*args)
def __len__(*args): return _inaoqi.StringVector___len__(*args)
def pop(*args): return _inaoqi.StringVector_pop(*args)
def __getslice__(*args): return _inaoqi.StringVector___getslice__(*args)
def __setslice__(*args): return _inaoqi.StringVector___setslice__(*args)
def __delslice__(*args): return _inaoqi.StringVector___delslice__(*args)
def __delitem__(*args): return _inaoqi.StringVector___delitem__(*args)
def __getitem__(*args): return _inaoqi.StringVector___getitem__(*args)
def __setitem__(*args): return _inaoqi.StringVector___setitem__(*args)
def append(*args): return _inaoqi.StringVector_append(*args)
def empty(*args): return _inaoqi.StringVector_empty(*args)
def size(*args): return _inaoqi.StringVector_size(*args)
def clear(*args): return _inaoqi.StringVector_clear(*args)
def swap(*args): return _inaoqi.StringVector_swap(*args)
def get_allocator(*args): return _inaoqi.StringVector_get_allocator(*args)
def begin(*args): return _inaoqi.StringVector_begin(*args)
def end(*args): return _inaoqi.StringVector_end(*args)
def rbegin(*args): return _inaoqi.StringVector_rbegin(*args)
def rend(*args): return _inaoqi.StringVector_rend(*args)
def pop_back(*args): return _inaoqi.StringVector_pop_back(*args)
def erase(*args): return _inaoqi.StringVector_erase(*args)
def __init__(self, *args):
this = _inaoqi.new_StringVector(*args)
try: self.this.append(this)
except: self.this = this
def push_back(*args): return _inaoqi.StringVector_push_back(*args)
def front(*args): return _inaoqi.StringVector_front(*args)
def back(*args): return _inaoqi.StringVector_back(*args)
def assign(*args): return _inaoqi.StringVector_assign(*args)
def resize(*args): return _inaoqi.StringVector_resize(*args)
def insert(*args): return _inaoqi.StringVector_insert(*args)
def reserve(*args): return _inaoqi.StringVector_reserve(*args)
def capacity(*args): return _inaoqi.StringVector_capacity(*args)
__swig_destroy__ = _inaoqi.delete_StringVector
__del__ = lambda self : None;
StringVector_swigregister = _inaoqi.StringVector_swigregister
StringVector_swigregister(StringVector)
setInstance = _inaoqi.setInstance
getMemoryProxy = _inaoqi.getMemoryProxy
_ALSystem = _inaoqi._ALSystem
class broker(_object):
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, broker, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, broker, name)
__repr__ = _swig_repr
def __init__(self, *args):
this = _inaoqi.new_broker(*args)
try: self.this.append(this)
except: self.this = this
__swig_destroy__ = _inaoqi.delete_broker
__del__ = lambda self : None;
def shutdown(*args): return _inaoqi.broker_shutdown(*args)
def isModulePresent(*args): return _inaoqi.broker_isModulePresent(*args)
def getGlobalModuleList(*args): return _inaoqi.broker_getGlobalModuleList(*args)
broker_swigregister = _inaoqi.broker_swigregister
broker_swigregister(broker)
class baseModule(_object):
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, baseModule, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, baseModule, name)
__repr__ = _swig_repr
def __init__(self, *args):
this = _inaoqi.new_baseModule(*args)
try: self.this.append(this)
except: self.this = this
def BIND_PYTHON(*args): return _inaoqi.baseModule_BIND_PYTHON(*args)
def _bindWithParam(*args): return _inaoqi.baseModule__bindWithParam(*args)
def exit(*args): return _inaoqi.baseModule_exit(*args)
def getName(*args): return _inaoqi.baseModule_getName(*args)
def getBrokerName(*args): return _inaoqi.baseModule_getBrokerName(*args)
def setModuleDescription(*args): return _inaoqi.baseModule_setModuleDescription(*args)
def addParam(*args): return _inaoqi.baseModule_addParam(*args)
def functionName(*args): return _inaoqi.baseModule_functionName(*args)
def autoBind(*args): return _inaoqi.baseModule_autoBind(*args)
def _methodMissing0(*args): return _inaoqi.baseModule__methodMissing0(*args)
def _methodMissing1(*args): return _inaoqi.baseModule__methodMissing1(*args)
def _methodMissing2(*args): return _inaoqi.baseModule__methodMissing2(*args)
def _methodMissing3(*args): return _inaoqi.baseModule__methodMissing3(*args)
def _methodMissing4(*args): return _inaoqi.baseModule__methodMissing4(*args)
def _methodMissing5(*args): return _inaoqi.baseModule__methodMissing5(*args)
def _methodMissing6(*args): return _inaoqi.baseModule__methodMissing6(*args)
def _methodMissing(*args): return _inaoqi.baseModule__methodMissing(*args)
def version(*args): return _inaoqi.baseModule_version(*args)
__swig_destroy__ = _inaoqi.delete_baseModule
__del__ = lambda self : None;
baseModule_swigregister = _inaoqi.baseModule_swigregister
baseModule_swigregister(baseModule)
class module(baseModule):
__swig_setmethods__ = {}
for _s in [baseModule]: __swig_setmethods__.update(getattr(_s,’__swig_setmethods__’,{}))
__setattr__ = lambda self, name, value: _swig_setattr(self, module, name, value)
__swig_getmethods__ = {}
for _s in [baseModule]: __swig_getmethods__.update(getattr(_s,’__swig_getmethods__’,{}))
__getattr__ = lambda self, name: _swig_getattr(self, module, name)
__repr__ = _swig_repr
def __init__(self, *args):
this = _inaoqi.new_module(*args)
try: self.this.append(this)
except: self.this = this
def BIND_PYTHON(*args): return _inaoqi.module_BIND_PYTHON(*args)
def exit(*args): return _inaoqi.module_exit(*args)
def getName(*args): return _inaoqi.module_getName(*args)
def getBrokerName(*args): return _inaoqi.module_getBrokerName(*args)
def _methodMissing(*args): return _inaoqi.module__methodMissing(*args)
def version(*args): return _inaoqi.module_version(*args)
__swig_destroy__ = _inaoqi.delete_module
__del__ = lambda self : None;
module_swigregister = _inaoqi.module_swigregister
module_swigregister(module)
class timeline(_object):
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, timeline, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, timeline, name)
__repr__ = _swig_repr
def __init__(self, *args):
this = _inaoqi.new_timeline(*args)
try: self.this.append(this)
except: self.this = this
__swig_destroy__ = _inaoqi.delete_timeline
__del__ = lambda self : None;
def play(*args): return _inaoqi.timeline_play(*args)
def pause(*args): return _inaoqi.timeline_pause(*args)
def stop(*args): return _inaoqi.timeline_stop(*args)
def goTo(*args): return _inaoqi.timeline_goTo(*args)
def getSize(*args): return _inaoqi.timeline_getSize(*args)
def getFPS(*args): return _inaoqi.timeline_getFPS(*args)
def setFPS(*args): return _inaoqi.timeline_setFPS(*args)
timeline_swigregister = _inaoqi.timeline_swigregister
timeline_swigregister(timeline)
class behavior(baseModule):
__swig_setmethods__ = {}
for _s in [baseModule]: __swig_setmethods__.update(getattr(_s,’__swig_setmethods__’,{}))
__setattr__ = lambda self, name, value: _swig_setattr(self, behavior, name, value)
__swig_getmethods__ = {}
for _s in [baseModule]: __swig_getmethods__.update(getattr(_s,’__swig_getmethods__’,{}))
__getattr__ = lambda self, name: _swig_getattr(self, behavior, name)
__repr__ = _swig_repr
def __init__(self, *args):
this = _inaoqi.new_behavior(*args)
try: self.this.append(this)
except: self.this = this
__swig_destroy__ = _inaoqi.delete_behavior
__del__ = lambda self : None;
def setEnabled(*args): return _inaoqi.behavior_setEnabled(*args)
def isEnabled(*args): return _inaoqi.behavior_isEnabled(*args)
def setResources(*args): return _inaoqi.behavior_setResources(*args)
def waitFor(*args): return _inaoqi.behavior_waitFor(*args)
def waitResourcesCallback(*args): return _inaoqi.behavior_waitResourcesCallback(*args)
def isResourceFree(*args): return _inaoqi.behavior_isResourceFree(*args)
def waitResourceFree(*args): return _inaoqi.behavior_waitResourceFree(*args)
def waitResources(*args): return _inaoqi.behavior_waitResources(*args)
def releaseResource(*args): return _inaoqi.behavior_releaseResource(*args)
def addInput(*args): return _inaoqi.behavior_addInput(*args)
def addOutput(*args): return _inaoqi.behavior_addOutput(*args)
def addParameter(*args): return _inaoqi.behavior_addParameter(*args)
def getParameter(*args): return _inaoqi.behavior_getParameter(*args)
def getParametersList(*args): return _inaoqi.behavior_getParametersList(*args)
def setParameter(*args): return _inaoqi.behavior_setParameter(*args)
def stimulateIO(*args): return _inaoqi.behavior_stimulateIO(*args)
def BIND_PYTHON(*args): return _inaoqi.behavior_BIND_PYTHON(*args)
def setModuleDescription(*args): return _inaoqi.behavior_setModuleDescription(*args)
def addParam(*args): return _inaoqi.behavior_addParam(*args)
def exit(*args): return _inaoqi.behavior_exit(*args)
def getName(*args): return _inaoqi.behavior_getName(*args)
def getBrokerName(*args): return _inaoqi.behavior_getBrokerName(*args)
def _methodMissing(*args): return _inaoqi.behavior__methodMissing(*args)
def version(*args): return _inaoqi.behavior_version(*args)
def hasTimeline(*args): return _inaoqi.behavior_hasTimeline(*args)
def getTimeline(*args): return _inaoqi.behavior_getTimeline(*args)
def hasParentTimeline(*args): return _inaoqi.behavior_hasParentTimeline(*args)
def getParentTimeline(*args): return _inaoqi.behavior_getParentTimeline(*args)
behavior_swigregister = _inaoqi.behavior_swigregister
behavior_swigregister(behavior)
class proxy(_object):
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, proxy, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, proxy, name)
__repr__ = _swig_repr
def __init__(self, *args):
this = _inaoqi.new_proxy(*args)
try: self.this.append(this)
except: self.this = this
def pythonCall(*args): return _inaoqi.proxy_pythonCall(*args)
def pythonPCall(*args): return _inaoqi.proxy_pythonPCall(*args)
def wait(*args): return _inaoqi.proxy_wait(*args)
def stop(*args): return _inaoqi.proxy_stop(*args)
def isRunning(*args): return _inaoqi.proxy_isRunning(*args)
__swig_destroy__ = _inaoqi.delete_proxy
__del__ = lambda self : None;
proxy_swigregister = _inaoqi.proxy_swigregister
proxy_swigregister(proxy)
class ALMemoryProxy(_object):
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, ALMemoryProxy, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, ALMemoryProxy, name)
__repr__ = _swig_repr
def __init__(self, *args):
this = _inaoqi.new_ALMemoryProxy(*args)
try: self.this.append(this)
except: self.this = this
__swig_setmethods__[“post”] = _inaoqi.ALMemoryProxy_post_set
__swig_getmethods__[“post”] = _inaoqi.ALMemoryProxy_post_get
if _newclass:post = _swig_property(_inaoqi.ALMemoryProxy_post_get, _inaoqi.ALMemoryProxy_post_set)
def getGenericProxy(*args): return _inaoqi.ALMemoryProxy_getGenericProxy(*args)
def declareEvent(*args): return _inaoqi.ALMemoryProxy_declareEvent(*args)
def exit(*args): return _inaoqi.ALMemoryProxy_exit(*args)
def getBrokerName(*args): return _inaoqi.ALMemoryProxy_getBrokerName(*args)
def getData(*args): return _inaoqi.ALMemoryProxy_getData(*args)
def getDataList(*args): return _inaoqi.ALMemoryProxy_getDataList(*args)
def getDataListName(*args): return _inaoqi.ALMemoryProxy_getDataListName(*args)
def getDataOnChange(*args): return _inaoqi.ALMemoryProxy_getDataOnChange(*args)
def getDataPtr(*args): return _inaoqi.ALMemoryProxy_getDataPtr(*args)
def getDescriptionList(*args): return _inaoqi.ALMemoryProxy_getDescriptionList(*args)
def getEventHistory(*args): return _inaoqi.ALMemoryProxy_getEventHistory(*args)
def getEventList(*args): return _inaoqi.ALMemoryProxy_getEventList(*args)
def getExtractorEvent(*args): return _inaoqi.ALMemoryProxy_getExtractorEvent(*args)
def getListData(*args): return _inaoqi.ALMemoryProxy_getListData(*args)
def getMethodHelp(*args): return _inaoqi.ALMemoryProxy_getMethodHelp(*args)
def getMethodList(*args): return _inaoqi.ALMemoryProxy_getMethodList(*args)
def getMicroEventList(*args): return _inaoqi.ALMemoryProxy_getMicroEventList(*args)
def getModuleHelp(*args): return _inaoqi.ALMemoryProxy_getModuleHelp(*args)
def getSubscribers(*args): return _inaoqi.ALMemoryProxy_getSubscribers(*args)
def getTimestamp(*args): return _inaoqi.ALMemoryProxy_getTimestamp(*args)
def getType(*args): return _inaoqi.ALMemoryProxy_getType(*args)
def getUsage(*args): return _inaoqi.ALMemoryProxy_getUsage(*args)
def insertData(*args): return _inaoqi.ALMemoryProxy_insertData(*args)
def insertListData(*args): return _inaoqi.ALMemoryProxy_insertListData(*args)
def isRunning(*args): return _inaoqi.ALMemoryProxy_isRunning(*args)
def ping(*args): return _inaoqi.ALMemoryProxy_ping(*args)
def raiseEvent(*args): return _inaoqi.ALMemoryProxy_raiseEvent(*args)
def raiseMicroEvent(*args): return _inaoqi.ALMemoryProxy_raiseMicroEvent(*args)
def removeData(*args): return _inaoqi.ALMemoryProxy_removeData(*args)
def removeMicroEvent(*args): return _inaoqi.ALMemoryProxy_removeMicroEvent(*args)
def setDescription(*args): return _inaoqi.ALMemoryProxy_setDescription(*args)
def stop(*args): return _inaoqi.ALMemoryProxy_stop(*args)
def subscribeToEvent(*args): return _inaoqi.ALMemoryProxy_subscribeToEvent(*args)
def subscribeToMicroEvent(*args): return _inaoqi.ALMemoryProxy_subscribeToMicroEvent(*args)
def unregisterModuleReference(*args): return _inaoqi.ALMemoryProxy_unregisterModuleReference(*args)
def unsubscribeToEvent(*args): return _inaoqi.ALMemoryProxy_unsubscribeToEvent(*args)
def unsubscribeToMicroEvent(*args): return _inaoqi.ALMemoryProxy_unsubscribeToMicroEvent(*args)
def version(*args): return _inaoqi.ALMemoryProxy_version(*args)
def wait(*args): return _inaoqi.ALMemoryProxy_wait(*args)
__swig_destroy__ = _inaoqi.delete_ALMemoryProxy
__del__ = lambda self : None;
ALMemoryProxy_swigregister = _inaoqi.ALMemoryProxy_swigregister
ALMemoryProxy_swigregister(ALMemoryProxy)

pynaoqi-python-2.7-naoqi-1.14-mac64/motion.py
# Class Motion for storing useful ALMotion constants
# SPACES
SPACE_TORSO = 0
SPACE_WORLD = 1
SPACE_NAO = 2
# NEW in 1.14
FRAME_TORSO = 0
FRAME_WORLD = 1
FRAME_ROBOT = 2
# MOVEMENT
MVT_RELATIVE = 0
MVT_ABSOLUTE = 1
#ANGLE TYPE
COMMANDS = 0,
SENSORS = 1
# AXIS MASK
AXIS_MASK_X = 1
AXIS_MASK_Y = 2
AXIS_MASK_Z = 4
AXIS_MASK_WX = 8
AXIS_MASK_WY = 16
AXIS_MASK_WZ = 32
AXIS_MASK_ALL = 63
AXIS_MASK_VEL = 7
AXIS_MASK_ROT = 56
# COMPUTING
TO_RAD = 0.01745329
TO_DEG = 57.295779513082323

pynaoqi-python-2.7-naoqi-1.14-mac64/vision_definitions.py
# Useful constants used by the Vision modules.
# Camera model
kOV7670 = 1 # VGA camera
kMT9M114 = 2 # HD wide angle camera
# Image format
k960p = 3 # 1280*960
k4VGA = 3 # 1280*960
kVGA = 2 # 640*480
kQVGA = 1 # 320*240
kQQVGA = 0 # 160*120
# Color Space
kYuvColorSpace = 0
kyUvColorSpace = 1
kyuVColorSpace = 2
kRgbColorSpace = 3
krGbColorSpace = 4
krgBColorSpace = 5
kHsvColorSpace = 6
khSvColorSpace = 7
khsVColorSpace = 8
kYUV422InterlacedColorSpace = 9 #deprecated
kYUV422ColorSpace = 9
kYUVColorSpace = 10
kRGBColorSpace = 11
kHSVColorSpace = 12
kBGRColorSpace = 13
kYYCbCrColorSpace = 14
kH2RGBColorSpace = 15
kHSMixedColorSpace = 16

# Scale methods
kSimpleScaleMethod = 0
kAverageScaleMethod = 1
kQualityScaleMethod = 2
kNoScaling = 3

# Standard Id
kCameraBrightnessID = 0
kCameraContrastID = 1
kCameraSaturationID = 2
kCameraHueID = 3
kCameraRedChromaID = 4
kCameraBlueChromaID = 5
kCameraGainID = 6
kCameraHFlipID = 7
kCameraVFlipID = 8
kCameraLensXID = 9
kCameraLensYID = 10
kCameraAutoExpositionID = 11
kCameraAutoWhiteBalanceID = 12
kCameraAutoGainID = 13
kCameraResolutionID = 14
kCameraFrameRateID = 15
kCameraBufferSizeID = 16
kCameraExposureID = 17
kCameraSelectID = 18
kCameraSetDefaultParamsID = 19
kCameraColorSpaceID = 20
kCameraExposureCorrectionID = 21
kCameraAecAlgorithmID = 22
kCameraFastSwitchID = 23
kCameraSharpnessID = 24
kCameraAwbGreenGainID = 25
kCameraAblcID = 26
kCameraAblcTargetID = 27
kCameraAblcStableRangeID = 28
kCameraBlcBlueID = 29
kCameraBlcRedID = 30
kCameraBlcGbID = 31
kCameraBlcGrID = 32
kCameraWhiteBalanceID = 33
kCameraBacklightCompensationID = 34

#! /usr/bin/python
import naoqi
import time
ipaddress = “192.168.1.106” #Nao’s IP address
testtype = 6
# a broker is needed for any event handling
broker = naoqi.ALBroker(“pythonBroker”, “0.0.0.0”, 9999, ipaddress, 9559)
# code example to say anything
talkproxy = naoqi.ALProxy(“ALTextToSpeech”, ipaddress, 9559)
talkproxy.say(“Hello”)

# code example to retrieve sensor values
if testtype == 2:
sonarproxy = naoqi.ALProxy(“ALSonar”, ipaddress, 9559)
memoryproxy = naoqi.ALProxy(“ALMemory”, ipaddress, 9559)
sonarproxy.subscribe(“MyApplication”)
leftdist = memoryproxy.getData(“Device/SubDeviceList/US/Left/Sensor/Value”)
rightdist = memoryproxy.getData(“Device/SubDeviceList/US/Right/Sensor/Value”)
print “Left distance = “, leftdist, “Right distance = “, rightdist
sonarproxy.unsubscribe(“MyApplication”)

# code example to move to one of the standard poses
if testtype == 3:
postureproxy = naoqi.ALProxy(“ALRobotPosture”, ipaddress, 9559)
postureproxy.goToPosture(“StandInit”, 1.0)

#code example to walk
if testtype == 4:
motionproxy = naoqi.ALProxy(“ALMotion”, ipaddress, 9559)
t = True
motionproxy.setWalkArmsEnabled(t,t)
motionproxy.moveTo(-0.2, 0.0, 0.0) # walk to a particular destination
time.sleep(2)
motionproxy.setWalkTargetVelocity(1.0,0.0,0.0,1.0) # walk in direction til stop
time.sleep(4)
motionproxy.stopMove()

# code example to detect sound direction
if testtype == 5:
class myModule(naoqi.ALModule):
“””callback module”””
def soundChanged(self, strVarName, value, strMessage):
“””callback function”””
if value[1][0] < 0: print "Turn right", -value[1][0], "radians" else: print "Turn left", value[1][0], "radians" pythonModule = myModule("pythonModule") soundproxy = naoqi.ALProxy("ALAudioSourceLocalization", ipaddress, 9559) memoryproxy = naoqi.ALProxy("ALMemory", ipaddress, 9559) memoryproxy.subscribeToEvent("ALAudioSourceLocalization/SoundLocated", "pythonModule", "soundChanged") soundproxy.subscribe("MyApplication") time.sleep(10) soundproxy.unsubscribe("MyApplication") memoryproxy.unsubscribeToEvent("ALAudioSourceLocalization/SoundLocated", "pythonModule", "soundChanged") # code example to recognize words if testtype == 6: class myModule(naoqi.ALModule): """callback module""" def wordChanged(self, strVarName, value, strMessage): """callback function""" if value[1] > 0.6:
print “Word recognized is”, value[0]
pythonModule = myModule(“pythonModule”)
speechproxy = naoqi.ALProxy(“ALSpeechRecognition”, ipaddress, 9559)
memoryproxy = naoqi.ALProxy(“ALMemory”, ipaddress, 9559)
#speechproxy.setWordListAsVocabulary([“yes”, “no”])
t = True
speechproxy.setVocabulary([“yes”, “no”], t)
memoryproxy.subscribeToEvent(“WordRecognized”, “pythonModule”, “wordChanged”)
speechproxy.subscribe(“MyApplication”)
time.sleep(15)
speechproxy.unsubscribe(“MyApplication”)
memoryproxy.unsubscribeToEvent(“WordRecognized”, “pythonModule”, “wordChanged”)

talkproxy.say(“Goodbye”)