# This file was automatically generated by SWIG (http://www.swig.org).
# Version 3.0.10
#
# Do not make changes to this file unless you know what you are doing--modify
# the SWIG interface file instead.





from sys import version_info as _swig_python_version_info
if _swig_python_version_info >= (2, 7, 0):
    def swig_import_helper():
        import importlib
        pkg = __name__.rpartition('.')[0]
        mname = '.'.join((pkg, '_phoPython2Win')).lstrip('.')
        try:
            return importlib.import_module(mname)
        except ImportError:
            return importlib.import_module('_phoPython2Win')
    _phoPython2Win = swig_import_helper()
    del swig_import_helper
elif _swig_python_version_info >= (2, 6, 0):
    def swig_import_helper():
        from os.path import dirname
        import imp
        fp = None
        try:
            fp, pathname, description = imp.find_module('_phoPython2Win', [dirname(__file__)])
        except ImportError:
            import _phoPython2Win
            return _phoPython2Win
        if fp is not None:
            try:
                _mod = imp.load_module('_phoPython2Win', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _phoPython2Win = swig_import_helper()
    del swig_import_helper
else:
    import _phoPython2Win
del _swig_python_version_info
try:
    _swig_property = property
except NameError:
    pass  # Python < 2.2 doesn't have 'property'.

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

def _swig_setattr_nondynamic(self, class_type, name, value, static=1):
    if (name == "thisown"):
        return self.this.own(value)
    if (name == "this"):
        if type(value).__name__ == 'SwigPyObject':
            self.__dict__[name] = value
            return
    method = class_type.__swig_setmethods__.get(name, None)
    if method:
        return method(self, value)
    if (not static):
        if _newclass:
            object.__setattr__(self, name, value)
        else:
            self.__dict__[name] = value
    else:
        raise AttributeError("You cannot add attributes to %s" % self)


def _swig_setattr(self, class_type, name, value):
    return _swig_setattr_nondynamic(self, class_type, name, value, 0)


def _swig_getattr(self, class_type, name):
    if (name == "thisown"):
        return self.this.own()
    method = class_type.__swig_getmethods__.get(name, None)
    if method:
        return method(self)
    raise AttributeError("'%s' object has no attribute '%s'" % (class_type.__name__, name))


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,)

try:
    _object = object
    _newclass = 1
except __builtin__.Exception:
    class _object:
        pass
    _newclass = 0


def new_floatP():
    """new_floatP() -> float *"""
    return _phoPython2Win.new_floatP()

def copy_floatP(value):
    """
    copy_floatP(float value) -> float *

    Parameters
    ----------
    value: float

    """
    return _phoPython2Win.copy_floatP(value)

def delete_floatP(obj):
    """
    delete_floatP(float * obj)

    Parameters
    ----------
    obj: float *

    """
    return _phoPython2Win.delete_floatP(obj)

def floatP_assign(obj, value):
    """
    floatP_assign(float * obj, float value)

    Parameters
    ----------
    obj: float *
    value: float

    """
    return _phoPython2Win.floatP_assign(obj, value)

def floatP_value(obj):
    """
    floatP_value(float * obj) -> float

    Parameters
    ----------
    obj: float *

    """
    return _phoPython2Win.floatP_value(obj)
class SwigPyIterator(_object):
    """Proxy of C++ swig::SwigPyIterator class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SwigPyIterator, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SwigPyIterator, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _phoPython2Win.delete_SwigPyIterator
    __del__ = lambda self: None

    def value(self):
        """
        value(SwigPyIterator self) -> PyObject *

        Parameters
        ----------
        self: swig::SwigPyIterator const *

        """
        return _phoPython2Win.SwigPyIterator_value(self)


    def incr(self, n=1):
        """
        incr(SwigPyIterator self, size_t n=1) -> SwigPyIterator

        Parameters
        ----------
        n: size_t

        incr(SwigPyIterator self) -> SwigPyIterator

        Parameters
        ----------
        self: swig::SwigPyIterator *

        """
        return _phoPython2Win.SwigPyIterator_incr(self, n)


    def decr(self, n=1):
        """
        decr(SwigPyIterator self, size_t n=1) -> SwigPyIterator

        Parameters
        ----------
        n: size_t

        decr(SwigPyIterator self) -> SwigPyIterator

        Parameters
        ----------
        self: swig::SwigPyIterator *

        """
        return _phoPython2Win.SwigPyIterator_decr(self, n)


    def distance(self, x):
        """
        distance(SwigPyIterator self, SwigPyIterator x) -> ptrdiff_t

        Parameters
        ----------
        x: swig::SwigPyIterator const &

        """
        return _phoPython2Win.SwigPyIterator_distance(self, x)


    def equal(self, x):
        """
        equal(SwigPyIterator self, SwigPyIterator x) -> bool

        Parameters
        ----------
        x: swig::SwigPyIterator const &

        """
        return _phoPython2Win.SwigPyIterator_equal(self, x)


    def copy(self):
        """
        copy(SwigPyIterator self) -> SwigPyIterator

        Parameters
        ----------
        self: swig::SwigPyIterator const *

        """
        return _phoPython2Win.SwigPyIterator_copy(self)


    def next(self):
        """
        next(SwigPyIterator self) -> PyObject *

        Parameters
        ----------
        self: swig::SwigPyIterator *

        """
        return _phoPython2Win.SwigPyIterator_next(self)


    def __next__(self):
        """
        __next__(SwigPyIterator self) -> PyObject *

        Parameters
        ----------
        self: swig::SwigPyIterator *

        """
        return _phoPython2Win.SwigPyIterator___next__(self)


    def previous(self):
        """
        previous(SwigPyIterator self) -> PyObject *

        Parameters
        ----------
        self: swig::SwigPyIterator *

        """
        return _phoPython2Win.SwigPyIterator_previous(self)


    def advance(self, n):
        """
        advance(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator

        Parameters
        ----------
        n: ptrdiff_t

        """
        return _phoPython2Win.SwigPyIterator_advance(self, n)


    def __eq__(self, x):
        """
        __eq__(SwigPyIterator self, SwigPyIterator x) -> bool

        Parameters
        ----------
        x: swig::SwigPyIterator const &

        """
        return _phoPython2Win.SwigPyIterator___eq__(self, x)


    def __ne__(self, x):
        """
        __ne__(SwigPyIterator self, SwigPyIterator x) -> bool

        Parameters
        ----------
        x: swig::SwigPyIterator const &

        """
        return _phoPython2Win.SwigPyIterator___ne__(self, x)


    def __iadd__(self, n):
        """
        __iadd__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator

        Parameters
        ----------
        n: ptrdiff_t

        """
        return _phoPython2Win.SwigPyIterator___iadd__(self, n)


    def __isub__(self, n):
        """
        __isub__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator

        Parameters
        ----------
        n: ptrdiff_t

        """
        return _phoPython2Win.SwigPyIterator___isub__(self, n)


    def __add__(self, n):
        """
        __add__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator

        Parameters
        ----------
        n: ptrdiff_t

        """
        return _phoPython2Win.SwigPyIterator___add__(self, n)


    def __sub__(self, *args):
        """
        __sub__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator

        Parameters
        ----------
        n: ptrdiff_t

        __sub__(SwigPyIterator self, SwigPyIterator x) -> ptrdiff_t

        Parameters
        ----------
        x: swig::SwigPyIterator const &

        """
        return _phoPython2Win.SwigPyIterator___sub__(self, *args)

    def __iter__(self):
        return self
SwigPyIterator_swigregister = _phoPython2Win.SwigPyIterator_swigregister
SwigPyIterator_swigregister(SwigPyIterator)

SHARED_PTR_DISOWN = _phoPython2Win.SHARED_PTR_DISOWN
PHOXI_SCANNER_ON = _phoPython2Win.PHOXI_SCANNER_ON
PHOXI_CAMERA_ON = _phoPython2Win.PHOXI_CAMERA_ON
PHOXI_DEVICE_TYPES_COUNT = _phoPython2Win.PHOXI_DEVICE_TYPES_COUNT
class PhoXiSize(_object):
    """Proxy of C++ pho::api::PhoXiSize class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, PhoXiSize, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, PhoXiSize, name)
    __repr__ = _swig_repr
    __swig_setmethods__["Width"] = _phoPython2Win.PhoXiSize_Width_set
    __swig_getmethods__["Width"] = _phoPython2Win.PhoXiSize_Width_get
    if _newclass:
        Width = _swig_property(_phoPython2Win.PhoXiSize_Width_get, _phoPython2Win.PhoXiSize_Width_set)
    __swig_setmethods__["Height"] = _phoPython2Win.PhoXiSize_Height_set
    __swig_getmethods__["Height"] = _phoPython2Win.PhoXiSize_Height_get
    if _newclass:
        Height = _swig_property(_phoPython2Win.PhoXiSize_Height_get, _phoPython2Win.PhoXiSize_Height_set)

    def __init__(self, *args):
        """
        __init__(pho::api::PhoXiSize self) -> PhoXiSize
        __init__(pho::api::PhoXiSize self, int _Width, int _Height) -> PhoXiSize

        Parameters
        ----------
        _Width: int
        _Height: int

        __init__(pho::api::PhoXiSize self, PhoXiSize Other) -> PhoXiSize

        Parameters
        ----------
        Other: pho::api::PhoXiSize const &

        """
        this = _phoPython2Win.new_PhoXiSize(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __eq__(self, Other):
        """
        __eq__(PhoXiSize self, PhoXiSize Other) -> bool

        Parameters
        ----------
        Other: pho::api::PhoXiSize const &

        """
        return _phoPython2Win.PhoXiSize___eq__(self, Other)


    def Area(self):
        """
        Area(PhoXiSize self) -> int

        Parameters
        ----------
        self: pho::api::PhoXiSize const *

        """
        return _phoPython2Win.PhoXiSize_Area(self)

    __swig_destroy__ = _phoPython2Win.delete_PhoXiSize
    __del__ = lambda self: None
PhoXiSize_swigregister = _phoPython2Win.PhoXiSize_swigregister
PhoXiSize_swigregister(PhoXiSize)

class PhoXiConnectionStatus(_object):
    """Proxy of C++ pho::api::PhoXiConnectionStatus class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, PhoXiConnectionStatus, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, PhoXiConnectionStatus, name)
    __repr__ = _swig_repr
    __swig_setmethods__["Attached"] = _phoPython2Win.PhoXiConnectionStatus_Attached_set
    __swig_getmethods__["Attached"] = _phoPython2Win.PhoXiConnectionStatus_Attached_get
    if _newclass:
        Attached = _swig_property(_phoPython2Win.PhoXiConnectionStatus_Attached_get, _phoPython2Win.PhoXiConnectionStatus_Attached_set)
    __swig_setmethods__["Ready"] = _phoPython2Win.PhoXiConnectionStatus_Ready_set
    __swig_getmethods__["Ready"] = _phoPython2Win.PhoXiConnectionStatus_Ready_get
    if _newclass:
        Ready = _swig_property(_phoPython2Win.PhoXiConnectionStatus_Ready_get, _phoPython2Win.PhoXiConnectionStatus_Ready_set)

    def __init__(self):
        """__init__(pho::api::PhoXiConnectionStatus self) -> PhoXiConnectionStatus"""
        this = _phoPython2Win.new_PhoXiConnectionStatus()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _phoPython2Win.delete_PhoXiConnectionStatus
    __del__ = lambda self: None
PhoXiConnectionStatus_swigregister = _phoPython2Win.PhoXiConnectionStatus_swigregister
PhoXiConnectionStatus_swigregister(PhoXiConnectionStatus)

class FrameInfo(_object):
    """Proxy of C++ pho::api::FrameInfo class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, FrameInfo, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, FrameInfo, name)
    __repr__ = _swig_repr
    __swig_setmethods__["FrameIndex"] = _phoPython2Win.FrameInfo_FrameIndex_set
    __swig_getmethods__["FrameIndex"] = _phoPython2Win.FrameInfo_FrameIndex_get
    if _newclass:
        FrameIndex = _swig_property(_phoPython2Win.FrameInfo_FrameIndex_get, _phoPython2Win.FrameInfo_FrameIndex_set)
    __swig_setmethods__["FrameTimestamp"] = _phoPython2Win.FrameInfo_FrameTimestamp_set
    __swig_getmethods__["FrameTimestamp"] = _phoPython2Win.FrameInfo_FrameTimestamp_get
    if _newclass:
        FrameTimestamp = _swig_property(_phoPython2Win.FrameInfo_FrameTimestamp_get, _phoPython2Win.FrameInfo_FrameTimestamp_set)
    __swig_setmethods__["FrameDuration"] = _phoPython2Win.FrameInfo_FrameDuration_set
    __swig_getmethods__["FrameDuration"] = _phoPython2Win.FrameInfo_FrameDuration_get
    if _newclass:
        FrameDuration = _swig_property(_phoPython2Win.FrameInfo_FrameDuration_get, _phoPython2Win.FrameInfo_FrameDuration_set)
    __swig_setmethods__["SensorPosition"] = _phoPython2Win.FrameInfo_SensorPosition_set
    __swig_getmethods__["SensorPosition"] = _phoPython2Win.FrameInfo_SensorPosition_get
    if _newclass:
        SensorPosition = _swig_property(_phoPython2Win.FrameInfo_SensorPosition_get, _phoPython2Win.FrameInfo_SensorPosition_set)
    __swig_setmethods__["SensorXAxis"] = _phoPython2Win.FrameInfo_SensorXAxis_set
    __swig_getmethods__["SensorXAxis"] = _phoPython2Win.FrameInfo_SensorXAxis_get
    if _newclass:
        SensorXAxis = _swig_property(_phoPython2Win.FrameInfo_SensorXAxis_get, _phoPython2Win.FrameInfo_SensorXAxis_set)
    __swig_setmethods__["SensorYAxis"] = _phoPython2Win.FrameInfo_SensorYAxis_set
    __swig_getmethods__["SensorYAxis"] = _phoPython2Win.FrameInfo_SensorYAxis_get
    if _newclass:
        SensorYAxis = _swig_property(_phoPython2Win.FrameInfo_SensorYAxis_get, _phoPython2Win.FrameInfo_SensorYAxis_set)
    __swig_setmethods__["SensorZAxis"] = _phoPython2Win.FrameInfo_SensorZAxis_set
    __swig_getmethods__["SensorZAxis"] = _phoPython2Win.FrameInfo_SensorZAxis_get
    if _newclass:
        SensorZAxis = _swig_property(_phoPython2Win.FrameInfo_SensorZAxis_get, _phoPython2Win.FrameInfo_SensorZAxis_set)

    def __init__(self):
        """__init__(pho::api::FrameInfo self) -> FrameInfo"""
        this = _phoPython2Win.new_FrameInfo()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _phoPython2Win.delete_FrameInfo
    __del__ = lambda self: None
FrameInfo_swigregister = _phoPython2Win.FrameInfo_swigregister
FrameInfo_swigregister(FrameInfo)

