Classes |
| class | ApiFunctions |
| class | apiFunctionsGraph |
| class | AppManagement |
| | < AppManagement (in order to provide access to basic organizers, managers and other main components to every instance More...
|
| class | FileDownloader |
| class | IOHelper |
| class | ParamHelper |
| class | MainApplication |
| | The MainApplication class is the basic management class for the entire application. More...
|
| struct | BreakPointItem |
| | item of BreakPointModel More...
|
| class | ClassNavigatorItem |
| class | LeafFilterProxyModel |
| | This class provides a special search function to the help model. The normal filtermodel hides nodes if they donīt contain the searched term, even though the children contain it. More...
|
| struct | PythonPackage |
| struct | PipGeneralOptions |
| struct | PipInstall |
| class | PipManager |
| class | PluginLoadStatus |
| | This struct provides a structure for saving the load status of any plugins or designerWidgets. More...
|
| class | PlugInModel |
| | class for visualizing the available (loaded) plugins More...
|
| struct | DesignerPlugin |
| struct | UserInfoStruct |
| class | UserModel |
| | class for for visualizing the available users More...
|
| class | AddInManager |
| | class for AddIn management More...
|
| class | AlgoInterfaceValidator |
| | The class AlgoInterfaceValidator provides validators and checks in order to verify that a certain filter or algoWidget that pretends to implement a certain interface really fits to the requirements and conditions of this interface. More...
|
| class | DummyItomDesignerPlugin |
| struct | FigurePlugin |
| struct | FigureCategory |
| class | DesignerWidgetOrganizer |
| class | HelpSystem |
| class | ItomPaletteBase |
| class | PaletteOrganizer |
| class | ProcessOrganizer |
| class | QsciApiManager |
| class | ScriptEditorOrganizer |
| | organizes script editors, independent on their appearance (docked or window-style) More...
|
| class | UiContainer |
| | Every instance of this class contains information about one user interface (main window, dialog, dock widget...) which is organized by UiOrganizer. More...
|
| struct | UiContainerItem |
| class | UiDataContainer |
| class | UiOrganizer |
| | The UiOrganizer is started as singleton instance within itom and organizes all main windows, dialogs, widgets,... which are currently loaded at runtime from any ui-file or from a widget, provided by any algorithm plugin. More...
|
| class | UserInteractionWatcher |
| class | UserOrganizer |
| | class handling users and their rights More...
|
| class | WidgetWrapper |
| | One instance of this class acts as wrapper for several import public methods of classes, derived from QObject, which should be made available by the call-method in python. More...
|
| class | PythonAutoInterval |
| class | PythonCommon |
| class | PythonDataObject |
| class | FuncWeakRef |
| class | PythonEngine |
| class | PythonFigure |
| class | PythonFont |
| class | PythonItom |
| struct | PythonQObjectMarshal |
| class | MethodDescription |
| | Small wrapper class with all necessary information for any method, signal or slot of class which should be inherited from QObject*. More...
|
| class | FctCallParamContainer |
| | each instance of this class contains the parameters (including return parameter) for any function call, which is parsed by the Qt-signal-slot system. This class is especially used for wrapping function calls between C++ and any python method. The convention for the main member variables corresponds to the usual Qt-way to wrap such function calls. More...
|
| class | PythonNumeric |
| class | PythonPlotItem |
| class | PythonPlugins |
| | class summing up the functionality of itom - hardware python plugins More...
|
| class | PythonProxy |
| class | PythonQtConversion |
| | Conversion class with mainly static methods, which convert values between Qt and standard C++ data types and PyObject* values. More...
|
| class | PythonQtSignalTarget |
| class | PythonQtSignalMapperBase |
| | base class for PythonQtSignalMapper More...
|
| class | PythonQtSignalMapper |
| | This class provides the possibility to redirect any signal emitted in an user-defined GUI to different python methods. More...
|
| class | PythonRegion |
| class | PythonRgba |
| class | PythonSharedPointerGuard |
| class | PythonParamConversion |
| class | PythonUi |
| class | TimerCallback |
| class | PythonTimer |
| class | PyWorkspaceItem |
| class | PyWorkspaceContainer |
| class | QDebugStream |
| class | AbstractFilterDialog |
| class | AbstractPropertyPageWidget |
| class | DialogAboutQItom |
| class | DialogEditBreakpoint |
| class | DialogGoto |
| class | DialogIconBrowser |
| class | DialogLoadedPlugins |
| class | DialogNewPluginInstance |
| class | DialogOpenFileWithFilter |
| class | DialogPipManager |
| class | DialogPipManagerInstall |
| class | PickerSortFilterProxyModel |
| class | DialogPluginPicker |
| class | DialogProperties |
| class | DialogReloadModule |
| class | DialogReplace |
| class | DialogSaveFileWithFilter |
| class | DialogSelectUser |
| class | DialogVariableDetail |
| class | HelpTreeDockWidget |
| class | ItomSpinBox |
| class | ParamInputParser |
| class | WidgetFindWord |
| class | WidgetInfoBox |
| class | WidgetPropConsoleLastCommand |
| class | WidgetPropConsoleWrap |
| class | WidgetPropEditorAPI |
| class | WidgetPropEditorAutoCompletion |
| class | WidgetPropEditorCalltips |
| class | WidgetPropEditorGeneral |
| class | WidgetPropEditorStyles |
| class | WidgetPropFigurePlugins |
| class | FigurePluginDelegate |
| class | WidgetPropGeneralApplication |
| class | WidgetPropGeneralLanguage |
| class | WidgetPropHelpDock |
| class | WidgetPropPythonGeneral |
| class | WidgetPropPythonStartup |
| class | AbstractDockWidget |
| | abstract dock widget class which inherits QDockWidget. The content of QDockWidget consists of an instance of QMainWindow. The real widget is then placed as central widget of this QMainWindow. QMainWindow has the ability to show a menubar as well as a toolbar, which is used in different versions depending on docked state. Inherit AbstractDockWidget in order to realize content of QMainWindow. More...
|
| class | AbstractPyScintillaWidget |
| class | AIManagerWidget |
| class | BreakPointDockWidget |
| class | CallStackDockWidget |
| | docking More...
|
| class | ConsoleWidget |
| class | DequeCommandList |
| class | FigureWidget |
| class | FileSystemDockWidget |
| class | HelpDockWidget |
| class | QTabWidgetItom |
| class | QTreeViewItom |
| class | LastCommandTreeWidget |
| class | LastCommandDockWidget |
| class | MainWindow |
| class | ScriptDockWidget |
| | widget containing one or multiple script editors (tabbed). This widget can either be a docking widget, docked in a docking area in the main window or it can be a floatable window which has a standard window behaviour. More...
|
| struct | ScriptEditorStorage |
| class | DialogUserManagement |
| class | DialogUserManagementEdit |
| class | UserUiDialog |
| class | WorkspaceDockWidget |
| | docking widget for contents of type workspace widget More...
|
| class | WorkspaceWidget |
| | the workspaceWidget displays either a global or a local workspace given by a python dictionary. This widget is inherited from QTreeWidget. More...
|
| class | DataObjectTagsPrivate |
| class | Range |
| | each range value has a start and end point. Optionally range can be marked as Range::all(), which indicates a full range More...
|
| class | DataObjectTagType |
| | Variant storage class for either a double or a string value. More...
|
| class | DObjConstIterator |
| | constant iterator through data object More...
|
| class | DObjIterator |
| | iterator through data object More...
|
| class | DataObject |
| | dataObject contains a n-dimensional matrix More...
|
| class | AbstractAddInConfigDialogPrivate |
| class | AbstractAddInConfigDialog |
| | abstract base class for configuration dialogs of plugins More...
|
| class | AbstractAddInDockWidgetPrivate |
| class | AbstractAddInDockWidget |
| | abstract base class for dock widgets (toolboxes) of plugins More...
|
| class | AddInGrabber |
| | Inherit from AddInGrabber if you write a camera/grabber plugin. Please call the constructor of AddInGrabber within your plugin constructor. More...
|
| struct | ExecFuncParams |
| struct | FilterParams |
| class | AddInInterfaceBase |
| | class of the AddIn - Library (DLL) - Interface More...
|
| class | AddInBase |
| | Base class for all plugins. More...
|
| class | AddInDataIO |
| | base class for all dataIO plugin classes More...
|
| class | AddInActuator |
| | base class for all actuator plugin classes More...
|
| class | AddInAlgo |
| | base class for all "algorithm" plugin classes More...
|
| class | ByteArray |
| class | Rgba32 |
| class | RGBChannel |
| class | threadActuator |
| | Helper class to give plugin-Developer an easy access to actuators in other threads. More...
|
| class | threadCamera |
| | Helper class to give plugin-Developer an easy access to cameras in other threads. More...
|
| class | CameraThreadCtrl |
| class | AutoInterval |
| | class for a interval type containing a min-max-range and an auto-flag. More...
|
| class | ItomPlotHandle |
| | class for a interval type containing the plot handle / unique id and name. More...
|
| class | ParamBase |
| class | Param |
| | class for parameter handling e.g. to pass paramters to plugins More...
|
| struct | ItomParamHelper |
| struct | ItomParamHelper< double > |
| struct | ItomParamHelper< int > |
| struct | ItomParamHelper< char > |
| struct | ItomParamHelper< unsigned char > |
| class | ParamMeta |
| | Base class for all meta-information classes. More...
|
| class | CharMeta |
| | meta-information for Param of type Char. More...
|
| class | IntMeta |
| | Meta-information for Param of type Int. More...
|
| class | DoubleMeta |
| | Meta-information for ito::Param of type Double. More...
|
| class | HWMeta |
| | Meta-information for Param of type HWPtr. More...
|
| class | StringMeta |
| | Meta-information for Param of type String. More...
|
| class | DObjMeta |
| | Meta-information for Param of type DObjPtr. More...
|
| class | CharArrayMeta |
| | Meta-information for Param of type CharArrayMeta. More...
|
| class | IntArrayMeta |
| class | DoubleArrayMeta |
| | Meta-information for Param of type DoubleArrayMeta. More...
|
| class | DoubleIntervalMeta |
| | Meta-information for Param of type DoubleIntervalMeta. More...
|
| class | IntervalMeta |
| | Meta-information for Param of type IntArrayMeta that represent an interval [minimum, maximum). More...
|
| class | RangeMeta |
| | Meta-information for Param of type IntArrayMeta that represent a range [minVal, maxVal]. More...
|
| class | RectMeta |
| | Meta-information for Param of type IntArrayMeta that represent a rectangle (left, top, width, height). More...
|
| class | PluginThreadCtrl |
| class | DataIOThreadCtrl |
| class | ActuatorThreadCtrl |
| class | RetVal |
| | Class for error value management. More...
|
| class | PluginInfo |
| struct | ItomPalette |
| class | PrimitiveContainer |
| class | RgbaBase32 |
Typedefs |
|
typedef QList< MethodDescription > | MethodDescriptionList |
|
typedef RetVal(* | tCreateFunc )(DataObject *dObj, const unsigned char dimensions, const int *sizes, const unsigned char continuous, const uchar *continuousDataPtr, const int *steps) |
|
typedef RetVal(* | tCreateFuncWithCVPlanes )(DataObject *dObj, const unsigned char dimensions, const int *sizes, const cv::Mat *planes, const unsigned int nrOfPlanes) |
|
typedef RetVal(* | tFreeFunc )(DataObject *dObj) |
|
typedef RetVal(* | tSecureFreeFunc )(DataObject *dObj) |
|
typedef RetVal(* | tCopyToFunc )(const DataObject &lhs, DataObject &rhs, unsigned char regionOnly) |
|
typedef RetVal(* | tDeepCopyPartialFunc )(const DataObject &lhs, DataObject &rhs) |
|
typedef RetVal(* | tZerosFunc )(const int sizeY, const int sizeX, uchar **dstMat) |
|
typedef RetVal(* | tOnesFunc )(const int sizeY, const int sizeX, uchar **dstMat) |
|
typedef RetVal(* | tRandFunc )(const int sizeY, const int sizeX, const double value1, const double value2, const bool randMode, uchar **dstMat) |
|
typedef RetVal(* | tCopyMatFunc )(const uchar **src, uchar **&dst, bool transposed, const int sizeofs) |
|
typedef RetVal(* | tAssignScalarFunc )(DataObject *src, const ito::tDataType type, const void *scalar) |
|
typedef RetVal(* | tAssignScalarMaskFunc )(DataObject *src, const DataObject *mask, const ito::tDataType type, const void *scalar) |
|
typedef RetVal(* | tAddFunc )(const DataObject *src1, const DataObject *src2, DataObject *dst) |
|
typedef RetVal(* | tAddScalarFunc )(const DataObject *dObjIn, ito::float64 scalar, DataObject *dObjOut) |
|
typedef RetVal(* | tSubFunc )(const DataObject *src1, const DataObject *src2, DataObject *dst) |
|
typedef RetVal(* | tOpMulFunc )(const DataObject *src1, const DataObject *src2, DataObject *dst) |
|
typedef RetVal(* | tOpScalarMulFunc )(DataObject *src, const double &factor) |
|
typedef RetVal(* | tCmpFunc )(const DataObject *src1, const DataObject *src2, DataObject *dst, int cmpOp) |
|
typedef RetVal(* | tCmpFuncScalar )(const DataObject *src, const float64 &value, DataObject *dst, int cmpOp) |
|
typedef RetVal(* | tShiftLFunc )(DataObject *src, const unsigned char shiftbit) |
|
typedef RetVal(* | tShiftRFunc )(DataObject *src, const unsigned char shiftbit) |
|
typedef RetVal(* | tBitAndFunc )(const DataObject *src1, const DataObject *src2, DataObject *dst) |
|
typedef RetVal(* | tBitOrFunc )(const DataObject *src1, const DataObject *src2, DataObject *dst) |
|
typedef RetVal(* | tBitXorFunc )(const DataObject *src1, const DataObject *src2, DataObject *dst) |
|
typedef RetVal(* | tGetRangeFunc )(DataObject *dObj, const int dtop, const int dbottom, const int dleft, const int dright) |
|
typedef RetVal(* | tAdjustROIFunc )(DataObject *dObj, int dtop, int dbottom, int dleft, int dright) |
|
typedef RetVal(* | tEyeFunc )(const int size, uchar **dstMat) |
|
typedef RetVal(* | tConjFunc )(DataObject *dObj) |
|
typedef RetVal(* | tMulFunc )(const DataObject *src1, const DataObject *src2, DataObject *res, const double scale) |
|
typedef RetVal(* | tDivFunc )(const DataObject *src1, const DataObject *src2, DataObject *res) |
|
typedef RetVal(* | tConvertToFunc )(const DataObject &lhs, DataObject &rhs, const int type, const double alpha, const double beta) |
|
typedef RetVal(* | tAbsFunc )(const DataObject *dObj, DataObject *resObj) |
|
typedef RetVal(* | tArgFunc )(const DataObject *dObj, DataObject *resObj) |
|
typedef RetVal(* | tRealFunc )(const DataObject *dObj, DataObject *resObj) |
|
typedef RetVal(* | tImagFunc )(const DataObject *dObj, DataObject *resObj) |
|
typedef RetVal(* | tMakeContinuousFunc )(const DataObject &dObj, DataObject &resDObj) |
|
typedef std::ostream &(* | tCoutFunc )(std::ostream &out, const DataObject &dObj) |
typedef RGBChannel
< Rgba32::RGBA_A > | AlphaChannel |
typedef RGBChannel
< Rgba32::RGBA_R > | RedChannel |
typedef RGBChannel
< Rgba32::RGBA_G > | GreenChannel |
typedef RGBChannel
< Rgba32::RGBA_B > | BlueChannel |
|
typedef int8_t | int8 |
|
typedef int16_t | int16 |
|
typedef int32_t | int32 |
|
typedef uint8_t | uint8 |
|
typedef uint16_t | uint16 |
|
typedef uint32_t | uint32 |
|
typedef float | float32 |
|
typedef double | float64 |
typedef std::complex
< ito::float32 > | complex64 |
typedef std::complex
< ito::float64 > | complex128 |
Enumerations |
| enum | tPluginLoadStatusFlag {
plsfOk = 0x001,
plsfWarning = 0x002,
plsfError = 0x004,
plsfIgnored = 0x008,
plsfRelDbg = 0x100
} |
| enum | UserRole { userRoleBasic = 0,
userRoleAdministrator = 1,
userRoleDeveloper = 2
} |
| enum | UserFeature {
featDeveloper = 1,
featFileSystem = 2,
featUserManag = 4,
featPlugins = 8,
featConsoleRead = 16,
featConsoleReadWrite = 32,
featProperties = 64
} |
| enum | tPluginType {
typeDataIO = 0x1,
typeActuator = 0x2,
typeAlgo = 0x4,
typeGrabber = 0x80,
typeADDA = 0x100,
typeRawIO = 0x200
} |
| | tPluginType enumeration More...
|
| enum | tActuatorStatus {
actuatorUnknown = 0x0001,
actuatorInterrupted = 0x0002,
actuatorMoving = 0x0004,
actuatorAtTarget = 0x0008,
actuatorTimeout = 0x0010,
actuatorEndSwitch = 0x0100,
actuatorLeftEndSwitch = 0x0200,
actuatorRightEndSwitch = 0x0400,
actuatorRefSwitch = 0x0800,
actuatorLeftRefSwitch = 0x1000,
actuatorRightRefSwitch = 0x2000,
actuatorAvailable = 0x4000,
actuatorEnabled = 0x8000,
actMovingMask = actuatorUnknown | actuatorInterrupted | actuatorMoving | actuatorAtTarget | actuatorTimeout,
actEndSwitchMask = actuatorEndSwitch | actuatorLeftEndSwitch | actuatorRightEndSwitch,
actRefSwitchMask = actuatorRefSwitch | actuatorLeftRefSwitch | actuatorRightRefSwitch,
actSwitchesMask = actEndSwitchMask | actRefSwitchMask,
actStatusMask = actuatorAvailable | actuatorEnabled
} |
| | tActuatorStatus enumeration More...
|
| enum | tAutoLoadPolicy { autoLoadAlways = 0x1,
autoLoadNever = 0x2,
autoLoadKeywordDefined = 0x4
} |
| enum | tAutoSavePolicy { autoSaveAlways = 0x1,
autoSaveNever = 0x2
} |
| enum | PlotDataType {
DataObjLine = 0x0001,
DataObjPlane = 0x0002,
DataObjPlaneStack = 0x0004,
PointCloud = 0x0008,
PolygonMesh = 0x0010
} |
| enum | PlotDataFormat {
Format_Gray8 = 0x0001,
Format_Gray16 = 0x0002,
Format_Gray32 = 0x0004,
Format_RGB32 = 0x0008,
Format_ARGB32 = 0x0010,
Format_CMYK32 = 0x0020,
Format_Float32 = 0x0040,
Format_Float64 = 0x0080,
Format_Complex = 0x0100
} |
| enum | PlotFeature {
Static = 0x0001,
Live = 0x0002,
Cartesian = 0x0004,
Polar = 0x0008,
Cylindrical = 0x0010,
OpenGl = 0x0020,
Cuda = 0x0040,
X3D = 0x0080,
PlotLine = 0x0100,
PlotImage = 0x0200,
PlotISO = 0x0400,
Plot3D = 0x0800
} |
| enum | tPalette {
tPaletteNoType = 0x00,
tPaletteGray = 0x01,
tPaletteRGB = 0x02,
tPaletteFC = 0x04,
tPaletteIndexed = 0x08,
tPaletteLinear = 0x10,
tPaletteReadOnly = 0x20
} |
| enum | tLogLevel {
logNone = 0x0,
logError = 0x1,
logWarning = 0x2,
logInfo = 0x4,
logAll = logInfo | logWarning | logError
} |
| enum | tRetValue { retOk = 0x0,
retWarning = 0x1,
retError = 0x2
} |
| enum | tMsgType {
msgReturnInfo,
msgReturnWarning,
msgReturnError,
msgTextInfo,
msgTextWarning,
msgTextError
} |
| enum | tPythonDbgCmd {
pyDbgNone = 0,
pyDbgContinue = 1,
pyDbgStep = 2,
pyDbgStepOut = 4,
pyDbgStepOver = 8,
pyDbgQuit = 16
} |
| enum | tPythonTransitions {
pyTransBeginRun = 1,
pyTransEndRun = 2,
pyTransBeginDebug = 4,
pyTransEndDebug = 8,
pyTransDebugWaiting = 16,
pyTransDebugContinue = 32,
pyTransDebugExecCmdBegin = 64,
pyTransDebugExecCmdEnd = 128
} |
| enum | tCompareResult { tCmpEqual,
tCmpCompatible,
tCmpFailed
} |
| enum | tPythonState {
pyStateIdle = 1,
pyStateRunning = 2,
pyStateDebugging = 4,
pyStateDebuggingWaiting = 8,
pyStateDebuggingWaitingButBusy = 16
} |
| enum | tDataType {
tInt8 = 0,
tUInt8 = 1,
tInt16 = 2,
tUInt16 = 3,
tInt32 = 4,
tUInt32 = 5,
tFloat32 = 6,
tFloat64 = 7,
tComplex64 = 8,
tComplex128 = 9,
tRGBA32 = 10
} |
| enum | tPCLPointType {
pclInvalid = 0x0000,
pclXYZ = 0x0001,
pclXYZI = 0x0002,
pclXYZRGBA = 0x0004,
pclXYZNormal = 0x0008,
pclXYZINormal = 0x0010,
pclXYZRGBNormal = 0x0020
} |
Functions |
| ito::RetVal | apiFCheckAndSetParamVal (QVariant *tempParam, ito::ParamBase *param, int *set) |
| ito::RetVal | apiFParseInitParams (QVector< ito::ParamBase > *initParamListMand, QVector< ito::ParamBase > *initParamListOpt, QVector< QVariant > *params) |
| QMap< QString, QString > | getItomVersionMap () |
| | This function is called to get all version numbers that itom contains.
|
|
QDataStream & | operator<< (QDataStream &out, const BreakPointItem &obj) |
|
QDataStream & | operator>> (QDataStream &in, BreakPointItem &obj) |
| ito::RetVal | decRefParamPlugins (ito::AddInBase *ai) |
| void | incRefParamPlugins (ito::AddInBase *ai, QVector< ito::ParamBase > *paramsMand, QVector< ito::ParamBase > *paramsOpt) |
|
QDataStream & | operator<< (QDataStream &out, const ito::ScriptEditorStorage &obj) |
|
QDataStream & | operator>> (QDataStream &in, ito::ScriptEditorStorage &obj) |
|
RetVal | getObjectChildrenInfoRecursive (const QObject *obj, bool recursive, QSharedPointer< QStringList > &objectNames, QSharedPointer< QStringList > &classNames) |
|
| PyDoc_STRVAR (autoIntervalInit_doc,"autoInterval([min=-inf, max=inf, auto=false]) -> creates a new auto interval object.\n\
\n\
Parameters \n\
----------- \n\
min : {float} \n\
minimum value of interval (default: -infinity) \n\
max : {float}, \n\
maximum value of interval (default: +infinity) \n\
auto : {uint8} \n\
0 if interval is fixed (default), 1 if the interval can be scaled automatically") |
| ito::RetVal | checkAndSetParamVal (PyObject *tempObj, ito::Param *param, int *set) |
|
ito::RetVal | checkAndSetParamVal (PyObject *pyObj, const ito::Param *defaultParam, ito::ParamBase &outParam, int *set) |
| | This function is used to print out parameters to a dictionary and the itom-console.
|
|
PyObject * | PrntOutParams (const QVector< ito::Param > *params, bool asErr, bool addInfos, const int num, bool printToStdStream) |
| void | errOutInitParams (const QVector< ito::Param > *params, const int num, const char *reason) |
| ito::RetVal | parseInitParams (QVector< ito::Param > *initParamListMand, QVector< ito::Param > *initParamListOpt, PyObject *args, PyObject *kwds) |
|
ito::RetVal | parseInitParams (const QVector< ito::Param > *defaultParamListMand, const QVector< ito::Param > *defaultParamListOpt, PyObject *args, PyObject *kwds, QVector< ito::ParamBase > ¶mListMandOut, QVector< ito::ParamBase > ¶mListOptOut) |
| ito::RetVal | copyParamVector (const QVector< ito::ParamBase > *paramVecIn, QVector< ito::ParamBase > ¶mVecOut) |
| ito::RetVal | copyParamVector (const QVector< ito::Param > *paramVecIn, QVector< ito::Param > ¶mVecOut) |
|
ito::RetVal | copyParamVector (const QVector< ito::Param > *paramVecIn, QVector< ito::ParamBase > ¶mVecOut) |
|
ito::RetVal | createEmptyParamBaseFromParamVector (const QVector< ito::Param > *paramVecIn, QVector< ito::ParamBase > ¶mVecOut) |
| | This function searches for reserves Keywords (e.g. autoLoadParams) sets the corresponding bool parameter to the right value and than deletes the keyword.
|
| ito::RetVal | findAndDeleteReservedInitKeyWords (PyObject *kwds, bool *enableAutoLoadParams) |
|
PyObject * | buildFilterOutputValues (QVector< QVariant > *outVals, ito::RetVal &retValue) |
|
PyObject * | parseParamMetaAsDict (const ito::ParamMeta *meta) |
| | PyDoc_STRVAR (dataObjectInit_doc,"dataObject([dims [, dtype='uint8'[, continuous = 0][, data = valueOrSequence]]]) -> constructor to get a new dataObject.\n\
\n\
The itom.dataObject represents a multidimensional array of fixed-size items with corresponding meta information (units, axes descriptions, scalings, tags, protocol...). \n\
Recently the following data types (dtype) are supported: \n\
\n\
* Integer-type (int8, uint8, int16, uint16, int32, uint32),\n\
* Floating-type (float32, float64 (=> double)),\n\
* Complex-type (complex64 (2x float32), complex128 (2x float64)).\n\
* Color-type (rgba32 (uint32 or uint[4] containing the four 8bit values [R, G, B, Alpha])).\n\
\n\
Arrays can also be constructed using some of the static pre-initialization methods 'zeros', 'ones', 'rand' or 'randN' (refer to the See Also section below). \n\
\n\
Parameters \n\
----------- \n\
dims : {sequence of integers}, optional \n\
'dims' is a list or tuple indicating the size of each dimension, e.g. [2,3] is a matrix with 2 rows and 3 columns. If not given, an empty data object is created.\n\
dtype : {str}, optional \n\
'dtype' is the data type of each element, possible values: 'int8','uint8',...,'int32','uint32','float32','float64','complex64','complex128', 'rgba32'\n\
continuous : {int}, optional \n\
'continuous' [0|1] defines whether the data block should be continuously allocated in memory [1] or in different smaller blocks [0] (recommended for huge matrices).\n\
data : {str}, optional \n\
'data' is a single value or a sequence with the same amount of values than the data object. The values from data will be assigned to the new data object (filled row by row).\n\
\n\
Notes \n\
------ \n\
\n\
The itom.dataObject is a direct wrapper for the underlying C++ class *dataObject*. This array class mainly is based on the class *Mat* of the computer vision library (OpenCV). \n\
\n\
In order to handle huge matrices, the data object can divide one array into chunks in memory.\n\
Each subpart (called matrix-plane) is two-dimensional and covers data of the last two dimensions.\n\
In c++-context each of these matrix-planes is of type cv::Mat_<type> and can be used with every operator given by the openCV-framework (version 2.3.1 or higher).\n\
\n\
The dimensions of the matrix are structured descending. So if we assume to have a n-dimensional matrix A,\n\
where each dimension has its size s_i, the dimensions order is n, .., z, y, x and the corresponding sizes of A are [s_n, s_(n-1), s_(n-2), ..., s_y, s_x].\n\
\n\
In order to make the data object compatible to continuously organized data structures, like numpy-arrays, \n\
it is also possible to have all matrix-planes in one data-block in memory (not recommended for huge matrices).\n\
Nevertheless, the indicated data structure with the two-dimensional sub-matrix-planes is still existing. \n\
The data organization is equal to the one of openCV, hence, two-dimensional matrices are stored row-by-row (C-style)...\n\
\n\
In addition to OpenCV, itom.dataObject supports complex valued data types for all operators and methods. \n\
\n\
Warning 'uint32' is not fully openCV-compatible and hence causes instability!\n\
\n\
**Deep Copy, Shallow Copy and ROI** \n\
\n\
It is possible to set a n-dimensional region of interest (ROI) to each matrix, the virtual dimensions,\n\
which will be delivered if the user asks for the matrix size.\n\
To avoid copy operations where possible a simple =_Operator will also make a shallow copy of the object.\n\
Shallow copies share the same data (elements and meta data) with the original object, hence manipulations of one object will affect the\n\
original object and all shallow copies.\n\
\n\
The opposite a deep copy of a dataObject (by sourceObject.copy()) creates a complete mew matrix with own meta data object.\n\
\n\
Example:\n\
::\n\
#Create an object \n\
dObj = dataObject([5, 10, 10], 'int8')\n\
\n\
# Make a shallow copy \n\
dObjShallow = dObj \n\
\n\
# Make a shallow copy on ROI\n\
dObjROI = dObj[1, :, :] \n\
\n\
# Set the value of element [1, 0, 0] to 0\n\
dObj[1, 0, 0] = 0\n\
\n\
# Make a deep copy of the dObjROI\n\
dObjROICopy = dObjROI.copy()\n\
\n\
# Set the value of dObjROICopy element [0, 0, 0] to 127 without effecting other objects\n\
dObjROICopy[0, 0, 0] = 127\n\
\n\
**Constructor** \n\
\n\
The function dataObject([dims [, dtype='uint8'[, continuous = 0][, data = valueOrSequence]]])\n\
creates a new itom-dataObject filled with undefined data.\n\
If no parameters are given, an uninitilized DataObject (dims = 0, no sizes) is created.\n\
\n\
As second possibility you can also use the copy-constructor 'dataObject(AnyArray)', \n\
where AnyArray must be any array-like structure which is parsable by the numpy-interface.\n\
\n\
See Also \n\
---------- \n\
ones() : Static method to construct a data object filled with ones. \n\
zeros() : Static method to construct a data object filled with zeros. \n\
rand() : Static method to construct a randomly filled data object (uniform distribution). \n\
randN() : Static method to construct a randomly filled data object (gaussian distribution).") |
| | brief description
|
|
| PyDoc_STRVAR (dataObjectAttrDims_doc,"number of dimensions of this data object\n\
\n\
Notes \n\
----- \n\
read-only property, this property is readable both by the attributes ndim and dims. \n\
") |
|
| PyDoc_STRVAR (dataObjectAttrType_doc,"get type string of data in this data object \n\
\n\
This type string has one of these values: 'uint8', 'int8', 'uint16', 'int16', 'uint32', 'int32', \n\
'float32', 'float64', 'complex64', 'complex128', 'rgba32'\n\
\n\
Notes \n\
----- \n\
This attribute is read-only") |
|
| PyDoc_STRVAR (dataObjectAttrContinuous_doc,"true if matrix is continuously organized, else false. \n\
\n\
If true, the whole matrix is allocated in one huge block in memory, hence, \n\
this data object can be transformed into a numpy representation (npDataObject) \n\
without reallocating memory.\n\
\n\
Notes \n\
----- \n\
read-only\n\
") |
|
| PyDoc_STRVAR (dataObjectAttrShape_doc,"tuple with the sizes of each dimension / axis of this data object. \n\
\n\
Notes\n\
------\n\
In difference to the shape attribute of numpy arrays, no new shape tuple can be assigned to \
this value (used to 'reshape' the array). Read-only.\n\
\n\
See Also \n\
--------- \n\
size() : Alternative method to return the size of all or any specific axis") |
|
| PyDoc_STRVAR (dataObjectAttrTags_doc,"tag dictionary of this data object. \n\
\n\
This attribute returns a dict_proxy object of the tag dictionary of this data object. This object is read-only. \n\
However you can assign an entire new dictionary to this attribute that fully replaces the old tag dictionary. \n\
The tag dictionary can contain arbitrary pairs of key -> value where value is either a string or a double value. \n\
\n\
Special tags are the key 'protocol' that contains the newline-separated protocol string of the data object (see: addToProtocol()) \n\
or the key 'title' that can for instance be used as title in any plots. \n\
\n\
You can add single elements using the method setTag(key,value) or you can delete tags using deleteTag(key).\n\
\n\
Do NOT use 'special character' within the tag key because they are not XML-save.\n\
\n\
Notes \n\
----- \n\
read-only / write only for fully new dictionary") |
|
| PyDoc_STRVAR (dataObjectAttrAxisScales_doc,"tuple containing the axis scales [unit/px]. \n\
\n\
This attribute gives access to the internal axis scales [unit/px] expressed as \n\
a tuple of double values. The i-th value in the tuple corresponds to the scaling factor of the i-th \n\
axis. Either assign a new tuple with the same length than the number of dimensions or change single values \n\
using tuple indexing. \n\
\n\
Definition: Physical unit = (px-Coordinate - offset)* scale\n\
\n\
Notes \n\
----- \n\
read / write\n\
\n\
See Also \n\
--------- \n\
setAxisScale() : Alternative method to set the scale value of one single axis") |
|
| PyDoc_STRVAR (dataObjectAttrAxisOffsets_doc,"tuple containing the axis offsets [px]. \n\
\n\
This attribute gives access to the internal axis offsets [px] expressed as \n\
a tuple of double values. The i-th value in the tuple corresponds to the pixel-offset of the i-th \n\
axis. Either assign a new tuple with the same length than the number of dimensions or change single values \n\
using tuple indexing. \n\
\n\
Definition: Physical unit = (px-Coordinate - offset)* scale\n\
\n\
Notes \n\
----- \n\
read / write\n\
\n\
See Also \n\
--------- \n\
setAxisOffset() : Alternative method to set the offset value of one single axis") |
|
| PyDoc_STRVAR (dataObjectAttrAxisDescriptions_doc,"tuple containing the axis descriptions {str}. \n\
\n\
This attribute gives access to the internal axis descriptions expressed as \n\
a tuple of strings. The tuple has the same length than the number of dimensions of this data object. \n\
\n\
You can either assign a new tuple with the same length or change single values using tuple indexing. \n\
\n\
See Also \n\
--------- \n\
setAxisDescriptions : alternative method to change the description string of one single axis \n\
\n\
Notes \n\
------- \n\
read / write") |
|
| PyDoc_STRVAR (dataObjectAttrAxisUnits_doc,"tuple containing the axis units {str}. \n\
\n\
This attribute gives access to the internal axis units expressed as \n\
a tuple of strings. The tuple has the same length than the number of dimensions of this data object. \n\
\n\
You can either assign a new tuple with the same length or change single values using tuple indexing. \n\
\n\
See Also \n\
--------- \n\
setAxisUnits : alternative method to change the unit string of one single axis \n\
\n\
Notes \n\
------- \n\
read / write") |
|
| PyDoc_STRVAR (dataObjectAttrValueUnit_doc,"value unit. \n\
\n\
Attribute to read or write the unit string of the values in this data object. \n\
\n\
Notes \n\
----- \n\
read / write") |
|
| PyDoc_STRVAR (dataObjectAttrValueDescription_doc,"value unit description. \n\
\n\
Attribute to read or write the unit description string of the values in this data object. \n\
\n\
Notes \n\
----- \n\
read / write") |
|
| PyDoc_STRVAR (dataObjectAttrValueScale_doc,"value scale [default: 0.0].\n\
\n\
This attribute gives the scaling factor of each value in the data object. This value is always 1.0. \n\
\n\
Notes \n\
----- \n\
This attribute is read only") |
|
| PyDoc_STRVAR (dataObjectAttrValueOffset_doc,"value offset [default: 0.0].\n\
\n\
This attribute gives the offset of each value in the data object. This value is always 0.0. \n\
\n\
Notes \n\
----- \n\
This attribute is read only") |
|
| PyDoc_STRVAR (dataObjectAttrValue_doc,"get/set the values within the ROI as a one-dimensional tuple.\n\
\n\
This method gets or sets the values within the ROI. If this attribute is called by means of a getter, \n\
a tuple is returned which is created by iterating through the values of the data object (row-wise). \n\
In the same way of iterating, the values are set to the data object if you provide a tuple of the size of the data object \n\
or its ROI, respectively. \n\
\n\
Example: ::\n\
\n\
b = dataObject[1,1:10,1,1].value\n\
# or for the first value \n\
b = dataObject[1,1:10,1,1].value[0]\n\
# The elements of the tuple are adressed with b[idx].") |
|
| PyDoc_STRVAR (dataObjectAttrRotationalMatrix_doc,"Access the 3x3 rotational matrix in the dataObject tagspace \n\
\n\
This attribute gives access to the xyRotationalMatrix in the metaData-Tagspace.\n\
The getter method retuns a 3x3-Array deep copied from the internal matrix,\n\
Implemented to offer compability to x3p format.\n\
\n\
Notes \n\
----- \n\
{3x3 array of doubles} : ReadWrite\n\
") |
|
| PyDoc_STRVAR (pyDataObjectSetAxisOffset_doc,"setAxisOffset(axisNum, axisOffset) -> Set the offset of the specified axis. \n\
\n\
Each axis in the data object can get a specific scale value, described in axisUnits per pixel. Use this method to set the scale of one specific axis. \n\
The value of each pixel in its physical unit is the (px-Coordinate - axisOffset) * axisScale \n\
\n\
Parameters \n\
------------\n\
axisNum : {int}\n\
The addressed axis index\n\
axisOffset : {double}\n\
New axis offset in [px]\n\
\n\
Raises \n\
------- \n\
Runtime error : \n\
if the given axisNum is invalid (out of range) \n\
\n\
See Also \n\
--------- \n\
axisOffsets : this attribute can directly be used to read/write the axis offset(s) of single or all axes") |
|
| PyDoc_STRVAR (pyDataObjectSetAxisScale_doc,"setAxisScale(axisNum, axisScale) -> Set the scale value of the specified axis. \n\
\n\
Each axis in the data object can get a specific scale value, described in axisUnits per pixel. Use this method to set the scale of one specific axis. \n\
\n\
Parameters \n\
------------\n\
axisNum : {int}\n\
The addressed axis index\n\
axisScale : {double}\n\
New axis scale in axisUnit/px\n\
\n\
Raises \n\
------- \n\
Runtime error : \n\
if the given axisNum is invalid (out of range) \n\
\n\
See Also \n\
--------- \n\
axisScales : this attribute can directly be used to read/write the axis scale(s) of single or all axes") |
|
| PyDoc_STRVAR (pyDataObjectSetAxisDescription_doc,"setAxisDescription(axisNum, axisDescription) -> Set the description of the specified axis. \n\
\n\
Each axis in the data object can get a specific axisDescription string (e.g. mm). Use this method to set the axisDescription of one specific axis. \n\
\n\
Parameters \n\
------------\n\
axisNum : {int}\n\
The addressed axis index\n\
axisDescription : {str}\n\
New axis description\n\
\n\
Raises \n\
------- \n\
Runtime error : \n\
if the given axisNum is invalid (out of range) \n\
\n\
See Also \n\
--------- \n\
axisDescriptions : this attribute can directly be used to read/write the axis description(s) of single or all axes") |
|
| PyDoc_STRVAR (pyDataObjectSetAxisUnit_doc,"setAxisUnit(axisNum, axisUnit) -> Set the unit of the specified axis. \n\
\n\
Each axis in the data object can get a specific unit string (e.g. mm). Use this method to set the unit of one specific axis. \n\
\n\
Parameters \n\
------------\n\
axisNum : {int}\n\
The addressed axis index\n\
axisUnit : {str}\n\
New axis unit\n\
\n\
Raises \n\
------- \n\
Runtime error : \n\
if the given axisNum is invalid (out of range) \n\
\n\
See Also \n\
--------- \n\
axisUnits : this attribute can directly be used to read/write the axis unit(s) of single or all axes") |
|
| PyDoc_STRVAR (pyDataObjectPhysToPix_doc,"physToPix(values [, axes]) -> returns the pixel coordinates for the given physical coordinates. \n\
\n\
This method transforms a physical axis coordinate into its corresponding pixel coordinate. The transformation is influenced \n\
by the offset and scaling of each axis: \n\
\n\
phys = (pix - offset) * scaling \n\
\n\
If no axes parameter is given, the values are assumed to belong the the ascending axis list (0,1,2,3...). \n\
\n\
Parameters \n\
------------\n\
values : {float, float-tuple}\n\
One single physical coordinate or a tuple of physical coordinates.\n\
axes : {int, int-tuple}, optional\n\
If this is given, the values are mapped to the axis indices given by this value or tuple. Else, an ascending list starting with index 0 is assumed. \n\
\n\
Returns \n\
-------- \n\
Float or float-tuple with the pixel coordinates for each physical coordinate at the given axis index. \n\
\n\
Raises \n\
------- \n\
Value error : \n\
if the given axes is invalid (out of range)") |
|
| PyDoc_STRVAR (pyDataObjectPixToPhys_doc,"pixToPhys(values [, axes]) -> returns the physical coordinates for the given pixel coordinates. \n\
\n\
This method transforms a pixel coordinate into its corresponding physical coordinate. The transformation is influenced \n\
by the offset and scaling of each axis: \n\
\n\
pix = (phys / scaling) + offset \n\
\n\
If no axes parameter is given, the values are assumed to belong the the ascending axis list (0,1,2,3...). \n\
\n\
Parameters \n\
------------\n\
values : {float, float-tuple}\n\
One single pixel coordinate or a tuple of pixel coordinates.\n\
axes : {int, int-tuple}, optional\n\
If this is given, the values are mapped to the axis indices given by this value or tuple. Else, an ascending list starting with index 0 is assumed. \n\
\n\
Returns \n\
-------- \n\
Float or float-tuple with the physical coordinates for each pixel coordinate at the given axis index. \n\
\n\
Raises \n\
------- \n\
Value error : \n\
if the given axes is invalid (out of range)") |
|
| PyDoc_STRVAR (pyDataObjectSetTag_doc,"setTag(key, tagvalue) -> Set the value of tag specified by key. \n\
\n\
Sets the value of an existing tag (defined by key) in the tag dictionary to the string or double tagvalue or \
adds a new item with key. \n\
\n\
Parameters \n\
------------\n\
key : {str}\n\
the name of the tag to set\n\
tagvalue : {str or double}\n\
the new value of the tag, either string or double value\n\
\n\
Notes \n\
----- \n\
Do NOT use 'special character' within the tag key because they are not XML-save.\n\
") |
|
| PyDoc_STRVAR (pyDataObjectDeleteTag_doc,"deleteTag(key) -> Delete a tag specified by key from the tag dictionary. \n\
\n\
Checks whether a tag with the given key exists in the tag dictionary and if so deletes it. \n\
\n\
Parameters \n\
------------\n\
key : {str}\n\
the name of the tag to be deleted\n\
\n\
Returns \n\
-------- \n\
success : {bool}: \n\
True if tag with given key existed and could be deleted, else False") |
|
| PyDoc_STRVAR (pyDataObjectTagExists_doc,"existTag(key) -> return True if tag with given key exists, else False \n\
\n\
Checks whether a tag with the given key exists in tag dictionary of this data object and returns True if such a tag exists, else False. \n\
\n\
Parameters \n\
------------\n\
key : {str}\n\
the key of the tag\n\
\n\
Returns \n\
-------- \n\
result : {bool}\n\
True if tag exists, else False") |
|
| PyDoc_STRVAR (pyDataObjectGetTagListSize_doc,"getTagListSize() -> returns the number of tags in the tag dictionary\n\
\n\
Every data object can have an arbitrary number of tags stored in the tag dictionary. This method returns the number of different tags, \
where the protocol is also one tag with the key 'protocol'. \n\
\n\
Returns \n\
------- \n\
length : {int}: \n\
size of the tag dictionary. The optional protocol also counts as one item.") |
|
| PyDoc_STRVAR (pyDataObjectAddToProtocol_doc,"addToProtocol(newLine) -> Appends a protocol line to the protocol. \n\
\n\
Appends a line of text to the protocol string of this data object. If this data object has got a region of interest defined, \
the rectangle of the ROI is automatically appended to newLine. The protocol string ends with a newline character. \n\
\n\
Address the content of the protocol by obj.tags[\"protocol\"]. The protocol is contained in the ordinary tag dictionary of this data object under the key 'protocol'. \n\
\n\
Parameters \n\
------------\n\
newLine : {str}\n\
The text to be added to the protocol.") |
|
| PyDoc_STRVAR (pyDataObjectName_doc,"name() -> returns the name of this object (dataObject)") |
|
| PyDoc_STRVAR (pyDataObjectData_doc,"data() -> prints the content of the dataObject in a readable form. \n\
\n\
Notes \n\
----- \n\
When calling this method, the complete content of the dataObject is printed to the standard output stream.") |
|
| PyDoc_STRVAR (pyDataObjectConj_doc,"conj() -> complex-conjugates all elements of this dataObject (inline). \n\
\n\
Every value of this dataObject is replaced by its complex-conjugate value. \n\
\n\
Raises \n\
------- \n\
TypeError : \n\
if data type of this data object is not complex.\n\
\n\
See Also \n\
--------- \n\
conjugate() : does the same operation but returns a complex-conjugated copy of this data object") |
|
| PyDoc_STRVAR (pyDataObjectConjugate_doc,"conjugate() -> return a copy of this dataObject where every element is complex-conjugated. \n\
\n\
Returns \n\
------- \n\
out : {dataObject} \n\
element-wise complex conjugate of this data object \n\
\n\
Raises \n\
------- \n\
TypeError : \n\
if data type of this data object is not complex.\n\
\n\
See Also \n\
--------- \n\
conj() : does the same operation but manipulates this object inline.") |
|
| PyDoc_STRVAR (pyDataObjectAdj_doc,"adj() -> Adjugate all elements\n\
\n\
Every plane (spanned by the last two axes) is transposed and every element is replaced by its complex conjugate value. \n\
\n\
Raises \n\
------- \n\
TypeError : \n\
if data type of this data object is not complex.\n\
\n\
See Also \n\
--------- \n\
adjugate() : does the same operation but returns the resulting data object") |
|
| PyDoc_STRVAR (pyDataObjectAdjugate_doc,"adjugate() -> returns the plane-wise adjugated array of this dataObject. \n\
\n\
If this data object has a complex type, the tranposed data object is returned where every element is complex conjugated. \
For data objects with more than two dimensions the tranposition is done plane-wise, hence, only the last two dimensions are permutated. \n\
\n\
Returns \n\
------- \n\
out : {dataObject} \n\
adjugate of this dataObject \n\
\n\
Raises \n\
------- \n\
TypeError : \n\
if data type of this data object is not complex.\n\
\n\
See Also \n\
--------- \n\
adj() : does the same operation but manipulates this object inline.") |
|
| PyDoc_STRVAR (pyDataObjectTrans_doc,"trans() -> return a plane-wise transposed dataObject\n\
\n\
Return a new data object with the same data type than this object and where every plane (data spanned by the last two dimensions) \
is transposed respectively such that the last two axes are permuted. \n\
\n\
Returns \n\
-------- \n\
out : {dataObject} \n\
A copy of this dataObject is returned where every plane is its transposed plane.") |
|
| PyDoc_STRVAR (pyDataObjectMakeContinuous_doc,"makeContinuous() -> return continuous representation of dataObject\n\
\n\
Per default a dataObject with more than two dimensions allocates separated chunks of memory for every plane, where \
a plane is always the matrix given by the last two dimensions. This separated storage usually allows allocating more \
memory for huge for instance three dimensional matrices. However, in order to generate a dataObject that is directly \
compatible to Numpy or other C-style matrix structures, the entire allocated memory must be in one block, that is called \
continuous. If you create a Numpy array from a dataObject that is not continuous, this function is implicitely called \
in order to firstly make the dataObject continuous before passing to Numpy. \n\
\n\
Returns \n\
-------- \n\
obj : {dataObject} \n\
continuous dataObject\n\
\n\
Notes \n\
----- \n\
if this dataObject already is continuous, a simple shallow copy is returned") |
|
| PyDoc_STRVAR (pyDataObjectSize_doc,"size([index]) -> returns the size of this dataObject (tuple of the sizes in all dimensions or size in dimension indicated by optional axis index). \n\
\n\
Parameters \n\
------------\n\
index : {int}, optional\n\
If index is given, only the size of the indicated dimension is returned as single number (0 <= index < number of dimensions) \n\
\n\
Returns \n\
-------- \n\
A tuple containing the sizes of all dimensions or one single size value if 'index' is indicated. \n\
\n\
Notes \n\
--------- \n\
For a more consistent syntax with respect to numpy arrays, the same result is obtained by the attribute shape. Please use the attribute shape for future implementations \
since this method is marked as deprecated.\n\
\n\
See Also \n\
--------- \n\
shape : the read-only attribute shape is equal to size()") |
|
| PyDoc_STRVAR (pyDataObjectCopy_doc,"copy(regionOnly=0) -> return a deep copy of this dataObject\n\
\n\
Parameters \n\
----------- \n\
regionOnly : {bool}, optional \n\
If regionOnly is 1, only the current region of interest of this dataObject is copied, else the entire dataObject \
including the current settings concerning the region of interest are deeply copied [default].\n\
\n\
Returns \n\
------- \n\
cpy : {dataObject} \n\
Deep copy of this dataObject") |
|
| PyDoc_STRVAR (pyDataObjectMul_doc,"mul(obj) -> a.mul(b) returns element wise multiplication of a*b\n\
\n\
All meta information (axis scales, offsets, descriptions, units, tags...) of the resulting object \
are copied from this data object. \n\
\n\
Parameters \n\
------------\n\
obj : {dataObject} \n\
dataObject whose values are element-wisely multiplied with the values in this dataObject. \n\
\n\
Returns \n\
-------- \n\
c : {dataObject} \n\
Resulting multiplied data object. \n\
\n\
For a mathematical multiplication see the *-operator.") |
|
| PyDoc_STRVAR (pyDataObjectDiv_doc,"div(obj) -> a.div(b) return result of element wise division of a./b \n\
\n\
All meta information (axis scales, offsets, descriptions, units, tags...) of the resulting object \
are copied from this data object. \n\
\n\
Parameters \n\
------------\n\
obj : {dataObject} \n\
Every value in this data object is divided by the corresponding value in obj. \n\
\n\
Returns \n\
-------- \n\
c : {dataObject} \n\
Resulting divided data object.") |
|
| PyDoc_STRVAR (pyDataObjectReshape_doc,"reshape(newSizes) -> Returns reshaped shallow copy of data object \n\
\n\
Notes \n\
----- \n\
Not implemented yet.\n\
\n\
") |
|
| PyDoc_STRVAR (pyDataObjectAstype_doc,"astype(typestring) -> converts this data object to another type\n\
\n\
Converts this data object to a new data object with another type, given by the string newTypestring (e.g. 'uint8'). The converted data object \
is a deep copy of this object if the new type does not correspond to the current type, else a shallow copy of this object is returned. \n\
\n\
Parameters \n\
----------- \n\
typestring : {str} \n\
Type string indicating the new type ('uint8',...'float32',..,'complex64') \n\
\n\
Returns \n\
-------- \n\
c : {dataObject} \n\
type-converted data object \n\
\n\
Notes \n\
----- \n\
This method mainly uses the method convertTo of OpenCV. \n\
") |
|
| PyDoc_STRVAR (pyDataObjectNormalize_doc,"normalize([minValue=0.0, maxValue=1.0, typestring='']) -> returns the normalization of this dataObject\n\
\n\
Returns the normalized version of this data object, where the values lie in the range [minValue,maxValue]. Additionally it is also \n\
possible to convert the resulting data object to another type (given by the parameter typestring). As default no type conversion is executed.\n\
\n\
Parameters \n\
----------- \n\
minValue : {double} \n\
minimum value of the normalized range \n\
maxValue : {double} \n\
maximum value of the normalized range \n\
typestring : {String} \n\
Type string indicating the new type ('uint8',...'float32',..,'complex64'), default: '' (no type conversion) \n\
\n\
Returns \n\
-------- \n\
normalized : {dataObject} \n\
normalized data object") |
|
| PyDoc_STRVAR (pyDataObjectLocateROI_doc,"locateROI() -> returns information about the current region of interest of this data object\n\
\n\
A region of interest (ROI) of a data object is defined by the two values per axis. The first element always indicates the size between the \n\
real border of the data object and the region of interest on the left / top ... side and the second value the margin of the right / bottom ... side. \n\
\n\
This method returns a tuple with two elements: The first is a list with the original sizes of this data object, \
the second is a list with the offsets from the original data object to the first value in the current region of interest \n\
\n\
If no region of interest is set (hence: full region of interest), the first list corresponds to the one returned by size(), \
the second list is a zero-vector. \n\
\n\
See Also \n\
-------- \n\
adjustROI(offsetList) : method to change the current region of interest") |
|
| PyDoc_STRVAR (pyDataObjectAdjustROI_doc,"adjustROI(offsetList) -> adjust the size and position of the region of interest of this data object\n\
\n\
For every data object, it is possible to define a region of interest such that subsequent commands only refer to this subpart. However, if values within \n\
the region of interest (ROI) are changed, this also affects the original data object due to the shallow copy principal of python. \n\
Use this command to adjust the current size and position of this region of interest by passing an offset list, that contains \
integer numbers with twice the size than the number of dimensions. \n\
\n\
Example: :: \n\
\n\
d = dataObject([5,4]) \n\
droi = d \n\
droi.adjustROI([-2,0,-1,-1]) \n\
\n\
Now *droi* is a region of interest of the original data object whose first value is equal to d[2,1] and its size is (3,2) \n\
\n\
Parameters \n\
----------- \n\
offsetList : {list of integers} \n\
This list must have twice as many values than the number of dimensions of this data object. A pair of numbers indicates the shift of the \
current boundaries of the region of interest in every dimension. The first value of each pair is the offset of the 'left' boundary, the \
second the shift of the right boundary. A positive value means a growth of the region of interest, a negative one let the region of interest \
shrink towards the center. \n\
\n\
See Also \n\
--------- \n\
locateROI() : method to get the borders of the current ROI") |
|
| PyDoc_STRVAR (pyDataObjectSqueeze_doc,"squeeze() -> return a squeezed shallow copy (if possible) of this dataObject. \n\
\n\
This method removes every dimension with size equal to 1. Take care, that \n\
none of the last two dimensions is considered by this squeeze-command. \n\
\n\
Returns \n\
-------- \n\
squeezed : {dataObject} \n\
The squeezed data object where all kept planes are shallow copies of the original plane. \n\
\n\
Notes \n\
----- \n\
The returned squeezed data object is a shallow copy of the original data object and hence changes in its values\n\
will also change the original data set.\n\
This method is equal to numpy.squeeze") |
|
| PyDoc_STRVAR (dataObjectAttrTagDict_doc,"return dictionary with all meta information of this dataObject \n\
\n\
Returns a new dictionary with the following meta information: \n\
\n\
* axisOffsets : List with offsets of each axis \n\
* axisScales : List with the scales of each axis \n\
* axisUnits : List with the unit strings of each axis \n\
* axisDescriptions : List with the description strings of each axis \n\
* tags : Dictionary with all tags including the tag 'protocol' if at least one protocol entry has been added using addToProtocol \n\
* valueOffset : Offset of each value (0.0) \n\
* valueScale : Scale of each value (1.0) \n\
* valueDescription : Description of the values \n\
* valueUnit : The unit string of the values \n\
\n\
Notes \n\
----- \n\
Adding or changing values to / in the dictionary does not change the meta information of the dataObject. \
Use the corresponding setters like setTag... instead.") |
|
| PyDoc_STRVAR (dataObjectArray_StructGet_doc,"__array_struct__ -> general python-array interface (do not call this directly) \n\
This interface makes the data object compatible to every array structure in python \n\
which does equally implement the array interface (e.g. NumPy). This method is \n\
therefore a helper method for the array interface.") |
|
| PyDoc_STRVAR (dataObjectArray_Interface_doc,"__array_interface__ -> general python-array interface (do not call this directly) \n\
This interface makes the data object compatible to every array structure in python \n\
which does equally implement the array interface (e.g. NumPy).") |
|
| PyDoc_STRVAR (dataObject_Array__doc,"__array__([dtype]) -> returns a numpy.ndarray from this dataObject. If possible a shallow copy is returned. \n\
If no desired dtype is given and if the this dataObject is continuous, a ndarray sharing its memory with this dataObject is returned. \n\
If the desired dtype does not fit to the type of this dataObject, a casted deep copy is returned. This is also the case if \n\
this dataObject is not continuous. Then a continuous dataObject is created that is the base object of the returned ndarray.") |
|
| PyDoc_STRVAR (pyDataObjectAbs_doc,"abs() -> return a new data object with the absolute values of the source\n\
\n\
This method calculates the abs value of each element in source and writes the result to the output object.\
In case of floating point or real object, the type of the output will not change. For complex values\
the type is changes to the corresponding floating type value.\n\
\n\
Returns \n\
------- \n\
res : {dataObject} \n\
output dataObject of same shape but the type may be changed.") |
|
| PyDoc_STRVAR (pyDataObjectArg_doc,"arg() -> return a new data object with the argument values of the source\n\
\n\
This method calculates the argument value of each element in source and writes the result to the output object.\
This object must be of complex type (complex128 or complex64). The output value will be float type (float64 or float32).\n\
\n\
Returns \n\
------- \n\
res : {dataObject} \n\
output dataObject of same shape but the type is changed.") |
|
| PyDoc_STRVAR (pyDataObjectReal_doc,"real() -> return a new data object with the real part of the source\n\
\n\
This method extracts the real part of each element in source and writes the result to the output object.\
This object must be of complex type (complex128 or complex64). The output value will be float type (float64 or float32).\n\
\n\
Returns \n\
------- \n\
res : {dataObject} \n\
output dataObject of same shape but the type is changed.") |
|
| PyDoc_STRVAR (pyDataObjectImag_doc,"imag() -> return a new data object with the imaginary part of the source\n\
\n\
This method extracts the imaginary part of each element in source and writes the result to the output object.\
This object must be of complex type (complex128 or complex64). The output value will be float type (float64 or float32).\n\
\n\
Returns \n\
------- \n\
res : {dataObject} \n\
output dataObject of same shape but the type is changed.") |
|
| PyDoc_STRVAR (pyDataObj_ToGray_doc,"toGray([destinationType='uint8']) -> returns the rgba32 color data object as a gray-scale object\n\
\n\
The destination data object has the same size than this data object and the real type given by destinationType. The pixel-wise \
conversion is done using the formula: gray = 0.299 * red + 0.587 * green + 0.114 * blue.\
\n\
Parameters \n\
----------- \n\
destinationType : {str} \n\
Type string indicating the new real type ('uint8',...'float32','float64' - no complex) \n\
\n\
Returns \n\
------- \n\
dataObj : {dataObject} \n\
converted gray-scale data object of desired type") |
|
| PyDoc_STRVAR (pyDataObjectToList_doc,"tolist() -> return the data object as a (possibly nested) list\n\
\n\
This method returns a nested list with all values of this data object. The recursion level of this nested list \
corresponds to the number of dimensions. The outer list corresponds to the first dimension. \n\
\n\
Returns \n\
------- \n\
y : {list} \n\
Nested list with values of data object (int, float or complex depending on type of data object)") |
|
| PyDoc_STRVAR (pyDataObjectStaticZeros_doc,"zeros(dims [, dtype='uint8'[, continuous = 0]]) -> creates new dataObject filled with zeros. \n\
\n\
Static method for creating a new n-dimensional itom.dataObject with given number of dimensions and dtype, filled with zeros. \n\
\n\
Parameters \n\
----------- \n\
dims : {integer list} \n\
'dims' is list indicating the size of each dimension, e.g. [2,3] is a matrix with 2 rows and 3 columns\n\
dtype : {str}, optional \n\
'dtype' is the data type of each element, possible values: 'int8','uint8',...,'int32','float32','float64','complex64','complex128', 'rgba32'\n\
continuous : {int}, optional \n\
'continuous' [0|1] defines whether the data block should be continuously allocated in memory [1] or in different smaller blocks [0] (recommended for huge matrices).\n\
\n\
Returns \n\
------- \n\
I : {dataObject} of shape (size,size)\n\
An array where all elements are equal to zero. \n\
\n\
See Also \n\
--------- \n\
eye: method for creating an eye matrix \n\
ones: method for creating a matrix filled with ones \n\
\n\
Notes \n\
------ \n\
For color-types (rgba32) every item / cell will be black and transparent: [r=0 g=0 b=0 a=0].") |
|
| PyDoc_STRVAR (pyDataObjectStaticOnes_doc,"ones(dims [, dtype='uint8'[, continuous = 0]]) -> creates new dataObject filled with ones. \n\
\n\
Static method for creating a new n-dimensional itom.dataObject with given number of dimensions and dtype, filled with ones. \n\
\n\
Parameters \n\
----------- \n\
dims : {integer list} \n\
'dims' is list indicating the size of each dimension, e.g. [2,3] is a matrix with 2 rows and 3 columns\n\
dtype : {str}, optional \n\
'dtype' is the data type of each element, possible values: 'int8','uint8',...,'int32','float32','float64','complex64','complex128', 'rgba32'\n\
continuous : {int}, optional \n\
'continuous' [0|1] defines whether the data block should be continuously allocated in memory [1] or in different smaller blocks [0] (recommended for huge matrices).\n\
\n\
Returns \n\
------- \n\
I : {dataObject} of shape (size,size)\n\
An array where all elements are equal to one. \n\
\n\
See Also \n\
--------- \n\
eye: method for creating an eye matrix \n\
zeros: method for creating a matrix filled with zeros \n\
\n\
Notes \n\
------ \n\
For color-types (rgba32) every item / cell will be white: [r=255 g=255 b=255 a=255].") |
|
| PyDoc_STRVAR (pyDataObjectStaticRand_doc,"rand([dims [, dtype='uint8'[, continuous = 0]]]) -> creates new dataObject filled with uniform distributed random values. \n\
\n\
Static method to create a new itom.dataObject filled with uniform distributed random numbers.\n\
In case of an integer type, the uniform noise is from min<ObjectType>(inclusiv) to max<ObjectType>(inclusiv).\n\
For floating point types, the noise is between 0(inclusiv) and 1(exclusiv). \n\
\n\
Parameters \n\
----------- \n\
dims : {integer list} \n\
'dims' is list indicating the size of each dimension, e.g. [2,3] is a matrix with 2 rows and 3 columns.\n\
dtype : {str}, optional \n\
'dtype' is the data type of each element, possible values: 'int8','uint8',...,'int32','float32','float64','complex64','complex128'\n\
continuous : {int}, optional \n\
'continuous' [0|1] defines whether the data block should be continuously allocated in memory [1] or in different smaller blocks [0] (recommended for huge matrices).\n\
\n\
Returns \n\
------- \n\
out : {dataObject} \n\
Array of random numbers with the given dimensions, dtype. \n\
\n\
See Also \n\
--------- \n\
randN: method for creating a matrix filled with gaussianly distributed values") |
|
| PyDoc_STRVAR (pyDataObjectStaticRandN_doc,"randN(dims [, dtype='uint8'[, continuous = 0]]) -> creates dataObject filled with gaussian distributed random values. \n\
\n\
Static method to create a new itom.dataObject filled with gaussian distributed random numbers. \n\
In case of an integer type, the gausian noise mean value is (max+min)/2.0 and the standard deviation is (max-min/)6.0 to max. \n\
For floating point types, the noise mean value is 0 and the standard deviation is 1.0/3.0. \n\
\n\
Parameters \n\
----------- \n\
dims : {integer list} \n\
'dims' is list indicating the size of each dimension, e.g. [2,3] is a matrix with 2 rows and 3 columns.\n\
dtype : {str}, optional \n\
'dtype' is the data type of each element, possible values: 'int8','uint8',...,'int32', 'float32','float64','complex64','complex128'\n\
continuous : {int}, optional \n\
'continuous' [0|1] defines whether the data block should be continuously allocated in memory [1] or in different smaller blocks [0] (recommended for huge matrices).\n\
\n\
Returns \n\
------- \n\
out : {dataObject} \n\
Array of random numbers with the given dimensions, dtype. \n\
\n\
See Also \n\
--------- \n\
rand: method for creating a matrix filled with unformly distributed values") |
|
| PyDoc_STRVAR (pyDataObjectStaticEye_doc,"eye(size [, dtype='uint8']) -> creates a 2D, square, eye-matrix.\n\
\n\
Static method for creating a two-dimensional, square, eye-matrix of type itom.dataObject. \n\
\n\
Parameters \n\
----------- \n\
size : {int}, \n\
the size of the square matrix (single value)\n\
dtype : {str}, optional \n\
'dtype' is the data type of each element, possible values: 'int8','uint8',...,'int32','uint32','float32','float64','complex64','complex128'\n\
\n\
Returns \n\
------- \n\
I : {dataObject} of shape (size,size)\n\
An array where all elements are equal to zero, except for the 'k-th diagonal, whose values are equal to one. \n\
\n\
See Also \n\
--------- \n\
ones: method for creating a matrix filled with ones \n\
zeros: method for creating a matrix filled with zeros") |
|
| PyDoc_STRVAR (pyDataObjectIterLen_doc,"Private method returning an estimate of len(list(it)).") |
|
| PyDoc_STRVAR (pyFigureInit_doc,"figure([handle, [rows = 1, cols = 1]]) -> creates figure window.\n\
\n\
The class itom.figure represents a standalone figure window, that can have various subplots. If an instance of this class \n\
is created without further parameters a new figure is created and opened having one subplot area (currently empty) and the numeric \n\
handle to this figure is returned:: \n\
\n\
h = figure() \n\
\n\
Subplots are arranged in a regular grid whose size is defined by the optional parameters 'rows' and 'cols'. If you create a figure \n\
instance with a given handle, the instance is either a reference to an existing figure that has got this handle or if it does not exist, \n\
a new figure with the desired handle is opened and the handle is returned, too. \n\
\n\
Parameters \n\
------------- \n\
handle : {int} \n\
numeric handle of the desired figure. \n\
rows : {int, default: 1} \n\
number of rows this figure should have (defines the size of the subplot-grid) \n\
cols : {int, default: 1} \n\
number of columns this figure should have (defines the size of the subplot-grid)") |
|
| PyDoc_STRVAR (pyFigurePlot_doc,"plot(data, [areaIndex, className, properties]) -> plots a dataObject in the current or given area of this figure\n\
Plot an existing dataObject in not dockable, not blocking window. \n\
The style of the plot will depend on the object dimensions.\n\
If x-dim or y-dim are equal to 1, plot will be a lineplot else a 2D-plot.\n\
\n\
Parameters\n\
-----------\n\
data : {DataObject} \n\
Is the data object whose region of interest will be plotted.\n\
areaIndex: {int}, optional \n\
Area number where the plot should be put if subplots have been created\n\
className : {str}, optional \n\
class name of desired plot (if not indicated default plot will be used (see application settings) \n\
properties : {dict}, optional \n\
optional dictionary of properties that will be directly applied to the plot widget.") |
|
| PyDoc_STRVAR (pyFigureLiveImage_doc,"liveImage(cam, [areaIndex, className, properties]) -> shows a camera live image in the current or given area of this figure\n\
Creates a plot-image (2D) and automatically grabs images into this window.\n\
This function is not blocking.\n\
\n\
Parameters\n\
-----------\n\
cam : {dataIO-Instance} \n\
Camera grabber device from which images are acquired.\n\
areaIndex: {int}, optional \n\
Area number where the plot should be put if subplots have been created\n\
className : {str}, optional \n\
class name of desired plot (if not indicated default plot will be used (see application settings) \n\
properties : {dict}, optional \n\
optional dictionary of properties that will be directly applied to the plot widget.") |
|
| PyDoc_STRVAR (pyFigureShow_doc,"show() -> shows figure \n\
\n\
\n\
") |
|
| PyDoc_STRVAR (pyFigureHide_doc,"hide() -> hides figure without deleting it\n\
\n\
\n\
") |
|
| PyDoc_STRVAR (pyFigureSubplot_doc,"subplot(index) -> returns plotItem of desired subplot\n\
\n\
This method closes and deletes any specific figure (given by handle) or all opened figures. \n\
\n\
Parameters \n\
----------- \n\
index : {unsigned int} \n\
index to desired subplot. The subplot at the top, left position has the index 0 whereas the index is incremented row-wise.") |
|
| PyDoc_STRVAR (pyFigure_docked_doc,"dock status of figure (True|False) \n\
\n\
this attribute controls the dock appearance of this figure. If it is docked, the figure is integrated into the main window \n\
of itom, else it is a independent window. \n\
") |
|
| PyDoc_STRVAR (pyFigure_Close_doc,"close(handle|'all') -> static method to close any specific or all open figures (unless any figure-instance still keeps track of them)\n\
\n\
This method closes and deletes any specific figure (given by handle) or all opened figures. \n\
\n\
Parameters \n\
----------- \n\
handle : {dataIO-Instance} \n\
any figure handle (>0) or 'all' in order to close all opened figures \n\
\n\
Notes \n\
------- \n\
If any instance of class 'figure' still keeps a reference to any figure, it is only closed and deleted if the last instance is deleted, too.") |
|
| PyDoc_STRVAR (PyFont_doc,"font(family [, pointSize = 0, weight = -1, italic = false) -> creates a font object. \n\
\n\
This class is a wrapper for the class QFont of Qt. It provides possibilities for creating a font type. \n\
\n\
Parameters \n\
----------- \n\
family : {str} \n\
The family name may optionally also include a foundry name, e.g. 'Helvetica [Cronyx]'. If the family is available \
from more than one foundry and the foundry isn't specified, an arbitrary foundry is chosen. If the family isn't \
available a family will be set using a best-matching algorithm. \n\
pointSize : {int}, optional \n\
If pointSize is zero or negative, the point size of the font is set to a system-dependent default value. \
Generally, this is 12 points, except on Symbian where it is 7 points. \n\
weight : {int}, optional \n\
Weighting scale from 0 to 99, e.g. font.Light, font.Normal (default), font.DemiBold, font.Bold, font.Black \n\
italic : {bool}, optional \n\
defines if font is italic or not (default)") |
|
| PyDoc_STRVAR (font_getFamily_doc,"Gets/Sets the family name of the font. The name is case insensitive and may include a foundry name. \n\
\n\
The family name may optionally also include a foundry name, e.g. 'Helvetica [Cronyx]'. If the family \
is available from more than one foundry and the foundry isn't specified, an arbitrary foundry is chosen. \
If the family isn't available a family will be set using a font matching algorithm.") |
|
| PyDoc_STRVAR (font_getWeight_doc,"Sets the weight the font to weight. \n\
\n\
This should be a value from the font.Light, font.Normal, font.DemiBold, font.Bold, font.Black enumeration or any value in the range [0,99].") |
|
| PyDoc_STRVAR (font_getPointSize_doc,"Gets/Sets the point size to pointSize. The point size must be greater than zero.") |
|
| PyDoc_STRVAR (font_getItalic_doc,"Gets/Sets the italic attribute of the font.") |
|
| PyDoc_STRVAR (font_getStrikeOut_doc,"Gets/Sets the strikeout on or off.") |
|
| PyDoc_STRVAR (font_getUnderline_doc,"Gets/Sets the underline on or off.") |
|
| PyDoc_STRVAR (pyOpenEmptyScriptEditor_doc,"scriptEditor() -> opens new, empty script editor window (undocked)") |
|
| PyDoc_STRVAR (pyNewScript_doc,"newScript() -> opens an empty, new script in the current script window.\n\
\n\
Creates a new itom script in the latest opened editor window.") |
|
| PyDoc_STRVAR (pyOpenScript_doc,"openScript(filename) -> open the given script in current script window.\n\
\n\
Open the python script indicated by *filename* in a new tab in the current, latest opened editor window. \n\
Filename can be either a string with a relative or absolute filename to the script to open or any object \n\
with a `__file__` attribute. This attribute is then read and used as path. \n\
\n\
The relative filename is relative with respect to the current directory. \n\
\n\
Parameters \n\
----------- \n\
filename : {str} or {obj} \n\
Relative or absolute filename to a python script that is then opened (in the current editor window). Alternatively an object with a `__file__` attribute is allowed.") |
|
| PyDoc_STRVAR (pyPlotImage_doc,"plot(data, [className, properties]) -> plots a dataObject in a newly created figure \n\
\n\
Plot an existing dataObject in dockable, not blocking window. \n\
The style of the plot depends on the object dimensions.\n\
If x-dim or y-dim are equal to 1, plot will be a line-plot, else a 2D-plot.\n\
\n\
Parameters \n\
----------- \n\
data : {DataObject} \n\
Is the data object whose region of interest will be plotted.\n\
className : {str}, optional \n\
class name of desired plot (if not indicated or if the className can not be found, the default plot will be used (see application settings) \n\
properties : {dict}, optional \n\
optional dictionary of properties that will be directly applied to the plot widget.") |
|
| PyDoc_STRVAR (pyLiveImage_doc,"liveImage(cam, [className, properties]) -> show a camera live image in a newly created figure\n\
\n\
Creates a plot-image (2D) and automatically grabs images into this window.\n\
This function is not blocking.\n\
\n\
Parameters \n\
----------- \n\
cam : {dataIO-Instance} \n\
Camera grabber device from which images are acquired.\n\
className : {str}, optional \n\
class name of desired plot (if not indicated or if the className can not be found, the default plot will be used (see application settings) \n\
properties : {dict}, optional \n\
optional dictionary of properties that will be directly applied to the plot widget.") |
| PyObject * | PyWidgetOrFilterHelp (bool getWidgetHelp, PyObject *pArgs, PyObject *pKwds) |
|
| PyDoc_STRVAR (pyFilterHelp_doc,"filterHelp([filterName, dictionary = 0, furtherInfos = 0]) -> generates an online help for the given filter(s). \n\
\n\
This method prints information about one specific filter (algorithm) or a list of filters to the console output. If one specific filter, defined \
in an algorithm plugin can be found that case-sensitively fits the given filterName its full documentation is printed. Else, a list of filters \
is printed whose name contains the given filterName.\n\
\n\
Parameters \n\
----------- \n\
filterName : {str}, optional \n\
is the fullname or a part of any filter-name which should be displayed. \n\
If filterName is empty or no filter matches filterName (case sensitive) a list with all suitable filters is given. \n\
dictionary : {dict}, optional \n\
if dictionary == 1, a dictionary with all relevant components of the filter's documentation is returned and nothing is printed to the command line [default: 0] \n\
furtherInfos : {int}, optional \n\
Usually, filters or algorithms whose name only contains the given filterName are only listed at the end of the information text. \n\
If this parameter is set to 1 [default: 0], the full information for all these filters is printed as well. \n\
\n\
Returns \n\
------- \n\
out : {None or dict} \n\
In its default parameterization this method returns None. Depending on the parameter dictionary it is also possible that this method \
returns a dictionary with the single components of the information text.") |
|
| PyDoc_STRVAR (pyWidgetHelp_doc,"widgetHelp([widgetName, dictionary = 0, furtherInfos = 0]) -> generates an online help for the given widget(s). \n\
\n\
This method prints information about one specific widget or a list of widgets to the console output. If one specific widget, defined \
in an algorithm plugin can be found that case-sensitively fits the given widgetName its full documentation is printed. Else, a list of widgets \
is printed whose name contains the given widgetName.\n\
\n\
Parameters \n\
----------- \n\
widgetName : {str}, optional \n\
is the fullname or a part of any widget-name which should be displayed. \n\
If widgetName is empty or no widget matches widgetName (case sensitive) a list with all suitable widgets is given. \n\
dictionary : {dict}, optional \n\
if dictionary == 1, a dictionary with all relevant components of the widget's documentation is returned and nothing is printed to the command line [default: 0] \n\
furtherInfos : {int}, optional \n\
Usually, widgets whose name only contains the given widgetName are only listed at the end of the information text. \n\
If this parameter is set to 1 [default: 0], the full information for all these widgets is printed as well. \n\
\n\
Returns \n\
------- \n\
out : {None or dict} \n\
In its default parameterization this method returns None. Depending on the parameter dictionary it is also possible that this method \
returns a dictionary with the single components of the information text.") |
|
| PyDoc_STRVAR (pyPluginLoaded_doc,"pluginLoaded(pluginName) -> check if a certain plugin could be successfully loaded.\n\
\n\
Checks if a specified plugin is loaded and returns the result as a boolean expression. \n\
\n\
Parameters \n\
----------- \n\
pluginName : {str} \n\
The name of a specified plugin as usually displayed in the plugin window.\n\
\n\
Returns \n\
------- \n\
result : {bool} \n\
True, if the plugin has been loaded and can be used, else False.") |
|
| PyDoc_STRVAR (pyPlotLoaded_doc,"plotLoaded(plotName) -> check if a certain plot widget is loaded.\n\
\n\
Checks if a specified plot widget is loaded and returns the result as a boolean expression. \n\
\n\
Parameters \n\
----------- \n\
pluginName : {str} \n\
The name of a specified plot widget as displayed in the preferences window.\n\
\n\
Returns \n\
------- \n\
result : {bool} \n\
True, if the plot has been loaded and can be used, else False.") |
|
| PyDoc_STRVAR (pyPlotHelp_doc,"plotHelp(plotName [, dictionary = False]) -> generates an online help for the specified plot.\n\
Gets (also print to console) the available slots / properties of the plot specified by plotName (str, as specified in the properties window).\n\
If `dictionary == True`, a dict with all plot slots / properties is returned and nothing is printed to the console.\n\
\n\
Parameters \n\
----------- \n\
plotName : {str} \n\
is the fullname of a plot as specified in the properties window (case insensitive).\n\
if * or empty string is given, a list of availble widgets is returned.\n\
dictionary : {bool}, optional \n\
if `dictionary == True`, function returns a dict with plot slots and properties and does not print anything to the console (default: False)\n\
\n\
Returns \n\
------- \n\
out : {None or dict} \n\
Returns None or a dict depending on the value of parameter `dictionary`.") |
|
| PyDoc_STRVAR (pyPluginHelp_doc,"pluginHelp(pluginName [, dictionary = False]) -> generates an online help for the specified plugin.\n\
Gets (also print to console) the initialisation parameters of the plugin specified pluginName (str, as specified in the plugin window).\n\
If `dictionary == True`, a dict with all plugin parameters is returned and nothing is printed to the console.\n\
\n\
Parameters \n\
----------- \n\
pluginName : {str} \n\
is the fullname of a plugin as specified in the plugin window.\n\
dictionary : {bool}, optional \n\
if `dictionary == True`, function returns a dict with plugin parameters and does not print anything to the console (default: False)\n\
\n\
Returns \n\
------- \n\
out : {None or dict} \n\
Returns None or a dict depending on the value of parameter `dictionary`.") |
|
| PyDoc_STRVAR (pyITOMVersion_doc,"version([toggle-output [, include-plugins]])) -> retrieve complete information about itom version numbers\n\
\n\
Parameters \n\
----------- \n\
toggle-output : {bool}, optional\n\
default = false\n\
if true, output will be written to a dictionary else to console.\n\
dictionary : {bool}, optional \n\
default = false\n\
if true, add informations about plugIn versions.\n\
\n\
Returns \n\
------- \n\
None (display outPut) or PyDictionary with version information.\n\
\n\
Notes \n\
----- \n\
\n\
Retrieve complete version information of itom and if specified version information of loaded plugins\n\
and print it either to the console or to a PyDictionary.") |
|
| PyDoc_STRVAR (pyAddButton_doc,"addButton(toolbarName, buttonName, code [, icon, argtuple]) -> adds a button to a toolbar in the main window \n\
\n\
This function adds a button to a toolbar in the main window. If the button is pressed the given code, function or method is executed. \n\
If the toolbar specified by 'toolbarName' does not exist, it is created. The button will show the optional icon, or if not given or not \n\
loadable, 'buttonName' is displayed as text. \n\
\n\
itom comes with basic icons addressable by ':/../iconname.png', e.g. ':/gui/icons/close.png'. These natively available icons are listed \n\
in the icon-browser in the menu 'edit >> iconbrowser' of any script window. Furthermore you can give a relative or absolute path to \n\
any allowed icon file (the preferred file format is png). \n\
\n\
Parameters \n\
----------- \n\
toolbarName : {str} \n\
The name of the toolbar.\n\
buttonName : {str} \n\
The name and identifier of the button to create.\n\
code : {str, method, function}\n\
The code to be executed if the button is pressed.\n\
icon : {str}, optional \n\
The filename of an icon-file. This can also be relative to the application directory of 'itom'.\n\
argtuple : {tuple}, optional \n\
Arguments, which will be passed to the method (in order to avoid cyclic references try to only use basic element types). \n\
\n\
Returns \n\
------- \n\
handle : {int} \n\
handle to the newly created button (pass it to removeButton to delete exactly this button) \n\
\n\
Raises \n\
------- \n\
Runtime error : \n\
if the main window is not available \n\
\n\
See Also \n\
--------- \n\
removeButton()") |
|
| PyDoc_STRVAR (pyRemoveButton_doc,"removeButton(handle | toolbarName [, buttonName]) -> removes a button from a given toolbar. \n\
\n\
This method removes an existing button from a toolbar in the main window of 'itom'. This button must have been \n\
created using `addButton`. If the toolbar is empty after the removal, it is finally deleted. \n\
\n\
Pass either the 'handle' parameter of both 'toolbarName' and 'buttonName'. It is more precise to use the handle in order to exactly \n\
delete the button that has been created by a call to `addButton`. Using the names of the toolbar and the button always delete any \n\
button that has been created using this data. \n\
\n\
Parameters \n\
----------- \n\
handle : {int} \n\
The handle returned by addButton(). \n\
toolbarName : {str} \n\
The name of the toolbar.\n\
buttonName : {str} \n\
The name (str, identifier) of the button to remove.\n\
\n\
Raises \n\
------- \n\
Runtime error : \n\
if the main window is not available or the given button could not be found. \n\
\n\
See Also \n\
--------- \n\
addButton()") |
|
| PyDoc_STRVAR (pyAddMenu_doc,"addMenu(type, key [, name, code, icon, argtuple]) -> adds an element to the menu bar of itom. \n\
\n\
This function adds an element to the main window menu bar. \n\
The root element of every menu-list must be a MENU-element. Such a MENU-element can contain sub-elements. \n\
The following sub-elements can be either another MENU, a SEPARATOR or a BUTTON. Only the BUTTON itself \n\
triggers a signal, which then executes the code, given by a string or a reference to a callable python method \n\
or function. Remember, that this reference is only stored as a weak pointer. \n\
If you want to directly add a sub-element, you can give a slash-separated string in the key-parameter. \n\
Every sub-component of this string then represents the menu-element in its specific level. Only the element in the last \n\
can be something else than MENU.\n\
\n\
itom comes with basic icons addressable by ':/../iconname.png', e.g. ':/gui/icons/close.png'. These natively available icons are listed \n\
in the icon-browser in the menu 'edit >> iconbrowser' of any script window. Furthermore you can give a relative or absolute path to \n\
any allowed icon file (the preferred file format is png). \n\
\n\
Parameters \n\
----------- \n\
type : {Int}\n\
The type of the menu-element (BUTTON:0 [default], SEPARATOR:1, MENU:2). Use the corresponding constans in module 'itom'.\n\
key : {str} \n\
A slash-separated string where every sub-element is the key-name for the menu-element in the specific level.\n\
name : {str}, optional \n\
The text of the menu-element. If not indicated, the last sub-element of key is taken.\n\
code : {str, Method, Function}, optional \n\
The code to be executed if menu element is pressed.\n\
icon : {str}, optional \n\
The filename of an icon-file. This can also be relative to the application directory of 'itom'.\n\
argtuple : {tuple}, optional \n\
Arguments, which will be passed to method (in order to avoid cyclic references try to only use basic element types).\n\
\n\
Returns \n\
------- \n\
handle : {int} \n\
Handle to the recently added leaf node (action, separator or menu item). Use this handle to delete the item including its child items (for type 'menu'). \n\
\n\
Raises \n\
------- \n\
Runtime error : \n\
if the main window is not available or the given button could not be found. \n\
\n\
See Also \n\
--------- \n\
removeMenu") |
|
| PyDoc_STRVAR (pyRemoveMenu_doc,"removeMenu(key | menuHandle) -> remove a menu element with the given key or handle. \n\
\n\
This function remove a menu element with the given key or menuHandle. \n\
key is a slash separated list. The sub-components then \n\
lead the way to the final element, which should be removed. \n\
\n\
Alternatively, it is possible to pass the handle obtained by `addMenu`. \n\
\n\
Parameters \n\
----------- \n\
key : {str}, optional\n\
The name (str, identifier) of the menu entry to remove.\n\
handle : {int}, optional \n\
The handle of the menu entry that should be removed (including its possible child items). \n\
\n\
Raises \n\
------- \n\
Runtime error : \n\
if the main window is not available or the given button could not be found. \n\
\n\
See Also \n\
--------- \n\
addMenu") |
|
| PyDoc_STRVAR (autoReloader_doc,"autoReloader(enabled [,checkFileExec = True, checkCmdExec = True, checkFctExec = False]) -> dis-/enables the module to automatically reload changed modules \n\
\n\
Use this method to enable or disable (and configure) a tool that automatically tries to reload imported modules and their submodules if they have changed \n\
since the last run. \n\
\n\
Returns \n\
------- \n\
enable : {bool} \n\
The auto-reload tool is loaded if it is enabled for the first time. If it is disabled, \n\
it does not check changes of any imported modules. \n\
checkFileExec : {bool} \n\
If True (default) and auto-reload enabled, a check for modifications is executed whenever a script is executed \n\
checkCmdExec : {bool} \n\
If True (default) and auto-reload enabled, a check for modifications is executed whenever a command in the command line is executed \n\
checkFctExec : {bool} \n\
If True and auto-reload enabled, a check for modifications is executed whenever a function or method is run (e.g. by an event or button click) (default: False)\n\
\n\
Notes \n\
------- \n\
This tool is inspired by and based on the IPython extension 'autoreload'. \n\
\n\
Reloading Python modules in a reliable way is in general difficult, \n\
and unexpected things may occur. ``autoReloader`` tries to work around \n\
common pitfalls by replacing function code objects and parts of \n\
classes previously in the module with new versions. This makes the \n\
following things to work: \n\
\n\
- Functions and classes imported via 'from xxx import foo' are upgraded \n\
to new versions when 'xxx' is reloaded. \n\
\n\
- Methods and properties of classes are upgraded on reload, so that \n\
calling 'c.foo()' on an object 'c' created before the reload causes \n\
the new code for 'foo' to be executed. \n\
\n\
Some of the known remaining caveats are: \n\
\n\
- Replacing code objects does not always succeed: changing a @property \n\
in a class to an ordinary method or a method to a member variable \n\
can cause problems (but in old objects only). \n\
\n\
- Functions that are removed (eg. via monkey-patching) from a module \n\
before it is reloaded are not upgraded. \n\
\n\
- C extension modules cannot be reloaded, and so cannot be autoreloaded.") |
|
| PyDoc_STRVAR (getScreenInfo_doc,"getScreenInfo() -> returns dictionary with information about all available screens. \n\
\n\
This method returns a dictionary with information about the current screen configuration of this computer. \n\
\n\
Returns \n\
------- \n\
screenInfo : {dict} \n\
dictionary with the following content is returned: \n\
\n\
* screenCount (int): number of available screens \n\
* primaryScreen (int): index (0-based) of primary screen \n\
* geometry (tuple): tuple with dictionaries for each screen containing data for width (w), height (h) and its top-left-position (x, y)") |
|
| PyDoc_STRVAR (pySaveMatlabMat_doc,"saveMatlabMat(filename, values[, matrixName = 'matrix']) -> save strings, numbers, arrays or combinations into a Matlab mat file. \n\
\n\
Save one or multiple objects (strings, numbers, arrays, `dataObject`, `numpy.ndarray`, `npDataObject`...) to a Matlab *mat* file. \n\
There are the following possibilites for saving: \n\
\n\
* One given value is saved under one given 'matrixName' or 'matrix' if 'matrixName' is not given. \n\
* A list or tuple of objects is given. If no 'matrixName' is given, the items get the names 'matrix1', 'matrix2'... Else, 'matrixName' must be a sequence of value names with the same length than 'values'. \n\
* A dictionary is given, such that each value is stored under its corresponding key. \n\
\n\
Parameters \n\
----------- \n\
filename : {str} \n\
Filename under which the file should be saved (.mat will be appended if not available)\n\
values : {dictionary, list, tuple, variant} \n\
single value, dictionary, list or tuple with elements of type number, string, array (dataObject, numpy.ndarray, npDataObject...)\n\
matrix-name : {str, list, tuple}, optional \n\
if 'values' is a single value, this parameter must be one single str, if 'values' is a sequence it must be a sequence of strings with the same length, if 'values' is a dictionary this argument is ignored. \n\
\n\
See Also \n\
---------- \n\
loadMatlabMat") |
|
| PyDoc_STRVAR (pyLoadMatlabMat_doc,"loadMatlabMat(filename) -> loads Matlab mat-file by using scipy methods and returns the loaded dictionary. \n\
\n\
This function loads matlab mat-file by using scipy methods and returns the loaded dictionary. \n\
\n\
Parameters \n\
----------- \n\
filename : {str} \n\
Filename from which the data will be imported (.mat will be added if not available)\n\
\n\
Returns \n\
------- \n\
mat : {dict} \n\
dictionary with content of file \n\
\n\
See Also \n\
--------- \n\
saveMatlabMat") |
|
| PyDoc_STRVAR (pyFilter_doc,"filter(name [, furtherParameters, ...]) -> invoke a filter (or algorithm) function from an algorithm-plugin. \n\
\n\
This function is used to invoke itom filter-functions or algorithms, declared within itom-algorithm plugins.\n\
The parameters (arguments) depends on the specific filter function (see filterHelp(name)),\n\
By filterHelp() a list of available filter functions is retrieved. \n\
\n\
Parameters \n\
----------- \n\
name : {str} \n\
The name of the filter\n\
furtherParameters : {variant} \n\
Further parameters depend on the filter-methods itself (give the mandatory and then optional parameters in their defined order).\n\
\n\
Returns \n\
------- \n\
out : {variant} \n\
The returned values depend on the definition of each filter. In general it is a tuple of all output parameters that are defined by the filter function.\n\
\n\
See Also \n\
--------- \n\
filterHelp") |
|
| PyDoc_STRVAR (pySaveDataObject_doc,"saveDataObject(filename, dataObject [, tagsAsBinary = False]) -> save a dataObject to harddrive in a xml-based file format. \n\
\n\
This method writes a `dataObject` into the file specified by 'filename'. The data is stored in a binary format within a xml-based structure. \n\
All string-tags of the dataObject are encoded in order to avoid xml-errors, the value of numerical tags are converted to string with \n\
15 significant digits (>32bit, tagsAsBinary = False [default]) or in a binary format (tagsAsBinary = True). \n\
\n\
Parameters \n\
----------- \n\
filename : {str} \n\
Filename and Path of the destination (.ido will be added if no .*-ending is available)\n\
dataObject : {DataObject} \n\
An allocated dataObject of n-Dimensions.\n\
tagsAsBinary : {bool}, optional \n\
Optional tag to toggle if numeric-tags should be saved (metaData) as binary or by default as string.\n\
\n\
Notes \n\
----- \n\
Tagnames which contains special characters leads to XML-conflics. \n\
\n\
See Also \n\
--------- \n\
loadDataObject") |
|
| PyDoc_STRVAR (pyLoadDataObject_doc,"loadDataObject(filename, dataObject [, doNotAppendIDO]) -> load a dataObject from the harddrive. \n\
\n\
This function reads a `dataObject` from the file specified by filename. \n\
MetaData saveType (string, binary) are extracted from the file and restored within the object.\n\
\n\
Parameters \n\
----------- \n\
filename : {str} \n\
Filename and Path of the destination (.ido will be added if not available)\n\
dataObject : {`dataObject`} \n\
A pre-allocated `dataObject` (empty dataObject is allowed).\n\
doNotAppendIDO : {bool}, optional \n\
False[default]: file suffix *.ido* will not be appended to filename, True: it will be added.\n\
\n\
Notes \n\
----- \n\
\n\
The value of string-Tags must be encoded to avoid XML-conflics.\n\
Tagnames which contains special characters leads to XML-conflics.") |
|
| PyDoc_STRVAR (getDefaultScaleableUnits_doc,"getDefaultScaleableUnits() -> Get a list with the strings of the standard scalable units. \n\
\n\
The unit strings returned as a list by this method can be transformed into each other using `scaleValueAndUnit`. \n\
\n\
Returns \n\
------- \n\
units : {list} \n\
List with strings containing all scaleable units \n\
\n\
See Also \n\
-------- \n\
scaleValueAndUnit") |
|
| PyDoc_STRVAR (scaleValueAndUnit_doc,"ScaleValueAndUnit(scaleableUnits, value, valueUnit) -> Scale a value and its unit and returns [value, 'Unit'] \n\
\n\
Parameters \n\
----------- \n\
scaleableUnits : {PyList of Strings} \n\
A string list with all scaleable units\n\
value : {double} \n\
The value to be scaled\n\
valueUnit : {str} \n\
The value unit to be scaled\n\
\n\
Returns \n\
------- \n\
PyTuple with scaled value and scaled unit\n\
\n\
Notes \n\
----- \n\
\n\
Rescale a value with SI-unit (e.g. 0.01 mm to 10 micrometer). Used together with itom.getDefaultScaleableUnits()") |
|
| PyDoc_STRVAR (getAppPath_doc,"getAppPath() -> returns absolute path of application base directory.\n\
\n\
This function returns the absolute path of application base directory.\n\
The return value is independent of the current working directory. \n\
\n\
Returns \n\
------- \n\
path : {str}\n\
absolute path of this application's base directory") |
|
| PyDoc_STRVAR (getCurrentPath_doc,"getCurrentPath() -> returns absolute path of current working directory.\n\
\n\
Returns \n\
------- \n\
Path : {str}\n\
absolute path of current working directory \n\
\n\
See Also \n\
---------- \n\
setCurrentPath") |
|
| PyDoc_STRVAR (setCurrentPath_doc,"setCurrentPath(newPath) -> set current working directory to given absolute newPath \n\
\n\
sets the absolute path of the current working directory to 'newPath'. The current working directory is the base \n\
directory for all subsequent relative pathes of icon-files, script-files, ui-files, relative import statements... \n\
\n\
The current directory is always indicated in the right corner of the status bar of the main window. \n\
\n\
Parameters \n\
----------- \n\
newPath : {str} \n\
The new working path of this application\n\
\n\
Returns \n\
------- \n\
success : {bool} \n\
True in case of success else False \n\
\n\
See Also \n\
--------- \n\
getCurrentPath()") |
|
| PyDoc_STRVAR (setApplicationCursor_doc,"setApplicationCursor([cursorIndex = -1]) -> changes the itom cursor or restores the previously set cursor if -1 \n\
\n\
This methods changes the overall cursor icon of itom where cursorIndex corresponds to the Qt enumeration Qt::CursorShape. e.g.:\n\
\n\
* 0: Arrow \n\
* 2: Cross Cursor \n\
* 3: Wait Curson \n\
* 13: Pointing Hand Cursor \n\
* 14: Forbidden Cursor \n\
* 16: Busy Cursor \n\
\n\
Parameters \n\
----------- \n\
cursorIndex : {int} optional\n\
The cursor enumeration value of the desired cursor shape (Qt::CursorShape) or -1 if the previous cursor should be restored (default)") |
|
| PyDoc_STRVAR (pyLoadIDC_doc,"loadIDC(filename) -> load a pickled idc-file and return the content as dictionary\n\
\n\
This methods loads the given idc-file using the method `pickle.load` from the python-buildin module `pickle` and returns the loaded dictionary.\n\
\n\
Parameters \n\
----------- \n\
filename : {String} \n\
absolute filename or filename relative to the current directory. \n\
\n\
Returns \n\
-------- \n\
content : {dict} \n\
dictionary with loaded content \n\
\n\
See Also \n\
--------- \n\
pickle.load, saveIDC") |
| | *static*/ PyObject* PythonItom::PyGetGlobalDict(PyObject* /*pSelf*/)
|
|
| PyDoc_STRVAR (pySaveIDC_doc,"saveIDC(filename, dict [,overwriteIfExists = True]) -> saves the given dictionary as pickled idc-file.\n\
\n\
This method saves the given dictionary as pickled idc-file using the method dump from the builtin module pickle.\n\
\n\
Parameters \n\
----------- \n\
filename : {string} \n\
absolute filename or filename relative to the current directory. \n\
dict : {dict} \n\
dictionary which should be pickled. \n\
overwriteIfExists : {bool}, default: True \n\
if True, an existing file will be overwritten. \n\
\n\
See Also \n\
--------- \n\
pickle.dump, loadIDC") |
|
| PyDoc_STRVAR (pyCheckIsAdmin_doc,"userIsAdmin() -> return True if USER has administrator status.\n\
\n\
This method returns a boolean expression. If the USER defined by the user managment has administrator status it is true, in other cases it is False. \n\
\n\
Returns \n\
------- \n\
isRequestedType : {boolean} \n\
Boolean return value \n\
\n\
") |
|
| PyDoc_STRVAR (pyCheckIsDeveloper_doc,"userIsDeveloper() -> return True if USER has developer status.\n\
\n\
This method returns a boolean expression. If the USER defined by the user managment has developer status it is true, in other cases it is False. \n\
\n\
Returns \n\
------- \n\
isRequestedType : {boolean} \n\
Boolean return value \n\
\n\
") |
|
| PyDoc_STRVAR (pyCheckIsUser_doc,"userIsUser() -> return True if USER has only user status.\n\
\n\
This method returns a boolean expression. If the USER defined by the user managment has only user status it is true, in other cases it is False. \n\
\n\
Returns \n\
------- \n\
isRequestedType : {boolean} \n\
Boolean return value \n\
\n\
") |
|
| PyDoc_STRVAR (pyGetUserInfo_doc,"userGetInfo() -> return a dictionary with the current user management information.\n\
\n\
This method returns a dictionary which contains the current user concerning system configuration. \n\
\n\
Returns \n\
------- \n\
isUser : {dict} \n\
dictionary with the following content is returned: \n\
\n\
* Name (string): The name of the current user \n\
* Type (string): The user type as string [user, administrator, developer] \n\
* ID (string): The user ID as a string \n\
* File (string): The location and name of the corresponding initialization file.") |
|
| PyDoc_STRVAR (pyItom_FigureClose_doc,"close(handle|'all') -> method to close any specific or all open figures (unless any figure-instance still keeps track of them)\n\
\n\
This method closes and deletes any specific figure (given by handle) or all opened figures. This method always calls the static method \n\
`figure.close`.\n\
\n\
Parameters \n\
----------- \n\
handle : {`dataIO`, str} \n\
any figure handle (>0) or 'all' in order to close all opened figures \n\
\n\
Notes \n\
------- \n\
If any instance of class 'figure' still keeps a reference to any figure, it is only closed and will be deleted after that the last referencing instance has been deleted. \n\
\n\
See Also \n\
--------- \n\
figure.close") |
|
| PyDoc_STRVAR (setPalette_doc,"setPalette(name, entries) -> set the palette for color bars defined by name.\n\
\n\
This methods sets a palette defined by entries within the palette organizer. If the palette does not exist, a new one is created.\n\
If the palette already exists and is not write protected, the palette is overwritten.\n\
\n\
Parameters \n\
----------- \n\
name : {string} \n\
name of the new palette. \n\
entries : {dict} \n\
dictionary with two floating type entries defining the stop coordiate and its rga value.\n\
\n\
See Also \n\
--------- \n\
getPalette, getPaletteList") |
|
| PyDoc_STRVAR (getPalette_doc,"getPalette(name) -> get the palette for color bars defined by name.\n\
\n\
\n\
Parameters \n\
----------- \n\
name : {string} \n\
name of the new palette. \n\
\n\
See Also \n\
--------- \n\
setPalette, getPaletteList") |
|
| PyDoc_STRVAR (getPaletteList_doc,"getPaletteList(typefilter) -> get a list of color bars / palettes.\n\
\n\
\n\
Parameters \n\
----------- \n\
typefilter : {int} \n\
currently not implemented filter for palette types. \n\
\n\
See Also \n\
--------- \n\
setPalette, getPalette") |
|
| PyDoc_STRVAR (pyAMax_doc,"amax(dataObject) -> returns the maximum value of the data object.") |
|
| PyDoc_STRVAR (pyPlotItemInit_doc,"plotItem(figure | uiItem[, subplotIdx]) -> instance of the plot or subplot of a figure.\n\
\n\
Use can use this constructor to access any plot or subplot (if more than one plot) of a figure. The subplotIndex \n\
row-wisely addresses the subplots, beginning with 0. \n\
\n\
As second possibility, the constructor can be used to cast 'uiItem' to 'plotItem' in order to access methods like 'pickPoints' \n\
or 'drawAndPickElement'. \n\
\n\
Parameters \n\
------------ \n\
figure : {???} \n\
\n\
subplotIdx: {???}\n\
\n\
") |
|
| PyDoc_STRVAR (pyPlotItem_pickPoints_doc,"pickPoints(points [,maxNrPoints]) -> method to let the user pick points on a plot (only if plot supports this) \n\
\n\
This method lets the user select one or multiple points (up to maxNrPoints) at the current plot (if the plot supports this).\n\
\n\
Parameters\n\
-----------\n\
points : {DataObject} \n\
resulting data object containing the 2D positions of the selected points [2 x nrOfSelectedPoints].\n\
maxNrPoints: {int}, optional \n\
let the user select up to this number of points [default: infinity]. Selection can be stopped pressing Space or Esc.") |
|
| PyDoc_STRVAR (pyPlotItem_drawAndPickElement_doc,"drawAndPickElement(elementType, elementData, [,maxNrElements]) -> method to let the user draw geometric elements on a plot (only if plot supports this) \n\
\n\
This method lets the user select one or multiple elements of type (up to maxNrElements) at the current plot (if the plot supports this).\n\
\n\
Parameters\n\
-----------\n\
elementType : {int} \n\
The element type to plot according to ito::PrimitiveContainer::tPrimitive.\n\
points : {DataObject} \n\
resulting data object containing the 2D positions of the selected points [2 x nrOfSelectedPoints].\n\
maxNrElements: {int}, optional \n\
let the user select up to this number of points [default: infinity]. Selection can be stopped pressing Space or Esc.") |
| int | parseParams (PyObject *args, int length, char **&cargs, char *&cargt) |
| int | freeParams (int length, char *&cargt, char **&cargs) |
| PyObject * | getParamList (ito::AddInBase *aib) |
| PyObject * | getParamListInfo (ito::AddInBase *aib, PyObject *args) |
| PyObject * | getParamInfo (ito::AddInBase *aib, PyObject *args) |
|
PyObject * | plugin_showConfiguration (ito::AddInBase *aib) |
| PyObject * | plugin_showToolbox (ito::AddInBase *aib) |
| PyObject * | plugin_hideToolbox (ito::AddInBase *aib) |
| PyObject * | getExecFuncsInfo (ito::AddInBase *aib, PyObject *args, PyObject *kwds) |
| PyObject * | getName (ito::AddInBase *addInObj) |
|
PyObject * | execFunc (ito::AddInBase *aib, PyObject *args, PyObject *kwds) |
| PyObject * | getParam (ito::AddInBase *addInObj, PyObject *args) |
|
| PyDoc_STRVAR (pyPluginName_doc,"name() -> returns the plugin name\n\
\n\
Returns \n\
-------- \n\
name : {str} \n\
name of the plugin, which corresponds to `getParam('name')` \n\
\n\
See Also \n\
--------- \n\
getParam") |
|
| PyDoc_STRVAR (pyPluginGetParamList_doc,"getParamList() -> returns a list of the names of the internal parameters of the plugin\n\
\n\
Each plugin defines a set of parameters, where each parameter has got a name and maps to any value. The value is represented by \n\
the C++ class ito::ParamBase and can have one of the following types: \n\
\n\
* String \n\
* Char \n\
* Integer \n\
* Double \n\
* CharArray \n\
* IntegerArray \n\
* DoubleArray \n\
* DataObject \n\
* PolygonMesh \n\
* PointCloud \n\
* Another plugin instance \n\
\n\
Using one of the parameter names, its current value can be obtained by `getParam('name')` and \n\
is writable by `setParam('name', newValue)` (if not read-only) \n\
\n\
Returns \n\
------- \n\
out : {list} \n\
list of parameter names \n\
\n\
See Also \n\
--------- \n\
getParam, setParam, getParamListInfo") |
|
| PyDoc_STRVAR (pyPluginGetParamListInfo_doc,"getParamListInfo([detailLevel]) -> prints detailed information about all plugin parameters. \n\
\n\
Each plugin defines a set of parameters, where each parameter has got a name and maps to any value. The value is represented by \n\
the C++ class ito::ParamBase and can have one of the following types: \n\
\n\
* String \n\
* Char \n\
* Integer \n\
* Double \n\
* CharArray \n\
* IntegerArray \n\
* DoubleArray \n\
* DataObject \n\
* PolygonMesh \n\
* PointCloud \n\
* Another plugin instance \n\
\n\
Using one of the parameter names, its current value can be obtained by `getParam('name')` and \n\
is writable by `setParam('name', newValue)` (if not read-only) \n\
\n\
This method prints a detailed table with the name, current value, description string and further meta information of every plugin parameter. \n\
Additionally, the column R/W indicates if this parameter is writable or read-only. \n\
\n\
Parameters \n\
----------- \n\
detailLevel : {dict}, optional \n\
if `detailLevel == 1`, function returns a dictionary with parameters, else None is returned and the output is printed in a readable form to the console [default]\n\
\n\
Returns \n\
------- \n\
out : {None, dict} \n\
If `detailLevel == 1`, a dictionary containing all printed information is returned \n\
\n\
See Also \n\
---------- \n\
getParam, setParam, getParamInfo, getParamList") |
|
| PyDoc_STRVAR (pyPluginGetParamInfo_doc,"getParamInfo(name) -> returns dictionary with meta information of parameter 'name'.") |
|
| PyDoc_STRVAR (pyPluginGetParam_doc,"getParam(name) -> current value of the plugin parameter 'name'.\n\
\n\
Returns the current value of the internal plugin parameter with 'name'. The type of the returned value depends on the \n\
real type of the internal plugin, which may be: \n\
\n\
* String -> str \n\
* Char, Integer -> int \n\
* Double -> float \n\
* CharArray, IntegerArray -> tuple of int \n\
* DoubleArray -> tuple of float \n\
* DataObject -> dataObject \n\
* PolygonMesh -> polygonMesh \n\
* PointCloud -> pointCloud \n\
* Another plugin instance -> dataIO or actuator \n\
\n\
The name of the parameter must have the following form: \n\
\n\
* name \n\
* name:additionalTag (additionalTag can be a special feature of some plugins) \n\
* name[index] (only possible if parameter is an array type and you only want to get one single value, specified by the integer index [0,nrOfArrayItems-1]) \n\
* name[index]:additionalTag \n\
\n\
Parameters \n\
----------- \n\
name : {str}\n\
name of the requested parameter\n\
\n\
Returns \n\
------- \n\
out : {variant}\n\
value of the parameter \n\
\n\
Raises \n\
------- \n\
ValueError \n\
if parameter does not exist \n\
\n\
See Also \n\
--------- \n\
setParam, getParamList, getParamListInfo") |
|
| PyDoc_STRVAR (pyPluginSetParam_doc,"setParam(name, value) -> sets parameter 'name' to the given value.\n\
\n\
Sets the internal plugin parameter with 'name' to a new value. The plugin itsself can decide whether the given value is \n\
accepted as new value. This may depend on the type of the given value, but also on the allowed value range indicated by \n\
further meta information of the internal parameter. Parameters that have the read-only flag set can not be reset. \n\
\n\
The name of the parameter must have the following form: \n\
\n\
* name \n\
* name:additionalTag (additionalTag can be a special feature of some plugins) \n\
* name[index] (only possible if parameter is an array type and you only want to get one single value, specified by the integer index [0,nrOfArrayItems-1]) \n\
* name[index]:additionalTag \n\
\n\
Parameters \n\
----------- \n\
name : {str}\n\
name of the parameter\n\
value : {str, int, double, ...}\n\
value that will be set. Only the name and existance of the parameter is checked before passing the request to the plugin. \n\
The plugin itsself is responsible for further validations (including read-only attribute). \n\
\n\
See Also \n\
--------- \n\
getParam, getParamList, getParamListInfo") |
|
| PyDoc_STRVAR (pyPluginShowToolbox_doc,"showToolbox() -> open toolbox of the plugin \n\
\n\
Raises \n\
------ \n\
RuntimeError \n\
if plugin does not provide a toolbox \n\
\n\
See Also \n\
--------- \n\
hideToolbox") |
|
| PyDoc_STRVAR (pyPluginHideToolbox_doc,"hideToolbox() -> hides toolbox of the plugin \n\
\n\
Raises \n\
------ \n\
RuntimeError \n\
if plugin does not provide a toolbox \n\
\n\
See Also \n\
--------- \n\
showToolbox") |
|
| PyDoc_STRVAR (pyPluginShowConfiguration_doc,"showConfiguration() -> show configuration dialog of the plugin\n\
\n\
Raises \n\
------- \n\
RuntimeError \n\
if plugin does not provide a configuration dialog") |
|
| PyDoc_STRVAR (pyPlugInGetExecFuncsInfo_doc,"getExecFuncsInfo([funcName [, detailLevel]]) -> plots a list of available execFuncs or a detailed description of the specified execFunc. \n\
\n\
Every plugin can define further functions, that are called by plugin.exec('funcName' [,param1, param2...]). This can for \n\
instance be used in order to call specific calibration routines of cameras or actuators. This method allows printing \n\
information about available functions of this type. \n\
\n\
Parameters \n\
----------- \n\
funcName : {str}, optional \n\
is the fullname or a part of any execFunc-name which should be displayed. \n\
If funcName is none or no execFunc matches funcName casesensitiv a list with all suitable execFuncs is given. \n\
detailLevel : {dict}, optional \n\
if `detailLevel == 1`, function returns a dictionary with parameters [default: 0]. \n\
\n\
Returns \n\
------- \n\
out : {None or dict}\n\
depending on the value of *detailLevel*. \n\
\n\
See Also \n\
-------- \n\
exec") |
|
| PyDoc_STRVAR (PyPlugin_execFunc_doc,"exec(funcName [, param1, ...]) -> invoke the function 'funcName' registered as execFunc within the plugin.\n\
\n\
Every plugin can define further functions that can for instance be used in order to call specific calibration routines \n\
of cameras or actuators. This general method is used to call one of these specific functions registered under `funcName`. \n\
\n\
Parameters \n\
----------- \n\
funcName : {str} \n\
The name of the function\n\
param1 : {variant}, optional \n\
Further parameters depending on the requirements of the specific function.\n\
\n\
Returns \n\
------- \n\
out : {variant, list of variants}.\n\
The return values depend on the function itself.\n\
\n\
See Also \n\
-------- \n\
execFuncsInfo") |
| PyObject * | setParam (ito::AddInBase *addInObj, PyObject *args) |
|
| PyDoc_STRVAR (pyActuatorInit_doc,"actuator(name[, mandparams, optparams]) -> creates new instance of actuator plugin 'name' \n\
\n\
This is the constructor for an `actuator` plugin. It initializes an new instance of the plugin specified by 'name'. \n\
The initialisation parameters are parsed and unnamed parameters are used in their incoming order to fill first \n\
mandatory parameters and afterwards optional parameters. Parameters may be passed with name as well but after \n\
the first named parameter no more unnamed parameters are allowed.\n\
\n\
See pluginHelp(name) for detail information about the specific initialisation parameters.\n\
\n\
Parameters \n\
----------- \n\
name : {str} \n\
is the fullname (case sensitive) of an 'actuator'-plugin as specified in the plugin-window. \n\
mandparams : {variant(s)} \n\
arguments corresponding the mandatory initialization parameters. The number of arguments and their order must fit the the required mandatory parameters \n\
optparams : {variant(s)}, optional \n\
argument corresponding to the optional initialization parameters. If unnamed arguments are used, their order must correspond to the order of the optional parameters, keyword-based parameters are allowed as well. \n\
\n\
Returns \n\
-------- \n\
inst : {actuator} \n\
new instance of the actuator-plugin") |
|
| PyDoc_STRVAR (pyActuatorCalib_doc,"calib(axis[, axis1, ...]) -> starts calibration or homing of given axes (0-based).\n\
\n\
Most actuators have the possibility to calibrate or home certain axes. Use this command to start the calibration. \n\
\n\
Parameters \n\
----------- \n\
axis : {int}\n\
index of the first axis to calibrate (e.g. 0 for first axis) \n\
axis1 : {int}\n\
add the indices of further axes as optional arguments if they should be calibrated as well\n\
\n\
Raises \n\
---------- \n\
NotImplemented \n\
if calibration not available") |
|
| PyDoc_STRVAR (pyActuatorSetOrigin_doc,"setOrigin(axis[, axis1, ...]) -> defines the actual position of the given axes to value 0. \n\
\n\
The current positions of all indicated axes (axis, axis1,...) are considered to be 0 such that following positioning commands \n\
are relative with respect to the current position. \n\
\n\
Parameters \n\
----------- \n\
axis : {int}\n\
index of the first axis (e.g. 0 for first axis) \n\
axis1 : {int}\n\
add the indices of further axes as optional arguments\n\
\n\
Raises \n\
---------- \n\
NotImplemented \n\
if actuator does not support this feature") |
|
| PyDoc_STRVAR (pyActuatorGetStatus_doc,"getStatus() -> returns a list of status values for each axis\n\
\n\
Each axis of an actuator plugin has got a status value that is used for informing about the current status of the axis. \n\
\n\
The status value is an or-combination of the following possible values: \n\
\n\
Moving flags: \n\
\n\
* actuatorUnknown = 0x0001 : unknown current moving status \n\
* actuatorInterrupted = 0x0002 : movement has been interrupted by the user or another error during the movement occurred \n\
* actuatorMoving = 0x0004 : axis is currently moving \n\
* actuatorAtTarget = 0x0008 : axis reached the target position \n\
* actuatorTimeout = 0x0010 : timout during movement. Unknown status of the movement \n\
\n\
Switches flags: \n\
\n\
* actuatorEndSwitch = 0x0100 : axis reached any end switch (e.g. if only one end switch is available) \n\
* actuatorLeftEndSwitch = 0x0200 : axis reached the left end switch \n\
* actuatorRightEndSwitch = 0x0400 : axis reached the right end switch \n\
* actuatorRefSwitch = 0x0800 : axis reached any reference switch (e.g. for calibration...) \n\
* actuatorLeftRefSwitch = 0x1000 : axis reached left reference switch \n\
* actuatorRightRefSwitch = 0x2000 : axis reached right reference switch \n\
\n\
Status flags: \n\
\n\
* actuatorAvailable = 0x4000 : the axis is available \n\
* actuatorEnabled = 0x8000 : the axis is currently enabled and can be moved \n\
\n\
Returns \n\
------- \n\
status : {list of integers} \n\
list of integers (size corresponds to number of axes) with the current status of each axis") |
|
| PyDoc_STRVAR (pyActuatorGetPos_doc,"getPos(axis[, axis1, ...]) -> returns the actual positions of the given axes (in mm or degree).\n\
\n\
This method requests the current position(s) of the given axes and returns it. \n\
\n\
Parameters \n\
----------- \n\
axis : {int}\n\
index of the first axis (e.g. 0 for first axis) \n\
axis1 : {int}\n\
add the indices of further axes as optional arguments\n\
\n\
Returns \n\
------- \n\
positions : {float or tuple of float} \n\
Current position as float value if only one axis is given or tuple of floats for multiple axes. The unit is mm or degree. \n\
\n\
See Also \n\
--------- \n\
setPosRel, setPosAbs") |
|
| PyDoc_STRVAR (PyActuatorPlugin_getType_doc,"getType() -> returns actuator type") |
|
| PyDoc_STRVAR (pyActuatorSetInterrupt_doc,"setInterrupt() -> interrupts a movement of an actuator \n\
\n\
Sets the interrupt flag of an actuator. The actuator interrupts the movement of all running axes \
as soon as this flag is checked again.") |
| ito::RetVal | parsePosParams (PyObject *args, char **&cargs, char *&cargt, QVector< int > &axisVec, QVector< double > &posVec) |
|
| PyDoc_STRVAR (pyActuatorSetPosAbs_doc,"setPosAbs(axis0, pos0 [, axis1, pos1, ...]) -> moves given axes to given absolute values (in mm or degree).\n\
\n\
All arguments are a pair of axis index and the new target position of this axis. This method starts the absolute positioning of all given axes. \n\
If the 'async' parameter of the plugin is 0 (usually default), a synchronous positioning is started, hence, this method returns after that all \n\
axes reached their target position or a timeout occurred. Else this method immediately returns and the actuator goes on moving. \n\
\n\
Parameters \n\
----------- \n\
axisM : {int} \n\
index of the axis to position \n\
posM : {float} \n\
absolute target position of the `axisM` (in mm or degree) \n\
\n\
See Also \n\
--------- \n\
getPos, setPosRel") |
|
| PyDoc_STRVAR (pyActuatorSetPosRel_doc,"setPosRel(axis0, pos0[, axis1, pos1, ...]) -> relatively moves given axes by the given distances [in mm or degree].\n\
\n\
All arguments are a pair of axis index and the relative moving-distance of this axis. This method starts the relative positioning of all given axes. \n\
If the 'async' parameter of the plugin is 0 (usually default), a synchronous positioning is started, hence, this method returns after that all \n\
axes reached their target position or a timeout occurred. Else this method immediately returns and the actuator goes on moving. \n\
\n\
Parameters \n\
----------- \n\
axisM : {int} \n\
index of the axis to position \n\
posM : {float} \n\
relative target position of the `axisM` (in mm or degree) \n\
\n\
See Also \n\
--------- \n\
getPos, setPosAbs") |
|
| PyDoc_STRVAR (pyDataIOInit_doc,"dataIO(name[, mandparams, optparams]) -> creates new instance of dataIO plugin 'name' \n\
\n\
This is the constructor for a `dataIO` plugin. It initializes an new instance of the plugin specified by 'name'. \n\
The initialisation parameters are parsed and unnamed parameters are used in their incoming order to fill first \n\
mandatory parameters and afterwards optional parameters. Parameters may be passed with name as well but after \n\
the first named parameter no more unnamed parameters are allowed.\n\
\n\
See pluginHelp(name) for detail information about the specific initialisation parameters.\n\
\n\
Parameters \n\
----------- \n\
name : {str} \n\
is the fullname (case sensitive) of an 'actuator'-plugin as specified in the plugin-window. \n\
mandparams : {variant(s)} \n\
arguments corresponding the mandatory initialization parameters. The number of arguments and their order must fit the the required mandatory parameters \n\
optparams : {variant(s)}, optional \n\
argument corresponding to the optional initialization parameters. If unnamed arguments are used, their order must correspond to the order of the optional parameters, keyword-based parameters are allowed as well. \n\
\n\
Returns \n\
-------- \n\
inst : {dataIO} \n\
new instance of the dataIO-plugin") |
|
| PyDoc_STRVAR (PyDataIOPlugin_startDevice_doc,"startDevice([count=1]) -> starts the given dataIO-plugin. \n\
\n\
This command starts the dataIO plugin such that it is ready for data acquisition. Call this method before you start \n\
using commands like acquire, `getVal` or `copyVal`. If the device already is started, an internal start-counter is incremented \n\
by the parameter 'count'. The corresponding `stopDevice` method then decrements this counter and finally stops the device once \n\
the counter drops to zero again. \n\
\n\
The counter is necessary, since every connected live image needs to start the device without knownledge about any \n\
previous start. No acquisition is possible, if the device has not been started, hence the counter is 0. \n\
\n\
Parameters \n\
----------- \n\
count : {int}, optional \n\
Number of increments to the internal start-counter [default:1] \n\
\n\
See Also \n\
--------- \n\
stopDevice()") |
|
| PyDoc_STRVAR (PyDataIOPlugin_stopDevice_doc,"stopDevice([count=1]) -> stops the given dataIO-plugin. \n\
\n\
If this method is called as many times as the corresponding `startDevice` (or if the counts are equal), the \n\
dataIO device is stopped (not deleted) and it is not possible to acquire further data. \n\
\n\
Once a live image is connected to a camera, `startDevice` is automatically called at start of the live acquisition \n\
and `stopDevice` at shutdown. \n\
\n\
Parameters \n\
----------- \n\
count : {int}, optional\n\
default = 1\n\
if count > 1, `stopDevice` is executed 'count' times, in order to decrement the grabber internal start counter. \n\
You can also use -1 as count argument, then `stopDevice` is repeated until the internal start counter is 0. The number of effective counts is then returned \n\
\n\
Returns \n\
-------- \n\
counts : {None or int} \n\
If `count == -1` the number of required counts to finally stop the device is returned. Else: None \n\
\n\
See Also \n\
--------- \n\
startDevice()") |
|
| PyDoc_STRVAR (PyDataIOPlugin_acquire_doc,"acquire(trigger=dataIO.TRIGGER_SOFTWARE) -> triggers a new the camera acquisition \n\
\n\
This method triggers a new data acquisition. This method immediately returns even if the acquisition is not finished yet. \n\
Use `getVal` or `copyVal` to get the acquired data. Both methods block until the data is available. \n\
\n\
Parameters \n\
----------- \n\
trigger : {int}, optional\n\
Type of the trigger: \n\
\n\
* `dataIO.TRIGGER_SOFTWARE = 0` : a software trigger is started, hence, the acquisition is immediately started when calling this method\n\
* others : depending on your camera, this parameter can be used to set other triggers, like hardware trigger with raising or falling edges...") |
|
| PyDoc_STRVAR (PyDataIOPlugin_getVal_doc,"getVal(buffer=`dataObject`|`bytearray`|`bytes` [,length=maxlength]) -> returns shallow copy of internal camera image if `dataObject`-buffer is provided. Else values from plugin are copied to given byte or byte-array buffer. \n\
\n\
Returns a reference (shallow copy) of the recently acquired image (located in the internal memory if the plugin) if the plugin is a grabber or camera and the buffer is a `dataObject`. \n\
Please consider that the values of the `dataObject` might change if a new image is acquired since it is only a reference. Therefore consider copying the `dataObject` or directly use \n\
`copyVal`. \n\
\n\
If no acquisition has been triggered, this method raises a RuntimeError. If the acquisition is not finished yet, this method \n\
blocks and waits until the end of the acquisition. \n\
\n\
If the plugin is another type than a grabber or camera (e.g. serialIO), this method requires any buffer-object that is preallocated with a reasonable size. Then, the currently available \n\
data is copied into this buffer object and the size of the copied data is returned. If the buffer is too small, only the data that fits into the buffer is copied. Another call to \n\
`getVal` will copy the rest. \n\
\n\
Parameters \n\
----------- \n\
buffer : {`dataObject`, `bytearray`, `bytes` or `str`} \n\
this parameter depends on the type of dataIO-instance: \n\
\n\
* cameras, grabber: the buffer must be a `dataObject` (no length parameter): A reference (shallow copy) to the internal memory of the camera plugin is set to the given data object. \
Therefore its content may change if a new image is being acquired by the camera. Consider taking a deep copy if the image (`dataObject.copy`) or use the method `copyVal`. \n\
* other IO-devices (AD-converters): The buffer must be an object of type `dataObject`, bytearray, bytes or unicode string. The length parameter is then set to the size of the buffers. The effective \
size of the used memory in buffer is returned. \n\
length : {int}, optional \n\
size of the given buffer. This value is usually automatically determined and must not be given. \n\
\n\
Returns \n\
-------- \n\
out : {None or int} \n\
None or size of used buffer if buffer is no `dataObject` \n\
\n\
See Also \n\
--------- \n\
copyVal()") |
|
| PyDoc_STRVAR (PyDataIOPlugin_copyVal_doc,"copyVal(dataObject) -> gets deep copy of data of this plugin, stored in the given data object. \n\
\n\
Returns a deep copy of the recently acquired data (for grabber and ADDA only) of the camera or AD-converter device. \n\
The deep copy sometimes requires one copy operation more than the similar command `getVal`. However, `getVal` only returns \n\
a reference to the plugin internal data structure whose values might be changed if another data acquisition is started. \n\
\n\
If no acquisition has been triggered, this method raises a RuntimeError. If the acquisition is not finished yet, this method \n\
blocks and waits until the end of the acquisition. \n\
\n\
Parameters \n\
----------- \n\
dataObject : {`dataObject`}\n\
`dataObject` where the plugin data is copied to. Either provide an empty `dataObject` or a `dataObject` whose size (or region of interest) \n\
exactly has the same size than the available data of the plugin. Therefore you can allocate a 3D data object, set a region of interest \n\
to one plane such that the data from the plugin is copied into this plane. \n\
\n\
Raises \n\
------- \n\
RuntimeError \n\
if the dataIO plugin is anything else than ADDA or grabber\n\
or if no acquisition has been triggered \n\
\n\
See Also \n\
--------- \n\
getVal()") |
|
| PyDoc_STRVAR (PyDataIOPlugin_setVal_doc,"setVal(dataObjectOrBuffer [, length=1]) -> transfer given `dataObject` to ADDA plugin or further buffer to other dataIO plugin.\n\
\n\
If the dataIO plugin has the subtype ADDA, this method is used to send data to one or more analog outputs of the device. \n\
In this case a `dataObject` must be given as first argument and the second argument `length` must be 1. \n\
\n\
For other dataIO plugins, the first argument must be any buffer object, like `bytearray`, `bytes` or `unicode string`. The length is then extracted \n\
from this value. However it is also possible to define a user-defined size using the 'length' argument. \n\
\n\
Parameters \n\
----------- \n\
dataObjectOrBuffer : {`dataObject`, `bytearray`, `bytes`, `str`}\n\
value to send to plugin. For an ADDA plugin, a `dataObject` is required whose content is sent to the analogous outputs of the device. For other dataIO \n\
plugins buffer values like `bytearray`, `bytes` or `unicode string` are required. \n\
length : {int}, optional \n\
usually this value is not required, since the length of the buffer is automatically extracted from the given objects and 1 for a `dataObject`") |
|
| PyDoc_STRVAR (PyDataIOPlugin_enableAutoGrabbing_doc,"enableAutoGrabbing() -> enable auto grabbing for the grabber (camera...), \n\
\n\
If the auto grabbing flag is set, the camera acquisition is automatically and continuously triggered if at least one live image is \n\
connected. This is an undesired behaviour if a measurement is started where the acquisition should be controlled by a specific \n\
script or something similar. Then disable the auto grabbing property. All connected live images will then get new images when \n\
`getVal` or `copyVal` is called by the script. The live image timer is disabled. \n\
\n\
This method enables the auto grabbing flag. \n\
\n\
See Also \n\
--------- \n\
setAutoGrabbing(on), disableAutoGrabbing(), getAutoGrabbing()") |
|
| PyDoc_STRVAR (PyDataIOPlugin_disableAutoGrabbing_doc,"disableAutoGrabbing() -> Disable auto grabbing for the grabber (camera...), \n\
\n\
If the auto grabbing flag is set, the camera acquisition is automatically and continuously triggered if at least one live image is \n\
connected. This is an undesired behaviour if a measurement is started where the acquisition should be controlled by a specific \n\
script or something similar. Then disable the auto grabbing property. All connected live images will then get new images when \n\
`getVal` or `copyVal` is called by the script. The live image timer is disabled. \n\
\n\
This method disables the auto grabbing flag. \n\
\n\
See Also \n\
--------- \n\
setAutoGrabbing(on), disableAutoGrabbing(), getAutoGrabbing()") |
|
| PyDoc_STRVAR (PyDataIOPlugin_setAutoGrabbing_doc,"setAutoGrabbing(on) -> Set auto grabbing of the grabber device to on or off\n\
\n\
If the auto grabbing flag is set, the camera acquisition is automatically and continuously triggered if at least one live image is \n\
connected. This is an undesired behaviour if a measurement is started where the acquisition should be controlled by a specific \n\
script or something similar. Then disable the auto grabbing property. All connected live images will then get new images when \n\
`getVal` or `copyVal` is called by the script. The live image timer is disabled. \n\
\n\
This method allows setting this flag. \n\
\n\
Parameters \n\
----------- \n\
on : {bool}\n\
* TRUE = on\n\
* FALSE = off\n\
\n\
See Also \n\
--------- \n\
enableAutoGrabbing(), disableAutoGrabbing(), getAutoGrabbing()") |
|
| PyDoc_STRVAR (PyDataIOPlugin_getAutoGrabbing_doc,"getAutoGrabbing() -> return the status of the auto grabbing flag. \n\
\n\
If the auto grabbing flag is set, the camera acquisition is automatically and continuously triggered if at least one live image is \n\
connected. This is an undesired behaviour if a measurement is started where the acquisition should be controlled by a specific \n\
script or something similar. Then disable the auto grabbing property. All connected live images will then get new images when \n\
`getVal` or `copyVal` is called by the script. The live image timer is disabled. \n\
\n\
Returns \n\
------- \n\
auto grabbing flag : {bool}\n\
* False = auto grabbing off \n\
* True = auto grabbing on. \n\
\n\
See Also \n\
--------- \n\
enableAutoGrabbing(), disableAutoGrabbing(), setAutoGrabbing(bool)") |
|
| PyDoc_STRVAR (PyDataIOPlugin_getType_doc,"getType() -> returns dataIO type") |
|
| PyDoc_STRVAR (pyRegion_doc,"region([x, y, w, h [,type=region.RECTANGLE]]) -> creates a rectangular or elliptical region. \n\
\n\
This class is a wrapper for the class QRegion of Qt. It provides possibilities for creating pixel-based regions. Furtherone you can \n\
calculate new regions based on the intersection, union or subtraction of other regions. Based on the region it is possible to get \n\
a uint8 masked dataObject, where every point within the entire region has the value 255 and all other values 0 \n\
\n\
Parameters \n\
----------- \n\
x : {int} \n\
x-coordinate of the reference corner of the region \n\
y : {int} \n\
y-coordinate of the reference corner of the region \n\
w : {int} \n\
width of the region \n\
h : {int} \n\
height of the region \n\
type : {int}, optional \n\
region.RECTANGLE creates a rectangular region (default). region.ELLIPSE creates an elliptical region, which is placed inside of the \n\
given boundaries. \n\
\n\
Notes\n\
----- \n\
It is also possible to create an empty instance of the region.") |
|
| PyDoc_STRVAR (pyRegionContains_doc,"contains(x,y[,w,h]) -> returns True if the given point or rectangle is fully contained in this region, otherwise returns False. \n\
\n\
This method returns True, if the given point (x,y) or region (x,y,w,h) is fully contained in this region. Otherwise returns False.\n\
Parameters \n\
----------- \n\
x : {int} \n\
x-coordinate of one corner of the new rectangular region \n\
y : {int} \n\
y-coordinate of one corner of the new rectangular region \n\
w : {int}, optional \n\
width of the new rectangular region. If not given, point is assumed. \n\
h : {int}, optional \n\
height of the new rectangular region. If not given, point is assumed. \n\
\n\
Returns \n\
------- \n\
True or False") |
|
| PyDoc_STRVAR (pyRegionIntersected_doc,"intersected(x,y,w,h | region) -> returns a region which is the intersection of a new region and this region. \n\
\n\
This method returns a new region, which is the intersection of this region and the given, new region. The intersection only contains points that are \n\
part of both given regions. \n\
Parameters \n\
----------- \n\
x : {int} \n\
x-coordinate of one corner of the new rectangular region \n\
y : {int} \n\
y-coordinate of one corner of the new rectangular region \n\
w : {int} \n\
width of the new rectangular region \n\
h : {int} \n\
height of the new rectangular region \n\
region : {region-object} \n\
another instance of region \n\
\n\
Returns \n\
------- \n\
new intersected region. \n\
\n\
Notes \n\
----- \n\
You can either use the parameters 'x','y','w','h' OR 'region'.") |
|
| PyDoc_STRVAR (pyRegionIntersects_doc,"intersects(x,y,w,h | region) -> returns True if this region intersects with the given region, else False. \n\
\n\
This method returns True, if this region intersects with the new region, otherwise returns False. \n\
Parameters \n\
----------- \n\
x : {int} \n\
x-coordinate of one corner of the new rectangular region \n\
y : {int} \n\
y-coordinate of one corner of the new rectangular region \n\
w : {int} \n\
width of the new rectangular region \n\
h : {int} \n\
height of the new rectangular region \n\
region : {region-object} \n\
another instance of region \n\
\n\
Returns \n\
------- \n\
True or False \n\
\n\
Notes \n\
----- \n\
You can either use the parameters 'x','y','w','h' OR 'region'.") |
|
| PyDoc_STRVAR (pyRegionSubtracted_doc,"subtracted(x,y,w,h | region) -> returns a region which is the new region subtracted from this region. \n\
\n\
This method returns a new region, which is the given, new region subtracted from this region. \n\
Parameters \n\
----------- \n\
x : {int} \n\
x-coordinate of one corner of the new rectangular region \n\
y : {int} \n\
y-coordinate of one corner of the new rectangular region \n\
w : {int} \n\
width of the new rectangular region \n\
h : {int} \n\
height of the new rectangular region \n\
region : {region-object} \n\
another instance of region \n\
\n\
Returns \n\
------- \n\
new subtracted region. \n\
\n\
Notes \n\
----- \n\
You can either use the parameters 'x','y','w','h' OR 'region'.") |
|
| PyDoc_STRVAR (pyRegionTranslate_doc,"translate(x,y) -> translateds this region by the given coordinates. \n\
\n\
This method translates this region by the given coordinates. \n\
Parameters \n\
----------- \n\
x : {int} \n\
translation in x-direction \n\
y : {int} \n\
translation in y-direction \n\
\n\
See Also \n\
--------- \n\
translated") |
|
| PyDoc_STRVAR (pyRegionTranslated_doc,"translated(x,y) -> returns a region, translated by the given coordinates. \n\
\n\
This method returns a new region, which is translated by the given coordinates in x and y direction. \n\
Parameters \n\
----------- \n\
x : {int} \n\
translation in x-direction \n\
y : {int} \n\
translation in y-direction \n\
\n\
Returns \n\
------- \n\
new translated region.\n\
\n\
See Also \n\
--------- \n\
translate") |
|
| PyDoc_STRVAR (pyRegionUnited_doc,"united(x,y,w,h | region) -> returns a region which is the union of the given region with this region. \n\
\n\
This method returns a new region, which is the union of this region with the region given as parameters. Union means that all values, that\n\
are contained in any of both regions is part of the overall region, too. \n\
Parameters \n\
----------- \n\
x : {int} \n\
x-coordinate of one corner of a rectangular region \n\
y : {int} \n\
y-coordinate of one corner of a rectangular region \n\
w : {int} \n\
width of the new rectangular region \n\
h : {int} \n\
height of the new rectangular region \n\
region : {region-object} \n\
another instance of region \n\
\n\
Returns \n\
------- \n\
new united region. \n\
\n\
Notes \n\
----- \n\
You can either use the parameters 'x','y','w','h' OR 'region'.") |
|
| PyDoc_STRVAR (pyRegionXored_doc,"xored(x,y,w,h | region) -> returns a region which is an xor combination of the given region with this region. \n\
\n\
This method returns a new region, which is defined by an xor-combination of this region with the region given as parameters. \n\
Parameters \n\
----------- \n\
x : {int} \n\
x-coordinate of one corner of a rectangular region \n\
y : {int} \n\
y-coordinate of one corner of a rectangular region \n\
w : {int} \n\
width of the new rectangular region \n\
h : {int} \n\
height of the new rectangular region \n\
region : {region-object} \n\
another instance of region \n\
\n\
Returns \n\
------- \n\
new xored region. \n\
\n\
Notes \n\
----- \n\
You can either use the parameters 'x','y','w','h' OR 'region'.") |
|
| PyDoc_STRVAR (pyRegionCreateMask_doc,"createMask([boundingRegion]) -> creates mask data object based on this region and the optional boundingRegion. \n\
\n\
Returns a uint8-dataObject whose size corresponds to the width and height of the bounding rectangle. \n\
All pixels contained in the region have a value of 255 while the rest is set to 0. The offset value of \n\
the dataObject is set such that it fits to the real position of the region, since the first element \n\
in the dataObject corresponds to the left upper corner of the bounding rectangle.\n\
\n\
Indicate a boundingRegion in order to increase the size of the returned data object. Its size will \n\
have the size of the union between the boundingRegion and the region.") |
|
| PyDoc_STRVAR (rgbaInit_doc,"rgba(r, g, b [, alpha=255]) -> creates a new color value from red, green, blue and optional alpha\n\
\n\
Parameters \n\
----------- \n\
r : {uint8} \n\
red component [0,255] \n\
g : {uint8}, \n\
green component [0,255] \n\
b : {uint8} \n\
blue component [0,255] \n\
alpha : {uint8}, optional \n\
alpha component [0,255], default: 255 (no transparancy) \n\
\n\
Notes \n\
------ \n\
\n\
For a gray value set all colors to the same value.") |
|
| PyDoc_STRVAR (PyUiItemInit_doc,"uiItem(...) -> base class representing any widget of a graphical user interface \n\
\n\
This class represents any widget (graphical, interactive element like a button or checkbox) on a graphical user interface. \n\
An instance of this class provides many functionalities given by the underlying Qt system. For instance, it is posible to \n\
call a public slot of the corresponding widget, connect signals to specific python methods or functions or change properties \n\
of the widget represeted by the instance. \n\
\n\
The overall dialog or window as main element of a graphical user interface itself are instances of the class *ui*. However, \n\
they are derived from *uiItem*, since dialogs or windows internally are widgets as well. \n\
\n\
Widgets placed at a user interface using the Qt Designer can be referenced by an *uiItem* instance by their specific objectName, \n\
assigned in the Qt Designer as well. As an example, a simple dialog with one button is created and the text of the button (objectName: btn) \n\
is set to OK: :: \n\
\n\
dialog = ui('filename.ui', type=ui.TYPEDIALOG) \n\
button = dialog.btn #here the reference to the button is obtained \n\
button[\"text\"] = \"OK\" #set the property text of the button \n\
\n\
Information about available properties, signals and slots can be obtained using the method **info()** of *uiItem*. \n\
\n\
Notes \n\
------ \n\
It is not intended to directly instantiate this class. Either create a user interface using the class *ui* or obtain \n\
a reference to an existing widget (this is then an instance of *uiItem*) using the dot-operator of a \n\
parent widget or the entire user interface.") |
|
| PyDoc_STRVAR (PyUiItemCall_doc,"call(slotOrPublicMethod [,argument1, argument2, ...]) -> calls any public slot of this widget or any accessible public method. \n\
\n\
This method invokes (calls) a method of the underlying widget that is marked as public slot. Besides slots there are some public methods of specific \n\
widget classes that are wrapped by itom and therefore are callable by this method, too. \n\
\n\
If only method is available, all arguments are tried to be cast to the requested types and the slot is called on conversion success. If the method has \n\
multiple overloaded possibilities in the underlying C++ classes, at first, it is intended to find the variant where all arguments can be strictly casted \n\
from Python types to the necessary C-types. If this fails, the next variant with a non-strict conversion is chosen. \n\
\n\
Parameters \n\
----------- \n\
slotOrPublicMethod : {str} \n\
name of the slot or method \n\
arguments : {various types}, optional\n\
Here you must indicate every argument, that the definition of the slot indicates. The type must be convertable into the \n\
requested C++ based argument type.\n\
\n\
Notes \n\
----- \n\
If you want to know all possible slots of a specific widget, see the Qt help or call the member *info()* of the widget. \n\
\n\
See Also \n\
--------- \n\
info()") |
|
| PyDoc_STRVAR (PyUiItemConnect_doc,"connect(signalSignature, callableMethod) -> connects the signal of the widget with the given callable python method \n\
\n\
This instance of *uiItem* wraps a widget, that is defined by a C++-class, that is finally derived from *QWidget*. See Qt-help for more information \n\
about the capabilities of every specific widget. Every widget can send various signals. Use this method to connect any signal to any \n\
callable python method (bounded or unbounded). This method must have the same number of arguments than the signal and the types of the \n\
signal definition must be convertable into a python object. \n\
\n\
Parameters \n\
----------- \n\
signalSignature : {str} \n\
This must be the valid signature, known from the Qt-method *connect* (e.g. 'clicked(bool)') \n\
callableMethod : {python method or function} \n\
valid method or function that is called if the signal is emitted. \n\
\n\
See Also \n\
--------- \n\
disconnect, invokeKeyboardInterrupt") |
|
| PyDoc_STRVAR (PyUiItemConnectKeyboardInterrupt_doc,"invokeKeyboardInterrupt(signalSignature) -> connects the given signal with a slot immediately invoking a python interrupt signal. \n\
\n\
Parameters \n\
----------- \n\
signalSignature : {str} \n\
This must be the valid signature, known from the Qt-method *connect* (e.g. 'clicked(bool)') \n\
\n\
Returns \n\
------- \n\
\n\
Notes \n\
----- \n\
If you use the connect method to link a signal with a python method or function, this method can only be executed if python is in an idle status. \n\
However, if you want raise the python interrupt signal if a specific signal is emitted, this interruption should be immediately invoked. Therefore \n\
\n\
See Also \n\
--------- \n\
connect") |
|
| PyDoc_STRVAR (PyUiItemDisconnect_doc,"disconnect(signalSignature, callableMethod) -> disconnects a connection which must have been established with exactly the same parameters.\n\
\n\
Parameters \n\
----------- \n\
signalSignature : {str} \n\
callableMethod : {python method or function} \n\
\n\
Returns \n\
------- \n\
\n\
Notes \n\
----- \n\
doctodo\n\
\n\
See Also \n\
--------- \n\
\n\
") |
|
| PyDoc_STRVAR (PyUiItemGetProperty_doc,"getProperty(propertyName | listOfPropertyNames) -> returns tuple of requested properties (single property or tuple of properties)\n\
Use this method or the operator [] in order to get the value of one specific property of this widget or of multiple properties. \n\
Multiple properties are given by a tuple or list of property names. For one single property, its value is returned as it is. \n\
If the property names are passed as sequence, a sequence of same size is returned with the corresponding values. \n\
\n\
Parameters \n\
----------- \n\
property : {string, string-list} \n\
Name of one property or sequence (tuple,list...) of property names \n\
\n\
Returns \n\
------- \n\
out : {variant, sequence of variants} \n\
the value of one single property of a list of values, if a sequence of names is given as parameter. \n\
\n\
See Also \n\
--------- \n\
setProperty \n\
") |
|
| PyDoc_STRVAR (PyUiItemSetProperty_doc,"setProperty(propertyDict) -> each property in the parameter dictionary is set to the dictionaries value.\n\
\n\
Parameters \n\
----------- \n\
propertyDict : {dict}\n\
Dictionary with properties (keyword) and the values that should be set.\n\
\n\
See Also \n\
--------- \n\
getProperty \n\
") |
|
| PyDoc_STRVAR (PyUiItemGetPropertyInfo_doc,"getPropertyInfo([propertyName]) -> returns information about the property 'propertyName' of this widget or all properties, if no name indicated.\n\
\n\
Parameters \n\
----------- \n\
propertyName : {tuple}, optional \n\
\n\
Returns \n\
------- \n\
") |
|
| PyDoc_STRVAR (PyUiItemGetAttribute_doc,"getAttribute(attributeNumber) -> returns specified attribute of corresponding widget.\n\
\n\
Widgets have specific attributes that influence their behaviour. These attributes are contained in the Qt-enumeration \n\
Qt::WidgetAttribute. Use this method to query the current status of one specific attributes. \n\
\n\
Important attributes are: \n\
\n\
* Qt::WA_DeleteOnClose (55) -> deletes the widget when it is closed, else it is only hidden [default] \n\
* Qt::WA_MouseTracking (2) -> indicates that the widget has mouse tracking enabled \n\
\n\
Parameters \n\
----------- \n\
attributeNumber : {int} \n\
Number of the attribute of the widget to query (enum Qt::WidgetAttribute) \n\
\n\
Returns \n\
------- \n\
out : {bool} \n\
True if attribute is set, else False \n\
\n\
See Also \n\
--------- \n\
setAttribute()\n\
") |
|
| PyDoc_STRVAR (PyUiItemSetAttribute_doc,"setAttribute(attributeNumber, value) -> sets attribute of corresponding widget.\n\
\n\
Widgets have specific attributes that influence their behaviour. These attributes are contained in the Qt-enumeration \n\
Qt::WidgetAttribute. Use this method to enable/disable one specific attribute.\n\
\n\
Important attributes are: \n\
\n\
* Qt::WA_DeleteOnClose (55) -> deletes the widget when it is closed, else it is only hidden [default] \n\
* Qt::WA_MouseTracking (2) -> indicates that the widget has mouse tracking enabled \n\
\n\
Parameters \n\
----------- \n\
attributeNumber : {int} \n\
Number of the attribute of the widget to set (enum Qt::WidgetAttribute) \n\
value : {bool} \n\
True if attribute should be enabled, else False \n\
\n\
See Also \n\
--------- \n\
getAttribute") |
|
| PyDoc_STRVAR (PyUiItemSetWindowFlags_doc,"setWindowFlags(flags) -> set window flags of corresponding widget.\n\
\n\
The window flags are used to set the type of a widget, dialog or window including further hints to the window system. \n\
This method is used to set the entire or-combination of all flags, contained in the Qt-enumeration Qt::WindowType. \n\
\n\
The most important types are: \n\
\n\
* Qt::Widget (0) -> default type for widgets \n\
* Qt::Window (1) -> the widget looks and behaves like a windows (title bar, window frame...) \n\
* Qt::Dialog (3) -> window decorated as dialog (no minimize or maximize button...) \n\
\n\
Further hints can be (among others): \n\
\n\
* Qt::FramelessWindowHint (0x00000800) -> borderless window (user cannot move or resize the window) \n\
* Qt::WindowTitleBar (0x00001000) -> gives the window a title bar \n\
* Qt::WindowMinimizeButtonHint (0x00004000) -> adds a minimize button to the title bar \n\
* Qt::WindowMaximizeButtonHint (0x00008000) -> adds a maximize button to the title bar \n\
* Qt::WindowCloseButtonHint (0x00010000) -> adds a close button. \n\
\n\
If you simply want to change one hint, get the current set of flags using **getWindowFlags**, change the necessary bitmask and \n\
set it again using this method. \n\
\n\
Parameters \n\
----------- \n\
flags : {int} \n\
window flags to set (or-combination, see Qt::WindowFlags) \n\
\n\
See Also \n\
---------- \n\
getWindowFlags()") |
|
| PyDoc_STRVAR (PyUiItemGetWindowFlags_doc,"getWindowFlags(flags) -> gets window flags of corresponding widget. \n\
\n\
The flags-value is an or-combination of the enumeration Qt::WindowType. See Qt documentation for more information. \n\
\n\
Returns \n\
-------- \n\
flags {int}: \n\
or-combination of Qt::WindowType describing the type and further hints of the user interface \n\
\n\
See Also \n\
--------- \n\
setWindowFlags()") |
|
| PyDoc_STRVAR (PyUiItemInfo_doc,"info([verbose = 0]) -> prints information about properties, public accessible slots and signals of the wrapped widget. \n\
\n\
Parameters \n\
----------- \n\
verbose : {int} \n\
0: only properties, slots and signals that do not come from Qt-classes are printed (default) \n\
1: properties, slots and signals are printed up to Qt GUI base classes \n\
2: all properties, slots and signals are printed") |
|
| PyDoc_STRVAR (PyUiItemExists_doc,"exists() -> returns true if widget still exists, else false.") |
|
| PyDoc_STRVAR (PyUiItemChildren_doc,"children([recursive = False]) -> returns dict with widget-based child items of this uiItem. \n\
\n\
Each key -> value pair is object-name -> class-name). Objects with no object-name are omitted. \n\
\n\
Parameters \n\
----------- \n\
recursive : {bool} \n\
True: all objects including sub-widgets of widgets are returned, False: only children of this uiItem are returned (default)") |
|
| PyDoc_STRVAR (pyUiInit_doc,"ui(filename, [type, dialogButtonBar, dialogButtons, childOfMainWindow, deleteOnClose, dockWidgetArea]) -> instance of user interface \n\
\n\
The class **ui** wraps a user interface, externally designed and given by a ui-file. If your user interface is a dialog or window, \n\
chose *ui.TYPEWINDOW* as type, if the user interface is a widget (simplest case), chose *ui.TYPEDIALOG* and your widget \n\
will be embedded in a dialog, provided by *itom*. This dialog can be equiped with a button bar, whose buttons are already \n\
connected to *itom* internal methods. If you then show your dialog in a modal mode, *itom* knows which button has been \n\
clicked in order to accept or reject the dialog. \n\
\n\
Parameters \n\
----------- \n\
filename : {str} \n\
path to user interface file (*.ui), absolute or relative to current directory \n\
type : {int}, optional \n\
display type: \n\
\n\
* 0 (ui.TYPEDIALOG): ui-file is embedded in auto-created dialog (default), \n\
* 1 (ui.TYPEWINDOW): ui-file is handled as main window, \n\
* 2 (ui.TYPEDOCKWIDGET): ui-file is handled as dock-widget and appended to the main-window dock area \n\
dialogButtonBar : {int}, optional \n\
Only for type ui.TYPEDIALOG (0). Indicates whether buttons should automatically be added to the dialog: \n\
\n\
* 0 (ui.BUTTONBAR_NO): do not add any buttons (default) \n\
* 1 (ui.BUTTONBAR_HORIZONTAL): add horizontal button bar \n\
* 2 (ui.BUTTONBAR_VERTICAL): add vertical button bar \n\
dialogButtons : {dict}, optional \n\
every dictionary-entry is one button. key is the role, value is the button text \n\
childOfMainWindow : {bool}, optional \n\
for type TYPEDIALOG and TYPEWINDOW only. Indicates whether window should be a child of itom main window (default: True) \n\
deleteOnClose : {bool}, optional \n\
Indicates whether window should be deleted if user closes it or if it is hidden (default: Hidden, False) \n\
dockWidgetArea : {int}, optional \n\
Only for type ui.TYPEDOCKWIDGET (2). Indicates the position where the dock widget should be placed: \n\
\n\
* 1 (ui.LEFTDOCKWIDGETAREA) \n\
* 2 (ui.RIGHTDOCKWIDGETAREA) \n\
* 4 (ui.TOPDOCKWIDGETAREA): default \n\
* 8 (ui.BOTTOMDOCKWIDGETAREA)") |
|
| PyDoc_STRVAR (pyUiShow_doc,"show([modal=0]) -> shows initialized UI-Dialog \n\
\n\
Parameters \n\
----------- \n\
modal : {int}, optional \n\
* 0: non-modal (default)\n\
* 1: modal (python waits until dialog is hidden)\n\
* 2: modal (python returns immediately)\n\
\n\
See Also \n\
--------- \n\
hide()") |
|
| PyDoc_STRVAR (pyUiHide_doc,"hide() -> hides initialized user interface \n\
\n\
See Also \n\
--------- \n\
show(modal)") |
|
| PyDoc_STRVAR (pyUiIsVisible_doc,"isVisible() -> returns true if dialog is still visible\n\
\n\
Returns \n\
------- \n\
visibility : {bool} \n\
True if user interface is visible, False if it is hidden") |
|
| PyDoc_STRVAR (pyUiGetDouble_doc,"getDouble(title, label, defaultValue [, min, max, decimals=3]) -> shows a dialog to get a double value from the user\n\
\n\
Parameters \n\
----------- \n\
title : {str}\n\
is the dialog title \n\
label : {str}\n\
is the label above the spin box \n\
defaultValue : {double}, optional\n\
is the default value in the spin box \n\
min : {double}, optional\n\
default = -2147483647.0\n\
is the allowed minimal value\n\
max : {double}, optional\n\
default = 2147483647.0\n\
is the allowed maximal value\n\
decimals : {int}, optional\n\
the maximum number of decimal places (default: 1) \n\
\n\
Returns \n\
------- \n\
out : {tuple (double, bool)} \n\
A tuple where the first value contains the current double value. The second value is True if the dialog has been accepted, else False. \n\
\n\
See Also \n\
--------- \n\
getInt, getText, getItem") |
|
| PyDoc_STRVAR (pyUiGetInt_doc,"getInt(title, label, defaultValue [, min, max, step=1]) -> shows a dialog to get an integer value from the user\n\
\n\
Parameters \n\
----------- \n\
title : {str}\n\
is the dialog title \n\
label : {str}\n\
is the label above the spinbox \n\
defaultValue : {int}, optional\n\
is the default value in the spinbox \n\
min : {int}, optional\n\
is the allowed minimal value (default: -2147483647) \n\
max : {int}, optional\n\
is the allowed maximal value (default: 2147483647) \n\
step : {int}, optional\n\
is the step size if user presses the up/down arrow (default: 1)\n\
\n\
Returns \n\
------- \n\
out : {tuple (int, bool)} \n\
A tuple where the first value contains the current integer value. The second value is True if the dialog has been accepted, else False. \n\
\n\
See Also \n\
--------- \n\
getDouble, getText, getItem") |
|
| PyDoc_STRVAR (pyUiGetItem_doc,"getItem(title, label, stringList [, currentIndex=0, editable=True]) -> shows a dialog to let the user select an item from a string list\n\
\n\
Parameters \n\
----------- \n\
title : {str}\n\
is the dialog title \n\
label : {str}\n\
is the label above the text box \n\
stringList : {tuple or list}, optional \n\
is a list or tuple of possible string values \n\
currentIndex : {int}, optional\n\
defines the preselected value index (default: 0)\n\
editable : {bool}, optional\n\
defines whether new entries can be added (True) or not (False, default)\n\
\n\
Returns \n\
------- \n\
out : {tuple (str, bool)} \n\
A tuple where the first value contains the current active or typed string value. The second value is True if the dialog has been accepted, else False. \n\
\n\
See Also \n\
--------- \n\
getInt, getDouble, getText") |
|
| PyDoc_STRVAR (pyUiGetText_doc,"getText(title, label, defaultString) -> opens a dialog in order to ask the user for a string \n\
Parameters \n\
----------- \n\
title : {str}\n\
is the dialog title \n\
label : {str}\n\
is the label above the text box \n\
defaultString : {str}\n\
is the default string in the text box\n\
\n\
Returns \n\
------- \n\
out : {tuple (str, bool)} \n\
A tuple where the first value contains the current string value. The second value is True if the dialog has been accepted, else False. \n\
\n\
See Also \n\
--------- \n\
getInt, getDouble, getItem") |
|
| PyDoc_STRVAR (pyUiMsgInformation_doc,"msgInformation(title, text [, buttons, defaultButton, parent]) -> opens an information message box \n\
\n\
Parameters \n\
----------- \n\
title : {str}\n\
is the message box title \n\
text : {str}\n\
is the message text \n\
buttons : {int}, optional\n\
is an or-combination of ui.MsgBox[...]-constants indicating the buttons to display. Use | for the or-combination. \n\
defaultButton : {int}, optional\n\
is a value of ui.MsgBox[...] which indicates the default button \n\
parent : {ui}, optional\n\
is the parent dialog of the message box.\n\
\n\
See Also \n\
--------- \n\
msgCritical, msgQuestion, msgWarning") |
|
| PyDoc_STRVAR (pyUiMsgQuestion_doc,"msgQuestion(title, text [, buttons, defaultButton, parent]) -> opens a question message box \n\
\n\
Parameters \n\
----------- \n\
title : {str}\n\
is the message box title \n\
text : {str}\n\
is the message text \n\
buttons : {int}, optional\n\
is an or-combination of ui.MsgBox[...]-constants indicating the buttons to display. Use | for the or-combination. \n\
defaultButton : {int}, optional\n\
is a value of ui.MsgBox[...] which indicates the default button \n\
parent : {ui}, optional\n\
is the parent dialog of the message box.\n\
\n\
See Also \n\
--------- \n\
msgCritical, msgWarning, msgInformation") |
|
| PyDoc_STRVAR (pyUiMsgWarning_doc,"msgWarning(title, text [, buttons, defaultButton, parent]) -> opens a warning message box \n\
\n\
Parameters \n\
----------- \n\
title : {str}\n\
is the message box title \n\
text : {str}\n\
is the message text \n\
buttons : {int}, optional\n\
is an or-combination of ui.MsgBox[...]-constants indicating the buttons to display. Use | for the or-combination. \n\
defaultButton : {int}, optional\n\
is a value of ui.MsgBox[...] which indicates the default button \n\
parent : {ui}, optional\n\
is the parent dialog of the message box.\n\
\n\
See Also \n\
--------- \n\
msgCritical, msgQuestion, msgInformation") |
|
| PyDoc_STRVAR (pyUiMsgCritical_doc,"msgCritical(title, text [, buttons, defaultButton, parent]) -> opens a critical message box \n\
\n\
Parameters \n\
----------- \n\
title : {str}\n\
is the message box title \n\
text : {str}\n\
is the message text \n\
buttons : {int}, optional\n\
is an or-combination of ui.MsgBox[...]-constants indicating the buttons to display. Use | for the or-combination. \n\
defaultButton : {int}, optional\n\
is a value of ui.MsgBox[...] which indicates the default button \n\
parent : {ui}, optional\n\
is the parent dialog of the message box.\n\
\n\
See Also \n\
--------- \n\
msgWarning, msgQuestion, msgInformation") |
|
| PyDoc_STRVAR (pyUiGetExistingDirectory_doc,"getExistingDirectory(caption, startDirectory [, options, parent]) -> opens a dialog to choose an existing directory \n\
\n\
Parameters \n\
----------- \n\
caption : {str}\n\
is the caption of this dialog \n\
startDirectory : {str}\n\
is the start directory \n\
options : {int}, optional\n\
is an or-combination of the following options (see 'QFileDialog::Option'): \n\
\n\
* 1: ShowDirsOnly [default] \n\
* 2: DontResolveSymlinks \n\
* ... (for others see Qt-Help) \n\
parent : {ui}, optional\n\
is a parent dialog or window, this dialog becomes modal.\n\
\n\
Returns \n\
------- \n\
out : {str, None} \n\
The selected directory is returned as absolute path or None if the dialog has been rejected. \n\
\n\
See Also \n\
--------- \n\
getSaveFileName, getOpenFileName") |
|
| PyDoc_STRVAR (pyUiGetOpenFileName_doc,"getOpenFileName([caption, startDirectory, filters, selectedFilterIndex, options, parent]) -> opens dialog for chosing an existing file. \n\
\n\
Parameters \n\
----------- \n\
caption : {str}, optional\n\
This is the optional title of the dialog, default: no title \n\
startDirectory {str}, optional\n\
optional, if not indicated currentDirectory will be taken\n\
filters : {str}, optional\n\
default = 0\n\
possible filter list, entries should be separated by ;; , e.g. 'Images (*.png *.jpg);;Text files (*.txt)' \n\
selectedFilterIndex : {int}, optional \n\
is the index of filters which is set by default (0 is first entry) \n\
options : {int}, optional\n\
default = 0 \n\
or-combination of enum values QFileDialog::Options \n\
parent : {ui}, optional\n\
is the parent widget of this dialog \n\
\n\
Returns \n\
------- \n\
out : {str, None} \n\
filename as string or None if dialog has been aborted.\n\
\n\
See Also \n\
--------- \n\
getSaveFileName") |
|
| PyDoc_STRVAR (pyUiGetSaveFileName_doc,"getSaveFileName([caption, startDirectory, filters, selectedFilterIndex, options, parent]) -> opens dialog for chosing a file to save. \n\
\n\
This method creates a modal file dialog to let the user select a file name used for saving a file. \n\
\n\
Parameters \n\
----------- \n\
caption : {str}, optional\n\
This is the title of the dialog \n\
startDirectory : {String}, optional\n\
if not indicated, the current working directory will be taken\n\
filters : {str}, optional\n\
possible filter list, entries should be separated by ;; , e.g. 'Images (*.png *.jpg);;Text files (*.txt)' \n\
selectedFilterIndex : {int}, optional\n\
default = 0\n\
is the index of filters which is set by default (0 is first entry) \n\
options : {int}, optional\n\
default = 0\n\
or-combination of enum values QFileDialog::Options \n\
parent : {ui}, optional\n\
is the parent widget of this dialog\n\
\n\
Returns \n\
------- \n\
out : {str, None} \n\
filename as string or None if dialog has been aborted.\n\
\n\
See Also \n\
--------- \n\
getOpenFileName") |
|
| PyDoc_STRVAR (pyUiCreateNewPluginWidget_doc,"createNewPluginWidget(widgetName[, mandparams, optparams]) -> creates widget defined by any algorithm plugin and returns the instance of type 'ui' \n\
Parameters \n\
----------- \n\
widgetName : {}\n\
name algorithm widget \n\
parameters to pass to the plugin. The parameters are parsed and unnamed parameters are used in their \
incoming order to fill first mandatory parameters and afterwards optional parameters. Parameters may be passed \
with name as well but after the first named parameter no more unnamed parameters are allowed.\n\
\n\
Returns \n\
------- \n\
\n\
Notes \n\
----- \n\
doctodo\n\
\n\
See Also \n\
--------- \n\
\n\
") |
|
| PyDoc_STRVAR (PyTimerInit_doc,"timer(interval, callbackFunc [, argTuple, singleShot]) -> new callback timer \n\
\n\
Creates a timer object that continuously calls a python callback function or method with a certain interval. The timer is active after construction and \n\
stops when this instance is destroyed or stop() is called. \n\
\n\
Parameters \n\
----------- \n\
interval : {int} \n\
time out interval in ms \n\
callbackFunc: {function, method} \n\
Python function that should be called when timer event raises \n\
argTuple: {tuple}, optional \n\
tuple of parameters passed as arguments to the callback function \n\
singleShot: {bool}, optional \n\
defines if this timer only fires one time after its start (True) or continuously (False, default)") |
|
| PyDoc_STRVAR (PyTimerStart_doc,"start() -> starts timer\n\
\n\
Starts or restarts the timer with its timeout interval. If the timer is already running, it will be stopped and restarted.") |
|
| PyDoc_STRVAR (PyTimerStop_doc,"stop() -> stops timer") |
|
| PyDoc_STRVAR (PyTimerIsActive_doc,"isActive() -> returns timer status\n\
\n\
Returns \n\
------- \n\
status : {bool} \n\
True if the timer is running, otherwise False.") |
|
| PyDoc_STRVAR (PyTimerSetInterval_doc,"setInterval(interval) -> sets timer interval in [ms]\n\
\n\
This method sets the timeout interval in milliseconds. The timer calls the callback function continuously after this interval (if started) \n\
\n\
Parameters \n\
----------- \n\
interval : {int} \n\
timeout interval in milliseconds. The callback function is continuously called after this timeout once the timer is started.") |
| template<typename _Tp > |
| RetVal | CreateFunc (DataObject *dObj, const unsigned char dimensions, const int *sizes, const unsigned char continuous, const uchar *continuousDataPtr, const int *steps) |
| | templated method for create
|
| template<typename _Tp > |
| RetVal | CreateFuncWithCVPlanes (DataObject *dObj, const unsigned char dimensions, const int *sizes, const cv::Mat *planes, const unsigned int nrOfPlanes) |
| | templated method for creation with given vector of cv::Mat-planes
|
| template<typename _Tp > |
| RetVal | FreeFunc (DataObject *dObj) |
| | low-level, templated method for freeing allocated data blocks
|
|
| MAKEFUNCLIST (FreeFunc) |
|
template<typename _Tp > |
| RetVal | SecureFreeFunc (DataObject *dObj) |
|
| MAKEFUNCLIST (SecureFreeFunc) |
| template<typename _Tp > |
| RetVal | CopyToFunc (const DataObject &lhs, DataObject &rhs, unsigned char regionOnly) |
| | low-level, templated method for deeply copying the data of one matrix to another given matrix
|
|
| MAKEFUNCLIST (CopyToFunc) |
| template<typename _Tp > |
| RetVal | DeepCopyPartialFunc (const DataObject &lhs, DataObject &rhs) |
| | low-level, templated method to copy the values of the ROI of matrix lhs to the ROI of matrix rhs.
|
|
| MAKEFUNCLIST (DeepCopyPartialFunc) |
| template<typename _Tp > |
| RetVal | ZerosFunc (const int sizeY, const int sizeX, uchar **dstMat) |
| | low-level, templated method for creation of zero-valued matrix-plane
|
|
| MAKEFUNCLIST (ZerosFunc) |
| template<typename _Tp > |
| RetVal | OnesFunc (const int sizeY, const int sizeX, uchar **dstMat) |
| | low-level, templated method for creation of one-valued matrix-plane
|
| template<> |
| RetVal | OnesFunc< ito::Rgba32 > (const int sizeY, const int sizeX, uchar **dstMat) |
| | low-level, overloaded template method for creation of one-valued matrix-plane of RGBA32
|
|
| MAKEFUNCLIST (OnesFunc) |
| template<typename _Tp > |
| RetVal | RandFunc (const int sizeY, const int sizeX, const double value1, const double value2, const bool randMode, uchar **dstMat) |
| | low-level, templated method for creation of random-valued matrix-plane
|
| template<> |
| RetVal | RandFunc< ito::complex128 > (const int sizeY, const int sizeX, const double value1, const double value2, const bool randMode, uchar **dstMat) |
| | template specialisation for low-level, templated method for creation of random-valued matrix-plane of type complex128
|
| template<> |
| RetVal | RandFunc< ito::Rgba32 > (const int sizeY, const int sizeX, const double value1, const double value2, const bool randMode, uchar **dstMat) |
| | template specialisation for low-level, templated method for creation of random-valued matrix-plane of type rgba32
|
|
| MAKEFUNCLIST (RandFunc) |
| template<typename _Tp > |
| RetVal | CopyMatFunc (const uchar **src, uchar **&dst, bool transposed, const int sizeofs) |
| | low-level, templated method that executes a shallow-copy of every matrix-plane in the source-vector and stores the copies in the destination-vector
|
| template<typename _Tp > |
| RetVal | AssignScalarFunc (DataObject *src, const ito::tDataType type, const void *scalar) |
| | low-level, templated helper method to assign the given scalar to every element within its ROI in DataObject src.
|
|
| MAKEFUNCLIST (AssignScalarFunc) |
| template<typename _Tp > |
| RetVal | AssignScalarMaskFunc (DataObject *src, const DataObject *mask, const ito::tDataType type, const void *scalar) |
| | low-level, templated helper method to assign the given scalar to every element within its ROI in DataObject src.
|
|
| MAKEFUNCLIST (AssignScalarMaskFunc) |
| template<typename _Tp > |
| RetVal | AddFunc (const DataObject *dObj1, const DataObject *dObj2, DataObject *dObjRes) |
| | Sets all or some of the array elements to the specific value.
|
|
| MAKEFUNCLIST (AddFunc) |
|
template<typename _Tp > |
| RetVal | AddScalarFunc (const DataObject *dObjIn, ito::float64 scalar, DataObject *dObjOut) |
|
template<> |
| RetVal | AddScalarFunc< ito::Rgba32 > (const DataObject *dObjIn, ito::float64 scalar, DataObject *dObjOut) |
|
| MAKEFUNCLIST (AddScalarFunc) |
| template<typename _Tp > |
| RetVal | SubFunc (const DataObject *dObj1, const DataObject *dObj2, DataObject *dObjRes) |
| | low-level, templated method for element-wise subtraction of values from second data object from values of first data object
|
|
| MAKEFUNCLIST (SubFunc) |
| template<typename _Tp > |
| RetVal | OpMulFunc (const DataObject *dObj1, const DataObject *dObj2, DataObject *dObjRes) |
| | brief description
|
|
| MAKEFUNCLIST (OpMulFunc) |
| template<typename _Tp > |
| RetVal | OpScalarMulFunc (DataObject *src, const double &factor) |
| | low-level, templated method which multiplies every element of Data Object with a factor
|
|
template<> |
| RetVal | OpScalarMulFunc< ito::complex64 > (DataObject *src, const double &factor) |
|
template<> |
| RetVal | OpScalarMulFunc< ito::complex128 > (DataObject *src, const double &factor) |
|
template<> |
| RetVal | OpScalarMulFunc< ito::Rgba32 > (DataObject *src, const double &factor) |
|
| MAKEFUNCLIST (OpScalarMulFunc) |
| template<typename _Tp > |
| RetVal | CmpFunc (const DataObject *src1, const DataObject *src2, DataObject *dst, int cmpOp) |
| | low-level, templated method which compares each element in source-matrix1 with its corresponding element in source-matrix2 and saves the result in a destionation matrix
|
| template<> |
| RetVal | CmpFunc< ito::complex64 > (const DataObject *, const DataObject *, DataObject *, int) |
| | template specialisation for compare function of type complex64
|
| template<> |
| RetVal | CmpFunc< ito::complex128 > (const DataObject *, const DataObject *, DataObject *, int) |
| | template specialisation for compare function of type complex128
|
|
| MAKEFUNCLIST (CmpFunc) |
| template<typename _Tp > |
| RetVal | CmpFuncScalar (const DataObject *src, const float64 &value, DataObject *dst, int cmpOp) |
| | low-level, templated method which compares each element in source-matrix1 with its corresponding element in source-matrix2 and saves the result in a destionation matrix
|
| template<> |
| RetVal | CmpFuncScalar< ito::complex64 > (const DataObject *, const float64 &, DataObject *, int) |
| | template specialisation for compare function of type complex64
|
| template<> |
| RetVal | CmpFuncScalar< ito::complex128 > (const DataObject *, const float64 &, DataObject *, int) |
| | template specialisation for compare function of type complex128
|
|
| MAKEFUNCLIST (CmpFuncScalar) |
| template<typename _Tp > |
| RetVal | ShiftLFunc (DataObject *src, const unsigned char shiftbit) |
| | low-level, templated method which element-wisely shifts the values of the source matrix by a certain value to the left
|
| template<> |
| RetVal | ShiftLFunc< ito::float32 > (DataObject *, const unsigned char) |
| | template specialisation for shift function of type float32
|
| template<> |
| RetVal | ShiftLFunc< ito::float64 > (DataObject *, const unsigned char) |
| | template specialisation for shift function of type float64
|
| template<> |
| RetVal | ShiftLFunc< ito::complex64 > (DataObject *, const unsigned char) |
| | template specialisation for shift function of type complex64
|
| template<> |
| RetVal | ShiftLFunc< ito::complex128 > (DataObject *, const unsigned char) |
| | template specialisation for shift function of type complex128
|
| template<> |
| RetVal | ShiftLFunc< ito::Rgba32 > (DataObject *, const unsigned char) |
| | template specialisation for shift function of type rgba32
|
|
| MAKEFUNCLIST (ShiftLFunc) |
| template<typename _Tp > |
| RetVal | ShiftRFunc (DataObject *src, const unsigned char shiftbit) |
| | low-level, templated method which element-wisely shifts the values of the source matrix by a certain value to the right
|
| template<> |
| RetVal | ShiftRFunc< ito::float32 > (DataObject *, const unsigned char) |
| | template specialisation for shift function of type float32
|
| template<> |
| RetVal | ShiftRFunc< ito::float64 > (DataObject *, const unsigned char) |
| | template specialisation for shift function of type float64
|
| template<> |
| RetVal | ShiftRFunc< ito::complex64 > (DataObject *, const unsigned char) |
| | template specialisation for shift function of type complex64
|
| template<> |
| RetVal | ShiftRFunc< ito::complex128 > (DataObject *, const unsigned char) |
| | template specialisation for shift function of type complex128
|
| template<> |
| RetVal | ShiftRFunc< ito::Rgba32 > (DataObject *, const unsigned char) |
| | template specialisation for shift function of type rgba32
|
| template<typename _Tp > |
| RetVal | BitAndFunc (const DataObject *dObj1, const DataObject *dObj2, DataObject *dObjRes) |
| | low-level, templated method which element-wisely executes a bitwise 'and' comparison between values of two dataObjects.
|
| template<> |
| RetVal | BitAndFunc< ito::float32 > (const DataObject *, const DataObject *, DataObject *) |
| | template specialisation for bitwise and function of type float32
|
| template<> |
| RetVal | BitAndFunc< ito::float64 > (const DataObject *, const DataObject *, DataObject *) |
| | template specialisation for bitwise and function of type float64
|
| template<> |
| RetVal | BitAndFunc< ito::complex64 > (const DataObject *, const DataObject *, DataObject *) |
| | template specialisation for bitwise and function of type complex64
|
| template<> |
| RetVal | BitAndFunc< ito::complex128 > (const DataObject *, const DataObject *, DataObject *) |
| | template specialisation for bitwise and function of type complex128
|
| template<> |
| RetVal | BitAndFunc< ito::Rgba32 > (const DataObject *, const DataObject *, DataObject *) |
| | template specialisation for bitwise and function of type rgba32
|
| template<typename _Tp > |
| RetVal | BitOrFunc (const DataObject *dObj1, const DataObject *dObj2, DataObject *dObjRes) |
| | low-level, templated method which element-wisely executes a bitwise 'or' comparison between values of two dataObjects.
|
| template<> |
| RetVal | BitOrFunc< ito::float32 > (const DataObject *, const DataObject *, DataObject *) |
| | template specialisation for bitwise or function of type float32
|
| template<> |
| RetVal | BitOrFunc< ito::float64 > (const DataObject *, const DataObject *, DataObject *) |
| | template specialisation for bitwise or function of type float64
|
| template<> |
| RetVal | BitOrFunc< ito::complex64 > (const DataObject *, const DataObject *, DataObject *) |
| | template specialisation for bitwise or function of type complex64
|
| template<> |
| RetVal | BitOrFunc< ito::complex128 > (const DataObject *, const DataObject *, DataObject *) |
| | template specialisation for bitwise or function of type complex128
|
| template<> |
| RetVal | BitOrFunc< ito::Rgba32 > (const DataObject *, const DataObject *, DataObject *) |
| | template specialisation for bitwise or function of type rgba32
|
| template<typename _Tp > |
| RetVal | BitXorFunc (const DataObject *dObj1, const DataObject *dObj2, DataObject *dObjRes) |
| | low-level, templated method which element-wisely executes a bitwise 'xor' comparison between values of two dataObjects.
|
| template<> |
| RetVal | BitXorFunc< ito::float32 > (const DataObject *, const DataObject *, DataObject *) |
| | template specialisation for bitwise xor function of type float32
|
| template<> |
| RetVal | BitXorFunc< ito::float64 > (const DataObject *, const DataObject *, DataObject *) |
| | template specialisation for bitwise xor function of type float64
|
| template<> |
| RetVal | BitXorFunc< ito::complex64 > (const DataObject *, const DataObject *, DataObject *) |
| | template specialisation for bitwise xor function of type complex64
|
| template<> |
| RetVal | BitXorFunc< ito::complex128 > (const DataObject *, const DataObject *, DataObject *) |
| | template specialisation for bitwise xor function of type complex128
|
| template<> |
| RetVal | BitXorFunc< ito::Rgba32 > (const DataObject *, const DataObject *, DataObject *) |
| | template specialisation for bitwise xor function of type complex128
|
| template<typename _Tp > |
| RetVal | GetRangeFunc (DataObject *dObj, const int dtop, const int dbottom, const int dleft, const int dright) |
| | low-level, templated method for saving a shallow copy of a source cv::Mat_ to a destination cv::Mat_ with respect to given row- and col-ranges
|
| template<typename _Tp > |
| RetVal | AdjustROIFunc (DataObject *dObj, int dtop, int dbottom, int dleft, int dright) |
| | low-level, templated method for adjusting the ROI of a data object by the given incremental values
|
| template<typename _Tp > |
| RetVal | EyeFunc (const int size, uchar **dstMat) |
| | low-level, templated method for creating an eye-matrix
|
| template<typename _Tp > |
| RetVal | ConjFunc (DataObject *dObj) |
| | low-level, templated method for calculating the conjugated value of each element within the ROI of this data object
|
|
template<> |
| RetVal | ConjFunc< int8 > (DataObject *) |
| | template specialization for data object of type int8. throws cv::Exception, since the data type is not complex.
|
|
template<> |
| RetVal | ConjFunc< uint8 > (DataObject *) |
| | template specialization for data object of type uint8. throws cv::Exception, since the data type is not complex.
|
|
template<> |
| RetVal | ConjFunc< int16 > (DataObject *) |
| | template specialization for data object of type int16. throws cv::Exception, since the data type is not complex.
|
|
template<> |
| RetVal | ConjFunc< uint16 > (DataObject *) |
| | template specialization for data object of type uint16. throws cv::Exception, since the data type is not complex.
|
|
template<> |
| RetVal | ConjFunc< int32 > (DataObject *) |
| | template specialization for data object of type int32. throws cv::Exception, since the data type is not complex.
|
|
template<> |
| RetVal | ConjFunc< uint32 > (DataObject *) |
| | template specialization for data object of type uint32. throws cv::Exception, since the data type is not complex.
|
|
template<> |
| RetVal | ConjFunc< ito::float32 > (DataObject *) |
| | template specialization for data object of type float32. throws cv::Exception, since the data type is not complex.
|
|
template<> |
| RetVal | ConjFunc< ito::float64 > (DataObject *) |
| | template specialization for data object of type float64. throws cv::Exception, since the data type is not complex.
|
|
template<> |
| RetVal | ConjFunc< ito::Rgba32 > (DataObject *) |
| | template specialization for data object of type float64. throws cv::Exception, since the data type is not complex.
|
|
template<> |
| RetVal | ConjFunc< int64 > (DataObject *) |
| | template specialization for data object of type int64. throws cv::Exception, since the data type is not complex.
|
|
template<typename _Tp > |
| RetVal | MulFunc (const DataObject *src1, const DataObject *src2, DataObject *res, const double) |
| template<typename _Tp > |
| RetVal | DivFunc (const DataObject *src1, const DataObject *src2, DataObject *res) |
| | low-level, templated method which does a element-wise division of elements in first source matrix by elements in second source matrix.
|
| template<> |
| RetVal | DivFunc< Rgba32 > (const DataObject *src1, const DataObject *src2, DataObject *res) |
| | low-level, templated method which does a element-wise division of elements in first source matrix by elements in second source matrix.
|
| template<typename _Tp , typename _T2 > |
| RetVal | CastFunc (const DataObject *dObj, DataObject *resObj, double alpha, double beta) |
| | low-level templated method to cast each element of source matrix to another type.
|
| template<typename _Tp > |
| RetVal | ConvertToFunc (const DataObject &lhs, DataObject &rhs, const int type, const double alpha, const double beta) |
| | converts data in DataObject lhs to DataObject rhs with a given type
|
|
| MAKEFUNCLIST (ConvertToFunc) |
|
template<typename _Tp > |
| RetVal | GrayScaleCastFunc (const DataObject *dObj, DataObject *resObj) |
| template<typename _CmplxTp , typename _Tp > |
| RetVal | AbsFunc (const DataObject *dObj, DataObject *resObj) |
| | low-level, double templated method to save the element-wise absolute value of each element in source matrix to result matrix
|
| template<typename _Tp > |
| RetVal | AbsFuncReal (const DataObject *dObj, DataObject *resObj) |
| | low-level, templated method to save the element-wise absolute value of each element in source matrix to result matrix
|
| DataObject | abs (const DataObject &dObj) |
| | high-level value which calculates the absolute value of each element of the input source data object and returns the resulting data object
|
| template<typename _CmplxTp , typename _Tp > |
| RetVal | ArgFunc (const DataObject *dObj, DataObject *resObj) |
| | low-level, double templated method to save the element-wise argument of each element in source matrix to result matrix
|
| DataObject | arg (const DataObject &dObj) |
| | high-level value which calculates the argument value of each element of the input source data object and returns the resulting data object
|
| template<typename _CmplxTp , typename _Tp > |
| RetVal | RealFunc (const DataObject *dObj, DataObject *resObj) |
| | low-level, double templated method to save the element-wise real value of each element in source matrix to result matrix
|
| DataObject | real (const DataObject &dObj) |
| | high-level value which calculates the real value of each element of the input source data object and returns the resulting data object
|
| template<typename _CmplxTp , typename _Tp > |
| RetVal | ImagFunc (const DataObject *dObj, DataObject *resObj) |
| | low-level, double templated method to save the element-wise imaginary value of each element in source matrix to result matrix
|
| DataObject | imag (const DataObject &dObj) |
| | high-level value which calculates the imaginary value of each element of the input source data object and returns the resulting data object
|
| template<typename _Tp > |
| RetVal | MakeContinuousFunc (const DataObject &dObj, DataObject &resDObj) |
| | low-level, templated method which copies an incontinuously organized data object to a continuously organized resulting data object
|
| DataObject | makeContinuous (const DataObject &dObj) |
| | high-level method which copies an incontinuously organized data object to a continuously organized resulting data object, which is returned
|
|
template<typename _Tp > |
| std::ostream & | coutFunc (std::ostream &out, const DataObject &dObj) |
|
std::ostream & | operator<< (std::ostream &out, const DataObject &dObj) |
| | streaming operator to stream the representation or contant of a data object
|
| template<typename _Tp > |
| _Tp | numberConversion (ito::tDataType fromType, const void *scalar) |
| | templated method for converting a given scalar value to the data type, indicated by the template parameter
|
|
template<typename _Tp > |
| _Tp | numberConversion (ito::tDataType fromType, void *scalar) |
| ito::tDataType | convertCmplxTypeToRealType (ito::tDataType cmplxType) |
| | method which returns the real data type of any given data type
|
| ito::tDataType | guessDataTypeFromCVMat (const cv::Mat *mat, ito::RetVal &retval) |
| | method which guesses the dataObject type from a given cv::Mat*
|
| template<typename _Tp > |
| ito::tDataType | getDataType (const _Tp *) |
| | method which returns the value of enumeration ito::tDataType, which corresponds to the type of the given pointer parameter.
|
|
template<> |
| ito::tDataType | getDataType (const uint8 *) |
|
template<> |
| ito::tDataType | getDataType (const int8 *) |
|
template<> |
| ito::tDataType | getDataType (const uint16 *) |
|
template<> |
| ito::tDataType | getDataType (const int16 *) |
|
template<> |
| ito::tDataType | getDataType (const uint32 *) |
|
template<> |
| ito::tDataType | getDataType (const int32 *) |
|
template<> |
| ito::tDataType | getDataType (const float32 *) |
|
template<> |
| ito::tDataType | getDataType (const float64 *) |
|
template<> |
| ito::tDataType | getDataType (const complex64 *) |
|
template<> |
| ito::tDataType | getDataType (const complex128 *) |
|
template<> |
| ito::tDataType | getDataType (const Rgba32 *) |
| template<typename _Tp > |
| ito::tDataType | getDataType2 () |
| | method which returns the value of enumeration ito::tDataType, which corresponds to the template parameter (must be a pointer).
|
|
template<> |
| ito::tDataType | getDataType2< uint8 * > () |
|
template<> |
| ito::tDataType | getDataType2< int8 * > () |
|
template<> |
| ito::tDataType | getDataType2< uint16 * > () |
|
template<> |
| ito::tDataType | getDataType2< int16 * > () |
|
template<> |
| ito::tDataType | getDataType2< uint32 * > () |
|
template<> |
| ito::tDataType | getDataType2< int32 * > () |
|
template<> |
| ito::tDataType | getDataType2< float32 * > () |
|
template<> |
| ito::tDataType | getDataType2< float64 * > () |
|
template<> |
| ito::tDataType | getDataType2< complex64 * > () |
|
template<> |
| ito::tDataType | getDataType2< complex128 * > () |
|
template<> |
| ito::tDataType | getDataType2< Rgba32 * > () |
| template<typename _Tp > |
| bool | isZeroValue (_Tp v, _Tp) |
| | method returns whether a given variable is equal to zero.
|
|
template<> |
| bool | isZeroValue (Rgba32 v, Rgba32) |
|
template<> |
| bool | isZeroValue (float32 v, float32 epsilon) |
|
template<> |
| bool | isZeroValue (float64 v, float64 epsilon) |
|
template<> |
| bool | isZeroValue (std::complex< ito::float32 > v, std::complex< ito::float32 > epsilon) |
|
template<> |
| bool | isZeroValue (std::complex< ito::float64 > v, std::complex< ito::float64 > epsilon) |
|
bool | operator== (const ByteArray &a1, const char *a2) |
|
bool | operator== (const char *a1, const ByteArray &a2) |
|
bool | operator!= (const ByteArray &a1, const char *a2) |
|
bool | operator!= (const char *a1, const ByteArray &a2) |
| ito::RetVal ITOMCOMMONQT_EXPORT | checkParamVector (QVector< ito::Param > *params) |
| | checks param vector
|
| ito::RetVal ITOMCOMMONQT_EXPORT | checkParamVectors (QVector< ito::Param > *paramsMand, QVector< ito::Param > *paramsOpt, QVector< ito::Param > *paramsOut) |
| | verifies that the three param vectors are not NULL
|
| ITOMCOMMONQT_EXPORT ito::Param * | getParamByName (QVector< ito::Param > *paramVec, const char *name, ito::RetVal *retval) |
| | brief returns a parameter from the parameter-vector, that fits to a specific name
|
ITOMCOMMONQT_EXPORT
ito::ParamBase * | getParamByName (QVector< ito::ParamBase > *paramVec, const char *name, ito::RetVal *retval=NULL) |
ITOMCOMMONQT_EXPORT QHash
< QString, ito::Param * > | createParamHashTable (QVector< ito::Param > *paramVec) |
|
bool ITOMCOMMONQT_EXPORT | checkNumericParamRange (const ito::Param ¶m, double &value, bool *ok=NULL) |
| ito::RetVal ITOMCOMMONQT_EXPORT | parseParamName (const QString &name, QString ¶mName, bool &hasIndex, int &index, QString &additionalTag) |
| | parses parameter name with respect to regular expression, assigned for parameter-communcation with plugins
|
|
ito::RetVal ITOMCOMMONQT_EXPORT | getParamValue (const QMap< QString, Param > *m_params, const QString &key, ito::Param &value, QString &pkey, int &index) |
|
ito::RetVal ITOMCOMMONQT_EXPORT | setParamValue (const QMap< QString, Param > *m_params, const QString &key, const ito::ParamBase &value, QString &pkey, int &index) |
| ITOMCOMMONQT_EXPORT ito::RetVal | formatDoubleWithUnit (QStringList scaleThisUnitsOnly, QString unitIn, double dVal, double &dValOut, QString &unitOut) |
| | < Function to convert double values with unit to scaled values with scaled units (0.01m -> 10mm)
|
| ITOMCOMMONQT_EXPORT ito::RetVal | generateAutoSaveParamFile (QString plugInName, QFile ¶mFile) |
| | loadXML2QLIST loads parameters from an XML-File and saves them to paramList
|
|
ITOMCOMMONQT_EXPORT ito::RetVal | loadXML2QLIST (QMap< QString, ito::Param > *paramList, QString id, QFile ¶mFile) |
| | saveQLIST2XML writes parameters from paramList to an XML-File
|
|
ITOMCOMMONQT_EXPORT ito::RetVal | saveQLIST2XML (QMap< QString, ito::Param > *paramList, QString id, QFile ¶mFile) |
| | mergeQLists copies parameters from newList to oldList and performs some checks
|
|
ITOMCOMMONQT_EXPORT ito::RetVal | mergeQLists (QMap< QString, ito::Param > *oldList, QMap< QString, ito::Param > *newList, bool checkAutoSave, bool deleteUnchangedParams=false) |
| | Save a dataObject to harddrive in a readable ITO-XML-Format (.ido or .idh)
|
| ITOMCOMMONQT_EXPORT ito::RetVal | saveDOBJ2XML (ito::DataObject *dObjOut, QString folderFileName, bool onlyHeaderObjectFile=false, bool doubleAsBinary=false) |
| | Import a dataObject from harddrive, saved in the ITO-XML-Format (.ido or .idh)
|
| ITOMCOMMONQT_EXPORT ito::RetVal | loadXML2DOBJ (ito::DataObject *dObjIn, QString folderFileName, bool onlyHeaderObjectFile=false, bool appendEnding=true) |
|
void | paramHelperSetValue (ito::Param ¶m, ito::ParamBase value, const int pos) |
| RetVal | loadXML2QLIST (QMap< QString, Param > *paramList, QString id, QFile ¶mFile) |
| RetVal | saveQLIST2XML (QMap< QString, Param > *paramList, QString id, QFile ¶mFile) |
| RetVal | mergeQLists (QMap< QString, Param > *oldList, QMap< QString, Param > *newList, bool checkAutoSave, bool deleteUnchangedParams) |
| RetVal | writeObjectHeaderToFileV1 (QXmlStreamWriter &stream, DataObject *dObjOut, bool doubleAsBinary, int &elementsize) |
| | This helper function writes the header of the Object to the xml stream. This helper function writes the header (dims, sizes, type) of an object and the metaData (complete DataObjectTags without tagsMap) from the Object to the xml stream. The values of the header are stored as string. The values of each axis-tag / value-tag / rotation matrix are in case of string-type directly written to the stream or in case of double converted to either strings directly (15 significat digits, >32Bit) or stored as lostfree binary (QByteArray::toBase64() to avoid XML-conflict). WARNING: Do not change the header (dims, sizes, type) information or the value of tags exported as binary (d2b).
|
| RetVal | writeObjectTagsToFileV1 (QXmlStreamWriter &stream, DataObject *dObjOut, bool doubleAsBinary) |
| | This helper function writes the tags defined in the tagMap (DataObjectTags) from the Object to the xml stream. This helper function writes the tags defined in the tagMap (DataObjectTags) from the Object to the xml stream. Therefore the values of each tag are in case of string-type directly written to the stream or in case of double converted to either strings directly (15 significat digits, >32Bit) or stored as lostfree binary (QByteArray::toBase64() to avoid XML-conflict). WARNING: Do not change information or the value of tags exported as binary (d2b).
|
| RetVal | writeObjectDataToFileV1 (QXmlStreamWriter &stream, DataObject *dObjOut, int elementsize) |
| | This helper function writes the data(cv::mats) from the Object to the xml stream. This helper function writes the data(cv::mats) from the Object to the xml stream. Therefore the data is converted using QByteArray::toBase64() to avoid XML-conflict with the binary data.
|
| bool | readTillNext (QXmlStreamReader &stream, int ×, int maxtimes) |
| | This helper function reads the stream till the next startElement. The Qt-Function readNextStartElement sometimes stops at the end-element (:P). So the function tries to read until it reaches the next startelement but only for maxtimes trys the Function checks if the attribute exists and than tries to convert to the value of the attribute either from binary or with string to double functions.
|
| RetVal | readDoubleFromXML (QXmlStreamAttributes &attrStream, QString &Element, QString &Attrib, double &val, bool isBinary) |
| | This helper function extracts a double from the xml-Attributes of the Stream This helper function extracts a double from the xml-Attributes of the Stream copied by the caller with the attrStream = attrStream = stream.attributes();. the Function checks if the attribute exists and than tries to convert to the value of the attribute either from binary or with string to double functions.
|
| RetVal | readStdStringFromXML (QXmlStreamAttributes &attrStream, QString &Element, QString &Attrib, std::string &val) |
| | This helper function extracts a std::string from the xml-Attributes of the Stream This helper function extracts a std::string from the xml-Attributes of the Stream copied by the caller with the attrStream = attrStream = stream.attributes();. the Function checks if the attribute exists and than tries to convert to the value of the attribute from QString to std::string.
|
| RetVal | createObjectFromXMLV1 (QXmlStreamReader &stream, DataObject &dObjIn, int &elementsize) |
| | This function creates an dataObject from the header of the xml-file This function creates an dataObject from the header of the xml-file by parsing the XML-stream. The first start element, already read by the calling function must contain the attributes dims, dataType and dim0..dimn-2, dimX, dimY.
|
| RetVal | loadObjectHeaderFromXMLV1 (QXmlStreamReader &stream, DataObject &dObjIn) |
| | This function fills the MetaData (DataObjectTags) of an allocated dataObject from the values of an xml-file This function fills the MetaData (DataObjectTags) of an allocated dataObject from the values of an xml-file. This includes the axis-Tags (offset, scale, unit, description), value-Tags ((offset), (scale), unit, description) and the rotation matrix. It does not include the tag-Space (std::map<std::string, DataObjectTagType> m_tags) (e.g. protocol ...)
|
| RetVal | loadTagSpaceFromXMLV1 (QXmlStreamReader &stream, DataObject &dObjIn) |
| | This function fills the tagsSpace (DataObjectTags) of an allocated dataObject from the values of an xml-file This function fills the tagsSpace (DataObjectTags) of an allocated dataObject from the values of an xml-file. This onlye includes the tag-Space (std::map<std::string, DataObjectTagType> m_tags) (e.g. protocol ...) and does not include the axis-Tags (offset, scale, unit, description), value-Tags ((offset), (scale), unit, description) and the rotation matrix.
|
| RetVal | loadDataFromXMLV1 (QXmlStreamReader &stream, DataObject &dObjIn, int elementsize) |
| | This function copies the CDATA from the xml-file to the allocated dataObject. This function copies the CDATA from the xml-file to the allocated dataObject. The data was before packed (substitution of xml-registered characters) during saving and is unpacked here. The data is stored plane-wise. The function checks if the plane-size if the object is equal to the imported size.
|
Variables |
|
void ** | ITOM_API_FUNCS |
|
void * | ITOM_API_FUNCS_ARR [] |
|
void ** | ITOM_API_FUNCS_GRAPH |
| void * | ITOM_API_FUNCS_GRAPH_ARR [] |
|
int | ROWHEIGHT = 20 |
|
int | COLWIDTH = 100 |
| tCoutFunc | fListCout [] |
|
const uint32 | paramFlagMask = 0xFFFF0000 |
| | bits of type lying within this mask are flags (e.g. typeNoAutosave, typeReadonly...)
|
|
const uint32 | paramTypeMask = 0x0000FFFF |
| | bits of param type lying withing this mask describe the type (typeNoAutosave must be included there)
|
1.7.4