# This file was automatically generated by SWIG (http://www.swig.org).
# Version 3.0.12
#
# 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, '_viso2')).lstrip('.')
        try:
            return importlib.import_module(mname)
        except ImportError:
            return importlib.import_module('_viso2')
    _viso2 = 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('_viso2', [dirname(__file__)])
        except ImportError:
            import _viso2
            return _viso2
        try:
            _mod = imp.load_module('_viso2', fp, pathname, description)
        finally:
            if fp is not None:
                fp.close()
        return _mod
    _viso2 = swig_import_helper()
    del swig_import_helper
else:
    import _viso2
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

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__ = _viso2.delete_SwigPyIterator
    __del__ = lambda self: None

    def value(self):
        """value(self) -> PyObject *"""
        return _viso2.SwigPyIterator_value(self)


    def incr(self, n=1):
        """
        incr(self, n=1) -> SwigPyIterator
        incr(self) -> SwigPyIterator
        """
        return _viso2.SwigPyIterator_incr(self, n)


    def decr(self, n=1):
        """
        decr(self, n=1) -> SwigPyIterator
        decr(self) -> SwigPyIterator
        """
        return _viso2.SwigPyIterator_decr(self, n)


    def distance(self, x):
        """distance(self, x) -> ptrdiff_t"""
        return _viso2.SwigPyIterator_distance(self, x)


    def equal(self, x):
        """equal(self, x) -> bool"""
        return _viso2.SwigPyIterator_equal(self, x)


    def copy(self):
        """copy(self) -> SwigPyIterator"""
        return _viso2.SwigPyIterator_copy(self)


    def next(self):
        """next(self) -> PyObject *"""
        return _viso2.SwigPyIterator_next(self)


    def __next__(self):
        """__next__(self) -> PyObject *"""
        return _viso2.SwigPyIterator___next__(self)


    def previous(self):
        """previous(self) -> PyObject *"""
        return _viso2.SwigPyIterator_previous(self)


    def advance(self, n):
        """advance(self, n) -> SwigPyIterator"""
        return _viso2.SwigPyIterator_advance(self, n)


    def __eq__(self, x):
        """__eq__(self, x) -> bool"""
        return _viso2.SwigPyIterator___eq__(self, x)


    def __ne__(self, x):
        """__ne__(self, x) -> bool"""
        return _viso2.SwigPyIterator___ne__(self, x)


    def __iadd__(self, n):
        """__iadd__(self, n) -> SwigPyIterator"""
        return _viso2.SwigPyIterator___iadd__(self, n)


    def __isub__(self, n):
        """__isub__(self, n) -> SwigPyIterator"""
        return _viso2.SwigPyIterator___isub__(self, n)


    def __add__(self, n):
        """__add__(self, n) -> SwigPyIterator"""
        return _viso2.SwigPyIterator___add__(self, n)


    def __sub__(self, *args):
        """
        __sub__(self, n) -> SwigPyIterator
        __sub__(self, x) -> ptrdiff_t
        """
        return _viso2.SwigPyIterator___sub__(self, *args)

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

class VisualOdometry(_object):
    """Proxy of C++ VisualOdometry class."""

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

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

    def process(self, p_matched_):
        """process(self, p_matched_) -> bool"""
        return _viso2.VisualOdometry_process(self, p_matched_)


    def getMotion(self):
        """getMotion(self) -> Matrix"""
        return _viso2.VisualOdometry_getMotion(self)


    def getMatches(self):
        """getMatches(self) -> MatchVector"""
        return _viso2.VisualOdometry_getMatches(self)


    def getNumberOfMatches(self):
        """getNumberOfMatches(self) -> int32_t"""
        return _viso2.VisualOdometry_getNumberOfMatches(self)


    def getNumberOfInliers(self):
        """getNumberOfInliers(self) -> int32_t"""
        return _viso2.VisualOdometry_getNumberOfInliers(self)


    def getInlierIndices(self):
        """getInlierIndices(self) -> std::vector< int32_t,std::allocator< int32_t > >"""
        return _viso2.VisualOdometry_getInlierIndices(self)


    def getGain(self, inliers_):
        """getGain(self, inliers_) -> float"""
        return _viso2.VisualOdometry_getGain(self, inliers_)

VisualOdometry_swigregister = _viso2.VisualOdometry_swigregister
VisualOdometry_swigregister(VisualOdometry)

class calibration(_object):
    """Proxy of C++ VisualOdometry::calibration class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, calibration, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, calibration, name)
    __repr__ = _swig_repr
    __swig_setmethods__["f"] = _viso2.calibration_f_set
    __swig_getmethods__["f"] = _viso2.calibration_f_get
    if _newclass:
        f = _swig_property(_viso2.calibration_f_get, _viso2.calibration_f_set)
    __swig_setmethods__["cu"] = _viso2.calibration_cu_set
    __swig_getmethods__["cu"] = _viso2.calibration_cu_get
    if _newclass:
        cu = _swig_property(_viso2.calibration_cu_get, _viso2.calibration_cu_set)
    __swig_setmethods__["cv"] = _viso2.calibration_cv_set
    __swig_getmethods__["cv"] = _viso2.calibration_cv_get
    if _newclass:
        cv = _swig_property(_viso2.calibration_cv_get, _viso2.calibration_cv_set)

    def __init__(self):
        """__init__(self) -> calibration"""
        this = _viso2.new_calibration()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _viso2.delete_calibration
    __del__ = lambda self: None
calibration_swigregister = _viso2.calibration_swigregister
calibration_swigregister(calibration)

class bucketing(_object):
    """Proxy of C++ VisualOdometry::bucketing class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, bucketing, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, bucketing, name)
    __repr__ = _swig_repr
    __swig_setmethods__["max_features"] = _viso2.bucketing_max_features_set
    __swig_getmethods__["max_features"] = _viso2.bucketing_max_features_get
    if _newclass:
        max_features = _swig_property(_viso2.bucketing_max_features_get, _viso2.bucketing_max_features_set)
    __swig_setmethods__["bucket_width"] = _viso2.bucketing_bucket_width_set
    __swig_getmethods__["bucket_width"] = _viso2.bucketing_bucket_width_get
    if _newclass:
        bucket_width = _swig_property(_viso2.bucketing_bucket_width_get, _viso2.bucketing_bucket_width_set)
    __swig_setmethods__["bucket_height"] = _viso2.bucketing_bucket_height_set
    __swig_getmethods__["bucket_height"] = _viso2.bucketing_bucket_height_get
    if _newclass:
        bucket_height = _swig_property(_viso2.bucketing_bucket_height_get, _viso2.bucketing_bucket_height_set)

    def __init__(self):
        """__init__(self) -> bucketing"""
        this = _viso2.new_bucketing()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _viso2.delete_bucketing
    __del__ = lambda self: None