class Frame(_object):
    """Proxy of C++ pho::api::Frame class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Frame, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Frame, name)
    __repr__ = _swig_repr
    __swig_setmethods__["Successful"] = _phoPython2Win.Frame_Successful_set
    __swig_getmethods__["Successful"] = _phoPython2Win.Frame_Successful_get
    if _newclass:
        Successful = _swig_property(_phoPython2Win.Frame_Successful_get, _phoPython2Win.Frame_Successful_set)
    __swig_setmethods__["Info"] = _phoPython2Win.Frame_Info_set
    __swig_getmethods__["Info"] = _phoPython2Win.Frame_Info_get
    if _newclass:
        Info = _swig_property(_phoPython2Win.Frame_Info_get, _phoPython2Win.Frame_Info_set)
    __swig_setmethods__["PointCloud"] = _phoPython2Win.Frame_PointCloud_set
    __swig_getmethods__["PointCloud"] = _phoPython2Win.Frame_PointCloud_get
    if _newclass:
        PointCloud = _swig_property(_phoPython2Win.Frame_PointCloud_get, _phoPython2Win.Frame_PointCloud_set)
    __swig_setmethods__["NormalMap"] = _phoPython2Win.Frame_NormalMap_set
    __swig_getmethods__["NormalMap"] = _phoPython2Win.Frame_NormalMap_get
    if _newclass:
        NormalMap = _swig_property(_phoPython2Win.Frame_NormalMap_get, _phoPython2Win.Frame_NormalMap_set)
    __swig_setmethods__["DepthMap"] = _phoPython2Win.Frame_DepthMap_set
    __swig_getmethods__["DepthMap"] = _phoPython2Win.Frame_DepthMap_get
    if _newclass:
        DepthMap = _swig_property(_phoPython2Win.Frame_DepthMap_get, _phoPython2Win.Frame_DepthMap_set)
    __swig_setmethods__["ConfidenceMap"] = _phoPython2Win.Frame_ConfidenceMap_set
    __swig_getmethods__["ConfidenceMap"] = _phoPython2Win.Frame_ConfidenceMap_get
    if _newclass:
        ConfidenceMap = _swig_property(_phoPython2Win.Frame_ConfidenceMap_get, _phoPython2Win.Frame_ConfidenceMap_set)
    __swig_setmethods__["Texture"] = _phoPython2Win.Frame_Texture_set
    __swig_getmethods__["Texture"] = _phoPython2Win.Frame_Texture_get
    if _newclass:
        Texture = _swig_property(_phoPython2Win.Frame_Texture_get, _phoPython2Win.Frame_Texture_set)

    def Empty(self):
        """
        Empty(Frame self) -> bool

        Parameters
        ----------
        self: pho::api::Frame const *

        """
        return _phoPython2Win.Frame_Empty(self)


    def GetResolution(self):
        """
        GetResolution(Frame self) -> PhoXiSize

        Parameters
        ----------
        self: pho::api::Frame const *

        """
        return _phoPython2Win.Frame_GetResolution(self)


    def SaveAsPly(self, FilePath, BinaryFile=True, NormalizeTexture=True, StorePointCloud=True, StoreNormalMap=True, StoreDepthMap=True, StoreTexture=True, StoreConfidenceMap=True, Unordered=False):
        """
        SaveAsPly(Frame self, std::string const & FilePath, bool BinaryFile=True, bool NormalizeTexture=True, bool StorePointCloud=True, bool StoreNormalMap=True, bool StoreDepthMap=True, bool StoreTexture=True, bool StoreConfidenceMap=True, bool Unordered=False) -> bool

        Parameters
        ----------
        FilePath: std::string const &
        BinaryFile: bool
        NormalizeTexture: bool
        StorePointCloud: bool
        StoreNormalMap: bool
        StoreDepthMap: bool
        StoreTexture: bool
        StoreConfidenceMap: bool
        Unordered: bool

        SaveAsPly(Frame self, std::string const & FilePath, bool BinaryFile=True, bool NormalizeTexture=True, bool StorePointCloud=True, bool StoreNormalMap=True, bool StoreDepthMap=True, bool StoreTexture=True, bool StoreConfidenceMap=True) -> bool

        Parameters
        ----------
        FilePath: std::string const &
        BinaryFile: bool
        NormalizeTexture: bool
        StorePointCloud: bool
        StoreNormalMap: bool
        StoreDepthMap: bool
        StoreTexture: bool
        StoreConfidenceMap: bool

        SaveAsPly(Frame self, std::string const & FilePath, bool BinaryFile=True, bool NormalizeTexture=True, bool StorePointCloud=True, bool StoreNormalMap=True, bool StoreDepthMap=True, bool StoreTexture=True) -> bool

        Parameters
        ----------
        FilePath: std::string const &
        BinaryFile: bool
        NormalizeTexture: bool
        StorePointCloud: bool
        StoreNormalMap: bool
        StoreDepthMap: bool
        StoreTexture: bool

        SaveAsPly(Frame self, std::string const & FilePath, bool BinaryFile=True, bool NormalizeTexture=True, bool StorePointCloud=True, bool StoreNormalMap=True, bool StoreDepthMap=True) -> bool

        Parameters
        ----------
        FilePath: std::string const &
        BinaryFile: bool
        NormalizeTexture: bool
        StorePointCloud: bool
        StoreNormalMap: bool
        StoreDepthMap: bool

        SaveAsPly(Frame self, std::string const & FilePath, bool BinaryFile=True, bool NormalizeTexture=True, bool StorePointCloud=True, bool StoreNormalMap=True) -> bool

        Parameters
        ----------
        FilePath: std::string const &
        BinaryFile: bool
        NormalizeTexture: bool
        StorePointCloud: bool
        StoreNormalMap: bool

        SaveAsPly(Frame self, std::string const & FilePath, bool BinaryFile=True, bool NormalizeTexture=True, bool StorePointCloud=True) -> bool

        Parameters
        ----------
        FilePath: std::string const &
        BinaryFile: bool
        NormalizeTexture: bool
        StorePointCloud: bool

        SaveAsPly(Frame self, std::string const & FilePath, bool BinaryFile=True, bool NormalizeTexture=True) -> bool

        Parameters
        ----------
        FilePath: std::string const &
        BinaryFile: bool
        NormalizeTexture: bool

        SaveAsPly(Frame self, std::string const & FilePath, bool BinaryFile=True) -> bool

        Parameters
        ----------
        FilePath: std::string const &
        BinaryFile: bool

        SaveAsPly(Frame self, std::string const & FilePath) -> bool

        Parameters
        ----------
        FilePath: std::string const &

        """
        return _phoPython2Win.Frame_SaveAsPly(self, FilePath, BinaryFile, NormalizeTexture, StorePointCloud, StoreNormalMap, StoreDepthMap, StoreTexture, StoreConfidenceMap, Unordered)


    def __init__(self):
        """__init__(pho::api::Frame self) -> Frame"""
        this = _phoPython2Win.new_Frame()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _phoPython2Win.delete_Frame
    __del__ = lambda self: None
Frame_swigregister = _phoPython2Win.Frame_swigregister
Frame_swigregister(Frame)

class PhoXiCapturingMode(_object):
    """Proxy of C++ pho::api::PhoXiCapturingMode class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, PhoXiCapturingMode, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, PhoXiCapturingMode, name)
    __repr__ = _swig_repr
    __swig_setmethods__["Resolution"] = _phoPython2Win.PhoXiCapturingMode_Resolution_set
    __swig_getmethods__["Resolution"] = _phoPython2Win.PhoXiCapturingMode_Resolution_get
    if _newclass:
        Resolution = _swig_property(_phoPython2Win.PhoXiCapturingMode_Resolution_get, _phoPython2Win.PhoXiCapturingMode_Resolution_set)

    def __init__(self, *args):
        """
        __init__(pho::api::PhoXiCapturingMode self) -> PhoXiCapturingMode
        __init__(pho::api::PhoXiCapturingMode self, PhoXiCapturingMode Other) -> PhoXiCapturingMode

        Parameters
        ----------
        Other: pho::api::PhoXiCapturingMode const &

        """
        this = _phoPython2Win.new_PhoXiCapturingMode(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __eq__(self, Other):
        """
        __eq__(PhoXiCapturingMode self, PhoXiCapturingMode Other) -> bool

        Parameters
        ----------
        Other: pho::api::PhoXiCapturingMode const &

        """
        return _phoPython2Win.PhoXiCapturingMode___eq__(self, Other)

    __swig_destroy__ = _phoPython2Win.delete_PhoXiCapturingMode
    __del__ = lambda self: None
PhoXiCapturingMode_swigregister = _phoPython2Win.PhoXiCapturingMode_swigregister
PhoXiCapturingMode_swigregister(PhoXiCapturingMode)

class PhoXiCapturingSettings(_object):
    """Proxy of C++ pho::api::PhoXiCapturingSettings class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, PhoXiCapturingSettings, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, PhoXiCapturingSettings, name)
    __repr__ = _swig_repr
    __swig_setmethods__["ShutterMultiplier"] = _phoPython2Win.PhoXiCapturingSettings_ShutterMultiplier_set
    __swig_getmethods__["ShutterMultiplier"] = _phoPython2Win.PhoXiCapturingSettings_ShutterMultiplier_get
    if _newclass:
        ShutterMultiplier = _swig_property(_phoPython2Win.PhoXiCapturingSettings_ShutterMultiplier_get, _phoPython2Win.PhoXiCapturingSettings_ShutterMultiplier_set)
    __swig_setmethods__["ScanMultiplier"] = _phoPython2Win.PhoXiCapturingSettings_ScanMultiplier_set
    __swig_getmethods__["ScanMultiplier"] = _phoPython2Win.PhoXiCapturingSettings_ScanMultiplier_get
    if _newclass:
        ScanMultiplier = _swig_property(_phoPython2Win.PhoXiCapturingSettings_ScanMultiplier_get, _phoPython2Win.PhoXiCapturingSettings_ScanMultiplier_set)

    def __init__(self, *args):
        """
        __init__(pho::api::PhoXiCapturingSettings self) -> PhoXiCapturingSettings
        __init__(pho::api::PhoXiCapturingSettings self, PhoXiCapturingSettings Other) -> PhoXiCapturingSettings

        Parameters
        ----------
        Other: pho::api::PhoXiCapturingSettings const &

        """
        this = _phoPython2Win.new_PhoXiCapturingSettings(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __eq__(self, Other):
        """
        __eq__(PhoXiCapturingSettings self, PhoXiCapturingSettings Other) -> bool

        Parameters
        ----------
        Other: pho::api::PhoXiCapturingSettings const &

        """
        return _phoPython2Win.PhoXiCapturingSettings___eq__(self, Other)

    __swig_destroy__ = _phoPython2Win.delete_PhoXiCapturingSettings
    __del__ = lambda self: None
PhoXiCapturingSettings_swigregister = _phoPython2Win.PhoXiCapturingSettings_swigregister
PhoXiCapturingSettings_swigregister(PhoXiCapturingSettings)

class PhoXiStatus(_object):
    """Proxy of C++ pho::api::PhoXiStatus class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, PhoXiStatus, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, PhoXiStatus, name)
    __repr__ = _swig_repr
    __swig_setmethods__["Attached"] = _phoPython2Win.PhoXiStatus_Attached_set
    __swig_getmethods__["Attached"] = _phoPython2Win.PhoXiStatus_Attached_get
    if _newclass:
        Attached = _swig_property(_phoPython2Win.PhoXiStatus_Attached_get, _phoPython2Win.PhoXiStatus_Attached_set)
    __swig_setmethods__["Connected"] = _phoPython2Win.PhoXiStatus_Connected_set
    __swig_getmethods__["Connected"] = _phoPython2Win.PhoXiStatus_Connected_get
    if _newclass:
        Connected = _swig_property(_phoPython2Win.PhoXiStatus_Connected_get, _phoPython2Win.PhoXiStatus_Connected_set)
    __swig_setmethods__["Acquiring"] = _phoPython2Win.PhoXiStatus_Acquiring_set
    __swig_getmethods__["Acquiring"] = _phoPython2Win.PhoXiStatus_Acquiring_get
    if _newclass:
        Acquiring = _swig_property(_phoPython2Win.PhoXiStatus_Acquiring_get, _phoPython2Win.PhoXiStatus_Acquiring_set)

    def __init__(self):
        """__init__(pho::api::PhoXiStatus self) -> PhoXiStatus"""
        this = _phoPython2Win.new_PhoXiStatus()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _phoPython2Win.delete_PhoXiStatus
    __del__ = lambda self: None
PhoXiStatus_swigregister = _phoPython2Win.PhoXiStatus_swigregister
PhoXiStatus_swigregister(PhoXiStatus)

