/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ /* ex: set filetype=cpp softtabstop=4 shiftwidth=4 tabstop=4 cindent expandtab: */ /* Author(s): Anton Deguet Created on: 2008-01-17 (C) Copyright 2008-2026 Johns Hopkins University (JHU), All Rights Reserved. --- begin cisst license - do not edit --- This software is provided "as is" under an open source license, with no warranty. The complete license can be found in license.txt and http://www.cisst.org/cisst/license.txt. --- end cisst license --- */ %module cisstMultiTaskPython %include "std_string.i" %include "std_vector.i" %include "std_map.i" %include "std_pair.i" %include "std_streambuf.i" %include "std_iostream.i" %include "swigrun.i" %import "cisstConfig.h" %import "cisstCommon/cisstCommon.i" %import "cisstVector/cisstVector.i" %import "cisstOSAbstraction/cisstOSAbstraction.i" %import "cisstMultiTask/mtsConfig.h" %init %{ import_array() // numpy initialization %} %header %{ #include %} // use class type to create the correct Python type %apply cmnGenericObject * {mtsGenericObject *}; %template(mtsStringVector) std::vector; %template(mtsDoubleVector) std::vector; // Generate parameter documentation for IRE %feature("autodoc", "1"); %ignore *::AddCommandVoid; %ignore *::AddEventVoid; %ignore mtsComponent::AddRequiredInterface; %ignore mtsComponent::AddProvidedInterface; %ignore mtsManagerLocal::AddTask; %ignore mtsManagerLocal::GetTask; %ignore mtsManagerLocal::AddDevice; %ignore mtsManagerLocal::GetDevice; #define CISST_EXPORT #define CISST_DEPRECATED // enums defined in mtsForwardDeclarations %include "cisstMultiTask/mtsForwardDeclarations.h" %include "cisstMultiTask/mtsExecutionResult.h" // Wrap base class %include "cisstMultiTask/mtsGenericObject.h" // Wrap commands %include "cisstMultiTask/mtsCommandBase.h" %include "cisstMultiTask/mtsCommandVoid.h" %include "cisstMultiTask/mtsCommandVoidReturn.h" %include "cisstMultiTask/mtsCommandRead.h" %include "cisstMultiTask/mtsCommandWriteBase.h" %include "cisstMultiTask/mtsCommandWriteReturn.h" %include "cisstMultiTask/mtsCommandQualifiedRead.h" %include "cisstMultiTask/mtsCommandVoidReturn.h" // Wrap event receivers %include "cisstMultiTask/mtsEventReceiver.h" // Extend mtsCommandVoid %extend mtsCommandVoid { %pythoncode %{ def __call__(self): return self.Execute(MTS_NOT_BLOCKING).GetResult() %} } // Extend mtsCommandVoidReturn %extend mtsCommandVoidReturn { %pythoncode %{ def UpdateFromC(self): try: tmpObject = self.GetResultPrototype().Services().Create() self.ArgumentType = tmpObject.__class__ except Exception as e: print('VoidReturn command ' + self.GetName() + ': ' + str(e)) def __call__(self): # PK: figure out if the first statement (after try) is still needed try: argument = self.ArgumentType(self.GetResultPrototype()) except Exception: argument = self.GetResultPrototype() # Probably should check return value below self.Execute(argument) # If argument has a GetDataCopy method, we assume it is derived from # mtsGenericObjectProxy (%extend is used to add this method). if hasattr(argument,"GetDataCopy"): return argument.GetDataCopy() else: return argument %} } // Extend mtsCommandWrite %extend mtsCommandWriteBase { %pythoncode %{ def UpdateFromC(self): try: tmpObject = self.GetArgumentClassServices().Create() self.ArgumentType = tmpObject.__class__ except Exception as e: print('Write command ' + self.GetName() + ': ' + str(e)) def __call__(self, argument): if isinstance(argument, self.ArgumentType): return self.Execute(argument, MTS_NOT_BLOCKING).GetResult() else: realArgument = self.ArgumentType(argument) return self.Execute(realArgument, MTS_NOT_BLOCKING).GetResult() %} } // Extend mtsCommandWriteReturn %extend mtsCommandWriteReturn { %pythoncode %{ def UpdateFromC(self): try: tmp1Object = self.GetArgumentPrototype().Services().Create() self.ArgumentType = tmp1Object.__class__ tmp2Object = self.GetResultPrototype().Services().Create() self.ResultType = tmp2Object.__class__ except Exception as e: print('WriteReturn command ' + self.GetName() + ': ' + str(e)) def __call__(self, argument): result = self.ResultType(self.GetResultPrototype()) # Probably should check return value of self.Execute if isinstance(argument, self.ArgumentType): self.Execute(argument, result) else: realArgument = self.ArgumentType(argument1) self.Execute(realArgument, result) # If result has a GetDataCopy method, we assume it is derived from # mtsGenericObjectProxy (%extend is used to add this method). if hasattr(result,"GetDataCopy"): return result.GetDataCopy() else: return result %} } // Extend mtsCommandRead %extend mtsCommandRead { %pythoncode %{ def UpdateFromC(self): try: tmpObject = self.GetArgumentPrototype().Services().Create() self.ArgumentType = tmpObject.__class__ except Exception as e: print('Read command ' + self.GetName() + ': ' + str(e)) except AttributeError as e: print('Read command ' + self.GetName() + ': ' + str(e)) def __call__(self): # PK: figure out if the first statement (after try) is still needed try: argument = self.ArgumentType(self.GetArgumentPrototype()) except Exception: argument = self.GetArgumentPrototype() # Probably should check return value below self.Execute(argument) # If argument has a GetDataCopy method, we assume it is derived from # mtsGenericObjectProxy (%extend is used to add this method). if hasattr(argument,"GetDataCopy"): return argument.GetDataCopy() else: return argument %} } // Extend mtsCommandQualifiedRead %extend mtsCommandQualifiedRead { %pythoncode %{ def UpdateFromC(self): try: tmp1Object = self.GetArgument1Prototype().Services().Create() self.Argument1Type = tmp1Object.__class__ tmp2Object = self.GetArgument2Prototype().Services().Create() self.Argument2Type = tmp2Object.__class__ except Exception as e: print('Qualified read command ' + self.GetName() + ': ' + str(e)) def __call__(self, argument1): argument2 = self.Argument2Type(self.GetArgument2Prototype()) # Probably should check return value of self.Execute if isinstance(argument1, self.Argument1Type): self.Execute(argument1, argument2) else: realArgument1 = self.Argument1Type(argument1) self.Execute(realArgument1, argument2) # If argument2 has a GetDataCopy method, we assume it is derived from # mtsGenericObjectProxy (%extend is used to add this method). if hasattr(argument2,"GetDataCopy"): return argument2.GetDataCopy() else: return argument2 %} } // Wrap functions %include "cisstMultiTask/mtsFunctionBase.h" %include "cisstMultiTask/mtsFunctionVoid.h" %include "cisstMultiTask/mtsFunctionVoidReturn.h" %include "cisstMultiTask/mtsFunctionRead.h" %include "cisstMultiTask/mtsFunctionWrite.h" %include "cisstMultiTask/mtsFunctionWriteReturn.h" %include "cisstMultiTask/mtsFunctionQualifiedRead.h" // Extend mtsFunctionVoid %extend mtsFunctionVoid { %pythoncode %{ def __call__(self): return self.Execute().GetResult() %} } // Extend mtsFunctionVoidReturn %extend mtsFunctionVoidReturn { %pythoncode %{ def UpdateFromC(self): if self.IsValid(): try: tmpObject = self.GetResultPrototype().Services().Create() self.ArgumentType = tmpObject.__class__ except Exception as e: print('VoidReturn function ' + self.GetCommand().GetName() + ': ' + str(e)) else: print('VoidReturn function not valid') def __call__(self): # PK: figure out if the first statement (after try) is still needed try: argument = self.ArgumentType(self.GetResultPrototype()) except Exception: argument = self.GetResultPrototype() # Probably should check return value below self.ExecuteGeneric(argument) # If argument has a GetDataCopy method, we assume it is derived from # mtsGenericObjectProxy (%extend is used to add this method). if hasattr(argument,"GetDataCopy"): return argument.GetDataCopy() else: return argument %} } // Extend mtsFunctionRead %extend mtsFunctionRead { %pythoncode %{ def UpdateFromC(self): if self.IsValid(): try: tmpObject = self.GetArgumentPrototype().Services().Create() self.ArgumentType = tmpObject.__class__ except Exception as e: print('Read function ' + self.GetCommand().GetName() + ': ' + str(e)) else: print('Read function not valid') def __call__(self): # PK: figure out if the first statement (after try) is still needed try: argument = self.ArgumentType(self.GetArgumentPrototype()) except Exception: argument = self.GetArgumentPrototype() # Probably should check return value below self.ExecuteGeneric(argument) # If argument has a GetDataCopy method, we assume it is derived from # mtsGenericObjectProxy (%extend is used to add this method). if hasattr(argument,"GetDataCopy"): return argument.GetDataCopy() else: return argument %} } // Extend mtsFunctionWrite %extend mtsFunctionWrite { %pythoncode %{ def UpdateFromC(self): if self.IsValid(): try: tmpObject = self.GetArgumentPrototype().Services().Create() self.ArgumentType = tmpObject.__class__ except Exception as e: print('Write function ' + self.GetCommand().GetName() + ': ' + str(e)) else: print('Write function not valid') def __call__(self, argument): if isinstance(argument, self.ArgumentType): return self.ExecuteGeneric(argument).GetResult() else: realArgument = self.ArgumentType(argument) return self.ExecuteGeneric(realArgument).GetResult() %} } // Extend mtsFunctionWriteReturn %extend mtsFunctionWriteReturn { %pythoncode %{ def UpdateFromC(self): if self.IsValid(): try: tmp1Object = self.GetArgumentPrototype().Services().Create() self.ArgumentType = tmp1Object.__class__ tmp2Object = self.GetResultPrototype().Services().Create() self.ResultType = tmp2Object.__class__ except Exception as e: print('WriteReturn function ' + self.GetCommand().GetName() + ': ' + str(e)) else: print('WriteReturn function not valid') def __call__(self, argument): result = self.ResultType(self.GetResultPrototype()) # Probably should check return value of self.Execute if isinstance(argument, self.ArgumentType): self.ExecuteGeneric(argument, result) else: realArgument = self.ArgumentType(argument1) self.ExecuteGeneric(realArgument, result) # If result has a GetDataCopy method, we assume it is derived from # mtsGenericObjectProxy (%extend is used to add this method). if hasattr(result,"GetDataCopy"): return result.GetDataCopy() else: return result %} } // Extend mtsFunctionQualifiedRead %extend mtsFunctionQualifiedRead { %pythoncode %{ def UpdateFromC(self): if self.IsValid(): try: tmp1Object = self.GetArgument1Prototype().Services().Create() self.Argument1Type = tmp1Object.__class__ tmp2Object = self.GetArgument2Prototype().Services().Create() self.Argument2Type = tmp2Object.__class__ except Exception as e: print('Qualified read function ' + self.GetCommand().GetName() + ': ' + str(e)) else: print('QualifiedRead function not valid') def __call__(self, argument1): argument2 = self.Argument2Type(self.GetArgument2Prototype()) # Probably should check return value of self.Execute if isinstance(argument1, self.Argument1Type): self.ExecuteGeneric(argument1, argument2) else: realArgument1 = self.Argument1Type(argument1) self.ExecuteGeneric(realArgument1, argument2) # If argument2 has a GetDataCopy method, we assume it is derived from # mtsGenericObjectProxy (%extend is used to add this method). if hasattr(argument2,"GetDataCopy"): return argument2.GetDataCopy() else: return argument2 %} } // Wrap tasks and components %include "cisstMultiTask/mtsComponent.h" %template(mtsComponentConstructorNameAndInt) mtsComponentConstructorNameAndArg; %template(mtsComponentConstructorNameAndUInt) mtsComponentConstructorNameAndArg; %template(mtsComponentConstructorNameAndLong) mtsComponentConstructorNameAndArg; %template(mtsComponentConstructorNameAndULong) mtsComponentConstructorNameAndArg; %template(mtsComponentConstructorNameAndDouble) mtsComponentConstructorNameAndArg; %template(mtsComponentConstructorNameAndString) mtsComponentConstructorNameAndArg; %extend mtsComponent { %pythoncode %{ def UpdateFromC(self): interfaces = mtsComponent.GetNamesOfInterfacesProvided(self) for interface in interfaces: interfaceNoSpace = interface.replace(' ', '') interfaceFrontEnd = mtsComponent.GetInterfaceProvided(self, interface) self.__dict__[interfaceNoSpace] = mtsInterfaceProvided.GetEndUserInterface(interfaceFrontEnd, 'Python') self.__dict__[interfaceNoSpace].UpdateFromC() interfaces = mtsComponent.GetNamesOfInterfacesRequired(self) for interface in interfaces: interfaceNoSpace = interface.replace(' ', '') self.__dict__[interfaceNoSpace] = mtsComponent.GetInterfaceRequired(self, interface) # Only call UpdateFromC if required interface is connected to a provided interface if self.__dict__[interfaceNoSpace].GetConnectedInterface(): self.__dict__[interfaceNoSpace].UpdateFromC() def AddInterfaceRequiredFromProvided(self, interfaceProvided, interfaceRequiredName = ''): if not isinstance(interfaceProvided, mtsInterfaceProvidedDescription): print('Parameter must be of type mtsInterfaceProvidedDescription') return if not interfaceRequiredName: interfaceProvidedNoSpace = interfaceProvided.InterfaceName.replace(' ', '') interfaceRequiredName = 'RequiredFor' + interfaceProvidedNoSpace else: interfaceRequiredName = interfaceRequiredName.replace(' ', '') interfaceRequired = self.AddInterfaceRequired(interfaceRequiredName, MTS_OPTIONAL) if not interfaceRequired: return self.__dict__[interfaceRequired.GetName()] = interfaceRequired for command in interfaceProvided.CommandsVoid: func = mtsFunctionVoid() interfaceRequired.AddFunction(command.Name, func) func.thisown = 0 for command in interfaceProvided.CommandsVoidReturn: func = mtsFunctionVoidReturn() interfaceRequired.AddFunction(command.Name, func) func.thisown = 0 for command in interfaceProvided.CommandsWrite: func = mtsFunctionWrite() interfaceRequired.AddFunction(command.Name, func) func.thisown = 0 for command in interfaceProvided.CommandsWriteReturn: func = mtsFunctionWriteReturn() interfaceRequired.AddFunction(command.Name, func) func.thisown = 0 for command in interfaceProvided.CommandsQualifiedRead: func = mtsFunctionQualifiedRead() interfaceRequired.AddFunction(command.Name, func) func.thisown = 0 for command in interfaceProvided.CommandsRead: func = mtsFunctionRead() interfaceRequired.AddFunction(command.Name, func) func.thisown = 0 return interfaceRequired # otherComponentInterface should be a tuple ('process', 'component', 'interfaceProvided') # or ('component', 'interfaceProvided') def AddInterfaceRequiredAndConnect(self, otherComponentInterface): try: LCM = mtsManagerLocal.GetInstance() localProcessName = LCM.GetProcessName() num = len(otherComponentInterface) if 2 <= num <= 3: interfaceName = otherComponentInterface[num-1] componentName = otherComponentInterface[num-2] if num == 3: processName = otherComponentInterface[num-3] else: processName = localProcessName interfaceDescription = LCM.GetInterfaceProvidedDescription(processName, componentName, interfaceName) if not interfaceDescription.InterfaceName: print('No provided interface (empty string)') return None interfaceRequiredName = 'RequiredFor' + componentName + '_' + interfaceName; interfaceRequired = self.AddInterfaceRequiredFromProvided(interfaceDescription, interfaceRequiredName) if (processName != localProcessName): LCM.Connect(localProcessName, self.GetName(), interfaceRequired.GetName(), processName, componentName, interfaceName) else: LCM.Connect(self.GetName(), interfaceRequired.GetName(), componentName, interfaceName) interfaceRequired.UpdateFromC() if interfaceRequired.GetConnectedInterface(): print('Required interface ' + interfaceRequired.GetName() + ' connected.') else: print('Required interface ' + interfaceRequired.GetName() + ' not connected.') return interfaceRequired else: print('Parameter error: must specify (process, component, interface) or (component, interface)') except TypeError as e: print('Parameter error: must specify (process, component, interface) or (component, interface), caught exception: ' + str(e)) %} } %include "cisstMultiTask/mtsInterface.h" %include "cisstMultiTask/mtsInterfaceProvided.h" %extend mtsInterfaceProvided { %pythoncode %{ def UpdateFromC(self): commands = mtsInterfaceProvided.GetNamesOfCommandsVoid(self) for command in commands: self.__dict__[command] = mtsInterfaceProvided.GetCommandVoid(self, command) commands = mtsInterfaceProvided.GetNamesOfCommandsVoidReturn(self) for command in commands: self.__dict__[command] = mtsInterfaceProvided.GetCommandVoidReturn(self, command) self.__dict__[command].UpdateFromC() commands = mtsInterfaceProvided.GetNamesOfCommandsWrite(self) for command in commands: self.__dict__[command] = mtsInterfaceProvided.GetCommandWrite(self, command) self.__dict__[command].UpdateFromC() commands = mtsInterfaceProvided.GetNamesOfCommandsWriteReturn(self) for command in commands: self.__dict__[command] = mtsInterfaceProvided.GetCommandWriteReturn(self, command) self.__dict__[command].UpdateFromC() commands = mtsInterfaceProvided.GetNamesOfCommandsQualifiedRead(self) for command in commands: self.__dict__[command] = mtsInterfaceProvided.GetCommandQualifiedRead(self, command) self.__dict__[command].UpdateFromC() commands = mtsInterfaceProvided.GetNamesOfCommandsRead(self) for command in commands: self.__dict__[command] = mtsInterfaceProvided.GetCommandRead(self, command) self.__dict__[command].UpdateFromC() %} } %include "cisstMultiTask/mtsInterfaceRequired.h" %extend mtsInterfaceRequired { %pythoncode %{ def UpdateFromC(self): if not self.GetConnectedInterface(): print('Required interface ' + self.GetName() + ' not yet connected.') return functions = mtsInterfaceRequired.GetNamesOfFunctionsVoid(self) for function in functions: self.__dict__[function] = mtsInterfaceRequired.GetFunctionVoid(self, function) functions = mtsInterfaceRequired.GetNamesOfFunctionsVoidReturn(self) for function in functions: self.__dict__[function] = mtsInterfaceRequired.GetFunctionVoidReturn(self, function) self.__dict__[function].UpdateFromC() functions = mtsInterfaceRequired.GetNamesOfFunctionsWrite(self) for function in functions: self.__dict__[function] = mtsInterfaceRequired.GetFunctionWrite(self, function) self.__dict__[function].UpdateFromC() functions = mtsInterfaceRequired.GetNamesOfFunctionsWriteReturn(self) for function in functions: self.__dict__[function] = mtsInterfaceRequired.GetFunctionWriteReturn(self, function) self.__dict__[function].UpdateFromC() functions = mtsInterfaceRequired.GetNamesOfFunctionsQualifiedRead(self) for function in functions: self.__dict__[function] = mtsInterfaceRequired.GetFunctionQualifiedRead(self, function) self.__dict__[function].UpdateFromC() functions = mtsInterfaceRequired.GetNamesOfFunctionsRead(self) for function in functions: self.__dict__[function] = mtsInterfaceRequired.GetFunctionRead(self, function) self.__dict__[function].UpdateFromC() %} } // Wrap manager component services (includes internal required interface) // Typemaps below are for GetNamesOfInterfaces, so that the two vectors of strings // (required and provided interfaces) can be returned as a list of lists of strings, // i.e., ((req1, req2, ...),(prov1, prov2, ...)) %typemap(in, numinputs=0) std::vector & namesOfInterfacesRequired (std::vector temp) { $1 = &temp; } %typemap(in, numinputs=0) std::vector & namesOfInterfacesProvided (std::vector temp) { $1 = &temp; } %typemap(argout) std::vector & namesOfInterfacesRequired { Py_DECREF($result); // Garbage collect the returned "bool" if (!result) { PyErr_SetString(PyExc_RuntimeError, "Failed to get interfaces"); return NULL; } $result = PyTuple_New(2); PyObject *required = PyTuple_New((*$1).size()); PyTuple_SetItem($result,0,required); size_t i; for (i = 0; i < (*$1).size(); i++) PyTuple_SetItem(required,i,PyUnicode_FromString((*$1)[i].c_str())); } %typemap(argout) std::vector & namesOfInterfacesProvided { PyObject *provided = PyTuple_New((*$1).size()); PyTuple_SetItem($result,1,provided); size_t i; for (i = 0; i < (*$1).size(); i++) PyTuple_SetItem(provided,i,PyUnicode_FromString((*$1)[i].c_str())); } %include "cisstMultiTask/mtsManagerComponentServices.h" %include "cisstMultiTask/mtsTask.h" %include "cisstMultiTask/mtsTaskContinuous.h" %include "cisstMultiTask/mtsTaskPeriodic.h" %include "cisstMultiTask/mtsTaskFromSignal.h" %include "cisstMultiTask/mtsManagerLocal.h" %extend mtsManagerLocal { %pythoncode %{ def UpdateFromC(self): comps = mtsManagerLocal.GetNamesOfComponents(self) for comp in comps: self.__dict__[comp] = mtsManagerLocal.GetComponent(self, comp) self.__dict__[comp].UpdateFromC() %} } %include "cisstMultiTask/mtsCollectorBase.h" %include "cisstMultiTask/mtsCollectorState.h" // Wrap some basic types %include "cisstMultiTask/mtsGenericObjectProxy.h" %define MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(name, elementType) // ignore the operator & %ignore mtsGenericObjectProxy::operator value_type&; %ignore mtsGenericObjectProxy::operator const value_type&; // Instantiate the template %template(name ## Base) mtsGenericObjectProxyBase; %template(name) mtsGenericObjectProxy; // Type addition for dynamic type checking %{ typedef mtsGenericObjectProxy name; %} typedef mtsGenericObjectProxy name; %types(name *); %extend mtsGenericObjectProxy { elementType GetDataCopy() const { return static_cast($self->GetData()); } } %enddef MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsDouble, double); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsFloat, float); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsInt, int); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsUInt, unsigned int); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsShort, short); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsUShort, unsigned short); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsChar, char); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsUChar, unsigned char); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsLong, long); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsULong, unsigned long); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsBool, bool); #ifdef SWIG_WINDOWS %apply long long {size_t}; MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsSizeT, size_t); #endif MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsStdString, std::string); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsStdStringVecProxy, stdStringVec); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsStdDoubleVecProxy, stdDoubleVec); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsStdCharVecProxy, stdCharVec); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVct1, vct1); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVct2, vct2); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVct3, vct3); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVct4, vct4); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVct5, vct5); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVct6, vct6); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVct7, vct7); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVct8, vct8); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVct9, vct9); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVctFloat1, vctFloat1); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVctFloat2, vctFloat2); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVctFloat3, vctFloat3); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVctFloat4, vctFloat4); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVctFloat5, vctFloat5); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVctFloat6, vctFloat6); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVctFloat7, vctFloat7); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVctFloat8, vctFloat8); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVctFloat9, vctFloat9); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVctLong1, vctLong1); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVctLong2, vctLong2); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVctLong3, vctLong3); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVctLong4, vctLong4); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVctLong5, vctLong5); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVctLong6, vctLong6); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVctLong7, vctLong7); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVctLong8, vctLong8); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVctLong9, vctLong9); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVctULong1, vctULong1); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVctULong2, vctULong2); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVctULong3, vctULong3); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVctULong4, vctULong4); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVctULong5, vctULong5); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVctULong6, vctULong6); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVctULong7, vctULong7); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVctULong8, vctULong8); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVctULong9, vctULong9); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVctInt1, vctInt1); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVctInt2, vctInt2); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVctInt3, vctInt3); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVctInt4, vctInt4); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVctInt5, vctInt5); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVctInt6, vctInt6); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVctInt7, vctInt7); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVctInt8, vctInt8); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVctInt9, vctInt9); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVctUInt1, vctUInt1); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVctUInt2, vctUInt2); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVctUInt3, vctUInt3); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVctUInt4, vctUInt4); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVctUInt5, vctUInt5); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVctUInt6, vctUInt6); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVctUInt7, vctUInt7); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVctUInt8, vctUInt8); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVctUInt9, vctUInt9); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVctShort1, vctShort1); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVctShort2, vctShort2); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVctShort3, vctShort3); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVctShort4, vctShort4); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVctShort5, vctShort5); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVctShort6, vctShort6); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVctShort7, vctShort7); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVctShort8, vctShort8); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVctShort9, vctShort9); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVctUShort1, vctUShort1); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVctUShort2, vctUShort2); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVctUShort3, vctUShort3); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVctUShort4, vctUShort4); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVctUShort5, vctUShort5); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVctUShort6, vctUShort6); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVctUShort7, vctUShort7); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVctUShort8, vctUShort8); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVctUShort9, vctUShort9); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVctChar1, vctChar1); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVctChar2, vctChar2); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVctChar3, vctChar3); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVctChar4, vctChar4); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVctChar5, vctChar5); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVctChar6, vctChar6); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVctChar7, vctChar7); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVctChar8, vctChar8); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVctChar9, vctChar9); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVctUChar1, vctUChar1); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVctUChar2, vctUChar2); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVctUChar3, vctUChar3); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVctUChar4, vctUChar4); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVctUChar5, vctUChar5); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVctUChar6, vctUChar6); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVctUChar7, vctUChar7); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVctUChar8, vctUChar8); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVctUChar9, vctUChar9); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVctBool1, vctBool1); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVctBool2, vctBool2); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVctBool3, vctBool3); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVctBool4, vctBool4); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVctBool5, vctBool5); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVctBool6, vctBool6); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVctBool7, vctBool7); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVctBool8, vctBool8); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVctBool9, vctBool9); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVct2x2, vct2x2); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVct3x3, vct3x3); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVct4x4, vct4x4); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVctMatRot3, vctMatRot3); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVctFrm3, vctFrm3); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVctFrm4x4, vctFrm4x4); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVctDoubleVec, vctDoubleVec); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVctFloatVec, vctFloatVec); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVctIntVec, vctIntVec); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVctUIntVec, vctUIntVec); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVctCharVec, vctCharVec); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVctUCharVec, vctUCharVec); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVctBoolVec, vctBoolVec); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVctShortVec, vctShortVec); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVctUShortVec, vctUShortVec); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVctLongVec, vctLongVec); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVctULongVec, vctULongVec); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVctDoubleMat, vctDoubleMat); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVctFloatMat, vctFloatMat); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsVctIntMat, vctIntMat); // Extend mtsGenericObjectProxy to support construction from numpy array (using cisstVector // typemaps that convert between numpy array and vctDynamicMatrix). This enables vctMatRot3 to be used // as a parameter in cisstMultiTask commands (e.g., mtsCommandWrite). // Note that it is not necessary for Python to know about the vctMatRot3 data type, but this could be // implemented by adding Swig wrapping of this type in cisstVector. %extend mtsGenericObjectProxy { mtsGenericObjectProxy(const vctDynamicMatrix &matrixRot) throw(std::runtime_error) { if ((matrixRot.rows() != 3) || (matrixRot.cols() != 3)) cmnThrow(std::runtime_error("mtsGenericObjectProxy: Input is not 3x3 matrix")); vctMatRot3 rot; rot.From(matrixRot[0][0], matrixRot[0][1], matrixRot[0][2], matrixRot[1][0], matrixRot[1][1], matrixRot[1][2], matrixRot[2][0], matrixRot[2][1], matrixRot[2][2]); mtsGenericObjectProxy * result = new mtsGenericObjectProxy(rot); return result; } } %include "cisstMultiTask/mtsParameterTypes.h" %template(mtsDescriptionConnectionVec) std::vector; MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsDescriptionConnectionVecProxy, mtsDescriptionConnectionVec); %template(mtsDescriptionComponentClassVec) std::vector; MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsDescriptionComponentClassVecProxy, mtsDescriptionComponentClassVec); %include "cisstMultiTask/mtsComponentState.h" MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsComponentStateProxy, mtsComponentState); %include "cisstMultiTask/mtsInterfaceCommon.h" MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsInterfaceProvidedDescriptionProxy, mtsInterfaceProvidedDescription); MTS_GENERIC_OBJECT_PROXY_INSTANTIATE(mtsInterfaceRequiredDescriptionProxy, mtsInterfaceRequiredDescription); %template(mtsCommandsVoidDescription) std::vector; %template(mtsCommandsVoidReturnDescription) std::vector; %template(mtsCommandsWriteDescription) std::vector; %template(mtsCommandsWriteReturnDescription) std::vector; %template(mtsCommandsReadDescription) std::vector; %template(mtsCommandsQualifiedReadDescription) std::vector; %template(mtsEventsVoidDescription) std::vector; %template(mtsEventsWriteDescription) std::vector; // Wrap mtsVector %import "cisstMultiTask/mtsVector.h" // define macro %define MTS_INSTANTIATE_VECTOR(name, elementType) // suppress warning about base class not known %warnfilter(401) mtsVector; // force instantiation and define name for SWIG %template(name) mtsVector; %{ typedef mtsVector name; %} typedef mtsVector name; %types(name *); // add two methods to retrieve the vector %extend mtsVector{ inline VectorType & Data(void) { return *self; } inline const VectorType & Data(void) const { return *self; } } %enddef // instantiate for types also instantiated in cisstVector wrappers MTS_INSTANTIATE_VECTOR(mtsDoubleVec, double); MTS_INSTANTIATE_VECTOR(mtsFloatVec, float); MTS_INSTANTIATE_VECTOR(mtsLongVec, long); MTS_INSTANTIATE_VECTOR(mtsULongVec, unsigned long); MTS_INSTANTIATE_VECTOR(mtsIntVec, int); MTS_INSTANTIATE_VECTOR(mtsUIntVec, unsigned int); MTS_INSTANTIATE_VECTOR(mtsShortVec, short); MTS_INSTANTIATE_VECTOR(mtsUShortVec, unsigned short); MTS_INSTANTIATE_VECTOR(mtsCharVec, char); MTS_INSTANTIATE_VECTOR(mtsUCharVec, unsigned char); MTS_INSTANTIATE_VECTOR(mtsBoolVec, bool); MTS_INSTANTIATE_VECTOR(mtsStdStringVec, std::string); // Wrap mtsMatrix %import "cisstMultiTask/mtsMatrix.h" // define macro %define MTS_INSTANTIATE_MATRIX(name, elementType) // suppress warning about base class not known %warnfilter(401) mtsMatrix; // force instantiation and define name for SWIG %template(name) mtsMatrix; %{ typedef mtsMatrix name; %} typedef mtsMatrix name; %types(name *); // add two methods to retrieve the matrix %extend mtsMatrix{ inline MatrixType & Data(void) { return *self; } inline const MatrixType & Data(void) const { return *self; } } %enddef // instantiate for types also instantiated in cisstVector wrappers MTS_INSTANTIATE_MATRIX(mtsDoubleMat, double); MTS_INSTANTIATE_MATRIX(mtsIntMat, int); MTS_INSTANTIATE_MATRIX(mtsShortMat, short); MTS_INSTANTIATE_MATRIX(mtsLongMat, long); %import "cisstMultiTask/mtsMacros.h" %import "cisstVector/vctTransformationTypes.h" %include "cisstMultiTask/mtsTransformationTypes.h" // Wrap mtsStateIndex %ignore mtsStateIndex::operator--; %include "cisstMultiTask/mtsStateIndex.h" // Wrap mtsIntervalStatistics %include "cisstMultiTask/mtsIntervalStatistics.h" %pythoncode %{ # Define separate class so that we have more flexibility to set up namespaces. # For example, command /one/two/three will become one.two.three. class mtsInterfaceRequiredPython: def __init__(self): pass def _add_entry(self, cmdName, cmdFunc): # Replace dashes with underscore cmdNameFixed = cmdName.replace('-', '_') # Split namespaces (/) items = cmdNameFixed.split('/') obj = self # Loop through any namespaces for i in range(0, len(items)-1): if not hasattr(obj, items[i]): setattr(obj, items[i], mtsInterfaceRequiredPython()) obj = getattr(obj, items[i]) # Last (or only) item is set to the func setattr(obj, items[len(items)-1], cmdFunc) # Dynamically load and create a server component # # This function dynamically loads the specified library and constructs an object using the # specified component class (className). The component name is specified through argSerialized # (if not empty); otherwise componentName is used. Note that if argSerialized is not empty, # componentName is ignored. def mtsLoadAndCreateServer(libraryName, className, componentName, argSerialized): print('Loading ' + libraryName) import cisstOSAbstractionPython as cisstOSAbstraction DynLoader = cisstOSAbstraction.osaDynamicLoader() if not DynLoader.Load(libraryName): print('Failed to load ' + libraryName + ' (see cisstLog.txt)') return None print('Creating ' + componentName + ' (' + className + ')') LCM = mtsManagerLocal.GetInstance() if (not argSerialized): comp = LCM.CreateComponentDynamically(className, componentName, '') else: comp = LCM.CreateComponentDynamically(className, argSerialized) if comp: print('Component created') LCM.AddComponent(comp) return comp # Create client component (if necessary) and then create required interface to server # provided interface def mtsCreateClientInterface(clientName, serverName, interfaceName): LCM = mtsManagerLocal.GetInstance() if (LCM.FindComponent(clientName)): print('mtsCreateClientInterface: component ' + clientName + ' already exists') client = LCM.GetComponent(clientName) else: print('Creating ' + clientName) client = LCM.CreateComponentDynamically('mtsComponent', clientName, '') if not client: print('Failed to create ' + clientName) return None LCM.AddComponent(client) interface = None if (serverName and interfaceName): print('Connecting ' + clientName + ' to ' + serverName + ' (' + interfaceName + ')') interface = client.AddInterfaceRequiredAndConnect((serverName, interfaceName)) interfacePython = None if interface: interfacePython = mtsInterfaceRequiredPython() for name in interface.GetNamesOfFunctions(): interfacePython._add_entry(name, getattr(interface, name)) return interfacePython %}