bucketing_swigregister = _viso2.bucketing_swigregister
bucketing_swigregister(bucketing)

class VO_parameters(_object):
    """Proxy of C++ VisualOdometry::parameters class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, VO_parameters, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, VO_parameters, name)
    __repr__ = _swig_repr
    __swig_setmethods__["match"] = _viso2.VO_parameters_match_set
    __swig_getmethods__["match"] = _viso2.VO_parameters_match_get
    if _newclass:
        match = _swig_property(_viso2.VO_parameters_match_get, _viso2.VO_parameters_match_set)
    __swig_setmethods__["bucket"] = _viso2.VO_parameters_bucket_set
    __swig_getmethods__["bucket"] = _viso2.VO_parameters_bucket_get
    if _newclass:
        bucket = _swig_property(_viso2.VO_parameters_bucket_get, _viso2.VO_parameters_bucket_set)
    __swig_setmethods__["calib"] = _viso2.VO_parameters_calib_set
    __swig_getmethods__["calib"] = _viso2.VO_parameters_calib_get
    if _newclass:
        calib = _swig_property(_viso2.VO_parameters_calib_get, _viso2.VO_parameters_calib_set)

    def __init__(self):
        """__init__(self) -> VO_parameters"""
        this = _viso2.new_VO_parameters()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _viso2.delete_VO_parameters
    __del__ = lambda self: None
VO_parameters_swigregister = _viso2.VO_parameters_swigregister
VO_parameters_swigregister(VO_parameters)

class VisualOdometryMono(VisualOdometry):
    """Proxy of C++ VisualOdometryMono class."""

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

    def __init__(self, param):
        """__init__(self, param) -> VisualOdometryMono"""
        this = _viso2.new_VisualOdometryMono(param)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _viso2.delete_VisualOdometryMono
    __del__ = lambda self: None

    def process(self, *args):
        """
        process(self, I, dims, replace=False) -> bool
        process(self, I, dims) -> bool
        process(self, I1, I2, dims, replace=False) -> bool
        process(self, I1, I2, dims) -> bool
        """
        return _viso2.VisualOdometryMono_process(self, *args)


    def getInlierMatches(self):
        """getInlierMatches(self) -> MatchVector"""
        return _viso2.VisualOdometryMono_getInlierMatches(self)


    def process_frame(self, *args):
        """
        process_frame(self, image1, replace=False) -> bool
        process_frame(self, image1) -> bool
        process_frame(self, image1, image2, replace=False) -> bool
        process_frame(self, image1, image2) -> bool
        """
        return _viso2.VisualOdometryMono_process_frame(self, *args)

VisualOdometryMono_swigregister = _viso2.VisualOdometryMono_swigregister
VisualOdometryMono_swigregister(VisualOdometryMono)

class Mono_parameters(VO_parameters):
    """Proxy of C++ VisualOdometryMono::parameters class."""

    __swig_setmethods__ = {}
    for _s in [VO_parameters]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Mono_parameters, name, value)
    __swig_getmethods__ = {}
    for _s in [VO_parameters]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Mono_parameters, name)
    __repr__ = _swig_repr
    __swig_setmethods__["height"] = _viso2.Mono_parameters_height_set
    __swig_getmethods__["height"] = _viso2.Mono_parameters_height_get
    if _newclass:
        height = _swig_property(_viso2.Mono_parameters_height_get, _viso2.Mono_parameters_height_set)
    __swig_setmethods__["pitch"] = _viso2.Mono_parameters_pitch_set
    __swig_getmethods__["pitch"] = _viso2.Mono_parameters_pitch_get
    if _newclass:
        pitch = _swig_property(_viso2.Mono_parameters_pitch_get, _viso2.Mono_parameters_pitch_set)
    __swig_setmethods__["ransac_iters"] = _viso2.Mono_parameters_ransac_iters_set
    __swig_getmethods__["ransac_iters"] = _viso2.Mono_parameters_ransac_iters_get
    if _newclass:
        ransac_iters = _swig_property(_viso2.Mono_parameters_ransac_iters_get, _viso2.Mono_parameters_ransac_iters_set)
    __swig_setmethods__["inlier_threshold"] = _viso2.Mono_parameters_inlier_threshold_set
    __swig_getmethods__["inlier_threshold"] = _viso2.Mono_parameters_inlier_threshold_get
    if _newclass:
        inlier_threshold = _swig_property(_viso2.Mono_parameters_inlier_threshold_get, _viso2.Mono_parameters_inlier_threshold_set)
    __swig_setmethods__["motion_threshold"] = _viso2.Mono_parameters_motion_threshold_set
    __swig_getmethods__["motion_threshold"] = _viso2.Mono_parameters_motion_threshold_get
    if _newclass:
        motion_threshold = _swig_property(_viso2.Mono_parameters_motion_threshold_get, _viso2.Mono_parameters_motion_threshold_set)

    def __init__(self):
        """__init__(self) -> Mono_parameters"""
        this = _viso2.new_Mono_parameters()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _viso2.delete_Mono_parameters
    __del__ = lambda self: None
Mono_parameters_swigregister = _viso2.Mono_parameters_swigregister
Mono_parameters_swigregister(Mono_parameters)

class VisualOdometryStereo(VisualOdometry):
    """Proxy of C++ VisualOdometryStereo class."""

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

    def __init__(self, param):
        """__init__(self, param) -> VisualOdometryStereo"""
        this = _viso2.new_VisualOdometryStereo(param)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _viso2.delete_VisualOdometryStereo
    __del__ = lambda self: None

    def process(self, *args):
        """
        process(self, I1, I2, dims, replace=False) -> bool
        process(self, I1, I2, dims) -> bool
        process(self, p_matched_) -> bool
        """
        return _viso2.VisualOdometryStereo_process(self, *args)


    def process_frame(self, image1, image2, replace=False):
        """
        process_frame(self, image1, image2, replace=False) -> bool
        process_frame(self, image1, image2) -> bool
        """
        return _viso2.VisualOdometryStereo_process_frame(self, image1, image2, replace)

VisualOdometryStereo_swigregister = _viso2.VisualOdometryStereo_swigregister
VisualOdometryStereo_swigregister(VisualOdometryStereo)

class Stereo_parameters(VO_parameters):
    """Proxy of C++ VisualOdometryStereo::parameters class."""

    __swig_setmethods__ = {}
    for _s in [VO_parameters]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Stereo_parameters, name, value)
    __swig_getmethods__ = {}
    for _s in [VO_parameters]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Stereo_parameters, name)
    __repr__ = _swig_repr
    __swig_setmethods__["base"] = _viso2.Stereo_parameters_base_set
    __swig_getmethods__["base"] = _viso2.Stereo_parameters_base_get
    if _newclass:
        base = _swig_property(_viso2.Stereo_parameters_base_get, _viso2.Stereo_parameters_base_set)
    __swig_setmethods__["ransac_iters"] = _viso2.Stereo_parameters_ransac_iters_set
    __swig_getmethods__["ransac_iters"] = _viso2.Stereo_parameters_ransac_iters_get
    if _newclass:
        ransac_iters = _swig_property(_viso2.Stereo_parameters_ransac_iters_get, _viso2.Stereo_parameters_ransac_iters_set)
    __swig_setmethods__["inlier_threshold"] = _viso2.Stereo_parameters_inlier_threshold_set
    __swig_getmethods__["inlier_threshold"] = _viso2.Stereo_parameters_inlier_threshold_get
    if _newclass:
        inlier_threshold = _swig_property(_viso2.Stereo_parameters_inlier_threshold_get, _viso2.Stereo_parameters_inlier_threshold_set)
    __swig_setmethods__["reweighting"] = _viso2.Stereo_parameters_reweighting_set
    __swig_getmethods__["reweighting"] = _viso2.Stereo_parameters_reweighting_get
    if _newclass:
        reweighting = _swig_property(_viso2.Stereo_parameters_reweighting_get, _viso2.Stereo_parameters_reweighting_set)

    def __init__(self):
        """__init__(self) -> Stereo_parameters"""
        this = _viso2.new_Stereo_parameters()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _viso2.delete_Stereo_parameters
    __del__ = lambda self: None
Stereo_parameters_swigregister = _viso2.Stereo_parameters_swigregister
Stereo_parameters_swigregister(Stereo_parameters)

class Matrix(_object):
    """Proxy of C++ Matrix class."""

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

    def __init__(self, *args):
        """
        __init__(self) -> Matrix
        __init__(self, m, n) -> Matrix
        __init__(self, m, n, val_) -> Matrix
        __init__(self, M) -> Matrix
        """
        this = _viso2.new_Matrix(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _viso2.delete_Matrix
    __del__ = lambda self: None

    def assign(self, M):
        """assign(self, M) -> Matrix"""
        return _viso2.Matrix_assign(self, M)


    def getData(self, val_, i1=0, j1=0, i2=-1, j2=-1):
        """
        getData(self, val_, i1=0, j1=0, i2=-1, j2=-1)
        getData(self, val_, i1=0, j1=0, i2=-1)
        getData(self, val_, i1=0, j1=0)
        getData(self, val_, i1=0)
        getData(self, val_)
        """
        return _viso2.Matrix_getData(self, val_, i1, j1, i2, j2)


    def getMat(self, i1, j1, i2=-1, j2=-1):
        """
        getMat(self, i1, j1, i2=-1, j2=-1) -> Matrix
        getMat(self, i1, j1, i2=-1) -> Matrix
        getMat(self, i1, j1) -> Matrix
        """
        return _viso2.Matrix_getMat(self, i1, j1, i2, j2)


    def setMat(self, M, i, j):
        """setMat(self, M, i, j)"""
        return _viso2.Matrix_setMat(self, M, i, j)


    def setVal(self, s, i1=0, j1=0, i2=-1, j2=-1):
        """
        setVal(self, s, i1=0, j1=0, i2=-1, j2=-1)
        setVal(self, s, i1=0, j1=0, i2=-1)
        setVal(self, s, i1=0, j1=0)
        setVal(self, s, i1=0)
        setVal(self, s)
        """
        return _viso2.Matrix_setVal(self, s, i1, j1, i2, j2)


    def setDiag(self, s, i1=0, i2=-1):
        """
        setDiag(self, s, i1=0, i2=-1)
        setDiag(self, s, i1=0)
        setDiag(self, s)
        """
        return _viso2.Matrix_setDiag(self, s, i1, i2)


    def zero(self):
        """zero(self)"""
        return _viso2.Matrix_zero(self)


    def extractCols(self, idx):
        """extractCols(self, idx) -> Matrix"""
        return _viso2.Matrix_extractCols(self, idx)


    def eye(m):
        """eye(m) -> Matrix"""
        return _viso2.Matrix_eye(m)

    eye = staticmethod(eye)

    def identity(self):
        """identity(self)"""
        return _viso2.Matrix_identity(self)


    def diag(M):
        """diag(M) -> Matrix"""
        return _viso2.Matrix_diag(M)

    diag = staticmethod(diag)

    def reshape(M, m, n):
        """reshape(M, m, n) -> Matrix"""
        return _viso2.Matrix_reshape(M, m, n)

    reshape = staticmethod(reshape)

    def rotMatX(angle):
        """rotMatX(angle) -> Matrix"""
        return _viso2.Matrix_rotMatX(angle)

    rotMatX = staticmethod(rotMatX)

    def rotMatY(angle):
        """rotMatY(angle) -> Matrix"""
        return _viso2.Matrix_rotMatY(angle)

    rotMatY = staticmethod(rotMatY)

    def rotMatZ(angle):
        """rotMatZ(angle) -> Matrix"""
        return _viso2.Matrix_rotMatZ(angle)

    rotMatZ = staticmethod(rotMatZ)

    def __add__(self, M):
        """__add__(self, M) -> Matrix"""
        return _viso2.Matrix___add__(self, M)


    def __sub__(self, M):
        """__sub__(self, M) -> Matrix"""
        return _viso2.Matrix___sub__(self, M)


    def __mul__(self, *args):
        """
        __mul__(self, M) -> Matrix
        __mul__(self, s) -> Matrix
        """
        return _viso2.Matrix___mul__(self, *args)


    def __truediv__(self, *args):
        return _viso2.Matrix___truediv__(self, *args)
    __div__ = __truediv__



    def __neg__(self):
        """__neg__(self) -> Matrix"""
        return _viso2.Matrix___neg__(self)


    def __invert__(self):
        """__invert__(self) -> Matrix"""
        return _viso2.Matrix___invert__(self)


    def l2norm(self):
        """l2norm(self) -> FLOAT"""
        return _viso2.Matrix_l2norm(self)


    def mean(self):
        """mean(self) -> FLOAT"""
        return _viso2.Matrix_mean(self)


    def cross(a, b):
        """cross(a, b) -> Matrix"""
        return _viso2.Matrix_cross(a, b)

    cross = staticmethod(cross)

    def inv(M):
        """inv(M) -> Matrix"""
        return _viso2.Matrix_inv(M)

    inv = staticmethod(inv)

    def setInverse(self):
        """setInverse(self) -> bool"""
        return _viso2.Matrix_setInverse(self)


    def det(self):
        """det(self) -> FLOAT"""
        return _viso2.Matrix_det(self)


    def solve(self, M, eps=1e-20):
        """
        solve(self, M, eps=1e-20) -> bool
        solve(self, M) -> bool
        """
        return _viso2.Matrix_solve(self, M, eps)


    def lu(self, idx, d, eps=1e-20):
        """
        lu(self, idx, d, eps=1e-20) -> bool
        lu(self, idx, d) -> bool
        """
        return _viso2.Matrix_lu(self, idx, d, eps)


    def svd(self, U, W, V):
        """svd(self, U, W, V)"""
        return _viso2.Matrix_svd(self, U, W, V)

    __swig_setmethods__["val"] = _viso2.Matrix_val_set
    __swig_getmethods__["val"] = _viso2.Matrix_val_get
    if _newclass:
        val = _swig_property(_viso2.Matrix_val_get, _viso2.Matrix_val_set)
    __swig_setmethods__["m"] = _viso2.Matrix_m_set
    __swig_getmethods__["m"] = _viso2.Matrix_m_get
    if _newclass:
        m = _swig_property(_viso2.Matrix_m_get, _viso2.Matrix_m_set)
    __swig_setmethods__["n"] = _viso2.Matrix_n_set
    __swig_getmethods__["n"] = _viso2.Matrix_n_get
    if _newclass:
        n = _swig_property(_viso2.Matrix_n_get, _viso2.Matrix_n_set)

    def __str__(self):
        """__str__(self) -> std::string"""
        return _viso2.Matrix___str__(self)


    def toNumpy(self, mat):
        """toNumpy(self, mat)"""
        return _viso2.Matrix_toNumpy(self, mat)

Matrix_swigregister = _viso2.Matrix_swigregister
Matrix_swigregister(Matrix)

def Matrix_eye(m):
    """Matrix_eye(m) -> Matrix"""
    return _viso2.Matrix_eye(m)

def Matrix_diag(M):
    """Matrix_diag(M) -> Matrix"""
    return _viso2.Matrix_diag(M)

def Matrix_reshape(M, m, n):
    """Matrix_reshape(M, m, n) -> Matrix"""
    return _viso2.Matrix_reshape(M, m, n)

def Matrix_rotMatX(angle):
    """Matrix_rotMatX(angle) -> Matrix"""
    return _viso2.Matrix_rotMatX(angle)

def Matrix_rotMatY(angle):
    """Matrix_rotMatY(angle) -> Matrix"""
    return _viso2.Matrix_rotMatY(angle)

def Matrix_rotMatZ(angle):
    """Matrix_rotMatZ(angle) -> Matrix"""
    return _viso2.Matrix_rotMatZ(angle)

def Matrix_cross(a, b):
    """Matrix_cross(a, b) -> Matrix"""
    return _viso2.Matrix_cross(a, b)

def Matrix_inv(M):
    """Matrix_inv(M) -> Matrix"""
    return _viso2.Matrix_inv(M)

class Matcher(_object):
    """Proxy of C++ Matcher class."""

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

    def __init__(self, param):
        """__init__(self, param) -> Matcher"""
        this = _viso2.new_Matcher(param)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _viso2.delete_Matcher
    __del__ = lambda self: None

    def setIntrinsics(self, f, cu, cv, base):
        """setIntrinsics(self, f, cu, cv, base)"""
        return _viso2.Matcher_setIntrinsics(self, f, cu, cv, base)


    def matchFeatures(self, method, Tr_delta=None):
        """
        matchFeatures(self, method, Tr_delta=None)
        matchFeatures(self, method)
        """
        return _viso2.Matcher_matchFeatures(self, method, Tr_delta)


    def bucketFeatures(self, max_features, bucket_width, bucket_height):
        """bucketFeatures(self, max_features, bucket_width, bucket_height)"""
        return _viso2.Matcher_bucketFeatures(self, max_features, bucket_width, bucket_height)


    def getMatches(self):
        """getMatches(self) -> MatchVector"""
        return _viso2.Matcher_getMatches(self)


    def getGain(self, inliers):
        """getGain(self, inliers) -> float"""
        return _viso2.Matcher_getGain(self, inliers)


    def pushBack(self, *args):
        """
        pushBack(self, I1, I2, dims, replace)
        pushBack(self, I1, dims, replace)
        pushBack(self, image1, image2, replace=False)
        pushBack(self, image1, image2)
        pushBack(self, image1, replace=False)
        pushBack(self, image1)
        """
        return _viso2.Matcher_pushBack(self, *args)

Matcher_swigregister = _viso2.Matcher_swigregister
Matcher_swigregister(Matcher)

class Matcher_parameters(_object):
    """Proxy of C++ Matcher::parameters class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Matcher_parameters, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Matcher_parameters, name)
    __repr__ = _swig_repr
    __swig_setmethods__["nms_n"] = _viso2.Matcher_parameters_nms_n_set
    __swig_getmethods__["nms_n"] = _viso2.Matcher_parameters_nms_n_get
    if _newclass:
        nms_n = _swig_property(_viso2.Matcher_parameters_nms_n_get, _viso2.Matcher_parameters_nms_n_set)
    __swig_setmethods__["nms_tau"] = _viso2.Matcher_parameters_nms_tau_set
    __swig_getmethods__["nms_tau"] = _viso2.Matcher_parameters_nms_tau_get
    if _newclass:
        nms_tau = _swig_property(_viso2.Matcher_parameters_nms_tau_get, _viso2.Matcher_parameters_nms_tau_set)
    __swig_setmethods__["match_binsize"] = _viso2.Matcher_parameters_match_binsize_set
    __swig_getmethods__["match_binsize"] = _viso2.Matcher_parameters_match_binsize_get
    if _newclass:
        match_binsize = _swig_property(_viso2.Matcher_parameters_match_binsize_get, _viso2.Matcher_parameters_match_binsize_set)
    __swig_setmethods__["match_radius"] = _viso2.Matcher_parameters_match_radius_set
    __swig_getmethods__["match_radius"] = _viso2.Matcher_parameters_match_radius_get
    if _newclass:
        match_radius = _swig_property(_viso2.Matcher_parameters_match_radius_get, _viso2.Matcher_parameters_match_radius_set)
    __swig_setmethods__["match_disp_tolerance"] = _viso2.Matcher_parameters_match_disp_tolerance_set
    __swig_getmethods__["match_disp_tolerance"] = _viso2.Matcher_parameters_match_disp_tolerance_get
    if _newclass:
        match_disp_tolerance = _swig_property(_viso2.Matcher_parameters_match_disp_tolerance_get, _viso2.Matcher_parameters_match_disp_tolerance_set)
    __swig_setmethods__["outlier_disp_tolerance"] = _viso2.Matcher_parameters_outlier_disp_tolerance_set
    __swig_getmethods__["outlier_disp_tolerance"] = _viso2.Matcher_parameters_outlier_disp_tolerance_get
    if _newclass:
        outlier_disp_tolerance = _swig_property(_viso2.Matcher_parameters_outlier_disp_tolerance_get, _viso2.Matcher_parameters_outlier_disp_tolerance_set)
    __swig_setmethods__["outlier_flow_tolerance"] = _viso2.Matcher_parameters_outlier_flow_tolerance_set
    __swig_getmethods__["outlier_flow_tolerance"] = _viso2.Matcher_parameters_outlier_flow_tolerance_get
    if _newclass:
        outlier_flow_tolerance = _swig_property(_viso2.Matcher_parameters_outlier_flow_tolerance_get, _viso2.Matcher_parameters_outlier_flow_tolerance_set)
    __swig_setmethods__["multi_stage"] = _viso2.Matcher_parameters_multi_stage_set
    __swig_getmethods__["multi_stage"] = _viso2.Matcher_parameters_multi_stage_get
    if _newclass:
        multi_stage = _swig_property(_viso2.Matcher_parameters_multi_stage_get, _viso2.Matcher_parameters_multi_stage_set)
    __swig_setmethods__["half_resolution"] = _viso2.Matcher_parameters_half_resolution_set
    __swig_getmethods__["half_resolution"] = _viso2.Matcher_parameters_half_resolution_get
    if _newclass:
        half_resolution = _swig_property(_viso2.Matcher_parameters_half_resolution_get, _viso2.Matcher_parameters_half_resolution_set)
    __swig_setmethods__["refinement"] = _viso2.Matcher_parameters_refinement_set
    __swig_getmethods__["refinement"] = _viso2.Matcher_parameters_refinement_get
    if _newclass:
        refinement = _swig_property(_viso2.Matcher_parameters_refinement_get, _viso2.Matcher_parameters_refinement_set)
    __swig_setmethods__["f"] = _viso2.Matcher_parameters_f_set
    __swig_getmethods__["f"] = _viso2.Matcher_parameters_f_get
    if _newclass:
        f = _swig_property(_viso2.Matcher_parameters_f_get, _viso2.Matcher_parameters_f_set)
    __swig_setmethods__["cu"] = _viso2.Matcher_parameters_cu_set
    __swig_getmethods__["cu"] = _viso2.Matcher_parameters_cu_get
    if _newclass:
        cu = _swig_property(_viso2.Matcher_parameters_cu_get, _viso2.Matcher_parameters_cu_set)
    __swig_setmethods__["cv"] = _viso2.Matcher_parameters_cv_set
    __swig_getmethods__["cv"] = _viso2.Matcher_parameters_cv_get
    if _newclass:
        cv = _swig_property(_viso2.Matcher_parameters_cv_get, _viso2.Matcher_parameters_cv_set)
    __swig_setmethods__["base"] = _viso2.Matcher_parameters_base_set
    __swig_getmethods__["base"] = _viso2.Matcher_parameters_base_get
    if _newclass:
        base = _swig_property(_viso2.Matcher_parameters_base_get, _viso2.Matcher_parameters_base_set)

    def __init__(self):
        """__init__(self) -> Matcher_parameters"""
        this = _viso2.new_Matcher_parameters()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _viso2.delete_Matcher_parameters
    __del__ = lambda self: None