class PhoXiTriggerMode(_object):
    """Proxy of C++ pho::api::PhoXiTriggerMode class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, PhoXiTriggerMode, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, PhoXiTriggerMode, name)
    __repr__ = _swig_repr
    Freerun = _phoPython2Win.PhoXiTriggerMode_Freerun
    Software = _phoPython2Win.PhoXiTriggerMode_Software
    Hardware = _phoPython2Win.PhoXiTriggerMode_Hardware
    NoValue = _phoPython2Win.PhoXiTriggerMode_NoValue

    def __init__(self, *args):
        """
        __init__(pho::api::PhoXiTriggerMode self, pho::api::PhoXiTriggerMode::Value const & TriggerMode) -> PhoXiTriggerMode

        Parameters
        ----------
        TriggerMode: pho::api::PhoXiTriggerMode::Value const &

        __init__(pho::api::PhoXiTriggerMode self, PhoXiTriggerMode Other) -> PhoXiTriggerMode

        Parameters
        ----------
        Other: pho::api::PhoXiTriggerMode const &

        __init__(pho::api::PhoXiTriggerMode self, int const & Other) -> PhoXiTriggerMode

        Parameters
        ----------
        Other: int const &

        __init__(pho::api::PhoXiTriggerMode self) -> PhoXiTriggerMode
        """
        this = _phoPython2Win.new_PhoXiTriggerMode(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _phoPython2Win.delete_PhoXiTriggerMode
    __del__ = lambda self: None
PhoXiTriggerMode_swigregister = _phoPython2Win.PhoXiTriggerMode_swigregister
PhoXiTriggerMode_swigregister(PhoXiTriggerMode)

class PhoXiTriggerSignalMode(_object):
    """Proxy of C++ pho::api::PhoXiTriggerSignalMode class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, PhoXiTriggerSignalMode, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, PhoXiTriggerSignalMode, name)
    __repr__ = _swig_repr
    Rising = _phoPython2Win.PhoXiTriggerSignalMode_Rising
    Falling = _phoPython2Win.PhoXiTriggerSignalMode_Falling
    NoValue = _phoPython2Win.PhoXiTriggerSignalMode_NoValue

    def __init__(self, *args):
        """
        __init__(pho::api::PhoXiTriggerSignalMode self, pho::api::PhoXiTriggerSignalMode::Value const & TriggerSignalMode) -> PhoXiTriggerSignalMode

        Parameters
        ----------
        TriggerSignalMode: pho::api::PhoXiTriggerSignalMode::Value const &

        __init__(pho::api::PhoXiTriggerSignalMode self) -> PhoXiTriggerSignalMode
        """
        this = _phoPython2Win.new_PhoXiTriggerSignalMode(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _phoPython2Win.delete_PhoXiTriggerSignalMode
    __del__ = lambda self: None
PhoXiTriggerSignalMode_swigregister = _phoPython2Win.PhoXiTriggerSignalMode_swigregister
PhoXiTriggerSignalMode_swigregister(PhoXiTriggerSignalMode)

class PhoXiTimeout(_object):
    """Proxy of C++ pho::api::PhoXiTimeout class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, PhoXiTimeout, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, PhoXiTimeout, name)
    __repr__ = _swig_repr
    ZeroTimeout = _phoPython2Win.PhoXiTimeout_ZeroTimeout
    Infinity = _phoPython2Win.PhoXiTimeout_Infinity
    LastStored = _phoPython2Win.PhoXiTimeout_LastStored
    Default = _phoPython2Win.PhoXiTimeout_Default

    def __init__(self, *args):
        """
        __init__(pho::api::PhoXiTimeout self, pho::api::PhoXiTimeout::Value const & Timeout) -> PhoXiTimeout

        Parameters
        ----------
        Timeout: pho::api::PhoXiTimeout::Value const &

        __init__(pho::api::PhoXiTimeout self, int const & Timeout) -> PhoXiTimeout

        Parameters
        ----------
        Timeout: int const &

        __init__(pho::api::PhoXiTimeout self, std::string const & Timeout) -> PhoXiTimeout

        Parameters
        ----------
        Timeout: std::string const &

        __init__(pho::api::PhoXiTimeout self) -> PhoXiTimeout
        """
        this = _phoPython2Win.new_PhoXiTimeout(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __eq__(self, *args):
        """
        __eq__(PhoXiTimeout self, int const & Other) -> bool

        Parameters
        ----------
        Other: int const &

        __eq__(PhoXiTimeout self, PhoXiTimeout Other) -> bool

        Parameters
        ----------
        Other: pho::api::PhoXiTimeout const &

        __eq__(PhoXiTimeout self, pho::api::PhoXiTimeout::Value const & Other) -> bool

        Parameters
        ----------
        Other: pho::api::PhoXiTimeout::Value const &

        """
        return _phoPython2Win.PhoXiTimeout___eq__(self, *args)


    def isNum(self):
        """
        isNum(PhoXiTimeout self) -> bool

        Parameters
        ----------
        self: pho::api::PhoXiTimeout const *

        """
        return _phoPython2Win.PhoXiTimeout_isNum(self)

    __swig_destroy__ = _phoPython2Win.delete_PhoXiTimeout
    __del__ = lambda self: None
PhoXiTimeout_swigregister = _phoPython2Win.PhoXiTimeout_swigregister
PhoXiTimeout_swigregister(PhoXiTimeout)

class PhoXiProcessingSettings(_object):
    """Proxy of C++ pho::api::PhoXiProcessingSettings class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, PhoXiProcessingSettings, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, PhoXiProcessingSettings, name)
    __repr__ = _swig_repr
    __swig_setmethods__["Confidence"] = _phoPython2Win.PhoXiProcessingSettings_Confidence_set
    __swig_getmethods__["Confidence"] = _phoPython2Win.PhoXiProcessingSettings_Confidence_get
    if _newclass:
        Confidence = _swig_property(_phoPython2Win.PhoXiProcessingSettings_Confidence_get, _phoPython2Win.PhoXiProcessingSettings_Confidence_set)

    def __init__(self):
        """__init__(pho::api::PhoXiProcessingSettings self) -> PhoXiProcessingSettings"""
        this = _phoPython2Win.new_PhoXiProcessingSettings()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __eq__(self, Other):
        """
        __eq__(PhoXiProcessingSettings self, PhoXiProcessingSettings Other) -> bool

        Parameters
        ----------
        Other: pho::api::PhoXiProcessingSettings const &

        """
        return _phoPython2Win.PhoXiProcessingSettings___eq__(self, Other)

    __swig_destroy__ = _phoPython2Win.delete_PhoXiProcessingSettings
    __del__ = lambda self: None
PhoXiProcessingSettings_swigregister = _phoPython2Win.PhoXiProcessingSettings_swigregister
PhoXiProcessingSettings_swigregister(PhoXiProcessingSettings)

class FrameOutputSettings(_object):
    """Proxy of C++ pho::api::FrameOutputSettings class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, FrameOutputSettings, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, FrameOutputSettings, name)
    __repr__ = _swig_repr
    __swig_setmethods__["SendPointCloud"] = _phoPython2Win.FrameOutputSettings_SendPointCloud_set
    __swig_getmethods__["SendPointCloud"] = _phoPython2Win.FrameOutputSettings_SendPointCloud_get
    if _newclass:
        SendPointCloud = _swig_property(_phoPython2Win.FrameOutputSettings_SendPointCloud_get, _phoPython2Win.FrameOutputSettings_SendPointCloud_set)
    __swig_setmethods__["SendNormalMap"] = _phoPython2Win.FrameOutputSettings_SendNormalMap_set
    __swig_getmethods__["SendNormalMap"] = _phoPython2Win.FrameOutputSettings_SendNormalMap_get
    if _newclass:
        SendNormalMap = _swig_property(_phoPython2Win.FrameOutputSettings_SendNormalMap_get, _phoPython2Win.FrameOutputSettings_SendNormalMap_set)
    __swig_setmethods__["SendDepthMap"] = _phoPython2Win.FrameOutputSettings_SendDepthMap_set
    __swig_getmethods__["SendDepthMap"] = _phoPython2Win.FrameOutputSettings_SendDepthMap_get
    if _newclass:
        SendDepthMap = _swig_property(_phoPython2Win.FrameOutputSettings_SendDepthMap_get, _phoPython2Win.FrameOutputSettings_SendDepthMap_set)
    __swig_setmethods__["SendConfidenceMap"] = _phoPython2Win.FrameOutputSettings_SendConfidenceMap_set
    __swig_getmethods__["SendConfidenceMap"] = _phoPython2Win.FrameOutputSettings_SendConfidenceMap_get
    if _newclass:
        SendConfidenceMap = _swig_property(_phoPython2Win.FrameOutputSettings_SendConfidenceMap_get, _phoPython2Win.FrameOutputSettings_SendConfidenceMap_set)
    __swig_setmethods__["SendTexture"] = _phoPython2Win.FrameOutputSettings_SendTexture_set
    __swig_getmethods__["SendTexture"] = _phoPython2Win.FrameOutputSettings_SendTexture_get
    if _newclass:
        SendTexture = _swig_property(_phoPython2Win.FrameOutputSettings_SendTexture_get, _phoPython2Win.FrameOutputSettings_SendTexture_set)

    def __init__(self, *args):
        """
        __init__(pho::api::FrameOutputSettings self) -> FrameOutputSettings
        __init__(pho::api::FrameOutputSettings self, FrameOutputSettings Other) -> FrameOutputSettings

        Parameters
        ----------
        Other: pho::api::FrameOutputSettings const &

        """
        this = _phoPython2Win.new_FrameOutputSettings(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __eq__(self, Other):
        """
        __eq__(FrameOutputSettings self, FrameOutputSettings Other) -> bool

        Parameters
        ----------
        Other: pho::api::FrameOutputSettings const &

        """
        return _phoPython2Win.FrameOutputSettings___eq__(self, Other)

    __swig_destroy__ = _phoPython2Win.delete_FrameOutputSettings
    __del__ = lambda self: None
FrameOutputSettings_swigregister = _phoPython2Win.FrameOutputSettings_swigregister
FrameOutputSettings_swigregister(FrameOutputSettings)

class PhoXiFeatureInterface(_object):
    """Proxy of C++ pho::api::PhoXiFeatureInterface class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, PhoXiFeatureInterface, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, PhoXiFeatureInterface, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def isImplemented(self):
        """
        isImplemented(PhoXiFeatureInterface self) -> bool

        Parameters
        ----------
        self: pho::api::PhoXiFeatureInterface const *

        """
        return _phoPython2Win.PhoXiFeatureInterface_isImplemented(self)


    def isEnabled(self):
        """
        isEnabled(PhoXiFeatureInterface self) -> bool

        Parameters
        ----------
        self: pho::api::PhoXiFeatureInterface const *

        """
        return _phoPython2Win.PhoXiFeatureInterface_isEnabled(self)


    def GetLastErrorMessage(self):
        """
        GetLastErrorMessage(PhoXiFeatureInterface self) -> std::string

        Parameters
        ----------
        self: pho::api::PhoXiFeatureInterface const *

        """
        return _phoPython2Win.PhoXiFeatureInterface_GetLastErrorMessage(self)


    def isLastOperationSuccessful(self):
        """
        isLastOperationSuccessful(PhoXiFeatureInterface self) -> bool

        Parameters
        ----------
        self: pho::api::PhoXiFeatureInterface const *

        """
        return _phoPython2Win.PhoXiFeatureInterface_isLastOperationSuccessful(self)


    def isInitiated(self):
        """
        isInitiated(PhoXiFeatureInterface self) -> bool

        Parameters
        ----------
        self: pho::api::PhoXiFeatureInterface const *

        """
        return _phoPython2Win.PhoXiFeatureInterface_isInitiated(self)


    def GetName(self):
        """
        GetName(PhoXiFeatureInterface self) -> std::string

        Parameters
        ----------
        self: pho::api::PhoXiFeatureInterface const *

        """
        return _phoPython2Win.PhoXiFeatureInterface_GetName(self)


    def CanGet(self):
        """
        CanGet(PhoXiFeatureInterface self) -> bool

        Parameters
        ----------
        self: pho::api::PhoXiFeatureInterface const *

        """
        return _phoPython2Win.PhoXiFeatureInterface_CanGet(self)


    def CanSet(self):
        """
        CanSet(PhoXiFeatureInterface self) -> bool

        Parameters
        ----------
        self: pho::api::PhoXiFeatureInterface const *

        """
        return _phoPython2Win.PhoXiFeatureInterface_CanSet(self)

    __swig_destroy__ = _phoPython2Win.delete_PhoXiFeatureInterface
    __del__ = lambda self: None
PhoXiFeatureInterface_swigregister = _phoPython2Win.PhoXiFeatureInterface_swigregister
PhoXiFeatureInterface_swigregister(PhoXiFeatureInterface)

