3309 lines
90 KiB
Python
3309 lines
90 KiB
Python
# 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) 2017-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 _genicam
|
|
else:
|
|
import _genicam
|
|
|
|
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__ = _genicam.delete_SwigPyIterator
|
|
|
|
def value(self):
|
|
return _genicam.SwigPyIterator_value(self)
|
|
|
|
def incr(self, n=1):
|
|
return _genicam.SwigPyIterator_incr(self, n)
|
|
|
|
def decr(self, n=1):
|
|
return _genicam.SwigPyIterator_decr(self, n)
|
|
|
|
def distance(self, x):
|
|
return _genicam.SwigPyIterator_distance(self, x)
|
|
|
|
def equal(self, x):
|
|
return _genicam.SwigPyIterator_equal(self, x)
|
|
|
|
def copy(self):
|
|
return _genicam.SwigPyIterator_copy(self)
|
|
|
|
def next(self):
|
|
return _genicam.SwigPyIterator_next(self)
|
|
|
|
def __next__(self):
|
|
return _genicam.SwigPyIterator___next__(self)
|
|
|
|
def previous(self):
|
|
return _genicam.SwigPyIterator_previous(self)
|
|
|
|
def advance(self, n):
|
|
return _genicam.SwigPyIterator_advance(self, n)
|
|
|
|
def __eq__(self, x):
|
|
return _genicam.SwigPyIterator___eq__(self, x)
|
|
|
|
def __ne__(self, x):
|
|
return _genicam.SwigPyIterator___ne__(self, x)
|
|
|
|
def __iadd__(self, n):
|
|
return _genicam.SwigPyIterator___iadd__(self, n)
|
|
|
|
def __isub__(self, n):
|
|
return _genicam.SwigPyIterator___isub__(self, n)
|
|
|
|
def __add__(self, n):
|
|
return _genicam.SwigPyIterator___add__(self, n)
|
|
|
|
def __sub__(self, *args):
|
|
return _genicam.SwigPyIterator___sub__(self, *args)
|
|
def __iter__(self):
|
|
return self
|
|
|
|
# Register SwigPyIterator in _genicam:
|
|
_genicam.SwigPyIterator_swigregister(SwigPyIterator)
|
|
class ios_base(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")
|
|
__repr__ = _swig_repr
|
|
erase_event = _genicam.ios_base_erase_event
|
|
imbue_event = _genicam.ios_base_imbue_event
|
|
copyfmt_event = _genicam.ios_base_copyfmt_event
|
|
|
|
def register_callback(self, __fn, __index):
|
|
return _genicam.ios_base_register_callback(self, __fn, __index)
|
|
|
|
def flags(self, *args):
|
|
return _genicam.ios_base_flags(self, *args)
|
|
|
|
def setf(self, *args):
|
|
return _genicam.ios_base_setf(self, *args)
|
|
|
|
def unsetf(self, __mask):
|
|
return _genicam.ios_base_unsetf(self, __mask)
|
|
|
|
def precision(self, *args):
|
|
return _genicam.ios_base_precision(self, *args)
|
|
|
|
def width(self, *args):
|
|
return _genicam.ios_base_width(self, *args)
|
|
|
|
@staticmethod
|
|
def sync_with_stdio(__sync=True):
|
|
return _genicam.ios_base_sync_with_stdio(__sync)
|
|
|
|
def imbue(self, __loc):
|
|
return _genicam.ios_base_imbue(self, __loc)
|
|
|
|
def getloc(self):
|
|
return _genicam.ios_base_getloc(self)
|
|
|
|
@staticmethod
|
|
def xalloc():
|
|
return _genicam.ios_base_xalloc()
|
|
|
|
def iword(self, __ix):
|
|
return _genicam.ios_base_iword(self, __ix)
|
|
|
|
def pword(self, __ix):
|
|
return _genicam.ios_base_pword(self, __ix)
|
|
__swig_destroy__ = _genicam.delete_ios_base
|
|
|
|
# Register ios_base in _genicam:
|
|
_genicam.ios_base_swigregister(ios_base)
|
|
cvar = _genicam.cvar
|
|
ios_base.boolalpha = _genicam.cvar.ios_base_boolalpha
|
|
ios_base.dec = _genicam.cvar.ios_base_dec
|
|
ios_base.fixed = _genicam.cvar.ios_base_fixed
|
|
ios_base.hex = _genicam.cvar.ios_base_hex
|
|
ios_base.internal = _genicam.cvar.ios_base_internal
|
|
ios_base.left = _genicam.cvar.ios_base_left
|
|
ios_base.oct = _genicam.cvar.ios_base_oct
|
|
ios_base.right = _genicam.cvar.ios_base_right
|
|
ios_base.scientific = _genicam.cvar.ios_base_scientific
|
|
ios_base.showbase = _genicam.cvar.ios_base_showbase
|
|
ios_base.showpoint = _genicam.cvar.ios_base_showpoint
|
|
ios_base.showpos = _genicam.cvar.ios_base_showpos
|
|
ios_base.skipws = _genicam.cvar.ios_base_skipws
|
|
ios_base.unitbuf = _genicam.cvar.ios_base_unitbuf
|
|
ios_base.uppercase = _genicam.cvar.ios_base_uppercase
|
|
ios_base.adjustfield = _genicam.cvar.ios_base_adjustfield
|
|
ios_base.basefield = _genicam.cvar.ios_base_basefield
|
|
ios_base.floatfield = _genicam.cvar.ios_base_floatfield
|
|
ios_base.badbit = _genicam.cvar.ios_base_badbit
|
|
ios_base.eofbit = _genicam.cvar.ios_base_eofbit
|
|
ios_base.failbit = _genicam.cvar.ios_base_failbit
|
|
ios_base.goodbit = _genicam.cvar.ios_base_goodbit
|
|
ios_base.app = _genicam.cvar.ios_base_app
|
|
ios_base.ate = _genicam.cvar.ios_base_ate
|
|
ios_base.binary = _genicam.cvar.ios_base_binary
|
|
ios_base.ios_base_in = _genicam.cvar.ios_base_ios_base_in
|
|
ios_base.out = _genicam.cvar.ios_base_out
|
|
ios_base.trunc = _genicam.cvar.ios_base_trunc
|
|
ios_base.beg = _genicam.cvar.ios_base_beg
|
|
ios_base.cur = _genicam.cvar.ios_base_cur
|
|
ios_base.end = _genicam.cvar.ios_base_end
|
|
|
|
class ios(ios_base):
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
def rdstate(self):
|
|
return _genicam.ios_rdstate(self)
|
|
|
|
def clear(self, *args):
|
|
return _genicam.ios_clear(self, *args)
|
|
|
|
def setstate(self, __state):
|
|
return _genicam.ios_setstate(self, __state)
|
|
|
|
def good(self):
|
|
return _genicam.ios_good(self)
|
|
|
|
def eof(self):
|
|
return _genicam.ios_eof(self)
|
|
|
|
def fail(self):
|
|
return _genicam.ios_fail(self)
|
|
|
|
def bad(self):
|
|
return _genicam.ios_bad(self)
|
|
|
|
def exceptions(self, *args):
|
|
return _genicam.ios_exceptions(self, *args)
|
|
|
|
def __init__(self, __sb):
|
|
_genicam.ios_swiginit(self, _genicam.new_ios(__sb))
|
|
__swig_destroy__ = _genicam.delete_ios
|
|
|
|
def tie(self, *args):
|
|
return _genicam.ios_tie(self, *args)
|
|
|
|
def rdbuf(self, *args):
|
|
return _genicam.ios_rdbuf(self, *args)
|
|
|
|
def copyfmt(self, __rhs):
|
|
return _genicam.ios_copyfmt(self, __rhs)
|
|
|
|
def fill(self, *args):
|
|
return _genicam.ios_fill(self, *args)
|
|
|
|
def imbue(self, __loc):
|
|
return _genicam.ios_imbue(self, __loc)
|
|
|
|
def narrow(self, __c, __dfault):
|
|
return _genicam.ios_narrow(self, __c, __dfault)
|
|
|
|
def widen(self, __c):
|
|
return _genicam.ios_widen(self, __c)
|
|
|
|
# Register ios in _genicam:
|
|
_genicam.ios_swigregister(ios)
|
|
|
|
GenericException = _genicam.GenericException
|
|
|
|
|
|
BadAllocException = _genicam.BadAllocException
|
|
|
|
|
|
InvalidArgumentException = _genicam.InvalidArgumentException
|
|
|
|
|
|
OutOfRangeException = _genicam.OutOfRangeException
|
|
|
|
|
|
PropertyException = _genicam.PropertyException
|
|
|
|
|
|
RuntimeException = _genicam.RuntimeException
|
|
|
|
|
|
LogicalErrorException = _genicam.LogicalErrorException
|
|
|
|
|
|
AccessException = _genicam.AccessException
|
|
|
|
|
|
TimeoutException = _genicam.TimeoutException
|
|
|
|
|
|
DynamicCastException = _genicam.DynamicCastException
|
|
|
|
|
|
def TranslateGenicamException(_gcex_e):
|
|
return _genicam.TranslateGenicamException(_gcex_e)
|
|
|
|
import warnings
|
|
|
|
Signed = _genicam.Signed
|
|
Unsigned = _genicam.Unsigned
|
|
_UndefinedSign = _genicam._UndefinedSign
|
|
NI = _genicam.NI
|
|
NA = _genicam.NA
|
|
WO = _genicam.WO
|
|
RO = _genicam.RO
|
|
RW = _genicam.RW
|
|
_UndefinedAccesMode = _genicam._UndefinedAccesMode
|
|
_CycleDetectAccesMode = _genicam._CycleDetectAccesMode
|
|
Beginner = _genicam.Beginner
|
|
Expert = _genicam.Expert
|
|
Guru = _genicam.Guru
|
|
Invisible = _genicam.Invisible
|
|
_UndefinedVisibility = _genicam._UndefinedVisibility
|
|
NoCache = _genicam.NoCache
|
|
WriteThrough = _genicam.WriteThrough
|
|
WriteAround = _genicam.WriteAround
|
|
_UndefinedCachingMode = _genicam._UndefinedCachingMode
|
|
Linear = _genicam.Linear
|
|
Logarithmic = _genicam.Logarithmic
|
|
Boolean = _genicam.Boolean
|
|
PureNumber = _genicam.PureNumber
|
|
HexNumber = _genicam.HexNumber
|
|
IPV4Address = _genicam.IPV4Address
|
|
MACAddress = _genicam.MACAddress
|
|
_UndefinedRepresentation = _genicam._UndefinedRepresentation
|
|
BigEndian = _genicam.BigEndian
|
|
LittleEndian = _genicam.LittleEndian
|
|
_UndefinedEndian = _genicam._UndefinedEndian
|
|
Custom = _genicam.Custom
|
|
Standard = _genicam.Standard
|
|
_UndefinedNameSpace = _genicam._UndefinedNameSpace
|
|
_None = _genicam._None
|
|
GEV = _genicam.GEV
|
|
IIDC = _genicam.IIDC
|
|
CL = _genicam.CL
|
|
USB = _genicam.USB
|
|
_UndefinedStandardNameSpace = _genicam._UndefinedStandardNameSpace
|
|
Yes = _genicam.Yes
|
|
No = _genicam.No
|
|
_UndefinedYesNo = _genicam._UndefinedYesNo
|
|
Increasing = _genicam.Increasing
|
|
Decreasing = _genicam.Decreasing
|
|
Varying = _genicam.Varying
|
|
Automatic = _genicam.Automatic
|
|
_UndefinedESlope = _genicam._UndefinedESlope
|
|
xvLoad = _genicam.xvLoad
|
|
xvCycles = _genicam.xvCycles
|
|
xvSFNC = _genicam.xvSFNC
|
|
xvDefault = _genicam.xvDefault
|
|
xvAll = _genicam.xvAll
|
|
_UndefinedEXMLValidation = _genicam._UndefinedEXMLValidation
|
|
fnAutomatic = _genicam.fnAutomatic
|
|
fnFixed = _genicam.fnFixed
|
|
fnScientific = _genicam.fnScientific
|
|
_UndefinedEDisplayNotation = _genicam._UndefinedEDisplayNotation
|
|
intfIValue = _genicam.intfIValue
|
|
intfIBase = _genicam.intfIBase
|
|
intfIInteger = _genicam.intfIInteger
|
|
intfIBoolean = _genicam.intfIBoolean
|
|
intfICommand = _genicam.intfICommand
|
|
intfIFloat = _genicam.intfIFloat
|
|
intfIString = _genicam.intfIString
|
|
intfIRegister = _genicam.intfIRegister
|
|
intfICategory = _genicam.intfICategory
|
|
intfIEnumeration = _genicam.intfIEnumeration
|
|
intfIEnumEntry = _genicam.intfIEnumEntry
|
|
intfIPort = _genicam.intfIPort
|
|
ctParentNodes = _genicam.ctParentNodes
|
|
ctReadingChildren = _genicam.ctReadingChildren
|
|
ctWritingChildren = _genicam.ctWritingChildren
|
|
ctInvalidatingChildren = _genicam.ctInvalidatingChildren
|
|
ctDependingNodes = _genicam.ctDependingNodes
|
|
ctTerminalNodes = _genicam.ctTerminalNodes
|
|
ctValueChangingChildren = _genicam.ctValueChangingChildren
|
|
noIncrement = _genicam.noIncrement
|
|
fixedIncrement = _genicam.fixedIncrement
|
|
listIncrement = _genicam.listIncrement
|
|
idFrom = _genicam.idFrom
|
|
idTo = _genicam.idTo
|
|
idNone = _genicam.idNone
|
|
class ESignClass(object):
|
|
r"""
|
|
|
|
|
|
ESignClass holds conversion methods for the sign enumeration.
|
|
|
|
C++ includes: EnumClasses.h
|
|
|
|
"""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
@staticmethod
|
|
def FromString(ValueStr, pValue):
|
|
r"""
|
|
|
|
|
|
Converts a string to enum value.
|
|
|
|
"""
|
|
return _genicam.ESignClass_FromString(ValueStr, pValue)
|
|
|
|
@staticmethod
|
|
def ToString(*args):
|
|
r"""
|
|
|
|
|
|
Converts a string to an int32_t property.
|
|
|
|
"""
|
|
return _genicam.ESignClass_ToString(*args)
|
|
|
|
def __init__(self):
|
|
_genicam.ESignClass_swiginit(self, _genicam.new_ESignClass())
|
|
__swig_destroy__ = _genicam.delete_ESignClass
|
|
|
|
# Register ESignClass in _genicam:
|
|
_genicam.ESignClass_swigregister(ESignClass)
|
|
class EEndianessClass(object):
|
|
r"""
|
|
|
|
|
|
EEndianessClass holds conversion methods for the endianess enumeration.
|
|
|
|
C++ includes: EnumClasses.h
|
|
|
|
"""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
@staticmethod
|
|
def FromString(ValueStr, pValue):
|
|
r"""
|
|
|
|
|
|
Converts a string to enum value.
|
|
|
|
"""
|
|
return _genicam.EEndianessClass_FromString(ValueStr, pValue)
|
|
|
|
@staticmethod
|
|
def ToString(*args):
|
|
r"""
|
|
|
|
|
|
Converts a string to an int32_t property.
|
|
|
|
"""
|
|
return _genicam.EEndianessClass_ToString(*args)
|
|
|
|
def __init__(self):
|
|
_genicam.EEndianessClass_swiginit(self, _genicam.new_EEndianessClass())
|
|
__swig_destroy__ = _genicam.delete_EEndianessClass
|
|
|
|
# Register EEndianessClass in _genicam:
|
|
_genicam.EEndianessClass_swigregister(EEndianessClass)
|
|
class ERepresentationClass(object):
|
|
r"""
|
|
|
|
|
|
ERepresentationClass holds conversion methods for the representation
|
|
enumeration.
|
|
|
|
C++ includes: EnumClasses.h
|
|
|
|
"""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
@staticmethod
|
|
def FromString(ValueStr, pValue):
|
|
r"""
|
|
|
|
|
|
Converts a string to enum value.
|
|
|
|
"""
|
|
return _genicam.ERepresentationClass_FromString(ValueStr, pValue)
|
|
|
|
@staticmethod
|
|
def ToString(*args):
|
|
r"""
|
|
|
|
|
|
Converts a string to an int32_t property.
|
|
|
|
"""
|
|
return _genicam.ERepresentationClass_ToString(*args)
|
|
|
|
def __init__(self):
|
|
_genicam.ERepresentationClass_swiginit(self, _genicam.new_ERepresentationClass())
|
|
__swig_destroy__ = _genicam.delete_ERepresentationClass
|
|
|
|
# Register ERepresentationClass in _genicam:
|
|
_genicam.ERepresentationClass_swigregister(ERepresentationClass)
|
|
class EVisibilityClass(object):
|
|
r"""
|
|
|
|
|
|
EVisibilityClass holds conversion methods for the visibility enumeration.
|
|
|
|
C++ includes: EnumClasses.h
|
|
|
|
"""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
@staticmethod
|
|
def FromString(ValueStr, pValue):
|
|
r"""
|
|
|
|
|
|
Converts a string to enum value.
|
|
|
|
"""
|
|
return _genicam.EVisibilityClass_FromString(ValueStr, pValue)
|
|
|
|
@staticmethod
|
|
def ToString(*args):
|
|
r"""
|
|
|
|
|
|
Converts a string to an int32_t property.
|
|
|
|
"""
|
|
return _genicam.EVisibilityClass_ToString(*args)
|
|
|
|
def __init__(self):
|
|
_genicam.EVisibilityClass_swiginit(self, _genicam.new_EVisibilityClass())
|
|
__swig_destroy__ = _genicam.delete_EVisibilityClass
|
|
|
|
# Register EVisibilityClass in _genicam:
|
|
_genicam.EVisibilityClass_swigregister(EVisibilityClass)
|
|
class EAccessModeClass(object):
|
|
r"""
|
|
|
|
|
|
EAccessModeClass holds conversion methods for the access mode enumeration.
|
|
|
|
C++ includes: EnumClasses.h
|
|
|
|
"""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
@staticmethod
|
|
def FromString(ValueStr, pValue):
|
|
r"""
|
|
|
|
|
|
Converts a string to enum value.
|
|
|
|
"""
|
|
return _genicam.EAccessModeClass_FromString(ValueStr, pValue)
|
|
|
|
@staticmethod
|
|
def ToString(*args):
|
|
r"""
|
|
|
|
|
|
Converts a string to an int32_t property.
|
|
|
|
"""
|
|
return _genicam.EAccessModeClass_ToString(*args)
|
|
|
|
def __init__(self):
|
|
_genicam.EAccessModeClass_swiginit(self, _genicam.new_EAccessModeClass())
|
|
__swig_destroy__ = _genicam.delete_EAccessModeClass
|
|
|
|
# Register EAccessModeClass in _genicam:
|
|
_genicam.EAccessModeClass_swigregister(EAccessModeClass)
|
|
class ECachingModeClass(object):
|
|
r"""
|
|
|
|
|
|
ECachingModeClass holds conversion methods for the caching mode enumeration.
|
|
|
|
C++ includes: EnumClasses.h
|
|
|
|
"""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
@staticmethod
|
|
def FromString(ValueStr, pValue):
|
|
r"""
|
|
|
|
|
|
Converts a string to enum value.
|
|
|
|
"""
|
|
return _genicam.ECachingModeClass_FromString(ValueStr, pValue)
|
|
|
|
@staticmethod
|
|
def ToString(*args):
|
|
r"""
|
|
|
|
|
|
Converts a string to an int32_t property.
|
|
|
|
"""
|
|
return _genicam.ECachingModeClass_ToString(*args)
|
|
|
|
def __init__(self):
|
|
_genicam.ECachingModeClass_swiginit(self, _genicam.new_ECachingModeClass())
|
|
__swig_destroy__ = _genicam.delete_ECachingModeClass
|
|
|
|
# Register ECachingModeClass in _genicam:
|
|
_genicam.ECachingModeClass_swigregister(ECachingModeClass)
|
|
class ENameSpaceClass(object):
|
|
r"""
|
|
|
|
|
|
Holds conversion methods for the namespace enumeration.
|
|
|
|
C++ includes: EnumClasses.h
|
|
|
|
"""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
@staticmethod
|
|
def FromString(ValueStr, pValue):
|
|
r"""
|
|
|
|
|
|
Converts a string to enum value.
|
|
|
|
"""
|
|
return _genicam.ENameSpaceClass_FromString(ValueStr, pValue)
|
|
|
|
@staticmethod
|
|
def ToString(*args):
|
|
r"""
|
|
|
|
|
|
Converts a string to an int32_t property.
|
|
|
|
"""
|
|
return _genicam.ENameSpaceClass_ToString(*args)
|
|
|
|
def __init__(self):
|
|
_genicam.ENameSpaceClass_swiginit(self, _genicam.new_ENameSpaceClass())
|
|
__swig_destroy__ = _genicam.delete_ENameSpaceClass
|
|
|
|
# Register ENameSpaceClass in _genicam:
|
|
_genicam.ENameSpaceClass_swigregister(ENameSpaceClass)
|
|
class EYesNoClass(object):
|
|
r"""
|
|
|
|
|
|
Holds conversion methods for the standard namespace enumeration.
|
|
|
|
C++ includes: EnumClasses.h
|
|
|
|
"""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
@staticmethod
|
|
def FromString(ValueStr, pValue):
|
|
r"""
|
|
|
|
|
|
Converts a string to enum value.
|
|
|
|
"""
|
|
return _genicam.EYesNoClass_FromString(ValueStr, pValue)
|
|
|
|
@staticmethod
|
|
def ToString(*args):
|
|
r"""
|
|
|
|
|
|
Converts a string to an int32_t property.
|
|
|
|
"""
|
|
return _genicam.EYesNoClass_ToString(*args)
|
|
|
|
def __init__(self):
|
|
_genicam.EYesNoClass_swiginit(self, _genicam.new_EYesNoClass())
|
|
__swig_destroy__ = _genicam.delete_EYesNoClass
|
|
|
|
# Register EYesNoClass in _genicam:
|
|
_genicam.EYesNoClass_swigregister(EYesNoClass)
|
|
class EStandardNameSpaceClass(object):
|
|
r"""
|
|
|
|
|
|
Holds conversion methods for the standard namespace enumeration.
|
|
|
|
C++ includes: EnumClasses.h
|
|
|
|
"""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
@staticmethod
|
|
def FromString(ValueStr, pValue):
|
|
r"""
|
|
|
|
|
|
Converts a string to enum value.
|
|
|
|
"""
|
|
return _genicam.EStandardNameSpaceClass_FromString(ValueStr, pValue)
|
|
|
|
@staticmethod
|
|
def ToString(*args):
|
|
r"""
|
|
|
|
|
|
Converts a string to an int32_t property.
|
|
|
|
"""
|
|
return _genicam.EStandardNameSpaceClass_ToString(*args)
|
|
|
|
def __init__(self):
|
|
_genicam.EStandardNameSpaceClass_swiginit(self, _genicam.new_EStandardNameSpaceClass())
|
|
__swig_destroy__ = _genicam.delete_EStandardNameSpaceClass
|
|
|
|
# Register EStandardNameSpaceClass in _genicam:
|
|
_genicam.EStandardNameSpaceClass_swigregister(EStandardNameSpaceClass)
|
|
class ESlopeClass(object):
|
|
r"""
|
|
|
|
|
|
Holds conversion methods for the converter formulas.
|
|
|
|
C++ includes: EnumClasses.h
|
|
|
|
"""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
@staticmethod
|
|
def FromString(ValueStr, pValue):
|
|
r"""
|
|
|
|
|
|
Converts a string to enum value.
|
|
|
|
"""
|
|
return _genicam.ESlopeClass_FromString(ValueStr, pValue)
|
|
|
|
@staticmethod
|
|
def ToString(*args):
|
|
r"""
|
|
|
|
|
|
Converts a string to an int32_t property.
|
|
|
|
"""
|
|
return _genicam.ESlopeClass_ToString(*args)
|
|
|
|
def __init__(self):
|
|
_genicam.ESlopeClass_swiginit(self, _genicam.new_ESlopeClass())
|
|
__swig_destroy__ = _genicam.delete_ESlopeClass
|
|
|
|
# Register ESlopeClass in _genicam:
|
|
_genicam.ESlopeClass_swigregister(ESlopeClass)
|
|
class EDisplayNotationClass(object):
|
|
r"""
|
|
|
|
|
|
Holds conversion methods for the notation type of floats.
|
|
|
|
C++ includes: EnumClasses.h
|
|
|
|
"""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
@staticmethod
|
|
def FromString(ValueStr, pValue):
|
|
r"""
|
|
|
|
|
|
Converts a string to enum value.
|
|
|
|
"""
|
|
return _genicam.EDisplayNotationClass_FromString(ValueStr, pValue)
|
|
|
|
@staticmethod
|
|
def ToString(*args):
|
|
r"""
|
|
|
|
|
|
Converts a string to an int32_t property.
|
|
|
|
"""
|
|
return _genicam.EDisplayNotationClass_ToString(*args)
|
|
|
|
def __init__(self):
|
|
_genicam.EDisplayNotationClass_swiginit(self, _genicam.new_EDisplayNotationClass())
|
|
__swig_destroy__ = _genicam.delete_EDisplayNotationClass
|
|
|
|
# Register EDisplayNotationClass in _genicam:
|
|
_genicam.EDisplayNotationClass_swigregister(EDisplayNotationClass)
|
|
class EInputDirectionClass(object):
|
|
r"""
|
|
|
|
|
|
Holds conversion methods for the notation type of floats.
|
|
|
|
C++ includes: EnumClasses.h
|
|
|
|
"""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
@staticmethod
|
|
def FromString(ValueStr, pValue):
|
|
r"""
|
|
|
|
|
|
Converts a string to enum value.
|
|
|
|
"""
|
|
return _genicam.EInputDirectionClass_FromString(ValueStr, pValue)
|
|
|
|
@staticmethod
|
|
def ToString(*args):
|
|
r"""
|
|
|
|
|
|
Converts a string to an int32_t property.
|
|
|
|
"""
|
|
return _genicam.EInputDirectionClass_ToString(*args)
|
|
|
|
def __init__(self):
|
|
_genicam.EInputDirectionClass_swiginit(self, _genicam.new_EInputDirectionClass())
|
|
__swig_destroy__ = _genicam.delete_EInputDirectionClass
|
|
|
|
# Register EInputDirectionClass in _genicam:
|
|
_genicam.EInputDirectionClass_swigregister(EInputDirectionClass)
|
|
class Version(object):
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
Major = property(_genicam.Version_Major_get, _genicam.Version_Major_set)
|
|
Minor = property(_genicam.Version_Minor_get, _genicam.Version_Minor_set)
|
|
SubMinor = property(_genicam.Version_SubMinor_get, _genicam.Version_SubMinor_set)
|
|
|
|
def __init__(self):
|
|
_genicam.Version_swiginit(self, _genicam.new_Version())
|
|
__swig_destroy__ = _genicam.delete_Version
|
|
|
|
# Register Version in _genicam:
|
|
_genicam.Version_swigregister(Version)
|
|
class IBase(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
|
|
|
|
def GetAccessMode(self):
|
|
return _genicam.IBase_GetAccessMode(self)
|
|
|
|
# Register IBase in _genicam:
|
|
_genicam.IBase_swigregister(IBase)
|
|
class INode(IBase):
|
|
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
|
|
|
|
def GetName(self, FullQualified=False):
|
|
return _genicam.INode_GetName(self, FullQualified)
|
|
Name = property(GetName)
|
|
|
|
def GetNameSpace(self):
|
|
return _genicam.INode_GetNameSpace(self)
|
|
NameSpace = property(GetNameSpace)
|
|
|
|
def GetVisibility(self):
|
|
return _genicam.INode_GetVisibility(self)
|
|
Visibility = property(GetVisibility)
|
|
|
|
def InvalidateNode(self):
|
|
return _genicam.INode_InvalidateNode(self)
|
|
|
|
def IsCachable(self):
|
|
return _genicam.INode_IsCachable(self)
|
|
|
|
def IsAccessModeCacheable(self):
|
|
return _genicam.INode_IsAccessModeCacheable(self)
|
|
|
|
def GetCachingMode(self):
|
|
return _genicam.INode_GetCachingMode(self)
|
|
CachingMode = property(GetCachingMode)
|
|
|
|
def GetPollingTime(self):
|
|
return _genicam.INode_GetPollingTime(self)
|
|
PollingTime = property(GetPollingTime)
|
|
|
|
def GetToolTip(self):
|
|
return _genicam.INode_GetToolTip(self)
|
|
ToolTip = property(GetToolTip)
|
|
|
|
def GetDescription(self):
|
|
return _genicam.INode_GetDescription(self)
|
|
Description = property(GetDescription)
|
|
|
|
def GetDisplayName(self):
|
|
return _genicam.INode_GetDisplayName(self)
|
|
DisplayName = property(GetDisplayName)
|
|
|
|
def GetDeviceName(self):
|
|
return _genicam.INode_GetDeviceName(self)
|
|
DeviceName = property(GetDeviceName)
|
|
|
|
def GetChildren(self, *args):
|
|
return _genicam.INode_GetChildren(self, *args)
|
|
Children = property(GetChildren)
|
|
|
|
def GetParents(self):
|
|
return _genicam.INode_GetParents(self)
|
|
Parents = property(GetParents)
|
|
|
|
def RegisterCallback(self, INPUT):
|
|
return _genicam.INode_RegisterCallback(self, INPUT)
|
|
|
|
def DeregisterCallback(self, hCallback):
|
|
return _genicam.INode_DeregisterCallback(self, hCallback)
|
|
|
|
def GetNodeMap(self):
|
|
return _genicam.INode_GetNodeMap(self)
|
|
NodeMap = property(GetNodeMap)
|
|
|
|
def GetEventID(self):
|
|
return _genicam.INode_GetEventID(self)
|
|
EventID = property(GetEventID)
|
|
|
|
def IsStreamable(self):
|
|
return _genicam.INode_IsStreamable(self)
|
|
|
|
def GetPropertyNames(self):
|
|
return _genicam.INode_GetPropertyNames(self)
|
|
PropertyNames = property(GetPropertyNames)
|
|
|
|
def GetProperty(self, PropertyName):
|
|
return _genicam.INode_GetProperty(self, PropertyName)
|
|
|
|
def ImposeAccessMode(self, ImposedAccessMode):
|
|
return _genicam.INode_ImposeAccessMode(self, ImposedAccessMode)
|
|
|
|
def ImposeVisibility(self, ImposedVisibility):
|
|
return _genicam.INode_ImposeVisibility(self, ImposedVisibility)
|
|
|
|
def GetAlias(self):
|
|
return _genicam.INode_GetAlias(self)
|
|
Alias = property(GetAlias)
|
|
|
|
def GetCastAlias(self):
|
|
return _genicam.INode_GetCastAlias(self)
|
|
CastAlias = property(GetCastAlias)
|
|
|
|
def GetDocuURL(self):
|
|
return _genicam.INode_GetDocuURL(self)
|
|
DocuURL = property(GetDocuURL)
|
|
|
|
def IsDeprecated(self):
|
|
return _genicam.INode_IsDeprecated(self)
|
|
|
|
def GetPrincipalInterfaceType(self):
|
|
return _genicam.INode_GetPrincipalInterfaceType(self)
|
|
PrincipalInterfaceType = property(GetPrincipalInterfaceType)
|
|
|
|
def IsFeature(self):
|
|
return _genicam.INode_IsFeature(self)
|
|
|
|
def IsSelector(self):
|
|
return _genicam.INode_IsSelector(self)
|
|
|
|
def GetSelectedFeatures(self):
|
|
return _genicam.INode_GetSelectedFeatures(self)
|
|
|
|
def GetSelectingFeatures(self):
|
|
return _genicam.INode_GetSelectingFeatures(self)
|
|
|
|
# Register INode in _genicam:
|
|
_genicam.INode_swigregister(INode)
|
|
|
|
def IsReadable(*args):
|
|
r"""
|
|
|
|
|
|
Checks if a node is readable.
|
|
|
|
"""
|
|
return _genicam.IsReadable(*args)
|
|
|
|
def IsWritable(*args):
|
|
r"""
|
|
|
|
|
|
Checks if a node is Writable.
|
|
|
|
"""
|
|
return _genicam.IsWritable(*args)
|
|
|
|
def IsImplemented(*args):
|
|
r"""
|
|
|
|
|
|
Checks if a node is Implemented.
|
|
|
|
"""
|
|
return _genicam.IsImplemented(*args)
|
|
|
|
def IsAvailable(*args):
|
|
r"""
|
|
|
|
|
|
Checks if a node is Available.
|
|
|
|
"""
|
|
return _genicam.IsAvailable(*args)
|
|
|
|
def Combine(Peter, Paul):
|
|
r"""
|
|
|
|
|
|
Computes which CachingMode results from a combination.
|
|
|
|
"""
|
|
return _genicam.Combine(Peter, Paul)
|
|
|
|
def IsVisible(Visibility, MaxVisiblity):
|
|
r"""
|
|
|
|
|
|
Tests Visibility.
|
|
|
|
CAVE : this relys on the EVisibility enum's coding
|
|
|
|
"""
|
|
return _genicam.IsVisible(Visibility, MaxVisiblity)
|
|
|
|
def CombineVisibility(Peter, Paul):
|
|
r"""
|
|
|
|
|
|
Computes which CachingMode results from a combination.
|
|
|
|
"""
|
|
return _genicam.CombineVisibility(Peter, Paul)
|
|
|
|
def IsCacheable(CachingMode):
|
|
r"""
|
|
|
|
|
|
Tests Cacheability.
|
|
|
|
"""
|
|
return _genicam.IsCacheable(CachingMode)
|
|
|
|
def CombineCachingMode(Peter, Paul):
|
|
r"""
|
|
|
|
|
|
Computes which CachingMode results from a combination.
|
|
|
|
"""
|
|
return _genicam.CombineCachingMode(Peter, Paul)
|
|
class INodeMap(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
|
|
|
|
def GetNodes(self):
|
|
return _genicam.INodeMap_GetNodes(self)
|
|
|
|
def GetNode(self, Name):
|
|
return _genicam.INodeMap_GetNode(self, Name)
|
|
|
|
def InvalidateNodes(self):
|
|
return _genicam.INodeMap_InvalidateNodes(self)
|
|
|
|
def Connect(self, *args):
|
|
return _genicam.INodeMap_Connect(self, *args)
|
|
|
|
def GetDeviceName(self):
|
|
return _genicam.INodeMap_GetDeviceName(self)
|
|
|
|
def Poll(self, ElapsedTime):
|
|
return _genicam.INodeMap_Poll(self, ElapsedTime)
|
|
|
|
def GetLock(self):
|
|
return _genicam.INodeMap_GetLock(self)
|
|
|
|
def GetNumNodes(self):
|
|
return _genicam.INodeMap_GetNumNodes(self)
|
|
|
|
def ParseSwissKnifes(self, pErrorList=None):
|
|
return _genicam.INodeMap_ParseSwissKnifes(self, pErrorList)
|
|
DeviceName = property(GetDeviceName)
|
|
|
|
def GetDeviceInfo(self):
|
|
return _genicam.INodeMap_GetDeviceInfo(self)
|
|
DeviceInfo = property(GetDeviceInfo)
|
|
|
|
def __getattr__(self, attribute):
|
|
if attribute in self.__dict__ or attribute in ( "thisown","this") or attribute.startswith("__"):
|
|
return object.__getattr__(self, attribute)
|
|
else:
|
|
return self.GetNode(attribute)
|
|
|
|
def __setattr__(self, attribute, val):
|
|
if attribute in self.__dict__ or attribute in ( "thisown","this") or attribute.startswith("__"):
|
|
object.__setattr__(self, attribute, val)
|
|
else:
|
|
warnings.warn(f"Setting a feature value by direct assignment is deprecated. Use <nodemap>.{attribute}.Value = {val}", DeprecationWarning, stacklevel=2)
|
|
self.GetNode(attribute).SetValue(val)
|
|
|
|
def __dir__(self):
|
|
l = dir(type(self))
|
|
l.extend(self.__dict__.keys())
|
|
nodes = []
|
|
try:
|
|
nodes = self.GetNodeMap().GetNodes()
|
|
features = filter(lambda n: n.GetNode().IsFeature(), nodes)
|
|
l.extend(x.GetNode().GetName() for x in features)
|
|
except:
|
|
pass
|
|
try:
|
|
chunks = filter(lambda n: "ChunkData" in (f.Name for f in n.GetParents()), nodes)
|
|
l.extend(x.GetNode().GetName() for x in chunks)
|
|
except:
|
|
pass
|
|
return sorted(set(l))
|
|
|
|
|
|
# Register INodeMap in _genicam:
|
|
_genicam.INodeMap_swigregister(INodeMap)
|
|
cbPostInsideLock = _genicam.cbPostInsideLock
|
|
cbPostOutsideLock = _genicam.cbPostOutsideLock
|
|
class PyNodeCallback(object):
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
def __init__(self, pNode, PyFunc, CallbackType):
|
|
_genicam.PyNodeCallback_swiginit(self, _genicam.new_PyNodeCallback(pNode, PyFunc, CallbackType))
|
|
__swig_destroy__ = _genicam.delete_PyNodeCallback
|
|
|
|
def GetNode(self):
|
|
return _genicam.PyNodeCallback_GetNode(self)
|
|
|
|
# Register PyNodeCallback in _genicam:
|
|
_genicam.PyNodeCallback_swigregister(PyNodeCallback)
|
|
|
|
def Register(node, callback_fun, callback_type=cbPostInsideLock):
|
|
assert callback_type in ( cbPostOutsideLock, cbPostInsideLock)
|
|
cb = PyNodeCallback(node, callback_fun, callback_type)
|
|
cb.thisown = 0
|
|
return node.RegisterCallback(cb)
|
|
|
|
|
|
|
|
def Deregister(pCallbackInfo):
|
|
r"""
|
|
|
|
|
|
Unregistering callback by handle.
|
|
|
|
"""
|
|
return _genicam.Deregister(pCallbackInfo)
|
|
class IValue(IBase):
|
|
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
|
|
|
|
def GetNode(self):
|
|
return _genicam.IValue_GetNode(self)
|
|
|
|
def ToString(self, Verify=False, IgnoreCache=False):
|
|
return _genicam.IValue_ToString(self, Verify, IgnoreCache)
|
|
|
|
def FromString(self, ValueStr, Verify=True):
|
|
return _genicam.IValue_FromString(self, ValueStr, Verify)
|
|
|
|
def IsValueCacheValid(self):
|
|
return _genicam.IValue_IsValueCacheValid(self)
|
|
Node = property(GetNode)
|
|
|
|
# Register IValue in _genicam:
|
|
_genicam.IValue_swigregister(IValue)
|
|
class node_vector(object):
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
def iterator(self):
|
|
return _genicam.node_vector_iterator(self)
|
|
def __iter__(self):
|
|
return self.iterator()
|
|
|
|
def __nonzero__(self):
|
|
return _genicam.node_vector___nonzero__(self)
|
|
|
|
def __bool__(self):
|
|
return _genicam.node_vector___bool__(self)
|
|
|
|
def __len__(self):
|
|
return _genicam.node_vector___len__(self)
|
|
|
|
def __getslice__(self, i, j):
|
|
return _genicam.node_vector___getslice__(self, i, j)
|
|
|
|
def __setslice__(self, *args):
|
|
return _genicam.node_vector___setslice__(self, *args)
|
|
|
|
def __delslice__(self, i, j):
|
|
return _genicam.node_vector___delslice__(self, i, j)
|
|
|
|
def __delitem__(self, *args):
|
|
return _genicam.node_vector___delitem__(self, *args)
|
|
|
|
def __getitem__(self, *args):
|
|
return _genicam.node_vector___getitem__(self, *args)
|
|
|
|
def __setitem__(self, *args):
|
|
return _genicam.node_vector___setitem__(self, *args)
|
|
|
|
def pop(self):
|
|
return _genicam.node_vector_pop(self)
|
|
|
|
def append(self, x):
|
|
return _genicam.node_vector_append(self, x)
|
|
|
|
def empty(self):
|
|
return _genicam.node_vector_empty(self)
|
|
|
|
def size(self):
|
|
return _genicam.node_vector_size(self)
|
|
|
|
def swap(self, v):
|
|
return _genicam.node_vector_swap(self, v)
|
|
|
|
def begin(self):
|
|
return _genicam.node_vector_begin(self)
|
|
|
|
def end(self):
|
|
return _genicam.node_vector_end(self)
|
|
|
|
def rbegin(self):
|
|
return _genicam.node_vector_rbegin(self)
|
|
|
|
def rend(self):
|
|
return _genicam.node_vector_rend(self)
|
|
|
|
def clear(self):
|
|
return _genicam.node_vector_clear(self)
|
|
|
|
def get_allocator(self):
|
|
return _genicam.node_vector_get_allocator(self)
|
|
|
|
def pop_back(self):
|
|
return _genicam.node_vector_pop_back(self)
|
|
|
|
def erase(self, *args):
|
|
return _genicam.node_vector_erase(self, *args)
|
|
|
|
def __init__(self, *args):
|
|
_genicam.node_vector_swiginit(self, _genicam.new_node_vector(*args))
|
|
|
|
def push_back(self, x):
|
|
return _genicam.node_vector_push_back(self, x)
|
|
|
|
def front(self):
|
|
return _genicam.node_vector_front(self)
|
|
|
|
def back(self):
|
|
return _genicam.node_vector_back(self)
|
|
|
|
def assign(self, n, x):
|
|
return _genicam.node_vector_assign(self, n, x)
|
|
|
|
def resize(self, *args):
|
|
return _genicam.node_vector_resize(self, *args)
|
|
|
|
def insert(self, *args):
|
|
return _genicam.node_vector_insert(self, *args)
|
|
|
|
def reserve(self, n):
|
|
return _genicam.node_vector_reserve(self, n)
|
|
|
|
def capacity(self):
|
|
return _genicam.node_vector_capacity(self)
|
|
__swig_destroy__ = _genicam.delete_node_vector
|
|
|
|
# Register node_vector in _genicam:
|
|
_genicam.node_vector_swigregister(node_vector)
|
|
class value_vector(object):
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
def iterator(self):
|
|
return _genicam.value_vector_iterator(self)
|
|
def __iter__(self):
|
|
return self.iterator()
|
|
|
|
def __nonzero__(self):
|
|
return _genicam.value_vector___nonzero__(self)
|
|
|
|
def __bool__(self):
|
|
return _genicam.value_vector___bool__(self)
|
|
|
|
def __len__(self):
|
|
return _genicam.value_vector___len__(self)
|
|
|
|
def __getslice__(self, i, j):
|
|
return _genicam.value_vector___getslice__(self, i, j)
|
|
|
|
def __setslice__(self, *args):
|
|
return _genicam.value_vector___setslice__(self, *args)
|
|
|
|
def __delslice__(self, i, j):
|
|
return _genicam.value_vector___delslice__(self, i, j)
|
|
|
|
def __delitem__(self, *args):
|
|
return _genicam.value_vector___delitem__(self, *args)
|
|
|
|
def __getitem__(self, *args):
|
|
return _genicam.value_vector___getitem__(self, *args)
|
|
|
|
def __setitem__(self, *args):
|
|
return _genicam.value_vector___setitem__(self, *args)
|
|
|
|
def pop(self):
|
|
return _genicam.value_vector_pop(self)
|
|
|
|
def append(self, x):
|
|
return _genicam.value_vector_append(self, x)
|
|
|
|
def empty(self):
|
|
return _genicam.value_vector_empty(self)
|
|
|
|
def size(self):
|
|
return _genicam.value_vector_size(self)
|
|
|
|
def swap(self, v):
|
|
return _genicam.value_vector_swap(self, v)
|
|
|
|
def begin(self):
|
|
return _genicam.value_vector_begin(self)
|
|
|
|
def end(self):
|
|
return _genicam.value_vector_end(self)
|
|
|
|
def rbegin(self):
|
|
return _genicam.value_vector_rbegin(self)
|
|
|
|
def rend(self):
|
|
return _genicam.value_vector_rend(self)
|
|
|
|
def clear(self):
|
|
return _genicam.value_vector_clear(self)
|
|
|
|
def get_allocator(self):
|
|
return _genicam.value_vector_get_allocator(self)
|
|
|
|
def pop_back(self):
|
|
return _genicam.value_vector_pop_back(self)
|
|
|
|
def erase(self, *args):
|
|
return _genicam.value_vector_erase(self, *args)
|
|
|
|
def __init__(self, *args):
|
|
_genicam.value_vector_swiginit(self, _genicam.new_value_vector(*args))
|
|
|
|
def push_back(self, x):
|
|
return _genicam.value_vector_push_back(self, x)
|
|
|
|
def front(self):
|
|
return _genicam.value_vector_front(self)
|
|
|
|
def back(self):
|
|
return _genicam.value_vector_back(self)
|
|
|
|
def assign(self, n, x):
|
|
return _genicam.value_vector_assign(self, n, x)
|
|
|
|
def resize(self, *args):
|
|
return _genicam.value_vector_resize(self, *args)
|
|
|
|
def insert(self, *args):
|
|
return _genicam.value_vector_insert(self, *args)
|
|
|
|
def reserve(self, n):
|
|
return _genicam.value_vector_reserve(self, n)
|
|
|
|
def capacity(self):
|
|
return _genicam.value_vector_capacity(self)
|
|
__swig_destroy__ = _genicam.delete_value_vector
|
|
|
|
# Register value_vector in _genicam:
|
|
_genicam.value_vector_swigregister(value_vector)
|
|
class string_vector(object):
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
def iterator(self):
|
|
return _genicam.string_vector_iterator(self)
|
|
def __iter__(self):
|
|
return self.iterator()
|
|
|
|
def __nonzero__(self):
|
|
return _genicam.string_vector___nonzero__(self)
|
|
|
|
def __bool__(self):
|
|
return _genicam.string_vector___bool__(self)
|
|
|
|
def __len__(self):
|
|
return _genicam.string_vector___len__(self)
|
|
|
|
def __getslice__(self, i, j):
|
|
return _genicam.string_vector___getslice__(self, i, j)
|
|
|
|
def __setslice__(self, *args):
|
|
return _genicam.string_vector___setslice__(self, *args)
|
|
|
|
def __delslice__(self, i, j):
|
|
return _genicam.string_vector___delslice__(self, i, j)
|
|
|
|
def __delitem__(self, *args):
|
|
return _genicam.string_vector___delitem__(self, *args)
|
|
|
|
def __getitem__(self, *args):
|
|
return _genicam.string_vector___getitem__(self, *args)
|
|
|
|
def __setitem__(self, *args):
|
|
return _genicam.string_vector___setitem__(self, *args)
|
|
|
|
def pop(self):
|
|
return _genicam.string_vector_pop(self)
|
|
|
|
def append(self, x):
|
|
return _genicam.string_vector_append(self, x)
|
|
|
|
def empty(self):
|
|
return _genicam.string_vector_empty(self)
|
|
|
|
def size(self):
|
|
return _genicam.string_vector_size(self)
|
|
|
|
def swap(self, v):
|
|
return _genicam.string_vector_swap(self, v)
|
|
|
|
def begin(self):
|
|
return _genicam.string_vector_begin(self)
|
|
|
|
def end(self):
|
|
return _genicam.string_vector_end(self)
|
|
|
|
def rbegin(self):
|
|
return _genicam.string_vector_rbegin(self)
|
|
|
|
def rend(self):
|
|
return _genicam.string_vector_rend(self)
|
|
|
|
def clear(self):
|
|
return _genicam.string_vector_clear(self)
|
|
|
|
def get_allocator(self):
|
|
return _genicam.string_vector_get_allocator(self)
|
|
|
|
def pop_back(self):
|
|
return _genicam.string_vector_pop_back(self)
|
|
|
|
def erase(self, *args):
|
|
return _genicam.string_vector_erase(self, *args)
|
|
|
|
def __init__(self, *args):
|
|
_genicam.string_vector_swiginit(self, _genicam.new_string_vector(*args))
|
|
|
|
def push_back(self, x):
|
|
return _genicam.string_vector_push_back(self, x)
|
|
|
|
def front(self):
|
|
return _genicam.string_vector_front(self)
|
|
|
|
def back(self):
|
|
return _genicam.string_vector_back(self)
|
|
|
|
def assign(self, n, x):
|
|
return _genicam.string_vector_assign(self, n, x)
|
|
|
|
def resize(self, *args):
|
|
return _genicam.string_vector_resize(self, *args)
|
|
|
|
def insert(self, *args):
|
|
return _genicam.string_vector_insert(self, *args)
|
|
|
|
def reserve(self, n):
|
|
return _genicam.string_vector_reserve(self, n)
|
|
|
|
def capacity(self):
|
|
return _genicam.string_vector_capacity(self)
|
|
__swig_destroy__ = _genicam.delete_string_vector
|
|
|
|
# Register string_vector in _genicam:
|
|
_genicam.string_vector_swigregister(string_vector)
|
|
class IPort(IBase):
|
|
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
|
|
|
|
def Read(self, Address, pBuffer):
|
|
return _genicam.IPort_Read(self, Address, pBuffer)
|
|
|
|
def Write(self, Address, pBuffer):
|
|
return _genicam.IPort_Write(self, Address, pBuffer)
|
|
|
|
def GetNode(self):
|
|
return _genicam.IPort_GetNode(self)
|
|
|
|
def GetChunkID(self):
|
|
return _genicam.IPort_GetChunkID(self)
|
|
|
|
def CacheChunkData(self):
|
|
return _genicam.IPort_CacheChunkData(self)
|
|
|
|
def GetSwapEndianess(self):
|
|
return _genicam.IPort_GetSwapEndianess(self)
|
|
Node = property(GetNode)
|
|
ChunkID = property(GetChunkID)
|
|
|
|
# Register IPort in _genicam:
|
|
_genicam.IPort_swigregister(IPort)
|
|
CHUNK_BASE_ADDRESS_REGISTER_LEN = _genicam.CHUNK_BASE_ADDRESS_REGISTER_LEN
|
|
CHUNK_LENGTH_REGISTER_LEN = _genicam.CHUNK_LENGTH_REGISTER_LEN
|
|
class IChunkPort(IPort):
|
|
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
|
|
|
|
def GetChunkID(self):
|
|
return _genicam.IChunkPort_GetChunkID(self)
|
|
|
|
def CacheChunkData(self):
|
|
return _genicam.IChunkPort_CacheChunkData(self)
|
|
|
|
# Register IChunkPort in _genicam:
|
|
_genicam.IChunkPort_swigregister(IChunkPort)
|
|
class IPortConstruct(IPort):
|
|
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
|
|
|
|
def GetSwapEndianess(self):
|
|
return _genicam.IPortConstruct_GetSwapEndianess(self)
|
|
|
|
# Register IPortConstruct in _genicam:
|
|
_genicam.IPortConstruct_swigregister(IPortConstruct)
|
|
class IPortWriteList(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
|
|
|
|
def Write(self, pBuffer, Address, Length):
|
|
return _genicam.IPortWriteList_Write(self, pBuffer, Address, Length)
|
|
|
|
def Replay(self, pPort):
|
|
return _genicam.IPortWriteList_Replay(self, pPort)
|
|
|
|
def SetCookie(self, Value):
|
|
return _genicam.IPortWriteList_SetCookie(self, Value)
|
|
|
|
def GetCookie(self):
|
|
return _genicam.IPortWriteList_GetCookie(self)
|
|
|
|
# Register IPortWriteList in _genicam:
|
|
_genicam.IPortWriteList_swigregister(IPortWriteList)
|
|
class IPortReplay(IPort):
|
|
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
|
|
|
|
def Replay(self, pPortRecorder, Invalidate=True):
|
|
return _genicam.IPortReplay_Replay(self, pPortRecorder, Invalidate)
|
|
|
|
# Register IPortReplay in _genicam:
|
|
_genicam.IPortReplay_swigregister(IPortReplay)
|
|
class IPortRecorder(IPortReplay):
|
|
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
|
|
|
|
def StartRecording(self, pPortRecorder):
|
|
return _genicam.IPortRecorder_StartRecording(self, pPortRecorder)
|
|
|
|
def StopRecording(self):
|
|
return _genicam.IPortRecorder_StopRecording(self)
|
|
|
|
# Register IPortRecorder in _genicam:
|
|
_genicam.IPortRecorder_swigregister(IPortRecorder)
|
|
class CPortImpl(object):
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
def __init__(self):
|
|
if self.__class__ == CPortImpl:
|
|
_self = None
|
|
else:
|
|
_self = self
|
|
_genicam.CPortImpl_swiginit(self, _genicam.new_CPortImpl(_self, ))
|
|
__swig_destroy__ = _genicam.delete_CPortImpl
|
|
|
|
def GetAccessMode(self):
|
|
r"""
|
|
|
|
|
|
Get the access mode of the node.
|
|
|
|
Driver closed => NI, Driver open => RW, analysing a struct, RO
|
|
|
|
"""
|
|
return _genicam.CPortImpl_GetAccessMode(self)
|
|
|
|
def Read(self, Address, pBuffer):
|
|
return _genicam.CPortImpl_Read(self, Address, pBuffer)
|
|
|
|
def Write(self, Address, pBuffer):
|
|
return _genicam.CPortImpl_Write(self, Address, pBuffer)
|
|
|
|
def InvalidateNode(self):
|
|
r"""
|
|
|
|
|
|
"""
|
|
return _genicam.CPortImpl_InvalidateNode(self)
|
|
def __disown__(self):
|
|
self.this.disown()
|
|
_genicam.disown_CPortImpl(self)
|
|
return weakref.proxy(self)
|
|
|
|
# Register CPortImpl in _genicam:
|
|
_genicam.CPortImpl_swigregister(CPortImpl)
|
|
class IDeviceInfo(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
|
|
|
|
def GetModelName(self):
|
|
return _genicam.IDeviceInfo_GetModelName(self)
|
|
|
|
def GetVendorName(self):
|
|
return _genicam.IDeviceInfo_GetVendorName(self)
|
|
|
|
def GetToolTip(self):
|
|
return _genicam.IDeviceInfo_GetToolTip(self)
|
|
|
|
def GetStandardNameSpace(self):
|
|
return _genicam.IDeviceInfo_GetStandardNameSpace(self)
|
|
|
|
def GetGenApiVersion(self):
|
|
return _genicam.IDeviceInfo_GetGenApiVersion(self)
|
|
|
|
def GetSchemaVersion(self):
|
|
return _genicam.IDeviceInfo_GetSchemaVersion(self)
|
|
|
|
def GetDeviceVersion(self):
|
|
return _genicam.IDeviceInfo_GetDeviceVersion(self)
|
|
|
|
def GetProductGuid(self):
|
|
return _genicam.IDeviceInfo_GetProductGuid(self)
|
|
|
|
def GetVersionGuid(self):
|
|
return _genicam.IDeviceInfo_GetVersionGuid(self)
|
|
|
|
# Register IDeviceInfo in _genicam:
|
|
_genicam.IDeviceInfo_swigregister(IDeviceInfo)
|
|
class CNodeMapRef(object):
|
|
r"""
|
|
|
|
|
|
Smartpointer for NodeMaps with create function.
|
|
|
|
note: This class is a simple typedef definition. The class syntax is only used,
|
|
because Doxygen has to generate a useful documentation.
|
|
|
|
C++ includes: NodeMapRef.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"""
|
|
|
|
|
|
Copy constructor.
|
|
|
|
"""
|
|
_genicam.CNodeMapRef_swiginit(self, _genicam.new_CNodeMapRef(*args))
|
|
__swig_destroy__ = _genicam.delete_CNodeMapRef
|
|
|
|
def _LoadXMLFromFile(self, FileName):
|
|
return _genicam.CNodeMapRef__LoadXMLFromFile(self, FileName)
|
|
|
|
def _LoadXMLFromString(self, XMLData):
|
|
return _genicam.CNodeMapRef__LoadXMLFromString(self, XMLData)
|
|
|
|
def _GetDeviceName(self):
|
|
return _genicam.CNodeMapRef__GetDeviceName(self)
|
|
|
|
def _Poll(self, ElapsedTime):
|
|
return _genicam.CNodeMapRef__Poll(self, ElapsedTime)
|
|
|
|
def _Destroy(self):
|
|
return _genicam.CNodeMapRef__Destroy(self)
|
|
|
|
@staticmethod
|
|
def _ClearXMLCache():
|
|
return _genicam.CNodeMapRef__ClearXMLCache()
|
|
|
|
def _GetNodes(self):
|
|
return _genicam.CNodeMapRef__GetNodes(self)
|
|
|
|
def _GetNode(self, key):
|
|
return _genicam.CNodeMapRef__GetNode(self, key)
|
|
|
|
def GetNode(self, key):
|
|
return _genicam.CNodeMapRef_GetNode(self, key)
|
|
|
|
def _InvalidateNodes(self):
|
|
return _genicam.CNodeMapRef__InvalidateNodes(self)
|
|
|
|
def _Connect(self, *args):
|
|
return _genicam.CNodeMapRef__Connect(self, *args)
|
|
_Ptr = property(_genicam.CNodeMapRef__Ptr_get, _genicam.CNodeMapRef__Ptr_set)
|
|
|
|
def GetDeviceInfo(self):
|
|
return _genicam.CNodeMapRef_GetDeviceInfo(self)
|
|
DeviceInfo = property(GetDeviceInfo)
|
|
|
|
def __getattr__(self, attribute):
|
|
if attribute in self.__dict__ or attribute in ( "thisown","this") or attribute.startswith("__"):
|
|
return object.__getattr__(self, attribute)
|
|
else:
|
|
return self.GetNode(attribute)
|
|
|
|
def __setattr__(self, attribute, val):
|
|
if attribute in self.__dict__ or attribute in ( "thisown","this") or attribute.startswith("__"):
|
|
object.__setattr__(self, attribute, val)
|
|
else:
|
|
warnings.warn(f"Setting a feature value by direct assignment is deprecated. Use <nodemap>.{attribute}.Value = {val}", DeprecationWarning, stacklevel=2)
|
|
self.GetNode(attribute).SetValue(val)
|
|
|
|
def __dir__(self):
|
|
l = []
|
|
l += [x for x in dir(type(self))]
|
|
l += [x for x in self.__dict__.keys()]
|
|
try:
|
|
l += [x.GetNode().GetName() for x in filter(lambda n: n.GetNode().IsFeature(), self.GetNodeMap().GetNodes())]
|
|
except:
|
|
pass
|
|
return sorted(set(l))
|
|
|
|
|
|
# Register CNodeMapRef in _genicam:
|
|
_genicam.CNodeMapRef_swigregister(CNodeMapRef)
|
|
class IFloat(IValue):
|
|
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
|
|
|
|
def SetValue(self, Value, Verify=True):
|
|
return _genicam.IFloat_SetValue(self, Value, Verify)
|
|
|
|
def GetValue(self, Verify=False, IgnoreCache=False):
|
|
return _genicam.IFloat_GetValue(self, Verify, IgnoreCache)
|
|
|
|
def __call__(self):
|
|
return _genicam.IFloat___call__(self)
|
|
|
|
def GetMin(self):
|
|
return _genicam.IFloat_GetMin(self)
|
|
|
|
def GetMax(self):
|
|
return _genicam.IFloat_GetMax(self)
|
|
|
|
def HasInc(self):
|
|
return _genicam.IFloat_HasInc(self)
|
|
|
|
def GetIncMode(self):
|
|
return _genicam.IFloat_GetIncMode(self)
|
|
|
|
def GetInc(self):
|
|
return _genicam.IFloat_GetInc(self)
|
|
|
|
def GetListOfValidValues(self, bounded=True):
|
|
return _genicam.IFloat_GetListOfValidValues(self, bounded)
|
|
|
|
def GetRepresentation(self):
|
|
return _genicam.IFloat_GetRepresentation(self)
|
|
|
|
def GetUnit(self):
|
|
return _genicam.IFloat_GetUnit(self)
|
|
|
|
def GetDisplayNotation(self):
|
|
return _genicam.IFloat_GetDisplayNotation(self)
|
|
|
|
def GetDisplayPrecision(self):
|
|
return _genicam.IFloat_GetDisplayPrecision(self)
|
|
|
|
def ImposeMin(self, Value):
|
|
return _genicam.IFloat_ImposeMin(self, Value)
|
|
|
|
def ImposeMax(self, Value):
|
|
return _genicam.IFloat_ImposeMax(self, Value)
|
|
|
|
def GetIntAlias(self):
|
|
return _genicam.IFloat_GetIntAlias(self)
|
|
|
|
def GetEnumAlias(self):
|
|
return _genicam.IFloat_GetEnumAlias(self)
|
|
Value = property(GetValue,SetValue)
|
|
Min = property(GetMin)
|
|
Max = property(GetMax)
|
|
IncMode = property(GetIncMode)
|
|
Inc = property(GetInc)
|
|
ListOfValidValues = property(GetListOfValidValues)
|
|
Representation = property(GetRepresentation)
|
|
Unit = property(GetUnit)
|
|
DisplayNotation = property(GetDisplayNotation)
|
|
DisplayPrecision = property(GetDisplayPrecision)
|
|
IntAlias = property(GetIntAlias)
|
|
EnumAlias = property(GetEnumAlias)
|
|
|
|
# Register IFloat in _genicam:
|
|
_genicam.IFloat_swigregister(IFloat)
|
|
class IInteger(IValue):
|
|
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
|
|
|
|
def SetValue(self, Value, Verify=True):
|
|
return _genicam.IInteger_SetValue(self, Value, Verify)
|
|
|
|
def GetValue(self, Verify=False, IgnoreCache=False):
|
|
return _genicam.IInteger_GetValue(self, Verify, IgnoreCache)
|
|
|
|
def __call__(self):
|
|
return _genicam.IInteger___call__(self)
|
|
|
|
def GetMin(self):
|
|
return _genicam.IInteger_GetMin(self)
|
|
|
|
def GetMax(self):
|
|
return _genicam.IInteger_GetMax(self)
|
|
|
|
def GetIncMode(self):
|
|
return _genicam.IInteger_GetIncMode(self)
|
|
|
|
def GetInc(self):
|
|
return _genicam.IInteger_GetInc(self)
|
|
|
|
def GetListOfValidValues(self, bounded=True):
|
|
return _genicam.IInteger_GetListOfValidValues(self, bounded)
|
|
|
|
def GetRepresentation(self):
|
|
return _genicam.IInteger_GetRepresentation(self)
|
|
|
|
def GetUnit(self):
|
|
return _genicam.IInteger_GetUnit(self)
|
|
|
|
def ImposeMin(self, Value):
|
|
return _genicam.IInteger_ImposeMin(self, Value)
|
|
|
|
def ImposeMax(self, Value):
|
|
return _genicam.IInteger_ImposeMax(self, Value)
|
|
|
|
def GetFloatAlias(self):
|
|
return _genicam.IInteger_GetFloatAlias(self)
|
|
|
|
def Set(self, pBuffer, Verify=True):
|
|
return _genicam.IInteger_Set(self, pBuffer, Verify)
|
|
|
|
def Get(self, pBuffer, Verify=False, IgnoreCache=False):
|
|
return _genicam.IInteger_Get(self, pBuffer, Verify, IgnoreCache)
|
|
|
|
def GetLength(self):
|
|
return _genicam.IInteger_GetLength(self)
|
|
|
|
def GetAddress(self):
|
|
return _genicam.IInteger_GetAddress(self)
|
|
Value = property(GetValue,SetValue)
|
|
Min = property(GetMin)
|
|
Max = property(GetMax)
|
|
IncMode = property(GetIncMode)
|
|
Inc = property(GetInc)
|
|
ListOfValidValues = property(GetListOfValidValues)
|
|
Representation = property(GetRepresentation)
|
|
Unit = property(GetUnit)
|
|
FloatAlias = property(GetFloatAlias)
|
|
Address = property(GetAddress)
|
|
Length = property(GetLength)
|
|
|
|
# Register IInteger in _genicam:
|
|
_genicam.IInteger_swigregister(IInteger)
|
|
class IRegister(IValue):
|
|
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
|
|
|
|
def Set(self, pBuffer, Verify=True):
|
|
return _genicam.IRegister_Set(self, pBuffer, Verify)
|
|
|
|
def Get(self, pBuffer, Verify=False, IgnoreCache=False):
|
|
return _genicam.IRegister_Get(self, pBuffer, Verify, IgnoreCache)
|
|
|
|
def GetLength(self):
|
|
return _genicam.IRegister_GetLength(self)
|
|
|
|
def GetAddress(self):
|
|
return _genicam.IRegister_GetAddress(self)
|
|
Length = property(GetLength)
|
|
Address = property(GetAddress)
|
|
|
|
# Register IRegister in _genicam:
|
|
_genicam.IRegister_swigregister(IRegister)
|
|
|
|
def GetAll(self):
|
|
return self.Get(self.GetLength())
|
|
IRegister.GetAll = GetAll
|
|
|
|
class IEnumEntry(IValue):
|
|
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
|
|
|
|
def GetValue(self):
|
|
return _genicam.IEnumEntry_GetValue(self)
|
|
|
|
def GetSymbolic(self):
|
|
return _genicam.IEnumEntry_GetSymbolic(self)
|
|
|
|
def GetNumericValue(self):
|
|
return _genicam.IEnumEntry_GetNumericValue(self)
|
|
|
|
def IsSelfClearing(self):
|
|
return _genicam.IEnumEntry_IsSelfClearing(self)
|
|
Value = property(GetValue)
|
|
Symbolic = property(GetSymbolic)
|
|
NumericValue = property(GetNumericValue)
|
|
|
|
def __call__( self ):
|
|
return self.GetValue()
|
|
|
|
|
|
# Register IEnumEntry in _genicam:
|
|
_genicam.IEnumEntry_swigregister(IEnumEntry)
|
|
class IEnumeration(IValue):
|
|
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
|
|
|
|
def GetSymbolics(self):
|
|
return _genicam.IEnumeration_GetSymbolics(self)
|
|
|
|
def GetEntries(self):
|
|
return _genicam.IEnumeration_GetEntries(self)
|
|
|
|
def SetIntValue(self, Value, Verify=True):
|
|
return _genicam.IEnumeration_SetIntValue(self, Value, Verify)
|
|
|
|
def GetIntValue(self, Verify=False, IgnoreCache=False):
|
|
return _genicam.IEnumeration_GetIntValue(self, Verify, IgnoreCache)
|
|
|
|
def GetEntryByName(self, Symbolic):
|
|
return _genicam.IEnumeration_GetEntryByName(self, Symbolic)
|
|
|
|
def GetEntry(self, IntValue):
|
|
return _genicam.IEnumeration_GetEntry(self, IntValue)
|
|
|
|
def GetCurrentEntry(self, Verify=False, IgnoreCache=False):
|
|
return _genicam.IEnumeration_GetCurrentEntry(self, Verify, IgnoreCache)
|
|
|
|
def __call__(self):
|
|
return _genicam.IEnumeration___call__(self)
|
|
|
|
def GetValue(self):
|
|
return _genicam.IEnumeration_GetValue(self)
|
|
|
|
def SetValue(self, entry):
|
|
return _genicam.IEnumeration_SetValue(self, entry)
|
|
Symbolics = property(GetSymbolics)
|
|
Entries = property(GetEntries)
|
|
IntValue = property(GetIntValue,SetIntValue)
|
|
Value = property(GetValue,SetValue)
|
|
|
|
# Register IEnumeration in _genicam:
|
|
_genicam.IEnumeration_swigregister(IEnumeration)
|
|
class IBoolean(IValue):
|
|
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
|
|
|
|
def SetValue(self, Value, Verify=True):
|
|
return _genicam.IBoolean_SetValue(self, Value, Verify)
|
|
|
|
def GetValue(self, Verify=False, IgnoreCache=False):
|
|
return _genicam.IBoolean_GetValue(self, Verify, IgnoreCache)
|
|
|
|
def __call__(self):
|
|
return _genicam.IBoolean___call__(self)
|
|
Value = property(GetValue,SetValue)
|
|
|
|
# Register IBoolean in _genicam:
|
|
_genicam.IBoolean_swigregister(IBoolean)
|
|
class ICommand(IValue):
|
|
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
|
|
|
|
def Execute(self, Verify=True):
|
|
return _genicam.ICommand_Execute(self, Verify)
|
|
|
|
def __call__(self):
|
|
return _genicam.ICommand___call__(self)
|
|
|
|
def IsDone(self, Verify=True):
|
|
return _genicam.ICommand_IsDone(self, Verify)
|
|
|
|
# Register ICommand in _genicam:
|
|
_genicam.ICommand_swigregister(ICommand)
|
|
class IString(IValue):
|
|
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
|
|
|
|
def SetValue(self, Value, Verify=True):
|
|
return _genicam.IString_SetValue(self, Value, Verify)
|
|
|
|
def GetValue(self, Verify=False, IgnoreCache=False):
|
|
return _genicam.IString_GetValue(self, Verify, IgnoreCache)
|
|
|
|
def __call__(self):
|
|
return _genicam.IString___call__(self)
|
|
|
|
def GetMaxLength(self):
|
|
return _genicam.IString_GetMaxLength(self)
|
|
|
|
def GetLength(self):
|
|
return _genicam.IString_GetLength(self)
|
|
Value = property(GetValue,SetValue)
|
|
MaxLength = property(GetMaxLength)
|
|
Length = property(GetLength)
|
|
|
|
# Register IString in _genicam:
|
|
_genicam.IString_swigregister(IString)
|
|
class ICategory(IValue):
|
|
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
|
|
|
|
def GetFeatures(self):
|
|
return _genicam.ICategory_GetFeatures(self)
|
|
Features = property(GetFeatures)
|
|
|
|
# Register ICategory in _genicam:
|
|
_genicam.ICategory_swigregister(ICategory)
|
|
class IReference(object):
|
|
r"""
|
|
|
|
|
|
"""
|
|
|
|
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
|
|
|
|
def SetReference(self, pBase):
|
|
return _genicam.IReference_SetReference(self, pBase)
|
|
|
|
# Register IReference in _genicam:
|
|
_genicam.IReference_swigregister(IReference)
|
|
class IEnumReference(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
|
|
|
|
def SetEnumReference(self, Index, Name):
|
|
return _genicam.IEnumReference_SetEnumReference(self, Index, Name)
|
|
|
|
def SetNumEnums(self, NumEnums):
|
|
return _genicam.IEnumReference_SetNumEnums(self, NumEnums)
|
|
|
|
# Register IEnumReference in _genicam:
|
|
_genicam.IEnumReference_swigregister(IEnumReference)
|
|
class ISelector(IBase):
|
|
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
|
|
|
|
# Register ISelector in _genicam:
|
|
_genicam.ISelector_swigregister(ISelector)
|
|
class ISelectorDigit(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
|
|
|
|
def SetFirst(self):
|
|
return _genicam.ISelectorDigit_SetFirst(self)
|
|
|
|
def SetNext(self, Tick=True):
|
|
return _genicam.ISelectorDigit_SetNext(self, Tick)
|
|
|
|
def Restore(self):
|
|
return _genicam.ISelectorDigit_Restore(self)
|
|
|
|
def ToString(self):
|
|
return _genicam.ISelectorDigit_ToString(self)
|
|
|
|
def GetSelectorList(self, Incremental=False):
|
|
return _genicam.ISelectorDigit_GetSelectorList(self, Incremental)
|
|
|
|
# Register ISelectorDigit in _genicam:
|
|
_genicam.ISelectorDigit_swigregister(ISelectorDigit)
|
|
class CSelectorSet(ISelectorDigit):
|
|
r"""
|
|
|
|
|
|
The set of selectors selecting a given node.
|
|
|
|
C++ includes: SelectorSet.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, pBase):
|
|
r"""
|
|
|
|
|
|
Constructor.
|
|
|
|
"""
|
|
_genicam.CSelectorSet_swiginit(self, _genicam.new_CSelectorSet(pBase))
|
|
__swig_destroy__ = _genicam.delete_CSelectorSet
|
|
|
|
def IsEmpty(self):
|
|
r"""
|
|
|
|
|
|
returns true if no selectors are present
|
|
|
|
"""
|
|
return _genicam.CSelectorSet_IsEmpty(self)
|
|
|
|
def SetFirst(self):
|
|
r"""
|
|
|
|
|
|
"""
|
|
return _genicam.CSelectorSet_SetFirst(self)
|
|
|
|
def SetNext(self, Tick=True):
|
|
r"""
|
|
|
|
|
|
"""
|
|
return _genicam.CSelectorSet_SetNext(self, Tick)
|
|
|
|
def Restore(self):
|
|
r"""
|
|
|
|
|
|
"""
|
|
return _genicam.CSelectorSet_Restore(self)
|
|
|
|
def ToString(self):
|
|
r"""
|
|
|
|
|
|
"""
|
|
return _genicam.CSelectorSet_ToString(self)
|
|
|
|
def GetSelectorList(self, Incremental=False):
|
|
r"""
|
|
|
|
|
|
"""
|
|
return _genicam.CSelectorSet_GetSelectorList(self, Incremental)
|
|
|
|
# Register CSelectorSet in _genicam:
|
|
_genicam.CSelectorSet_swigregister(CSelectorSet)
|
|
class ChunkPort(IPortConstruct):
|
|
r"""
|
|
|
|
|
|
Port attachable to a chunk in a buffer.
|
|
|
|
C++ includes: ChunkPort.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, pPort=None):
|
|
r"""
|
|
|
|
|
|
Constructor; can attach to a port.
|
|
|
|
"""
|
|
_genicam.ChunkPort_swiginit(self, _genicam.new_ChunkPort(pPort))
|
|
__swig_destroy__ = _genicam.delete_ChunkPort
|
|
|
|
def GetAccessMode(self):
|
|
r"""
|
|
|
|
|
|
Get the access mode of the node.
|
|
|
|
"""
|
|
return _genicam.ChunkPort_GetAccessMode(self)
|
|
|
|
def GetPrincipalInterfaceType(self):
|
|
r"""
|
|
|
|
|
|
Get the type of the main interface of a node.
|
|
|
|
"""
|
|
return _genicam.ChunkPort_GetPrincipalInterfaceType(self)
|
|
|
|
def Read(self, pBuffer, Address, Length):
|
|
r"""
|
|
|
|
|
|
Reads a chunk of bytes from the port.
|
|
|
|
"""
|
|
return _genicam.ChunkPort_Read(self, pBuffer, Address, Length)
|
|
|
|
def Write(self, pBuffer, Address, Length):
|
|
r"""
|
|
|
|
|
|
Writes a chunk of bytes to the port.
|
|
|
|
"""
|
|
return _genicam.ChunkPort_Write(self, pBuffer, Address, Length)
|
|
|
|
def SetPortImpl(self, pPort):
|
|
r"""
|
|
|
|
|
|
Called from the port node to give the chunk port a pointer to itself.
|
|
|
|
"""
|
|
return _genicam.ChunkPort_SetPortImpl(self, pPort)
|
|
|
|
def GetSwapEndianess(self):
|
|
r"""
|
|
|
|
|
|
Determines if the port adapter must perform an endianess swap.
|
|
|
|
"""
|
|
return _genicam.ChunkPort_GetSwapEndianess(self)
|
|
|
|
def InvalidateNode(self):
|
|
r"""
|
|
|
|
|
|
"""
|
|
return _genicam.ChunkPort_InvalidateNode(self)
|
|
|
|
def AttachPort(self, pPort):
|
|
r"""
|
|
|
|
|
|
Attaches the ChunkPort to the Port.
|
|
|
|
"""
|
|
return _genicam.ChunkPort_AttachPort(self, pPort)
|
|
|
|
def DetachPort(self):
|
|
r"""
|
|
|
|
|
|
Detaches the ChunkPort to the Port.
|
|
|
|
"""
|
|
return _genicam.ChunkPort_DetachPort(self)
|
|
|
|
def AttachChunk(self, pBaseAddress, ChunkOffset, Length, Cache):
|
|
r"""
|
|
|
|
|
|
Attaches the Chunk to the ChunkPort.
|
|
|
|
"""
|
|
return _genicam.ChunkPort_AttachChunk(self, pBaseAddress, ChunkOffset, Length, Cache)
|
|
|
|
def DetachChunk(self):
|
|
r"""
|
|
|
|
|
|
Detaches the Chunk from the ChunkPort.
|
|
|
|
"""
|
|
return _genicam.ChunkPort_DetachChunk(self)
|
|
|
|
def GetChunkIDLength(self):
|
|
r"""
|
|
|
|
|
|
Gets the ChunkID length.
|
|
|
|
"""
|
|
return _genicam.ChunkPort_GetChunkIDLength(self)
|
|
|
|
def CheckChunkID(self, *args):
|
|
r"""
|
|
|
|
|
|
Checks if a ChunkID matches, version using uint64_t ID representation.
|
|
|
|
"""
|
|
return _genicam.ChunkPort_CheckChunkID(self, *args)
|
|
|
|
def UpdateBuffer(self, pBaseAddress):
|
|
r"""
|
|
|
|
|
|
Updates the base address of the chunk.
|
|
|
|
"""
|
|
return _genicam.ChunkPort_UpdateBuffer(self, pBaseAddress)
|
|
|
|
def ClearCache(self):
|
|
r"""
|
|
|
|
|
|
Clears the chunk cache.
|
|
|
|
"""
|
|
return _genicam.ChunkPort_ClearCache(self)
|
|
AccessMode = property(GetAccessMode)
|
|
PrincipalInterfaceType = property(GetPrincipalInterfaceType)
|
|
|
|
# Register ChunkPort in _genicam:
|
|
_genicam.ChunkPort_swigregister(ChunkPort)
|
|
|
|
CChunkPort = ChunkPort
|
|
|
|
class AttachStatistics_t(object):
|
|
r"""
|
|
|
|
|
|
Delivers information about the attached chunks and nodes
|
|
|
|
C++ includes: ChunkAdapter.h
|
|
|
|
"""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
NumChunkPorts = property(_genicam.AttachStatistics_t_NumChunkPorts_get, _genicam.AttachStatistics_t_NumChunkPorts_set)
|
|
NumChunks = property(_genicam.AttachStatistics_t_NumChunks_get, _genicam.AttachStatistics_t_NumChunks_set)
|
|
NumAttachedChunks = property(_genicam.AttachStatistics_t_NumAttachedChunks_get, _genicam.AttachStatistics_t_NumAttachedChunks_set)
|
|
|
|
def __init__(self):
|
|
_genicam.AttachStatistics_t_swiginit(self, _genicam.new_AttachStatistics_t())
|
|
__swig_destroy__ = _genicam.delete_AttachStatistics_t
|
|
|
|
# Register AttachStatistics_t in _genicam:
|
|
_genicam.AttachStatistics_t_swigregister(AttachStatistics_t)
|
|
class ChunkAdapter(object):
|
|
r"""
|
|
|
|
|
|
Connects a chunked buffer to a node map.
|
|
|
|
C++ includes: ChunkAdapter.h
|
|
|
|
"""
|
|
|
|
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__ = _genicam.delete_ChunkAdapter
|
|
|
|
def AttachNodeMap(self, pNodeMap):
|
|
r"""
|
|
|
|
|
|
Attaches to a node map and retrieves the chunk ports.
|
|
|
|
"""
|
|
return _genicam.ChunkAdapter_AttachNodeMap(self, pNodeMap)
|
|
|
|
def DetachNodeMap(self):
|
|
r"""
|
|
|
|
|
|
Detaches from the node map.
|
|
|
|
"""
|
|
return _genicam.ChunkAdapter_DetachNodeMap(self)
|
|
|
|
def CheckBufferLayout(self, pBuffer):
|
|
r"""
|
|
|
|
|
|
Checks if a buffer contains chunks in a known format.
|
|
|
|
Implement that for a specific buffer layout
|
|
|
|
"""
|
|
return _genicam.ChunkAdapter_CheckBufferLayout(self, pBuffer)
|
|
|
|
def AttachBuffer(self, pBuffer, pAttachStatistics=None):
|
|
r"""
|
|
|
|
|
|
Attaches a buffer to the matching ChunkPort.
|
|
|
|
Implement that for a specific buffer layout
|
|
|
|
"""
|
|
return _genicam.ChunkAdapter_AttachBuffer(self, pBuffer, pAttachStatistics)
|
|
|
|
def DetachBuffer(self):
|
|
r"""
|
|
|
|
|
|
Detaches a buffer.
|
|
|
|
"""
|
|
return _genicam.ChunkAdapter_DetachBuffer(self)
|
|
|
|
def UpdateBuffer(self, pBaseAddress):
|
|
r"""
|
|
|
|
|
|
Updates the base address of the buffer.
|
|
|
|
"""
|
|
return _genicam.ChunkAdapter_UpdateBuffer(self, pBaseAddress)
|
|
|
|
def ClearCaches(self):
|
|
r"""
|
|
|
|
|
|
Clears the chunk caches.
|
|
|
|
"""
|
|
return _genicam.ChunkAdapter_ClearCaches(self)
|
|
|
|
# Register ChunkAdapter in _genicam:
|
|
_genicam.ChunkAdapter_swigregister(ChunkAdapter)
|
|
|
|
CChunkAdapter = ChunkAdapter
|
|
|
|
class GVCP_CHUNK_TRAILER(object):
|
|
r"""
|
|
|
|
|
|
header of a GVCP request packet
|
|
|
|
C++ includes: ChunkAdapterGEV.h
|
|
|
|
"""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
ChunkID = property(_genicam.GVCP_CHUNK_TRAILER_ChunkID_get, _genicam.GVCP_CHUNK_TRAILER_ChunkID_set)
|
|
ChunkLength = property(_genicam.GVCP_CHUNK_TRAILER_ChunkLength_get, _genicam.GVCP_CHUNK_TRAILER_ChunkLength_set)
|
|
|
|
def __init__(self):
|
|
_genicam.GVCP_CHUNK_TRAILER_swiginit(self, _genicam.new_GVCP_CHUNK_TRAILER())
|
|
__swig_destroy__ = _genicam.delete_GVCP_CHUNK_TRAILER
|
|
|
|
# Register GVCP_CHUNK_TRAILER in _genicam:
|
|
_genicam.GVCP_CHUNK_TRAILER_swigregister(GVCP_CHUNK_TRAILER)
|
|
class ChunkAdapterGEV(ChunkAdapter):
|
|
r"""
|
|
|
|
|
|
Connects a chunked DCAM buffer to a node map.
|
|
|
|
C++ includes: ChunkAdapterGEV.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, pNodeMap=None, MaxChunkCacheSize=-1):
|
|
r"""
|
|
|
|
|
|
Constructor.
|
|
|
|
"""
|
|
_genicam.ChunkAdapterGEV_swiginit(self, _genicam.new_ChunkAdapterGEV(pNodeMap, MaxChunkCacheSize))
|
|
__swig_destroy__ = _genicam.delete_ChunkAdapterGEV
|
|
|
|
def CheckBufferLayout(self, pBuffer):
|
|
r"""
|
|
|
|
|
|
Checks if a buffer contains chunks in a known format.
|
|
|
|
"""
|
|
return _genicam.ChunkAdapterGEV_CheckBufferLayout(self, pBuffer)
|
|
|
|
def AttachBuffer(self, pBuffer, pAttachStatistics=None):
|
|
r"""
|
|
|
|
|
|
Attaches a buffer to the matching ChunkPort.
|
|
|
|
"""
|
|
return _genicam.ChunkAdapterGEV_AttachBuffer(self, pBuffer, pAttachStatistics)
|
|
|
|
# Register ChunkAdapterGEV in _genicam:
|
|
_genicam.ChunkAdapterGEV_swigregister(ChunkAdapterGEV)
|
|
|
|
CChunkAdapterGEV = ChunkAdapterGEV
|
|
|
|
class U3V_CHUNK_TRAILER(object):
|
|
r"""
|
|
|
|
|
|
header of a GVCP request packet
|
|
|
|
C++ includes: ChunkAdapterU3V.h
|
|
|
|
"""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
ChunkID = property(_genicam.U3V_CHUNK_TRAILER_ChunkID_get, _genicam.U3V_CHUNK_TRAILER_ChunkID_set)
|
|
ChunkLength = property(_genicam.U3V_CHUNK_TRAILER_ChunkLength_get, _genicam.U3V_CHUNK_TRAILER_ChunkLength_set)
|
|
|
|
def __init__(self):
|
|
_genicam.U3V_CHUNK_TRAILER_swiginit(self, _genicam.new_U3V_CHUNK_TRAILER())
|
|
__swig_destroy__ = _genicam.delete_U3V_CHUNK_TRAILER
|
|
|
|
# Register U3V_CHUNK_TRAILER in _genicam:
|
|
_genicam.U3V_CHUNK_TRAILER_swigregister(U3V_CHUNK_TRAILER)
|
|
class ChunkAdapterU3V(ChunkAdapter):
|
|
r"""
|
|
|
|
|
|
Connects a chunked U3V buffer to a node map.
|
|
|
|
C++ includes: ChunkAdapterU3V.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, pNodeMap=None, MaxChunkCacheSize=-1):
|
|
r"""
|
|
|
|
|
|
Constructor.
|
|
|
|
"""
|
|
_genicam.ChunkAdapterU3V_swiginit(self, _genicam.new_ChunkAdapterU3V(pNodeMap, MaxChunkCacheSize))
|
|
__swig_destroy__ = _genicam.delete_ChunkAdapterU3V
|
|
|
|
def CheckBufferLayout(self, pBuffer):
|
|
r"""
|
|
|
|
|
|
Checks if a buffer contains chunks in a known format.
|
|
|
|
"""
|
|
return _genicam.ChunkAdapterU3V_CheckBufferLayout(self, pBuffer)
|
|
|
|
def AttachBuffer(self, pBuffer, pAttachStatistics=None):
|
|
r"""
|
|
|
|
|
|
Attaches a buffer to the matching ChunkPort.
|
|
|
|
"""
|
|
return _genicam.ChunkAdapterU3V_AttachBuffer(self, pBuffer, pAttachStatistics)
|
|
|
|
# Register ChunkAdapterU3V in _genicam:
|
|
_genicam.ChunkAdapterU3V_swigregister(ChunkAdapterU3V)
|
|
|
|
CChunkAdapterU3V = ChunkAdapterU3V
|
|
|
|
class SingleChunkData_t(object):
|
|
r"""
|
|
|
|
|
|
"""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
ChunkID = property(_genicam.SingleChunkData_t_ChunkID_get, _genicam.SingleChunkData_t_ChunkID_set)
|
|
ChunkOffset = property(_genicam.SingleChunkData_t_ChunkOffset_get, _genicam.SingleChunkData_t_ChunkOffset_set)
|
|
ChunkLength = property(_genicam.SingleChunkData_t_ChunkLength_get, _genicam.SingleChunkData_t_ChunkLength_set)
|
|
|
|
def __init__(self):
|
|
_genicam.SingleChunkData_t_swiginit(self, _genicam.new_SingleChunkData_t())
|
|
__swig_destroy__ = _genicam.delete_SingleChunkData_t
|
|
|
|
# Register SingleChunkData_t in _genicam:
|
|
_genicam.SingleChunkData_t_swigregister(SingleChunkData_t)
|
|
class SingleChunkDataStr_t(object):
|
|
r"""
|
|
|
|
|
|
"""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
ChunkID = property(_genicam.SingleChunkDataStr_t_ChunkID_get, _genicam.SingleChunkDataStr_t_ChunkID_set)
|
|
ChunkOffset = property(_genicam.SingleChunkDataStr_t_ChunkOffset_get, _genicam.SingleChunkDataStr_t_ChunkOffset_set)
|
|
ChunkLength = property(_genicam.SingleChunkDataStr_t_ChunkLength_get, _genicam.SingleChunkDataStr_t_ChunkLength_set)
|
|
|
|
def __init__(self):
|
|
_genicam.SingleChunkDataStr_t_swiginit(self, _genicam.new_SingleChunkDataStr_t())
|
|
__swig_destroy__ = _genicam.delete_SingleChunkDataStr_t
|
|
|
|
# Register SingleChunkDataStr_t in _genicam:
|
|
_genicam.SingleChunkDataStr_t_swigregister(SingleChunkDataStr_t)
|
|
class ChunkAdapterGeneric(ChunkAdapter):
|
|
r"""
|
|
|
|
|
|
Connects a generic chunked buffer to a node map.
|
|
|
|
C++ includes: ChunkAdapterGeneric.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, pNodeMap=None, MaxChunkCacheSize=-1):
|
|
r"""
|
|
|
|
|
|
Constructor.
|
|
|
|
"""
|
|
_genicam.ChunkAdapterGeneric_swiginit(self, _genicam.new_ChunkAdapterGeneric(pNodeMap, MaxChunkCacheSize))
|
|
__swig_destroy__ = _genicam.delete_ChunkAdapterGeneric
|
|
|
|
def CheckBufferLayout(self, pBuffer):
|
|
r"""
|
|
|
|
|
|
Checks if a buffer contains chunks in a known format.
|
|
|
|
Implement that for a specific buffer layout
|
|
|
|
"""
|
|
return _genicam.ChunkAdapterGeneric_CheckBufferLayout(self, pBuffer)
|
|
|
|
def AttachBuffer(self, *args):
|
|
r"""
|
|
|
|
|
|
"""
|
|
return _genicam.ChunkAdapterGeneric_AttachBuffer(self, *args)
|
|
|
|
# Register ChunkAdapterGeneric in _genicam:
|
|
_genicam.ChunkAdapterGeneric_swigregister(ChunkAdapterGeneric)
|
|
|
|
CChunkAdapterGeneric = ChunkAdapterGeneric
|
|
|
|
class EventPort(IPortConstruct):
|
|
r"""
|
|
|
|
|
|
Port attachable to an event.
|
|
|
|
C++ includes: EventPort.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, pNode=None):
|
|
r"""
|
|
|
|
|
|
Constructor; can attach to a node.
|
|
|
|
"""
|
|
_genicam.EventPort_swiginit(self, _genicam.new_EventPort(pNode))
|
|
__swig_destroy__ = _genicam.delete_EventPort
|
|
|
|
def GetAccessMode(self):
|
|
r"""
|
|
|
|
|
|
Get the access mode of the node.
|
|
|
|
"""
|
|
return _genicam.EventPort_GetAccessMode(self)
|
|
|
|
def GetPrincipalInterfaceType(self):
|
|
r"""
|
|
|
|
|
|
Get the type of the main interface of a node.
|
|
|
|
"""
|
|
return _genicam.EventPort_GetPrincipalInterfaceType(self)
|
|
|
|
def Read(self, pBuffer, Address, Length):
|
|
r"""
|
|
|
|
|
|
Reads a chunk of bytes from the port.
|
|
|
|
"""
|
|
return _genicam.EventPort_Read(self, pBuffer, Address, Length)
|
|
|
|
def Write(self, pBuffer, Address, Length):
|
|
r"""
|
|
|
|
|
|
Writes a chunk of bytes to the port.
|
|
|
|
"""
|
|
return _genicam.EventPort_Write(self, pBuffer, Address, Length)
|
|
|
|
def SetPortImpl(self, pPort):
|
|
r"""
|
|
|
|
|
|
Called from the port node to give the chunk port a pointer to itself.
|
|
|
|
"""
|
|
return _genicam.EventPort_SetPortImpl(self, pPort)
|
|
|
|
def GetSwapEndianess(self):
|
|
r"""
|
|
|
|
|
|
Determines if the port adapter must perform an endianess swap.
|
|
|
|
"""
|
|
return _genicam.EventPort_GetSwapEndianess(self)
|
|
|
|
def InvalidateNode(self):
|
|
r"""
|
|
|
|
|
|
"""
|
|
return _genicam.EventPort_InvalidateNode(self)
|
|
|
|
def AttachNode(self, pNode):
|
|
r"""
|
|
|
|
|
|
Attaches to the Node.
|
|
|
|
"""
|
|
return _genicam.EventPort_AttachNode(self, pNode)
|
|
|
|
def DetachNode(self):
|
|
r"""
|
|
|
|
|
|
Detaches from the Node.
|
|
|
|
"""
|
|
return _genicam.EventPort_DetachNode(self)
|
|
|
|
def GetEventIDLength(self):
|
|
r"""
|
|
|
|
|
|
Gets the EventID length.
|
|
|
|
"""
|
|
return _genicam.EventPort_GetEventIDLength(self)
|
|
|
|
def CheckEventID(self, *args):
|
|
r"""
|
|
|
|
|
|
Checks if a EventID matches, version using uint64_t ID representation.
|
|
|
|
"""
|
|
return _genicam.EventPort_CheckEventID(self, *args)
|
|
|
|
def AttachEvent(self, pBaseAddress, Length):
|
|
r"""
|
|
|
|
|
|
Attaches the an Event to the EventPort.
|
|
|
|
"""
|
|
return _genicam.EventPort_AttachEvent(self, pBaseAddress, Length)
|
|
|
|
def DetachEvent(self):
|
|
r"""
|
|
|
|
|
|
Detaches the Event from the EventPort.
|
|
|
|
"""
|
|
return _genicam.EventPort_DetachEvent(self)
|
|
|
|
# Register EventPort in _genicam:
|
|
_genicam.EventPort_swigregister(EventPort)
|
|
|
|
CEventPort = EventPort
|
|
|
|
class EventAdapter(object):
|
|
r"""
|
|
|
|
|
|
Delivers Events to ports.
|
|
|
|
C++ includes: EventAdapter.h
|
|
|
|
"""
|
|
|
|
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__ = _genicam.delete_EventAdapter
|
|
|
|
def AttachNodeMap(self, pNodeMap):
|
|
r"""
|
|
|
|
|
|
Attaches to a node map and retrieves the chunk ports.
|
|
|
|
"""
|
|
return _genicam.EventAdapter_AttachNodeMap(self, pNodeMap)
|
|
|
|
def DetachNodeMap(self):
|
|
r"""
|
|
|
|
|
|
Detaches from the node emap.
|
|
|
|
"""
|
|
return _genicam.EventAdapter_DetachNodeMap(self)
|
|
|
|
def DeliverMessage(self, msg):
|
|
r"""
|
|
|
|
|
|
Deliver message.
|
|
|
|
"""
|
|
return _genicam.EventAdapter_DeliverMessage(self, msg)
|
|
|
|
# Register EventAdapter in _genicam:
|
|
_genicam.EventAdapter_swigregister(EventAdapter)
|
|
|
|
CEventAdapter = EventAdapter
|
|
|
|
class EventAdapterGEV(EventAdapter):
|
|
r"""
|
|
|
|
|
|
Connects a GigE Event to a node map.
|
|
|
|
C++ includes: EventAdapterGEV.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, pNodeMap=None):
|
|
r"""
|
|
|
|
|
|
Constructor.
|
|
|
|
"""
|
|
_genicam.EventAdapterGEV_swiginit(self, _genicam.new_EventAdapterGEV(pNodeMap))
|
|
__swig_destroy__ = _genicam.delete_EventAdapterGEV
|
|
|
|
def DeliverMessage(self, msg):
|
|
r"""
|
|
|
|
|
|
Deliver message.
|
|
|
|
"""
|
|
return _genicam.EventAdapterGEV_DeliverMessage(self, msg)
|
|
|
|
# Register EventAdapterGEV in _genicam:
|
|
_genicam.EventAdapterGEV_swigregister(EventAdapterGEV)
|
|
COMMAND_MAGIC = cvar.COMMAND_MAGIC
|
|
|
|
|
|
CEventAdapterGEV = EventAdapterGEV
|
|
|
|
class EventAdapterU3V(EventAdapter):
|
|
r"""
|
|
|
|
|
|
Connects a U3V Event to a node map.
|
|
|
|
C++ includes: EventAdapterU3V.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, pNodeMap=None):
|
|
r"""
|
|
|
|
|
|
Constructor.
|
|
|
|
"""
|
|
_genicam.EventAdapterU3V_swiginit(self, _genicam.new_EventAdapterU3V(pNodeMap))
|
|
__swig_destroy__ = _genicam.delete_EventAdapterU3V
|
|
|
|
def DeliverMessage(self, msg):
|
|
r"""
|
|
|
|
|
|
Deliver message.
|
|
|
|
"""
|
|
return _genicam.EventAdapterU3V_DeliverMessage(self, msg)
|
|
|
|
# Register EventAdapterU3V in _genicam:
|
|
_genicam.EventAdapterU3V_swigregister(EventAdapterU3V)
|
|
U3V_EVENT_PREFIX = cvar.U3V_EVENT_PREFIX
|
|
GENCP_EVENT_CMD_ID = cvar.GENCP_EVENT_CMD_ID
|
|
GENCP_COMMAND_HEADER_SIZE = cvar.GENCP_COMMAND_HEADER_SIZE
|
|
GENCP_EVENT_BASIC_SIZE = cvar.GENCP_EVENT_BASIC_SIZE
|
|
|
|
|
|
CEventAdapterU3V = EventAdapterU3V
|
|
|
|
class EventAdapterGeneric(EventAdapter):
|
|
r"""
|
|
|
|
|
|
Connects a generic event to a node map.
|
|
|
|
C++ includes: EventAdapterGeneric.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, pNodeMap=None):
|
|
r"""
|
|
|
|
|
|
Constructor.
|
|
|
|
"""
|
|
_genicam.EventAdapterGeneric_swiginit(self, _genicam.new_EventAdapterGeneric(pNodeMap))
|
|
__swig_destroy__ = _genicam.delete_EventAdapterGeneric
|
|
|
|
def DeliverMessage(self, *args):
|
|
r"""
|
|
|
|
|
|
"""
|
|
return _genicam.EventAdapterGeneric_DeliverMessage(self, *args)
|
|
|
|
# Register EventAdapterGeneric in _genicam:
|
|
_genicam.EventAdapterGeneric_swigregister(EventAdapterGeneric)
|
|
|
|
CEventAdapterGeneric = EventAdapterGeneric
|
|
|
|
class FileProtocolAdapter(object):
|
|
r"""
|
|
|
|
|
|
Adapter between the std::iostreambuf and the SFNC Features representing the
|
|
device filesystem.
|
|
|
|
Adapter between the std::iostreambuf and the SFNC Features representing the
|
|
device filesystem The adapter assumes, that the features provide stdio
|
|
fileaccess compatible semantic
|
|
|
|
C++ includes: Filestream.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"""
|
|
|
|
|
|
Constructor.
|
|
|
|
"""
|
|
_genicam.FileProtocolAdapter_swiginit(self, _genicam.new_FileProtocolAdapter())
|
|
|
|
def attach(self, pInterface):
|
|
r"""
|
|
|
|
|
|
attach file protocol adapter to nodemap
|
|
|
|
Parameters
|
|
----------
|
|
* `pInterface` :
|
|
NodeMap of the device to which the FileProtocolAdapter is attached
|
|
|
|
Returns
|
|
-------
|
|
true if attach was successful, false if not
|
|
|
|
"""
|
|
return _genicam.FileProtocolAdapter_attach(self, pInterface)
|
|
|
|
def openFile(self, pFileName, mode):
|
|
r"""
|
|
|
|
|
|
open a file on the device
|
|
|
|
Parameters
|
|
----------
|
|
* `pFileName` :
|
|
filename of the file to open. The filename must exist in the Enumeration
|
|
FileSelector
|
|
* `mode` :
|
|
mode to open the file. The mode must exist in the Enumeration FileOpenMode
|
|
|
|
Returns
|
|
-------
|
|
true on success, false on error
|
|
|
|
"""
|
|
return _genicam.FileProtocolAdapter_openFile(self, pFileName, mode)
|
|
|
|
def closeFile(self, pFileName):
|
|
r"""
|
|
|
|
|
|
close a file on the device
|
|
|
|
Parameters
|
|
----------
|
|
* `pFileName` :
|
|
filename of the file to open. The filename must exist in the Enumeration
|
|
FileSelector
|
|
|
|
Returns
|
|
-------
|
|
true on success, false on error
|
|
|
|
"""
|
|
return _genicam.FileProtocolAdapter_closeFile(self, pFileName)
|
|
|
|
def write(self, pBuffer, offs, pFileName):
|
|
r"""
|
|
|
|
|
|
writes data into a file.
|
|
|
|
Parameters
|
|
----------
|
|
* `buf` :
|
|
source buffer
|
|
* `offs` :
|
|
offset into the device file
|
|
* `len` :
|
|
count of bytes to write
|
|
* `pFileName` :
|
|
filename of the file to write into The filename must exist in the
|
|
Enumeration FileSelector
|
|
|
|
Returns
|
|
-------
|
|
count of bytes written
|
|
|
|
"""
|
|
return _genicam.FileProtocolAdapter_write(self, pBuffer, offs, pFileName)
|
|
|
|
def read(self, pBuffer, offs, pFileName):
|
|
r"""
|
|
|
|
|
|
read data from the device into a buffer
|
|
|
|
Parameters
|
|
----------
|
|
* `buf` :
|
|
target buffer
|
|
* `offs` :
|
|
offset in the device file to read from
|
|
* `len` :
|
|
count of bytes to read
|
|
* `pFileName` :
|
|
filename of the file to write into The filename must exist in the
|
|
Enumeration FileSelector
|
|
|
|
Returns
|
|
-------
|
|
count of bytes successfully read
|
|
|
|
"""
|
|
return _genicam.FileProtocolAdapter_read(self, pBuffer, offs, pFileName)
|
|
|
|
def getBufSize(self, pFileName, mode):
|
|
r"""
|
|
|
|
|
|
fetch max FileAccessBuffer length for a file
|
|
|
|
Parameters
|
|
----------
|
|
* `pFileName` :
|
|
filename of the file to open. The filename must exist in the Enumeration
|
|
FileSelector
|
|
* `mode` :
|
|
mode to open the file. The mode must exist in the Enunmeration FileOpenMode
|
|
|
|
Returns
|
|
-------
|
|
max length of FileAccessBuffer in the given mode on the given file
|
|
|
|
"""
|
|
return _genicam.FileProtocolAdapter_getBufSize(self, pFileName, mode)
|
|
|
|
def deleteFile(self, pFileName):
|
|
r"""
|
|
|
|
|
|
Delete the content of the file.
|
|
|
|
Parameters
|
|
----------
|
|
* `pFileName` :
|
|
filename of the file to open. The filename must exist in the Enumeration
|
|
FileSelector
|
|
|
|
Returns
|
|
-------
|
|
true on success, false on error
|
|
|
|
"""
|
|
return _genicam.FileProtocolAdapter_deleteFile(self, pFileName)
|
|
__swig_destroy__ = _genicam.delete_FileProtocolAdapter
|
|
|
|
# Register FileProtocolAdapter in _genicam:
|
|
_genicam.FileProtocolAdapter_swigregister(FileProtocolAdapter)
|
|
|
|
class FileAccess(object):
|
|
def __init__(self, read_bufsize = 4096):
|
|
if read_bufsize == 0:
|
|
raise IOError("invalid read_bufsize")
|
|
|
|
self.isopen = False
|
|
self.filename = ""
|
|
self.mode = ""
|
|
self.fpa = FileProtocolAdapter()
|
|
self.fpa_bufsize = 0
|
|
self.fpos = 0
|
|
self.read_bufsize = read_bufsize
|
|
|
|
def open(self, nodemap, filename, openmode):
|
|
self.fpa.attach(nodemap)
|
|
self.filename = filename
|
|
self.fpa.openFile(filename,openmode)
|
|
self.fpa_bufsize = self.fpa.getBufSize(filename, openmode)
|
|
self.fpos = 0
|
|
self.isopen = True
|
|
|
|
def close(self):
|
|
self.isopen = False
|
|
self.fpa.closeFile(self.filename)
|
|
|
|
def _read(self, size):
|
|
assert(self.isopen)
|
|
read_len, data = self.fpa.read(size, self.fpos, self.filename)
|
|
data = data[:read_len]
|
|
self.fpos += read_len
|
|
return data
|
|
|
|
def read(self, size = -1):
|
|
assert(self.isopen)
|
|
if size < 0:
|
|
buf = b""
|
|
while True:
|
|
data = self._read(self.read_bufsize)
|
|
buf += data
|
|
if len(data) < self.read_bufsize:
|
|
return buf
|
|
|
|
else:
|
|
data = self._read(size)
|
|
return data
|
|
|
|
|
|
def write(self,data):
|
|
assert(self.isopen)
|
|
ret = self.fpa.write(data, self.fpos, self.filename)
|
|
self.fpos += len(data)
|
|
return ret
|
|
|
|
|
|
|
|
__version__ = '4.2.0'
|