Matcher_parameters_swigregister = _viso2.Matcher_parameters_swigregister
Matcher_parameters_swigregister(Matcher_parameters)

class p_match(_object):
    """Proxy of C++ Matcher::p_match class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, p_match, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, p_match, name)
    __repr__ = _swig_repr
    __swig_setmethods__["u1p"] = _viso2.p_match_u1p_set
    __swig_getmethods__["u1p"] = _viso2.p_match_u1p_get
    if _newclass:
        u1p = _swig_property(_viso2.p_match_u1p_get, _viso2.p_match_u1p_set)
    __swig_setmethods__["v1p"] = _viso2.p_match_v1p_set
    __swig_getmethods__["v1p"] = _viso2.p_match_v1p_get
    if _newclass:
        v1p = _swig_property(_viso2.p_match_v1p_get, _viso2.p_match_v1p_set)
    __swig_setmethods__["i1p"] = _viso2.p_match_i1p_set
    __swig_getmethods__["i1p"] = _viso2.p_match_i1p_get
    if _newclass:
        i1p = _swig_property(_viso2.p_match_i1p_get, _viso2.p_match_i1p_set)
    __swig_setmethods__["u2p"] = _viso2.p_match_u2p_set
    __swig_getmethods__["u2p"] = _viso2.p_match_u2p_get
    if _newclass:
        u2p = _swig_property(_viso2.p_match_u2p_get, _viso2.p_match_u2p_set)
    __swig_setmethods__["v2p"] = _viso2.p_match_v2p_set
    __swig_getmethods__["v2p"] = _viso2.p_match_v2p_get
    if _newclass:
        v2p = _swig_property(_viso2.p_match_v2p_get, _viso2.p_match_v2p_set)
    __swig_setmethods__["i2p"] = _viso2.p_match_i2p_set
    __swig_getmethods__["i2p"] = _viso2.p_match_i2p_get
    if _newclass:
        i2p = _swig_property(_viso2.p_match_i2p_get, _viso2.p_match_i2p_set)
    __swig_setmethods__["u1c"] = _viso2.p_match_u1c_set
    __swig_getmethods__["u1c"] = _viso2.p_match_u1c_get
    if _newclass:
        u1c = _swig_property(_viso2.p_match_u1c_get, _viso2.p_match_u1c_set)
    __swig_setmethods__["v1c"] = _viso2.p_match_v1c_set
    __swig_getmethods__["v1c"] = _viso2.p_match_v1c_get
    if _newclass:
        v1c = _swig_property(_viso2.p_match_v1c_get, _viso2.p_match_v1c_set)
    __swig_setmethods__["i1c"] = _viso2.p_match_i1c_set
    __swig_getmethods__["i1c"] = _viso2.p_match_i1c_get
    if _newclass:
        i1c = _swig_property(_viso2.p_match_i1c_get, _viso2.p_match_i1c_set)
    __swig_setmethods__["u2c"] = _viso2.p_match_u2c_set
    __swig_getmethods__["u2c"] = _viso2.p_match_u2c_get
    if _newclass:
        u2c = _swig_property(_viso2.p_match_u2c_get, _viso2.p_match_u2c_set)
    __swig_setmethods__["v2c"] = _viso2.p_match_v2c_set
    __swig_getmethods__["v2c"] = _viso2.p_match_v2c_get
    if _newclass:
        v2c = _swig_property(_viso2.p_match_v2c_get, _viso2.p_match_v2c_set)
    __swig_setmethods__["i2c"] = _viso2.p_match_i2c_set
    __swig_getmethods__["i2c"] = _viso2.p_match_i2c_get
    if _newclass:
        i2c = _swig_property(_viso2.p_match_i2c_get, _viso2.p_match_i2c_set)

    def __init__(self, *args):
        """
        __init__(self) -> p_match
        __init__(self, u1p, v1p, i1p, u2p, v2p, i2p, u1c, v1c, i1c, u2c, v2c, i2c) -> p_match
        """
        this = _viso2.new_p_match(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _viso2.delete_p_match
    __del__ = lambda self: None
p_match_swigregister = _viso2.p_match_swigregister
p_match_swigregister(p_match)

class Reconstruction(_object):
    """Proxy of C++ Reconstruction class."""

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

    def __init__(self):
        """__init__(self) -> Reconstruction"""
        this = _viso2.new_Reconstruction()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _viso2.delete_Reconstruction
    __del__ = lambda self: None

    def setCalibration(self, f, cu, cv):
        """setCalibration(self, f, cu, cv)"""
        return _viso2.Reconstruction_setCalibration(self, f, cu, cv)


    def update(self, p_matched, Tr, point_type=1, min_track_length=2, max_dist=30, min_angle=2):
        """
        update(self, p_matched, Tr, point_type=1, min_track_length=2, max_dist=30, min_angle=2)
        update(self, p_matched, Tr, point_type=1, min_track_length=2, max_dist=30)
        update(self, p_matched, Tr, point_type=1, min_track_length=2)
        update(self, p_matched, Tr, point_type=1)
        update(self, p_matched, Tr)
        """
        return _viso2.Reconstruction_update(self, p_matched, Tr, point_type, min_track_length, max_dist, min_angle)


    def getPoints(self):
        """getPoints(self) -> Point3dVector"""
        return _viso2.Reconstruction_getPoints(self)


    def getTracks(self):
        """getTracks(self) -> TrackVector"""
        return _viso2.Reconstruction_getTracks(self)

Reconstruction_swigregister = _viso2.Reconstruction_swigregister
Reconstruction_swigregister(Reconstruction)

class point3d(_object):
    """Proxy of C++ Reconstruction::point3d class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, point3d, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, point3d, name)
    __repr__ = _swig_repr
    __swig_setmethods__["x"] = _viso2.point3d_x_set
    __swig_getmethods__["x"] = _viso2.point3d_x_get
    if _newclass:
        x = _swig_property(_viso2.point3d_x_get, _viso2.point3d_x_set)
    __swig_setmethods__["y"] = _viso2.point3d_y_set
    __swig_getmethods__["y"] = _viso2.point3d_y_get
    if _newclass:
        y = _swig_property(_viso2.point3d_y_get, _viso2.point3d_y_set)
    __swig_setmethods__["z"] = _viso2.point3d_z_set
    __swig_getmethods__["z"] = _viso2.point3d_z_get
    if _newclass:
        z = _swig_property(_viso2.point3d_z_get, _viso2.point3d_z_set)

    def __init__(self, *args):
        """
        __init__(self) -> point3d
        __init__(self, x, y, z) -> point3d
        """
        this = _viso2.new_point3d(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _viso2.delete_point3d
    __del__ = lambda self: None
point3d_swigregister = _viso2.point3d_swigregister
point3d_swigregister(point3d)

class point2d(_object):
    """Proxy of C++ Reconstruction::point2d class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, point2d, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, point2d, name)
    __repr__ = _swig_repr
    __swig_setmethods__["u"] = _viso2.point2d_u_set
    __swig_getmethods__["u"] = _viso2.point2d_u_get
    if _newclass:
        u = _swig_property(_viso2.point2d_u_get, _viso2.point2d_u_set)
    __swig_setmethods__["v"] = _viso2.point2d_v_set
    __swig_getmethods__["v"] = _viso2.point2d_v_get
    if _newclass:
        v = _swig_property(_viso2.point2d_v_get, _viso2.point2d_v_set)

    def __init__(self, *args):
        """
        __init__(self) -> point2d
        __init__(self, u, v) -> point2d
        """
        this = _viso2.new_point2d(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _viso2.delete_point2d
    __del__ = lambda self: None
point2d_swigregister = _viso2.point2d_swigregister
point2d_swigregister(point2d)

class track(_object):
    """Proxy of C++ Reconstruction::track class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, track, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, track, name)
    __repr__ = _swig_repr
    __swig_setmethods__["pixels"] = _viso2.track_pixels_set
    __swig_getmethods__["pixels"] = _viso2.track_pixels_get
    if _newclass:
        pixels = _swig_property(_viso2.track_pixels_get, _viso2.track_pixels_set)
    __swig_setmethods__["pt"] = _viso2.track_pt_set
    __swig_getmethods__["pt"] = _viso2.track_pt_get
    if _newclass:
        pt = _swig_property(_viso2.track_pt_get, _viso2.track_pt_set)
    __swig_setmethods__["valid"] = _viso2.track_valid_set
    __swig_getmethods__["valid"] = _viso2.track_valid_get
    if _newclass:
        valid = _swig_property(_viso2.track_valid_get, _viso2.track_valid_set)
    __swig_setmethods__["first_frame"] = _viso2.track_first_frame_set
    __swig_getmethods__["first_frame"] = _viso2.track_first_frame_get
    if _newclass:
        first_frame = _swig_property(_viso2.track_first_frame_get, _viso2.track_first_frame_set)
    __swig_setmethods__["last_frame"] = _viso2.track_last_frame_set
    __swig_getmethods__["last_frame"] = _viso2.track_last_frame_get
    if _newclass:
        last_frame = _swig_property(_viso2.track_last_frame_get, _viso2.track_last_frame_set)
    __swig_setmethods__["last_idx"] = _viso2.track_last_idx_set
    __swig_getmethods__["last_idx"] = _viso2.track_last_idx_get
    if _newclass:
        last_idx = _swig_property(_viso2.track_last_idx_get, _viso2.track_last_idx_set)

    def __init__(self):
        """__init__(self) -> track"""
        this = _viso2.new_track()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _viso2.delete_track
    __del__ = lambda self: None