class PhoXiInterface(_object):
    """Proxy of C++ pho::api::PhoXiInterface class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, PhoXiInterface, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, PhoXiInterface, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _phoPython2Win.delete_PhoXiInterface
    __del__ = lambda self: None

    def isConnected(self):
        """
        isConnected(PhoXiInterface self) -> bool

        Parameters
        ----------
        self: pho::api::PhoXiInterface const *

        """
        return _phoPython2Win.PhoXiInterface_isConnected(self)


    def isAcquiring(self):
        """
        isAcquiring(PhoXiInterface self) -> bool

        Parameters
        ----------
        self: pho::api::PhoXiInterface *

        """
        return _phoPython2Win.PhoXiInterface_isAcquiring(self)


    def SetName(self, Name):
        """
        SetName(PhoXiInterface self, std::string const & Name)

        Parameters
        ----------
        Name: std::string const &

        """
        return _phoPython2Win.PhoXiInterface_SetName(self, Name)


    def GetName(self):
        """
        GetName(PhoXiInterface self) -> std::string

        Parameters
        ----------
        self: pho::api::PhoXiInterface const *

        """
        return _phoPython2Win.PhoXiInterface_GetName(self)


    def GetFrame(self, *args):
        """
        GetFrame(PhoXiInterface self, PhoXiTimeout Timeout) -> pho::api::PFrame

        Parameters
        ----------
        Timeout: pho::api::PhoXiTimeout

        GetFrame(PhoXiInterface self) -> pho::api::PFrame
        GetFrame(PhoXiInterface self, PhoXiTimeout Timeout, double & RealDuration, bool PrintError=True) -> pho::api::PFrame

        Parameters
        ----------
        Timeout: pho::api::PhoXiTimeout
        RealDuration: double &
        PrintError: bool

        GetFrame(PhoXiInterface self, PhoXiTimeout Timeout, double & RealDuration) -> pho::api::PFrame

        Parameters
        ----------
        Timeout: pho::api::PhoXiTimeout
        RealDuration: double &

        """
        return _phoPython2Win.PhoXiInterface_GetFrame(self, *args)


    def GetSpecificFrame(self, *args):
        """
        GetSpecificFrame(PhoXiInterface self, int FrameID, PhoXiTimeout Timeout) -> pho::api::PFrame

        Parameters
        ----------
        FrameID: int
        Timeout: pho::api::PhoXiTimeout

        GetSpecificFrame(PhoXiInterface self, int FrameID) -> pho::api::PFrame

        Parameters
        ----------
        FrameID: int

        """
        return _phoPython2Win.PhoXiInterface_GetSpecificFrame(self, *args)


    def TriggerImage(self, WaitForAccept=True):
        """
        TriggerImage(PhoXiInterface self, bool WaitForAccept=True) -> int

        Parameters
        ----------
        WaitForAccept: bool

        TriggerImage(PhoXiInterface self) -> int

        Parameters
        ----------
        self: pho::api::PhoXiInterface *

        """
        return _phoPython2Win.PhoXiInterface_TriggerImage(self, WaitForAccept)


    def TriggerFrame(self, WaitForAccept=True, WaitForGrabbingEnd=False):
        """
        TriggerFrame(PhoXiInterface self, bool WaitForAccept=True, bool WaitForGrabbingEnd=False) -> int

        Parameters
        ----------
        WaitForAccept: bool
        WaitForGrabbingEnd: bool

        TriggerFrame(PhoXiInterface self, bool WaitForAccept=True) -> int

        Parameters
        ----------
        WaitForAccept: bool

        TriggerFrame(PhoXiInterface self) -> int

        Parameters
        ----------
        self: pho::api::PhoXiInterface *

        """
        return _phoPython2Win.PhoXiInterface_TriggerFrame(self, WaitForAccept, WaitForGrabbingEnd)


    def StartAcquisition(self):
        """
        StartAcquisition(PhoXiInterface self) -> bool

        Parameters
        ----------
        self: pho::api::PhoXiInterface *

        """
        return _phoPython2Win.PhoXiInterface_StartAcquisition(self)


    def StopAcquisition(self):
        """
        StopAcquisition(PhoXiInterface self) -> bool

        Parameters
        ----------
        self: pho::api::PhoXiInterface *

        """
        return _phoPython2Win.PhoXiInterface_StopAcquisition(self)

    __swig_setmethods__["Features"] = _phoPython2Win.PhoXiInterface_Features_set
    __swig_getmethods__["Features"] = _phoPython2Win.PhoXiInterface_Features_get
    if _newclass:
        Features = _swig_property(_phoPython2Win.PhoXiInterface_Features_get, _phoPython2Win.PhoXiInterface_Features_set)
PhoXiInterface_swigregister = _phoPython2Win.PhoXiInterface_swigregister
PhoXiInterface_swigregister(PhoXiInterface)

PHOXI_OPERATION_TIMEOUT_DEFAULT = _phoPython2Win.PHOXI_OPERATION_TIMEOUT_DEFAULT
class PhoXiDeviceType(_object):
    """Proxy of C++ pho::api::PhoXiDeviceType class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, PhoXiDeviceType, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, PhoXiDeviceType, name)
    __repr__ = _swig_repr
    PhoXiScanner = _phoPython2Win.PhoXiDeviceType_PhoXiScanner
    NoValue = _phoPython2Win.PhoXiDeviceType_NoValue

    def __init__(self, *args):
        """
        __init__(pho::api::PhoXiDeviceType self, int const & Type) -> PhoXiDeviceType

        Parameters
        ----------
        Type: int const &

        __init__(pho::api::PhoXiDeviceType self, pho::api::PhoXiDeviceType::Value const & Type) -> PhoXiDeviceType

        Parameters
        ----------
        Type: pho::api::PhoXiDeviceType::Value const &

        __init__(pho::api::PhoXiDeviceType self, std::string const & Type) -> PhoXiDeviceType

        Parameters
        ----------
        Type: std::string const &

        __init__(pho::api::PhoXiDeviceType self) -> PhoXiDeviceType
        """
        this = _phoPython2Win.new_PhoXiDeviceType(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    PhoXiDeviceTypesCount = _phoPython2Win.PhoXiDeviceType_PhoXiDeviceTypesCount
    __swig_destroy__ = _phoPython2Win.delete_PhoXiDeviceType
    __del__ = lambda self: None
PhoXiDeviceType_swigregister = _phoPython2Win.PhoXiDeviceType_swigregister
PhoXiDeviceType_swigregister(PhoXiDeviceType)

class PPhoXi(_object):
    """Proxy of C++ pho::api::PPhoXi class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, PPhoXi, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, PPhoXi, name)
    __repr__ = _swig_repr

    def __deref__(self):
        """
        __deref__(PPhoXi self) -> PhoXi

        Parameters
        ----------
        self: pho::api::PPhoXi const *

        """
        return _phoPython2Win.PPhoXi___deref__(self)


    def __init__(self, *args):
        """
        __init__(pho::api::PPhoXi self, PPhoXi Other) -> PPhoXi

        Parameters
        ----------
        Other: pho::api::PPhoXi const &

        __init__(pho::api::PPhoXi self, std::shared_ptr< pho::api::PhoXi > const & Other) -> PPhoXi

        Parameters
        ----------
        Other: std::shared_ptr< pho::api::PhoXi > const &

        __init__(pho::api::PPhoXi self, std::nullptr_t arg2) -> PPhoXi

        Parameters
        ----------
        arg2: std::nullptr_t

        __init__(pho::api::PPhoXi self) -> PPhoXi
        """
        this = _phoPython2Win.new_PPhoXi(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __nonzero__(self):
        return _phoPython2Win.PPhoXi___nonzero__(self)
    __bool__ = __nonzero__



    def Reset(self):
        """
        Reset(PPhoXi self)

        Parameters
        ----------
        self: pho::api::PPhoXi *

        """
        return _phoPython2Win.PPhoXi_Reset(self)

    __swig_destroy__ = _phoPython2Win.delete_PPhoXi
    __del__ = lambda self: None

    def GetType(self):
        """
        GetType(PPhoXi self) -> PhoXiDeviceType

        Parameters
        ----------
        self: pho::api::PPhoXi const *

        """
        return _phoPython2Win.PPhoXi_GetType(self)


    def CanConnect(self):
        """
        CanConnect(PPhoXi self) -> bool

        Parameters
        ----------
        self: pho::api::PPhoXi *

        """
        return _phoPython2Win.PPhoXi_CanConnect(self)


    def Connect(self):
        """
        Connect(PPhoXi self) -> bool

        Parameters
        ----------
        self: pho::api::PPhoXi *

        """
        return _phoPython2Win.PPhoXi_Connect(self)


    def Disconnect(self, LogOutDevice=False):
        """
        Disconnect(PPhoXi self, bool LogOutDevice=False) -> bool

        Parameters
        ----------
        LogOutDevice: bool

        Disconnect(PPhoXi self) -> bool

        Parameters
        ----------
        self: pho::api::PPhoXi *

        """
        return _phoPython2Win.PPhoXi_Disconnect(self, LogOutDevice)


    def GetFrame(self, *args):
        """
        GetFrame(PPhoXi self, PhoXiTimeout Timeout) -> pho::api::PFrame

        Parameters
        ----------
        Timeout: pho::api::PhoXiTimeout

        GetFrame(PPhoXi self) -> pho::api::PFrame
        GetFrame(PPhoXi self, PhoXiTimeout Timeout, double & RealDuration, bool PrintError=True) -> pho::api::PFrame

        Parameters
        ----------
        Timeout: pho::api::PhoXiTimeout
        RealDuration: double &
        PrintError: bool

        GetFrame(PPhoXi self, PhoXiTimeout Timeout, double & RealDuration) -> pho::api::PFrame

        Parameters
        ----------
        Timeout: pho::api::PhoXiTimeout
        RealDuration: double &

        """
        return _phoPython2Win.PPhoXi_GetFrame(self, *args)


    def GetSpecificFrame(self, *args):
        """
        GetSpecificFrame(PPhoXi self, int FrameID, PhoXiTimeout Timeout) -> pho::api::PFrame

        Parameters
        ----------
        FrameID: int
        Timeout: pho::api::PhoXiTimeout

        GetSpecificFrame(PPhoXi self, int FrameID) -> pho::api::PFrame

        Parameters
        ----------
        FrameID: int

        """
        return _phoPython2Win.PPhoXi_GetSpecificFrame(self, *args)


    def ClearBuffer(self):
        """
        ClearBuffer(PPhoXi self) -> int

        Parameters
        ----------
        self: pho::api::PPhoXi *

        """
        return _phoPython2Win.PPhoXi_ClearBuffer(self)


    def StartAcquisition(self):
        """
        StartAcquisition(PPhoXi self) -> bool

        Parameters
        ----------
        self: pho::api::PPhoXi *

        """
        return _phoPython2Win.PPhoXi_StartAcquisition(self)


    def StopAcquisition(self):
        """
        StopAcquisition(PPhoXi self) -> bool

        Parameters
        ----------
        self: pho::api::PPhoXi *

        """
        return _phoPython2Win.PPhoXi_StopAcquisition(self)


    def TriggerFrame(self, WaitForAccept=True, WaitForGrabbingEnd=False):
        """
        TriggerFrame(PPhoXi self, bool WaitForAccept=True, bool WaitForGrabbingEnd=False) -> int

        Parameters
        ----------
        WaitForAccept: bool
        WaitForGrabbingEnd: bool

        TriggerFrame(PPhoXi self, bool WaitForAccept=True) -> int

        Parameters
        ----------
        WaitForAccept: bool

        TriggerFrame(PPhoXi self) -> int

        Parameters
        ----------
        self: pho::api::PPhoXi *

        """
        return _phoPython2Win.PPhoXi_TriggerFrame(self, WaitForAccept, WaitForGrabbingEnd)


    def LockGUI(self):
        """
        LockGUI(PPhoXi self) -> bool

        Parameters
        ----------
        self: pho::api::PPhoXi *

        """
        return _phoPython2Win.PPhoXi_LockGUI(self)


    def UnlockGUI(self):
        """
        UnlockGUI(PPhoXi self) -> bool

        Parameters
        ----------
        self: pho::api::PPhoXi *

        """
        return _phoPython2Win.PPhoXi_UnlockGUI(self)


    def isConnected(self):
        """
        isConnected(PPhoXi self) -> bool

        Parameters
        ----------
        self: pho::api::PPhoXi const *

        """
        return _phoPython2Win.PPhoXi_isConnected(self)


    def isAcquiring(self):
        """
        isAcquiring(PPhoXi self) -> bool

        Parameters
        ----------
        self: pho::api::PPhoXi *

        """
        return _phoPython2Win.PPhoXi_isAcquiring(self)


    def SetName(self, Name):
        """
        SetName(PPhoXi self, std::string const & Name)

        Parameters
        ----------
        Name: std::string const &

        """
        return _phoPython2Win.PPhoXi_SetName(self, Name)


    def GetName(self):
        """
        GetName(PPhoXi self) -> std::string

        Parameters
        ----------
        self: pho::api::PPhoXi const *

        """
        return _phoPython2Win.PPhoXi_GetName(self)


    def TriggerImage(self, WaitForAccept=True):
        """
        TriggerImage(PPhoXi self, bool WaitForAccept=True) -> int

        Parameters
        ----------
        WaitForAccept: bool

        TriggerImage(PPhoXi self) -> int

        Parameters
        ----------
        self: pho::api::PPhoXi *

        """
        return _phoPython2Win.PPhoXi_TriggerImage(self, WaitForAccept)

    __swig_setmethods__["Features"] = _phoPython2Win.PPhoXi_Features_set
    __swig_getmethods__["Features"] = _phoPython2Win.PPhoXi_Features_get
    if _newclass:
        Features = _swig_property(_phoPython2Win.PPhoXi_Features_get, _phoPython2Win.PPhoXi_Features_set)
PPhoXi_swigregister = _phoPython2Win.PPhoXi_swigregister
PPhoXi_swigregister(PPhoXi)

class PhoXi(PhoXiInterface):
    """Proxy of C++ pho::api::PhoXi class."""

    __swig_setmethods__ = {}
    for _s in [PhoXiInterface]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PhoXi, name, value)
    __swig_getmethods__ = {}
    for _s in [PhoXiInterface]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, PhoXi, name)
    __repr__ = _swig_repr

    def __init__(self):
        """__init__(pho::api::PhoXi self) -> PhoXi"""
        this = _phoPython2Win.new_PhoXi()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _phoPython2Win.delete_PhoXi
    __del__ = lambda self: None

    def GetType(self):
        """
        GetType(PhoXi self) -> PhoXiDeviceType

        Parameters
        ----------
        self: pho::api::PhoXi const *

        """
        return _phoPython2Win.PhoXi_GetType(self)


    def CanConnect(self):
        """
        CanConnect(PhoXi self) -> bool

        Parameters
        ----------
        self: pho::api::PhoXi *

        """
        return _phoPython2Win.PhoXi_CanConnect(self)


    def Connect(self):
        """
        Connect(PhoXi self) -> bool

        Parameters
        ----------
        self: pho::api::PhoXi *

        """
        return _phoPython2Win.PhoXi_Connect(self)


    def Disconnect(self, LogOutDevice=False):
        """
        Disconnect(PhoXi self, bool LogOutDevice=False) -> bool

        Parameters
        ----------
        LogOutDevice: bool

        Disconnect(PhoXi self) -> bool

        Parameters
        ----------
        self: pho::api::PhoXi *

        """
        return _phoPython2Win.PhoXi_Disconnect(self, LogOutDevice)


    def GetFrame(self, *args):
        """
        GetFrame(PhoXi self, PhoXiTimeout Timeout) -> pho::api::PFrame

        Parameters
        ----------
        Timeout: pho::api::PhoXiTimeout

        GetFrame(PhoXi self) -> pho::api::PFrame
        GetFrame(PhoXi self, PhoXiTimeout Timeout, double & RealDuration, bool PrintError=True) -> pho::api::PFrame

        Parameters
        ----------
        Timeout: pho::api::PhoXiTimeout
        RealDuration: double &
        PrintError: bool

        GetFrame(PhoXi self, PhoXiTimeout Timeout, double & RealDuration) -> pho::api::PFrame

        Parameters
        ----------
        Timeout: pho::api::PhoXiTimeout
        RealDuration: double &

        """
        return _phoPython2Win.PhoXi_GetFrame(self, *args)


    def GetSpecificFrame(self, *args):
        """
        GetSpecificFrame(PhoXi self, int FrameID, PhoXiTimeout Timeout) -> pho::api::PFrame

        Parameters
        ----------
        FrameID: int
        Timeout: pho::api::PhoXiTimeout

        GetSpecificFrame(PhoXi self, int FrameID) -> pho::api::PFrame

        Parameters
        ----------
        FrameID: int

        """
        return _phoPython2Win.PhoXi_GetSpecificFrame(self, *args)


    def ClearBuffer(self):
        """
        ClearBuffer(PhoXi self) -> int

        Parameters
        ----------
        self: pho::api::PhoXi *

        """
        return _phoPython2Win.PhoXi_ClearBuffer(self)


    def StartAcquisition(self):
        """
        StartAcquisition(PhoXi self) -> bool

        Parameters
        ----------
        self: pho::api::PhoXi *

        """
        return _phoPython2Win.PhoXi_StartAcquisition(self)


    def StopAcquisition(self):
        """
        StopAcquisition(PhoXi self) -> bool

        Parameters
        ----------
        self: pho::api::PhoXi *

        """
        return _phoPython2Win.PhoXi_StopAcquisition(self)


    def TriggerFrame(self, WaitForAccept=True, WaitForGrabbingEnd=False):
        """
        TriggerFrame(PhoXi self, bool WaitForAccept=True, bool WaitForGrabbingEnd=False) -> int

        Parameters
        ----------
        WaitForAccept: bool
        WaitForGrabbingEnd: bool

        TriggerFrame(PhoXi self, bool WaitForAccept=True) -> int

        Parameters
        ----------
        WaitForAccept: bool

        TriggerFrame(PhoXi self) -> int

        Parameters
        ----------
        self: pho::api::PhoXi *

        """
        return _phoPython2Win.PhoXi_TriggerFrame(self, WaitForAccept, WaitForGrabbingEnd)


    def LockGUI(self):
        """
        LockGUI(PhoXi self) -> bool

        Parameters
        ----------
        self: pho::api::PhoXi *

        """
        return _phoPython2Win.PhoXi_LockGUI(self)


    def UnlockGUI(self):
        """
        UnlockGUI(PhoXi self) -> bool

        Parameters
        ----------
        self: pho::api::PhoXi *

        """
        return _phoPython2Win.PhoXi_UnlockGUI(self)

PhoXi_swigregister = _phoPython2Win.PhoXi_swigregister
PhoXi_swigregister(PhoXi)

class PhoXiDeviceInformation(_object):
    """Proxy of C++ pho::api::PhoXiDeviceInformation class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, PhoXiDeviceInformation, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, PhoXiDeviceInformation, name)
    __repr__ = _swig_repr
    __swig_setmethods__["Name"] = _phoPython2Win.PhoXiDeviceInformation_Name_set
    __swig_getmethods__["Name"] = _phoPython2Win.PhoXiDeviceInformation_Name_get
    if _newclass:
        Name = _swig_property(_phoPython2Win.PhoXiDeviceInformation_Name_get, _phoPython2Win.PhoXiDeviceInformation_Name_set)
    __swig_setmethods__["Type"] = _phoPython2Win.PhoXiDeviceInformation_Type_set
    __swig_getmethods__["Type"] = _phoPython2Win.PhoXiDeviceInformation_Type_get
    if _newclass:
        Type = _swig_property(_phoPython2Win.PhoXiDeviceInformation_Type_get, _phoPython2Win.PhoXiDeviceInformation_Type_set)
    __swig_setmethods__["HWIdentification"] = _phoPython2Win.PhoXiDeviceInformation_HWIdentification_set
    __swig_getmethods__["HWIdentification"] = _phoPython2Win.PhoXiDeviceInformation_HWIdentification_get
    if _newclass:
        HWIdentification = _swig_property(_phoPython2Win.PhoXiDeviceInformation_HWIdentification_get, _phoPython2Win.PhoXiDeviceInformation_HWIdentification_set)
    __swig_setmethods__["Status"] = _phoPython2Win.PhoXiDeviceInformation_Status_set
    __swig_getmethods__["Status"] = _phoPython2Win.PhoXiDeviceInformation_Status_get
    if _newclass:
        Status = _swig_property(_phoPython2Win.PhoXiDeviceInformation_Status_get, _phoPython2Win.PhoXiDeviceInformation_Status_set)
    __swig_setmethods__["FirmwareVersion"] = _phoPython2Win.PhoXiDeviceInformation_FirmwareVersion_set
    __swig_getmethods__["FirmwareVersion"] = _phoPython2Win.PhoXiDeviceInformation_FirmwareVersion_get
    if _newclass:
        FirmwareVersion = _swig_property(_phoPython2Win.PhoXiDeviceInformation_FirmwareVersion_get, _phoPython2Win.PhoXiDeviceInformation_FirmwareVersion_set)

    def ConnectedToPhoXiControl(self):
        """
        ConnectedToPhoXiControl(PhoXiDeviceInformation self) -> bool

        Parameters
        ----------
        self: pho::api::PhoXiDeviceInformation const *

        """
        return _phoPython2Win.PhoXiDeviceInformation_ConnectedToPhoXiControl(self)


    def __init__(self):
        """__init__(pho::api::PhoXiDeviceInformation self) -> PhoXiDeviceInformation"""
        this = _phoPython2Win.new_PhoXiDeviceInformation()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def GetTypeHWIdentification(self):
        """
        GetTypeHWIdentification(PhoXiDeviceInformation self) -> std::string

        Parameters
        ----------
        self: pho::api::PhoXiDeviceInformation const *

        """
        return _phoPython2Win.PhoXiDeviceInformation_GetTypeHWIdentification(self)

    __swig_destroy__ = _phoPython2Win.delete_PhoXiDeviceInformation
    __del__ = lambda self: None
