# 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, '_aruco')).lstrip('.')
        try:
            return importlib.import_module(mname)
        except ImportError:
            return importlib.import_module('_aruco')
    _aruco = 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('_aruco', [dirname(__file__)])
        except ImportError:
            import _aruco
            return _aruco
        try:
            _mod = imp.load_module('_aruco', fp, pathname, description)
        finally:
            if fp is not None:
                fp.close()
        return _mod
    _aruco = swig_import_helper()
    del swig_import_helper
else:
    import _aruco
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

try:
    import weakref
    weakref_proxy = weakref.proxy
except __builtin__.Exception:
    weakref_proxy = lambda x: x


import collections
class SwigPyIterator(_object):
    __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__ = _aruco.delete_SwigPyIterator
    __del__ = lambda self: None

    def value(self):
        return _aruco.SwigPyIterator_value(self)

    def incr(self, n=1):
        return _aruco.SwigPyIterator_incr(self, n)

    def decr(self, n=1):
        return _aruco.SwigPyIterator_decr(self, n)

    def distance(self, x):
        return _aruco.SwigPyIterator_distance(self, x)

    def equal(self, x):
        return _aruco.SwigPyIterator_equal(self, x)

    def copy(self):
        return _aruco.SwigPyIterator_copy(self)

    def next(self):
        return _aruco.SwigPyIterator_next(self)

    def __next__(self):
        return _aruco.SwigPyIterator___next__(self)

    def previous(self):
        return _aruco.SwigPyIterator_previous(self)

    def advance(self, n):
        return _aruco.SwigPyIterator_advance(self, n)

    def __eq__(self, x):
        return _aruco.SwigPyIterator___eq__(self, x)

    def __ne__(self, x):
        return _aruco.SwigPyIterator___ne__(self, x)

    def __iadd__(self, n):
        return _aruco.SwigPyIterator___iadd__(self, n)

    def __isub__(self, n):
        return _aruco.SwigPyIterator___isub__(self, n)

    def __add__(self, n):
        return _aruco.SwigPyIterator___add__(self, n)

    def __sub__(self, *args):
        return _aruco.SwigPyIterator___sub__(self, *args)
    def __iter__(self):
        return self