track_swigregister = _viso2.track_swigregister
track_swigregister(track)

class MatchVector(_object):
    """Proxy of C++ std::vector<(Matcher::p_match)> class."""

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

    def iterator(self):
        """iterator(self) -> SwigPyIterator"""
        return _viso2.MatchVector_iterator(self)

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

    def __nonzero__(self):
        """__nonzero__(self) -> bool"""
        return _viso2.MatchVector___nonzero__(self)


    def __bool__(self):
        """__bool__(self) -> bool"""
        return _viso2.MatchVector___bool__(self)


    def __len__(self):
        """__len__(self) -> std::vector< Matcher::p_match >::size_type"""
        return _viso2.MatchVector___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(self, i, j) -> MatchVector"""
        return _viso2.MatchVector___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(self, i, j)
        __setslice__(self, i, j, v)
        """
        return _viso2.MatchVector___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(self, i, j)"""
        return _viso2.MatchVector___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(self, i)
        __delitem__(self, slice)
        """
        return _viso2.MatchVector___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(self, slice) -> MatchVector
        __getitem__(self, i) -> p_match
        """
        return _viso2.MatchVector___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(self, slice, v)
        __setitem__(self, slice)
        __setitem__(self, i, x)
        """
        return _viso2.MatchVector___setitem__(self, *args)


    def pop(self):
        """pop(self) -> p_match"""
        return _viso2.MatchVector_pop(self)


    def append(self, x):
        """append(self, x)"""
        return _viso2.MatchVector_append(self, x)


    def empty(self):
        """empty(self) -> bool"""
        return _viso2.MatchVector_empty(self)


    def size(self):
        """size(self) -> std::vector< Matcher::p_match >::size_type"""
        return _viso2.MatchVector_size(self)


    def swap(self, v):
        """swap(self, v)"""
        return _viso2.MatchVector_swap(self, v)


    def begin(self):
        """begin(self) -> std::vector< Matcher::p_match >::iterator"""
        return _viso2.MatchVector_begin(self)


    def end(self):
        """end(self) -> std::vector< Matcher::p_match >::iterator"""
        return _viso2.MatchVector_end(self)


    def rbegin(self):
        """rbegin(self) -> std::vector< Matcher::p_match >::reverse_iterator"""
        return _viso2.MatchVector_rbegin(self)


    def rend(self):
        """rend(self) -> std::vector< Matcher::p_match >::reverse_iterator"""
        return _viso2.MatchVector_rend(self)


    def clear(self):
        """clear(self)"""
        return _viso2.MatchVector_clear(self)


    def get_allocator(self):
        """get_allocator(self) -> std::vector< Matcher::p_match >::allocator_type"""
        return _viso2.MatchVector_get_allocator(self)


    def pop_back(self):
        """pop_back(self)"""
        return _viso2.MatchVector_pop_back(self)


    def erase(self, *args):
        """
        erase(self, pos) -> std::vector< Matcher::p_match >::iterator
        erase(self, first, last) -> std::vector< Matcher::p_match >::iterator
        """
        return _viso2.MatchVector_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(self) -> MatchVector
        __init__(self, arg2) -> MatchVector
        __init__(self, size) -> MatchVector
        __init__(self, size, value) -> MatchVector
        """
        this = _viso2.new_MatchVector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        """push_back(self, x)"""
        return _viso2.MatchVector_push_back(self, x)


    def front(self):
        """front(self) -> p_match"""
        return _viso2.MatchVector_front(self)


    def back(self):
        """back(self) -> p_match"""
        return _viso2.MatchVector_back(self)


    def assign(self, n, x):
        """assign(self, n, x)"""
        return _viso2.MatchVector_assign(self, n, x)


    def resize(self, *args):
        """
        resize(self, new_size)
        resize(self, new_size, x)
        """
        return _viso2.MatchVector_resize(self, *args)


    def insert(self, *args):
        """
        insert(self, pos, x) -> std::vector< Matcher::p_match >::iterator
        insert(self, pos, n, x)
        """
        return _viso2.MatchVector_insert(self, *args)


    def reserve(self, n):
        """reserve(self, n)"""
        return _viso2.MatchVector_reserve(self, n)


    def capacity(self):
        """capacity(self) -> std::vector< Matcher::p_match >::size_type"""
        return _viso2.MatchVector_capacity(self)

    __swig_destroy__ = _viso2.delete_MatchVector
    __del__ = lambda self: None
MatchVector_swigregister = _viso2.MatchVector_swigregister
MatchVector_swigregister(MatchVector)

class Point3dVector(_object):
    """Proxy of C++ std::vector<(Reconstruction::point3d)> class."""

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

    def iterator(self):
        """iterator(self) -> SwigPyIterator"""
        return _viso2.Point3dVector_iterator(self)

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

    def __nonzero__(self):
        """__nonzero__(self) -> bool"""
        return _viso2.Point3dVector___nonzero__(self)


    def __bool__(self):
        """__bool__(self) -> bool"""
        return _viso2.Point3dVector___bool__(self)


    def __len__(self):
        """__len__(self) -> std::vector< Reconstruction::point3d >::size_type"""
        return _viso2.Point3dVector___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(self, i, j) -> Point3dVector"""
        return _viso2.Point3dVector___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(self, i, j)
        __setslice__(self, i, j, v)
        """
        return _viso2.Point3dVector___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(self, i, j)"""
        return _viso2.Point3dVector___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(self, i)
        __delitem__(self, slice)
        """
        return _viso2.Point3dVector___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(self, slice) -> Point3dVector
        __getitem__(self, i) -> point3d
        """
        return _viso2.Point3dVector___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(self, slice, v)
        __setitem__(self, slice)
        __setitem__(self, i, x)
        """
        return _viso2.Point3dVector___setitem__(self, *args)


    def pop(self):
        """pop(self) -> point3d"""
        return _viso2.Point3dVector_pop(self)


    def append(self, x):
        """append(self, x)"""
        return _viso2.Point3dVector_append(self, x)


    def empty(self):
        """empty(self) -> bool"""
        return _viso2.Point3dVector_empty(self)


    def size(self):
        """size(self) -> std::vector< Reconstruction::point3d >::size_type"""
        return _viso2.Point3dVector_size(self)


    def swap(self, v):
        """swap(self, v)"""
        return _viso2.Point3dVector_swap(self, v)


    def begin(self):
        """begin(self) -> std::vector< Reconstruction::point3d >::iterator"""
        return _viso2.Point3dVector_begin(self)


    def end(self):
        """end(self) -> std::vector< Reconstruction::point3d >::iterator"""
        return _viso2.Point3dVector_end(self)


    def rbegin(self):
        """rbegin(self) -> std::vector< Reconstruction::point3d >::reverse_iterator"""
        return _viso2.Point3dVector_rbegin(self)


    def rend(self):
        """rend(self) -> std::vector< Reconstruction::point3d >::reverse_iterator"""
        return _viso2.Point3dVector_rend(self)


    def clear(self):
        """clear(self)"""
        return _viso2.Point3dVector_clear(self)


    def get_allocator(self):
        """get_allocator(self) -> std::vector< Reconstruction::point3d >::allocator_type"""
        return _viso2.Point3dVector_get_allocator(self)


    def pop_back(self):
        """pop_back(self)"""
        return _viso2.Point3dVector_pop_back(self)


    def erase(self, *args):
        """
        erase(self, pos) -> std::vector< Reconstruction::point3d >::iterator
        erase(self, first, last) -> std::vector< Reconstruction::point3d >::iterator
        """
        return _viso2.Point3dVector_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(self) -> Point3dVector
        __init__(self, arg2) -> Point3dVector
        __init__(self, size) -> Point3dVector
        __init__(self, size, value) -> Point3dVector
        """
        this = _viso2.new_Point3dVector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        """push_back(self, x)"""
        return _viso2.Point3dVector_push_back(self, x)


    def front(self):
        """front(self) -> point3d"""
        return _viso2.Point3dVector_front(self)


    def back(self):
        """back(self) -> point3d"""
        return _viso2.Point3dVector_back(self)


    def assign(self, n, x):
        """assign(self, n, x)"""
        return _viso2.Point3dVector_assign(self, n, x)


    def resize(self, *args):
        """
        resize(self, new_size)
        resize(self, new_size, x)
        """
        return _viso2.Point3dVector_resize(self, *args)


    def insert(self, *args):
        """
        insert(self, pos, x) -> std::vector< Reconstruction::point3d >::iterator
        insert(self, pos, n, x)
        """
        return _viso2.Point3dVector_insert(self, *args)


    def reserve(self, n):
        """reserve(self, n)"""
        return _viso2.Point3dVector_reserve(self, n)


    def capacity(self):
        """capacity(self) -> std::vector< Reconstruction::point3d >::size_type"""
        return _viso2.Point3dVector_capacity(self)

    __swig_destroy__ = _viso2.delete_Point3dVector
    __del__ = lambda self: None