PhoXiDeviceInformation_swigregister = _phoPython2Win.PhoXiDeviceInformation_swigregister
PhoXiDeviceInformation_swigregister(PhoXiDeviceInformation)

class PhoXiFactory(_object):
    """Proxy of C++ pho::api::PhoXiFactory class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, PhoXiFactory, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, PhoXiFactory, name)
    __repr__ = _swig_repr

    def Create(self, *args):
        """
        Create(PhoXiFactory self, PhoXiDeviceType Type) -> PPhoXi

        Parameters
        ----------
        Type: pho::api::PhoXiDeviceType

        Create(PhoXiFactory self, std::string const & Type) -> PPhoXi

        Parameters
        ----------
        Type: std::string const &

        Create(PhoXiFactory self, int Type) -> PPhoXi

        Parameters
        ----------
        Type: int

        """
        return _phoPython2Win.PhoXiFactory_Create(self, *args)


    def CreateAndConnect(self, *args):
        """
        CreateAndConnect(PhoXiFactory self, std::string const & HWIdentification, PhoXiTimeout Timeout) -> PPhoXi

        Parameters
        ----------
        HWIdentification: std::string const &
        Timeout: pho::api::PhoXiTimeout

        CreateAndConnect(PhoXiFactory self, std::string const & HWIdentification) -> PPhoXi

        Parameters
        ----------
        HWIdentification: std::string const &

        CreateAndConnect(PhoXiFactory self, std::string const & HWIdentification, PhoXiDeviceType Type, std::string const & IP4) -> PPhoXi

        Parameters
        ----------
        HWIdentification: std::string const &
        Type: pho::api::PhoXiDeviceType
        IP4: std::string const &

        """
        return _phoPython2Win.PhoXiFactory_CreateAndConnect(self, *args)


    def CreateAndConnectFirstAttached(self):
        """
        CreateAndConnectFirstAttached(PhoXiFactory self) -> PPhoXi

        Parameters
        ----------
        self: pho::api::PhoXiFactory *

        """
        return _phoPython2Win.PhoXiFactory_CreateAndConnectFirstAttached(self)


    def GetDeviceList(self, RefreshDeviceDiscovery=False):
        """
        GetDeviceList(PhoXiFactory self, bool RefreshDeviceDiscovery=False) -> PhoXiDeviceInformationVector

        Parameters
        ----------
        RefreshDeviceDiscovery: bool

        GetDeviceList(PhoXiFactory self) -> PhoXiDeviceInformationVector

        Parameters
        ----------
        self: pho::api::PhoXiFactory *

        """
        return _phoPython2Win.PhoXiFactory_GetDeviceList(self, RefreshDeviceDiscovery)


    def isPhoXiControlRunning(self):
        """
        isPhoXiControlRunning(PhoXiFactory self) -> bool

        Parameters
        ----------
        self: pho::api::PhoXiFactory *

        """
        return _phoPython2Win.PhoXiFactory_isPhoXiControlRunning(self)


    def GetPhoXiControlVersion(self):
        """
        GetPhoXiControlVersion(PhoXiFactory self) -> std::string

        Parameters
        ----------
        self: pho::api::PhoXiFactory *

        """
        return _phoPython2Win.PhoXiFactory_GetPhoXiControlVersion(self)


    def GetAPIVersion(self):
        """
        GetAPIVersion(PhoXiFactory self) -> std::string

        Parameters
        ----------
        self: pho::api::PhoXiFactory *

        """
        return _phoPython2Win.PhoXiFactory_GetAPIVersion(self)


    def MinimizePhoXiControl(self):
        """
        MinimizePhoXiControl(PhoXiFactory self) -> bool

        Parameters
        ----------
        self: pho::api::PhoXiFactory *

        """
        return _phoPython2Win.PhoXiFactory_MinimizePhoXiControl(self)


    def __init__(self):
        """__init__(pho::api::PhoXiFactory self) -> PhoXiFactory"""
        this = _phoPython2Win.new_PhoXiFactory()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def CanConnect(self, HardwareIdentification):
        """
        CanConnect(PhoXiFactory self, std::string HardwareIdentification) -> bool

        Parameters
        ----------
        HardwareIdentification: std::string

        """
        return _phoPython2Win.PhoXiFactory_CanConnect(self, HardwareIdentification)


    def RemovePhoXi(self, HWIdentification):
        """
        RemovePhoXi(PhoXiFactory self, std::string const & HWIdentification) -> bool

        Parameters
        ----------
        HWIdentification: std::string const &

        """
        return _phoPython2Win.PhoXiFactory_RemovePhoXi(self, HWIdentification)


    def StartConsoleOutput(self, Type):
        """
        StartConsoleOutput(PhoXiFactory self, std::string const & Type)

        Parameters
        ----------
        Type: std::string const &

        """
        return _phoPython2Win.PhoXiFactory_StartConsoleOutput(self, Type)


    def isInDebugMode(self):
        """
        isInDebugMode(PhoXiFactory self) -> bool

        Parameters
        ----------
        self: pho::api::PhoXiFactory *

        """
        return _phoPython2Win.PhoXiFactory_isInDebugMode(self)

    __swig_destroy__ = _phoPython2Win.delete_PhoXiFactory
    __del__ = lambda self: None
PhoXiFactory_swigregister = _phoPython2Win.PhoXiFactory_swigregister
PhoXiFactory_swigregister(PhoXiFactory)

class MatTypeFloat32_f(_object):
    """Proxy of C++ pho::api::MatType<(pho::api::float32_t)> class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, MatTypeFloat32_f, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, MatTypeFloat32_f, name)
    __repr__ = _swig_repr
    TypeSize = _phoPython2Win.MatTypeFloat32_f_TypeSize

    def floatref(self):
        """
        floatref(MatTypeFloat32_f self) -> float &

        Parameters
        ----------
        self: pho::api::MatType< pho::api::float32_t > *

        """
        return _phoPython2Win.MatTypeFloat32_f_floatref(self)


    def __init__(self, *args):
        """
        __init__(pho::api::MatType<(pho::api::float32_t)> self) -> MatTypeFloat32_f
        __init__(pho::api::MatType<(pho::api::float32_t)> self, MatTypeFloat32_f Other) -> MatTypeFloat32_f

        Parameters
        ----------
        Other: pho::api::MatType< float > const &

        __init__(pho::api::MatType<(pho::api::float32_t)> self, float const & Other) -> MatTypeFloat32_f

        Parameters
        ----------
        Other: float const &

        """
        this = _phoPython2Win.new_MatTypeFloat32_f(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __eq__(self, Other):
        """
        __eq__(MatTypeFloat32_f self, MatTypeFloat32_f Other) -> bool

        Parameters
        ----------
        Other: pho::api::MatType< pho::api::float32_t > const &

        """
        return _phoPython2Win.MatTypeFloat32_f___eq__(self, Other)


    def __ne__(self, Other):
        """
        __ne__(MatTypeFloat32_f self, MatTypeFloat32_f Other) -> bool

        Parameters
        ----------
        Other: pho::api::MatType< pho::api::float32_t > const &

        """
        return _phoPython2Win.MatTypeFloat32_f___ne__(self, Other)

    __swig_destroy__ = _phoPython2Win.delete_MatTypeFloat32_f
    __del__ = lambda self: None
MatTypeFloat32_f_swigregister = _phoPython2Win.MatTypeFloat32_f_swigregister
MatTypeFloat32_f_swigregister(MatTypeFloat32_f)
cvar = _phoPython2Win.cvar
MatTypeFloat32_f.TypeName = _phoPython2Win.cvar.MatTypeFloat32_f_TypeName

class MatInterfacePoint3Float2D(_object):
    """Proxy of C++ pho::api::MatInterface<(pho::api::Point3_32f,2)> class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, MatInterfacePoint3Float2D, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, MatInterfacePoint3Float2D, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    CopyData = _phoPython2Win.MatInterfacePoint3Float2D_CopyData
    NoCopyNoOwnership = _phoPython2Win.MatInterfacePoint3Float2D_NoCopyNoOwnership
    NoCopyFullOwnership = _phoPython2Win.MatInterfacePoint3Float2D_NoCopyFullOwnership

    def GetDimensions(self):
        """
        GetDimensions(MatInterfacePoint3Float2D self) -> std::vector< int,std::allocator< int > >

        Parameters
        ----------
        self: pho::api::MatInterface< pho::api::Point3_32f,2 > const *

        """
        return _phoPython2Win.MatInterfacePoint3Float2D_GetDimensions(self)


    def GetDimension(self, Index):
        """
        GetDimension(MatInterfacePoint3Float2D self, int Index) -> int

        Parameters
        ----------
        Index: int

        """
        return _phoPython2Win.MatInterfacePoint3Float2D_GetDimension(self, Index)


    def GetElementsCount(self):
        """
        GetElementsCount(MatInterfacePoint3Float2D self) -> std::size_t

        Parameters
        ----------
        self: pho::api::MatInterface< pho::api::Point3_32f,2 > const *

        """
        return _phoPython2Win.MatInterfacePoint3Float2D_GetElementsCount(self)


    def GetDataSize(self):
        """
        GetDataSize(MatInterfacePoint3Float2D self) -> std::size_t

        Parameters
        ----------
        self: pho::api::MatInterface< pho::api::Point3_32f,2 > const *

        """
        return _phoPython2Win.MatInterfacePoint3Float2D_GetDataSize(self)


    def GetElementSize():
        """GetElementSize() -> std::size_t"""
        return _phoPython2Win.MatInterfacePoint3Float2D_GetElementSize()

    GetElementSize = staticmethod(GetElementSize)

    def GetElementName():
        """GetElementName() -> std::string"""
        return _phoPython2Win.MatInterfacePoint3Float2D_GetElementName()

    GetElementName = staticmethod(GetElementName)

    def Reshape(self, SizeND):
        """
        Reshape(MatInterfacePoint3Float2D self, std::vector< int,std::allocator< int > > const & SizeND) -> bool

        Parameters
        ----------
        SizeND: std::vector< int,std::allocator< int > > const &

        """
        return _phoPython2Win.MatInterfacePoint3Float2D_Reshape(self, SizeND)


    def Resize(self, SizeND):
        """
        Resize(MatInterfacePoint3Float2D self, std::vector< int,std::allocator< int > > const & SizeND) -> bool

        Parameters
        ----------
        SizeND: std::vector< int,std::allocator< int > > const &

        """
        return _phoPython2Win.MatInterfacePoint3Float2D_Resize(self, SizeND)


    def Assign(self, SizeND, Data_, DataOwnershipTransfer):
        """
        Assign(MatInterfacePoint3Float2D self, std::vector< int,std::allocator< int > > const & SizeND, Point3_32f Data_, pho::api::MatInterface< pho::api::Point3< float >,2 >::OwnershipTransfer DataOwnershipTransfer) -> bool

        Parameters
        ----------
        SizeND: std::vector< int,std::allocator< int > > const &
        Data_: pho::api::Point3< float > *
        DataOwnershipTransfer: enum pho::api::MatInterface< pho::api::Point3< float >,2 >::OwnershipTransfer

        """
        return _phoPython2Win.MatInterfacePoint3Float2D_Assign(self, SizeND, Data_, DataOwnershipTransfer)


    def At(self, *args):
        """
        At(MatInterfacePoint3Float2D self, std::vector< int,std::allocator< int > > const & Index) -> Point3_32f

        Parameters
        ----------
        Index: std::vector< int,std::allocator< int > > const &

        At(MatInterfacePoint3Float2D self, std::vector< int,std::allocator< int > > const & Index) -> Point3_32f

        Parameters
        ----------
        Index: std::vector< int,std::allocator< int > > const &

        """
        return _phoPython2Win.MatInterfacePoint3Float2D_At(self, *args)


    def GetDataPtr(self, *args):
        """
        GetDataPtr(MatInterfacePoint3Float2D self) -> Point3_32f
        GetDataPtr(MatInterfacePoint3Float2D self) -> Point3_32f

        Parameters
        ----------
        self: pho::api::MatInterface< pho::api::Point3_32f,2 > const *

        """
        return _phoPython2Win.MatInterfacePoint3Float2D_GetDataPtr(self, *args)


    def Empty(self):
        """
        Empty(MatInterfacePoint3Float2D self) -> bool

        Parameters
        ----------
        self: pho::api::MatInterface< pho::api::Point3_32f,2 > const *

        """
        return _phoPython2Win.MatInterfacePoint3Float2D_Empty(self)


    def Clear(self):
        """
        Clear(MatInterfacePoint3Float2D self) -> bool

        Parameters
        ----------
        self: pho::api::MatInterface< pho::api::Point3_32f,2 > *

        """
        return _phoPython2Win.MatInterfacePoint3Float2D_Clear(self)

    __swig_destroy__ = _phoPython2Win.delete_MatInterfacePoint3Float2D
    __del__ = lambda self: None
MatInterfacePoint3Float2D_swigregister = _phoPython2Win.MatInterfacePoint3Float2D_swigregister
MatInterfacePoint3Float2D_swigregister(MatInterfacePoint3Float2D)

def MatInterfacePoint3Float2D_GetElementSize():
    """MatInterfacePoint3Float2D_GetElementSize() -> std::size_t"""
    return _phoPython2Win.MatInterfacePoint3Float2D_GetElementSize()

def MatInterfacePoint3Float2D_GetElementName():
    """MatInterfacePoint3Float2D_GetElementName() -> std::string"""
    return _phoPython2Win.MatInterfacePoint3Float2D_GetElementName()

class MatInterfaceDepthFloat2D(_object):
    """Proxy of C++ pho::api::MatInterface<(pho::api::Depth_32f,2)> class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, MatInterfaceDepthFloat2D, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, MatInterfaceDepthFloat2D, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    CopyData = _phoPython2Win.MatInterfaceDepthFloat2D_CopyData
    NoCopyNoOwnership = _phoPython2Win.MatInterfaceDepthFloat2D_NoCopyNoOwnership
    NoCopyFullOwnership = _phoPython2Win.MatInterfaceDepthFloat2D_NoCopyFullOwnership

    def GetDimensions(self):
        """
        GetDimensions(MatInterfaceDepthFloat2D self) -> std::vector< int,std::allocator< int > >

        Parameters
        ----------
        self: pho::api::MatInterface< pho::api::Depth_32f,2 > const *

        """
        return _phoPython2Win.MatInterfaceDepthFloat2D_GetDimensions(self)


    def GetDimension(self, Index):
        """
        GetDimension(MatInterfaceDepthFloat2D self, int Index) -> int

        Parameters
        ----------
        Index: int

        """
        return _phoPython2Win.MatInterfaceDepthFloat2D_GetDimension(self, Index)


    def GetElementsCount(self):
        """
        GetElementsCount(MatInterfaceDepthFloat2D self) -> std::size_t

        Parameters
        ----------
        self: pho::api::MatInterface< pho::api::Depth_32f,2 > const *

        """
        return _phoPython2Win.MatInterfaceDepthFloat2D_GetElementsCount(self)


    def GetDataSize(self):
        """
        GetDataSize(MatInterfaceDepthFloat2D self) -> std::size_t

        Parameters
        ----------
        self: pho::api::MatInterface< pho::api::Depth_32f,2 > const *

        """
        return _phoPython2Win.MatInterfaceDepthFloat2D_GetDataSize(self)


    def GetElementSize():
        """GetElementSize() -> std::size_t"""
        return _phoPython2Win.MatInterfaceDepthFloat2D_GetElementSize()

    GetElementSize = staticmethod(GetElementSize)

    def GetElementName():
        """GetElementName() -> std::string"""
        return _phoPython2Win.MatInterfaceDepthFloat2D_GetElementName()

    GetElementName = staticmethod(GetElementName)

    def Reshape(self, SizeND):
        """
        Reshape(MatInterfaceDepthFloat2D self, std::vector< int,std::allocator< int > > const & SizeND) -> bool

        Parameters
        ----------
        SizeND: std::vector< int,std::allocator< int > > const &

        """
        return _phoPython2Win.MatInterfaceDepthFloat2D_Reshape(self, SizeND)


    def Resize(self, SizeND):
        """
        Resize(MatInterfaceDepthFloat2D self, std::vector< int,std::allocator< int > > const & SizeND) -> bool

        Parameters
        ----------
        SizeND: std::vector< int,std::allocator< int > > const &

        """
        return _phoPython2Win.MatInterfaceDepthFloat2D_Resize(self, SizeND)


    def Assign(self, SizeND, Data_, DataOwnershipTransfer):
        """
        Assign(MatInterfaceDepthFloat2D self, std::vector< int,std::allocator< int > > const & SizeND, Depth_32f Data_, pho::api::MatInterface< pho::api::Scalar< float >,2 >::OwnershipTransfer DataOwnershipTransfer) -> bool

        Parameters
        ----------
        SizeND: std::vector< int,std::allocator< int > > const &
        Data_: pho::api::Scalar< float > *
        DataOwnershipTransfer: enum pho::api::MatInterface< pho::api::Scalar< float >,2 >::OwnershipTransfer

        """
        return _phoPython2Win.MatInterfaceDepthFloat2D_Assign(self, SizeND, Data_, DataOwnershipTransfer)


    def At(self, *args):
        """
        At(MatInterfaceDepthFloat2D self, std::vector< int,std::allocator< int > > const & Index) -> Depth_32f

        Parameters
        ----------
        Index: std::vector< int,std::allocator< int > > const &

        At(MatInterfaceDepthFloat2D self, std::vector< int,std::allocator< int > > const & Index) -> Depth_32f

        Parameters
        ----------
        Index: std::vector< int,std::allocator< int > > const &

        """
        return _phoPython2Win.MatInterfaceDepthFloat2D_At(self, *args)


    def GetDataPtr(self, *args):
        """
        GetDataPtr(MatInterfaceDepthFloat2D self) -> Depth_32f
        GetDataPtr(MatInterfaceDepthFloat2D self) -> Depth_32f

        Parameters
        ----------
        self: pho::api::MatInterface< pho::api::Depth_32f,2 > const *

        """
        return _phoPython2Win.MatInterfaceDepthFloat2D_GetDataPtr(self, *args)


    def Empty(self):
        """
        Empty(MatInterfaceDepthFloat2D self) -> bool

        Parameters
        ----------
        self: pho::api::MatInterface< pho::api::Depth_32f,2 > const *

        """
        return _phoPython2Win.MatInterfaceDepthFloat2D_Empty(self)


    def Clear(self):
        """
        Clear(MatInterfaceDepthFloat2D self) -> bool

        Parameters
        ----------
        self: pho::api::MatInterface< pho::api::Depth_32f,2 > *

        """
        return _phoPython2Win.MatInterfaceDepthFloat2D_Clear(self)

    __swig_destroy__ = _phoPython2Win.delete_MatInterfaceDepthFloat2D
    __del__ = lambda self: None
MatInterfaceDepthFloat2D_swigregister = _phoPython2Win.MatInterfaceDepthFloat2D_swigregister
MatInterfaceDepthFloat2D_swigregister(MatInterfaceDepthFloat2D)

def MatInterfaceDepthFloat2D_GetElementSize():
    """MatInterfaceDepthFloat2D_GetElementSize() -> std::size_t"""
    return _phoPython2Win.MatInterfaceDepthFloat2D_GetElementSize()

def MatInterfaceDepthFloat2D_GetElementName():
    """MatInterfaceDepthFloat2D_GetElementName() -> std::string"""
    return _phoPython2Win.MatInterfaceDepthFloat2D_GetElementName()

class PointCloud32f(MatInterfacePoint3Float2D):
    """Proxy of C++ pho::api::Mat2D<(pho::api::Point3_32f)> class."""

    __swig_setmethods__ = {}
    for _s in [MatInterfacePoint3Float2D]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PointCloud32f, name, value)
    __swig_getmethods__ = {}
    for _s in [MatInterfacePoint3Float2D]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, PointCloud32f, name)
    __repr__ = _swig_repr
    __swig_setmethods__["Size"] = _phoPython2Win.PointCloud32f_Size_set
    __swig_getmethods__["Size"] = _phoPython2Win.PointCloud32f_Size_get
    if _newclass:
        Size = _swig_property(_phoPython2Win.PointCloud32f_Size_get, _phoPython2Win.PointCloud32f_Size_set)

    def Reshape(self, *args):
        """
        Reshape(PointCloud32f self, std::vector< int,std::allocator< int > > const & SizeND) -> bool

        Parameters
        ----------
        SizeND: std::vector< int,std::allocator< int > > const &

        Reshape(PointCloud32f self, PhoXiSize Size) -> bool

        Parameters
        ----------
        Size: pho::api::PhoXiSize const &

        """
        return _phoPython2Win.PointCloud32f_Reshape(self, *args)


    def Resize(self, *args):
        """
        Resize(PointCloud32f self, std::vector< int,std::allocator< int > > const & SizeND) -> bool

        Parameters
        ----------
        SizeND: std::vector< int,std::allocator< int > > const &

        Resize(PointCloud32f self, PhoXiSize Size) -> bool

        Parameters
        ----------
        Size: pho::api::PhoXiSize const &

        """
        return _phoPython2Win.PointCloud32f_Resize(self, *args)


    def At(self, *args):
        """
        At(PointCloud32f self, int y, int x) -> Point3_32f

        Parameters
        ----------
        y: int
        x: int

        At(PointCloud32f self, int y, int x) -> Point3_32f

        Parameters
        ----------
        y: int
        x: int

        """
        return _phoPython2Win.PointCloud32f_At(self, *args)


    def GetChannelCopy(self, OutputMat, ChannelIndex):
        """
        GetChannelCopy(PointCloud32f self, DepthMap32f OutputMat, int ChannelIndex) -> bool

        Parameters
        ----------
        OutputMat: pho::api::Mat2D< pho::api::Scalar< pho::api::Point3< float >::ElementChannelType > > &
        ChannelIndex: int

        """
        return _phoPython2Win.PointCloud32f_GetChannelCopy(self, OutputMat, ChannelIndex)


    def __init__(self, *args):
        """
        __init__(pho::api::Mat2D<(pho::api::Point3_32f)> self, PointCloud32f Other) -> PointCloud32f

        Parameters
        ----------
        Other: pho::api::Mat2D< pho::api::Point3_32f > const &

        __init__(pho::api::Mat2D<(pho::api::Point3_32f)> self, std::vector< int,std::allocator< int > > const & SizeND) -> PointCloud32f

        Parameters
        ----------
        SizeND: std::vector< int,std::allocator< int > > const &

        __init__(pho::api::Mat2D<(pho::api::Point3_32f)> self, std::vector< int,std::allocator< int > > const & SizeND, Point3_32f _Data, pho::api::MatInterface< pho::api::Point3< float >,2 >::OwnershipTransfer DataOwnershipTransfer) -> PointCloud32f

        Parameters
        ----------
        SizeND: std::vector< int,std::allocator< int > > const &
        _Data: pho::api::Point3< float > *
        DataOwnershipTransfer: enum pho::api::MatInterface< pho::api::Point3< float >,2 >::OwnershipTransfer

        __init__(pho::api::Mat2D<(pho::api::Point3_32f)> self, PhoXiSize Size) -> PointCloud32f

        Parameters
        ----------
        Size: pho::api::PhoXiSize const &

        __init__(pho::api::Mat2D<(pho::api::Point3_32f)> self, PhoXiSize Size, Point3_32f _Data, pho::api::MatInterface< pho::api::Point3< float >,2 >::OwnershipTransfer DataOwnershipTransfer) -> PointCloud32f

        Parameters
        ----------
        Size: pho::api::PhoXiSize const &
        _Data: pho::api::Point3< float > *
        DataOwnershipTransfer: enum pho::api::MatInterface< pho::api::Point3< float >,2 >::OwnershipTransfer

        __init__(pho::api::Mat2D<(pho::api::Point3_32f)> self) -> PointCloud32f
        """
        this = _phoPython2Win.new_PointCloud32f(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def Assign(self, *args):
        """
        Assign(PointCloud32f self, PhoXiSize Size, Point3_32f _Data, pho::api::MatInterface< pho::api::Point3< float >,2 >::OwnershipTransfer DataOwnershipTransfer) -> bool

        Parameters
        ----------
        Size: pho::api::PhoXiSize const &
        _Data: pho::api::Point3< float > *
        DataOwnershipTransfer: enum pho::api::MatInterface< pho::api::Point3< float >,2 >::OwnershipTransfer

        Assign(PointCloud32f self, std::vector< int,std::allocator< int > > const & SizeND, Point3_32f _Data, pho::api::MatInterface< pho::api::Point3< float >,2 >::OwnershipTransfer DataOwnershipTransfer) -> bool

        Parameters
        ----------
        SizeND: std::vector< int,std::allocator< int > > const &
        _Data: pho::api::Point3< float > *
        DataOwnershipTransfer: enum pho::api::MatInterface< pho::api::Point3< float >,2 >::OwnershipTransfer

        """
        return _phoPython2Win.PointCloud32f_Assign(self, *args)


    def ConvertTo2DArray(self, mat2DArray):
        """
        ConvertTo2DArray(PointCloud32f self, float * mat2DArray)

        Parameters
        ----------
        mat2DArray: float *

        """
        return _phoPython2Win.PointCloud32f_ConvertTo2DArray(self, mat2DArray)


    def ConvertTo3DArray(self, mat2DArray):
        """
        ConvertTo3DArray(PointCloud32f self, float * mat2DArray)

        Parameters
        ----------
        mat2DArray: float *

        """
        return _phoPython2Win.PointCloud32f_ConvertTo3DArray(self, mat2DArray)

    __swig_destroy__ = _phoPython2Win.delete_PointCloud32f
    __del__ = lambda self: None
PointCloud32f_swigregister = _phoPython2Win.PointCloud32f_swigregister
PointCloud32f_swigregister(PointCloud32f)

class DepthMap32f(MatInterfaceDepthFloat2D):
    """Proxy of C++ pho::api::Mat2D<(pho::api::Depth_32f)> class."""

    __swig_setmethods__ = {}
    for _s in [MatInterfaceDepthFloat2D]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, DepthMap32f, name, value)
    __swig_getmethods__ = {}
    for _s in [MatInterfaceDepthFloat2D]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, DepthMap32f, name)
    __repr__ = _swig_repr
    __swig_setmethods__["Size"] = _phoPython2Win.DepthMap32f_Size_set
    __swig_getmethods__["Size"] = _phoPython2Win.DepthMap32f_Size_get
    if _newclass:
        Size = _swig_property(_phoPython2Win.DepthMap32f_Size_get, _phoPython2Win.DepthMap32f_Size_set)

    def Reshape(self, *args):
        """
        Reshape(DepthMap32f self, std::vector< int,std::allocator< int > > const & SizeND) -> bool

        Parameters
        ----------
        SizeND: std::vector< int,std::allocator< int > > const &

        Reshape(DepthMap32f self, PhoXiSize Size) -> bool

        Parameters
        ----------
        Size: pho::api::PhoXiSize const &

        """
        return _phoPython2Win.DepthMap32f_Reshape(self, *args)


    def Resize(self, *args):
        """
        Resize(DepthMap32f self, std::vector< int,std::allocator< int > > const & SizeND) -> bool

        Parameters
        ----------
        SizeND: std::vector< int,std::allocator< int > > const &

        Resize(DepthMap32f self, PhoXiSize Size) -> bool

        Parameters
        ----------
        Size: pho::api::PhoXiSize const &

        """
        return _phoPython2Win.DepthMap32f_Resize(self, *args)


    def At(self, *args):
        """
        At(DepthMap32f self, int y, int x) -> Depth_32f

        Parameters
        ----------
        y: int
        x: int

        At(DepthMap32f self, int y, int x) -> Depth_32f

        Parameters
        ----------
        y: int
        x: int

        """
        return _phoPython2Win.DepthMap32f_At(self, *args)


    def GetChannelCopy(self, OutputMat, ChannelIndex):
        """
        GetChannelCopy(DepthMap32f self, DepthMap32f OutputMat, int ChannelIndex) -> bool

        Parameters
        ----------
        OutputMat: pho::api::Mat2D< pho::api::Scalar< pho::api::Scalar< float >::ElementChannelType > > &
        ChannelIndex: int

        """
        return _phoPython2Win.DepthMap32f_GetChannelCopy(self, OutputMat, ChannelIndex)


    def __init__(self, *args):
        """
        __init__(pho::api::Mat2D<(pho::api::Depth_32f)> self, DepthMap32f Other) -> DepthMap32f

        Parameters
        ----------
        Other: pho::api::Mat2D< pho::api::Depth_32f > const &

        __init__(pho::api::Mat2D<(pho::api::Depth_32f)> self, std::vector< int,std::allocator< int > > const & SizeND) -> DepthMap32f

        Parameters
        ----------
        SizeND: std::vector< int,std::allocator< int > > const &

        __init__(pho::api::Mat2D<(pho::api::Depth_32f)> self, std::vector< int,std::allocator< int > > const & SizeND, Depth_32f _Data, pho::api::MatInterface< pho::api::Scalar< float >,2 >::OwnershipTransfer DataOwnershipTransfer) -> DepthMap32f

        Parameters
        ----------
        SizeND: std::vector< int,std::allocator< int > > const &
        _Data: pho::api::Scalar< float > *
        DataOwnershipTransfer: enum pho::api::MatInterface< pho::api::Scalar< float >,2 >::OwnershipTransfer

        __init__(pho::api::Mat2D<(pho::api::Depth_32f)> self, PhoXiSize Size) -> DepthMap32f

        Parameters
        ----------
        Size: pho::api::PhoXiSize const &

        __init__(pho::api::Mat2D<(pho::api::Depth_32f)> self, PhoXiSize Size, Depth_32f _Data, pho::api::MatInterface< pho::api::Scalar< float >,2 >::OwnershipTransfer DataOwnershipTransfer) -> DepthMap32f

        Parameters
        ----------
        Size: pho::api::PhoXiSize const &
        _Data: pho::api::Scalar< float > *
        DataOwnershipTransfer: enum pho::api::MatInterface< pho::api::Scalar< float >,2 >::OwnershipTransfer

        __init__(pho::api::Mat2D<(pho::api::Depth_32f)> self) -> DepthMap32f
        """
        this = _phoPython2Win.new_DepthMap32f(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def Assign(self, *args):
        """
        Assign(DepthMap32f self, PhoXiSize Size, Depth_32f _Data, pho::api::MatInterface< pho::api::Scalar< float >,2 >::OwnershipTransfer DataOwnershipTransfer) -> bool

        Parameters
        ----------
        Size: pho::api::PhoXiSize const &
        _Data: pho::api::Scalar< float > *
        DataOwnershipTransfer: enum pho::api::MatInterface< pho::api::Scalar< float >,2 >::OwnershipTransfer

        Assign(DepthMap32f self, std::vector< int,std::allocator< int > > const & SizeND, Depth_32f _Data, pho::api::MatInterface< pho::api::Scalar< float >,2 >::OwnershipTransfer DataOwnershipTransfer) -> bool

        Parameters
        ----------
        SizeND: std::vector< int,std::allocator< int > > const &
        _Data: pho::api::Scalar< float > *
        DataOwnershipTransfer: enum pho::api::MatInterface< pho::api::Scalar< float >,2 >::OwnershipTransfer

        """
        return _phoPython2Win.DepthMap32f_Assign(self, *args)


    def ConvertTo2DArray(self, mat2DArray):
        """
        ConvertTo2DArray(DepthMap32f self, float * mat2DArray)

        Parameters
        ----------
        mat2DArray: float *

        """
        return _phoPython2Win.DepthMap32f_ConvertTo2DArray(self, mat2DArray)


    def ConvertTo3DArray(self, mat2DArray):
        """
        ConvertTo3DArray(DepthMap32f self, float * mat2DArray)

        Parameters
        ----------
        mat2DArray: float *

        """
        return _phoPython2Win.DepthMap32f_ConvertTo3DArray(self, mat2DArray)

    __swig_destroy__ = _phoPython2Win.delete_DepthMap32f
    __del__ = lambda self: None
DepthMap32f_swigregister = _phoPython2Win.DepthMap32f_swigregister
DepthMap32f_swigregister(DepthMap32f)

class ConfidenceMap32f(MatInterfaceDepthFloat2D):
    """Proxy of C++ pho::api::Mat2D<(pho::api::Intensity_32f)> class."""

    __swig_setmethods__ = {}
    for _s in [MatInterfaceDepthFloat2D]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ConfidenceMap32f, name, value)
    __swig_getmethods__ = {}
    for _s in [MatInterfaceDepthFloat2D]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ConfidenceMap32f, name)
    __repr__ = _swig_repr
    __swig_setmethods__["Size"] = _phoPython2Win.ConfidenceMap32f_Size_set
    __swig_getmethods__["Size"] = _phoPython2Win.ConfidenceMap32f_Size_get
    if _newclass:
        Size = _swig_property(_phoPython2Win.ConfidenceMap32f_Size_get, _phoPython2Win.ConfidenceMap32f_Size_set)

    def Reshape(self, *args):
        """
        Reshape(ConfidenceMap32f self, std::vector< int,std::allocator< int > > const & SizeND) -> bool

        Parameters
        ----------
        SizeND: std::vector< int,std::allocator< int > > const &

        Reshape(ConfidenceMap32f self, PhoXiSize Size) -> bool

        Parameters
        ----------
        Size: pho::api::PhoXiSize const &

        """
        return _phoPython2Win.ConfidenceMap32f_Reshape(self, *args)


    def Resize(self, *args):
        """
        Resize(ConfidenceMap32f self, std::vector< int,std::allocator< int > > const & SizeND) -> bool

        Parameters
        ----------
        SizeND: std::vector< int,std::allocator< int > > const &

        Resize(ConfidenceMap32f self, PhoXiSize Size) -> bool

        Parameters
        ----------
        Size: pho::api::PhoXiSize const &

        """
        return _phoPython2Win.ConfidenceMap32f_Resize(self, *args)


    def At(self, *args):
        """
        At(ConfidenceMap32f self, int y, int x) -> Depth_32f

        Parameters
        ----------
        y: int
        x: int

        At(ConfidenceMap32f self, int y, int x) -> Depth_32f

        Parameters
        ----------
        y: int
        x: int

        """
        return _phoPython2Win.ConfidenceMap32f_At(self, *args)


    def GetChannelCopy(self, OutputMat, ChannelIndex):
        """
        GetChannelCopy(ConfidenceMap32f self, DepthMap32f OutputMat, int ChannelIndex) -> bool

        Parameters
        ----------
        OutputMat: pho::api::Mat2D< pho::api::Scalar< pho::api::Scalar< float >::ElementChannelType > > &
        ChannelIndex: int

        """
        return _phoPython2Win.ConfidenceMap32f_GetChannelCopy(self, OutputMat, ChannelIndex)


    def __init__(self, *args):
        """
        __init__(pho::api::Mat2D<(pho::api::Intensity_32f)> self, DepthMap32f Other) -> ConfidenceMap32f

        Parameters
        ----------
        Other: pho::api::Mat2D< pho::api::Intensity_32f > const &

        __init__(pho::api::Mat2D<(pho::api::Intensity_32f)> self, std::vector< int,std::allocator< int > > const & SizeND) -> ConfidenceMap32f

        Parameters
        ----------
        SizeND: std::vector< int,std::allocator< int > > const &

        __init__(pho::api::Mat2D<(pho::api::Intensity_32f)> self, std::vector< int,std::allocator< int > > const & SizeND, Depth_32f _Data, pho::api::MatInterface< pho::api::Scalar< float >,2 >::OwnershipTransfer DataOwnershipTransfer) -> ConfidenceMap32f

        Parameters
        ----------
        SizeND: std::vector< int,std::allocator< int > > const &
        _Data: pho::api::Scalar< float > *
        DataOwnershipTransfer: enum pho::api::MatInterface< pho::api::Scalar< float >,2 >::OwnershipTransfer

        __init__(pho::api::Mat2D<(pho::api::Intensity_32f)> self, PhoXiSize Size) -> ConfidenceMap32f

        Parameters
        ----------
        Size: pho::api::PhoXiSize const &

        __init__(pho::api::Mat2D<(pho::api::Intensity_32f)> self, PhoXiSize Size, Depth_32f _Data, pho::api::MatInterface< pho::api::Scalar< float >,2 >::OwnershipTransfer DataOwnershipTransfer) -> ConfidenceMap32f

        Parameters
        ----------
        Size: pho::api::PhoXiSize const &
        _Data: pho::api::Scalar< float > *
        DataOwnershipTransfer: enum pho::api::MatInterface< pho::api::Scalar< float >,2 >::OwnershipTransfer

        __init__(pho::api::Mat2D<(pho::api::Intensity_32f)> self) -> ConfidenceMap32f
        """
        this = _phoPython2Win.new_ConfidenceMap32f(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def Assign(self, *args):
        """
        Assign(ConfidenceMap32f self, PhoXiSize Size, Depth_32f _Data, pho::api::MatInterface< pho::api::Scalar< float >,2 >::OwnershipTransfer DataOwnershipTransfer) -> bool

        Parameters
        ----------
        Size: pho::api::PhoXiSize const &
        _Data: pho::api::Scalar< float > *
        DataOwnershipTransfer: enum pho::api::MatInterface< pho::api::Scalar< float >,2 >::OwnershipTransfer

        Assign(ConfidenceMap32f self, std::vector< int,std::allocator< int > > const & SizeND, Depth_32f _Data, pho::api::MatInterface< pho::api::Scalar< float >,2 >::OwnershipTransfer DataOwnershipTransfer) -> bool

        Parameters
        ----------
        SizeND: std::vector< int,std::allocator< int > > const &
        _Data: pho::api::Scalar< float > *
        DataOwnershipTransfer: enum pho::api::MatInterface< pho::api::Scalar< float >,2 >::OwnershipTransfer

        """
        return _phoPython2Win.ConfidenceMap32f_Assign(self, *args)


    def ConvertTo2DArray(self, mat2DArray):
        """
        ConvertTo2DArray(ConfidenceMap32f self, float * mat2DArray)

        Parameters
        ----------
        mat2DArray: float *

        """
        return _phoPython2Win.ConfidenceMap32f_ConvertTo2DArray(self, mat2DArray)


    def ConvertTo3DArray(self, mat2DArray):
        """
        ConvertTo3DArray(ConfidenceMap32f self, float * mat2DArray)

        Parameters
        ----------
        mat2DArray: float *

        """
        return _phoPython2Win.ConfidenceMap32f_ConvertTo3DArray(self, mat2DArray)

    __swig_destroy__ = _phoPython2Win.delete_ConfidenceMap32f
    __del__ = lambda self: None
ConfidenceMap32f_swigregister = _phoPython2Win.ConfidenceMap32f_swigregister
ConfidenceMap32f_swigregister(ConfidenceMap32f)

class Point3_32f(_object):
    """Proxy of C++ pho::api::Point3<(pho::api::float32_t)> class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Point3_32f, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Point3_32f, name)
    __repr__ = _swig_repr
    __swig_setmethods__["x"] = _phoPython2Win.Point3_32f_x_set
    __swig_getmethods__["x"] = _phoPython2Win.Point3_32f_x_get
    if _newclass:
        x = _swig_property(_phoPython2Win.Point3_32f_x_get, _phoPython2Win.Point3_32f_x_set)
    __swig_setmethods__["y"] = _phoPython2Win.Point3_32f_y_set
    __swig_getmethods__["y"] = _phoPython2Win.Point3_32f_y_get
    if _newclass:
        y = _swig_property(_phoPython2Win.Point3_32f_y_get, _phoPython2Win.Point3_32f_y_set)
    __swig_setmethods__["z"] = _phoPython2Win.Point3_32f_z_set
    __swig_getmethods__["z"] = _phoPython2Win.Point3_32f_z_get
    if _newclass:
        z = _swig_property(_phoPython2Win.Point3_32f_z_get, _phoPython2Win.Point3_32f_z_set)

    def __init__(self, *args):
        """
        __init__(pho::api::Point3<(pho::api::float32_t)> self) -> Point3_32f
        __init__(pho::api::Point3<(pho::api::float32_t)> self, float const & _x, float const & _y, float const & _z) -> Point3_32f

        Parameters
        ----------
        _x: float const &
        _y: float const &
        _z: float const &

        """
        this = _phoPython2Win.new_Point3_32f(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __eq__(self, Other):
        """
        __eq__(Point3_32f self, Point3_32f Other) -> bool

        Parameters
        ----------
        Other: pho::api::Point3< pho::api::float32_t > const &

        """
        return _phoPython2Win.Point3_32f___eq__(self, Other)


    def __ne__(self, Other):
        """
        __ne__(Point3_32f self, Point3_32f Other) -> bool

        Parameters
        ----------
        Other: pho::api::Point3< pho::api::float32_t > const &

        """
        return _phoPython2Win.Point3_32f___ne__(self, Other)

    __swig_destroy__ = _phoPython2Win.delete_Point3_32f
    __del__ = lambda self: None
Point3_32f_swigregister = _phoPython2Win.Point3_32f_swigregister
Point3_32f_swigregister(Point3_32f)

class Depth_32f(MatTypeFloat32_f):
    """Proxy of C++ pho::api::Scalar<(pho::api::float32_t)> class."""

    __swig_setmethods__ = {}
    for _s in [MatTypeFloat32_f]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Depth_32f, name, value)
    __swig_getmethods__ = {}
    for _s in [MatTypeFloat32_f]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Depth_32f, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(pho::api::Scalar<(pho::api::float32_t)> self) -> Depth_32f
        __init__(pho::api::Scalar<(pho::api::float32_t)> self, Depth_32f Other) -> Depth_32f

        Parameters
        ----------
        Other: pho::api::Scalar< pho::api::float32_t > const &

        __init__(pho::api::Scalar<(pho::api::float32_t)> self, float const & Other) -> Depth_32f

        Parameters
        ----------
        Other: float const &

        """
        this = _phoPython2Win.new_Depth_32f(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _phoPython2Win.delete_Depth_32f
    __del__ = lambda self: None
Depth_32f_swigregister = _phoPython2Win.Depth_32f_swigregister
Depth_32f_swigregister(Depth_32f)

class PhoXiDeviceInformationVector(_object):
    """Proxy of C++ std::vector<(pho::api::PhoXiDeviceInformation)> class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, PhoXiDeviceInformationVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, PhoXiDeviceInformationVector, name)
    __repr__ = _swig_repr

    def iterator(self):
        """
        iterator(PhoXiDeviceInformationVector self) -> SwigPyIterator

        Parameters
        ----------
        self: std::vector< pho::api::PhoXiDeviceInformation > *

        """
        return _phoPython2Win.PhoXiDeviceInformationVector_iterator(self)

    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        """
        __nonzero__(PhoXiDeviceInformationVector self) -> bool

        Parameters
        ----------
        self: std::vector< pho::api::PhoXiDeviceInformation > const *

        """
        return _phoPython2Win.PhoXiDeviceInformationVector___nonzero__(self)


    def __bool__(self):
        """
        __bool__(PhoXiDeviceInformationVector self) -> bool

        Parameters
        ----------
        self: std::vector< pho::api::PhoXiDeviceInformation > const *

        """
        return _phoPython2Win.PhoXiDeviceInformationVector___bool__(self)


    def __len__(self):
        """
        __len__(PhoXiDeviceInformationVector self) -> std::vector< pho::api::PhoXiDeviceInformation >::size_type

        Parameters
        ----------
        self: std::vector< pho::api::PhoXiDeviceInformation > const *

        """
        return _phoPython2Win.PhoXiDeviceInformationVector___len__(self)


    def __getslice__(self, i, j):
        """
        __getslice__(PhoXiDeviceInformationVector self, std::vector< pho::api::PhoXiDeviceInformation >::difference_type i, std::vector< pho::api::PhoXiDeviceInformation >::difference_type j) -> PhoXiDeviceInformationVector

        Parameters
        ----------
        i: std::vector< pho::api::PhoXiDeviceInformation >::difference_type
        j: std::vector< pho::api::PhoXiDeviceInformation >::difference_type

        """
        return _phoPython2Win.PhoXiDeviceInformationVector___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(PhoXiDeviceInformationVector self, std::vector< pho::api::PhoXiDeviceInformation >::difference_type i, std::vector< pho::api::PhoXiDeviceInformation >::difference_type j)

        Parameters
        ----------
        i: std::vector< pho::api::PhoXiDeviceInformation >::difference_type
        j: std::vector< pho::api::PhoXiDeviceInformation >::difference_type

        __setslice__(PhoXiDeviceInformationVector self, std::vector< pho::api::PhoXiDeviceInformation >::difference_type i, std::vector< pho::api::PhoXiDeviceInformation >::difference_type j, PhoXiDeviceInformationVector v)

        Parameters
        ----------
        i: std::vector< pho::api::PhoXiDeviceInformation >::difference_type
        j: std::vector< pho::api::PhoXiDeviceInformation >::difference_type
        v: std::vector< pho::api::PhoXiDeviceInformation,std::allocator< pho::api::PhoXiDeviceInformation > > const &

        """
        return _phoPython2Win.PhoXiDeviceInformationVector___setslice__(self, *args)


    def __delslice__(self, i, j):
        """
        __delslice__(PhoXiDeviceInformationVector self, std::vector< pho::api::PhoXiDeviceInformation >::difference_type i, std::vector< pho::api::PhoXiDeviceInformation >::difference_type j)

        Parameters
        ----------
        i: std::vector< pho::api::PhoXiDeviceInformation >::difference_type
        j: std::vector< pho::api::PhoXiDeviceInformation >::difference_type

        """
        return _phoPython2Win.PhoXiDeviceInformationVector___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(PhoXiDeviceInformationVector self, std::vector< pho::api::PhoXiDeviceInformation >::difference_type i)

        Parameters
        ----------
        i: std::vector< pho::api::PhoXiDeviceInformation >::difference_type

        __delitem__(PhoXiDeviceInformationVector self, PySliceObject * slice)

        Parameters
        ----------
        slice: PySliceObject *

        """
        return _phoPython2Win.PhoXiDeviceInformationVector___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(PhoXiDeviceInformationVector self, PySliceObject * slice) -> PhoXiDeviceInformationVector

        Parameters
        ----------
        slice: PySliceObject *

        __getitem__(PhoXiDeviceInformationVector self, std::vector< pho::api::PhoXiDeviceInformation >::difference_type i) -> PhoXiDeviceInformation

        Parameters
        ----------
        i: std::vector< pho::api::PhoXiDeviceInformation >::difference_type

        """
        return _phoPython2Win.PhoXiDeviceInformationVector___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(PhoXiDeviceInformationVector self, PySliceObject * slice, PhoXiDeviceInformationVector v)

        Parameters
        ----------
        slice: PySliceObject *
        v: std::vector< pho::api::PhoXiDeviceInformation,std::allocator< pho::api::PhoXiDeviceInformation > > const &

        __setitem__(PhoXiDeviceInformationVector self, PySliceObject * slice)

        Parameters
        ----------
        slice: PySliceObject *

        __setitem__(PhoXiDeviceInformationVector self, std::vector< pho::api::PhoXiDeviceInformation >::difference_type i, PhoXiDeviceInformation x)

        Parameters
        ----------
        i: std::vector< pho::api::PhoXiDeviceInformation >::difference_type
        x: std::vector< pho::api::PhoXiDeviceInformation >::value_type const &

        """
        return _phoPython2Win.PhoXiDeviceInformationVector___setitem__(self, *args)


    def pop(self):
        """
        pop(PhoXiDeviceInformationVector self) -> PhoXiDeviceInformation

        Parameters
        ----------
        self: std::vector< pho::api::PhoXiDeviceInformation > *

        """
        return _phoPython2Win.PhoXiDeviceInformationVector_pop(self)


    def append(self, x):
        """
        append(PhoXiDeviceInformationVector self, PhoXiDeviceInformation x)

        Parameters
        ----------
        x: std::vector< pho::api::PhoXiDeviceInformation >::value_type const &

        """
        return _phoPython2Win.PhoXiDeviceInformationVector_append(self, x)


    def empty(self):
        """
        empty(PhoXiDeviceInformationVector self) -> bool

        Parameters
        ----------
        self: std::vector< pho::api::PhoXiDeviceInformation > const *

        """
        return _phoPython2Win.PhoXiDeviceInformationVector_empty(self)


    def size(self):
        """
        size(PhoXiDeviceInformationVector self) -> std::vector< pho::api::PhoXiDeviceInformation >::size_type

        Parameters
        ----------
        self: std::vector< pho::api::PhoXiDeviceInformation > const *

        """
        return _phoPython2Win.PhoXiDeviceInformationVector_size(self)


    def swap(self, v):
        """
        swap(PhoXiDeviceInformationVector self, PhoXiDeviceInformationVector v)

        Parameters
        ----------
        v: std::vector< pho::api::PhoXiDeviceInformation > &

        """
        return _phoPython2Win.PhoXiDeviceInformationVector_swap(self, v)


    def begin(self):
        """
        begin(PhoXiDeviceInformationVector self) -> std::vector< pho::api::PhoXiDeviceInformation >::iterator

        Parameters
        ----------
        self: std::vector< pho::api::PhoXiDeviceInformation > *

        """
        return _phoPython2Win.PhoXiDeviceInformationVector_begin(self)


    def end(self):
        """
        end(PhoXiDeviceInformationVector self) -> std::vector< pho::api::PhoXiDeviceInformation >::iterator

        Parameters
        ----------
        self: std::vector< pho::api::PhoXiDeviceInformation > *

        """
        return _phoPython2Win.PhoXiDeviceInformationVector_end(self)


    def rbegin(self):
        """
        rbegin(PhoXiDeviceInformationVector self) -> std::vector< pho::api::PhoXiDeviceInformation >::reverse_iterator

        Parameters
        ----------
        self: std::vector< pho::api::PhoXiDeviceInformation > *

        """
        return _phoPython2Win.PhoXiDeviceInformationVector_rbegin(self)


    def rend(self):
        """
        rend(PhoXiDeviceInformationVector self) -> std::vector< pho::api::PhoXiDeviceInformation >::reverse_iterator

        Parameters
        ----------
        self: std::vector< pho::api::PhoXiDeviceInformation > *

        """
        return _phoPython2Win.PhoXiDeviceInformationVector_rend(self)


    def clear(self):
        """
        clear(PhoXiDeviceInformationVector self)

        Parameters
        ----------
        self: std::vector< pho::api::PhoXiDeviceInformation > *

        """
        return _phoPython2Win.PhoXiDeviceInformationVector_clear(self)


    def get_allocator(self):
        """
        get_allocator(PhoXiDeviceInformationVector self) -> std::vector< pho::api::PhoXiDeviceInformation >::allocator_type

        Parameters
        ----------
        self: std::vector< pho::api::PhoXiDeviceInformation > const *

        """
        return _phoPython2Win.PhoXiDeviceInformationVector_get_allocator(self)


    def pop_back(self):
        """
        pop_back(PhoXiDeviceInformationVector self)

        Parameters
        ----------
        self: std::vector< pho::api::PhoXiDeviceInformation > *

        """
        return _phoPython2Win.PhoXiDeviceInformationVector_pop_back(self)


    def erase(self, *args):
        """
        erase(PhoXiDeviceInformationVector self, std::vector< pho::api::PhoXiDeviceInformation >::iterator pos) -> std::vector< pho::api::PhoXiDeviceInformation >::iterator

        Parameters
        ----------
        pos: std::vector< pho::api::PhoXiDeviceInformation >::iterator

        erase(PhoXiDeviceInformationVector self, std::vector< pho::api::PhoXiDeviceInformation >::iterator first, std::vector< pho::api::PhoXiDeviceInformation >::iterator last) -> std::vector< pho::api::PhoXiDeviceInformation >::iterator

        Parameters
        ----------
        first: std::vector< pho::api::PhoXiDeviceInformation >::iterator
        last: std::vector< pho::api::PhoXiDeviceInformation >::iterator

        """
        return _phoPython2Win.PhoXiDeviceInformationVector_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::vector<(pho::api::PhoXiDeviceInformation)> self) -> PhoXiDeviceInformationVector
        __init__(std::vector<(pho::api::PhoXiDeviceInformation)> self, PhoXiDeviceInformationVector arg2) -> PhoXiDeviceInformationVector

        Parameters
        ----------
        arg2: std::vector< pho::api::PhoXiDeviceInformation > const &

        __init__(std::vector<(pho::api::PhoXiDeviceInformation)> self, std::vector< pho::api::PhoXiDeviceInformation >::size_type size) -> PhoXiDeviceInformationVector

        Parameters
        ----------
        size: std::vector< pho::api::PhoXiDeviceInformation >::size_type

        __init__(std::vector<(pho::api::PhoXiDeviceInformation)> self, std::vector< pho::api::PhoXiDeviceInformation >::size_type size, PhoXiDeviceInformation value) -> PhoXiDeviceInformationVector

        Parameters
        ----------
        size: std::vector< pho::api::PhoXiDeviceInformation >::size_type
        value: std::vector< pho::api::PhoXiDeviceInformation >::value_type const &

        """
        this = _phoPython2Win.new_PhoXiDeviceInformationVector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        """
        push_back(PhoXiDeviceInformationVector self, PhoXiDeviceInformation x)

        Parameters
        ----------
        x: std::vector< pho::api::PhoXiDeviceInformation >::value_type const &

        """
        return _phoPython2Win.PhoXiDeviceInformationVector_push_back(self, x)


    def front(self):
        """
        front(PhoXiDeviceInformationVector self) -> PhoXiDeviceInformation

        Parameters
        ----------
        self: std::vector< pho::api::PhoXiDeviceInformation > const *

        """
        return _phoPython2Win.PhoXiDeviceInformationVector_front(self)


    def back(self):
        """
        back(PhoXiDeviceInformationVector self) -> PhoXiDeviceInformation

        Parameters
        ----------
        self: std::vector< pho::api::PhoXiDeviceInformation > const *

        """
        return _phoPython2Win.PhoXiDeviceInformationVector_back(self)


    def assign(self, n, x):
        """
        assign(PhoXiDeviceInformationVector self, std::vector< pho::api::PhoXiDeviceInformation >::size_type n, PhoXiDeviceInformation x)

        Parameters
        ----------
        n: std::vector< pho::api::PhoXiDeviceInformation >::size_type
        x: std::vector< pho::api::PhoXiDeviceInformation >::value_type const &

        """
        return _phoPython2Win.PhoXiDeviceInformationVector_assign(self, n, x)


    def resize(self, *args):
        """
        resize(PhoXiDeviceInformationVector self, std::vector< pho::api::PhoXiDeviceInformation >::size_type new_size)

        Parameters
        ----------
        new_size: std::vector< pho::api::PhoXiDeviceInformation >::size_type

        resize(PhoXiDeviceInformationVector self, std::vector< pho::api::PhoXiDeviceInformation >::size_type new_size, PhoXiDeviceInformation x)

        Parameters
        ----------
        new_size: std::vector< pho::api::PhoXiDeviceInformation >::size_type
        x: std::vector< pho::api::PhoXiDeviceInformation >::value_type const &

        """
        return _phoPython2Win.PhoXiDeviceInformationVector_resize(self, *args)


    def insert(self, *args):
        """
        insert(PhoXiDeviceInformationVector self, std::vector< pho::api::PhoXiDeviceInformation >::iterator pos, PhoXiDeviceInformation x) -> std::vector< pho::api::PhoXiDeviceInformation >::iterator

        Parameters
        ----------
        pos: std::vector< pho::api::PhoXiDeviceInformation >::iterator
        x: std::vector< pho::api::PhoXiDeviceInformation >::value_type const &

        insert(PhoXiDeviceInformationVector self, std::vector< pho::api::PhoXiDeviceInformation >::iterator pos, std::vector< pho::api::PhoXiDeviceInformation >::size_type n, PhoXiDeviceInformation x)

        Parameters
        ----------
        pos: std::vector< pho::api::PhoXiDeviceInformation >::iterator
        n: std::vector< pho::api::PhoXiDeviceInformation >::size_type
        x: std::vector< pho::api::PhoXiDeviceInformation >::value_type const &

        """
        return _phoPython2Win.PhoXiDeviceInformationVector_insert(self, *args)


    def reserve(self, n):
        """
        reserve(PhoXiDeviceInformationVector self, std::vector< pho::api::PhoXiDeviceInformation >::size_type n)

        Parameters
        ----------
        n: std::vector< pho::api::PhoXiDeviceInformation >::size_type

        """
        return _phoPython2Win.PhoXiDeviceInformationVector_reserve(self, n)


    def capacity(self):
        """
        capacity(PhoXiDeviceInformationVector self) -> std::vector< pho::api::PhoXiDeviceInformation >::size_type

        Parameters
        ----------
        self: std::vector< pho::api::PhoXiDeviceInformation > const *

        """
        return _phoPython2Win.PhoXiDeviceInformationVector_capacity(self)

    __swig_destroy__ = _phoPython2Win.delete_PhoXiDeviceInformationVector
    __del__ = lambda self: None
PhoXiDeviceInformationVector_swigregister = _phoPython2Win.PhoXiDeviceInformationVector_swigregister
PhoXiDeviceInformationVector_swigregister(PhoXiDeviceInformationVector)

# This file is compatible with both classic and new-style classes.