SwigPyIterator_swigregister = _aruco.SwigPyIterator_swigregister
SwigPyIterator_swigregister(SwigPyIterator)

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

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

    def __nonzero__(self):
        return _aruco.VectorInt___nonzero__(self)

    def __bool__(self):
        return _aruco.VectorInt___bool__(self)

    def __len__(self):
        return _aruco.VectorInt___len__(self)

    def __getslice__(self, i, j):
        return _aruco.VectorInt___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _aruco.VectorInt___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _aruco.VectorInt___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _aruco.VectorInt___delitem__(self, *args)

    def __getitem__(self, *args):
        return _aruco.VectorInt___getitem__(self, *args)

    def __setitem__(self, *args):
        return _aruco.VectorInt___setitem__(self, *args)

    def pop(self):
        return _aruco.VectorInt_pop(self)

    def append(self, x):
        return _aruco.VectorInt_append(self, x)

    def empty(self):
        return _aruco.VectorInt_empty(self)

    def size(self):
        return _aruco.VectorInt_size(self)

    def swap(self, v):
        return _aruco.VectorInt_swap(self, v)

    def begin(self):
        return _aruco.VectorInt_begin(self)

    def end(self):
        return _aruco.VectorInt_end(self)

    def rbegin(self):
        return _aruco.VectorInt_rbegin(self)

    def rend(self):
        return _aruco.VectorInt_rend(self)

    def clear(self):
        return _aruco.VectorInt_clear(self)

    def get_allocator(self):
        return _aruco.VectorInt_get_allocator(self)

    def pop_back(self):
        return _aruco.VectorInt_pop_back(self)

    def erase(self, *args):
        return _aruco.VectorInt_erase(self, *args)

    def __init__(self, *args):
        this = _aruco.new_VectorInt(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        return _aruco.VectorInt_push_back(self, x)

    def front(self):
        return _aruco.VectorInt_front(self)

    def back(self):
        return _aruco.VectorInt_back(self)

    def assign(self, n, x):
        return _aruco.VectorInt_assign(self, n, x)

    def resize(self, *args):
        return _aruco.VectorInt_resize(self, *args)

    def insert(self, *args):
        return _aruco.VectorInt_insert(self, *args)

    def reserve(self, n):
        return _aruco.VectorInt_reserve(self, n)

    def capacity(self):
        return _aruco.VectorInt_capacity(self)
    __swig_destroy__ = _aruco.delete_VectorInt
    __del__ = lambda self: None
VectorInt_swigregister = _aruco.VectorInt_swigregister
VectorInt_swigregister(VectorInt)

ARUCO_VERSION_MAJOR = _aruco.ARUCO_VERSION_MAJOR
ARUCO_VERSION_MINOR = _aruco.ARUCO_VERSION_MINOR
class CameraParameters(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CameraParameters, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CameraParameters, name)
    __repr__ = _swig_repr
    __swig_setmethods__["CameraMatrix"] = _aruco.CameraParameters_CameraMatrix_set
    __swig_getmethods__["CameraMatrix"] = _aruco.CameraParameters_CameraMatrix_get
    if _newclass:
        CameraMatrix = _swig_property(_aruco.CameraParameters_CameraMatrix_get, _aruco.CameraParameters_CameraMatrix_set)
    __swig_setmethods__["Distorsion"] = _aruco.CameraParameters_Distorsion_set
    __swig_getmethods__["Distorsion"] = _aruco.CameraParameters_Distorsion_get
    if _newclass:
        Distorsion = _swig_property(_aruco.CameraParameters_Distorsion_get, _aruco.CameraParameters_Distorsion_set)
    __swig_setmethods__["CamSize"] = _aruco.CameraParameters_CamSize_set
    __swig_getmethods__["CamSize"] = _aruco.CameraParameters_CamSize_get
    if _newclass:
        CamSize = _swig_property(_aruco.CameraParameters_CamSize_get, _aruco.CameraParameters_CamSize_set)

    def setParams(self, cameraMatrix, distorsionCoeff, size):
        return _aruco.CameraParameters_setParams(self, cameraMatrix, distorsionCoeff, size)

    def __init__(self, *args):
        this = _aruco.new_CameraParameters(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def isValid(self):
        return _aruco.CameraParameters_isValid(self)

    def saveToFile(self, path, inXML=True):
        return _aruco.CameraParameters_saveToFile(self, path, inXML)

    def readFromXMLFile(self, filePath):
        return _aruco.CameraParameters_readFromXMLFile(self, filePath)

    def resize(self, size):
        return _aruco.CameraParameters_resize(self, size)
    if _newclass:
        getCameraLocation = staticmethod(_aruco.CameraParameters_getCameraLocation)
    else:
        getCameraLocation = _aruco.CameraParameters_getCameraLocation

    def glGetProjectionMatrix(self, orgImgSize, size, proj_matrix, gnear, gfar, invert=False):
        return _aruco.CameraParameters_glGetProjectionMatrix(self, orgImgSize, size, proj_matrix, gnear, gfar, invert)

    def OgreGetProjectionMatrix(self, orgImgSize, size, proj_matrix, gnear, gfar, invert=False):
        return _aruco.CameraParameters_OgreGetProjectionMatrix(self, orgImgSize, size, proj_matrix, gnear, gfar, invert)
    if _newclass:
        getRTMatrix = staticmethod(_aruco.CameraParameters_getRTMatrix)
    else:
        getRTMatrix = _aruco.CameraParameters_getRTMatrix

    def clear(self):
        return _aruco.CameraParameters_clear(self)
    __swig_destroy__ = _aruco.delete_CameraParameters
    __del__ = lambda self: None
CameraParameters_swigregister = _aruco.CameraParameters_swigregister
CameraParameters_swigregister(CameraParameters)

def CameraParameters_getCameraLocation(Rvec, Tvec):
    return _aruco.CameraParameters_getCameraLocation(Rvec, Tvec)
CameraParameters_getCameraLocation = _aruco.CameraParameters_getCameraLocation

def CameraParameters_getRTMatrix(R_, T_, forceType):
    return _aruco.CameraParameters_getRTMatrix(R_, T_, forceType)
CameraParameters_getRTMatrix = _aruco.CameraParameters_getRTMatrix

class CvDrawingUtils(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CvDrawingUtils, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CvDrawingUtils, name)
    __repr__ = _swig_repr
    if _newclass:
        draw3dAxis = staticmethod(_aruco.CvDrawingUtils_draw3dAxis)
    else:
        draw3dAxis = _aruco.CvDrawingUtils_draw3dAxis
    if _newclass:
        draw3dCube = staticmethod(_aruco.CvDrawingUtils_draw3dCube)
    else:
        draw3dCube = _aruco.CvDrawingUtils_draw3dCube

    def __init__(self):
        this = _aruco.new_CvDrawingUtils()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _aruco.delete_CvDrawingUtils
    __del__ = lambda self: None
CvDrawingUtils_swigregister = _aruco.CvDrawingUtils_swigregister
CvDrawingUtils_swigregister(CvDrawingUtils)

def CvDrawingUtils_draw3dAxis(*args):
    return _aruco.CvDrawingUtils_draw3dAxis(*args)
CvDrawingUtils_draw3dAxis = _aruco.CvDrawingUtils_draw3dAxis

def CvDrawingUtils_draw3dCube(Image, m, CP, lineSize=1, setYperpendicular=False):
    return _aruco.CvDrawingUtils_draw3dCube(Image, m, CP, lineSize, setYperpendicular)
CvDrawingUtils_draw3dCube = _aruco.CvDrawingUtils_draw3dCube

class Debug(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Debug, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Debug, name)
    __repr__ = _swig_repr
    if _newclass:
        init = staticmethod(_aruco.Debug_init)
    else:
        init = _aruco.Debug_init
    if _newclass:
        setLevel = staticmethod(_aruco.Debug_setLevel)
    else:
        setLevel = _aruco.Debug_setLevel
    if _newclass:
        getLevel = staticmethod(_aruco.Debug_getLevel)
    else:
        getLevel = _aruco.Debug_getLevel
    if _newclass:
        addString = staticmethod(_aruco.Debug_addString)
    else:
        addString = _aruco.Debug_addString
    if _newclass:
        getString = staticmethod(_aruco.Debug_getString)
    else:
        getString = _aruco.Debug_getString
    if _newclass:
        getFileName = staticmethod(_aruco.Debug_getFileName)
    else:
        getFileName = _aruco.Debug_getFileName

    def __init__(self):
        this = _aruco.new_Debug()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _aruco.delete_Debug
    __del__ = lambda self: None
Debug_swigregister = _aruco.Debug_swigregister
Debug_swigregister(Debug)

def Debug_init():
    return _aruco.Debug_init()
Debug_init = _aruco.Debug_init

def Debug_setLevel(l):
    return _aruco.Debug_setLevel(l)
Debug_setLevel = _aruco.Debug_setLevel

def Debug_getLevel():
    return _aruco.Debug_getLevel()
Debug_getLevel = _aruco.Debug_getLevel

def Debug_addString(label, data):
    return _aruco.Debug_addString(label, data)
Debug_addString = _aruco.Debug_addString

def Debug_getString(str):
    return _aruco.Debug_getString(str)
Debug_getString = _aruco.Debug_getString

def Debug_getFileName(filepath):
    return _aruco.Debug_getFileName(filepath)
Debug_getFileName = _aruco.Debug_getFileName

class Dictionary(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Dictionary, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Dictionary, name)
    __repr__ = _swig_repr
    ALL_DICTS = _aruco.Dictionary_ALL_DICTS
    ARUCO_MIP_36h12 = _aruco.Dictionary_ARUCO_MIP_36h12
    ARUCO = _aruco.Dictionary_ARUCO
    ARUCO_MIP_25h7 = _aruco.Dictionary_ARUCO_MIP_25h7
    ARUCO_MIP_16h3 = _aruco.Dictionary_ARUCO_MIP_16h3
    ARTAG = _aruco.Dictionary_ARTAG
    ARTOOLKITPLUS = _aruco.Dictionary_ARTOOLKITPLUS
    ARTOOLKITPLUSBCH = _aruco.Dictionary_ARTOOLKITPLUSBCH
    TAG16h5 = _aruco.Dictionary_TAG16h5
    TAG25h7 = _aruco.Dictionary_TAG25h7
    TAG25h9 = _aruco.Dictionary_TAG25h9
    TAG36h11 = _aruco.Dictionary_TAG36h11
    TAG36h10 = _aruco.Dictionary_TAG36h10
    CHILITAGS = _aruco.Dictionary_CHILITAGS
    CUSTOM = _aruco.Dictionary_CUSTOM

    def _is(self, code):
        return _aruco.Dictionary__is(self, code)

    def getType(self):
        return _aruco.Dictionary_getType(self)

    def size(self):
        return _aruco.Dictionary_size(self)

    def nbits(self):
        return _aruco.Dictionary_nbits(self)

    def tau(self):
        return _aruco.Dictionary_tau(self)

    def getName(self):
        return _aruco.Dictionary_getName(self)

    def getMapCode(self):
        return _aruco.Dictionary_getMapCode(self)

    def at(self, code):
        return _aruco.Dictionary_at(self, code)

    def getMarkerImage_id(self, id, bit_size, addWaterMark=True, enclosed_corners=False, printExternalWhiteBorder=False, centralCircle=False):
        return _aruco.Dictionary_getMarkerImage_id(self, id, bit_size, addWaterMark, enclosed_corners, printExternalWhiteBorder, centralCircle)

    def createMarkerMap(self, gridSize, MarkerSize, MarkerDistance, Ids, chess_board=False):
        return _aruco.Dictionary_createMarkerMap(self, gridSize, MarkerSize, MarkerDistance, Ids, chess_board)
    if _newclass:
        loadPredefined = staticmethod(_aruco.Dictionary_loadPredefined)
    else:
        loadPredefined = _aruco.Dictionary_loadPredefined
    if _newclass:
        loadFromFile = staticmethod(_aruco.Dictionary_loadFromFile)
    else:
        loadFromFile = _aruco.Dictionary_loadFromFile
    if _newclass:
        load = staticmethod(_aruco.Dictionary_load)
    else:
        load = _aruco.Dictionary_load
    if _newclass:
        computeDictionaryDistance = staticmethod(_aruco.Dictionary_computeDictionaryDistance)
    else:
        computeDictionaryDistance = _aruco.Dictionary_computeDictionaryDistance
    if _newclass:
        getTypeFromString = staticmethod(_aruco.Dictionary_getTypeFromString)
    else:
        getTypeFromString = _aruco.Dictionary_getTypeFromString
    if _newclass:
        getTypeString = staticmethod(_aruco.Dictionary_getTypeString)
    else:
        getTypeString = _aruco.Dictionary_getTypeString
    if _newclass:
        isPredefinedDictinaryString = staticmethod(_aruco.Dictionary_isPredefinedDictinaryString)
    else:
        isPredefinedDictinaryString = _aruco.Dictionary_isPredefinedDictinaryString
    if _newclass:
        getDicTypes = staticmethod(_aruco.Dictionary_getDicTypes)
    else:
        getDicTypes = _aruco.Dictionary_getDicTypes

    def __init__(self):
        this = _aruco.new_Dictionary()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _aruco.delete_Dictionary
    __del__ = lambda self: None
Dictionary_swigregister = _aruco.Dictionary_swigregister
Dictionary_swigregister(Dictionary)

def Dictionary_loadPredefined(*args):
    return _aruco.Dictionary_loadPredefined(*args)
Dictionary_loadPredefined = _aruco.Dictionary_loadPredefined

def Dictionary_loadFromFile(path):
    return _aruco.Dictionary_loadFromFile(path)
Dictionary_loadFromFile = _aruco.Dictionary_loadFromFile

def Dictionary_load(info):
    return _aruco.Dictionary_load(info)
Dictionary_load = _aruco.Dictionary_load

def Dictionary_computeDictionaryDistance(d):
    return _aruco.Dictionary_computeDictionaryDistance(d)
Dictionary_computeDictionaryDistance = _aruco.Dictionary_computeDictionaryDistance

def Dictionary_getTypeFromString(str):
    return _aruco.Dictionary_getTypeFromString(str)
Dictionary_getTypeFromString = _aruco.Dictionary_getTypeFromString

def Dictionary_getTypeString(t):
    return _aruco.Dictionary_getTypeString(t)
Dictionary_getTypeString = _aruco.Dictionary_getTypeString

def Dictionary_isPredefinedDictinaryString(str):
    return _aruco.Dictionary_isPredefinedDictinaryString(str)
Dictionary_isPredefinedDictinaryString = _aruco.Dictionary_isPredefinedDictinaryString

def Dictionary_getDicTypes():
    return _aruco.Dictionary_getDicTypes()
Dictionary_getDicTypes = _aruco.Dictionary_getDicTypes

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

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

    def __nonzero__(self):
        return _aruco.Point2fVec___nonzero__(self)

    def __bool__(self):
        return _aruco.Point2fVec___bool__(self)

    def __len__(self):
        return _aruco.Point2fVec___len__(self)

    def __getslice__(self, i, j):
        return _aruco.Point2fVec___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _aruco.Point2fVec___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _aruco.Point2fVec___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _aruco.Point2fVec___delitem__(self, *args)

    def __getitem__(self, *args):
        return _aruco.Point2fVec___getitem__(self, *args)

    def __setitem__(self, *args):
        return _aruco.Point2fVec___setitem__(self, *args)

    def pop(self):
        return _aruco.Point2fVec_pop(self)

    def append(self, x):
        return _aruco.Point2fVec_append(self, x)

    def empty(self):
        return _aruco.Point2fVec_empty(self)

    def size(self):
        return _aruco.Point2fVec_size(self)

    def swap(self, v):
        return _aruco.Point2fVec_swap(self, v)

    def begin(self):
        return _aruco.Point2fVec_begin(self)

    def end(self):
        return _aruco.Point2fVec_end(self)

    def rbegin(self):
        return _aruco.Point2fVec_rbegin(self)

    def rend(self):
        return _aruco.Point2fVec_rend(self)

    def clear(self):
        return _aruco.Point2fVec_clear(self)

    def get_allocator(self):
        return _aruco.Point2fVec_get_allocator(self)

    def pop_back(self):
        return _aruco.Point2fVec_pop_back(self)

    def erase(self, *args):
        return _aruco.Point2fVec_erase(self, *args)

    def __init__(self, *args):
        this = _aruco.new_Point2fVec(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        return _aruco.Point2fVec_push_back(self, x)

    def front(self):
        return _aruco.Point2fVec_front(self)

    def back(self):
        return _aruco.Point2fVec_back(self)

    def assign(self, n, x):
        return _aruco.Point2fVec_assign(self, n, x)

    def resize(self, *args):
        return _aruco.Point2fVec_resize(self, *args)

    def insert(self, *args):
        return _aruco.Point2fVec_insert(self, *args)

    def reserve(self, n):
        return _aruco.Point2fVec_reserve(self, n)

    def capacity(self):
        return _aruco.Point2fVec_capacity(self)
    __swig_destroy__ = _aruco.delete_Point2fVec
    __del__ = lambda self: None
Point2fVec_swigregister = _aruco.Point2fVec_swigregister
Point2fVec_swigregister(Point2fVec)

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

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

    def __nonzero__(self):
        return _aruco.MarkerVec___nonzero__(self)

    def __bool__(self):
        return _aruco.MarkerVec___bool__(self)

    def __len__(self):
        return _aruco.MarkerVec___len__(self)

    def __getslice__(self, i, j):
        return _aruco.MarkerVec___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _aruco.MarkerVec___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _aruco.MarkerVec___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _aruco.MarkerVec___delitem__(self, *args)

    def __getitem__(self, *args):
        return _aruco.MarkerVec___getitem__(self, *args)

    def __setitem__(self, *args):
        return _aruco.MarkerVec___setitem__(self, *args)

    def pop(self):
        return _aruco.MarkerVec_pop(self)

    def append(self, x):
        return _aruco.MarkerVec_append(self, x)

    def empty(self):
        return _aruco.MarkerVec_empty(self)

    def size(self):
        return _aruco.MarkerVec_size(self)

    def swap(self, v):
        return _aruco.MarkerVec_swap(self, v)

    def begin(self):
        return _aruco.MarkerVec_begin(self)

    def end(self):
        return _aruco.MarkerVec_end(self)

    def rbegin(self):
        return _aruco.MarkerVec_rbegin(self)

    def rend(self):
        return _aruco.MarkerVec_rend(self)

    def clear(self):
        return _aruco.MarkerVec_clear(self)

    def get_allocator(self):
        return _aruco.MarkerVec_get_allocator(self)

    def pop_back(self):
        return _aruco.MarkerVec_pop_back(self)

    def erase(self, *args):
        return _aruco.MarkerVec_erase(self, *args)

    def __init__(self, *args):
        this = _aruco.new_MarkerVec(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        return _aruco.MarkerVec_push_back(self, x)

    def front(self):
        return _aruco.MarkerVec_front(self)

    def back(self):
        return _aruco.MarkerVec_back(self)

    def assign(self, n, x):
        return _aruco.MarkerVec_assign(self, n, x)

    def resize(self, *args):
        return _aruco.MarkerVec_resize(self, *args)

    def insert(self, *args):
        return _aruco.MarkerVec_insert(self, *args)

    def reserve(self, n):
        return _aruco.MarkerVec_reserve(self, n)

    def capacity(self):
        return _aruco.MarkerVec_capacity(self)
    __swig_destroy__ = _aruco.delete_MarkerVec
    __del__ = lambda self: None
MarkerVec_swigregister = _aruco.MarkerVec_swigregister
MarkerVec_swigregister(MarkerVec)

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

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

    def __nonzero__(self):
        return _aruco.VectorMarker3DInfo___nonzero__(self)

    def __bool__(self):
        return _aruco.VectorMarker3DInfo___bool__(self)

    def __len__(self):
        return _aruco.VectorMarker3DInfo___len__(self)

    def __getslice__(self, i, j):
        return _aruco.VectorMarker3DInfo___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _aruco.VectorMarker3DInfo___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _aruco.VectorMarker3DInfo___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _aruco.VectorMarker3DInfo___delitem__(self, *args)

    def __getitem__(self, *args):
        return _aruco.VectorMarker3DInfo___getitem__(self, *args)

    def __setitem__(self, *args):
        return _aruco.VectorMarker3DInfo___setitem__(self, *args)

    def pop(self):
        return _aruco.VectorMarker3DInfo_pop(self)

    def append(self, x):
        return _aruco.VectorMarker3DInfo_append(self, x)

    def empty(self):
        return _aruco.VectorMarker3DInfo_empty(self)

    def size(self):
        return _aruco.VectorMarker3DInfo_size(self)

    def swap(self, v):
        return _aruco.VectorMarker3DInfo_swap(self, v)

    def begin(self):
        return _aruco.VectorMarker3DInfo_begin(self)

    def end(self):
        return _aruco.VectorMarker3DInfo_end(self)

    def rbegin(self):
        return _aruco.VectorMarker3DInfo_rbegin(self)

    def rend(self):
        return _aruco.VectorMarker3DInfo_rend(self)

    def clear(self):
        return _aruco.VectorMarker3DInfo_clear(self)

    def get_allocator(self):
        return _aruco.VectorMarker3DInfo_get_allocator(self)

    def pop_back(self):
        return _aruco.VectorMarker3DInfo_pop_back(self)

    def erase(self, *args):
        return _aruco.VectorMarker3DInfo_erase(self, *args)

    def __init__(self, *args):
        this = _aruco.new_VectorMarker3DInfo(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        return _aruco.VectorMarker3DInfo_push_back(self, x)

    def front(self):
        return _aruco.VectorMarker3DInfo_front(self)

    def back(self):
        return _aruco.VectorMarker3DInfo_back(self)

    def assign(self, n, x):
        return _aruco.VectorMarker3DInfo_assign(self, n, x)

    def resize(self, *args):
        return _aruco.VectorMarker3DInfo_resize(self, *args)

    def insert(self, *args):
        return _aruco.VectorMarker3DInfo_insert(self, *args)

    def reserve(self, n):
        return _aruco.VectorMarker3DInfo_reserve(self, n)

    def capacity(self):
        return _aruco.VectorMarker3DInfo_capacity(self)
    __swig_destroy__ = _aruco.delete_VectorMarker3DInfo
    __del__ = lambda self: None
VectorMarker3DInfo_swigregister = _aruco.VectorMarker3DInfo_swigregister
VectorMarker3DInfo_swigregister(VectorMarker3DInfo)

class Marker(Point2fVec):
    __swig_setmethods__ = {}
    for _s in [Point2fVec]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Marker, name, value)
    __swig_getmethods__ = {}
    for _s in [Point2fVec]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Marker, name)
    __repr__ = _swig_repr
    __swig_setmethods__["id"] = _aruco.Marker_id_set
    __swig_getmethods__["id"] = _aruco.Marker_id_get
    if _newclass:
        id = _swig_property(_aruco.Marker_id_get, _aruco.Marker_id_set)
    __swig_setmethods__["ssize"] = _aruco.Marker_ssize_set
    __swig_getmethods__["ssize"] = _aruco.Marker_ssize_get
    if _newclass:
        ssize = _swig_property(_aruco.Marker_ssize_get, _aruco.Marker_ssize_set)
    __swig_setmethods__["Rvec"] = _aruco.Marker_Rvec_set
    __swig_getmethods__["Rvec"] = _aruco.Marker_Rvec_get
    if _newclass:
        Rvec = _swig_property(_aruco.Marker_Rvec_get, _aruco.Marker_Rvec_set)
    __swig_setmethods__["Tvec"] = _aruco.Marker_Tvec_set
    __swig_getmethods__["Tvec"] = _aruco.Marker_Tvec_get
    if _newclass:
        Tvec = _swig_property(_aruco.Marker_Tvec_get, _aruco.Marker_Tvec_set)
    __swig_setmethods__["dict_info"] = _aruco.Marker_dict_info_set
    __swig_getmethods__["dict_info"] = _aruco.Marker_dict_info_get
    if _newclass:
        dict_info = _swig_property(_aruco.Marker_dict_info_get, _aruco.Marker_dict_info_set)
    __swig_setmethods__["contourPoints"] = _aruco.Marker_contourPoints_set
    __swig_getmethods__["contourPoints"] = _aruco.Marker_contourPoints_get
    if _newclass:
        contourPoints = _swig_property(_aruco.Marker_contourPoints_get, _aruco.Marker_contourPoints_set)

    def __init__(self, *args):
        this = _aruco.new_Marker(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _aruco.delete_Marker
    __del__ = lambda self: None

    def isValid(self):
        return _aruco.Marker_isValid(self)

    def isPoseValid(self):
        return _aruco.Marker_isPoseValid(self)

    def draw(self, *args):
        return _aruco.Marker_draw(self, *args)

    def calculateExtrinsics(self, *args):
        return _aruco.Marker_calculateExtrinsics(self, *args)

    def glGetModelViewMatrix(self, modelview_matrix):
        return _aruco.Marker_glGetModelViewMatrix(self, modelview_matrix)

    def OgreGetPoseParameters(self, position, orientation):
        return _aruco.Marker_OgreGetPoseParameters(self, position, orientation)

    def getCenter(self):
        return _aruco.Marker_getCenter(self)

    def getPerimeter(self):
        return _aruco.Marker_getPerimeter(self)

    def getArea(self):
        return _aruco.Marker_getArea(self)

    def getRadius(self):
        return _aruco.Marker_getRadius(self)

    def __eq__(self, m):
        return _aruco.Marker___eq__(self, m)

    def copyTo(self, m):
        return _aruco.Marker_copyTo(self, m)

    def toStream(self, str):
        return _aruco.Marker_toStream(self, str)

    def fromStream(self, str):
        return _aruco.Marker_fromStream(self, str)

    def get3DPoints(self, *args):
        return _aruco.Marker_get3DPoints(self, *args)

    def getTransformMatrix(self):
        return _aruco.Marker_getTransformMatrix(self)

    def __getitem__(self, i):
        return _aruco.Marker___getitem__(self, i)

    def iterator(self):
        return VectorIterator(self)

Marker_swigregister = _aruco.Marker_swigregister
Marker_swigregister(Marker)


class VectorIterator(object):

    def __init__(self, pointerToVector):
        self.pointerToVector = pointerToVector
        self.index = -1

    def __iter__(self):
        return self

    def __next__(self):
        self.index += 1
        if self.index < len(self.pointerToVector):
            return self.pointerToVector[self.index]
        else:
            raise StopIteration

    def next(self):
        self.index += 1
        if self.index < len(self.pointerToVector):
            return self.pointerToVector[self.index]
        else:
            raise StopIteration

DM_NORMAL = _aruco.DM_NORMAL
DM_FAST = _aruco.DM_FAST
DM_VIDEO_FAST = _aruco.DM_VIDEO_FAST
CORNER_SUBPIX = _aruco.CORNER_SUBPIX
CORNER_LINES = _aruco.CORNER_LINES
CORNER_NONE = _aruco.CORNER_NONE
class MarkerDetector(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, MarkerDetector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, MarkerDetector, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _aruco.new_MarkerDetector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def saveParamsToFile(self, path):
        return _aruco.MarkerDetector_saveParamsToFile(self, path)

    def loadParamsFromFile(self, path):
        return _aruco.MarkerDetector_loadParamsFromFile(self, path)
    __swig_destroy__ = _aruco.delete_MarkerDetector
    __del__ = lambda self: None

    def setDetectionMode(self, dm, minMarkerSize=0):
        return _aruco.MarkerDetector_setDetectionMode(self, dm, minMarkerSize)

    def getDetectionMode(self):
        return _aruco.MarkerDetector_getDetectionMode(self)

    def detect(self, *args):
        return _aruco.MarkerDetector_detect(self, *args)

    def getParameters(self, *args):
        return _aruco.MarkerDetector_getParameters(self, *args)

    def setDictionary(self, *args):
        return _aruco.MarkerDetector_setDictionary(self, *args)

    def getThresholdedImage(self, idx=0):
        return _aruco.MarkerDetector_getThresholdedImage(self, idx)

    def setMarkerLabeler(self, detector):
        return _aruco.MarkerDetector_setMarkerLabeler(self, detector)

    def getMarkerLabeler(self):
        return _aruco.MarkerDetector_getMarkerLabeler(self)

    def getCandidates(self):
        return _aruco.MarkerDetector_getCandidates(self)

    def getImagePyramid(self):
        return _aruco.MarkerDetector_getImagePyramid(self)

    def cornerUpsample(self, corners, lowResImageSize):
        return _aruco.MarkerDetector_cornerUpsample(self, corners, lowResImageSize)

    def toStream(self, str):
        return _aruco.MarkerDetector_toStream(self, str)

    def fromStream(self, str):
        return _aruco.MarkerDetector_fromStream(self, str)

    def setParameters(self, params):
        return _aruco.MarkerDetector_setParameters(self, params)
MarkerDetector_swigregister = _aruco.MarkerDetector_swigregister
MarkerDetector_swigregister(MarkerDetector)

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    if _newclass:
        create = staticmethod(_aruco.MarkerLabeler_create)
    else:
        create = _aruco.MarkerLabeler_create

    def detect(self, arg2, marker_id, nRotations, additionalInfo):
        return _aruco.MarkerLabeler_detect(self, arg2, marker_id, nRotations, additionalInfo)

    def getBestInputSize(self):
        return _aruco.MarkerLabeler_getBestInputSize(self)

    def getNSubdivisions(self):
        return _aruco.MarkerLabeler_getNSubdivisions(self)

    def getName(self):
        return _aruco.MarkerLabeler_getName(self)
    __swig_destroy__ = _aruco.delete_MarkerLabeler
    __del__ = lambda self: None
MarkerLabeler_swigregister = _aruco.MarkerLabeler_swigregister
MarkerLabeler_swigregister(MarkerLabeler)

def MarkerLabeler_create(*args):
    return _aruco.MarkerLabeler_create(*args)
MarkerLabeler_create = _aruco.MarkerLabeler_create

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

    def __init__(self):
        this = _aruco.new_FractalDetector()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def setConfiguration(self, *args):
        return _aruco.FractalDetector_setConfiguration(self, *args)

    def setParams(self, cam_params, markerSize):
        return _aruco.FractalDetector_setParams(self, cam_params, markerSize)

    def getConfiguration(self):
        return _aruco.FractalDetector_getConfiguration(self)

    def detect(self, input):
        return _aruco.FractalDetector_detect(self, input)

    def poseEstimation(self):
        return _aruco.FractalDetector_poseEstimation(self)

    def getRvec(self):
        return _aruco.FractalDetector_getRvec(self)

    def getTvec(self):
        return _aruco.FractalDetector_getTvec(self)

    def drawMarkers(self, img):
        return _aruco.FractalDetector_drawMarkers(self, img)

    def draw2d(self, img):
        return _aruco.FractalDetector_draw2d(self, img)

    def draw3d(self, img, cube=True, axis=True):
        return _aruco.FractalDetector_draw3d(self, img, cube, axis)

    def draw3dCube(self, Image, m, CP, lineSize):
        return _aruco.FractalDetector_draw3dCube(self, Image, m, CP, lineSize)

    def getMarkers(self):
        return _aruco.FractalDetector_getMarkers(self)
    __swig_destroy__ = _aruco.delete_FractalDetector
    __del__ = lambda self: None
FractalDetector_swigregister = _aruco.FractalDetector_swigregister
FractalDetector_swigregister(FractalDetector)

class Marker3DInfo(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Marker3DInfo, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Marker3DInfo, name)
    __repr__ = _swig_repr
    __swig_setmethods__["points"] = _aruco.Marker3DInfo_points_set
    __swig_getmethods__["points"] = _aruco.Marker3DInfo_points_get
    if _newclass:
        points = _swig_property(_aruco.Marker3DInfo_points_get, _aruco.Marker3DInfo_points_set)
    __swig_setmethods__["id"] = _aruco.Marker3DInfo_id_set
    __swig_getmethods__["id"] = _aruco.Marker3DInfo_id_get
    if _newclass:
        id = _swig_property(_aruco.Marker3DInfo_id_get, _aruco.Marker3DInfo_id_set)

    def __init__(self, *args):
        this = _aruco.new_Marker3DInfo(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __eq__(self, MI):
        return _aruco.Marker3DInfo___eq__(self, MI)

    def getMarkerSize(self):
        return _aruco.Marker3DInfo_getMarkerSize(self)

    def at(self, idx):
        return _aruco.Marker3DInfo_at(self, idx)

    def push_back(self, p):
        return _aruco.Marker3DInfo_push_back(self, p)

    def size(self):
        return _aruco.Marker3DInfo_size(self)

    def toStream(self, str):
        return _aruco.Marker3DInfo_toStream(self, str)

    def fromStream(self, str):
        return _aruco.Marker3DInfo_fromStream(self, str)
    __swig_destroy__ = _aruco.delete_Marker3DInfo
    __del__ = lambda self: None
Marker3DInfo_swigregister = _aruco.Marker3DInfo_swigregister
Marker3DInfo_swigregister(Marker3DInfo)

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

    def __init__(self, *args):
        this = _aruco.new_MarkerMap(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def isExpressedInMeters(self):
        return _aruco.MarkerMap_isExpressedInMeters(self)

    def isExpressedInPixels(self):
        return _aruco.MarkerMap_isExpressedInPixels(self)

    def convertToMeters(self, markerSize):
        return _aruco.MarkerMap_convertToMeters(self, markerSize)

    def getIndices(self, markers):
        return _aruco.MarkerMap_getIndices(self, markers)

    def getMarker3DInfo(self, id):
        return _aruco.MarkerMap_getMarker3DInfo(self, id)

    def getIndexOfMarkerId(self, id):
        return _aruco.MarkerMap_getIndexOfMarkerId(self, id)

    def getIdList(self, ids, append=True):
        return _aruco.MarkerMap_getIdList(self, ids, append)

    def getImage(self, METER2PIX=0):
        return _aruco.MarkerMap_getImage(self, METER2PIX)

    def saveToFile(self, sfile):
        return _aruco.MarkerMap_saveToFile(self, sfile)

    def readFromFile(self, sfile):
        return _aruco.MarkerMap_readFromFile(self, sfile)

    def calculateExtrinsics(self, markers, markerSize, CameraMatrix, Distorsion):
        return _aruco.MarkerMap_calculateExtrinsics(self, markers, markerSize, CameraMatrix, Distorsion)

    def getDictionary(self):
        return _aruco.MarkerMap_getDictionary(self)
    NONE = _aruco.MarkerMap_NONE
    PIX = _aruco.MarkerMap_PIX
    METERS = _aruco.MarkerMap_METERS

    def setDictionary(self, d):
        return _aruco.MarkerMap_setDictionary(self, d)
    __swig_setmethods__["mInfoType"] = _aruco.MarkerMap_mInfoType_set
    __swig_getmethods__["mInfoType"] = _aruco.MarkerMap_mInfoType_get
    if _newclass:
        mInfoType = _swig_property(_aruco.MarkerMap_mInfoType_get, _aruco.MarkerMap_mInfoType_set)

    def toStream(self, str):
        return _aruco.MarkerMap_toStream(self, str)

    def fromStream(self, str):
        return _aruco.MarkerMap_fromStream(self, str)
    __swig_destroy__ = _aruco.delete_MarkerMap
    __del__ = lambda self: None
MarkerMap_swigregister = _aruco.MarkerMap_swigregister
MarkerMap_swigregister(MarkerMap)

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

    def estimatePose(self, m, cam_params, markerSize, minErrorRatio=10):
        return _aruco.MarkerPoseTracker_estimatePose(self, m, cam_params, markerSize, minErrorRatio)

    def getRTMatrix(self):
        return _aruco.MarkerPoseTracker_getRTMatrix(self)

    def getRvec(self):
        return _aruco.MarkerPoseTracker_getRvec(self)

    def getTvec(self):
        return _aruco.MarkerPoseTracker_getTvec(self)

    def __init__(self):
        this = _aruco.new_MarkerPoseTracker()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _aruco.delete_MarkerPoseTracker
    __del__ = lambda self: None
MarkerPoseTracker_swigregister = _aruco.MarkerPoseTracker_swigregister
MarkerPoseTracker_swigregister(MarkerPoseTracker)

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

    def __init__(self):
        this = _aruco.new_MarkerMapPoseTracker()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def setParams(self, cam_params, msconf, markerSize=-1):
        return _aruco.MarkerMapPoseTracker_setParams(self, cam_params, msconf, markerSize)

    def isValid(self):
        return _aruco.MarkerMapPoseTracker_isValid(self)

    def reset(self):
        return _aruco.MarkerMapPoseTracker_reset(self)

    def estimatePose(self, v_m):
        return _aruco.MarkerMapPoseTracker_estimatePose(self, v_m)

    def getRTMatrix(self):
        return _aruco.MarkerMapPoseTracker_getRTMatrix(self)

    def getRvec(self):
        return _aruco.MarkerMapPoseTracker_getRvec(self)

    def getTvec(self):
        return _aruco.MarkerMapPoseTracker_getTvec(self)

    def setMaxTrackingDifference(self, maxTranslation, maxAngle):
        return _aruco.MarkerMapPoseTracker_setMaxTrackingDifference(self, maxTranslation, maxAngle)
    __swig_destroy__ = _aruco.delete_MarkerMapPoseTracker
    __del__ = lambda self: None
MarkerMapPoseTracker_swigregister = _aruco.MarkerMapPoseTracker_swigregister
MarkerMapPoseTracker_swigregister(MarkerMapPoseTracker)

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

    def __call__(self, *args):
        return _aruco.PicoFlann_KeyPointAdapter___call__(self, *args)

    def __init__(self):
        this = _aruco.new_PicoFlann_KeyPointAdapter()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _aruco.delete_PicoFlann_KeyPointAdapter
    __del__ = lambda self: None
PicoFlann_KeyPointAdapter_swigregister = _aruco.PicoFlann_KeyPointAdapter_swigregister
PicoFlann_KeyPointAdapter_swigregister(PicoFlann_KeyPointAdapter)

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

    def __init__(self):
        this = _aruco.new_FractalPoseTracker()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def setParams(self, cam_params, msconf):
        return _aruco.FractalPoseTracker_setParams(self, cam_params, msconf)

    def fractalInnerPose(self, markerDetector, markers, refinement=True):
        return _aruco.FractalPoseTracker_fractalInnerPose(self, markerDetector, markers, refinement)

    def ROI(self, imagePyramid, img, innerPoints2d, offset, ratio):
        return _aruco.FractalPoseTracker_ROI(self, imagePyramid, img, innerPoints2d, offset, ratio)

    def assignClass(self, im, kpoints, norm=False, wsize=5):
        return _aruco.FractalPoseTracker_assignClass(self, im, kpoints, norm, wsize)

    def fractal_solve_ransac(self, ninners, inner_kpnt, kpnts, maxIter=500, _minInliers=0.35, _thresInliers=0.7):
        return _aruco.FractalPoseTracker_fractal_solve_ransac(self, ninners, inner_kpnt, kpnts, maxIter, _minInliers, _thresInliers)

    def fractalRefinement(self, markerDetector, markerWarpPix=10):
        return _aruco.FractalPoseTracker_fractalRefinement(self, markerDetector, markerWarpPix)

    def getRvec(self):
        return _aruco.FractalPoseTracker_getRvec(self)

    def getTvec(self):
        return _aruco.FractalPoseTracker_getTvec(self)

    def getInner3d(self):
        return _aruco.FractalPoseTracker_getInner3d(self)

    def isPoseValid(self):
        return _aruco.FractalPoseTracker_isPoseValid(self)
    __swig_destroy__ = _aruco.delete_FractalPoseTracker
    __del__ = lambda self: None
FractalPoseTracker_swigregister = _aruco.FractalPoseTracker_swigregister
FractalPoseTracker_swigregister(FractalPoseTracker)

class FractalMarkerLabeler(MarkerLabeler):
    __swig_setmethods__ = {}
    for _s in [MarkerLabeler]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, FractalMarkerLabeler, name, value)
    __swig_getmethods__ = {}
    for _s in [MarkerLabeler]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, FractalMarkerLabeler, name)
    __repr__ = _swig_repr
    if _newclass:
        create = staticmethod(_aruco.FractalMarkerLabeler_create)
    else:
        create = _aruco.FractalMarkerLabeler_create

    def setConfiguration(self, fractMarkerSet):
        return _aruco.FractalMarkerLabeler_setConfiguration(self, fractMarkerSet)
    __swig_destroy__ = _aruco.delete_FractalMarkerLabeler
    __del__ = lambda self: None

    def getName(self):
        return _aruco.FractalMarkerLabeler_getName(self)

    def detect(self, arg2, marker_id, nRotations, additionalInfo):
        return _aruco.FractalMarkerLabeler_detect(self, arg2, marker_id, nRotations, additionalInfo)

    def getNSubdivisions(self):
        return _aruco.FractalMarkerLabeler_getNSubdivisions(self)
    __swig_setmethods__["_fractalMarkerSet"] = _aruco.FractalMarkerLabeler__fractalMarkerSet_set
    __swig_getmethods__["_fractalMarkerSet"] = _aruco.FractalMarkerLabeler__fractalMarkerSet_get
    if _newclass:
        _fractalMarkerSet = _swig_property(_aruco.FractalMarkerLabeler__fractalMarkerSet_get, _aruco.FractalMarkerLabeler__fractalMarkerSet_set)

    def __init__(self):
        this = _aruco.new_FractalMarkerLabeler()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
FractalMarkerLabeler_swigregister = _aruco.FractalMarkerLabeler_swigregister
FractalMarkerLabeler_swigregister(FractalMarkerLabeler)

def FractalMarkerLabeler_create(*args):
    return _aruco.FractalMarkerLabeler_create(*args)
FractalMarkerLabeler_create = _aruco.FractalMarkerLabeler_create

class FractalMarkerSet(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, FractalMarkerSet, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, FractalMarkerSet, name)
    __repr__ = _swig_repr
    FRACTAL_2L_6 = _aruco.FractalMarkerSet_FRACTAL_2L_6
    FRACTAL_3L_6 = _aruco.FractalMarkerSet_FRACTAL_3L_6
    FRACTAL_4L_6 = _aruco.FractalMarkerSet_FRACTAL_4L_6
    FRACTAL_5L_6 = _aruco.FractalMarkerSet_FRACTAL_5L_6
    CUSTOM = _aruco.FractalMarkerSet_CUSTOM

    def create(self, regionsConfig, pixSize):
        return _aruco.FractalMarkerSet_create(self, regionsConfig, pixSize)

    def configureMat(self, nVal, kVal, maxIter=10000):
        return _aruco.FractalMarkerSet_configureMat(self, nVal, kVal, maxIter)

    def dstMarker(self, m):
        return _aruco.FractalMarkerSet_dstMarker(self, m)

    def dstMarkerToMarker(self, m1, m2):
        return _aruco.FractalMarkerSet_dstMarkerToMarker(self, m1, m2)

    def dstMarkerToFractalDict(self, m):
        return _aruco.FractalMarkerSet_dstMarkerToFractalDict(self, m)
    if _newclass:
        _toStream = staticmethod(_aruco.FractalMarkerSet__toStream)
    else:
        _toStream = _aruco.FractalMarkerSet__toStream
    if _newclass:
        _fromStream = staticmethod(_aruco.FractalMarkerSet__fromStream)
    else:
        _fromStream = _aruco.FractalMarkerSet__fromStream
    if _newclass:
        isPredefinedConfigurationString = staticmethod(_aruco.FractalMarkerSet_isPredefinedConfigurationString)
    else:
        isPredefinedConfigurationString = _aruco.FractalMarkerSet_isPredefinedConfigurationString
    if _newclass:
        getTypeString = staticmethod(_aruco.FractalMarkerSet_getTypeString)
    else:
        getTypeString = _aruco.FractalMarkerSet_getTypeString
    if _newclass:
        getTypeFromString = staticmethod(_aruco.FractalMarkerSet_getTypeFromString)
    else:
        getTypeFromString = _aruco.FractalMarkerSet_getTypeFromString
    if _newclass:
        load = staticmethod(_aruco.FractalMarkerSet_load)
    else:
        load = _aruco.FractalMarkerSet_load
    if _newclass:
        loadPredefined = staticmethod(_aruco.FractalMarkerSet_loadPredefined)
    else:
        loadPredefined = _aruco.FractalMarkerSet_loadPredefined
    if _newclass:
        readFromFile = staticmethod(_aruco.FractalMarkerSet_readFromFile)
    else:
        readFromFile = _aruco.FractalMarkerSet_readFromFile

    def saveToFile(self, fs):
        return _aruco.FractalMarkerSet_saveToFile(self, fs)
    __swig_setmethods__["fractalMarkerCollection"] = _aruco.FractalMarkerSet_fractalMarkerCollection_set
    __swig_getmethods__["fractalMarkerCollection"] = _aruco.FractalMarkerSet_fractalMarkerCollection_get
    if _newclass:
        fractalMarkerCollection = _swig_property(_aruco.FractalMarkerSet_fractalMarkerCollection_get, _aruco.FractalMarkerSet_fractalMarkerCollection_set)
    __swig_setmethods__["nbits_fractalMarkerIDs"] = _aruco.FractalMarkerSet_nbits_fractalMarkerIDs_set
    __swig_getmethods__["nbits_fractalMarkerIDs"] = _aruco.FractalMarkerSet_nbits_fractalMarkerIDs_get
    if _newclass:
        nbits_fractalMarkerIDs = _swig_property(_aruco.FractalMarkerSet_nbits_fractalMarkerIDs_get, _aruco.FractalMarkerSet_nbits_fractalMarkerIDs_set)
    NONE = _aruco.FractalMarkerSet_NONE
    PIX = _aruco.FractalMarkerSet_PIX
    METERS = _aruco.FractalMarkerSet_METERS
    NORM = _aruco.FractalMarkerSet_NORM

    def isExpressedInMeters(self):
        return _aruco.FractalMarkerSet_isExpressedInMeters(self)

    def isExpressedInPixels(self):
        return _aruco.FractalMarkerSet_isExpressedInPixels(self)

    def isNormalize(self):
        return _aruco.FractalMarkerSet_isNormalize(self)

    def normalize(self):
        return _aruco.FractalMarkerSet_normalize(self)

    def convertToMeters(self, fractalSize_meters):
        return _aruco.FractalMarkerSet_convertToMeters(self, fractalSize_meters)
    if _newclass:
        getConfigurations = staticmethod(_aruco.FractalMarkerSet_getConfigurations)
    else:
        getConfigurations = _aruco.FractalMarkerSet_getConfigurations

    def getFractalSize(self):
        return _aruco.FractalMarkerSet_getFractalSize(self)

    def nBits(self):
        return _aruco.FractalMarkerSet_nBits(self)

    def isFractalMarker(self, m, nbits, id):
        return _aruco.FractalMarkerSet_isFractalMarker(self, m, nbits, id)

    def getInnerCorners(self):
        return _aruco.FractalMarkerSet_getInnerCorners(self)

    def getFractalMarkerImage(self, pixSize, border=False):
        return _aruco.FractalMarkerSet_getFractalMarkerImage(self, pixSize, border)
    __swig_setmethods__["mInfoType"] = _aruco.FractalMarkerSet_mInfoType_set
    __swig_getmethods__["mInfoType"] = _aruco.FractalMarkerSet_mInfoType_get
    if _newclass:
        mInfoType = _swig_property(_aruco.FractalMarkerSet_mInfoType_get, _aruco.FractalMarkerSet_mInfoType_set)

    def __init__(self):
        this = _aruco.new_FractalMarkerSet()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _aruco.delete_FractalMarkerSet
    __del__ = lambda self: None
FractalMarkerSet_swigregister = _aruco.FractalMarkerSet_swigregister
FractalMarkerSet_swigregister(FractalMarkerSet)

def FractalMarkerSet__toStream(configuration, str):
    return _aruco.FractalMarkerSet__toStream(configuration, str)
FractalMarkerSet__toStream = _aruco.FractalMarkerSet__toStream

def FractalMarkerSet__fromStream(configuration, str):
    return _aruco.FractalMarkerSet__fromStream(configuration, str)
FractalMarkerSet__fromStream = _aruco.FractalMarkerSet__fromStream

def FractalMarkerSet_isPredefinedConfigurationString(str):
    return _aruco.FractalMarkerSet_isPredefinedConfigurationString(str)
FractalMarkerSet_isPredefinedConfigurationString = _aruco.FractalMarkerSet_isPredefinedConfigurationString

def FractalMarkerSet_getTypeString(t):
    return _aruco.FractalMarkerSet_getTypeString(t)
FractalMarkerSet_getTypeString = _aruco.FractalMarkerSet_getTypeString

def FractalMarkerSet_getTypeFromString(str):
    return _aruco.FractalMarkerSet_getTypeFromString(str)
FractalMarkerSet_getTypeFromString = _aruco.FractalMarkerSet_getTypeFromString

def FractalMarkerSet_load(info):
    return _aruco.FractalMarkerSet_load(info)
FractalMarkerSet_load = _aruco.FractalMarkerSet_load

def FractalMarkerSet_loadPredefined(*args):
    return _aruco.FractalMarkerSet_loadPredefined(*args)
FractalMarkerSet_loadPredefined = _aruco.FractalMarkerSet_loadPredefined

def FractalMarkerSet_readFromFile(path):
    return _aruco.FractalMarkerSet_readFromFile(path)
FractalMarkerSet_readFromFile = _aruco.FractalMarkerSet_readFromFile

def FractalMarkerSet_getConfigurations():
    return _aruco.FractalMarkerSet_getConfigurations()
FractalMarkerSet_getConfigurations = _aruco.FractalMarkerSet_getConfigurations

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

    def __init__(self, *args):
        this = _aruco.new_FractalMarker(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def addSubFractalMarker(self, submarker):
        return _aruco.FractalMarker_addSubFractalMarker(self, submarker)

    def getInnerCorners(self):
        return _aruco.FractalMarker_getInnerCorners(self)

    def mat(self):
        return _aruco.FractalMarker_mat(self)

    def mask(self):
        return _aruco.FractalMarker_mask(self)

    def nBits(self):
        return _aruco.FractalMarker_nBits(self)

    def subMarkers(self):
        return _aruco.FractalMarker_subMarkers(self)
    __swig_destroy__ = _aruco.delete_FractalMarker
    __del__ = lambda self: None
FractalMarker_swigregister = _aruco.FractalMarker_swigregister
FractalMarker_swigregister(FractalMarker)

class ScopeTimer(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ScopeTimer, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ScopeTimer, name)
    __repr__ = _swig_repr
    __swig_setmethods__["begin"] = _aruco.ScopeTimer_begin_set
    __swig_getmethods__["begin"] = _aruco.ScopeTimer_begin_get
    if _newclass:
        begin = _swig_property(_aruco.ScopeTimer_begin_get, _aruco.ScopeTimer_begin_set)
    __swig_setmethods__["end"] = _aruco.ScopeTimer_end_set
    __swig_getmethods__["end"] = _aruco.ScopeTimer_end_get
    if _newclass:
        end = _swig_property(_aruco.ScopeTimer_end_get, _aruco.ScopeTimer_end_set)
    __swig_setmethods__["name"] = _aruco.ScopeTimer_name_set
    __swig_getmethods__["name"] = _aruco.ScopeTimer_name_get
    if _newclass:
        name = _swig_property(_aruco.ScopeTimer_name_get, _aruco.ScopeTimer_name_set)
    __swig_setmethods__["use"] = _aruco.ScopeTimer_use_set
    __swig_getmethods__["use"] = _aruco.ScopeTimer_use_get
    if _newclass:
        use = _swig_property(_aruco.ScopeTimer_use_get, _aruco.ScopeTimer_use_set)
    NSEC = _aruco.ScopeTimer_NSEC
    MSEC = _aruco.ScopeTimer_MSEC
    SEC = _aruco.ScopeTimer_SEC
    __swig_setmethods__["sc"] = _aruco.ScopeTimer_sc_set
    __swig_getmethods__["sc"] = _aruco.ScopeTimer_sc_get
    if _newclass:
        sc = _swig_property(_aruco.ScopeTimer_sc_get, _aruco.ScopeTimer_sc_set)

    def __init__(self, *args):
        this = _aruco.new_ScopeTimer(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _aruco.delete_ScopeTimer
    __del__ = lambda self: None
ScopeTimer_swigregister = _aruco.ScopeTimer_swigregister
ScopeTimer_swigregister(ScopeTimer)

class ScopedTimerEvents(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ScopedTimerEvents, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ScopedTimerEvents, name)
    __repr__ = _swig_repr
    NSEC = _aruco.ScopedTimerEvents_NSEC
    MSEC = _aruco.ScopedTimerEvents_MSEC
    SEC = _aruco.ScopedTimerEvents_SEC
    __swig_setmethods__["sc"] = _aruco.ScopedTimerEvents_sc_set
    __swig_getmethods__["sc"] = _aruco.ScopedTimerEvents_sc_get
    if _newclass:
        sc = _swig_property(_aruco.ScopedTimerEvents_sc_get, _aruco.ScopedTimerEvents_sc_set)
    __swig_setmethods__["vtimes"] = _aruco.ScopedTimerEvents_vtimes_set
    __swig_getmethods__["vtimes"] = _aruco.ScopedTimerEvents_vtimes_get
    if _newclass:
        vtimes = _swig_property(_aruco.ScopedTimerEvents_vtimes_get, _aruco.ScopedTimerEvents_vtimes_set)
    __swig_setmethods__["names"] = _aruco.ScopedTimerEvents_names_set
    __swig_getmethods__["names"] = _aruco.ScopedTimerEvents_names_get
    if _newclass:
        names = _swig_property(_aruco.ScopedTimerEvents_names_get, _aruco.ScopedTimerEvents_names_set)
    __swig_setmethods__["_name"] = _aruco.ScopedTimerEvents__name_set
    __swig_getmethods__["_name"] = _aruco.ScopedTimerEvents__name_get
    if _newclass:
        _name = _swig_property(_aruco.ScopedTimerEvents__name_get, _aruco.ScopedTimerEvents__name_set)

    def __init__(self, *args):
        this = _aruco.new_ScopedTimerEvents(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def add(self, name):
        return _aruco.ScopedTimerEvents_add(self, name)

    def addspaces(self, str):
        return _aruco.ScopedTimerEvents_addspaces(self, str)
    __swig_destroy__ = _aruco.delete_ScopedTimerEvents
    __del__ = lambda self: None
ScopedTimerEvents_swigregister = _aruco.ScopedTimerEvents_swigregister
ScopedTimerEvents_swigregister(ScopedTimerEvents)

class Timer(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Timer, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Timer, name)
    __repr__ = _swig_repr
    NSEC = _aruco.Timer_NSEC
    MSEC = _aruco.Timer_MSEC
    SEC = _aruco.Timer_SEC
    __swig_setmethods__["_s"] = _aruco.Timer__s_set
    __swig_getmethods__["_s"] = _aruco.Timer__s_get
    if _newclass:
        _s = _swig_property(_aruco.Timer__s_get, _aruco.Timer__s_set)
    __swig_setmethods__["sum"] = _aruco.Timer_sum_set
    __swig_getmethods__["sum"] = _aruco.Timer_sum_get
    if _newclass:
        sum = _swig_property(_aruco.Timer_sum_get, _aruco.Timer_sum_set)
    __swig_setmethods__["n"] = _aruco.Timer_n_set
    __swig_getmethods__["n"] = _aruco.Timer_n_get
    if _newclass:
        n = _swig_property(_aruco.Timer_n_get, _aruco.Timer_n_set)
    __swig_setmethods__["_name"] = _aruco.Timer__name_set
    __swig_getmethods__["_name"] = _aruco.Timer__name_get
    if _newclass:
        _name = _swig_property(_aruco.Timer__name_get, _aruco.Timer__name_set)

    def __init__(self, *args):
        this = _aruco.new_Timer(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def setName(self, name):
        return _aruco.Timer_setName(self, name)

    def start(self):
        return _aruco.Timer_start(self)

    def end(self):
        return _aruco.Timer_end(self)

    def _print(self, *args):
        return _aruco.Timer__print(self, *args)

    def getAverage(self, *args):
        return _aruco.Timer_getAverage(self, *args)
    __swig_destroy__ = _aruco.delete_Timer
    __del__ = lambda self: None
Timer_swigregister = _aruco.Timer_swigregister
Timer_swigregister(Timer)


def __pf_aruco_methodName(prettyFunction):
    return _aruco.__pf_aruco_methodName(prettyFunction)
__pf_aruco_methodName = _aruco.__pf_aruco_methodName
# This file is compatible with both classic and new-style classes.


