#! /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("MyApplica ...

1. #! /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

2. 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)

3. memoryproxy.subscribeToEvent("ALAudioSourceLocalization/
SoundLocated", "pythonModule", "soundChanged")
soundproxy.subscribe("MyApplication")
time.sleep(10)
soundproxy.unsubscribe("MyApplication")
memoryproxy.unsubscribeToEvent("ALAudioSourceLocalizatio
n/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")

4. talkproxy.say("Goodbye")
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"""

5. # 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(functio
n.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):

6. 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",

7. "", # record.filename in this case is simply '<string>'
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)

8. 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")

9. _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_co
de.co_varnames)-1)
def __del__(self):
NaoQiModule.__del__(self)
self.logger.removeHandler(self.behaviorloghandler)
self.behaviorloghandler.close()

10. 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)

11. 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)

12. 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:

13. 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"

14. 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"),

15. 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

16. 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

17. 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;

18. - 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

19. (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

20. 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

21. 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

22. 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

23. 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.

24. 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.

25. 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):

26. 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

27. 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):

28. 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

29. __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)

30. 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

31. 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):

32. """__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)

33. 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)

34. 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):

35. """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"""

36. __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

37. 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):

38. """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):

39. """
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)

40. 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,

41. 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)"""

42. 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):
"""

43. 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)

44. 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):

45. """
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)

46. 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)

47. 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)

48. 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

49. __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)

50. 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

51. __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"""

52. 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)

53. 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

54. 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

55. 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)

56. 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)

57. 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)

58. __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"""

59. 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"""

60. 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"""

61. 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)

62. __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):

63. """__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):

64. """__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):

65. """__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"] =

66. _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):
"""

67. 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

68. __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)

69. 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"""

70. 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,

71. 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,

72. _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):

73. """__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:

74. 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)

75. 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)

76. 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)

77. 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

78. __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):

79. """__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)

80. 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)

81. __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"] =

82. _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"""

83. 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)