Programming- Nao Robot by choregraphe
SamG
pynaoqi-python-2.7-naoqi-1.14.5-linux64.tarpynaoqi-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 '<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) 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