Point3dVector_swigregister = _viso2.Point3dVector_swigregister
Point3dVector_swigregister(Point3dVector)

class TrackVector(_object):
    """Proxy of C++ std::vector<(Reconstruction::track)> class."""

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

    def iterator(self):
        """iterator(self) -> SwigPyIterator"""
        return _viso2.TrackVector_iterator(self)

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

    def __nonzero__(self):
        """__nonzero__(self) -> bool"""
        return _viso2.TrackVector___nonzero__(self)


    def __bool__(self):
        """__bool__(self) -> bool"""
        return _viso2.TrackVector___bool__(self)


    def __len__(self):
        """__len__(self) -> std::vector< Reconstruction::track >::size_type"""
        return _viso2.TrackVector___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(self, i, j) -> TrackVector"""
        return _viso2.TrackVector___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(self, i, j)
        __setslice__(self, i, j, v)
        """
        return _viso2.TrackVector___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(self, i, j)"""
        return _viso2.TrackVector___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(self, i)
        __delitem__(self, slice)
        """
        return _viso2.TrackVector___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(self, slice) -> TrackVector
        __getitem__(self, i) -> track
        """
        return _viso2.TrackVector___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(self, slice, v)
        __setitem__(self, slice)
        __setitem__(self, i, x)
        """
        return _viso2.TrackVector___setitem__(self, *args)


    def pop(self):
        """pop(self) -> track"""
        return _viso2.TrackVector_pop(self)


    def append(self, x):
        """append(self, x)"""
        return _viso2.TrackVector_append(self, x)


    def empty(self):
        """empty(self) -> bool"""
        return _viso2.TrackVector_empty(self)


    def size(self):
        """size(self) -> std::vector< Reconstruction::track >::size_type"""
        return _viso2.TrackVector_size(self)


    def swap(self, v):
        """swap(self, v)"""
        return _viso2.TrackVector_swap(self, v)


    def begin(self):
        """begin(self) -> std::vector< Reconstruction::track >::iterator"""
        return _viso2.TrackVector_begin(self)


    def end(self):
        """end(self) -> std::vector< Reconstruction::track >::iterator"""
        return _viso2.TrackVector_end(self)


    def rbegin(self):
        """rbegin(self) -> std::vector< Reconstruction::track >::reverse_iterator"""
        return _viso2.TrackVector_rbegin(self)


    def rend(self):
        """rend(self) -> std::vector< Reconstruction::track >::reverse_iterator"""
        return _viso2.TrackVector_rend(self)


    def clear(self):
        """clear(self)"""
        return _viso2.TrackVector_clear(self)


    def get_allocator(self):
        """get_allocator(self) -> std::vector< Reconstruction::track >::allocator_type"""
        return _viso2.TrackVector_get_allocator(self)


    def pop_back(self):
        """pop_back(self)"""
        return _viso2.TrackVector_pop_back(self)


    def erase(self, *args):
        """
        erase(self, pos) -> std::vector< Reconstruction::track >::iterator
        erase(self, first, last) -> std::vector< Reconstruction::track >::iterator
        """
        return _viso2.TrackVector_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(self) -> TrackVector
        __init__(self, arg2) -> TrackVector
        __init__(self, size) -> TrackVector
        __init__(self, size, value) -> TrackVector
        """
        this = _viso2.new_TrackVector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        """push_back(self, x)"""
        return _viso2.TrackVector_push_back(self, x)


    def front(self):
        """front(self) -> track"""
        return _viso2.TrackVector_front(self)


    def back(self):
        """back(self) -> track"""
        return _viso2.TrackVector_back(self)


    def assign(self, n, x):
        """assign(self, n, x)"""
        return _viso2.TrackVector_assign(self, n, x)


    def resize(self, *args):
        """
        resize(self, new_size)
        resize(self, new_size, x)
        """
        return _viso2.TrackVector_resize(self, *args)


    def insert(self, *args):
        """
        insert(self, pos, x) -> std::vector< Reconstruction::track >::iterator
        insert(self, pos, n, x)
        """
        return _viso2.TrackVector_insert(self, *args)


    def reserve(self, n):
        """reserve(self, n)"""
        return _viso2.TrackVector_reserve(self, n)


    def capacity(self):
        """capacity(self) -> std::vector< Reconstruction::track >::size_type"""
        return _viso2.TrackVector_capacity(self)

    __swig_destroy__ = _viso2.delete_TrackVector
    __del__ = lambda self: None
TrackVector_swigregister = _viso2.TrackVector_swigregister
TrackVector_swigregister(TrackVector)

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



[((14, 19, 14, 49), 'importlib.import_module', 'importlib.import_module', ({(14, 43, 14, 48): 'mname'}, {}), '(mname)', False, 'import importlib\n'), ((16, 19, 16, 52), 'importlib.import_module', 'importlib.import_module', ({(16, 43, 16, 51): '"""_viso2"""'}, {}), "('_viso2')", False, 'import importlib\n'), ((30, 19, 30, 71), 'imp.load_module', 'imp.load_module', ({(30, 35, 30, 43): '"""_viso2"""', (30, 45, 30, 47): 'fp', (30, 49, 30, 57): 'pathname', (30, 59, 30, 70): 'description'}, {}), "('_viso2', fp, pathname, description)", False, 'import imp\n'), ((25, 67, 25, 84), 'os.path.dirname', 'dirname', ({(25, 75, 25, 83): '__file__'}, {}), '(__file__)', False, 'from os.path import dirname\n')]