shudder5305/pupilometer
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
feature/max485-control
pupilometer/.venv/lib/python3.12/site-packages/pypylon/pylondataprocessing.py

4588 lines
148 KiB
Python
Raw Permalink Blame History

# This file was automatically generated by SWIG (https://www.swig.org).
# Version 4.3.0
#
# Do not make changes to this file unless you know what you are doing - modify
# the SWIG interface file instead.
"""
Copyright (C) 2023 Basler AG
Redistribution and use in source and binary forms, with or without modification,
are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
3. Neither the name of the copyright holder nor the names of its contributors
may be used to endorse or promote products derived from this software
without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
"""
from sys import version_info as _swig_python_version_info
# Import the low-level C/C++ module
if __package__ or "." in __name__:
from . import _pylondataprocessing
else:
import _pylondataprocessing
try:
import builtins as __builtin__
except ImportError:
import __builtin__
def _swig_repr(self):
try:
strthis = "proxy of " + self.this.__repr__()
except __builtin__.Exception:
strthis = ""
return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)
def _swig_setattr_nondynamic_instance_variable(set):
def set_instance_attr(self, name, value):
if name == "this":
set(self, name, value)
elif name == "thisown":
self.this.own(value)
elif hasattr(self, name) and isinstance(getattr(type(self), name), property):
set(self, name, value)
else:
raise AttributeError("You cannot add instance attributes to %s" % self)
return set_instance_attr
def _swig_setattr_nondynamic_class_variable(set):
def set_class_attr(cls, name, value):
if hasattr(cls, name) and not isinstance(getattr(cls, name), property):
set(cls, name, value)
else:
raise AttributeError("You cannot add class attributes to %s" % cls)
return set_class_attr
def _swig_add_metaclass(metaclass):
"""Class decorator for adding a metaclass to a SWIG wrapped class - a slimmed down version of six.add_metaclass"""
def wrapper(cls):
return metaclass(cls.__name__, cls.__bases__, cls.__dict__.copy())
return wrapper
class _SwigNonDynamicMeta(type):
"""Meta class to enforce nondynamic attributes (no new attributes) for a class"""
__setattr__ = _swig_setattr_nondynamic_class_variable(type.__setattr__)
import weakref
class SwigPyIterator(object):
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
def __init__(self, *args, **kwargs):
raise AttributeError("No constructor defined - class is abstract")
__repr__ = _swig_repr
__swig_destroy__ = _pylondataprocessing.delete_SwigPyIterator
def value(self):
return _pylondataprocessing.SwigPyIterator_value(self)
def incr(self, n=1):
return _pylondataprocessing.SwigPyIterator_incr(self, n)
def decr(self, n=1):
return _pylondataprocessing.SwigPyIterator_decr(self, n)
def distance(self, x):
return _pylondataprocessing.SwigPyIterator_distance(self, x)
def equal(self, x):
return _pylondataprocessing.SwigPyIterator_equal(self, x)
def copy(self):
return _pylondataprocessing.SwigPyIterator_copy(self)
def next(self):
return _pylondataprocessing.SwigPyIterator_next(self)
def __next__(self):
return _pylondataprocessing.SwigPyIterator___next__(self)
def previous(self):
return _pylondataprocessing.SwigPyIterator_previous(self)
def advance(self, n):
return _pylondataprocessing.SwigPyIterator_advance(self, n)
def __eq__(self, x):
return _pylondataprocessing.SwigPyIterator___eq__(self, x)
def __ne__(self, x):
return _pylondataprocessing.SwigPyIterator___ne__(self, x)
def __iadd__(self, n):
return _pylondataprocessing.SwigPyIterator___iadd__(self, n)
def __isub__(self, n):
return _pylondataprocessing.SwigPyIterator___isub__(self, n)
def __add__(self, n):
return _pylondataprocessing.SwigPyIterator___add__(self, n)
def __sub__(self, *args):
return _pylondataprocessing.SwigPyIterator___sub__(self, *args)
def __iter__(self):
return self
# Register SwigPyIterator in _pylondataprocessing:
_pylondataprocessing.SwigPyIterator_swigregister(SwigPyIterator)
try:
from types import ModuleType
import numpy as _pylon_numpy
except:
pass
def needs_numpy(func):
def func_wrapper(*args, **kwargs):
e = None
try:
if not isinstance(_pylon_numpy, ModuleType):
e = RuntimeError("_pylon_numpy not a module - not good!")
except NameError:
e = NotImplementedError("please install numpy to use this method")
if e: raise e
return func(*args, **kwargs)
return func_wrapper
import pypylon.genicam
import pypylon.pylon
PYLON_DATAPROCESSING_VERSION_MAJOR = _pylondataprocessing.PYLON_DATAPROCESSING_VERSION_MAJOR
PYLON_DATAPROCESSING_VERSION_MINOR = _pylondataprocessing.PYLON_DATAPROCESSING_VERSION_MINOR
PYLON_DATAPROCESSING_VERSION_SUBMINOR = _pylondataprocessing.PYLON_DATAPROCESSING_VERSION_SUBMINOR
PYLON_DATAPROCESSING_VERSION_BUILD = _pylondataprocessing.PYLON_DATAPROCESSING_VERSION_BUILD
PYLON_DATAPROCESSING_VERSIONSTRING_MAJOR = _pylondataprocessing.PYLON_DATAPROCESSING_VERSIONSTRING_MAJOR
PYLON_DATAPROCESSING_VERSIONSTRING_MINOR = _pylondataprocessing.PYLON_DATAPROCESSING_VERSIONSTRING_MINOR
PYLON_DATAPROCESSING_VERSIONSTRING_SUBMINOR = _pylondataprocessing.PYLON_DATAPROCESSING_VERSIONSTRING_SUBMINOR
PYLON_DATAPROCESSING_VERSIONSTRING_BUILD = _pylondataprocessing.PYLON_DATAPROCESSING_VERSIONSTRING_BUILD
PYLON_DATAPROCESSING_VERSIONSTRING_EXTENSION = _pylondataprocessing.PYLON_DATAPROCESSING_VERSIONSTRING_EXTENSION
PYLON_DATAPROCESSING_GIT_REVISION = _pylondataprocessing.PYLON_DATAPROCESSING_GIT_REVISION
PYLON_DATAPROCESSING_VERSION_SUFFIX = _pylondataprocessing.PYLON_DATAPROCESSING_VERSION_SUFFIX
def GetVersion():
return _pylondataprocessing.GetVersion()
AcquisitionMode_Unchanged = _pylondataprocessing.AcquisitionMode_Unchanged
AcquisitionMode_SingleFrame = _pylondataprocessing.AcquisitionMode_SingleFrame
AcquisitionMode_Continuous = _pylondataprocessing.AcquisitionMode_Continuous
class PointF2D(object):
r"""
The data of a CVariant object with the VariantDataType_PointF2D data type.
PointF2D can provide image coordinates in pixels and world coordinates in
meters. The origin (0,0) of image coordinates defined by a PointF2D is the
center of the top left image pixel.
C++ includes: PointF2D.h
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
X = property(_pylondataprocessing.PointF2D_X_get, _pylondataprocessing.PointF2D_X_set)
Y = property(_pylondataprocessing.PointF2D_Y_get, _pylondataprocessing.PointF2D_Y_set)
def __str__(self):
result = "X = {0}; Y = {1}".format(self.X,self.Y)
return result
def __init__(self, *args):
r"""
Pylon::DataProcessing::SPointF2D::SPointF2D
Creates a point and initializes it with (x,y).
"""
_pylondataprocessing.PointF2D_swiginit(self, _pylondataprocessing.new_PointF2D(*args))
__swig_destroy__ = _pylondataprocessing.delete_PointF2D
# Register PointF2D in _pylondataprocessing:
_pylondataprocessing.PointF2D_swigregister(PointF2D)
class LineF2D(object):
r"""
The data of a CVariant object with the VariantDataType_LineF2D data type.
C++ includes: LineF2D.h
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
_PointA = property(_pylondataprocessing.LineF2D__PointA_get, _pylondataprocessing.LineF2D__PointA_set)
_PointB = property(_pylondataprocessing.LineF2D__PointB_get, _pylondataprocessing.LineF2D__PointB_set)
def _Get_PointA(self):
result = self._PointA#creates a new 1 wrapper containing a pointer to the wrapped C++ object of self
result._myParentStruct = self#we add a reference to the parent here to work around lifetime issues
return result
def _Set_PointA(self, value):
self._PointA = value
PointA = property(_Get_PointA, _Set_PointA )
def _Get_PointB(self):
result = self._PointB#creates a new 1 wrapper containing a pointer to the wrapped C++ object of self
result._myParentStruct = self#we add a reference to the parent here to work around lifetime issues
return result
def _Set_PointB(self, value):
self._PointB = value
PointB = property(_Get_PointB, _Set_PointB )
def __str__(self):
result = "PointA: ({0}); PointB: ({1})".format(self.PointA,self.PointB)
return result
def __init__(self, *args):
r"""
Pylon::DataProcessing::SLineF2D::SLineF2D
Creates a line and initializes it.
Parameters
----------
* `pointA` :
Point A of the line.
* `pointB` :
Point B of the line.
"""
_pylondataprocessing.LineF2D_swiginit(self, _pylondataprocessing.new_LineF2D(*args))
__swig_destroy__ = _pylondataprocessing.delete_LineF2D
# Register LineF2D in _pylondataprocessing:
_pylondataprocessing.LineF2D_swigregister(LineF2D)
class EllipseF(object):
r"""
The data of a CVariant object with the VariantDataType_EllipseF data type.
C++ includes: EllipseF.h
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
_Center = property(_pylondataprocessing.EllipseF__Center_get, _pylondataprocessing.EllipseF__Center_set)
Radius1 = property(_pylondataprocessing.EllipseF_Radius1_get, _pylondataprocessing.EllipseF_Radius1_set)
Radius2 = property(_pylondataprocessing.EllipseF_Radius2_get, _pylondataprocessing.EllipseF_Radius2_set)
Rotation = property(_pylondataprocessing.EllipseF_Rotation_get, _pylondataprocessing.EllipseF_Rotation_set)
def _Get_Center(self):
result = self._Center#creates a new 1 wrapper containing a pointer to the wrapped C++ object of self
result._myParentStruct = self#we add a reference to the parent here to work around lifetime issues
return result
def _Set_Center(self, value):
self._Center = value
Center = property(_Get_Center, _Set_Center )
def __str__(self):
result = "Center: ({0}); Radius1 = {1}; Radius2 = {2}; Rotation = {3} rad".format(self.Center, self.Radius1, self.Radius2, self.Rotation)
return result
def __init__(self, *args):
r"""
Pylon::DataProcessing::SEllipseF::SEllipseF
Creates an ellipse and initializes it.
Parameters
----------
* `center` :
The center of the ellipse.
* `radius1` :
The radius of the ellipse that is parallel to the x axis when the ellipse is
in its original state, i.e., it hasn't been rotated.
* `radius2` :
The radius of the ellipse that is parallel to the y axis when the ellipse is
in its original state, i.e., it hasn't been rotated.
* `rotation` :
The rotation of the ellipse in radiant.
"""
_pylondataprocessing.EllipseF_swiginit(self, _pylondataprocessing.new_EllipseF(*args))
__swig_destroy__ = _pylondataprocessing.delete_EllipseF
# Register EllipseF in _pylondataprocessing:
_pylondataprocessing.EllipseF_swigregister(EllipseF)
class CircleF(object):
r"""
The data of a CVariant object with the VariantDataType_CircleF data type.
C++ includes: CircleF.h
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
_Center = property(_pylondataprocessing.CircleF__Center_get, _pylondataprocessing.CircleF__Center_set)
Radius = property(_pylondataprocessing.CircleF_Radius_get, _pylondataprocessing.CircleF_Radius_set)
def _Get_Center(self):
result = self._Center#creates a new 1 wrapper containing a pointer to the wrapped C++ object of self
result._myParentStruct = self#we add a reference to the parent here to work around lifetime issues
return result
def _Set_Center(self, value):
self._Center = value
Center = property(_Get_Center, _Set_Center )
def __str__(self):
result = "Center: ({0}); Radius = {1}".format(self.Center, self.Radius)
return result
def __init__(self, *args):
r"""
Pylon::DataProcessing::SCircleF::SCircleF
Creates a circle and initializes it.
Parameters
----------
* `center` :
The center of the circle.
* `radius` :
The radius of the circle.
"""
_pylondataprocessing.CircleF_swiginit(self, _pylondataprocessing.new_CircleF(*args))
__swig_destroy__ = _pylondataprocessing.delete_CircleF
# Register CircleF in _pylondataprocessing:
_pylondataprocessing.CircleF_swigregister(CircleF)
class RectangleF(object):
r"""
The data of a CVariant object with the VariantDataType_RectangleF data type.
C++ includes: RectangleF.h
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
_Center = property(_pylondataprocessing.RectangleF__Center_get, _pylondataprocessing.RectangleF__Center_set)
Width = property(_pylondataprocessing.RectangleF_Width_get, _pylondataprocessing.RectangleF_Width_set)
Height = property(_pylondataprocessing.RectangleF_Height_get, _pylondataprocessing.RectangleF_Height_set)
Rotation = property(_pylondataprocessing.RectangleF_Rotation_get, _pylondataprocessing.RectangleF_Rotation_set)
def _Get_Center(self):
result = self._Center#creates a new 1 wrapper containing a pointer to the wrapped C++ object of self
result._myParentStruct = self#we add a reference to the parent here to work around lifetime issues
return result
def _Set_Center(self, value):
self._Center = value
Center = property(_Get_Center, _Set_Center )
def __str__(self):
result = "Center: ({0}); Width = {1}; Height = {2}; Rotation = {3} rad".format(self.Center, self.Width, self.Height, self.Rotation)
return result
def __init__(self, *args):
r"""
Pylon::DataProcessing::SRectangleF::SRectangleF
Creates a rectangle and initializes it.
Parameters
----------
* `center` :
The center of the rectangle.
* `width` :
The width of the rectangle.
* `height` :
The height of the rectangle.
* `rotation` :
The rotation of the rectangle in radiant.
"""
_pylondataprocessing.RectangleF_swiginit(self, _pylondataprocessing.new_RectangleF(*args))
__swig_destroy__ = _pylondataprocessing.delete_RectangleF
# Register RectangleF in _pylondataprocessing:
_pylondataprocessing.RectangleF_swigregister(RectangleF)
class RegionEntryRLE32(object):
r"""
Entry for the run-length encoded pixels of a region. Region entries must be
sorted line-wise starting with line 0 and then column-wise starting with column
0.
C++ includes: RegionEntry.h
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
StartX = property(_pylondataprocessing.RegionEntryRLE32_StartX_get, _pylondataprocessing.RegionEntryRLE32_StartX_set)
EndX = property(_pylondataprocessing.RegionEntryRLE32_EndX_get, _pylondataprocessing.RegionEntryRLE32_EndX_set)
Y = property(_pylondataprocessing.RegionEntryRLE32_Y_get, _pylondataprocessing.RegionEntryRLE32_Y_set)
def __init__(self, *args):
_pylondataprocessing.RegionEntryRLE32_swiginit(self, _pylondataprocessing.new_RegionEntryRLE32(*args))
def __str__(self):
result = "StartX = {0}; EndX = {1}; Y = {2}".format(self.StartX, self.EndX, self.Y)
return result
__swig_destroy__ = _pylondataprocessing.delete_RegionEntryRLE32
# Register RegionEntryRLE32 in _pylondataprocessing:
_pylondataprocessing.RegionEntryRLE32_swigregister(RegionEntryRLE32)
PYLON_REGIONTYPE_CUSTOM = _pylondataprocessing.PYLON_REGIONTYPE_CUSTOM
RegionType_Undefined = _pylondataprocessing.RegionType_Undefined
RegionType_RLE32 = _pylondataprocessing.RegionType_RLE32
def IsValidRegionType(regionType):
r"""
Pylon::DataProcessing::IsValidRegionType
Checks whether a given region type is valid.
Parameters
----------
* `regionType` :
The region type to check.
Returns
-------
Returns true if the region type is valid or false otherwise.
\error Doesn't throw C++ exceptions.
"""
return _pylondataprocessing.IsValidRegionType(regionType)
def BitPerRegionElement(regionType):
r"""
Pylon::DataProcessing::BitPerRegionElement
Determines the element size in bits of a given region type.
Parameters
----------
* `regionType` :
The region type to get the element size of.
pre:
* The region type must be valid.
Returns
-------
Returns the size of an element of a region type in bits.
\error Throws an exception if the preconditions aren't met.
"""
return _pylondataprocessing.BitPerRegionElement(regionType)
def ComputeRegionSize(regionType, elementCount):
r"""
Pylon::DataProcessing::ComputeRegionSize
Determines the required data size of a region with a given region type and
number of region elements.
Parameters
----------
* `regionType` :
The region type to be used.
* `elementCount` :
The number of region elements.
pre:
* The region type must be valid.
Returns
-------
Returns the required data size of a region with a given region type and number
of region elements.
\error Throws an exception if the preconditions aren't met.
"""
return _pylondataprocessing.ComputeRegionSize(regionType, elementCount)
def ComputeRegionEntryCount(regionType, regionSize):
return _pylondataprocessing.ComputeRegionEntryCount(regionType, regionSize)
class TransformationData(object):
r"""
Describes a transformation data class that represents a mathematical matrix with
a specific number of columns and rows.
\threading The CTransformationData class isn't thread-safe.
C++ includes: TransformationData.h
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
def __init__(self, *args):
r"""
Pylon::DataProcessing::CTransformationData::CTransformationData
Move constructs the transformation data properties and values from the source
transformation data.
Parameters
----------
* `source` :
The source transformation data (will be invalid after the call).
\error Doesn't throw C++ exceptions.
"""
_pylondataprocessing.TransformationData_swiginit(self, _pylondataprocessing.new_TransformationData(*args))
__swig_destroy__ = _pylondataprocessing.delete_TransformationData
def Reset(self, columns, rows):
r"""
Pylon::DataProcessing::CTransformationData::Reset
Resets the transformation data using the specified number of columns and rows.
Parameters
----------
* `columns` :
The number of columns that the transformation data should have (must be
higher than 0).
* `rows` :
The number of rows that the transformation data should have (must be higher
than 0).
pre:
* Argument columns must be higher than 0.
* Argument rows must be higher than 0.
post:
* IsValid() will return true.
* All entries will be reset to 0.0.
\error Throws an exception if the preconditions aren't met.
"""
return _pylondataprocessing.TransformationData_Reset(self, columns, rows)
def IsValid(self):
r"""
Pylon::DataProcessing::CTransformationData::IsValid
Can be used to check whether the transformation data is valid.
Returns
-------
Returns false if the transformation data is invalid.
\error Doesn't throw C++ exceptions.
"""
return _pylondataprocessing.TransformationData_IsValid(self)
def GetColumnCount(self):
r"""
Pylon::DataProcessing::CTransformationData::GetColumnCount
Get the number of columns of the transformation data.
Returns
-------
Returns the number of columns or 0 if the transformation data is invalid.
\error Doesn't throw C++ exceptions.
"""
return _pylondataprocessing.TransformationData_GetColumnCount(self)
def GetRowCount(self):
r"""
Pylon::DataProcessing::CTransformationData::GetRowCount
Get the number of rows of the transformation data.
Returns
-------
Returns the number of rows or 0 if the transformation data is invalid.
\error Doesn't throw C++ exceptions.
"""
return _pylondataprocessing.TransformationData_GetRowCount(self)
def GetEntry(self, column, row):
r"""
Pylon::DataProcessing::CTransformationData::GetEntry
Get an entry at a specific position of the transformation data.
Parameters
----------
* `column` :
The column of the entry to retrieve (must be lower than number of columns).
* `row` :
The row of the entry to retrieve (must be lower than number of rows).
pre:
* Transformation data must be valid.
* Argument column must be lower than number of columns.
* Argument row must be lower than number of rows.
Returns
-------
Returns the entry retrieved at the specified position.
\error Throws an exception if the preconditions aren't met.
"""
return _pylondataprocessing.TransformationData_GetEntry(self, column, row)
def SetEntry(self, column, row, value):
r"""
Pylon::DataProcessing::CTransformationData::SetEntry
Set an entry at a specific position in the transformation data.
Parameters
----------
* `column` :
The column of the entry to set (must be lower than number of columns).
* `row` :
The row of the entry to set (must be lower than number of rows).
* `value` :
The new value to set the entry to.
pre:
* Transformation data must be valid.
* Argument column must be lower than number of columns.
* Argument row must be lower than number of rows.
\error Throws an exception if the preconditions aren't met.
"""
return _pylondataprocessing.TransformationData_SetEntry(self, column, row, value)
def __str__(self):
resultList = []
for rowIndex in range(self.RowCount):
if rowIndex != 0:
resultList.append("\n")
for columnIndex in range(self.ColumnCount):
if columnIndex != 0:
resultList.append(", ")
resultList.append(str(self.GetEntry(columnIndex, rowIndex)))
result = "".join(resultList)
return result
# Register TransformationData in _pylondataprocessing:
_pylondataprocessing.TransformationData_swigregister(TransformationData)
class Region(object):
r"""
Describes a region and takes care of the buffer handling and lifetime.
* Automatically handles size and lifetime of the region buffer.
* Allows you to connect user buffers or buffers provided by third-party
software packages.
par: Buffer Handling:
The buffer that is automatically created by the CRegion class or is replaced
by a larger buffer if Reset() is called (only if required). The size of the
allocated buffer is never decreased. Referenced user buffers are never
automatically replaced by a larger buffer. See the Reset() method for more
details. The Release() method can be used to detach a user buffer or to free
an allocated buffer.
\threading The CRegion class isn't thread-safe.
C++ includes: Region.h
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
def __init__(self, *args):
r"""
Pylon::DataProcessing::CRegion::CRegion
Copies the region properties and creates a reference to the buffer of the source
region.
Parameters
----------
* `source` :
The source region.
post:
* Another reference to the source region buffer is created.
* Creates an invalid region if the source region is invalid.
\error Doesn't throw C++ exceptions.
"""
_pylondataprocessing.Region_swiginit(self, _pylondataprocessing.new_Region(*args))
__swig_destroy__ = _pylondataprocessing.delete_Region
def CopyRegion(self, *args):
r"""
Pylon::DataProcessing::CRegion::CopyRegion
Copies the region data from a buffer provided.
This method is used for making a full copy of a region. Calls the Reset() method
to set the same region properties as the source region and copies the region
data.
Parameters
----------
* `pBuffer` :
The pointer to the buffer of the source region.
* `dataSize` :
The size of the region in bytes. For run-length encoded formats, the size in
bytes defines the number of entries, e.g., 24 bytes result in 2 RLE32
entries for RegionType_RLE32.
* `regionType` :
The type of the new region.
* `referenceWidth` :
The width of the source of the region if available, 0 otherwise.
* `referenceHeight` :
The height of the source of the region if available, 0 otherwise.
* `boundingBoxTopLeftX` :
The smallest horizontal pixel position of the region if available, 0
otherwise.
* `boundingBoxTopLeftY` :
The smallest vertical pixel position of the region if available, 0
otherwise.
* `boundingBoxWidth` :
The width of the bounding box of the region if available, 0 otherwise.
* `boundingBoxHeight` :
The height of the bounding box of the region if available, 0 otherwise.
pre:
* The region type must be valid.
* `pBuffer` must not be NULL.
* The preconditions of the Reset() method must be met.
* Either all bounding box values are 0, or `boundingBoxWidth` and
`boundingBoxHeight` are both greater than 0.
post: A copy of the source region buffer's region is made.
\error Throws an exception if no buffer with the required size could be
allocated. Throws an exception if the preconditions of the Reset() method aren't
met.
"""
return _pylondataprocessing.Region_CopyRegion(self, *args)
def IsValid(self):
r"""
Pylon::DataProcessing::CRegion::IsValid
Can be used to check whether a region is valid.
Returns
-------
Returns false if the region is invalid.
\error Doesn't throw C++ exceptions.
"""
return _pylondataprocessing.Region_IsValid(self)
def IsReadOnly(self):
r"""
Pylon::DataProcessing::CRegion::IsReadOnly
Can be used to check whether a region data buffer is read-only.
Returns
-------
Returns true if the region data buffer is read-only or the region is invalid.
\error Doesn't throw C++ exceptions.
"""
return _pylondataprocessing.Region_IsReadOnly(self)
def GetRegionType(self):
r"""
Pylon::DataProcessing::CRegion::GetRegionType
Get the current region type.
Returns
-------
Returns the Region type or RegionType_Undefined if the region is invalid.
\error Doesn't throw C++ exceptions.
"""
return _pylondataprocessing.Region_GetRegionType(self)
def IsUserBufferAttached(self):
r"""
Pylon::DataProcessing::CRegion::IsUserBufferAttached
Indicates whether a user buffer is attached.
Returns
-------
Returns true if a user buffer is attached. Returns false if the region is
invalid.
\error Doesn't throw C++ exceptions.
"""
return _pylondataprocessing.Region_IsUserBufferAttached(self)
def GetAllocatedBufferSize(self):
r"""
Pylon::DataProcessing::CRegion::GetAllocatedBufferSize
Returns the size of the buffer used.
This method is useful when working with so-called user buffers.
Returns
-------
Returns the size of the buffer used in bytes or 0 if the region is invalid.
\error Doesn't throw C++ exceptions.
"""
return _pylondataprocessing.Region_GetAllocatedBufferSize(self)
def GetDataSize(self):
r"""
Pylon::DataProcessing::CRegion::GetDataSize
Get the size of the region in bytes.
Returns
-------
Returns the size of the region in bytes or 0 if the region is invalid.
\error Doesn't throw C++ exceptions.
"""
return _pylondataprocessing.Region_GetDataSize(self)
def IsUnique(self):
r"""
Pylon::DataProcessing::CRegion::IsUnique
Indicates whether the referenced buffer is only referenced by this region.
Returns
-------
Returns true if the referenced buffer is only referenced by this region. Returns
false if the region is invalid.
\error Doesn't throw C++ exceptions.
"""
return _pylondataprocessing.Region_IsUnique(self)
def HasReferenceSize(self):
r"""
Pylon::DataProcessing::CRegion::HasReferenceSize
Indicates whether reference size information is available.
Returns
-------
Returns true if reference width or height aren't equal to zero. Returns false if
the region is invalid.
\error Doesn't throw C++ exceptions.
"""
return _pylondataprocessing.Region_HasReferenceSize(self)
def GetReferenceWidth(self):
r"""
Pylon::DataProcessing::CRegion::GetReferenceWidth
Get the reference width in pixels.
Returns
-------
Returns the reference width or 0 if the region is invalid.
\error Doesn't throw C++ exceptions.
"""
return _pylondataprocessing.Region_GetReferenceWidth(self)
def GetReferenceHeight(self):
r"""
Pylon::DataProcessing::CRegion::GetReferenceHeight
Get the reference height in pixels.
Returns
-------
Returns the reference height or 0 if the region is invalid.
\error Doesn't throw C++ exceptions.
"""
return _pylondataprocessing.Region_GetReferenceHeight(self)
def HasBoundingBox(self):
r"""
Pylon::DataProcessing::CRegion::HasBoundingBox
Indicates whether bounding box information is available.
Returns
-------
Returns true if boundingBoxWidth and boundingBoxHeight aren't equal to zero.
Returns false if the region is invalid.
\error Doesn't throw C++ exceptions.
"""
return _pylondataprocessing.Region_HasBoundingBox(self)
def GetBoundingBoxTopLeftX(self):
r"""
Pylon::DataProcessing::CRegion::GetBoundingBoxTopLeftX
Use this method to get the smallest horizontal pixel position of the region.
\error Doesn't throw C++ exceptions.
Returns
-------
Returns the smallest horizontal pixel position of the region. Returns 0 if the
region is invalid.
"""
return _pylondataprocessing.Region_GetBoundingBoxTopLeftX(self)
def GetBoundingBoxTopLeftY(self):
r"""
Pylon::DataProcessing::CRegion::GetBoundingBoxTopLeftY
Use this method to get the smallest vertical pixel position of the region.
\error Doesn't throw C++ exceptions.
Returns
-------
Returns the smallest vertical pixel position of the region. Returns 0 if the
region is invalid.
"""
return _pylondataprocessing.Region_GetBoundingBoxTopLeftY(self)
def GetBoundingBoxWidth(self):
r"""
Pylon::DataProcessing::CRegion::GetBoundingBoxWidth
Use this method to get the width of the region's bounding box. \error Doesn't
throw C++ exceptions.
Returns
-------
Returns the width of the region's bounding box. Returns 0 if the region is
invalid.
"""
return _pylondataprocessing.Region_GetBoundingBoxWidth(self)
def GetBoundingBoxHeight(self):
r"""
Pylon::DataProcessing::CRegion::GetBoundingBoxHeight
Use this method to get the height of the region's bounding box. \error Doesn't
throw C++ exceptions.
Returns
-------
Returns the height of the region's bounding box. Returns 0 if the region is
invalid.
"""
return _pylondataprocessing.Region_GetBoundingBoxHeight(self)
def Reset(self, regionType, dataSize, referenceWidth=0, referenceHeight=0, boundingBoxTopLeftX=0, boundingBoxTopLeftY=0, boundingBoxWidth=0, boundingBoxHeight=0):
r"""
Pylon::DataProcessing::CRegion::Reset
Resets the region properties and allocates a new buffer if required.
Parameters
----------
* `regionType` :
The type of the new region.
* `dataSize` :
The size of the region in bytes. For run-length encoded formats, the size in
bytes defines the number of entries, e.g., 24 bytes result in 2 RLE32
entries for RegionType_RLE32.
* `referenceWidth` :
The width of the source of the region if available, 0 otherwise.
* `referenceHeight` :
The height of the source of the region if available, 0 otherwise.
* `boundingBoxTopLeftX` :
The smallest horizontal pixel position of the region if available, 0
otherwise.
* `boundingBoxTopLeftY` :
The smallest vertical pixel position of the region if available, 0
otherwise.
* `boundingBoxWidth` :
The width of the bounding box of the region if available, 0 otherwise.
* `boundingBoxHeight` :
The height of the bounding box of the region if available, 0 otherwise.
pre:
* The region type must be valid.
* If a user buffer is referenced, this buffer must not be referenced by
another pylon region. See the IsUnique() and IsUserBufferAttached()
methods.
* If a user buffer is referenced, this buffer must be large enough to hold
the destination region. See the GetAllocatedBufferSize() and
IsUserBufferAttached() methods.
* Either all bounding box values are 0, or `boundingBoxWidth` and
`boundingBoxHeight` are both greater than 0.
post:
* If the previously referenced buffer is also referenced by another pylon
region, a new buffer has been allocated.
* If the previously referenced buffer isn't large enough to hold a region
with the specified properties, a new buffer has been allocated.
* If no buffer has been allocated before, a buffer has been allocated.
\error Throws an exception if the preconditions aren't met. Throws an exception
if no buffer with the required size could be allocated.
"""
return _pylondataprocessing.Region_Reset(self, regionType, dataSize, referenceWidth, referenceHeight, boundingBoxTopLeftX, boundingBoxTopLeftY, boundingBoxWidth, boundingBoxHeight)
def Resize(self, dataSize):
r"""
Pylon::DataProcessing::CRegion::Resize
Resizes the region.
Parameters
----------
* `dataSize` :
The size of the region in bytes. For run-length encoded formats, the size in
bytes defines the number of entries, e.g., 24 bytes result in 2 RLE32
entries for RegionType_RLE32.
pre:
* The region must be valid.
* If a user buffer is referenced, this buffer must not be referenced by
another pylon region. See the IsUnique() and IsUserBufferAttached()
methods.
* If a user buffer is referenced, this buffer must be large enough to hold
the new data size. See the GetAllocatedBufferSize() and
IsUserBufferAttached() methods.
post:
* If the previously referenced buffer is also referenced by another pylon
region, a new buffer has been allocated.
* A new buffer is allocated if necessary.
* If a new buffer is allocated, the old data (old data size bytes) is
copied to the new buffer.
* The data size is changed.
"""
return _pylondataprocessing.Region_Resize(self, dataSize)
def Release(self):
r"""
Pylon::DataProcessing::CRegion::Release
Releases the region buffer and resets to an invalid region.
post:
* RegionType = RegionType_Undefined.
* DataSize=0.
* ReferenceWidth = 0.
* ReferenceHeight = 0.
* boundingBoxTopLeftX = 0.
* boundingBoxTopLeftY = 0.
* boundingBoxWidth = 0.
* boundingBoxHeight = 0.
* No buffer is allocated.
\error Doesn't throw C++ exceptions.
"""
return _pylondataprocessing.Region_Release(self)
def GetBuffer(self):
return _pylondataprocessing.Region_GetBuffer(self)
def GetMemoryView(self):
return _pylondataprocessing.Region_GetMemoryView(self)
def ToArray(self):
return _pylondataprocessing.Region_ToArray(self)
# Register Region in _pylondataprocessing:
_pylondataprocessing.Region_swigregister(Region)
VariantDataType_Int64 = _pylondataprocessing.VariantDataType_Int64
VariantDataType_UInt64 = _pylondataprocessing.VariantDataType_UInt64
VariantDataType_Boolean = _pylondataprocessing.VariantDataType_Boolean
VariantDataType_String = _pylondataprocessing.VariantDataType_String
VariantDataType_Float = _pylondataprocessing.VariantDataType_Float
VariantDataType_PylonImage = _pylondataprocessing.VariantDataType_PylonImage
VariantDataType_Region = _pylondataprocessing.VariantDataType_Region
VariantDataType_TransformationData = _pylondataprocessing.VariantDataType_TransformationData
VariantDataType_Composite = _pylondataprocessing.VariantDataType_Composite
VariantDataType_PointF2D = _pylondataprocessing.VariantDataType_PointF2D
VariantDataType_LineF2D = _pylondataprocessing.VariantDataType_LineF2D
VariantDataType_RectangleF = _pylondataprocessing.VariantDataType_RectangleF
VariantDataType_CircleF = _pylondataprocessing.VariantDataType_CircleF
VariantDataType_EllipseF = _pylondataprocessing.VariantDataType_EllipseF
VariantDataType_None = _pylondataprocessing.VariantDataType_None
VariantDataType_Generic = _pylondataprocessing.VariantDataType_Generic
VariantDataType_Unsupported = _pylondataprocessing.VariantDataType_Unsupported
VariantContainerType_None = _pylondataprocessing.VariantContainerType_None
VariantContainerType_Array = _pylondataprocessing.VariantContainerType_Array
VariantContainerType_Unsupported = _pylondataprocessing.VariantContainerType_Unsupported
class Variant(object):
r"""
A variant class that can be used to represent any data type processed by a
`CRecipe`.
\threading The `CVariant` class isn't thread-safe.
C++ includes: Variant.h
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
def __init__(self, *args):
r"""
Pylon::DataProcessing::CVariant::CVariant
Move constructs a variant.
Parameters
----------
* `other` :
The variant to move the content from.
post:
* The content of the `other` variant passed will be moved to the new
instance without any copy.
* The `other` variant will be reset to its initial state afterwards.
\error Doesn't throw C++ exceptions.
"""
_pylondataprocessing.Variant_swiginit(self, _pylondataprocessing.new_Variant(*args))
def IsEqualInstance(self, rhs):
r"""
Pylon::DataProcessing::CVariant::IsEqualInstance
Compares a variant object.
Parameters
----------
* `rhs` :
The variant to compare to.
Returns
-------
`true` if the same data in variant objects is referenced.
\error Doesn't throw C++ exceptions.
"""
return _pylondataprocessing.Variant_IsEqualInstance(self, rhs)
def __eq__(self, rhs):
return _pylondataprocessing.Variant___eq__(self, rhs)
def Copy(self):
r"""
Pylon::DataProcessing::CVariant::Copy
Returns a deep copy of the variant object.
Returns
-------
A deep copy of the variant object.
post:
* The value the variant references to is copied.
* If the current variant references a subvalue of a composite type, only
the subtype of the composite type is copied.
* The deep copy is held by the variant returned.
\error Doesn't throw C++ exceptions.
"""
return _pylondataprocessing.Variant_Copy(self)
__swig_destroy__ = _pylondataprocessing.delete_Variant
def GetDataType(self):
r"""
Pylon::DataProcessing::CVariant::GetDataType
Returns the data type of the variant.
Returns
-------
The data type of the data held.
\error Doesn't throw C++ exceptions.
"""
return _pylondataprocessing.Variant_GetDataType(self)
def GetContainerType(self):
r"""
Pylon::DataProcessing::CVariant::GetContainerType
Returns the container type of the variant.
Returns
-------
The container type of the data held.
\error Doesn't throw C++ exceptions.
"""
return _pylondataprocessing.Variant_GetContainerType(self)
def GetNumSubValues(self):
r"""
Pylon::DataProcessing::CVariant::GetNumSubValues
Returns the number of subvalues.
Returns
-------
The number of subvalues. For example, returns 2 for a PointF{double X, double
Y}.
\error Doesn't throw C++ exceptions.
"""
return _pylondataprocessing.Variant_GetNumSubValues(self)
def GetSubValueName(self, index):
r"""
Pylon::DataProcessing::CVariant::GetSubValueName
Returns the name of a subvalue of the value referenced by the variant.
note: The position of a subvalue is not fixed and can change for different
versions of pylon.
Parameters
----------
* `index` :
The index.
Returns
-------
The name of a subvalue of the value referenced by the variant. For example,
returns "X" for a PointF{double X, double Y} if 0 is passed as `index`. For
example, returns "Y" for a PointF{double X, double Y} if 1 is passed as
`index`.
pre:
* `GetNumSubValues()` returns a value larger than zero.
* The `index` passed is smaller than the value returned by
`GetNumSubValues()`.
\error Throws an exception if the preconditions aren't met.
"""
return _pylondataprocessing.Variant_GetSubValueName(self, index)
def HasSubValue(self, subValueName):
r"""
Pylon::DataProcessing::CVariant::HasSubValue
Returns `true` if a sub alue of the value referenced by the variant with the
name passed exists.
Parameters
----------
* `subValueName` :
The name of the subvalue.
Returns
-------
`true` if a subvalue of the value referenced by the variant with the name passed
exists. For example, returns `true` for a PointF{double X, double Y} if "X" is
passed. For example, returns `false` for a PointF{double X, double Y} if "Z"
is passed.
\error Doesn't throw C++ exceptions.
"""
return _pylondataprocessing.Variant_HasSubValue(self, subValueName)
def GetSubValue(self, subValueName):
r"""
Pylon::DataProcessing::CVariant::GetSubValue
Returns a variant object referencing the subvalue.
Parameters
----------
* `subValueName` :
The name of the subvalue.
Returns
-------
A variant object referencing the subvalue with name `subValueName`.
pre:
* A subvalue of the value referenced by the variant with the
`subValueName` passed exists.
\error Throws an exception if the preconditions aren't met.
"""
return _pylondataprocessing.Variant_GetSubValue(self, subValueName)
def SetSubValue(self, subValueName, newValue):
r"""
Pylon::DataProcessing::CVariant::SetSubValue
Changes the value of a subvalue of the value referenced by this variant.
Parameters
----------
* `subValueName` :
The name of the subvalue.
* `newValue` :
The new value for the subvalue.
pre:
* A subvalue with the `subValueName` passed exists in the value referenced
by the variant.
* `newValue` must be compatible in type with the subvalue to change.
post:
* The subvalue has been changed to the new value.
\error Throws an exception if the preconditions aren't met.
"""
return _pylondataprocessing.Variant_SetSubValue(self, subValueName, newValue)
def GetValueName(self, pOptionalRootValueName=None):
r"""
Pylon::DataProcessing::CVariant::GetValueName
Returns the name of the value referenced by the variant.
Parameters
----------
* `pOptionalRootValueName` :
The name of the root value that can optionally be provided by the user. The
name of root value depends on the context the variant is used in. For
example, "lineStartPoint" can be used for a PointF{double X, double Y}.
Returns
-------
The name of the value referenced by the variant if it references a subvalue.
`pOptionalRootValueName` or an empty string if it doesn't reference a subvalue.
The name of the value with index in square brackets, e.g., `line`[2], referenced
by the variant if it references an array item.
\error Doesn't throw C++ exceptions.
"""
return _pylondataprocessing.Variant_GetValueName(self, pOptionalRootValueName)
def IsArray(self):
r"""
Pylon::DataProcessing::CVariant::IsArray
Returns `true` if the value referenced is an array.
Returns
-------
`true` if the value referenced is an array.
\error Doesn't throw C++ exceptions.
"""
return _pylondataprocessing.Variant_IsArray(self)
def GetNumArrayValues(self):
r"""
Pylon::DataProcessing::CVariant::GetNumArrayValues
Returns the number of values in an array.
Returns
-------
The number of values in an array. Returns 0 if the value is not an array.
\error Doesn't throw C++ exceptions.
"""
return _pylondataprocessing.Variant_GetNumArrayValues(self)
def GetArrayValue(self, index):
r"""
Pylon::DataProcessing::CVariant::GetArrayValue
Returns a variant object referencing the array item value.
Parameters
----------
* `index` :
The index.
Returns
-------
A variant object referencing the array item value.
pre:
* `GetNumArrayValues()` returns a value larger than zero.
* The `index` passed is smaller than the value returned by
`GetNumArrayValues()`.
\error Throws an exception if the preconditions aren't met.
"""
return _pylondataprocessing.Variant_GetArrayValue(self, index)
def ChangeArraySize(self, size):
r"""
Pylon::DataProcessing::CVariant::ChangeArraySize
Changes the size of an array so that it contains `size` items.
If `size` is smaller than the current array size, the array size is reduced to
its first `size` elements, removing those beyond.
If `size` is greater than the current array size, the array size is increased by
inserting as many elements as needed at the end to reach a size of `size`.
Inserted elements will be of type `VariantDataType_None`.
Parameters
----------
* `size` :
The new size.
pre:
* `IsArray()` returns `true`.
post:
* The array size has changed.
* Any old values inside the array are preserved if the new `size` is
greater or equal than the previous array size.
\error Throws an exception if:
* The preconditions aren't met.
* Memory allocation fails.
"""
return _pylondataprocessing.Variant_ChangeArraySize(self, size)
def SetArrayItemValue(self, index, newValue):
r"""
Pylon::DataProcessing::CVariant::SetArrayItemValue
Changes the value of an array item of the value referenced by this variant.
Parameters
----------
* `index` :
The index.
* `newValue` :
The new value for the array item.
pre:
* `IsArray()` returns `true`.
* `GetNumArrayValues()` is greater than `index`.
* The `newValue` must be compatible in type with the array item to change.
post:
* The entry in the array at the given index has been changed to the new
value.
\error Throws an exception if the preconditions aren't met.
"""
return _pylondataprocessing.Variant_SetArrayItemValue(self, index, newValue)
def CanConvert(self, targetType):
r"""
Pylon::DataProcessing::CVariant::CanConvert
Checks whether the value can be converted to target type.
Parameters
----------
* `targetType` :
The target variant data type for conversion.
Returns
-------
`true` if the value can be converted to target type.
\error Doesn't throw C++ exceptions.
"""
return _pylondataprocessing.Variant_CanConvert(self, targetType)
def Convert(self, targetType):
r"""
Pylon::DataProcessing::CVariant::Convert
Converts value to target type.
`CanConvert()` can be used to check whether this `CVariant` can be converted to
`targetType`.
Parameters
----------
* `targetType` :
The target variant data type for conversion.
Returns
-------
A variant object referencing the converted item value.
pre:
* `CanConvert()` returns `true`.
\error Throws an exception if the preconditions aren't met.
"""
return _pylondataprocessing.Variant_Convert(self, targetType)
def ToBool(self):
r"""
Pylon::DataProcessing::CVariant::ToBool
Returns the value of the variant for a basic type as bool.
note: Conversions exist for `VariantDataType_Boolean`, `VariantDataType_Int64`,
`VariantDataType_UInt64`, `VariantDataType_Float`, and
`VariantDataType_String`. Can be checked with
`CanConvert(VariantDataType_Boolean)`.
Returns
-------
The value of the variant as `bool`.
pre:
* `IsArray()` returns `false`.
* The type of this `CVariant` is `VariantDataType_Boolean`,
`VariantDataType_Int64`, `VariantDataType_UInt64`,
`VariantDataType_Float`, or `VariantDataType_String`.
* `CanConvert(VariantDataType_Boolean)` returns `true`.
\error Throws an exception if:
* The preconditions aren't met.
* The conversion fails.
"""
return _pylondataprocessing.Variant_ToBool(self)
def ToInt64(self):
r"""
Pylon::DataProcessing::CVariant::ToInt64
Returns the value of the variant for a basic type as int64_t.
note: The value is undefined if a conversion exceeds the range of the target
value.
Conversions exist for `VariantDataType_Boolean`, `VariantDataType_Int64`,
`VariantDataType_UInt64`, `VariantDataType_Float`, and `VariantDataType_String`.
Can be checked with `CanConvert(VariantDataType_Int64)`.
Returns
-------
Returns the value of the variant as int64_t.
pre:
* `IsArray()` returns `false`.
* The type of this `CVariant` is `VariantDataType_Boolean`,
`VariantDataType_Int64`, `VariantDataType_UInt64`,
`VariantDataType_Float`, or `VariantDataType_String`.
* `CanConvert(VariantDataType_Int64)` returns `true`.
\error Throws an exception if:
* The preconditions aren't met.
* The conversion fails.
"""
return _pylondataprocessing.Variant_ToInt64(self)
def ToUInt64(self):
r"""
Pylon::DataProcessing::CVariant::ToUInt64
Returns the value of the variant for a basic type as uint64_t.
note: The value is undefined if a conversion exceeds the range of the target
value.
Conversions exist for `VariantDataType_Boolean`, `VariantDataType_Int64`,
`VariantDataType_UInt64`, `VariantDataType_Float`, or `VariantDataType_String`.
Can be checked with `CanConvert(VariantDataType_UInt64)`.
Returns
-------
Returns the value of the variant as uint64_t.
pre:
* `IsArray()` returns `false`.
* The type of this `CVariant` is `VariantDataType_Boolean`,
`VariantDataType_Int64`, `VariantDataType_UInt64`,
`VariantDataType_Float`, or `VariantDataType_String`.
* `CanConvert(VariantDataType_UInt64)` returns `true`.
\error Throws an exception if:
* The preconditions aren't met.
* The conversion fails.
"""
return _pylondataprocessing.Variant_ToUInt64(self)
def ToDouble(self):
r"""
Pylon::DataProcessing::CVariant::ToDouble
Returns the value of the variant for a basic type as double.
note: Conversions exist for `VariantDataType_Boolean`, `VariantDataType_Int64`,
`VariantDataType_UInt64`, `VariantDataType_Float`, or
`VariantDataType_String`. Can be checked with
`CanConvert(VariantDataType_Float)`.
Returns
-------
Returns the value of the variant as double.
pre:
* `IsArray()` returns `false`.
* The type of this `CVariant` is `VariantDataType_Boolean`,
`VariantDataType_Int64`, `VariantDataType_UInt64`,
`VariantDataType_Float`, or `VariantDataType_String`.
* `CanConvert(VariantDataType_Float)` returns `true`.
\error Throws an exception if:
* The preconditions aren't met.
* The conversion fails.
"""
return _pylondataprocessing.Variant_ToDouble(self)
def ToString(self):
r"""
Pylon::DataProcessing::CVariant::ToString
Returns the value of the variant for a basic type as string.
note: The string conversion always uses a dot for decimals.
Conversions exist for `VariantDataType_Boolean`, `VariantDataType_Int64`,
`VariantDataType_UInt64`, `VariantDataType_Float`, or `VariantDataType_String`.
Can be checked with `CanConvert(VariantDataType_String)`.
Returns
-------
Returns the value of the variant as string.
pre:
* `IsArray()` returns `false`.
* The type of this `CVariant` is `VariantDataType_Boolean`,
`VariantDataType_Int64`, `VariantDataType_UInt64`,
`VariantDataType_Float`, `VariantDataType_String` or
`VariantDataType_Composite`
* `CanConvert(VariantDataType_String)` returns `true`.
\error Throws an exception if:
* The preconditions aren't met.
* The conversion fails.
"""
return _pylondataprocessing.Variant_ToString(self)
def ToImage(self):
r"""
Pylon::DataProcessing::CVariant::ToImage
Returns the value of the variant for a basic type as CPylonImage.
Returns
-------
Returns the value of the variant as CPylonImage.
pre:
* `IsArray()` returns `false`.
* The type of this `CVariant` is `VariantDataType_PylonImage`.
* `CanConvert(VariantDataType_PylonImage)` returns `true`.
\error Throws an exception if:
* The preconditions aren't met.
* The conversion fails.
"""
return _pylondataprocessing.Variant_ToImage(self)
def ToRegion(self):
r"""
Pylon::DataProcessing::CVariant::ToRegion
Returns the value of the variant for a basic type as CRegion.
Returns
-------
Returns the value of the variant as CRegion.
pre:
* `IsArray()` returns `false`.
* The type of this `CVariant` is `VariantDataType_Region`.
* `CanConvert(VariantDataType_Region)` returns `true`.
\error Throws an exception if:
* The preconditions aren't met.
* The conversion fails.
"""
return _pylondataprocessing.Variant_ToRegion(self)
def ToTransformationData(self):
r"""
Pylon::DataProcessing::CVariant::ToTransformationData
Returns the value of the variant for a basic type as CTransformationData.
Returns
-------
Returns the value of the variant as CTransformationData.
pre:
* `IsArray()` returns `false`.
* The type of this `CVariant` is `VariantDataType_TransformationData`.
* `CanConvert(VariantDataType_TransformationData)` returns `true`.
\error Throws an exception if:
* The preconditions aren't met.
* The conversion fails.
"""
return _pylondataprocessing.Variant_ToTransformationData(self)
def ToPointF2D(self):
r"""
Pylon::DataProcessing::CVariant::ToPointF2D
Returns the value of the variant as SPointF2D.
Returns
-------
Returns the value of the variant as SPointF2D.
pre:
* `IsArray()` returns `false`.
* The type of this `CVariant` is `VariantDataType_PointF2D`.
* `CanConvert(VariantDataType_PointF2D)` returns `true`.
\error Throws an exception if:
* The preconditions aren't met.
* The conversion fails.
"""
return _pylondataprocessing.Variant_ToPointF2D(self)
def ToLineF2D(self):
r"""
Pylon::DataProcessing::CVariant::ToLineF2D
Returns the value of the variant as SLineF2D.
Returns
-------
Returns the value of the variant as SLineF2D.
pre:
* `IsArray()` returns `false`.
* The type of this `CVariant` is `VariantDataType_LineF2D`.
* `CanConvert(VariantDataType_LineF2D)` returns `true`.
\error Throws an exception if:
* The preconditions aren't met.
* The conversion fails.
"""
return _pylondataprocessing.Variant_ToLineF2D(self)
def ToRectangleF(self):
r"""
Pylon::DataProcessing::CVariant::ToRectangleF
Returns the value of the variant as SRectangleF.
Returns
-------
Returns the value of the variant as SRectangleF.
pre:
* `IsArray()` returns `false`.
* The type of this `CVariant` is `VariantDataType_RectangleF`.
* `CanConvert(VariantDataType_RectangleF)` returns `true`.
\error Throws an exception if:
* The preconditions aren't met.
* The conversion fails.
"""
return _pylondataprocessing.Variant_ToRectangleF(self)
def ToCircleF(self):
r"""
Pylon::DataProcessing::CVariant::ToCircleF
Returns the value of the variant as SCircleF.
Returns
-------
Returns the value of the variant as SCircleF.
pre:
* `IsArray()` returns `false`.
* The type of this `CVariant` is `VariantDataType_CircleF`.
* `CanConvert(VariantDataType_CircleF)` returns `true`.
\error Throws an exception if:
* The preconditions aren't met.
* The conversion fails.
"""
return _pylondataprocessing.Variant_ToCircleF(self)
def ToEllipseF(self):
r"""
Pylon::DataProcessing::CVariant::ToEllipseF
Returns the value of the variant as SEllipseF.
Returns
-------
Returns the value of the variant as SEllipseF.
pre:
* `IsArray()` returns `false`.
* The type of this `CVariant` is `VariantDataType_EllipseF`.
* `CanConvert(VariantDataType_EllipseF)` returns `true`.
\error Throws an exception if:
* The preconditions aren't met.
* The conversion fails.
"""
return _pylondataprocessing.Variant_ToEllipseF(self)
def FromBool(self, newValue):
r"""
Pylon::DataProcessing::CVariant::FromBool
Changes the value referenced by the variant.
Parameters
----------
* `newValue` :
The new value for the referenced value.
pre:
* `IsArray()` returns `false`.
* The type of this `CVariant` is `VariantDataType_Boolean`,
`VariantDataType_Int64`, `VariantDataType_UInt64`,
`VariantDataType_Float`, or `VariantDataType_String`.
post:
* The referenced value has been changed to the value of `newValue`.
* The data type returned by `GetDataType()` hasn't changed.
\error Throws an exception if the preconditions aren't met.
"""
return _pylondataprocessing.Variant_FromBool(self, newValue)
def FromInt64(self, newValue):
r"""
Pylon::DataProcessing::CVariant::FromInt64
Changes the value referenced by the variant.
Parameters
----------
* `newValue` :
The new value for the referenced value.
pre:
* `IsArray()` returns `false`.
* The variant data type is able to represent the value.
* The type of this `CVariant` is `VariantDataType_Boolean`,
`VariantDataType_Int64`, `VariantDataType_UInt64`,
`VariantDataType_Float`, or `VariantDataType_String`.
post:
* The referenced value has been changed to the value of `newValue`.
* The data type returned by `GetDataType()` hasn't changed.
\error Throws an exception if the preconditions aren't met.
"""
return _pylondataprocessing.Variant_FromInt64(self, newValue)
def FromUInt64(self, newValue):
r"""
Pylon::DataProcessing::CVariant::FromUInt64
Changes the value referenced by the variant.
Parameters
----------
* `newValue` :
The new value for the referenced value.
pre:
* `IsArray()` returns `false`.
* The variant data type is able to represent the value.
* The type of this `CVariant` is `VariantDataType_Boolean`,
`VariantDataType_Int64`, `VariantDataType_UInt64`,
`VariantDataType_Float`, or `VariantDataType_String`.
post:
* The referenced value has been changed to the value of `newValue`.
* The data type returned by `GetDataType()` hasn't changed.
\error Throws an exception if the preconditions aren't met.
"""
return _pylondataprocessing.Variant_FromUInt64(self, newValue)
def FromDouble(self, newValue):
r"""
Pylon::DataProcessing::CVariant::FromDouble
Changes the value referenced by the variant.
Parameters
----------
* `newValue` :
The new value for the referenced value.
pre:
* `IsArray()` returns `false`.
* The variant data type is able to represent the value.
* The type of this `CVariant` is `VariantDataType_Boolean`,
`VariantDataType_Int64`, `VariantDataType_UInt64`,
`VariantDataType_Float`, or `VariantDataType_String`.
attention: If data type is an integer data type, the value is NOT rounded in a
mathematical way. It is truncated equivalent to static_cast<int64_t>.
post:
* The referenced value has been changed to the value of `newValue`.
* The data type returned by `GetDataType()` hasn't changed.
\error Throws an exception if the preconditions aren't met.
"""
return _pylondataprocessing.Variant_FromDouble(self, newValue)
def FromString(self, newValue):
r"""
Pylon::DataProcessing::CVariant::FromString
Changes the value referenced by the variant.
note: This method will fail if the content of `newValue` is not convertible to
the type of this `CVariant`.
Parameters
----------
* `newValue` :
The new value for the referenced value.
pre:
* `IsArray()` returns `false`.
* The variant data type is able to represent the value.
* The type of this `CVariant` is `VariantDataType_Boolean`,
`VariantDataType_Int64`, `VariantDataType_UInt64`,
`VariantDataType_Float`, or `VariantDataType_String`.
post:
* The referenced value has been changed to the value of `newValue` if the
conversion succeeded.
* The data type returned by `GetDataType()` hasn't changed.
\error Throws an exception if:
* The preconditions aren't met.
* The conversion fails.
"""
return _pylondataprocessing.Variant_FromString(self, newValue)
def FromImage(self, newValue):
r"""
Pylon::DataProcessing::CVariant::FromImage
Changes the value referenced by the variant.
Parameters
----------
* `newValue` :
The new value for the referenced value.
pre:
* `newValue` must be a valid image.
* `IsArray()` returns `false`.
* The type of this `CVariant` is `VariantDataType_PylonImage`.
post:
* The referenced value has been changed to the value of `newValue`.
* The data type returned by `GetDataType()` hasn't changed.
\error Throws an exception if the preconditions aren't met.
"""
return _pylondataprocessing.Variant_FromImage(self, newValue)
def FromRegion(self, newValue):
r"""
Pylon::DataProcessing::CVariant::FromRegion
Changes the value referenced by the variant.
Parameters
----------
* `newValue` :
The new value for the referenced value.
pre:
* `newValue` must be a valid region.
* `IsArray()` returns `false`.
* The type of this `CVariant` is `VariantDataType_Region`.
post:
* The referenced value has been changed to the value of `newValue`.
* The data type returned by `GetDataType()` hasn't changed.
\error Throws an exception if the preconditions aren't met.
"""
return _pylondataprocessing.Variant_FromRegion(self, newValue)
def FromTransformationData(self, newValue):
r"""
Pylon::DataProcessing::CVariant::FromTransformationData
Changes the value referenced by the variant.
Parameters
----------
* `newValue` :
The new value for the referenced value.
pre:
* `newValue` must be valid transformation data.
* `IsArray()` returns `false`.
* The type of this `CVariant` is `VariantDataType_TransformationData`.
post:
* The referenced value has been changed to the value of `newValue`.
* The data type returned by `GetDataType()` hasn't changed.
\error Throws an exception if the preconditions aren't met.
"""
return _pylondataprocessing.Variant_FromTransformationData(self, newValue)
def FromPointF2D(self, newValue):
r"""
Pylon::DataProcessing::CVariant::FromPointF2D
Changes the value referenced by the variant.
Parameters
----------
* `newValue` :
The new value for the referenced value.
pre:
* `IsArray()` returns `false`.
* The type of this `CVariant` is `VariantDataType_PointF2D`.
post:
* The referenced value has been changed to the value of `newValue`.
* The data type returned by `GetDataType()` hasn't changed.
\error Throws an exception if the preconditions aren't met.
"""
return _pylondataprocessing.Variant_FromPointF2D(self, newValue)
def FromLineF2D(self, newValue):
r"""
Pylon::DataProcessing::CVariant::FromLineF2D
Changes the value referenced by the variant.
Parameters
----------
* `newValue` :
The new value for the referenced value.
pre:
* `IsArray()` returns `false`.
* The type of this `CVariant` is `VariantDataType_LineF2D`.
post:
* The referenced value has been changed to the value of `newValue`.
* The data type returned by `GetDataType()` hasn't changed.
\error Throws an exception if the preconditions aren't met.
"""
return _pylondataprocessing.Variant_FromLineF2D(self, newValue)
def FromRectangleF(self, newValue):
r"""
Pylon::DataProcessing::CVariant::FromRectangleF
Changes the value referenced by the variant.
Parameters
----------
* `newValue` :
The new value for the referenced value.
pre:
* `IsArray()` returns `false`.
* The type of this `CVariant` is `VariantDataType_RectangleF`.
post:
* The referenced value has been changed to the value of `newValue`.
* The data type returned by `GetDataType()` hasn't changed.
\error Throws an exception if the preconditions aren't met.
"""
return _pylondataprocessing.Variant_FromRectangleF(self, newValue)
def FromCircleF(self, newValue):
r"""
Pylon::DataProcessing::CVariant::FromCircleF
Changes the value referenced by the variant.
Parameters
----------
* `newValue` :
The new value for the referenced value.
pre:
* `IsArray()` returns `false`.
* The type of this `CVariant` is `VariantDataType_CircleF`.
post:
* The referenced value has been changed to the value of `newValue`.
* The data type returned by `GetDataType()` hasn't changed.
\error Throws an exception if the preconditions aren't met.
"""
return _pylondataprocessing.Variant_FromCircleF(self, newValue)
def FromEllipseF(self, newValue):
r"""
Pylon::DataProcessing::CVariant::FromEllipseF
Changes the value referenced by the variant.
Parameters
----------
* `newValue` :
The new value for the referenced value.
pre:
* `IsArray()` returns `false`.
* The type of this `CVariant` is `VariantDataType_EllipseF`.
post:
* The referenced value has been changed to the value of `newValue`.
* The data type returned by `GetDataType()` hasn't changed.
\error Throws an exception if the preconditions aren't met.
"""
return _pylondataprocessing.Variant_FromEllipseF(self, newValue)
def GetErrorDescription(self, checkSubValues=True):
r"""
Pylon::DataProcessing::CVariant::GetErrorDescription
Use this method to get the error description of the value.
Parameters
----------
* `checkSubValues` :
Optionally, also check the subvalues.
Returns
-------
Error description if the value is in error state, an empty string otherwise.
\error Doesn't throw C++ exceptions.
"""
return _pylondataprocessing.Variant_GetErrorDescription(self, checkSubValues)
def HasError(self, checkSubValues=True):
r"""
Pylon::DataProcessing::CVariant::HasError
Use this method to check the error state of the value.
Parameters
----------
* `checkSubValues` :
Optionally, check also the subvalues.
Returns
-------
`true` if the value is in error state.
\error Doesn't throw C++ exceptions.
"""
return _pylondataprocessing.Variant_HasError(self, checkSubValues)
def SetError(self, message):
r"""
Pylon::DataProcessing::CVariant::SetError
Sets an invalid data error.
This method is mainly intended for testing how invalid data are handled by a
recipe when a variant is provided as input value.
Parameters
----------
* `message` :
The error message text.
pre: The data type is not VariantDataType_None.
post:
* An invalid data error with the message text provided has been added to
the value.
\error Throws an exception if the preconditions aren't met.
"""
return _pylondataprocessing.Variant_SetError(self, message)
@staticmethod
def MakeVariant(*args):
return _pylondataprocessing.Variant_MakeVariant(*args)
def __str__(self):
resultList = ["Type = "]
dt = self.GetDataType()
hasString = False
if (dt == VariantDataType_None):
resultList.append("None")
elif (dt == VariantDataType_Int64):
resultList.append("Int64")
hasString = True
elif (dt == VariantDataType_UInt64):
resultList.append("UInt64")
hasString = True
elif (dt == VariantDataType_Boolean):
resultList.append("Boolean")
hasString = True
elif (dt == VariantDataType_String):
resultList.append("String")
hasString = True
elif (dt == VariantDataType_Float):
resultList.append("Float")
hasString = True
elif (dt == VariantDataType_PylonImage):
resultList.append("PylonImage")
elif (dt == VariantDataType_Region):
resultList.append("Region")
elif (dt == VariantDataType_TransformationData):
resultList.append("TransformationData")
hasString = True
elif (dt == VariantDataType_PointF2D):
resultList.append("PointF2D")
hasString = True
elif (dt == VariantDataType_LineF2D):
resultList.append("LineF2D")
hasString = True
elif (dt == VariantDataType_RectangleF):
resultList.append("RectangleF")
hasString = True
elif (dt == VariantDataType_CircleF):
resultList.append("CircleF")
hasString = True
elif (dt == VariantDataType_EllipseF):
resultList.append("EllipseF")
hasString = True
else:
resultList.append("?")
if self.HasError():
resultList.append("; Error = ")
resultList.append(self.GetErrorDescription())
elif hasString:
resultList.append("; ")
resultList.append(self.ToString())
result = "".join(resultList)
return result
# Register Variant in _pylondataprocessing:
_pylondataprocessing.Variant_swigregister(Variant)
class Update(object):
r"""
The `CUpdate` class can be used to check which output data has been generated by
which `CRecipe` data update operation and what the corresponding input data is.
The pylon recipe uses the concept of updates. An update can consist of the
synchronized processing of a defined set of data by one or more vTools at the
same time. Some vTools can trigger updates on their own, e.g., when triggered by
a preceding update. This causes a chain of updates.
\threading The CUpdate class isn't thread-safe.
C++ includes: Update.h
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
__swig_destroy__ = _pylondataprocessing.delete_Update
def __init__(self, *args):
r"""
Pylon::DataProcessing::CUpdate::CUpdate
Copies a `CUpdate` object.
Parameters
----------
* `rhs` :
The update to copy.
post:
* The update data has been copied.
\error Doesn't throw C++ exceptions.
"""
_pylondataprocessing.Update_swiginit(self, _pylondataprocessing.new_Update(*args))
def __eq__(self, rhs):
return _pylondataprocessing.Update___eq__(self, rhs)
def __lt__(self, rhs):
return _pylondataprocessing.Update___lt__(self, rhs)
def GetNumPrecedingUpdates(self):
r"""
Pylon::DataProcessing::CUpdate::GetNumPrecedingUpdates
Get the number of updates that directly caused this update.
Returns
-------
The number of updates that caused this update.
\error Doesn't throw C++ exceptions.
"""
return _pylondataprocessing.Update_GetNumPrecedingUpdates(self)
def GetPrecedingUpdate(self, index):
r"""
Pylon::DataProcessing::CUpdate::GetPrecedingUpdate
Returns the preceding update at the corresponding index.
Parameters
----------
* `index` :
The index.
Returns
-------
The preceding update at the corresponding `index`.
pre:
* `GetNumPrecedingUpdates()` returns a value larger than zero.
* The `index` passed is smaller than the value returned by
`GetNumPrecedingUpdates()`.
\error Throws an exception if the preconditions aren't met.
"""
return _pylondataprocessing.Update_GetPrecedingUpdate(self, index)
def HasBeenTriggeredBy(self, rhs):
r"""
Pylon::DataProcessing::CUpdate::HasBeenTriggeredBy
Checks whether the update passed has triggered this update.
Parameters
----------
* `rhs` :
The update to compare to.
Returns
-------
`true` if this update is equal to `rhs`. True if `rhs` is contained in the list
of preceding updates.
\error Doesn't throw C++ exceptions.
"""
return _pylondataprocessing.Update_HasBeenTriggeredBy(self, rhs)
def IsValid(self):
r"""
Pylon::DataProcessing::CUpdate::IsValid
Checks whether the update is valid.
Returns
-------
`true` if this update is valid.
\error Doesn't throw C++ exceptions.
"""
return _pylondataprocessing.Update_IsValid(self)
# Register Update in _pylondataprocessing:
_pylondataprocessing.Update_swigregister(Update)
QueueMode_Unlimited = _pylondataprocessing.QueueMode_Unlimited
QueueMode_DropOldest = _pylondataprocessing.QueueMode_DropOldest
QueueMode_DropNewest = _pylondataprocessing.QueueMode_DropNewest
QueueMode_Blocking = _pylondataprocessing.QueueMode_Blocking
class VariantContainer(object):
r"""
`CVariantContainer` is a map-like container providing an interface like a C++
standard library.
Values can be processed like this:
\threading The `CVariantContainer` class isn't thread-safe.
C++ includes: VariantContainer.h
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
def __init__(self, *args):
r"""
Pylon::DataProcessing::CVariantContainer::CVariantContainer
Move constructs a variant container object.
Parameters
----------
* `rhs` :
The variant container to move the data from.
\error Doesn't throw C++ exceptions.
"""
_pylondataprocessing.VariantContainer_swiginit(self, _pylondataprocessing.new_VariantContainer(*args))
__swig_destroy__ = _pylondataprocessing.delete_VariantContainer
def count(self, key):
r"""
Pylon::DataProcessing::CVariantContainer::count
Number of elements with key.
Parameters
----------
* `key` :
The key as string value, typically the name of an input or an output.
Returns
-------
The number of elements with key, which is either 1 or 0.
\error Doesn't throw C++ exceptions.
"""
return _pylondataprocessing.VariantContainer_count(self, key)
def clear(self):
r"""
Pylon::DataProcessing::CVariantContainer::clear
Clears all elements.
post:
* The `CVariantContainer` has no elements.<
- >
\error Doesn't throw C++ exceptions.
"""
return _pylondataprocessing.VariantContainer_clear(self)
def empty(self):
r"""
Pylon::DataProcessing::CVariantContainer::empty
Checks `CVariantContainer` has no elements.
Returns
-------
`true` if empty, `false` otherwise.
\error Doesn't throw C++ exceptions.
"""
return _pylondataprocessing.VariantContainer_empty(self)
def size(self):
r"""
Pylon::DataProcessing::CVariantContainer::size
Returns the number of elements.
Returns
-------
The number of elements.
\error Doesn't throw C++ exceptions.
"""
return _pylondataprocessing.VariantContainer_size(self)
def erase(self, key):
r"""
Pylon::DataProcessing::CVariantContainer::erase
Erases an element by key.
Parameters
----------
* `key` :
The key as string value, typically the name of an input or an output.
Returns
-------
The number of deletions, which is either 0 or 1.
\error Doesn't throw C++ exceptions.
"""
return _pylondataprocessing.VariantContainer_erase(self, key)
def getValue(self, key):
return _pylondataprocessing.VariantContainer_getValue(self, key)
def setValue(self, key, v):
return _pylondataprocessing.VariantContainer_setValue(self, key, v)
# Register VariantContainer in _pylondataprocessing:
_pylondataprocessing.VariantContainer_swigregister(VariantContainer)
class OutputObserver(object):
r"""
An interface that can be used to receive output data from a `CRecipe`.
\threading This interface is called from multiple internal threads of the
`CRecipe`.
C++ includes: IOutputObserver.h
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
__swig_destroy__ = _pylondataprocessing.delete_OutputObserver
def OutputDataPush(self, recipe, value, update, userProvidedId):
r"""
Pylon::DataProcessing::IOutputObserver::OutputDataPush
This method is called when an output of the `CRecipe` pushes data out.
Parameters
----------
* `recipe` :
The recipe that produced the output.
* `value` :
A variant container containing the output data.
* `update` :
The corresponding update.
* `userProvidedId` :
This ID is passed to distinguish between different events. This ID has been
passed when calling `CRecipe::RegisterOutputObserver()`.
\error C++ exceptions thrown by this method are caught and ignored.
"""
return _pylondataprocessing.OutputObserver_OutputDataPush(self, recipe, value, update, userProvidedId)
def OnDeregistered(self, recipe):
r"""
Pylon::DataProcessing::IOutputObserver::OnDeregistered
This method is called when the output observer is deregistered from the recipe.
It can be used to delete the output observer by overloading the method.
Parameters
----------
* `recipe` :
The recipe that the observer is deregistered from.
\error C++ Exceptions thrown by this method are caught and ignored.
"""
return _pylondataprocessing.OutputObserver_OnDeregistered(self, recipe)
def __init__(self):
if self.__class__ == OutputObserver:
_self = None
else:
_self = self
_pylondataprocessing.OutputObserver_swiginit(self, _pylondataprocessing.new_OutputObserver(_self, ))
def __disown__(self):
self.this.disown()
_pylondataprocessing.disown_OutputObserver(self)
return weakref.proxy(self)
# Register OutputObserver in _pylondataprocessing:
_pylondataprocessing.OutputObserver_swigregister(OutputObserver)
class GenericOutputObserverResult(object):
r"""
A container for recipe output data.
C++ includes: GenericOutputObserver.h
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
Update = property(_pylondataprocessing.GenericOutputObserverResult_Update_get, _pylondataprocessing.GenericOutputObserverResult_Update_set)
UserProvidedID = property(_pylondataprocessing.GenericOutputObserverResult_UserProvidedID_get, _pylondataprocessing.GenericOutputObserverResult_UserProvidedID_set)
Container = property(_pylondataprocessing.GenericOutputObserverResult_Container_get, _pylondataprocessing.GenericOutputObserverResult_Container_set)
def GetContainer(self):
return _pylondataprocessing.GenericOutputObserverResult_GetContainer(self)
def __init__(self):
_pylondataprocessing.GenericOutputObserverResult_swiginit(self, _pylondataprocessing.new_GenericOutputObserverResult())
__swig_destroy__ = _pylondataprocessing.delete_GenericOutputObserverResult
# Register GenericOutputObserverResult in _pylondataprocessing:
_pylondataprocessing.GenericOutputObserverResult_swigregister(GenericOutputObserverResult)
class GenericOutputObserver(OutputObserver):
r"""
A simple Recipe Output Observer that collects recipe outputs in a queue.
C++ includes: GenericOutputObserver.h
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
def __init__(self):
r"""
Pylon::DataProcessing::CGenericOutputObserver::CGenericOutputObserver
Creates a `CGenericOutputObserver` object.
\error Doesn't throw C++ exceptions.
"""
_pylondataprocessing.GenericOutputObserver_swiginit(self, _pylondataprocessing.new_GenericOutputObserver())
def OutputDataPush(self, recipe, value, update, userProvidedId):
r"""
Pylon::DataProcessing::IOutputObserver::OutputDataPush
This method is called when an output of the `CRecipe` pushes data out.
Parameters
----------
* `recipe` :
The recipe that produced the output.
* `value` :
A variant container containing the output data.
* `update` :
The corresponding update.
* `userProvidedId` :
This ID is passed to distinguish between different events. This ID has been
passed when calling `CRecipe::RegisterOutputObserver()`.
\error C++ exceptions thrown by this method are caught and ignored.
"""
return _pylondataprocessing.GenericOutputObserver_OutputDataPush(self, recipe, value, update, userProvidedId)
def GetWaitObject(self):
r"""
Pylon::DataProcessing::CGenericOutputObserver::GetWaitObject
Returns a WaitObject that is in Signaled state if the queue is not empty and in
Reset state if it is empty.
Returns
-------
`WaitObject` of the GenericOutputObserver.
\error Doesn't throw C++ exceptions.
\threading This method is thread safe.
"""
return _pylondataprocessing.GenericOutputObserver_GetWaitObject(self)
def GetNumResults(self):
r"""
Pylon::DataProcessing::CGenericOutputObserver::GetNumResults
Gets the number of SGenericOutputObserverResults in the queue.
Returns
-------
`The` number of elements in the queue.
\error Doesn't throw C++ exceptions.
\threading This method is thread safe.
"""
return _pylondataprocessing.GenericOutputObserver_GetNumResults(self)
def Clear(self):
r"""
Pylon::DataProcessing::CGenericOutputObserver::Clear
Removes all CVariantContainers from the queue.
\error Doesn't throw C++ exceptions.
\threading This method is thread safe.
"""
return _pylondataprocessing.GenericOutputObserver_Clear(self)
def RetrieveResult(self):
return _pylondataprocessing.GenericOutputObserver_RetrieveResult(self)
def RetrieveFullResult(self):
return _pylondataprocessing.GenericOutputObserver_RetrieveFullResult(self)
__swig_destroy__ = _pylondataprocessing.delete_GenericOutputObserver
# Register GenericOutputObserver in _pylondataprocessing:
_pylondataprocessing.GenericOutputObserver_swigregister(GenericOutputObserver)
GenericOutputObserverResult.Container = property(GenericOutputObserverResult.GetContainer)
class UpdateObserver(object):
r"""
An interface that can be used to get notified about the processing of updates.
\threading This interface is called from multiple internal threads of the
`Pylon::DataProcessing::CRecipe`.
C++ includes: IUpdateObserver.h
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
__swig_destroy__ = _pylondataprocessing.delete_UpdateObserver
def UpdateDone(self, recipe, update, userProvidedId):
r"""
Pylon::DataProcessing::IUpdateObserver::UpdateDone
This method is called when an update of a `Pylon::DataProcessing::CRecipe` has
been processed completely.
note: If this update has triggered further updates, depending on the vTools used
in an recipe, the output data may not be available yet.
Parameters
----------
* `recipe` :
The recipe that processed the update.
* `update` :
The update that was processed completely.
* `userProvidedId` :
This ID is passed to distinguish between different events. This ID has been
passed when calling `CRecipe::TriggerUpdateAsync()` or
`CRecipe:TriggerUpdate()`.
\error C++ Exceptions thrown by this method are caught and ignored.
"""
return _pylondataprocessing.UpdateObserver_UpdateDone(self, recipe, update, userProvidedId)
def __init__(self):
if self.__class__ == UpdateObserver:
_self = None
else:
_self = self
_pylondataprocessing.UpdateObserver_swiginit(self, _pylondataprocessing.new_UpdateObserver(_self, ))
def __disown__(self):
self.this.disown()
_pylondataprocessing.disown_UpdateObserver(self)
return weakref.proxy(self)
# Register UpdateObserver in _pylondataprocessing:
_pylondataprocessing.UpdateObserver_swigregister(UpdateObserver)
class EventData(object):
r"""
Data associated with an event inside the recipe. Currently, only errors are
supported.
C++ includes: IEventObserver.h
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
EventType_Error = _pylondataprocessing.EventData_EventType_Error
EventType_ErrorReset = _pylondataprocessing.EventData_EventType_ErrorReset
EventType = property(_pylondataprocessing.EventData_EventType_get, _pylondataprocessing.EventData_EventType_set)
Description = property(_pylondataprocessing.EventData_Description_get, _pylondataprocessing.EventData_Description_set)
EventClass = property(_pylondataprocessing.EventData_EventClass_get, _pylondataprocessing.EventData_EventClass_set)
EventSourceName = property(_pylondataprocessing.EventData_EventSourceName_get, _pylondataprocessing.EventData_EventSourceName_set)
def __str__(self):
result = "EventType: {0}; Description = {1}; EventClass = {2}; EventSourceName = {3}".format(self.EventType, self.Description, self.EventClass, self.EventSourceName)
return result
def __init__(self):
_pylondataprocessing.EventData_swiginit(self, _pylondataprocessing.new_EventData())
__swig_destroy__ = _pylondataprocessing.delete_EventData
# Register EventData in _pylondataprocessing:
_pylondataprocessing.EventData_swigregister(EventData)
class EventObserver(object):
r"""
An interface that can be used to receive event data from a `CRecipe`.
\threading This interface is called from multiple internal threads of the
`CRecipe`.
C++ includes: IEventObserver.h
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
__swig_destroy__ = _pylondataprocessing.delete_EventObserver
def OnEventSignaled(self, recipe, pEvents, numEvents):
r"""
Pylon::DataProcessing::IEventObserver::OnEventSignaled
This method is called when the graph of the `CRecipe` detects an event, e.g., an
error change of a vtool.
Parameters
----------
* `recipe` :
The recipe that produced the output.
* `pEvents` :
List of event infos as plain C array.
* `numEvents` :
Number of entries in that list.
\error C++ Exceptions thrown by this method are caught and ignored.
"""
return _pylondataprocessing.EventObserver_OnEventSignaled(self, recipe, pEvents, numEvents)
def OnDeregistered(self, recipe):
r"""
Pylon::DataProcessing::IEventObserver::OnDeregistered
This method is called when the event observer is deregistered from the recipe.
It can be used to delete the event observer by overloading the method. The
default implementation of this method does nothing.
Parameters
----------
* `recipe` :
The recipe that the observer is deregistered from.
\error C++ Exceptions thrown by this method are caught and ignored.
"""
return _pylondataprocessing.EventObserver_OnDeregistered(self, recipe)
def __init__(self):
if self.__class__ == EventObserver:
_self = None
else:
_self = self
_pylondataprocessing.EventObserver_swiginit(self, _pylondataprocessing.new_EventObserver(_self, ))
def __disown__(self):
self.this.disown()
_pylondataprocessing.disown_EventObserver(self)
return weakref.proxy(self)
# Register EventObserver in _pylondataprocessing:
_pylondataprocessing.EventObserver_swigregister(EventObserver)
class Recipe(object):
r"""
Provides convenient access to a data processing design described by a recipe
file.
C++ includes: Recipe.h
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
def __init__(self):
r"""
Pylon::DataProcessing::CRecipe::CRecipe
Creates a `CRecipe` object with no recipe loaded.
\error Doesn't throw C++ exceptions.
"""
_pylondataprocessing.Recipe_swiginit(self, _pylondataprocessing.new_Recipe())
__swig_destroy__ = _pylondataprocessing.delete_Recipe
def Load(self, filename):
r"""
Pylon::DataProcessing::CRecipe::Load
Loads a recipe from disk and creates the objects of the design described by the
recipe. Relative paths, i.e., relative to the directory the recipe file is
located in, are used for loading external recipe components, e.g., images.
Parameters
----------
* `filename` :
The name and path of the recipe.
pre:
* The given file name must be a valid file path of an existing file
containing valid recipe data.
post:
* A recipe is loaded. You can use `IsLoaded()` to check whether a recipe
is loaded. Implicitly calls `Unload()` and unregisters all observers
already connected.
\error Throws an exception if the recipe can't be loaded. No recipe is loaded
if an error occurred.
\threading This method is synchronized using the lock provided by `GetLock()`.
"""
return _pylondataprocessing.Recipe_Load(self, filename)
def LoadFromBinary(self, *args):
r"""
Pylon::DataProcessing::CRecipe::LoadFromBinary
Loads a recipe from binary buffer and creates the objects of the design
described by the recipe.
Parameters
----------
* `pBuffer` :
Buffer pointer to binary recipe.
* `bufferSize` :
Buffer size for binary recipe buffer in bytes.
* `directory` :
External recipe components, e.g., images, will be loaded relative to this
directory.
pre:
* The buffer specified by pBuffer and bufferSize must contain valid recipe
data.
post:
* A recipe is loaded. You can use `IsLoaded()` to check whether a recipe
is loaded. Implicitly calls `Unload()` and unregisters all observers
already connected.
\error Throws an exception if the recipe can't be loaded. No recipe is loaded
if an error occurred.
\threading This method is synchronized using the lock provided by `GetLock()`.
"""
return _pylondataprocessing.Recipe_LoadFromBinary(self, *args)
def IsLoaded(self):
r"""
Pylon::DataProcessing::CRecipe::IsLoaded
Checks whether a recipe is loaded.
Returns
-------
`true` if a recipe is loaded.
\error Doesn't throw C++ exceptions.
\threading This method is synchronized using the lock provided by `GetLock()`.
"""
return _pylondataprocessing.Recipe_IsLoaded(self)
def PreAllocateResources(self):
r"""
Pylon::DataProcessing::CRecipe::PreAllocateResources
Optional method to pre-allocate resources.
All resources that could be allocated successfully stay allocated until a call
to `DeallocateResources()`.
pre:
* A recipe is loaded.
* The recipe must not be started.
post:
* All resources are allocated.
\error Throws an exception if:
* The preconditions aren't met.
* The resources couldn't be allocated.
\threading This method is synchronized using the lock provided by `GetLock()`.
"""
return _pylondataprocessing.Recipe_PreAllocateResources(self)
def Start(self, *args):
r"""
Pylon::DataProcessing::CRecipe::Start
Prepares the data processing and allocates resources required by the design. In
addition, the acquisition mode for all Camera and Image Loading vTools can be
specified (see `EAcquisitionMode` for more details).
Parameters
----------
* `acquisitionMode` :
The acquisition mode used to start the recipe (see `EAcquisitionMode` for
more details).
pre:
* A recipe has been loaded.
\error The recipe is not started if an error occurred. Throws an exception if
the preconditions aren't met.
\threading This method is synchronized using the lock provided by `GetLock()`.
"""
return _pylondataprocessing.Recipe_Start(self, *args)
def IsStarted(self):
r"""
Pylon::DataProcessing::CRecipe::IsStarted
Returns information about the recipe being started.
Returns
-------
`true` if the recipe has been started.
\error Doesn't throw C++ exceptions.
\threading This method is synchronized using the lock provided by `GetLock()`.
"""
return _pylondataprocessing.Recipe_IsStarted(self)
def Stop(self, *args):
r"""
Pylon::DataProcessing::CRecipe::Stop
Finishes the data processing and deallocates all resources allocated at start.
Updates may accumulate at some places in the design, e.g., when updates are
triggered more frequently than can be processed and the queue mode of the
connections is not set properly. `timeoutMs` describes the time these
accumulated updates are tolerated before they will be cleared. Updates that are
already being processed by a vTool will not be aborted when the timeout expires.
Parameters
----------
* `timeoutMs` :
Time to wait for updates not yet started to be processed.
\error Doesn't throw C++ exceptions.
post:
* The recipe is stopped.
* Resources allocated when calling `Start()` are deallocated.
* Resources allocated when calling `PreAllocateResources()` are still
allocated.
\threading This method is synchronized using the lock provided by `GetLock()`.
"""
return _pylondataprocessing.Recipe_Stop(self, *args)
def DeallocateResources(self):
r"""
Pylon::DataProcessing::CRecipe::DeallocateResources
Deallocates all resources used by the recipe.
Calls `Stop()` if the design described by the recipe has been started.
post:
* No resources are allocated.
\error Doesn't throw C++ exceptions.
\threading This method is synchronized using the lock provided by `GetLock()`.
"""
return _pylondataprocessing.Recipe_DeallocateResources(self)
def Unload(self):
r"""
Pylon::DataProcessing::CRecipe::Unload
Unloads the recipe currently loaded.
Calls `DeallocateResources()` if the design described by the recipe has
allocated resources. Unregisters all observers that have been connected.
pre:
* Data received via `IOutputObserver::OutputDataPush` must be freed.
post:
* No recipe is loaded.
\error Doesn't throw C++ exceptions.
\threading This method is synchronized using the lock provided by `GetLock()`.
"""
return _pylondataprocessing.Recipe_Unload(self)
def SetRecipeContext(self, context):
r"""
Pylon::DataProcessing::CRecipe::SetRecipeContext
Sets a context.
This is useful when handling multiple recipes.
You can access the context using `GetRecipeContext()`, e.g., in
`IOutputObserver::OutputDataPush()`, when receiving data from multiple recipes.
Parameters
----------
* `context` :
The user-defined context.
\error Doesn't throw C++ exceptions.
\threading This method is synchronized using an internal lock for the recipe
context.
"""
return _pylondataprocessing.Recipe_SetRecipeContext(self, context)
def GetRecipeContext(self):
r"""
Pylon::DataProcessing::CRecipe::GetRecipeContext
Returns the context.
This is useful when handling multiple recipes.
You can access the context using `GetRecipeContext()`, e.g., in
`IOutputObserver::OutputDataPush()`, when receiving data from multiple recipes.
Returns
-------
The context.
\error Doesn't throw C++ exceptions.
\threading This method is synchronized using an internal lock for the recipe
context.
"""
return _pylondataprocessing.Recipe_GetRecipeContext(self)
def HasInput(self, inputFullName):
r"""
Pylon::DataProcessing::CRecipe::HasInput
Checks whether an input pin is available.
Parameters
----------
* `inputFullName` :
The identifier of the input pin.
Returns
-------
`true` if the input pin is available.
\error Doesn't throw C++ exceptions.
\threading This method is synchronized using the lock provided by `GetLock()`.
"""
return _pylondataprocessing.Recipe_HasInput(self, inputFullName)
def HasOutput(self, outputFullName):
r"""
Pylon::DataProcessing::CRecipe::HasOutput
Checks whether an output pin is available.
Parameters
----------
* `outputFullName` :
The identifier of the output pin.
Returns
-------
`true` if the output pin is available.
\error Doesn't throw C++ exceptions.
\threading This method is synchronized using the lock provided by `GetLock()`.
"""
return _pylondataprocessing.Recipe_HasOutput(self, outputFullName)
def GetInputType(self, inputFullName):
r"""
Pylon::DataProcessing::CRecipe::GetInputType
Returns the variant data type of the input pin.
Parameters
----------
* `inputFullName` :
The identifier of the input pin.
Returns
-------
The variant data type of the input pin.
pre:
* An input pin with the name `inputFullName` must exist.
\error Throws an exception if the preconditions aren't met.
\threading This method is synchronized using the lock provided by `GetLock()`.
"""
return _pylondataprocessing.Recipe_GetInputType(self, inputFullName)
def GetInputContainerType(self, inputFullName):
r"""
Pylon::DataProcessing::CRecipe::GetInputContainerType
Returns the variant container type of the input pin.
Parameters
----------
* `inputFullName` :
The identifier of the input pin.
Returns
-------
The variant container type of the input pin.
pre:
* An input pin with the name `inputFullName` must exist.
\error Throws an exception if the preconditions aren't met.
\threading This method is synchronized using the lock provided by `GetLock()`.
"""
return _pylondataprocessing.Recipe_GetInputContainerType(self, inputFullName)
def GetOutputType(self, outputFullName):
r"""
Pylon::DataProcessing::CRecipe::GetOutputType
Returns the variant data type of the output pin.
Parameters
----------
* `outputFullName` :
The identifier of the output pin.
Returns
-------
The variant data type of the output pin.
pre:
* An output pin with the name `outputFullName` must exist.
\error Throws an exception if the preconditions aren't met.
\threading This method is synchronized using the lock provided by `GetLock()`.
"""
return _pylondataprocessing.Recipe_GetOutputType(self, outputFullName)
def GetOutputContainerType(self, outputFullName):
r"""
Pylon::DataProcessing::CRecipe::GetOutputContainerType
Returns the variant container type of the output pin.
Parameters
----------
* `outputFullName` :
The identifier of the output pin.
Returns
-------
The variant container type of the output pin.
pre:
* An output pin with the name `outputFullName` must exist.
\error Throws an exception if the preconditions aren't met.
\threading This method is synchronized using the lock provided by `GetLock()`.
"""
return _pylondataprocessing.Recipe_GetOutputContainerType(self, outputFullName)
def CanTriggerUpdate(self):
r"""
Pylon::DataProcessing::CRecipe::CanTriggerUpdate
Checks whether triggering an update is possible.
An update can't be triggered if the recipe is not started or at least one
connection connected to the input terminal has its queue mode set to blocking
and there is no space available.
Returns
-------
`true` if an update can be triggered, `false` otherwise.
\error Doesn't throw C++ exceptions.
\threading This method is synchronized using the lock provided by `GetLock()`.
"""
return _pylondataprocessing.Recipe_CanTriggerUpdate(self)
def TriggerUpdateWithReturn(self, *args):
r"""
Pylon::DataProcessing::CRecipe::TriggerUpdateWithReturn
Starts an update in a blocking call for a number of input pins. After the update
has been processed, a variant container containing the recipe output is
returned. This method is only intended for cases where the input triggers
exactly one result.
Parameters
----------
* `inputCollection` :
Provides the input names and the values.
* `timeoutMs` :
The timeout for the update to finish completely.
* `timeoutHandling` :
If timeoutHandling equals TimeoutHandling_ThrowException, a timeout
exception is thrown on timeout.
Returns
-------
The variant container that has been output by the recipe.
pre:
* The recipe is started.
* The `inputCollection` argument is not empty.
* The input pins exist.
* The types of the values in `inputCollection` are compatible with the
input data types.
* `CanTriggerUpdate()` must return `true`.
\error Throws an exception if the preconditions aren't met. Throws an exception
if the update couldn't be processed in the time specified by `timeoutMs` and
`timeoutHandling` == TimeoutHandling_ThrowException.
\threading This method is synchronized using the lock provided by `GetLock()`
while not waiting for the update to finish completely.
"""
return _pylondataprocessing.Recipe_TriggerUpdateWithReturn(self, *args)
def RegisterAllOutputsObserver(self, pObserver, mode, userProvidedId=0):
r"""
Pylon::DataProcessing::CRecipe::RegisterAllOutputsObserver
Adds an output observer to the list of registered output observers.
If `mode` equals `RegistrationMode_ReplaceAll`, the list of registered observes
is cleared.
note:
* The observer must not be deleted before the `CRecipe` is destroyed while
it is registered.
* If the `IOutputObserver` and the `CRecipe` are created on the stack in
the same scope, the observer must be created prior to the `CRecipe` it
is registered to because the objects are destroyed in reverse order.
Parameters
----------
* `pObserver` :
The receiver of events.
* `mode` :
Indicates how to register the new observer.
* `userProvidedId` :
This optional ID is passed to distinguish between different events. This ID
is provided to `IUpdateObserver::UpdateDone`.
pre:
* A recipe is loaded.
* `pObserver` is not nullptr.
post:
* The observer is registered and called when any output data is available.
\error Throws an exception if the preconditions aren't met. If an exception is
thrown, the observer is not registered and its `OnDeregistered` method will not
be called.
\threading This method is synchronized using the lock provided by `GetLock()`.
"""
return _pylondataprocessing.Recipe_RegisterAllOutputsObserver(self, pObserver, mode, userProvidedId)
def RegisterEventObserver(self, pObserver):
r"""
Pylon::DataProcessing::CRecipe::RegisterEventObserver
Registers an event observer to the recipe. Only one single observer per recipe
is supported. Registering a new one automatically unregisters the old one.
Registered observers must be unregistered before destruction.
Parameters
----------
* `pObserver` :
The receiver of events.
pre:
* `pObserver` is not nullptr.
post:
* The observer is registered and called when events occur, e.g., an error
is detected by a vTool.
\error Throws an exception if the preconditions aren't met. If an exception is
thrown, the observer is not registered and its `OnDeregistered` method will not
be called.
\threading This method is synchronized using an internal lock for event
observer handling.
"""
return _pylondataprocessing.Recipe_RegisterEventObserver(self, pObserver)
def UnregisterEventObserver(self):
r"""
Pylon::DataProcessing::CRecipe::UnregisterEventObserver
Removes any registered event observer from the recipe and calls the observer's
`OnDeregistered` method.
If an observer is not found, nothing is done.
\error Doesn't throw C++ exceptions.
\threading This method is synchronized using an internal lock for event
observer handling.
"""
return _pylondataprocessing.Recipe_UnregisterEventObserver(self)
def GetLock(self):
r"""
Pylon::DataProcessing::CRecipe::GetLock
Provides access to the lock used for synchronizing the access to the recipe.
This lock can be used when extending the Recipe class.
Example:
\error Doesn't throw C++ exceptions.
"""
return _pylondataprocessing.Recipe_GetLock(self)
def GetOutputNames(self):
return _pylondataprocessing.Recipe_GetOutputNames(self)
def GetAllParameterNames(self):
return _pylondataprocessing.Recipe_GetAllParameterNames(self)
def ContainsParameter(self, fullname):
return _pylondataprocessing.Recipe_ContainsParameter(self, fullname)
def GetParameter(self, fullname):
return _pylondataprocessing.Recipe_GetParameter(self, fullname)
def RegisterOutputObserver(self, outputFullNames, pObserver, mode, userProvidedId=0):
return _pylondataprocessing.Recipe_RegisterOutputObserver(self, outputFullNames, pObserver, mode, userProvidedId)
def UnregisterOutputObserver(self, pObserver, userProvidedId=0):
return _pylondataprocessing.Recipe_UnregisterOutputObserver(self, pObserver, userProvidedId)
def TriggerUpdateAsync(self, inputCollection, pObserver=None, userProvidedId=0):
return _pylondataprocessing.Recipe_TriggerUpdateAsync(self, inputCollection, pObserver, userProvidedId)
def TriggerUpdate(self, *args):
return _pylondataprocessing.Recipe_TriggerUpdate(self, *args)
# Register Recipe in _pylondataprocessing:
_pylondataprocessing.Recipe_swigregister(Recipe)
RecipeFileFormat_JsonDefault = _pylondataprocessing.RecipeFileFormat_JsonDefault
RecipeFileFormat_JsonCompressedBinaryData = _pylondataprocessing.RecipeFileFormat_JsonCompressedBinaryData
class BuildersRecipe(Recipe):
r"""
This class can be used to build recipes programmatically and run them.
C++ includes: BuildersRecipe.h
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
def __init__(self):
r"""
Pylon::DataProcessing::CBuildersRecipe::CBuildersRecipe
Creates a `CBuildersRecipe` object.
\error Doesn't throw C++ exceptions.
"""
_pylondataprocessing.BuildersRecipe_swiginit(self, _pylondataprocessing.new_BuildersRecipe())
__swig_destroy__ = _pylondataprocessing.delete_BuildersRecipe
def GetVToolDisplayNameForTypeID(self, vToolTypeID):
r"""
Pylon::DataProcessing::CBuildersRecipe::GetVToolDisplayNameForTypeID
Retrieves the display name of the vTool type identified by the given type ID.
Parameters
----------
* `vToolTypeID` :
The type ID of the vTool type whose display name is retrieved.
pre:
* `vToolTypeID` refers to an available vTool type (use
`GetAvailableVToolTypeIDs()` to get a list of all available vTool type
IDs).
\error Throws an exception if the preconditions aren't met.
Returns
-------
The display name of the vTool type identified by `vToolTypeID`.
\threading This method is synchronized using the lock provided by `GetLock()`.
"""
return _pylondataprocessing.BuildersRecipe_GetVToolDisplayNameForTypeID(self, vToolTypeID)
def AddVTool(self, *args):
r"""
Pylon::DataProcessing::CBuildersRecipe::AddVTool
Creates a vTool of a specific type and adds it to the recipe with an
automatically generated identifier.
Parameters
----------
* `vToolTypeID` :
Type ID specifying the vTool type of the vTool to be added.
pre:
* `vToolTypeID` refers to an available vTool type (use
`GetAvailableVToolTypeIDs()` to get a list of all available vTool type
IDs).
* Your license allows instantiating the requested vTool type from the Data
Processing SDK.
* The recipe hasn't been started (i.e., IsStarted() must return false).
post:
* A new vTool of the type identified by `vToolTypeID` has been added to
the recipe with a unique identifier.
\error Throws an exception if the preconditions aren't met.
Returns
-------
Returns the identifier of the newly created vTool instance.
\threading This method is synchronized using the lock provided by `GetLock()`.
"""
return _pylondataprocessing.BuildersRecipe_AddVTool(self, *args)
def GetVToolTypeID(self, identifier):
r"""
Pylon::DataProcessing::CBuildersRecipe::GetVToolTypeID
Returns the type ID of the vTool instance with the given identifier.
Parameters
----------
* `identifier` :
Identifier of the vTool whose type ID is retrieved.
pre:
* The recipe contains a vTool with the identifier `identifier`.
\error Throws an exception if the preconditions aren't met.
Returns
-------
The type ID of the vTool instance with the identifier `identifier`.
\threading This method is synchronized using the lock provided by `GetLock()`.
"""
return _pylondataprocessing.BuildersRecipe_GetVToolTypeID(self, identifier)
def HasVTool(self, identifier):
r"""
Pylon::DataProcessing::CBuildersRecipe::HasVTool
Checks whether the recipe contains a vTool with a specific identifier.
Parameters
----------
* `identifier` :
Identifier of the vTool.
\error Doesn't throw C++ exceptions.
Returns
-------
Returns true if the recipe contains a vTool with the identifier `identifier`,
otherwise false.
\threading This method is synchronized using the lock provided by `GetLock()`.
"""
return _pylondataprocessing.BuildersRecipe_HasVTool(self, identifier)
def RenameVTool(self, oldIdentifier, newIdentifier):
r"""
Pylon::DataProcessing::CBuildersRecipe::RenameVTool
Assigns a new identifier to an existing vTool instance.
Parameters
----------
* `oldIdentifier` :
The identifier of the vTool to be renamed.
* `newIdentifier` :
The new identifier of the vTool.
pre:
* The recipe contains a vTool with the identifier `oldIdentifier`.
* `newIdentifier` is a valid C++ identifier and must not start with an
underscore.
* The recipe doesn't contain a vTool with the identifier `newIdentifier`.
* The recipe hasn't been started (i.e., IsStarted() must return false).
post:
* The vTool with the identifier `oldIdentifier` has been renamed to
`newIdentifier`.
\error Throws an exception if the preconditions aren't met.
\threading This method is synchronized using the lock provided by `GetLock()`.
"""
return _pylondataprocessing.BuildersRecipe_RenameVTool(self, oldIdentifier, newIdentifier)
def RemoveVTool(self, identifier):
r"""
Pylon::DataProcessing::CBuildersRecipe::RemoveVTool
Removes an existing vTool instance. Any connections attached to any of the
vTool's pins will be removed as well.
Parameters
----------
* `identifier` :
The identifier of the vTool to be removed.
pre:
* The recipe contains a vTool with the identifier `identifier`.
* The recipe hasn't been started (i.e., IsStarted() must return false).
post:
* The vTool with the identifier `identifier` has been removed from the
recipe.
* Any connections attached to any of the vTool's pins have been removed
from the recipe.
\error Throws an exception if the preconditions aren't met.
\threading This method is synchronized using the lock provided by `GetLock()`.
"""
return _pylondataprocessing.BuildersRecipe_RemoveVTool(self, identifier)
def AddInput(self, *args):
r"""
Pylon::DataProcessing::CBuildersRecipe::AddInput
Adds an input of a specific type to the recipe with an automatically generated
identifier.
Parameters
----------
* `inputDataType` :
Data type of the new input.
* `inputContainerType` :
Container type of the new input.
pre:
* `inputDataType` refers to an actual data type and is not equal to
`VariantDataType_Composite`, `VariantDataType_None`, or
`VariantDataType_Unsupported`.
* `inputContainerType` refers to an actual container type and is not equal
to `VariantContainerType_Unsupported`.
* The recipe hasn't been started (i.e., IsStarted() must return false).
post:
* An input with the type identified by `inputDataType` and
`inputContainerType` has been added to the recipe.
\error Throws an exception if the preconditions aren't met.
Returns
-------
Returns the automatically generated identifier of the newly created input.
\threading This method is synchronized using the lock provided by `GetLock()`.
"""
return _pylondataprocessing.BuildersRecipe_AddInput(self, *args)
def RenameInput(self, oldInputFullName, newInputFullName):
r"""
Pylon::DataProcessing::CBuildersRecipe::RenameInput
Assigns a new identifier to an existing input.
Parameters
----------
* `oldInputFullName` :
The identifier of the input to be renamed.
* `newInputFullName` :
The new identifier of the input.
pre:
* The recipe contains an input with the identifier `oldInputFullName`.
* `newInputFullName` is a valid C++ identifier and must not start with an
underscore.
* The recipe doesn't contain an input with the identifier
`newInputFullName`.
* The input with the given identifier isn't connected.
* The recipe hasn't been started (i.e., IsStarted() must return false).
post:
* The input with the identifier `oldInputFullName` has been renamed to
`newInputFullName`.
\error Throws an exception if the preconditions aren't met.
\threading This method is synchronized using the lock provided by `GetLock()`.
"""
return _pylondataprocessing.BuildersRecipe_RenameInput(self, oldInputFullName, newInputFullName)
def RemoveInput(self, inputFullName):
r"""
Pylon::DataProcessing::CBuildersRecipe::RemoveInput
Removes an input from the recipe. If any connections are attached to this input,
they will be removed as well.
Parameters
----------
* `inputFullName` :
The identifiers of the input to be removed.
pre:
* The recipe has an input with the identifier `inputFullName`.
* The recipe hasn't been started (i.e., IsStarted() must return false).
post:
* The input with the identifier `inputFullName` has been removed from the
recipe.
* Any connections attached to the removed input have been removed.
\error Throws an exception if the preconditions aren't met.
\threading This method is synchronized using the lock provided by `GetLock()`.
"""
return _pylondataprocessing.BuildersRecipe_RemoveInput(self, inputFullName)
def AddOutput(self, *args):
r"""
Pylon::DataProcessing::CBuildersRecipe::AddOutput
Adds an output of a specific type to the recipe with an automatically generated
identifier.
Parameters
----------
* `outputDataType` :
Data type of the new output.
* `outputContainerType` :
Container type of the new output.
pre:
* `outputDataType` refers to an actual data type and is not equal to
`VariantDataType_Composite`, `VariantDataType_None`, or
`VariantDataType_Unsupported`.
* `outputContainerType` refers to an actual container type and is not
equal to `VariantContainerType_Unsupported`.
* The recipe hasn't been started (i.e., IsStarted() must return false).
post:
* An output with the type identified by `outputDataType` and
`outputContainerType` has been added to the recipe.
\error Throws an exception if the preconditions aren't met.
Returns
-------
Returns the automatically generated identifier of the newly created output.
\threading This method is synchronized using the lock provided by `GetLock()`.
"""
return _pylondataprocessing.BuildersRecipe_AddOutput(self, *args)
def RenameOutput(self, oldOutputFullName, newOutputFullName):
r"""
Pylon::DataProcessing::CBuildersRecipe::RenameOutput
Assigns a new identifier to an existing output.
Parameters
----------
* `oldOutputFullName` :
The identifier of the output to be renamed.
* `newOutputFullName` :
The new identifier of the output.
pre:
* The recipe contains an output with the identifier `oldOutputFullName`.
* `newOutputFullName` is a valid C++ identifier and must not start with an
underscore.
* The recipe doesn't contain an output with the identifier
`newOutputFullName`.
* The output with the given identifier isn't connected.
* The recipe hasn't been started (i.e., IsStarted() must return false).
post:
* The output with the identifier `oldOutputFullName` has been renamed to
`newOutputFullName`.
\error Throws an exception if the preconditions aren't met.
\threading This method is synchronized using the lock provided by `GetLock()`.
"""
return _pylondataprocessing.BuildersRecipe_RenameOutput(self, oldOutputFullName, newOutputFullName)
def RemoveOutput(self, outputFullName):
r"""
Pylon::DataProcessing::CBuildersRecipe::RemoveOutput
Removes an output from the recipe. If a connection is attached to this output,
it will be removed as well.
Parameters
----------
* `outputFullName` :
The identifier of the output to be removed.
pre:
* The recipe contains an output with the identifier `outputFullName`.
* The recipe hasn't been started (i.e., IsStarted() must return false).
post:
* The output with the identifier `outputFullName` has been removed from
the recipe.
* If a connection was attached to this output, it has been removed from
the recipe.
\error Throws an exception if the preconditions aren't met.
\threading This method is synchronized using the lock provided by `GetLock()`.
"""
return _pylondataprocessing.BuildersRecipe_RemoveOutput(self, outputFullName)
def AddConnection(self, *args):
r"""
Pylon::DataProcessing::CBuildersRecipe::AddConnection
Creates a connection between vTool pins and/or recipe inputs or outputs with an
automatically generated identifier.
Parameters
----------
* `sourceFullName` :
Full name of the source of the connection in the form
"[vToolIdentifier].[vToolOutputIdentifier]" (e.g., "Camera.Image" or
"myVTool.Point"). To create a connection from a recipe input, use
<RecipeInput> as the vToolIdentifier (e.g., "\<RecipeInput\>.Image").
* `destinationFullName` :
Full name of the destination of the connection
"[vToolIdentifier].[vToolInputIdentifier]" (e.g.,
"ImageFormatConverter.Image" or "myVTool.Point"). To create a connection
to a recipe output, use <RecipeOutput> as the vToolIdentifier (e.g.,
"\<RecipeOutput\>.Image").
* `queueMode` :
The queue mode for the connection queue (see `EQueueMode` for all available
queue modes). The default value is QueueMode_Blocking.
* `maxQueueSize` :
The initial maximum size of the connection queue. The default value is 1. If
`queueMode` is `QueueMode_Unlimited`, this has no effect.
pre:
* `sourceFullName` must specify the full name of an existing vTool output
pin or an existing recipe input.
* `destinationFullName` must specify the full name of an existing vTool
input pin or an existing recipe output.
* `sourceFullName` and `destinationFullName` must have compatible data
types.
* `maxQueueSize` must be greater than 0 and lower than the maximum value
of size_t.
* The destination must not be connected.
* The recipe hasn't been started (i.e., IsStarted() must return false).
post:
* A new connection has been created in the recipe connecting
`sourceFullName` to `destinationFullName`.
\error Throws an exception if the preconditions aren't met.
Returns
-------
Returns the identifier of the newly created connection.
\threading This method is synchronized using the lock provided by `GetLock()`.
"""
return _pylondataprocessing.BuildersRecipe_AddConnection(self, *args)
def GetConnectionMaxQueueSize(self, identifier):
r"""
Pylon::DataProcessing::CBuildersRecipe::GetConnectionMaxQueueSize
Gets the current maximum queue size for a connection identified by its
identifier.
Parameters
----------
* `identifier` :
Identifier of the connection whose maximum queue size is retrieved.
pre:
* The recipe contains a connection with the identifier `identifier`.
\error Throws an exception if the preconditions aren't met.
Returns
-------
The maximum queue size of the connection with the identifier `identifier`.
\threading This method is synchronized using the lock provided by `GetLock()`.
"""
return _pylondataprocessing.BuildersRecipe_GetConnectionMaxQueueSize(self, identifier)
def GetConnectionSource(self, identifier):
r"""
Pylon::DataProcessing::CBuildersRecipe::GetConnectionSource
Gets the full name of a connection's source.
Parameters
----------
* `identifier` :
Identifier of the connection.
pre:
* The recipe contains a connection with the identifier `identifier`.
\error Throws an exception if the preconditions aren't met.
Returns
-------
The full name of the connection's source.
\threading This method is synchronized using the lock provided by `GetLock()`.
"""
return _pylondataprocessing.BuildersRecipe_GetConnectionSource(self, identifier)
def GetConnectionDestination(self, identifier):
r"""
Pylon::DataProcessing::CBuildersRecipe::GetConnectionDestination
Gets the full name of a connection's destination.
Parameters
----------
* `identifier` :
Identifier of the connection.
pre:
* The recipe contains a connection with the identifier `identifier`.
\error Throws an exception if the preconditions aren't met.
Returns
-------
The full name of the connection's destination.
\threading This method is synchronized using the lock provided by `GetLock()`.
"""
return _pylondataprocessing.BuildersRecipe_GetConnectionDestination(self, identifier)
def GetConnectionQueueMode(self, identifier):
r"""
Pylon::DataProcessing::CBuildersRecipe::GetConnectionQueueMode
Gets the current queue mode for a connection identified by its identifier.
Parameters
----------
* `identifier` :
Identifier of the connection whose queue mode is retrieved.
pre:
* The recipe contains a connection with the identifier `identifier`.
\error Throws an exception if the preconditions aren't met.
Returns
-------
The queue mode of the connection with the identifier `identifier`.
\threading This method is synchronized using the lock provided by `GetLock()`.
"""
return _pylondataprocessing.BuildersRecipe_GetConnectionQueueMode(self, identifier)
def HasConnection(self, identifier):
r"""
Pylon::DataProcessing::CBuildersRecipe::HasConnection
Checks whether the recipe contains a connection with a specific identifier.
Parameters
----------
* `identifier` :
Identifier of the connection.
\error Doesn't throw C++ exceptions.
Returns
-------
Returns true if the recipe contains a connection with the identifier
`identifier`, otherwise false.
\threading This method is synchronized using the lock provided by `GetLock()`.
"""
return _pylondataprocessing.BuildersRecipe_HasConnection(self, identifier)
def RenameConnection(self, oldIdentifier, newIdentifier):
r"""
Pylon::DataProcessing::CBuildersRecipe::RenameConnection
Assigns a new identifier to an existing connection.
Parameters
----------
* `oldIdentifier` :
The identifier of the connection to be renamed.
* `newIdentifier` :
The new identifier of the connection.
pre:
* The recipe contains a connection with the identifier `oldIdentifier`.
* `newIdentifier` is a valid C++ identifier and must not start with an
underscore.
* The recipe doesn't contain a connection with the identifier
`newIdentifier`.
* The recipe hasn't been started (i.e., IsStarted() must return false).
post:
* The connection with the identifier `oldIdentifier` has been renamed to
`newIdentifier`.
\error Throws an exception if the preconditions aren't met.
\threading This method is synchronized using the lock provided by `GetLock()`.
"""
return _pylondataprocessing.BuildersRecipe_RenameConnection(self, oldIdentifier, newIdentifier)
def SetConnectionSettings(self, identifier, queueMode, maxQueueSize):
r"""
Pylon::DataProcessing::CBuildersRecipe::SetConnectionSettings
Modifies the settings of an existing connection.
Parameters
----------
* `identifier` :
The identifier of the connection to be modified.
* `queueMode` :
The new queue mode of the connection.
* `maxQueueSize` :
The new maximum queue size of the connection.
pre:
* The recipe contains a connection with the identifier `identifier`.
* `maxQueueSize` must be greater than 0 and lower than the maximum value
of size_t.
post:
* The connection's queue mode has been set to `queueMode`.
* The connection's maximum queue size has been set to `maxQueueSize`.
* The recipe hasn't been started (i.e., IsStarted() must return false).
\error Throws an exception if the preconditions aren't met.
\threading This method is synchronized using the lock provided by `GetLock()`.
"""
return _pylondataprocessing.BuildersRecipe_SetConnectionSettings(self, identifier, queueMode, maxQueueSize)
def SetConnectionQueueMode(self, identifier, queueMode):
r"""
Pylon::DataProcessing::CBuildersRecipe::SetConnectionQueueMode
Modifies the queue mode of an existing connection.
Parameters
----------
* `identifier` :
The identifier of the connection to be modified.
* `queueMode` :
The new queue mode of the connection.
pre:
* The recipe contains a connection with the identifier `identifier`.
* The recipe hasn't been started (i.e., IsStarted() must return false).
post:
* The connection's queue mode has been set to `queueMode`.
\error Throws an exception if the preconditions aren't met.
\threading This method is synchronized using the lock provided by `GetLock()`.
"""
return _pylondataprocessing.BuildersRecipe_SetConnectionQueueMode(self, identifier, queueMode)
def SetConnectionMaxQueueSize(self, identifier, maxQueueSize):
r"""
Pylon::DataProcessing::CBuildersRecipe::SetConnectionMaxQueueSize
Modifies the maximum queue size of an existing connection.
Parameters
----------
* `identifier` :
The identifier of the connection to be modified.
* `maxQueueSize` :
The new maximum queue size of the connection.
pre:
* The recipe contains a connection with the identifier `identifier`.
* `maxQueueSize` must be greater than 0 and lower than the maximum value
of size_t.
* The recipe hasn't been started (i.e., IsStarted() must return false).
post:
* The connection's maximum queue size has been set to `maxQueueSize`.
\error Throws an exception if the preconditions aren't met.
\threading This method is synchronized using the lock provided by `GetLock()`.
"""
return _pylondataprocessing.BuildersRecipe_SetConnectionMaxQueueSize(self, identifier, maxQueueSize)
def RemoveConnection(self, identifier):
r"""
Pylon::DataProcessing::CBuildersRecipe::RemoveConnection
Removes an existing connection.
Parameters
----------
* `identifier` :
The identifier of the connection to be removed.
pre:
* The recipe contains a connection with the identifier `identifier`.
* The recipe hasn't been started (i.e., IsStarted() must return false).
post:
* The connection with the identifier `identifier` has been removed from
the recipe.
\error Throws an exception if the preconditions aren't met.
\threading This method is synchronized using the lock provided by `GetLock()`.
"""
return _pylondataprocessing.BuildersRecipe_RemoveConnection(self, identifier)
def Save(self, fileName):
r"""
Pylon::DataProcessing::CBuildersRecipe::Save
Writes the recipe to a recipe file.
Parameters
----------
* `fileName` :
Path to the file to store the recipe in. This can be an absolute or a
relative path. If it is relative, the file will be saved relative to your
current working directory.
pre:
* `fileName` is a writable file path and a valid file path for your
platform.
post:
* The recipe has been written to the specified file path and can be loaded
using the `CRecipe` API.
\error Throws an exception if the preconditions aren't met.
\threading This method is synchronized using the lock provided by `GetLock()`.
"""
return _pylondataprocessing.BuildersRecipe_Save(self, fileName)
def SaveAs(self, format, fileName):
return _pylondataprocessing.BuildersRecipe_SaveAs(self, format, fileName)
def ResetToEmpty(self):
r"""
Pylon::DataProcessing::CBuildersRecipe::ResetToEmpty
Resets the recipe by removing all vTools, inputs, outputs, connections, and
observers. Stop() is called implicitly with an infinite timeout if the recipe
has been started.
post:
* The recipe is empty, i.e., all vTools, inputs, outputs, connections, and
observers have been removed.
* `IsStarted()` returns false.
* `IsLoaded()` returns true.
* The recipe can be modified.
\error Throws an exception if the preconditions aren't met.
"""
return _pylondataprocessing.BuildersRecipe_ResetToEmpty(self)
def GetAvailableVToolTypeIDs(self):
return _pylondataprocessing.BuildersRecipe_GetAvailableVToolTypeIDs(self)
def GetVToolIdentifiers(self):
return _pylondataprocessing.BuildersRecipe_GetVToolIdentifiers(self)
def GetInputNames(self):
return _pylondataprocessing.BuildersRecipe_GetInputNames(self)
def GetConnectionIdentifiers(self):
return _pylondataprocessing.BuildersRecipe_GetConnectionIdentifiers(self)
# Register BuildersRecipe in _pylondataprocessing:
_pylondataprocessing.BuildersRecipe_swigregister(BuildersRecipe)
TransformationData.ColumnCount = property(TransformationData.GetColumnCount)
TransformationData.RowCount = property(TransformationData.GetRowCount)
Region.RegionType = property(Region.GetRegionType)
Region.AllocatedBufferSize = property(Region.GetAllocatedBufferSize)
Region.DataSize = property(Region.GetDataSize)
Region.ReferenceWidth = property(Region.GetReferenceWidth)
Region.ReferenceHeight = property(Region.GetReferenceHeight)
Region.BoundingBoxTopLeftX = property(Region.GetBoundingBoxTopLeftX)
Region.BoundingBoxTopLeftY = property(Region.GetBoundingBoxTopLeftY)
Region.BoundingBoxWidth = property(Region.GetBoundingBoxWidth)
Region.BoundingBoxHeight = property(Region.GetBoundingBoxHeight)
Variant.DataType = property(Variant.GetDataType)
Variant.NumSubValues = property(Variant.GetNumSubValues)
Variant.NumArrayValues = property(Variant.GetNumArrayValues)
Update.NumPrecedingUpdates = property(Update.GetNumPrecedingUpdates)
Recipe.RecipeContext = property(Recipe.GetRecipeContext)
GenericOutputObserver.NumResults = property(GenericOutputObserver.GetNumResults)
GenericOutputObserver.WaitObject = property(GenericOutputObserver.GetWaitObject)
__version__ = '4.2.0'
Reference in New Issue View Git Blame Copy Permalink