# This file was automatically generated by SWIG (http://www.swig.org).
# Version 3.0.3
#
# 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
if 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('_hsi', [dirname(__file__)])
        except ImportError:
            import _hsi
            return _hsi
        if fp is not None:
            try:
                _mod = imp.load_module('_hsi', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _hsi = swig_import_helper()
    del swig_import_helper
else:
    import _hsi
del version_info
try:
    _swig_property = property
except NameError:
    pass  # Python < 2.2 doesn't have 'property'.


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):
        object.__setattr__(self, 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_nondynamic(self, class_type, name, static=1):
    if (name == "thisown"):
        return self.this.own()
    method = class_type.__swig_getmethods__.get(name, None)
    if method:
        return method(self)
    if (not static):
        return object.__getattr__(self, name)
    else:
        raise AttributeError(name)

def _swig_getattr(self, class_type, name):
    return _swig_getattr_nondynamic(self, class_type, name, 0)


def _swig_repr(self):
    try:
        strthis = "proxy of " + self.this.__repr__()
    except:
        strthis = ""
    return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)

try:
    _object = object
    _newclass = 1
except AttributeError:
    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__ = _hsi.delete_SwigPyIterator
    __del__ = lambda self: None

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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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

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

class ios_base(_object):
    """Proxy of C++ std::ios_base class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ios_base, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ios_base, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    erase_event = _hsi.ios_base_erase_event
    imbue_event = _hsi.ios_base_imbue_event
    copyfmt_event = _hsi.ios_base_copyfmt_event

    def register_callback(self, __fn, __index):
        """register_callback(ios_base self, std::ios_base::event_callback __fn, int __index)"""
        return _hsi.ios_base_register_callback(self, __fn, __index)


    def flags(self, *args):
        """
        flags(ios_base self) -> std::ios_base::fmtflags
        flags(ios_base self, std::ios_base::fmtflags __fmtfl) -> std::ios_base::fmtflags
        """
        return _hsi.ios_base_flags(self, *args)


    def setf(self, *args):
        """
        setf(ios_base self, std::ios_base::fmtflags __fmtfl) -> std::ios_base::fmtflags
        setf(ios_base self, std::ios_base::fmtflags __fmtfl, std::ios_base::fmtflags __mask) -> std::ios_base::fmtflags
        """
        return _hsi.ios_base_setf(self, *args)


    def unsetf(self, __mask):
        """unsetf(ios_base self, std::ios_base::fmtflags __mask)"""
        return _hsi.ios_base_unsetf(self, __mask)


    def precision(self, *args):
        """
        precision(ios_base self) -> std::streamsize
        precision(ios_base self, std::streamsize __prec) -> std::streamsize
        """
        return _hsi.ios_base_precision(self, *args)


    def width(self, *args):
        """
        width(ios_base self) -> std::streamsize
        width(ios_base self, std::streamsize __wide) -> std::streamsize
        """
        return _hsi.ios_base_width(self, *args)


    def sync_with_stdio(__sync=True):
        """
        sync_with_stdio(bool __sync=True) -> bool
        sync_with_stdio() -> bool
        """
        return _hsi.ios_base_sync_with_stdio(__sync)

    if _newclass:
        sync_with_stdio = staticmethod(sync_with_stdio)
    __swig_getmethods__["sync_with_stdio"] = lambda x: sync_with_stdio

    def imbue(self, __loc):
        """imbue(ios_base self, std::locale const & __loc) -> std::locale"""
        return _hsi.ios_base_imbue(self, __loc)


    def getloc(self):
        """getloc(ios_base self) -> std::locale"""
        return _hsi.ios_base_getloc(self)


    def xalloc():
        """xalloc() -> int"""
        return _hsi.ios_base_xalloc()

    if _newclass:
        xalloc = staticmethod(xalloc)
    __swig_getmethods__["xalloc"] = lambda x: xalloc

    def iword(self, __ix):
        """iword(ios_base self, int __ix) -> long &"""
        return _hsi.ios_base_iword(self, __ix)


    def pword(self, __ix):
        """pword(ios_base self, int __ix) -> void *&"""
        return _hsi.ios_base_pword(self, __ix)

    __swig_destroy__ = _hsi.delete_ios_base
    __del__ = lambda self: None
ios_base_swigregister = _hsi.ios_base_swigregister
ios_base_swigregister(ios_base)
cvar = _hsi.cvar
ios_base.boolalpha = _hsi.cvar.ios_base_boolalpha
ios_base.dec = _hsi.cvar.ios_base_dec
ios_base.fixed = _hsi.cvar.ios_base_fixed
ios_base.hex = _hsi.cvar.ios_base_hex
ios_base.internal = _hsi.cvar.ios_base_internal
ios_base.left = _hsi.cvar.ios_base_left
ios_base.oct = _hsi.cvar.ios_base_oct
ios_base.right = _hsi.cvar.ios_base_right
ios_base.scientific = _hsi.cvar.ios_base_scientific
ios_base.showbase = _hsi.cvar.ios_base_showbase
ios_base.showpoint = _hsi.cvar.ios_base_showpoint
ios_base.showpos = _hsi.cvar.ios_base_showpos
ios_base.skipws = _hsi.cvar.ios_base_skipws
ios_base.unitbuf = _hsi.cvar.ios_base_unitbuf
ios_base.uppercase = _hsi.cvar.ios_base_uppercase
ios_base.adjustfield = _hsi.cvar.ios_base_adjustfield
ios_base.basefield = _hsi.cvar.ios_base_basefield
ios_base.floatfield = _hsi.cvar.ios_base_floatfield
ios_base.badbit = _hsi.cvar.ios_base_badbit
ios_base.eofbit = _hsi.cvar.ios_base_eofbit
ios_base.failbit = _hsi.cvar.ios_base_failbit
ios_base.goodbit = _hsi.cvar.ios_base_goodbit
ios_base.app = _hsi.cvar.ios_base_app
ios_base.ate = _hsi.cvar.ios_base_ate
ios_base.binary = _hsi.cvar.ios_base_binary
ios_base.ios_base_in = _hsi.cvar.ios_base_ios_base_in
ios_base.out = _hsi.cvar.ios_base_out
ios_base.trunc = _hsi.cvar.ios_base_trunc
ios_base.beg = _hsi.cvar.ios_base_beg
ios_base.cur = _hsi.cvar.ios_base_cur
ios_base.end = _hsi.cvar.ios_base_end

def ios_base_sync_with_stdio(__sync=True):
    """
    sync_with_stdio(bool __sync=True) -> bool
    ios_base_sync_with_stdio() -> bool
    """
    return _hsi.ios_base_sync_with_stdio(__sync)

def ios_base_xalloc():
    """ios_base_xalloc() -> int"""
    return _hsi.ios_base_xalloc()

class ios(ios_base):
    """Proxy of C++ std::basic_ios<(char)> class"""
    __swig_setmethods__ = {}
    for _s in [ios_base]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ios, name, value)
    __swig_getmethods__ = {}
    for _s in [ios_base]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ios, name)
    __repr__ = _swig_repr

    def rdstate(self):
        """rdstate(ios self) -> std::ios_base::iostate"""
        return _hsi.ios_rdstate(self)


    def clear(self, *args):
        """
        clear(ios self, std::ios_base::iostate __state)
        clear(ios self)
        """
        return _hsi.ios_clear(self, *args)


    def setstate(self, __state):
        """setstate(ios self, std::ios_base::iostate __state)"""
        return _hsi.ios_setstate(self, __state)


    def good(self):
        """good(ios self) -> bool"""
        return _hsi.ios_good(self)


    def eof(self):
        """eof(ios self) -> bool"""
        return _hsi.ios_eof(self)


    def fail(self):
        """fail(ios self) -> bool"""
        return _hsi.ios_fail(self)


    def bad(self):
        """bad(ios self) -> bool"""
        return _hsi.ios_bad(self)


    def exceptions(self, *args):
        """
        exceptions(ios self) -> std::ios_base::iostate
        exceptions(ios self, std::ios_base::iostate __except)
        """
        return _hsi.ios_exceptions(self, *args)


    def __init__(self, __sb):
        """__init__(std::basic_ios<(char)> self, std::basic_streambuf< char,std::char_traits< char > > * __sb) -> ios"""
        this = _hsi.new_ios(__sb)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _hsi.delete_ios
    __del__ = lambda self: None

    def tie(self, *args):
        """
        tie(ios self) -> ostream
        tie(ios self, ostream __tiestr) -> ostream
        """
        return _hsi.ios_tie(self, *args)


    def rdbuf(self, *args):
        """
        rdbuf(ios self) -> std::basic_streambuf< char,std::char_traits< char > >
        rdbuf(ios self, std::basic_streambuf< char,std::char_traits< char > > * __sb) -> std::basic_streambuf< char,std::char_traits< char > > *
        """
        return _hsi.ios_rdbuf(self, *args)


    def copyfmt(self, __rhs):
        """copyfmt(ios self, ios __rhs) -> ios"""
        return _hsi.ios_copyfmt(self, __rhs)


    def fill(self, *args):
        """
        fill(ios self) -> std::basic_ios< char >::char_type
        fill(ios self, std::basic_ios< char >::char_type __ch) -> std::basic_ios< char >::char_type
        """
        return _hsi.ios_fill(self, *args)


    def imbue(self, __loc):
        """imbue(ios self, std::locale const & __loc) -> std::locale"""
        return _hsi.ios_imbue(self, __loc)


    def narrow(self, __c, __dfault):
        """narrow(ios self, std::basic_ios< char >::char_type __c, char __dfault) -> char"""
        return _hsi.ios_narrow(self, __c, __dfault)


    def widen(self, __c):
        """widen(ios self, char __c) -> std::basic_ios< char >::char_type"""
        return _hsi.ios_widen(self, __c)

ios_swigregister = _hsi.ios_swigregister
ios_swigregister(ios)

class ostream(ios):
    """Proxy of C++ std::basic_ostream<(char)> class"""
    __swig_setmethods__ = {}
    for _s in [ios]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ostream, name, value)
    __swig_getmethods__ = {}
    for _s in [ios]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ostream, name)
    __repr__ = _swig_repr

    def __init__(self, __sb):
        """__init__(std::basic_ostream<(char)> self, std::basic_streambuf< char,std::char_traits< char > > * __sb) -> ostream"""
        this = _hsi.new_ostream(__sb)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _hsi.delete_ostream
    __del__ = lambda self: None

    def __lshift__(self, *args):
        """
        __lshift__(ostream self, std::basic_ostream< char,std::char_traits< char > > &(*)(std::basic_ostream< char,std::char_traits< char > > &) __pf) -> ostream
        __lshift__(ostream self, std::basic_ios< char,std::char_traits< char > > &(*)(std::basic_ios< char,std::char_traits< char > > &) __pf) -> ostream
        __lshift__(ostream self, std::ios_base &(*)(std::ios_base &) __pf) -> ostream
        __lshift__(ostream self, long __n) -> ostream
        __lshift__(ostream self, unsigned long __n) -> ostream
        __lshift__(ostream self, bool __n) -> ostream
        __lshift__(ostream self, short __n) -> ostream
        __lshift__(ostream self, unsigned short __n) -> ostream
        __lshift__(ostream self, int __n) -> ostream
        __lshift__(ostream self, unsigned int __n) -> ostream
        __lshift__(ostream self, long long __n) -> ostream
        __lshift__(ostream self, unsigned long long __n) -> ostream
        __lshift__(ostream self, double __f) -> ostream
        __lshift__(ostream self, float __f) -> ostream
        __lshift__(ostream self, long double __f) -> ostream
        __lshift__(ostream self, void const * __p) -> ostream
        __lshift__(ostream self, std::basic_streambuf< char,std::char_traits< char > > * __sb) -> ostream
        __lshift__(ostream self, std::basic_string< char,std::char_traits< char >,std::allocator< char > > const & s) -> ostream
        """
        return _hsi.ostream___lshift__(self, *args)


    def put(self, __c):
        """put(ostream self, std::basic_ostream< char >::char_type __c) -> ostream"""
        return _hsi.ostream_put(self, __c)


    def write(self, __s, __n):
        """write(ostream self, std::basic_ostream< char >::char_type const * __s, std::streamsize __n) -> ostream"""
        return _hsi.ostream_write(self, __s, __n)


    def flush(self):
        """flush(ostream self) -> ostream"""
        return _hsi.ostream_flush(self)


    def tellp(self):
        """tellp(ostream self) -> std::basic_ostream< char >::pos_type"""
        return _hsi.ostream_tellp(self)


    def seekp(self, *args):
        """
        seekp(ostream self, std::basic_ostream< char >::pos_type arg2) -> ostream
        seekp(ostream self, std::basic_ostream< char >::off_type arg2, std::ios_base::seekdir arg3) -> ostream
        """
        return _hsi.ostream_seekp(self, *args)

ostream_swigregister = _hsi.ostream_swigregister
ostream_swigregister(ostream)
cin = cvar.cin
cout = cvar.cout
cerr = cvar.cerr
clog = cvar.clog

class istream(ios):
    """Proxy of C++ std::basic_istream<(char)> class"""
    __swig_setmethods__ = {}
    for _s in [ios]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, istream, name, value)
    __swig_getmethods__ = {}
    for _s in [ios]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, istream, name)
    __repr__ = _swig_repr

    def __init__(self, __sb):
        """__init__(std::basic_istream<(char)> self, std::basic_streambuf< char,std::char_traits< char > > * __sb) -> istream"""
        this = _hsi.new_istream(__sb)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _hsi.delete_istream
    __del__ = lambda self: None

    def __rshift__(self, *args):
        """
        __rshift__(istream self, std::basic_istream< char,std::char_traits< char > > &(*)(std::basic_istream< char,std::char_traits< char > > &) __pf) -> istream
        __rshift__(istream self, std::basic_ios< char,std::char_traits< char > > &(*)(std::basic_ios< char,std::char_traits< char > > &) __pf) -> istream
        __rshift__(istream self, std::ios_base &(*)(std::ios_base &) __pf) -> istream
        __rshift__(istream self, bool & __n) -> istream
        __rshift__(istream self, short & __n) -> istream
        __rshift__(istream self, unsigned short & __n) -> istream
        __rshift__(istream self, int & __n) -> istream
        __rshift__(istream self, unsigned int & __n) -> istream
        __rshift__(istream self, long & __n) -> istream
        __rshift__(istream self, unsigned long & __n) -> istream
        __rshift__(istream self, long long & __n) -> istream
        __rshift__(istream self, unsigned long long & __n) -> istream
        __rshift__(istream self, float & __f) -> istream
        __rshift__(istream self, double & __f) -> istream
        __rshift__(istream self, long double & __f) -> istream
        __rshift__(istream self, void *& __p) -> istream
        __rshift__(istream self, std::basic_streambuf< char,std::char_traits< char > > * __sb) -> istream
        """
        return _hsi.istream___rshift__(self, *args)


    def gcount(self):
        """gcount(istream self) -> std::streamsize"""
        return _hsi.istream_gcount(self)


    def get(self, *args):
        """
        get(istream self) -> std::basic_istream< char >::int_type
        get(istream self, std::basic_istream< char >::char_type & __c) -> istream
        get(istream self, std::basic_istream< char >::char_type * __s, std::streamsize __n, std::basic_istream< char >::char_type __delim) -> istream
        get(istream self, std::basic_istream< char >::char_type * __s, std::streamsize __n) -> istream
        get(istream self, std::basic_streambuf< char,std::char_traits< char > > & __sb, std::basic_istream< char >::char_type __delim) -> istream
        get(istream self, std::basic_streambuf< char,std::char_traits< char > > & __sb) -> istream
        """
        return _hsi.istream_get(self, *args)


    def getline(self, *args):
        """
        getline(istream self, std::basic_istream< char >::char_type * __s, std::streamsize __n, std::basic_istream< char >::char_type __delim) -> istream
        getline(istream self, std::basic_istream< char >::char_type * __s, std::streamsize __n) -> istream
        """
        return _hsi.istream_getline(self, *args)


    def ignore(self, *args):
        """
        ignore(istream self, std::streamsize __n=1, std::basic_istream< char >::int_type __delim) -> istream
        ignore(istream self, std::streamsize __n=1) -> istream
        ignore(istream self) -> istream
        """
        return _hsi.istream_ignore(self, *args)


    def peek(self):
        """peek(istream self) -> std::basic_istream< char >::int_type"""
        return _hsi.istream_peek(self)


    def read(self, __s, __n):
        """read(istream self, std::basic_istream< char >::char_type * __s, std::streamsize __n) -> istream"""
        return _hsi.istream_read(self, __s, __n)


    def readsome(self, __s, __n):
        """readsome(istream self, std::basic_istream< char >::char_type * __s, std::streamsize __n) -> std::streamsize"""
        return _hsi.istream_readsome(self, __s, __n)


    def putback(self, __c):
        """putback(istream self, std::basic_istream< char >::char_type __c) -> istream"""
        return _hsi.istream_putback(self, __c)


    def unget(self):
        """unget(istream self) -> istream"""
        return _hsi.istream_unget(self)


    def sync(self):
        """sync(istream self) -> int"""
        return _hsi.istream_sync(self)


    def tellg(self):
        """tellg(istream self) -> std::basic_istream< char >::pos_type"""
        return _hsi.istream_tellg(self)


    def seekg(self, *args):
        """
        seekg(istream self, std::basic_istream< char >::pos_type arg2) -> istream
        seekg(istream self, std::basic_istream< char >::off_type arg2, std::ios_base::seekdir arg3) -> istream
        """
        return _hsi.istream_seekg(self, *args)

istream_swigregister = _hsi.istream_swigregister
istream_swigregister(istream)

class iostream(istream, ostream):
    """Proxy of C++ std::basic_iostream<(char)> class"""
    __swig_setmethods__ = {}
    for _s in [istream, ostream]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, iostream, name, value)
    __swig_getmethods__ = {}
    for _s in [istream, ostream]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, iostream, name)
    __repr__ = _swig_repr

    def __init__(self, __sb):
        """__init__(std::basic_iostream<(char)> self, std::basic_streambuf< char,std::char_traits< char > > * __sb) -> iostream"""
        this = _hsi.new_iostream(__sb)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _hsi.delete_iostream
    __del__ = lambda self: None
iostream_swigregister = _hsi.iostream_swigregister
iostream_swigregister(iostream)

endl_cb_ptr = _hsi.endl_cb_ptr

def endl(arg1):
    """endl(ostream arg1) -> ostream"""
    return _hsi.endl(arg1)
endl = _hsi.endl
ends_cb_ptr = _hsi.ends_cb_ptr

def ends(arg1):
    """ends(ostream arg1) -> ostream"""
    return _hsi.ends(arg1)
ends = _hsi.ends
flush_cb_ptr = _hsi.flush_cb_ptr

def flush(arg1):
    """flush(ostream arg1) -> ostream"""
    return _hsi.flush(arg1)
flush = _hsi.flush
class ifstream(istream):
    """Proxy of C++ std::ifstream class"""
    __swig_setmethods__ = {}
    for _s in [istream]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ifstream, name, value)
    __swig_getmethods__ = {}
    for _s in [istream]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ifstream, name)
    __repr__ = _swig_repr

    def __init__(self, filename):
        """__init__(std::ifstream self, char * filename) -> ifstream"""
        this = _hsi.new_ifstream(filename)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _hsi.delete_ifstream
    __del__ = lambda self: None
ifstream_swigregister = _hsi.ifstream_swigregister
ifstream_swigregister(ifstream)

class ofstream(ostream):
    """Proxy of C++ std::ofstream class"""
    __swig_setmethods__ = {}
    for _s in [ostream]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofstream, name, value)
    __swig_getmethods__ = {}
    for _s in [ostream]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ofstream, name)
    __repr__ = _swig_repr

    def __init__(self, filename):
        """__init__(std::ofstream self, char * filename) -> ofstream"""
        this = _hsi.new_ofstream(filename)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _hsi.delete_ofstream
    __del__ = lambda self: None
ofstream_swigregister = _hsi.ofstream_swigregister
ofstream_swigregister(ofstream)

class UIntVector(_object):
    """Proxy of C++ vector<(unsigned int)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, UIntVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, UIntVector, name)
    __repr__ = _swig_repr

    def iterator(self):
        """iterator(UIntVector self) -> SwigPyIterator"""
        return _hsi.UIntVector_iterator(self)

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

    def __nonzero__(self):
        """__nonzero__(UIntVector self) -> bool"""
        return _hsi.UIntVector___nonzero__(self)


    def __bool__(self):
        """__bool__(UIntVector self) -> bool"""
        return _hsi.UIntVector___bool__(self)


    def __len__(self):
        """__len__(UIntVector self) -> vector< unsigned int >::size_type"""
        return _hsi.UIntVector___len__(self)


    def pop(self):
        """pop(UIntVector self) -> vector< unsigned int >::value_type"""
        return _hsi.UIntVector_pop(self)


    def __getslice__(self, i, j):
        """__getslice__(UIntVector self, vector< unsigned int >::difference_type i, vector< unsigned int >::difference_type j) -> std::vector< unsigned int,std::allocator< unsigned int > > *"""
        return _hsi.UIntVector___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(UIntVector self, vector< unsigned int >::difference_type i, vector< unsigned int >::difference_type j, std::vector< unsigned int,std::allocator< unsigned int > > const & v)
        __setslice__(UIntVector self, vector< unsigned int >::difference_type i, vector< unsigned int >::difference_type j)
        """
        return _hsi.UIntVector___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(UIntVector self, vector< unsigned int >::difference_type i, vector< unsigned int >::difference_type j)"""
        return _hsi.UIntVector___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(UIntVector self, vector< unsigned int >::difference_type i)
        __delitem__(UIntVector self, PySliceObject * slice)
        """
        return _hsi.UIntVector___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(UIntVector self, PySliceObject * slice) -> std::vector< unsigned int,std::allocator< unsigned int > >
        __getitem__(UIntVector self, vector< unsigned int >::difference_type i) -> vector< unsigned int >::value_type const &
        """
        return _hsi.UIntVector___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(UIntVector self, PySliceObject * slice, std::vector< unsigned int,std::allocator< unsigned int > > const & v)
        __setitem__(UIntVector self, PySliceObject * slice)
        __setitem__(UIntVector self, vector< unsigned int >::difference_type i, vector< unsigned int >::value_type const & x)
        """
        return _hsi.UIntVector___setitem__(self, *args)


    def append(self, x):
        """append(UIntVector self, vector< unsigned int >::value_type const & x)"""
        return _hsi.UIntVector_append(self, x)


    def empty(self):
        """empty(UIntVector self) -> bool"""
        return _hsi.UIntVector_empty(self)


    def size(self):
        """size(UIntVector self) -> vector< unsigned int >::size_type"""
        return _hsi.UIntVector_size(self)


    def clear(self):
        """clear(UIntVector self)"""
        return _hsi.UIntVector_clear(self)


    def swap(self, v):
        """swap(UIntVector self, UIntVector v)"""
        return _hsi.UIntVector_swap(self, v)


    def get_allocator(self):
        """get_allocator(UIntVector self) -> vector< unsigned int >::allocator_type"""
        return _hsi.UIntVector_get_allocator(self)


    def begin(self):
        """begin(UIntVector self) -> vector< unsigned int >::iterator"""
        return _hsi.UIntVector_begin(self)


    def end(self):
        """end(UIntVector self) -> vector< unsigned int >::iterator"""
        return _hsi.UIntVector_end(self)


    def rbegin(self):
        """rbegin(UIntVector self) -> vector< unsigned int >::reverse_iterator"""
        return _hsi.UIntVector_rbegin(self)


    def rend(self):
        """rend(UIntVector self) -> vector< unsigned int >::reverse_iterator"""
        return _hsi.UIntVector_rend(self)


    def pop_back(self):
        """pop_back(UIntVector self)"""
        return _hsi.UIntVector_pop_back(self)


    def erase(self, *args):
        """
        erase(UIntVector self, vector< unsigned int >::iterator pos) -> vector< unsigned int >::iterator
        erase(UIntVector self, vector< unsigned int >::iterator first, vector< unsigned int >::iterator last) -> vector< unsigned int >::iterator
        """
        return _hsi.UIntVector_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(vector<(unsigned int)> self) -> UIntVector
        __init__(vector<(unsigned int)> self, UIntVector arg2) -> UIntVector
        __init__(vector<(unsigned int)> self, vector< unsigned int >::size_type size) -> UIntVector
        __init__(vector<(unsigned int)> self, vector< unsigned int >::size_type size, vector< unsigned int >::value_type const & value) -> UIntVector
        """
        this = _hsi.new_UIntVector(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def push_back(self, x):
        """push_back(UIntVector self, vector< unsigned int >::value_type const & x)"""
        return _hsi.UIntVector_push_back(self, x)


    def front(self):
        """front(UIntVector self) -> vector< unsigned int >::value_type const &"""
        return _hsi.UIntVector_front(self)


    def back(self):
        """back(UIntVector self) -> vector< unsigned int >::value_type const &"""
        return _hsi.UIntVector_back(self)


    def assign(self, n, x):
        """assign(UIntVector self, vector< unsigned int >::size_type n, vector< unsigned int >::value_type const & x)"""
        return _hsi.UIntVector_assign(self, n, x)


    def resize(self, *args):
        """
        resize(UIntVector self, vector< unsigned int >::size_type new_size)
        resize(UIntVector self, vector< unsigned int >::size_type new_size, vector< unsigned int >::value_type const & x)
        """
        return _hsi.UIntVector_resize(self, *args)


    def insert(self, *args):
        """
        insert(UIntVector self, vector< unsigned int >::iterator pos, vector< unsigned int >::value_type const & x) -> vector< unsigned int >::iterator
        insert(UIntVector self, vector< unsigned int >::iterator pos, vector< unsigned int >::size_type n, vector< unsigned int >::value_type const & x)
        """
        return _hsi.UIntVector_insert(self, *args)


    def reserve(self, n):
        """reserve(UIntVector self, vector< unsigned int >::size_type n)"""
        return _hsi.UIntVector_reserve(self, n)


    def capacity(self):
        """capacity(UIntVector self) -> vector< unsigned int >::size_type"""
        return _hsi.UIntVector_capacity(self)

    __swig_destroy__ = _hsi.delete_UIntVector
    __del__ = lambda self: None
UIntVector_swigregister = _hsi.UIntVector_swigregister
UIntVector_swigregister(UIntVector)

class UIntSet(_object):
    """Proxy of C++ set<(unsigned int)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, UIntSet, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, UIntSet, name)
    __repr__ = _swig_repr

    def iterator(self):
        """iterator(UIntSet self) -> SwigPyIterator"""
        return _hsi.UIntSet_iterator(self)

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

    def __nonzero__(self):
        """__nonzero__(UIntSet self) -> bool"""
        return _hsi.UIntSet___nonzero__(self)


    def __bool__(self):
        """__bool__(UIntSet self) -> bool"""
        return _hsi.UIntSet___bool__(self)


    def __len__(self):
        """__len__(UIntSet self) -> set< unsigned int >::size_type"""
        return _hsi.UIntSet___len__(self)


    def append(self, x):
        """append(UIntSet self, set< unsigned int >::value_type x)"""
        return _hsi.UIntSet_append(self, x)


    def __contains__(self, x):
        """__contains__(UIntSet self, set< unsigned int >::value_type x) -> bool"""
        return _hsi.UIntSet___contains__(self, x)


    def __getitem__(self, i):
        """__getitem__(UIntSet self, set< unsigned int >::difference_type i) -> set< unsigned int >::value_type"""
        return _hsi.UIntSet___getitem__(self, i)


    def add(self, x):
        """add(UIntSet self, set< unsigned int >::value_type x)"""
        return _hsi.UIntSet_add(self, x)


    def discard(self, x):
        """discard(UIntSet self, set< unsigned int >::value_type x)"""
        return _hsi.UIntSet_discard(self, x)


    def __init__(self, *args):
        """
        __init__(set<(unsigned int)> self, std::less< unsigned int > const & arg2) -> UIntSet
        __init__(set<(unsigned int)> self) -> UIntSet
        __init__(set<(unsigned int)> self, UIntSet arg2) -> UIntSet
        """
        this = _hsi.new_UIntSet(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def empty(self):
        """empty(UIntSet self) -> bool"""
        return _hsi.UIntSet_empty(self)


    def size(self):
        """size(UIntSet self) -> set< unsigned int >::size_type"""
        return _hsi.UIntSet_size(self)


    def clear(self):
        """clear(UIntSet self)"""
        return _hsi.UIntSet_clear(self)


    def swap(self, v):
        """swap(UIntSet self, UIntSet v)"""
        return _hsi.UIntSet_swap(self, v)


    def count(self, x):
        """count(UIntSet self, set< unsigned int >::key_type const & x) -> set< unsigned int >::size_type"""
        return _hsi.UIntSet_count(self, x)


    def begin(self):
        """begin(UIntSet self) -> set< unsigned int >::iterator"""
        return _hsi.UIntSet_begin(self)


    def end(self):
        """end(UIntSet self) -> set< unsigned int >::iterator"""
        return _hsi.UIntSet_end(self)


    def rbegin(self):
        """rbegin(UIntSet self) -> set< unsigned int >::reverse_iterator"""
        return _hsi.UIntSet_rbegin(self)


    def rend(self):
        """rend(UIntSet self) -> set< unsigned int >::reverse_iterator"""
        return _hsi.UIntSet_rend(self)


    def erase(self, *args):
        """
        erase(UIntSet self, set< unsigned int >::key_type const & x) -> set< unsigned int >::size_type
        erase(UIntSet self, set< unsigned int >::iterator pos)
        erase(UIntSet self, set< unsigned int >::iterator first, set< unsigned int >::iterator last)
        """
        return _hsi.UIntSet_erase(self, *args)


    def find(self, x):
        """find(UIntSet self, set< unsigned int >::key_type const & x) -> set< unsigned int >::iterator"""
        return _hsi.UIntSet_find(self, x)


    def lower_bound(self, x):
        """lower_bound(UIntSet self, set< unsigned int >::key_type const & x) -> set< unsigned int >::iterator"""
        return _hsi.UIntSet_lower_bound(self, x)


    def upper_bound(self, x):
        """upper_bound(UIntSet self, set< unsigned int >::key_type const & x) -> set< unsigned int >::iterator"""
        return _hsi.UIntSet_upper_bound(self, x)


    def equal_range(self, x):
        """equal_range(UIntSet self, set< unsigned int >::key_type const & x) -> std::pair< set< unsigned int >::iterator,set< unsigned int >::iterator >"""
        return _hsi.UIntSet_equal_range(self, x)


    def insert(self, __x):
        """insert(UIntSet self, set< unsigned int >::value_type const & __x) -> std::pair< set< unsigned int >::iterator,bool >"""
        return _hsi.UIntSet_insert(self, __x)

    __swig_destroy__ = _hsi.delete_UIntSet
    __del__ = lambda self: None
UIntSet_swigregister = _hsi.UIntSet_swigregister
UIntSet_swigregister(UIntSet)

class DoubleVector(_object):
    """Proxy of C++ vector<(double)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, DoubleVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, DoubleVector, name)
    __repr__ = _swig_repr

    def iterator(self):
        """iterator(DoubleVector self) -> SwigPyIterator"""
        return _hsi.DoubleVector_iterator(self)

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

    def __nonzero__(self):
        """__nonzero__(DoubleVector self) -> bool"""
        return _hsi.DoubleVector___nonzero__(self)


    def __bool__(self):
        """__bool__(DoubleVector self) -> bool"""
        return _hsi.DoubleVector___bool__(self)


    def __len__(self):
        """__len__(DoubleVector self) -> vector< double >::size_type"""
        return _hsi.DoubleVector___len__(self)


    def pop(self):
        """pop(DoubleVector self) -> vector< double >::value_type"""
        return _hsi.DoubleVector_pop(self)


    def __getslice__(self, i, j):
        """__getslice__(DoubleVector self, vector< double >::difference_type i, vector< double >::difference_type j) -> std::vector< double,std::allocator< double > > *"""
        return _hsi.DoubleVector___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(DoubleVector self, vector< double >::difference_type i, vector< double >::difference_type j, std::vector< double,std::allocator< double > > const & v)
        __setslice__(DoubleVector self, vector< double >::difference_type i, vector< double >::difference_type j)
        """
        return _hsi.DoubleVector___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(DoubleVector self, vector< double >::difference_type i, vector< double >::difference_type j)"""
        return _hsi.DoubleVector___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(DoubleVector self, vector< double >::difference_type i)
        __delitem__(DoubleVector self, PySliceObject * slice)
        """
        return _hsi.DoubleVector___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(DoubleVector self, PySliceObject * slice) -> std::vector< double,std::allocator< double > >
        __getitem__(DoubleVector self, vector< double >::difference_type i) -> vector< double >::value_type const &
        """
        return _hsi.DoubleVector___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(DoubleVector self, PySliceObject * slice, std::vector< double,std::allocator< double > > const & v)
        __setitem__(DoubleVector self, PySliceObject * slice)
        __setitem__(DoubleVector self, vector< double >::difference_type i, vector< double >::value_type const & x)
        """
        return _hsi.DoubleVector___setitem__(self, *args)


    def append(self, x):
        """append(DoubleVector self, vector< double >::value_type const & x)"""
        return _hsi.DoubleVector_append(self, x)


    def empty(self):
        """empty(DoubleVector self) -> bool"""
        return _hsi.DoubleVector_empty(self)


    def size(self):
        """size(DoubleVector self) -> vector< double >::size_type"""
        return _hsi.DoubleVector_size(self)


    def clear(self):
        """clear(DoubleVector self)"""
        return _hsi.DoubleVector_clear(self)


    def swap(self, v):
        """swap(DoubleVector self, DoubleVector v)"""
        return _hsi.DoubleVector_swap(self, v)


    def get_allocator(self):
        """get_allocator(DoubleVector self) -> vector< double >::allocator_type"""
        return _hsi.DoubleVector_get_allocator(self)


    def begin(self):
        """begin(DoubleVector self) -> vector< double >::iterator"""
        return _hsi.DoubleVector_begin(self)


    def end(self):
        """end(DoubleVector self) -> vector< double >::iterator"""
        return _hsi.DoubleVector_end(self)


    def rbegin(self):
        """rbegin(DoubleVector self) -> vector< double >::reverse_iterator"""
        return _hsi.DoubleVector_rbegin(self)


    def rend(self):
        """rend(DoubleVector self) -> vector< double >::reverse_iterator"""
        return _hsi.DoubleVector_rend(self)


    def pop_back(self):
        """pop_back(DoubleVector self)"""
        return _hsi.DoubleVector_pop_back(self)


    def erase(self, *args):
        """
        erase(DoubleVector self, vector< double >::iterator pos) -> vector< double >::iterator
        erase(DoubleVector self, vector< double >::iterator first, vector< double >::iterator last) -> vector< double >::iterator
        """
        return _hsi.DoubleVector_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(vector<(double)> self) -> DoubleVector
        __init__(vector<(double)> self, DoubleVector arg2) -> DoubleVector
        __init__(vector<(double)> self, vector< double >::size_type size) -> DoubleVector
        __init__(vector<(double)> self, vector< double >::size_type size, vector< double >::value_type const & value) -> DoubleVector
        """
        this = _hsi.new_DoubleVector(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def push_back(self, x):
        """push_back(DoubleVector self, vector< double >::value_type const & x)"""
        return _hsi.DoubleVector_push_back(self, x)


    def front(self):
        """front(DoubleVector self) -> vector< double >::value_type const &"""
        return _hsi.DoubleVector_front(self)


    def back(self):
        """back(DoubleVector self) -> vector< double >::value_type const &"""
        return _hsi.DoubleVector_back(self)


    def assign(self, n, x):
        """assign(DoubleVector self, vector< double >::size_type n, vector< double >::value_type const & x)"""
        return _hsi.DoubleVector_assign(self, n, x)


    def resize(self, *args):
        """
        resize(DoubleVector self, vector< double >::size_type new_size)
        resize(DoubleVector self, vector< double >::size_type new_size, vector< double >::value_type const & x)
        """
        return _hsi.DoubleVector_resize(self, *args)


    def insert(self, *args):
        """
        insert(DoubleVector self, vector< double >::iterator pos, vector< double >::value_type const & x) -> vector< double >::iterator
        insert(DoubleVector self, vector< double >::iterator pos, vector< double >::size_type n, vector< double >::value_type const & x)
        """
        return _hsi.DoubleVector_insert(self, *args)


    def reserve(self, n):
        """reserve(DoubleVector self, vector< double >::size_type n)"""
        return _hsi.DoubleVector_reserve(self, n)


    def capacity(self):
        """capacity(DoubleVector self) -> vector< double >::size_type"""
        return _hsi.DoubleVector_capacity(self)

    __swig_destroy__ = _hsi.delete_DoubleVector
    __del__ = lambda self: None
DoubleVector_swigregister = _hsi.DoubleVector_swigregister
DoubleVector_swigregister(DoubleVector)

class Size2D(_object):
    """Proxy of C++ vigra::Size2D class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Size2D, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Size2D, name)
    __repr__ = _swig_repr
    __swig_setmethods__["x"] = _hsi.Size2D_x_set
    __swig_getmethods__["x"] = _hsi.Size2D_x_get
    if _newclass:
        x = _swig_property(_hsi.Size2D_x_get, _hsi.Size2D_x_set)
    __swig_setmethods__["y"] = _hsi.Size2D_y_set
    __swig_getmethods__["y"] = _hsi.Size2D_y_get
    if _newclass:
        y = _swig_property(_hsi.Size2D_y_get, _hsi.Size2D_y_set)

    def __init__(self, *args):
        """
        __init__(vigra::Size2D self) -> Size2D
        __init__(vigra::Size2D self, int ix, int iy) -> Size2D
        """
        this = _hsi.new_Size2D(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def width(self):
        """width(Size2D self) -> int"""
        return _hsi.Size2D_width(self)


    def height(self):
        """height(Size2D self) -> int"""
        return _hsi.Size2D_height(self)


    def setWidth(self, w):
        """setWidth(Size2D self, int w)"""
        return _hsi.Size2D_setWidth(self, w)


    def setHeight(self, h):
        """setHeight(Size2D self, int h)"""
        return _hsi.Size2D_setHeight(self, h)

    __swig_destroy__ = _hsi.delete_Size2D
    __del__ = lambda self: None
Size2D_swigregister = _hsi.Size2D_swigregister
Size2D_swigregister(Size2D)

class Point2D(_object):
    """Proxy of C++ vigra::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__["x"] = _hsi.Point2D_x_set
    __swig_getmethods__["x"] = _hsi.Point2D_x_get
    if _newclass:
        x = _swig_property(_hsi.Point2D_x_get, _hsi.Point2D_x_set)
    __swig_setmethods__["y"] = _hsi.Point2D_y_set
    __swig_getmethods__["y"] = _hsi.Point2D_y_get
    if _newclass:
        y = _swig_property(_hsi.Point2D_y_get, _hsi.Point2D_y_set)

    def __init__(self, *args):
        """
        __init__(vigra::Point2D self) -> Point2D
        __init__(vigra::Point2D self, int ix, int iy) -> Point2D
        """
        this = _hsi.new_Point2D(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _hsi.delete_Point2D
    __del__ = lambda self: None
Point2D_swigregister = _hsi.Point2D_swigregister
Point2D_swigregister(Point2D)

class Rect2D(_object):
    """Proxy of C++ vigra::Rect2D class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Rect2D, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Rect2D, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(vigra::Rect2D self) -> Rect2D
        __init__(vigra::Rect2D self, int l, int t, int r, int b) -> Rect2D
        """
        this = _hsi.new_Rect2D(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def upperLeft(self):
        """upperLeft(Rect2D self) -> Point2D"""
        return _hsi.Rect2D_upperLeft(self)


    def lowerRight(self):
        """lowerRight(Rect2D self) -> Point2D"""
        return _hsi.Rect2D_lowerRight(self)


    def left(self):
        """left(Rect2D self) -> int"""
        return _hsi.Rect2D_left(self)


    def top(self):
        """top(Rect2D self) -> int"""
        return _hsi.Rect2D_top(self)


    def right(self):
        """right(Rect2D self) -> int"""
        return _hsi.Rect2D_right(self)


    def bottom(self):
        """bottom(Rect2D self) -> int"""
        return _hsi.Rect2D_bottom(self)


    def width(self):
        """width(Rect2D self) -> int"""
        return _hsi.Rect2D_width(self)


    def height(self):
        """height(Rect2D self) -> int"""
        return _hsi.Rect2D_height(self)

    __swig_destroy__ = _hsi.delete_Rect2D
    __del__ = lambda self: None
Rect2D_swigregister = _hsi.Rect2D_swigregister
Rect2D_swigregister(Rect2D)

class FDiff2D(_object):
    """Proxy of C++ hugin_utils::FDiff2D class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, FDiff2D, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, FDiff2D, name)
    __repr__ = _swig_repr
    __swig_setmethods__["x"] = _hsi.FDiff2D_x_set
    __swig_getmethods__["x"] = _hsi.FDiff2D_x_get
    if _newclass:
        x = _swig_property(_hsi.FDiff2D_x_get, _hsi.FDiff2D_x_set)
    __swig_setmethods__["y"] = _hsi.FDiff2D_y_set
    __swig_getmethods__["y"] = _hsi.FDiff2D_y_get
    if _newclass:
        y = _swig_property(_hsi.FDiff2D_y_get, _hsi.FDiff2D_y_set)

    def __init__(self, *args):
        """
        __init__(hugin_utils::FDiff2D self) -> FDiff2D
        __init__(hugin_utils::FDiff2D self, double ix, double iy) -> FDiff2D
        """
        this = _hsi.new_FDiff2D(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _hsi.delete_FDiff2D
    __del__ = lambda self: None
FDiff2D_swigregister = _hsi.FDiff2D_swigregister
FDiff2D_swigregister(FDiff2D)

class tm(_object):
    """Proxy of C++ tm class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, tm, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, tm, name)
    __repr__ = _swig_repr
    __swig_setmethods__["tm_sec"] = _hsi.tm_tm_sec_set
    __swig_getmethods__["tm_sec"] = _hsi.tm_tm_sec_get
    if _newclass:
        tm_sec = _swig_property(_hsi.tm_tm_sec_get, _hsi.tm_tm_sec_set)
    __swig_setmethods__["tm_min"] = _hsi.tm_tm_min_set
    __swig_getmethods__["tm_min"] = _hsi.tm_tm_min_get
    if _newclass:
        tm_min = _swig_property(_hsi.tm_tm_min_get, _hsi.tm_tm_min_set)
    __swig_setmethods__["tm_hour"] = _hsi.tm_tm_hour_set
    __swig_getmethods__["tm_hour"] = _hsi.tm_tm_hour_get
    if _newclass:
        tm_hour = _swig_property(_hsi.tm_tm_hour_get, _hsi.tm_tm_hour_set)
    __swig_setmethods__["tm_mday"] = _hsi.tm_tm_mday_set
    __swig_getmethods__["tm_mday"] = _hsi.tm_tm_mday_get
    if _newclass:
        tm_mday = _swig_property(_hsi.tm_tm_mday_get, _hsi.tm_tm_mday_set)
    __swig_setmethods__["tm_mon"] = _hsi.tm_tm_mon_set
    __swig_getmethods__["tm_mon"] = _hsi.tm_tm_mon_get
    if _newclass:
        tm_mon = _swig_property(_hsi.tm_tm_mon_get, _hsi.tm_tm_mon_set)
    __swig_setmethods__["tm_year"] = _hsi.tm_tm_year_set
    __swig_getmethods__["tm_year"] = _hsi.tm_tm_year_get
    if _newclass:
        tm_year = _swig_property(_hsi.tm_tm_year_get, _hsi.tm_tm_year_set)
    __swig_setmethods__["tm_wday"] = _hsi.tm_tm_wday_set
    __swig_getmethods__["tm_wday"] = _hsi.tm_tm_wday_get
    if _newclass:
        tm_wday = _swig_property(_hsi.tm_tm_wday_get, _hsi.tm_tm_wday_set)
    __swig_setmethods__["tm_yday"] = _hsi.tm_tm_yday_set
    __swig_getmethods__["tm_yday"] = _hsi.tm_tm_yday_get
    if _newclass:
        tm_yday = _swig_property(_hsi.tm_tm_yday_get, _hsi.tm_tm_yday_set)
    __swig_setmethods__["tm_isdst"] = _hsi.tm_tm_isdst_set
    __swig_getmethods__["tm_isdst"] = _hsi.tm_tm_isdst_get
    if _newclass:
        tm_isdst = _swig_property(_hsi.tm_tm_isdst_get, _hsi.tm_tm_isdst_set)

    def __init__(self):
        """__init__(tm self) -> tm"""
        this = _hsi.new_tm()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _hsi.delete_tm
    __del__ = lambda self: None
tm_swigregister = _hsi.tm_swigregister
tm_swigregister(tm)

class DocumentData(_object):
    """Proxy of C++ AppBase::DocumentData class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, DocumentData, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, DocumentData, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _hsi.delete_DocumentData
    __del__ = lambda self: None
    SUCCESSFUL = _hsi.DocumentData_SUCCESSFUL
    UNKNOWN_ERROR = _hsi.DocumentData_UNKNOWN_ERROR
    INCOMPATIBLE_TYPE = _hsi.DocumentData_INCOMPATIBLE_TYPE
    INVALID_DATA = _hsi.DocumentData_INVALID_DATA
    PARCER_ERROR = _hsi.DocumentData_PARCER_ERROR

    def readData(self, dataInput, documentType=""):
        """
        readData(DocumentData self, istream dataInput, std::string documentType="") -> AppBase::DocumentData::ReadWriteError
        readData(DocumentData self, istream dataInput) -> AppBase::DocumentData::ReadWriteError
        """
        return _hsi.DocumentData_readData(self, dataInput, documentType)


    def writeData(self, dataOutput, documentType=""):
        """
        writeData(DocumentData self, ostream dataOutput, std::string documentType="") -> AppBase::DocumentData::ReadWriteError
        writeData(DocumentData self, ostream dataOutput) -> AppBase::DocumentData::ReadWriteError
        """
        return _hsi.DocumentData_writeData(self, dataOutput, documentType)


    def isDirty(self):
        """isDirty(DocumentData self) -> bool"""
        return _hsi.DocumentData_isDirty(self)


    def clearDirty(self):
        """clearDirty(DocumentData self)"""
        return _hsi.DocumentData_clearDirty(self)

DocumentData_swigregister = _hsi.DocumentData_swigregister
DocumentData_swigregister(DocumentData)

class PanoramaData(_object):
    """Proxy of C++ HuginBase::PanoramaData class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, PanoramaData, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, PanoramaData, name)

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

    def getNewSubset(self, imgs):
        """getNewSubset(PanoramaData self, HuginBase::UIntSet const & imgs) -> PanoramaData"""
        return _hsi.PanoramaData_getNewSubset(self, imgs)


    def getNewCopy(self):
        """getNewCopy(PanoramaData self) -> PanoramaData"""
        return _hsi.PanoramaData_getNewCopy(self)


    def getNrOfImages(self):
        """getNrOfImages(PanoramaData self) -> std::size_t"""
        return _hsi.PanoramaData_getNrOfImages(self)


    def getImage(self, nr):
        """getImage(PanoramaData self, std::size_t nr) -> SrcPanoImage"""
        return _hsi.PanoramaData_getImage(self, nr)


    def setImage(self, nr, img):
        """setImage(PanoramaData self, std::size_t nr, SrcPanoImage img)"""
        return _hsi.PanoramaData_setImage(self, nr, img)


    def addImage(self, img):
        """addImage(PanoramaData self, SrcPanoImage img) -> unsigned int"""
        return _hsi.PanoramaData_addImage(self, img)


    def removeImage(self, nr):
        """removeImage(PanoramaData self, unsigned int nr)"""
        return _hsi.PanoramaData_removeImage(self, nr)


    def swapImages(self, img1, img2):
        """swapImages(PanoramaData self, unsigned int img1, unsigned int img2)"""
        return _hsi.PanoramaData_swapImages(self, img1, img2)


    def moveImage(self, img1, img2):
        """moveImage(PanoramaData self, size_t img1, size_t img2)"""
        return _hsi.PanoramaData_moveImage(self, img1, img2)


    def getSrcImage(self, imgNr):
        """getSrcImage(PanoramaData self, unsigned int imgNr) -> SrcPanoImage"""
        return _hsi.PanoramaData_getSrcImage(self, imgNr)


    def setSrcImage(self, nr, img):
        """setSrcImage(PanoramaData self, unsigned int nr, SrcPanoImage img)"""
        return _hsi.PanoramaData_setSrcImage(self, nr, img)


    def setImageFilename(self, img, fname):
        """setImageFilename(PanoramaData self, unsigned int img, std::string const & fname)"""
        return _hsi.PanoramaData_setImageFilename(self, img, fname)


    def activateImage(self, imgNr, active=True):
        """
        activateImage(PanoramaData self, unsigned int imgNr, bool active=True)
        activateImage(PanoramaData self, unsigned int imgNr)
        """
        return _hsi.PanoramaData_activateImage(self, imgNr, active)


    def getActiveImages(self):
        """getActiveImages(PanoramaData self) -> HuginBase::UIntSet"""
        return _hsi.PanoramaData_getActiveImages(self)


    def linkImageVariableFilename(self, sourceImgNr, destImgNr):
        """linkImageVariableFilename(PanoramaData self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.PanoramaData_linkImageVariableFilename(self, sourceImgNr, destImgNr)


    def linkImageVariableSize(self, sourceImgNr, destImgNr):
        """linkImageVariableSize(PanoramaData self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.PanoramaData_linkImageVariableSize(self, sourceImgNr, destImgNr)


    def linkImageVariableProjection(self, sourceImgNr, destImgNr):
        """linkImageVariableProjection(PanoramaData self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.PanoramaData_linkImageVariableProjection(self, sourceImgNr, destImgNr)


    def linkImageVariableHFOV(self, sourceImgNr, destImgNr):
        """linkImageVariableHFOV(PanoramaData self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.PanoramaData_linkImageVariableHFOV(self, sourceImgNr, destImgNr)


    def linkImageVariableCropFactor(self, sourceImgNr, destImgNr):
        """linkImageVariableCropFactor(PanoramaData self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.PanoramaData_linkImageVariableCropFactor(self, sourceImgNr, destImgNr)


    def linkImageVariableResponseType(self, sourceImgNr, destImgNr):
        """linkImageVariableResponseType(PanoramaData self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.PanoramaData_linkImageVariableResponseType(self, sourceImgNr, destImgNr)


    def linkImageVariableEMoRParams(self, sourceImgNr, destImgNr):
        """linkImageVariableEMoRParams(PanoramaData self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.PanoramaData_linkImageVariableEMoRParams(self, sourceImgNr, destImgNr)


    def linkImageVariableExposureValue(self, sourceImgNr, destImgNr):
        """linkImageVariableExposureValue(PanoramaData self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.PanoramaData_linkImageVariableExposureValue(self, sourceImgNr, destImgNr)


    def linkImageVariableGamma(self, sourceImgNr, destImgNr):
        """linkImageVariableGamma(PanoramaData self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.PanoramaData_linkImageVariableGamma(self, sourceImgNr, destImgNr)


    def linkImageVariableWhiteBalanceRed(self, sourceImgNr, destImgNr):
        """linkImageVariableWhiteBalanceRed(PanoramaData self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.PanoramaData_linkImageVariableWhiteBalanceRed(self, sourceImgNr, destImgNr)


    def linkImageVariableWhiteBalanceBlue(self, sourceImgNr, destImgNr):
        """linkImageVariableWhiteBalanceBlue(PanoramaData self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.PanoramaData_linkImageVariableWhiteBalanceBlue(self, sourceImgNr, destImgNr)


    def linkImageVariableRoll(self, sourceImgNr, destImgNr):
        """linkImageVariableRoll(PanoramaData self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.PanoramaData_linkImageVariableRoll(self, sourceImgNr, destImgNr)


    def linkImageVariablePitch(self, sourceImgNr, destImgNr):
        """linkImageVariablePitch(PanoramaData self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.PanoramaData_linkImageVariablePitch(self, sourceImgNr, destImgNr)


    def linkImageVariableYaw(self, sourceImgNr, destImgNr):
        """linkImageVariableYaw(PanoramaData self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.PanoramaData_linkImageVariableYaw(self, sourceImgNr, destImgNr)


    def linkImageVariableX(self, sourceImgNr, destImgNr):
        """linkImageVariableX(PanoramaData self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.PanoramaData_linkImageVariableX(self, sourceImgNr, destImgNr)


    def linkImageVariableY(self, sourceImgNr, destImgNr):
        """linkImageVariableY(PanoramaData self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.PanoramaData_linkImageVariableY(self, sourceImgNr, destImgNr)


    def linkImageVariableZ(self, sourceImgNr, destImgNr):
        """linkImageVariableZ(PanoramaData self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.PanoramaData_linkImageVariableZ(self, sourceImgNr, destImgNr)


    def linkImageVariableTranslationPlaneYaw(self, sourceImgNr, destImgNr):
        """linkImageVariableTranslationPlaneYaw(PanoramaData self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.PanoramaData_linkImageVariableTranslationPlaneYaw(self, sourceImgNr, destImgNr)


    def linkImageVariableTranslationPlanePitch(self, sourceImgNr, destImgNr):
        """linkImageVariableTranslationPlanePitch(PanoramaData self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.PanoramaData_linkImageVariableTranslationPlanePitch(self, sourceImgNr, destImgNr)


    def linkImageVariableStack(self, sourceImgNr, destImgNr):
        """linkImageVariableStack(PanoramaData self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.PanoramaData_linkImageVariableStack(self, sourceImgNr, destImgNr)


    def linkImageVariableRadialDistortion(self, sourceImgNr, destImgNr):
        """linkImageVariableRadialDistortion(PanoramaData self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.PanoramaData_linkImageVariableRadialDistortion(self, sourceImgNr, destImgNr)


    def linkImageVariableRadialDistortionRed(self, sourceImgNr, destImgNr):
        """linkImageVariableRadialDistortionRed(PanoramaData self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.PanoramaData_linkImageVariableRadialDistortionRed(self, sourceImgNr, destImgNr)


    def linkImageVariableRadialDistortionBlue(self, sourceImgNr, destImgNr):
        """linkImageVariableRadialDistortionBlue(PanoramaData self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.PanoramaData_linkImageVariableRadialDistortionBlue(self, sourceImgNr, destImgNr)


    def linkImageVariableRadialDistortionCenterShift(self, sourceImgNr, destImgNr):
        """linkImageVariableRadialDistortionCenterShift(PanoramaData self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.PanoramaData_linkImageVariableRadialDistortionCenterShift(self, sourceImgNr, destImgNr)


    def linkImageVariableShear(self, sourceImgNr, destImgNr):
        """linkImageVariableShear(PanoramaData self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.PanoramaData_linkImageVariableShear(self, sourceImgNr, destImgNr)


    def linkImageVariableCropMode(self, sourceImgNr, destImgNr):
        """linkImageVariableCropMode(PanoramaData self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.PanoramaData_linkImageVariableCropMode(self, sourceImgNr, destImgNr)


    def linkImageVariableCropRect(self, sourceImgNr, destImgNr):
        """linkImageVariableCropRect(PanoramaData self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.PanoramaData_linkImageVariableCropRect(self, sourceImgNr, destImgNr)


    def linkImageVariableAutoCenterCrop(self, sourceImgNr, destImgNr):
        """linkImageVariableAutoCenterCrop(PanoramaData self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.PanoramaData_linkImageVariableAutoCenterCrop(self, sourceImgNr, destImgNr)


    def linkImageVariableVigCorrMode(self, sourceImgNr, destImgNr):
        """linkImageVariableVigCorrMode(PanoramaData self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.PanoramaData_linkImageVariableVigCorrMode(self, sourceImgNr, destImgNr)


    def linkImageVariableFlatfieldFilename(self, sourceImgNr, destImgNr):
        """linkImageVariableFlatfieldFilename(PanoramaData self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.PanoramaData_linkImageVariableFlatfieldFilename(self, sourceImgNr, destImgNr)


    def linkImageVariableRadialVigCorrCoeff(self, sourceImgNr, destImgNr):
        """linkImageVariableRadialVigCorrCoeff(PanoramaData self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.PanoramaData_linkImageVariableRadialVigCorrCoeff(self, sourceImgNr, destImgNr)


    def linkImageVariableRadialVigCorrCenterShift(self, sourceImgNr, destImgNr):
        """linkImageVariableRadialVigCorrCenterShift(PanoramaData self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.PanoramaData_linkImageVariableRadialVigCorrCenterShift(self, sourceImgNr, destImgNr)


    def linkImageVariableExifModel(self, sourceImgNr, destImgNr):
        """linkImageVariableExifModel(PanoramaData self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.PanoramaData_linkImageVariableExifModel(self, sourceImgNr, destImgNr)


    def linkImageVariableExifMake(self, sourceImgNr, destImgNr):
        """linkImageVariableExifMake(PanoramaData self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.PanoramaData_linkImageVariableExifMake(self, sourceImgNr, destImgNr)


    def linkImageVariableExifLens(self, sourceImgNr, destImgNr):
        """linkImageVariableExifLens(PanoramaData self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.PanoramaData_linkImageVariableExifLens(self, sourceImgNr, destImgNr)


    def linkImageVariableExifFocalLength(self, sourceImgNr, destImgNr):
        """linkImageVariableExifFocalLength(PanoramaData self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.PanoramaData_linkImageVariableExifFocalLength(self, sourceImgNr, destImgNr)


    def linkImageVariableExifOrientation(self, sourceImgNr, destImgNr):
        """linkImageVariableExifOrientation(PanoramaData self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.PanoramaData_linkImageVariableExifOrientation(self, sourceImgNr, destImgNr)


    def linkImageVariableExifAperture(self, sourceImgNr, destImgNr):
        """linkImageVariableExifAperture(PanoramaData self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.PanoramaData_linkImageVariableExifAperture(self, sourceImgNr, destImgNr)


    def linkImageVariableExifISO(self, sourceImgNr, destImgNr):
        """linkImageVariableExifISO(PanoramaData self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.PanoramaData_linkImageVariableExifISO(self, sourceImgNr, destImgNr)


    def linkImageVariableExifDistance(self, sourceImgNr, destImgNr):
        """linkImageVariableExifDistance(PanoramaData self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.PanoramaData_linkImageVariableExifDistance(self, sourceImgNr, destImgNr)


    def linkImageVariableExifFocalLength35(self, sourceImgNr, destImgNr):
        """linkImageVariableExifFocalLength35(PanoramaData self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.PanoramaData_linkImageVariableExifFocalLength35(self, sourceImgNr, destImgNr)


    def linkImageVariableExifCropFactor(self, sourceImgNr, destImgNr):
        """linkImageVariableExifCropFactor(PanoramaData self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.PanoramaData_linkImageVariableExifCropFactor(self, sourceImgNr, destImgNr)


    def linkImageVariableExifExposureTime(self, sourceImgNr, destImgNr):
        """linkImageVariableExifExposureTime(PanoramaData self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.PanoramaData_linkImageVariableExifExposureTime(self, sourceImgNr, destImgNr)


    def linkImageVariableExifDate(self, sourceImgNr, destImgNr):
        """linkImageVariableExifDate(PanoramaData self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.PanoramaData_linkImageVariableExifDate(self, sourceImgNr, destImgNr)


    def linkImageVariableExifExposureMode(self, sourceImgNr, destImgNr):
        """linkImageVariableExifExposureMode(PanoramaData self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.PanoramaData_linkImageVariableExifExposureMode(self, sourceImgNr, destImgNr)


    def linkImageVariableExifRedBalance(self, sourceImgNr, destImgNr):
        """linkImageVariableExifRedBalance(PanoramaData self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.PanoramaData_linkImageVariableExifRedBalance(self, sourceImgNr, destImgNr)


    def linkImageVariableExifBlueBalance(self, sourceImgNr, destImgNr):
        """linkImageVariableExifBlueBalance(PanoramaData self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.PanoramaData_linkImageVariableExifBlueBalance(self, sourceImgNr, destImgNr)


    def linkImageVariableMasks(self, sourceImgNr, destImgNr):
        """linkImageVariableMasks(PanoramaData self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.PanoramaData_linkImageVariableMasks(self, sourceImgNr, destImgNr)


    def linkImageVariableActiveMasks(self, sourceImgNr, destImgNr):
        """linkImageVariableActiveMasks(PanoramaData self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.PanoramaData_linkImageVariableActiveMasks(self, sourceImgNr, destImgNr)


    def linkImageVariableActive(self, sourceImgNr, destImgNr):
        """linkImageVariableActive(PanoramaData self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.PanoramaData_linkImageVariableActive(self, sourceImgNr, destImgNr)


    def unlinkImageVariableFilename(self, imgNr):
        """unlinkImageVariableFilename(PanoramaData self, unsigned int imgNr)"""
        return _hsi.PanoramaData_unlinkImageVariableFilename(self, imgNr)


    def unlinkImageVariableSize(self, imgNr):
        """unlinkImageVariableSize(PanoramaData self, unsigned int imgNr)"""
        return _hsi.PanoramaData_unlinkImageVariableSize(self, imgNr)


    def unlinkImageVariableProjection(self, imgNr):
        """unlinkImageVariableProjection(PanoramaData self, unsigned int imgNr)"""
        return _hsi.PanoramaData_unlinkImageVariableProjection(self, imgNr)


    def unlinkImageVariableHFOV(self, imgNr):
        """unlinkImageVariableHFOV(PanoramaData self, unsigned int imgNr)"""
        return _hsi.PanoramaData_unlinkImageVariableHFOV(self, imgNr)


    def unlinkImageVariableCropFactor(self, imgNr):
        """unlinkImageVariableCropFactor(PanoramaData self, unsigned int imgNr)"""
        return _hsi.PanoramaData_unlinkImageVariableCropFactor(self, imgNr)


    def unlinkImageVariableResponseType(self, imgNr):
        """unlinkImageVariableResponseType(PanoramaData self, unsigned int imgNr)"""
        return _hsi.PanoramaData_unlinkImageVariableResponseType(self, imgNr)


    def unlinkImageVariableEMoRParams(self, imgNr):
        """unlinkImageVariableEMoRParams(PanoramaData self, unsigned int imgNr)"""
        return _hsi.PanoramaData_unlinkImageVariableEMoRParams(self, imgNr)


    def unlinkImageVariableExposureValue(self, imgNr):
        """unlinkImageVariableExposureValue(PanoramaData self, unsigned int imgNr)"""
        return _hsi.PanoramaData_unlinkImageVariableExposureValue(self, imgNr)


    def unlinkImageVariableGamma(self, imgNr):
        """unlinkImageVariableGamma(PanoramaData self, unsigned int imgNr)"""
        return _hsi.PanoramaData_unlinkImageVariableGamma(self, imgNr)


    def unlinkImageVariableWhiteBalanceRed(self, imgNr):
        """unlinkImageVariableWhiteBalanceRed(PanoramaData self, unsigned int imgNr)"""
        return _hsi.PanoramaData_unlinkImageVariableWhiteBalanceRed(self, imgNr)


    def unlinkImageVariableWhiteBalanceBlue(self, imgNr):
        """unlinkImageVariableWhiteBalanceBlue(PanoramaData self, unsigned int imgNr)"""
        return _hsi.PanoramaData_unlinkImageVariableWhiteBalanceBlue(self, imgNr)


    def unlinkImageVariableRoll(self, imgNr):
        """unlinkImageVariableRoll(PanoramaData self, unsigned int imgNr)"""
        return _hsi.PanoramaData_unlinkImageVariableRoll(self, imgNr)


    def unlinkImageVariablePitch(self, imgNr):
        """unlinkImageVariablePitch(PanoramaData self, unsigned int imgNr)"""
        return _hsi.PanoramaData_unlinkImageVariablePitch(self, imgNr)


    def unlinkImageVariableYaw(self, imgNr):
        """unlinkImageVariableYaw(PanoramaData self, unsigned int imgNr)"""
        return _hsi.PanoramaData_unlinkImageVariableYaw(self, imgNr)


    def unlinkImageVariableX(self, imgNr):
        """unlinkImageVariableX(PanoramaData self, unsigned int imgNr)"""
        return _hsi.PanoramaData_unlinkImageVariableX(self, imgNr)


    def unlinkImageVariableY(self, imgNr):
        """unlinkImageVariableY(PanoramaData self, unsigned int imgNr)"""
        return _hsi.PanoramaData_unlinkImageVariableY(self, imgNr)


    def unlinkImageVariableZ(self, imgNr):
        """unlinkImageVariableZ(PanoramaData self, unsigned int imgNr)"""
        return _hsi.PanoramaData_unlinkImageVariableZ(self, imgNr)


    def unlinkImageVariableTranslationPlaneYaw(self, imgNr):
        """unlinkImageVariableTranslationPlaneYaw(PanoramaData self, unsigned int imgNr)"""
        return _hsi.PanoramaData_unlinkImageVariableTranslationPlaneYaw(self, imgNr)


    def unlinkImageVariableTranslationPlanePitch(self, imgNr):
        """unlinkImageVariableTranslationPlanePitch(PanoramaData self, unsigned int imgNr)"""
        return _hsi.PanoramaData_unlinkImageVariableTranslationPlanePitch(self, imgNr)


    def unlinkImageVariableStack(self, imgNr):
        """unlinkImageVariableStack(PanoramaData self, unsigned int imgNr)"""
        return _hsi.PanoramaData_unlinkImageVariableStack(self, imgNr)


    def unlinkImageVariableRadialDistortion(self, imgNr):
        """unlinkImageVariableRadialDistortion(PanoramaData self, unsigned int imgNr)"""
        return _hsi.PanoramaData_unlinkImageVariableRadialDistortion(self, imgNr)


    def unlinkImageVariableRadialDistortionRed(self, imgNr):
        """unlinkImageVariableRadialDistortionRed(PanoramaData self, unsigned int imgNr)"""
        return _hsi.PanoramaData_unlinkImageVariableRadialDistortionRed(self, imgNr)


    def unlinkImageVariableRadialDistortionBlue(self, imgNr):
        """unlinkImageVariableRadialDistortionBlue(PanoramaData self, unsigned int imgNr)"""
        return _hsi.PanoramaData_unlinkImageVariableRadialDistortionBlue(self, imgNr)


    def unlinkImageVariableRadialDistortionCenterShift(self, imgNr):
        """unlinkImageVariableRadialDistortionCenterShift(PanoramaData self, unsigned int imgNr)"""
        return _hsi.PanoramaData_unlinkImageVariableRadialDistortionCenterShift(self, imgNr)


    def unlinkImageVariableShear(self, imgNr):
        """unlinkImageVariableShear(PanoramaData self, unsigned int imgNr)"""
        return _hsi.PanoramaData_unlinkImageVariableShear(self, imgNr)


    def unlinkImageVariableCropMode(self, imgNr):
        """unlinkImageVariableCropMode(PanoramaData self, unsigned int imgNr)"""
        return _hsi.PanoramaData_unlinkImageVariableCropMode(self, imgNr)


    def unlinkImageVariableCropRect(self, imgNr):
        """unlinkImageVariableCropRect(PanoramaData self, unsigned int imgNr)"""
        return _hsi.PanoramaData_unlinkImageVariableCropRect(self, imgNr)


    def unlinkImageVariableAutoCenterCrop(self, imgNr):
        """unlinkImageVariableAutoCenterCrop(PanoramaData self, unsigned int imgNr)"""
        return _hsi.PanoramaData_unlinkImageVariableAutoCenterCrop(self, imgNr)


    def unlinkImageVariableVigCorrMode(self, imgNr):
        """unlinkImageVariableVigCorrMode(PanoramaData self, unsigned int imgNr)"""
        return _hsi.PanoramaData_unlinkImageVariableVigCorrMode(self, imgNr)


    def unlinkImageVariableFlatfieldFilename(self, imgNr):
        """unlinkImageVariableFlatfieldFilename(PanoramaData self, unsigned int imgNr)"""
        return _hsi.PanoramaData_unlinkImageVariableFlatfieldFilename(self, imgNr)


    def unlinkImageVariableRadialVigCorrCoeff(self, imgNr):
        """unlinkImageVariableRadialVigCorrCoeff(PanoramaData self, unsigned int imgNr)"""
        return _hsi.PanoramaData_unlinkImageVariableRadialVigCorrCoeff(self, imgNr)


    def unlinkImageVariableRadialVigCorrCenterShift(self, imgNr):
        """unlinkImageVariableRadialVigCorrCenterShift(PanoramaData self, unsigned int imgNr)"""
        return _hsi.PanoramaData_unlinkImageVariableRadialVigCorrCenterShift(self, imgNr)


    def unlinkImageVariableExifModel(self, imgNr):
        """unlinkImageVariableExifModel(PanoramaData self, unsigned int imgNr)"""
        return _hsi.PanoramaData_unlinkImageVariableExifModel(self, imgNr)


    def unlinkImageVariableExifMake(self, imgNr):
        """unlinkImageVariableExifMake(PanoramaData self, unsigned int imgNr)"""
        return _hsi.PanoramaData_unlinkImageVariableExifMake(self, imgNr)


    def unlinkImageVariableExifLens(self, imgNr):
        """unlinkImageVariableExifLens(PanoramaData self, unsigned int imgNr)"""
        return _hsi.PanoramaData_unlinkImageVariableExifLens(self, imgNr)


    def unlinkImageVariableExifFocalLength(self, imgNr):
        """unlinkImageVariableExifFocalLength(PanoramaData self, unsigned int imgNr)"""
        return _hsi.PanoramaData_unlinkImageVariableExifFocalLength(self, imgNr)


    def unlinkImageVariableExifOrientation(self, imgNr):
        """unlinkImageVariableExifOrientation(PanoramaData self, unsigned int imgNr)"""
        return _hsi.PanoramaData_unlinkImageVariableExifOrientation(self, imgNr)


    def unlinkImageVariableExifAperture(self, imgNr):
        """unlinkImageVariableExifAperture(PanoramaData self, unsigned int imgNr)"""
        return _hsi.PanoramaData_unlinkImageVariableExifAperture(self, imgNr)


    def unlinkImageVariableExifISO(self, imgNr):
        """unlinkImageVariableExifISO(PanoramaData self, unsigned int imgNr)"""
        return _hsi.PanoramaData_unlinkImageVariableExifISO(self, imgNr)


    def unlinkImageVariableExifDistance(self, imgNr):
        """unlinkImageVariableExifDistance(PanoramaData self, unsigned int imgNr)"""
        return _hsi.PanoramaData_unlinkImageVariableExifDistance(self, imgNr)


    def unlinkImageVariableExifFocalLength35(self, imgNr):
        """unlinkImageVariableExifFocalLength35(PanoramaData self, unsigned int imgNr)"""
        return _hsi.PanoramaData_unlinkImageVariableExifFocalLength35(self, imgNr)


    def unlinkImageVariableExifCropFactor(self, imgNr):
        """unlinkImageVariableExifCropFactor(PanoramaData self, unsigned int imgNr)"""
        return _hsi.PanoramaData_unlinkImageVariableExifCropFactor(self, imgNr)


    def unlinkImageVariableExifExposureTime(self, imgNr):
        """unlinkImageVariableExifExposureTime(PanoramaData self, unsigned int imgNr)"""
        return _hsi.PanoramaData_unlinkImageVariableExifExposureTime(self, imgNr)


    def unlinkImageVariableExifDate(self, imgNr):
        """unlinkImageVariableExifDate(PanoramaData self, unsigned int imgNr)"""
        return _hsi.PanoramaData_unlinkImageVariableExifDate(self, imgNr)


    def unlinkImageVariableExifExposureMode(self, imgNr):
        """unlinkImageVariableExifExposureMode(PanoramaData self, unsigned int imgNr)"""
        return _hsi.PanoramaData_unlinkImageVariableExifExposureMode(self, imgNr)


    def unlinkImageVariableExifRedBalance(self, imgNr):
        """unlinkImageVariableExifRedBalance(PanoramaData self, unsigned int imgNr)"""
        return _hsi.PanoramaData_unlinkImageVariableExifRedBalance(self, imgNr)


    def unlinkImageVariableExifBlueBalance(self, imgNr):
        """unlinkImageVariableExifBlueBalance(PanoramaData self, unsigned int imgNr)"""
        return _hsi.PanoramaData_unlinkImageVariableExifBlueBalance(self, imgNr)


    def unlinkImageVariableMasks(self, imgNr):
        """unlinkImageVariableMasks(PanoramaData self, unsigned int imgNr)"""
        return _hsi.PanoramaData_unlinkImageVariableMasks(self, imgNr)


    def unlinkImageVariableActiveMasks(self, imgNr):
        """unlinkImageVariableActiveMasks(PanoramaData self, unsigned int imgNr)"""
        return _hsi.PanoramaData_unlinkImageVariableActiveMasks(self, imgNr)


    def unlinkImageVariableActive(self, imgNr):
        """unlinkImageVariableActive(PanoramaData self, unsigned int imgNr)"""
        return _hsi.PanoramaData_unlinkImageVariableActive(self, imgNr)


    def getNrOfCtrlPoints(self):
        """getNrOfCtrlPoints(PanoramaData self) -> std::size_t"""
        return _hsi.PanoramaData_getNrOfCtrlPoints(self)


    def getCtrlPoint(self, nr):
        """getCtrlPoint(PanoramaData self, std::size_t nr) -> ControlPoint"""
        return _hsi.PanoramaData_getCtrlPoint(self, nr)


    def getCtrlPoints(self):
        """getCtrlPoints(PanoramaData self) -> CPVector const &"""
        return _hsi.PanoramaData_getCtrlPoints(self)


    def getCtrlPointsForImage(self, imgNr):
        """getCtrlPointsForImage(PanoramaData self, unsigned int imgNr) -> std::vector< unsigned int,std::allocator< unsigned int > >"""
        return _hsi.PanoramaData_getCtrlPointsForImage(self, imgNr)


    def setCtrlPoints(self, points):
        """setCtrlPoints(PanoramaData self, CPVector const & points)"""
        return _hsi.PanoramaData_setCtrlPoints(self, points)


    def addCtrlPoint(self, point):
        """addCtrlPoint(PanoramaData self, ControlPoint point) -> unsigned int"""
        return _hsi.PanoramaData_addCtrlPoint(self, point)


    def removeCtrlPoint(self, pNr):
        """removeCtrlPoint(PanoramaData self, unsigned int pNr)"""
        return _hsi.PanoramaData_removeCtrlPoint(self, pNr)


    def removeDuplicateCtrlPoints(self):
        """removeDuplicateCtrlPoints(PanoramaData self)"""
        return _hsi.PanoramaData_removeDuplicateCtrlPoints(self)


    def changeControlPoint(self, pNr, point):
        """changeControlPoint(PanoramaData self, unsigned int pNr, ControlPoint point)"""
        return _hsi.PanoramaData_changeControlPoint(self, pNr, point)


    def getNextCPTypeLineNumber(self):
        """getNextCPTypeLineNumber(PanoramaData self) -> int"""
        return _hsi.PanoramaData_getNextCPTypeLineNumber(self)


    def updateLineCtrlPoints(self):
        """updateLineCtrlPoints(PanoramaData self)"""
        return _hsi.PanoramaData_updateLineCtrlPoints(self)


    def updateCtrlPointErrors(self, *args):
        """
        updateCtrlPointErrors(PanoramaData self, CPVector const & controlPoints)
        updateCtrlPointErrors(PanoramaData self, HuginBase::UIntSet const & imgs, CPVector const & cps)
        """
        return _hsi.PanoramaData_updateCtrlPointErrors(self, *args)


    def getVariables(self):
        """getVariables(PanoramaData self) -> VariableMapVector"""
        return _hsi.PanoramaData_getVariables(self)


    def getImageVariables(self, imgNr):
        """getImageVariables(PanoramaData self, unsigned int imgNr) -> VariableMap const"""
        return _hsi.PanoramaData_getImageVariables(self, imgNr)


    def updateVariables(self, *args):
        """
        updateVariables(PanoramaData self, VariableMapVector const & vars)
        updateVariables(PanoramaData self, HuginBase::UIntSet const & imgs, VariableMapVector const & var)
        updateVariables(PanoramaData self, unsigned int imgNr, VariableMap const & var)
        """
        return _hsi.PanoramaData_updateVariables(self, *args)


    def updateVariable(self, imgNr, var):
        """updateVariable(PanoramaData self, unsigned int imgNr, Variable var)"""
        return _hsi.PanoramaData_updateVariable(self, imgNr, var)


    def updateWhiteBalance(self, redFactor, blueFactor):
        """updateWhiteBalance(PanoramaData self, double redFactor, double blueFactor)"""
        return _hsi.PanoramaData_updateWhiteBalance(self, redFactor, blueFactor)


    def getOptimizeVector(self):
        """getOptimizeVector(PanoramaData self) -> OptimizeVector"""
        return _hsi.PanoramaData_getOptimizeVector(self)


    def setOptimizeVector(self, optvec):
        """setOptimizeVector(PanoramaData self, OptimizeVector optvec)"""
        return _hsi.PanoramaData_setOptimizeVector(self, optvec)


    def getOptimizerSwitch(self):
        """getOptimizerSwitch(PanoramaData self) -> int const"""
        return _hsi.PanoramaData_getOptimizerSwitch(self)


    def setOptimizerSwitch(self, newSwitch):
        """setOptimizerSwitch(PanoramaData self, int const newSwitch)"""
        return _hsi.PanoramaData_setOptimizerSwitch(self, newSwitch)


    def getPhotometricOptimizerSwitch(self):
        """getPhotometricOptimizerSwitch(PanoramaData self) -> int const"""
        return _hsi.PanoramaData_getPhotometricOptimizerSwitch(self)


    def setPhotometricOptimizerSwitch(self, newSwitch):
        """setPhotometricOptimizerSwitch(PanoramaData self, int const newSwitch)"""
        return _hsi.PanoramaData_setPhotometricOptimizerSwitch(self, newSwitch)


    def getOptions(self):
        """getOptions(PanoramaData self) -> PanoramaOptions"""
        return _hsi.PanoramaData_getOptions(self)


    def setOptions(self, opt):
        """setOptions(PanoramaData self, PanoramaOptions opt)"""
        return _hsi.PanoramaData_setOptions(self, opt)


    def parseOptimizerScript(self, i, imgs, imgVars, ctrlPoints):
        """parseOptimizerScript(PanoramaData self, istream i, HuginBase::UIntSet const & imgs, VariableMapVector & imgVars, CPVector & ctrlPoints)"""
        return _hsi.PanoramaData_parseOptimizerScript(self, i, imgs, imgVars, ctrlPoints)


    def printPanoramaScript(self, o, optvars, options, imgs, forPTOptimizer, stripPrefix=""):
        """
        printPanoramaScript(PanoramaData self, ostream o, OptimizeVector optvars, PanoramaOptions options, HuginBase::UIntSet const & imgs, bool forPTOptimizer, std::string const & stripPrefix="")
        printPanoramaScript(PanoramaData self, ostream o, OptimizeVector optvars, PanoramaOptions options, HuginBase::UIntSet const & imgs, bool forPTOptimizer)
        """
        return _hsi.PanoramaData_printPanoramaScript(self, o, optvars, options, imgs, forPTOptimizer, stripPrefix)


    def printStitcherScript(self, o, target, imgs):
        """printStitcherScript(PanoramaData self, ostream o, PanoramaOptions target, HuginBase::UIntSet const & imgs)"""
        return _hsi.PanoramaData_printStitcherScript(self, o, target, imgs)


    def changeFinished(self):
        """changeFinished(PanoramaData self)"""
        return _hsi.PanoramaData_changeFinished(self)


    def imageChanged(self, imgNr):
        """imageChanged(PanoramaData self, unsigned int imgNr)"""
        return _hsi.PanoramaData_imageChanged(self, imgNr)


    def updateMasksForImage(self, imgNr, newMasks):
        """updateMasksForImage(PanoramaData self, unsigned int imgNr, MaskPolygonVector newMasks)"""
        return _hsi.PanoramaData_updateMasksForImage(self, imgNr, newMasks)


    def updateMasks(self, convertPosMaskToNeg=False):
        """
        updateMasks(PanoramaData self, bool convertPosMaskToNeg=False)
        updateMasks(PanoramaData self)
        """
        return _hsi.PanoramaData_updateMasks(self, convertPosMaskToNeg)


    def transferMask(self, mask, imgNr, targetImgs):
        """transferMask(PanoramaData self, MaskPolygon mask, unsigned int imgNr, HuginBase::UIntSet const targetImgs)"""
        return _hsi.PanoramaData_transferMask(self, mask, imgNr, targetImgs)


    def updateOptimizeVector(self):
        """updateOptimizeVector(PanoramaData self)"""
        return _hsi.PanoramaData_updateOptimizeVector(self)


    def getRefImages(self):
        """getRefImages(PanoramaData self) -> std::set< size_t,std::less< size_t >,std::allocator< size_t > >"""
        return _hsi.PanoramaData_getRefImages(self)


    def checkRefOptStatus(self, linkRefImgsYaw, linkRefImgsPitch, linkRefImgsRoll):
        """checkRefOptStatus(PanoramaData self, bool & linkRefImgsYaw, bool & linkRefImgsPitch, bool & linkRefImgsRoll)"""
        return _hsi.PanoramaData_checkRefOptStatus(self, linkRefImgsYaw, linkRefImgsPitch, linkRefImgsRoll)

PanoramaData_swigregister = _hsi.PanoramaData_swigregister
PanoramaData_swigregister(PanoramaData)

class PanoramaObserver(_object):
    """Proxy of C++ HuginBase::PanoramaObserver class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, PanoramaObserver, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, PanoramaObserver, name)

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

    def panoramaChanged(self, pano):
        """panoramaChanged(PanoramaObserver self, PanoramaData pano)"""
        return _hsi.PanoramaObserver_panoramaChanged(self, pano)


    def panoramaImagesChanged(self, pano, changed):
        """panoramaImagesChanged(PanoramaObserver self, PanoramaData pano, HuginBase::UIntSet const & changed)"""
        return _hsi.PanoramaObserver_panoramaImagesChanged(self, pano, changed)

PanoramaObserver_swigregister = _hsi.PanoramaObserver_swigregister
PanoramaObserver_swigregister(PanoramaObserver)

class PanoramaDataMemento(_object):
    """Proxy of C++ HuginBase::PanoramaDataMemento class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, PanoramaDataMemento, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, PanoramaDataMemento, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _hsi.delete_PanoramaDataMemento
    __del__ = lambda self: None
PanoramaDataMemento_swigregister = _hsi.PanoramaDataMemento_swigregister
PanoramaDataMemento_swigregister(PanoramaDataMemento)

class ManagedPanoramaData(PanoramaData):
    """Proxy of C++ HuginBase::ManagedPanoramaData class"""
    __swig_setmethods__ = {}
    for _s in [PanoramaData]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ManagedPanoramaData, name, value)
    __swig_getmethods__ = {}
    for _s in [PanoramaData]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ManagedPanoramaData, name)

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

    def addObserver(self, o):
        """addObserver(ManagedPanoramaData self, PanoramaObserver o)"""
        return _hsi.ManagedPanoramaData_addObserver(self, o)


    def removeObserver(self, observer):
        """removeObserver(ManagedPanoramaData self, PanoramaObserver observer) -> bool"""
        return _hsi.ManagedPanoramaData_removeObserver(self, observer)


    def clearObservers(self):
        """clearObservers(ManagedPanoramaData self)"""
        return _hsi.ManagedPanoramaData_clearObservers(self)


    def changeFinished(self):
        """changeFinished(ManagedPanoramaData self)"""
        return _hsi.ManagedPanoramaData_changeFinished(self)


    def clearDirty(self):
        """clearDirty(ManagedPanoramaData self)"""
        return _hsi.ManagedPanoramaData_clearDirty(self)


    def imageChanged(self, imgNr):
        """imageChanged(ManagedPanoramaData self, unsigned int imgNr)"""
        return _hsi.ManagedPanoramaData_imageChanged(self, imgNr)


    def getNewMemento(self):
        """getNewMemento(ManagedPanoramaData self) -> PanoramaDataMemento"""
        return _hsi.ManagedPanoramaData_getNewMemento(self)


    def setMementoToCopyOf(self, memento):
        """setMementoToCopyOf(ManagedPanoramaData self, PanoramaDataMemento memento) -> bool"""
        return _hsi.ManagedPanoramaData_setMementoToCopyOf(self, memento)


    def needsOptimization(self):
        """needsOptimization(ManagedPanoramaData self) -> bool"""
        return _hsi.ManagedPanoramaData_needsOptimization(self)


    def markAsOptimized(self, optimized=True):
        """
        markAsOptimized(ManagedPanoramaData self, bool optimized=True)
        markAsOptimized(ManagedPanoramaData self)
        """
        return _hsi.ManagedPanoramaData_markAsOptimized(self, optimized)

ManagedPanoramaData_swigregister = _hsi.ManagedPanoramaData_swigregister
ManagedPanoramaData_swigregister(ManagedPanoramaData)

class CPoint(_object):
    """Proxy of C++ std::pair<(unsigned int,ControlPoint)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CPoint, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CPoint, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(std::pair<(unsigned int,ControlPoint)> self) -> CPoint
        __init__(std::pair<(unsigned int,ControlPoint)> self, unsigned int first, ControlPoint second) -> CPoint
        __init__(std::pair<(unsigned int,ControlPoint)> self, CPoint p) -> CPoint
        """
        this = _hsi.new_CPoint(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_setmethods__["first"] = _hsi.CPoint_first_set
    __swig_getmethods__["first"] = _hsi.CPoint_first_get
    if _newclass:
        first = _swig_property(_hsi.CPoint_first_get, _hsi.CPoint_first_set)
    __swig_setmethods__["second"] = _hsi.CPoint_second_set
    __swig_getmethods__["second"] = _hsi.CPoint_second_get
    if _newclass:
        second = _swig_property(_hsi.CPoint_second_get, _hsi.CPoint_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = _hsi.delete_CPoint
    __del__ = lambda self: None
CPoint_swigregister = _hsi.CPoint_swigregister
CPoint_swigregister(CPoint)

class CPointVector(_object):
    """Proxy of C++ std::vector<(std::pair<(unsigned int,ControlPoint)>)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CPointVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CPointVector, name)
    __repr__ = _swig_repr

    def iterator(self):
        """iterator(CPointVector self) -> SwigPyIterator"""
        return _hsi.CPointVector_iterator(self)

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

    def __nonzero__(self):
        """__nonzero__(CPointVector self) -> bool"""
        return _hsi.CPointVector___nonzero__(self)


    def __bool__(self):
        """__bool__(CPointVector self) -> bool"""
        return _hsi.CPointVector___bool__(self)


    def __len__(self):
        """__len__(CPointVector self) -> std::vector< std::pair< unsigned int,ControlPoint > >::size_type"""
        return _hsi.CPointVector___len__(self)


    def pop(self):
        """pop(CPointVector self) -> std::vector< std::pair< unsigned int,ControlPoint > >::value_type"""
        return _hsi.CPointVector_pop(self)


    def __getslice__(self, i, j):
        """__getslice__(CPointVector self, std::vector< std::pair< unsigned int,ControlPoint > >::difference_type i, std::vector< std::pair< unsigned int,ControlPoint > >::difference_type j) -> std::vector< std::pair< unsigned int,HuginBase::ControlPoint >,std::allocator< std::pair< unsigned int,HuginBase::ControlPoint > > > *"""
        return _hsi.CPointVector___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(CPointVector self, std::vector< std::pair< unsigned int,ControlPoint > >::difference_type i, std::vector< std::pair< unsigned int,ControlPoint > >::difference_type j, std::vector< std::pair< unsigned int,HuginBase::ControlPoint >,std::allocator< std::pair< unsigned int,HuginBase::ControlPoint > > > const & v)
        __setslice__(CPointVector self, std::vector< std::pair< unsigned int,ControlPoint > >::difference_type i, std::vector< std::pair< unsigned int,ControlPoint > >::difference_type j)
        """
        return _hsi.CPointVector___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(CPointVector self, std::vector< std::pair< unsigned int,ControlPoint > >::difference_type i, std::vector< std::pair< unsigned int,ControlPoint > >::difference_type j)"""
        return _hsi.CPointVector___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(CPointVector self, std::vector< std::pair< unsigned int,ControlPoint > >::difference_type i)
        __delitem__(CPointVector self, PySliceObject * slice)
        """
        return _hsi.CPointVector___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(CPointVector self, PySliceObject * slice) -> std::vector< std::pair< unsigned int,HuginBase::ControlPoint >,std::allocator< std::pair< unsigned int,HuginBase::ControlPoint > > >
        __getitem__(CPointVector self, std::vector< std::pair< unsigned int,ControlPoint > >::difference_type i) -> std::vector< std::pair< unsigned int,ControlPoint > >::value_type const &
        """
        return _hsi.CPointVector___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(CPointVector self, PySliceObject * slice, std::vector< std::pair< unsigned int,HuginBase::ControlPoint >,std::allocator< std::pair< unsigned int,HuginBase::ControlPoint > > > const & v)
        __setitem__(CPointVector self, PySliceObject * slice)
        __setitem__(CPointVector self, std::vector< std::pair< unsigned int,ControlPoint > >::difference_type i, std::vector< std::pair< unsigned int,ControlPoint > >::value_type const & x)
        """
        return _hsi.CPointVector___setitem__(self, *args)


    def append(self, x):
        """append(CPointVector self, std::vector< std::pair< unsigned int,ControlPoint > >::value_type const & x)"""
        return _hsi.CPointVector_append(self, x)


    def empty(self):
        """empty(CPointVector self) -> bool"""
        return _hsi.CPointVector_empty(self)


    def size(self):
        """size(CPointVector self) -> std::vector< std::pair< unsigned int,ControlPoint > >::size_type"""
        return _hsi.CPointVector_size(self)


    def clear(self):
        """clear(CPointVector self)"""
        return _hsi.CPointVector_clear(self)


    def swap(self, v):
        """swap(CPointVector self, std::vector< std::pair< unsigned int,HuginBase::ControlPoint > > & v)"""
        return _hsi.CPointVector_swap(self, v)


    def get_allocator(self):
        """get_allocator(CPointVector self) -> std::vector< std::pair< unsigned int,ControlPoint > >::allocator_type"""
        return _hsi.CPointVector_get_allocator(self)


    def begin(self):
        """begin(CPointVector self) -> std::vector< std::pair< unsigned int,ControlPoint > >::iterator"""
        return _hsi.CPointVector_begin(self)


    def end(self):
        """end(CPointVector self) -> std::vector< std::pair< unsigned int,ControlPoint > >::iterator"""
        return _hsi.CPointVector_end(self)


    def rbegin(self):
        """rbegin(CPointVector self) -> std::vector< std::pair< unsigned int,ControlPoint > >::reverse_iterator"""
        return _hsi.CPointVector_rbegin(self)


    def rend(self):
        """rend(CPointVector self) -> std::vector< std::pair< unsigned int,ControlPoint > >::reverse_iterator"""
        return _hsi.CPointVector_rend(self)


    def pop_back(self):
        """pop_back(CPointVector self)"""
        return _hsi.CPointVector_pop_back(self)


    def erase(self, *args):
        """
        erase(CPointVector self, std::vector< std::pair< unsigned int,ControlPoint > >::iterator pos) -> std::vector< std::pair< unsigned int,ControlPoint > >::iterator
        erase(CPointVector self, std::vector< std::pair< unsigned int,ControlPoint > >::iterator first, std::vector< std::pair< unsigned int,ControlPoint > >::iterator last) -> std::vector< std::pair< unsigned int,ControlPoint > >::iterator
        """
        return _hsi.CPointVector_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::vector<(std::pair<(unsigned int,ControlPoint)>)> self) -> CPointVector
        __init__(std::vector<(std::pair<(unsigned int,ControlPoint)>)> self, std::vector< std::pair< unsigned int,HuginBase::ControlPoint > > const & arg2) -> CPointVector
        __init__(std::vector<(std::pair<(unsigned int,ControlPoint)>)> self, std::vector< std::pair< unsigned int,ControlPoint > >::size_type size) -> CPointVector
        __init__(std::vector<(std::pair<(unsigned int,ControlPoint)>)> self, std::vector< std::pair< unsigned int,ControlPoint > >::size_type size, std::vector< std::pair< unsigned int,ControlPoint > >::value_type const & value) -> CPointVector
        """
        this = _hsi.new_CPointVector(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def push_back(self, x):
        """push_back(CPointVector self, std::vector< std::pair< unsigned int,ControlPoint > >::value_type const & x)"""
        return _hsi.CPointVector_push_back(self, x)


    def front(self):
        """front(CPointVector self) -> std::vector< std::pair< unsigned int,ControlPoint > >::value_type const &"""
        return _hsi.CPointVector_front(self)


    def back(self):
        """back(CPointVector self) -> std::vector< std::pair< unsigned int,ControlPoint > >::value_type const &"""
        return _hsi.CPointVector_back(self)


    def assign(self, n, x):
        """assign(CPointVector self, std::vector< std::pair< unsigned int,ControlPoint > >::size_type n, std::vector< std::pair< unsigned int,ControlPoint > >::value_type const & x)"""
        return _hsi.CPointVector_assign(self, n, x)


    def resize(self, *args):
        """
        resize(CPointVector self, std::vector< std::pair< unsigned int,ControlPoint > >::size_type new_size)
        resize(CPointVector self, std::vector< std::pair< unsigned int,ControlPoint > >::size_type new_size, std::vector< std::pair< unsigned int,ControlPoint > >::value_type const & x)
        """
        return _hsi.CPointVector_resize(self, *args)


    def insert(self, *args):
        """
        insert(CPointVector self, std::vector< std::pair< unsigned int,ControlPoint > >::iterator pos, std::vector< std::pair< unsigned int,ControlPoint > >::value_type const & x) -> std::vector< std::pair< unsigned int,ControlPoint > >::iterator
        insert(CPointVector self, std::vector< std::pair< unsigned int,ControlPoint > >::iterator pos, std::vector< std::pair< unsigned int,ControlPoint > >::size_type n, std::vector< std::pair< unsigned int,ControlPoint > >::value_type const & x)
        """
        return _hsi.CPointVector_insert(self, *args)


    def reserve(self, n):
        """reserve(CPointVector self, std::vector< std::pair< unsigned int,ControlPoint > >::size_type n)"""
        return _hsi.CPointVector_reserve(self, n)


    def capacity(self):
        """capacity(CPointVector self) -> std::vector< std::pair< unsigned int,ControlPoint > >::size_type"""
        return _hsi.CPointVector_capacity(self)

    __swig_destroy__ = _hsi.delete_CPointVector
    __del__ = lambda self: None
CPointVector_swigregister = _hsi.CPointVector_swigregister
CPointVector_swigregister(CPointVector)

class CPVector(_object):
    """Proxy of C++ std::vector<(ControlPoint)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CPVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CPVector, name)
    __repr__ = _swig_repr

    def iterator(self):
        """iterator(CPVector self) -> SwigPyIterator"""
        return _hsi.CPVector_iterator(self)

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

    def __nonzero__(self):
        """__nonzero__(CPVector self) -> bool"""
        return _hsi.CPVector___nonzero__(self)


    def __bool__(self):
        """__bool__(CPVector self) -> bool"""
        return _hsi.CPVector___bool__(self)


    def __len__(self):
        """__len__(CPVector self) -> std::vector< ControlPoint >::size_type"""
        return _hsi.CPVector___len__(self)


    def pop(self):
        """pop(CPVector self) -> ControlPoint"""
        return _hsi.CPVector_pop(self)


    def __getslice__(self, i, j):
        """__getslice__(CPVector self, std::vector< ControlPoint >::difference_type i, std::vector< ControlPoint >::difference_type j) -> std::vector< HuginBase::ControlPoint,std::allocator< HuginBase::ControlPoint > > *"""
        return _hsi.CPVector___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(CPVector self, std::vector< ControlPoint >::difference_type i, std::vector< ControlPoint >::difference_type j, std::vector< HuginBase::ControlPoint,std::allocator< HuginBase::ControlPoint > > const & v)
        __setslice__(CPVector self, std::vector< ControlPoint >::difference_type i, std::vector< ControlPoint >::difference_type j)
        """
        return _hsi.CPVector___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(CPVector self, std::vector< ControlPoint >::difference_type i, std::vector< ControlPoint >::difference_type j)"""
        return _hsi.CPVector___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(CPVector self, std::vector< ControlPoint >::difference_type i)
        __delitem__(CPVector self, PySliceObject * slice)
        """
        return _hsi.CPVector___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(CPVector self, PySliceObject * slice) -> std::vector< HuginBase::ControlPoint,std::allocator< HuginBase::ControlPoint > >
        __getitem__(CPVector self, std::vector< ControlPoint >::difference_type i) -> ControlPoint
        """
        return _hsi.CPVector___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(CPVector self, PySliceObject * slice, std::vector< HuginBase::ControlPoint,std::allocator< HuginBase::ControlPoint > > const & v)
        __setitem__(CPVector self, PySliceObject * slice)
        __setitem__(CPVector self, std::vector< ControlPoint >::difference_type i, ControlPoint x)
        """
        return _hsi.CPVector___setitem__(self, *args)


    def append(self, x):
        """append(CPVector self, ControlPoint x)"""
        return _hsi.CPVector_append(self, x)


    def empty(self):
        """empty(CPVector self) -> bool"""
        return _hsi.CPVector_empty(self)


    def size(self):
        """size(CPVector self) -> std::vector< ControlPoint >::size_type"""
        return _hsi.CPVector_size(self)


    def clear(self):
        """clear(CPVector self)"""
        return _hsi.CPVector_clear(self)


    def swap(self, v):
        """swap(CPVector self, CPVector v)"""
        return _hsi.CPVector_swap(self, v)


    def get_allocator(self):
        """get_allocator(CPVector self) -> std::vector< ControlPoint >::allocator_type"""
        return _hsi.CPVector_get_allocator(self)


    def begin(self):
        """begin(CPVector self) -> std::vector< ControlPoint >::iterator"""
        return _hsi.CPVector_begin(self)


    def end(self):
        """end(CPVector self) -> std::vector< ControlPoint >::iterator"""
        return _hsi.CPVector_end(self)


    def rbegin(self):
        """rbegin(CPVector self) -> std::vector< ControlPoint >::reverse_iterator"""
        return _hsi.CPVector_rbegin(self)


    def rend(self):
        """rend(CPVector self) -> std::vector< ControlPoint >::reverse_iterator"""
        return _hsi.CPVector_rend(self)


    def pop_back(self):
        """pop_back(CPVector self)"""
        return _hsi.CPVector_pop_back(self)


    def erase(self, *args):
        """
        erase(CPVector self, std::vector< ControlPoint >::iterator pos) -> std::vector< ControlPoint >::iterator
        erase(CPVector self, std::vector< ControlPoint >::iterator first, std::vector< ControlPoint >::iterator last) -> std::vector< ControlPoint >::iterator
        """
        return _hsi.CPVector_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::vector<(ControlPoint)> self) -> CPVector
        __init__(std::vector<(ControlPoint)> self, CPVector arg2) -> CPVector
        __init__(std::vector<(ControlPoint)> self, std::vector< ControlPoint >::size_type size) -> CPVector
        __init__(std::vector<(ControlPoint)> self, std::vector< ControlPoint >::size_type size, ControlPoint value) -> CPVector
        """
        this = _hsi.new_CPVector(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def push_back(self, x):
        """push_back(CPVector self, ControlPoint x)"""
        return _hsi.CPVector_push_back(self, x)


    def front(self):
        """front(CPVector self) -> ControlPoint"""
        return _hsi.CPVector_front(self)


    def back(self):
        """back(CPVector self) -> ControlPoint"""
        return _hsi.CPVector_back(self)


    def assign(self, n, x):
        """assign(CPVector self, std::vector< ControlPoint >::size_type n, ControlPoint x)"""
        return _hsi.CPVector_assign(self, n, x)


    def resize(self, *args):
        """
        resize(CPVector self, std::vector< ControlPoint >::size_type new_size)
        resize(CPVector self, std::vector< ControlPoint >::size_type new_size, ControlPoint x)
        """
        return _hsi.CPVector_resize(self, *args)


    def insert(self, *args):
        """
        insert(CPVector self, std::vector< ControlPoint >::iterator pos, ControlPoint x) -> std::vector< ControlPoint >::iterator
        insert(CPVector self, std::vector< ControlPoint >::iterator pos, std::vector< ControlPoint >::size_type n, ControlPoint x)
        """
        return _hsi.CPVector_insert(self, *args)


    def reserve(self, n):
        """reserve(CPVector self, std::vector< ControlPoint >::size_type n)"""
        return _hsi.CPVector_reserve(self, n)


    def capacity(self):
        """capacity(CPVector self) -> std::vector< ControlPoint >::size_type"""
        return _hsi.CPVector_capacity(self)

    __swig_destroy__ = _hsi.delete_CPVector
    __del__ = lambda self: None
CPVector_swigregister = _hsi.CPVector_swigregister
CPVector_swigregister(CPVector)

class ImageVector(_object):
    """Proxy of C++ std::vector<(SrcPanoImage)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ImageVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ImageVector, name)
    __repr__ = _swig_repr

    def iterator(self):
        """iterator(ImageVector self) -> SwigPyIterator"""
        return _hsi.ImageVector_iterator(self)

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

    def __nonzero__(self):
        """__nonzero__(ImageVector self) -> bool"""
        return _hsi.ImageVector___nonzero__(self)


    def __bool__(self):
        """__bool__(ImageVector self) -> bool"""
        return _hsi.ImageVector___bool__(self)


    def __len__(self):
        """__len__(ImageVector self) -> std::vector< SrcPanoImage >::size_type"""
        return _hsi.ImageVector___len__(self)


    def pop(self):
        """pop(ImageVector self) -> SrcPanoImage"""
        return _hsi.ImageVector_pop(self)


    def __getslice__(self, i, j):
        """__getslice__(ImageVector self, std::vector< SrcPanoImage >::difference_type i, std::vector< SrcPanoImage >::difference_type j) -> std::vector< HuginBase::SrcPanoImage,std::allocator< HuginBase::SrcPanoImage > > *"""
        return _hsi.ImageVector___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(ImageVector self, std::vector< SrcPanoImage >::difference_type i, std::vector< SrcPanoImage >::difference_type j, std::vector< HuginBase::SrcPanoImage,std::allocator< HuginBase::SrcPanoImage > > const & v)
        __setslice__(ImageVector self, std::vector< SrcPanoImage >::difference_type i, std::vector< SrcPanoImage >::difference_type j)
        """
        return _hsi.ImageVector___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(ImageVector self, std::vector< SrcPanoImage >::difference_type i, std::vector< SrcPanoImage >::difference_type j)"""
        return _hsi.ImageVector___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(ImageVector self, std::vector< SrcPanoImage >::difference_type i)
        __delitem__(ImageVector self, PySliceObject * slice)
        """
        return _hsi.ImageVector___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(ImageVector self, PySliceObject * slice) -> std::vector< HuginBase::SrcPanoImage,std::allocator< HuginBase::SrcPanoImage > >
        __getitem__(ImageVector self, std::vector< SrcPanoImage >::difference_type i) -> SrcPanoImage
        """
        return _hsi.ImageVector___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(ImageVector self, PySliceObject * slice, std::vector< HuginBase::SrcPanoImage,std::allocator< HuginBase::SrcPanoImage > > const & v)
        __setitem__(ImageVector self, PySliceObject * slice)
        __setitem__(ImageVector self, std::vector< SrcPanoImage >::difference_type i, SrcPanoImage x)
        """
        return _hsi.ImageVector___setitem__(self, *args)


    def append(self, x):
        """append(ImageVector self, SrcPanoImage x)"""
        return _hsi.ImageVector_append(self, x)


    def empty(self):
        """empty(ImageVector self) -> bool"""
        return _hsi.ImageVector_empty(self)


    def size(self):
        """size(ImageVector self) -> std::vector< SrcPanoImage >::size_type"""
        return _hsi.ImageVector_size(self)


    def clear(self):
        """clear(ImageVector self)"""
        return _hsi.ImageVector_clear(self)


    def swap(self, v):
        """swap(ImageVector self, ImageVector v)"""
        return _hsi.ImageVector_swap(self, v)


    def get_allocator(self):
        """get_allocator(ImageVector self) -> std::vector< SrcPanoImage >::allocator_type"""
        return _hsi.ImageVector_get_allocator(self)


    def begin(self):
        """begin(ImageVector self) -> std::vector< SrcPanoImage >::iterator"""
        return _hsi.ImageVector_begin(self)


    def end(self):
        """end(ImageVector self) -> std::vector< SrcPanoImage >::iterator"""
        return _hsi.ImageVector_end(self)


    def rbegin(self):
        """rbegin(ImageVector self) -> std::vector< SrcPanoImage >::reverse_iterator"""
        return _hsi.ImageVector_rbegin(self)


    def rend(self):
        """rend(ImageVector self) -> std::vector< SrcPanoImage >::reverse_iterator"""
        return _hsi.ImageVector_rend(self)


    def pop_back(self):
        """pop_back(ImageVector self)"""
        return _hsi.ImageVector_pop_back(self)


    def erase(self, *args):
        """
        erase(ImageVector self, std::vector< SrcPanoImage >::iterator pos) -> std::vector< SrcPanoImage >::iterator
        erase(ImageVector self, std::vector< SrcPanoImage >::iterator first, std::vector< SrcPanoImage >::iterator last) -> std::vector< SrcPanoImage >::iterator
        """
        return _hsi.ImageVector_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::vector<(SrcPanoImage)> self) -> ImageVector
        __init__(std::vector<(SrcPanoImage)> self, ImageVector arg2) -> ImageVector
        __init__(std::vector<(SrcPanoImage)> self, std::vector< SrcPanoImage >::size_type size) -> ImageVector
        __init__(std::vector<(SrcPanoImage)> self, std::vector< SrcPanoImage >::size_type size, SrcPanoImage value) -> ImageVector
        """
        this = _hsi.new_ImageVector(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def push_back(self, x):
        """push_back(ImageVector self, SrcPanoImage x)"""
        return _hsi.ImageVector_push_back(self, x)


    def front(self):
        """front(ImageVector self) -> SrcPanoImage"""
        return _hsi.ImageVector_front(self)


    def back(self):
        """back(ImageVector self) -> SrcPanoImage"""
        return _hsi.ImageVector_back(self)


    def assign(self, n, x):
        """assign(ImageVector self, std::vector< SrcPanoImage >::size_type n, SrcPanoImage x)"""
        return _hsi.ImageVector_assign(self, n, x)


    def resize(self, *args):
        """
        resize(ImageVector self, std::vector< SrcPanoImage >::size_type new_size)
        resize(ImageVector self, std::vector< SrcPanoImage >::size_type new_size, SrcPanoImage x)
        """
        return _hsi.ImageVector_resize(self, *args)


    def insert(self, *args):
        """
        insert(ImageVector self, std::vector< SrcPanoImage >::iterator pos, SrcPanoImage x) -> std::vector< SrcPanoImage >::iterator
        insert(ImageVector self, std::vector< SrcPanoImage >::iterator pos, std::vector< SrcPanoImage >::size_type n, SrcPanoImage x)
        """
        return _hsi.ImageVector_insert(self, *args)


    def reserve(self, n):
        """reserve(ImageVector self, std::vector< SrcPanoImage >::size_type n)"""
        return _hsi.ImageVector_reserve(self, n)


    def capacity(self):
        """capacity(ImageVector self) -> std::vector< SrcPanoImage >::size_type"""
        return _hsi.ImageVector_capacity(self)

    __swig_destroy__ = _hsi.delete_ImageVector
    __del__ = lambda self: None
ImageVector_swigregister = _hsi.ImageVector_swigregister
ImageVector_swigregister(ImageVector)

class LensVarMap(_object):
    """Proxy of C++ std::map<(std::string,LensVariable)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, LensVarMap, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, LensVarMap, name)
    __repr__ = _swig_repr

    def iterator(self):
        """iterator(LensVarMap self) -> SwigPyIterator"""
        return _hsi.LensVarMap_iterator(self)

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

    def __nonzero__(self):
        """__nonzero__(LensVarMap self) -> bool"""
        return _hsi.LensVarMap___nonzero__(self)


    def __bool__(self):
        """__bool__(LensVarMap self) -> bool"""
        return _hsi.LensVarMap___bool__(self)


    def __len__(self):
        """__len__(LensVarMap self) -> std::map< std::string,LensVariable >::size_type"""
        return _hsi.LensVarMap___len__(self)

    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key):
        """__getitem__(LensVarMap self, std::map< std::string,LensVariable >::key_type const & key) -> LensVariable"""
        return _hsi.LensVarMap___getitem__(self, key)


    def __delitem__(self, key):
        """__delitem__(LensVarMap self, std::map< std::string,LensVariable >::key_type const & key)"""
        return _hsi.LensVarMap___delitem__(self, key)


    def has_key(self, key):
        """has_key(LensVarMap self, std::map< std::string,LensVariable >::key_type const & key) -> bool"""
        return _hsi.LensVarMap_has_key(self, key)


    def keys(self):
        """keys(LensVarMap self) -> PyObject *"""
        return _hsi.LensVarMap_keys(self)


    def values(self):
        """values(LensVarMap self) -> PyObject *"""
        return _hsi.LensVarMap_values(self)


    def items(self):
        """items(LensVarMap self) -> PyObject *"""
        return _hsi.LensVarMap_items(self)


    def __contains__(self, key):
        """__contains__(LensVarMap self, std::map< std::string,LensVariable >::key_type const & key) -> bool"""
        return _hsi.LensVarMap___contains__(self, key)


    def key_iterator(self):
        """key_iterator(LensVarMap self) -> SwigPyIterator"""
        return _hsi.LensVarMap_key_iterator(self)


    def value_iterator(self):
        """value_iterator(LensVarMap self) -> SwigPyIterator"""
        return _hsi.LensVarMap_value_iterator(self)


    def __setitem__(self, *args):
        """
        __setitem__(LensVarMap self, std::map< std::string,LensVariable >::key_type const & key)
        __setitem__(LensVarMap self, std::map< std::string,LensVariable >::key_type const & key, LensVariable x)
        """
        return _hsi.LensVarMap___setitem__(self, *args)


    def asdict(self):
        """asdict(LensVarMap self) -> PyObject *"""
        return _hsi.LensVarMap_asdict(self)


    def __init__(self, *args):
        """
        __init__(std::map<(std::string,LensVariable)> self, std::less< std::string > const & arg2) -> LensVarMap
        __init__(std::map<(std::string,LensVariable)> self) -> LensVarMap
        __init__(std::map<(std::string,LensVariable)> self, LensVarMap arg2) -> LensVarMap
        """
        this = _hsi.new_LensVarMap(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def empty(self):
        """empty(LensVarMap self) -> bool"""
        return _hsi.LensVarMap_empty(self)


    def size(self):
        """size(LensVarMap self) -> std::map< std::string,LensVariable >::size_type"""
        return _hsi.LensVarMap_size(self)


    def clear(self):
        """clear(LensVarMap self)"""
        return _hsi.LensVarMap_clear(self)


    def swap(self, v):
        """swap(LensVarMap self, LensVarMap v)"""
        return _hsi.LensVarMap_swap(self, v)


    def get_allocator(self):
        """get_allocator(LensVarMap self) -> std::map< std::string,LensVariable >::allocator_type"""
        return _hsi.LensVarMap_get_allocator(self)


    def begin(self):
        """begin(LensVarMap self) -> std::map< std::string,LensVariable >::iterator"""
        return _hsi.LensVarMap_begin(self)


    def end(self):
        """end(LensVarMap self) -> std::map< std::string,LensVariable >::iterator"""
        return _hsi.LensVarMap_end(self)


    def rbegin(self):
        """rbegin(LensVarMap self) -> std::map< std::string,LensVariable >::reverse_iterator"""
        return _hsi.LensVarMap_rbegin(self)


    def rend(self):
        """rend(LensVarMap self) -> std::map< std::string,LensVariable >::reverse_iterator"""
        return _hsi.LensVarMap_rend(self)


    def count(self, x):
        """count(LensVarMap self, std::map< std::string,LensVariable >::key_type const & x) -> std::map< std::string,LensVariable >::size_type"""
        return _hsi.LensVarMap_count(self, x)


    def erase(self, *args):
        """
        erase(LensVarMap self, std::map< std::string,LensVariable >::key_type const & x) -> std::map< std::string,LensVariable >::size_type
        erase(LensVarMap self, std::map< std::string,LensVariable >::iterator position)
        erase(LensVarMap self, std::map< std::string,LensVariable >::iterator first, std::map< std::string,LensVariable >::iterator last)
        """
        return _hsi.LensVarMap_erase(self, *args)


    def find(self, x):
        """find(LensVarMap self, std::map< std::string,LensVariable >::key_type const & x) -> std::map< std::string,LensVariable >::iterator"""
        return _hsi.LensVarMap_find(self, x)


    def lower_bound(self, x):
        """lower_bound(LensVarMap self, std::map< std::string,LensVariable >::key_type const & x) -> std::map< std::string,LensVariable >::iterator"""
        return _hsi.LensVarMap_lower_bound(self, x)


    def upper_bound(self, x):
        """upper_bound(LensVarMap self, std::map< std::string,LensVariable >::key_type const & x) -> std::map< std::string,LensVariable >::iterator"""
        return _hsi.LensVarMap_upper_bound(self, x)

    __swig_destroy__ = _hsi.delete_LensVarMap
    __del__ = lambda self: None
LensVarMap_swigregister = _hsi.LensVarMap_swigregister
LensVarMap_swigregister(LensVarMap)

class OptimizeVector(_object):
    """Proxy of C++ std::vector<(std::set<(std::string)>)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, OptimizeVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, OptimizeVector, name)
    __repr__ = _swig_repr

    def iterator(self):
        """iterator(OptimizeVector self) -> SwigPyIterator"""
        return _hsi.OptimizeVector_iterator(self)

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

    def __nonzero__(self):
        """__nonzero__(OptimizeVector self) -> bool"""
        return _hsi.OptimizeVector___nonzero__(self)


    def __bool__(self):
        """__bool__(OptimizeVector self) -> bool"""
        return _hsi.OptimizeVector___bool__(self)


    def __len__(self):
        """__len__(OptimizeVector self) -> std::vector< std::set< std::string > >::size_type"""
        return _hsi.OptimizeVector___len__(self)


    def pop(self):
        """pop(OptimizeVector self) -> std::vector< std::set< std::string > >::value_type"""
        return _hsi.OptimizeVector_pop(self)


    def __getslice__(self, i, j):
        """__getslice__(OptimizeVector self, std::vector< std::set< std::string > >::difference_type i, std::vector< std::set< std::string > >::difference_type j) -> OptimizeVector"""
        return _hsi.OptimizeVector___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(OptimizeVector self, std::vector< std::set< std::string > >::difference_type i, std::vector< std::set< std::string > >::difference_type j, OptimizeVector v)
        __setslice__(OptimizeVector self, std::vector< std::set< std::string > >::difference_type i, std::vector< std::set< std::string > >::difference_type j)
        """
        return _hsi.OptimizeVector___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(OptimizeVector self, std::vector< std::set< std::string > >::difference_type i, std::vector< std::set< std::string > >::difference_type j)"""
        return _hsi.OptimizeVector___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(OptimizeVector self, std::vector< std::set< std::string > >::difference_type i)
        __delitem__(OptimizeVector self, PySliceObject * slice)
        """
        return _hsi.OptimizeVector___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(OptimizeVector self, PySliceObject * slice) -> OptimizeVector
        __getitem__(OptimizeVector self, std::vector< std::set< std::string > >::difference_type i) -> std::vector< std::set< std::string > >::value_type const &
        """
        return _hsi.OptimizeVector___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(OptimizeVector self, PySliceObject * slice, OptimizeVector v)
        __setitem__(OptimizeVector self, PySliceObject * slice)
        __setitem__(OptimizeVector self, std::vector< std::set< std::string > >::difference_type i, std::vector< std::set< std::string > >::value_type const & x)
        """
        return _hsi.OptimizeVector___setitem__(self, *args)


    def append(self, x):
        """append(OptimizeVector self, std::vector< std::set< std::string > >::value_type const & x)"""
        return _hsi.OptimizeVector_append(self, x)


    def empty(self):
        """empty(OptimizeVector self) -> bool"""
        return _hsi.OptimizeVector_empty(self)


    def size(self):
        """size(OptimizeVector self) -> std::vector< std::set< std::string > >::size_type"""
        return _hsi.OptimizeVector_size(self)


    def clear(self):
        """clear(OptimizeVector self)"""
        return _hsi.OptimizeVector_clear(self)


    def swap(self, v):
        """swap(OptimizeVector self, OptimizeVector v)"""
        return _hsi.OptimizeVector_swap(self, v)


    def get_allocator(self):
        """get_allocator(OptimizeVector self) -> std::vector< std::set< std::string > >::allocator_type"""
        return _hsi.OptimizeVector_get_allocator(self)


    def begin(self):
        """begin(OptimizeVector self) -> std::vector< std::set< std::string > >::iterator"""
        return _hsi.OptimizeVector_begin(self)


    def end(self):
        """end(OptimizeVector self) -> std::vector< std::set< std::string > >::iterator"""
        return _hsi.OptimizeVector_end(self)


    def rbegin(self):
        """rbegin(OptimizeVector self) -> std::vector< std::set< std::string > >::reverse_iterator"""
        return _hsi.OptimizeVector_rbegin(self)


    def rend(self):
        """rend(OptimizeVector self) -> std::vector< std::set< std::string > >::reverse_iterator"""
        return _hsi.OptimizeVector_rend(self)


    def pop_back(self):
        """pop_back(OptimizeVector self)"""
        return _hsi.OptimizeVector_pop_back(self)


    def erase(self, *args):
        """
        erase(OptimizeVector self, std::vector< std::set< std::string > >::iterator pos) -> std::vector< std::set< std::string > >::iterator
        erase(OptimizeVector self, std::vector< std::set< std::string > >::iterator first, std::vector< std::set< std::string > >::iterator last) -> std::vector< std::set< std::string > >::iterator
        """
        return _hsi.OptimizeVector_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::vector<(std::set<(std::string)>)> self) -> OptimizeVector
        __init__(std::vector<(std::set<(std::string)>)> self, OptimizeVector arg2) -> OptimizeVector
        __init__(std::vector<(std::set<(std::string)>)> self, std::vector< std::set< std::string > >::size_type size) -> OptimizeVector
        __init__(std::vector<(std::set<(std::string)>)> self, std::vector< std::set< std::string > >::size_type size, std::vector< std::set< std::string > >::value_type const & value) -> OptimizeVector
        """
        this = _hsi.new_OptimizeVector(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def push_back(self, x):
        """push_back(OptimizeVector self, std::vector< std::set< std::string > >::value_type const & x)"""
        return _hsi.OptimizeVector_push_back(self, x)


    def front(self):
        """front(OptimizeVector self) -> std::vector< std::set< std::string > >::value_type const &"""
        return _hsi.OptimizeVector_front(self)


    def back(self):
        """back(OptimizeVector self) -> std::vector< std::set< std::string > >::value_type const &"""
        return _hsi.OptimizeVector_back(self)


    def assign(self, n, x):
        """assign(OptimizeVector self, std::vector< std::set< std::string > >::size_type n, std::vector< std::set< std::string > >::value_type const & x)"""
        return _hsi.OptimizeVector_assign(self, n, x)


    def resize(self, *args):
        """
        resize(OptimizeVector self, std::vector< std::set< std::string > >::size_type new_size)
        resize(OptimizeVector self, std::vector< std::set< std::string > >::size_type new_size, std::vector< std::set< std::string > >::value_type const & x)
        """
        return _hsi.OptimizeVector_resize(self, *args)


    def insert(self, *args):
        """
        insert(OptimizeVector self, std::vector< std::set< std::string > >::iterator pos, std::vector< std::set< std::string > >::value_type const & x) -> std::vector< std::set< std::string > >::iterator
        insert(OptimizeVector self, std::vector< std::set< std::string > >::iterator pos, std::vector< std::set< std::string > >::size_type n, std::vector< std::set< std::string > >::value_type const & x)
        """
        return _hsi.OptimizeVector_insert(self, *args)


    def reserve(self, n):
        """reserve(OptimizeVector self, std::vector< std::set< std::string > >::size_type n)"""
        return _hsi.OptimizeVector_reserve(self, n)


    def capacity(self):
        """capacity(OptimizeVector self) -> std::vector< std::set< std::string > >::size_type"""
        return _hsi.OptimizeVector_capacity(self)

    __swig_destroy__ = _hsi.delete_OptimizeVector
    __del__ = lambda self: None
OptimizeVector_swigregister = _hsi.OptimizeVector_swigregister
OptimizeVector_swigregister(OptimizeVector)

class VariableMap(_object):
    """Proxy of C++ std::map<(std::string,Variable)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, VariableMap, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, VariableMap, name)
    __repr__ = _swig_repr

    def iterator(self):
        """iterator(VariableMap self) -> SwigPyIterator"""
        return _hsi.VariableMap_iterator(self)

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

    def __nonzero__(self):
        """__nonzero__(VariableMap self) -> bool"""
        return _hsi.VariableMap___nonzero__(self)


    def __bool__(self):
        """__bool__(VariableMap self) -> bool"""
        return _hsi.VariableMap___bool__(self)


    def __len__(self):
        """__len__(VariableMap self) -> std::map< std::string,Variable >::size_type"""
        return _hsi.VariableMap___len__(self)

    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key):
        """__getitem__(VariableMap self, std::map< std::string,Variable >::key_type const & key) -> Variable"""
        return _hsi.VariableMap___getitem__(self, key)


    def __delitem__(self, key):
        """__delitem__(VariableMap self, std::map< std::string,Variable >::key_type const & key)"""
        return _hsi.VariableMap___delitem__(self, key)


    def has_key(self, key):
        """has_key(VariableMap self, std::map< std::string,Variable >::key_type const & key) -> bool"""
        return _hsi.VariableMap_has_key(self, key)


    def keys(self):
        """keys(VariableMap self) -> PyObject *"""
        return _hsi.VariableMap_keys(self)


    def values(self):
        """values(VariableMap self) -> PyObject *"""
        return _hsi.VariableMap_values(self)


    def items(self):
        """items(VariableMap self) -> PyObject *"""
        return _hsi.VariableMap_items(self)


    def __contains__(self, key):
        """__contains__(VariableMap self, std::map< std::string,Variable >::key_type const & key) -> bool"""
        return _hsi.VariableMap___contains__(self, key)


    def key_iterator(self):
        """key_iterator(VariableMap self) -> SwigPyIterator"""
        return _hsi.VariableMap_key_iterator(self)


    def value_iterator(self):
        """value_iterator(VariableMap self) -> SwigPyIterator"""
        return _hsi.VariableMap_value_iterator(self)


    def __setitem__(self, *args):
        """
        __setitem__(VariableMap self, std::map< std::string,Variable >::key_type const & key)
        __setitem__(VariableMap self, std::map< std::string,Variable >::key_type const & key, Variable x)
        """
        return _hsi.VariableMap___setitem__(self, *args)


    def asdict(self):
        """asdict(VariableMap self) -> PyObject *"""
        return _hsi.VariableMap_asdict(self)


    def __init__(self, *args):
        """
        __init__(std::map<(std::string,Variable)> self, std::less< std::string > const & arg2) -> VariableMap
        __init__(std::map<(std::string,Variable)> self) -> VariableMap
        __init__(std::map<(std::string,Variable)> self, VariableMap arg2) -> VariableMap
        """
        this = _hsi.new_VariableMap(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def empty(self):
        """empty(VariableMap self) -> bool"""
        return _hsi.VariableMap_empty(self)


    def size(self):
        """size(VariableMap self) -> std::map< std::string,Variable >::size_type"""
        return _hsi.VariableMap_size(self)


    def clear(self):
        """clear(VariableMap self)"""
        return _hsi.VariableMap_clear(self)


    def swap(self, v):
        """swap(VariableMap self, VariableMap v)"""
        return _hsi.VariableMap_swap(self, v)


    def get_allocator(self):
        """get_allocator(VariableMap self) -> std::map< std::string,Variable >::allocator_type"""
        return _hsi.VariableMap_get_allocator(self)


    def begin(self):
        """begin(VariableMap self) -> std::map< std::string,Variable >::iterator"""
        return _hsi.VariableMap_begin(self)


    def end(self):
        """end(VariableMap self) -> std::map< std::string,Variable >::iterator"""
        return _hsi.VariableMap_end(self)


    def rbegin(self):
        """rbegin(VariableMap self) -> std::map< std::string,Variable >::reverse_iterator"""
        return _hsi.VariableMap_rbegin(self)


    def rend(self):
        """rend(VariableMap self) -> std::map< std::string,Variable >::reverse_iterator"""
        return _hsi.VariableMap_rend(self)


    def count(self, x):
        """count(VariableMap self, std::map< std::string,Variable >::key_type const & x) -> std::map< std::string,Variable >::size_type"""
        return _hsi.VariableMap_count(self, x)


    def erase(self, *args):
        """
        erase(VariableMap self, std::map< std::string,Variable >::key_type const & x) -> std::map< std::string,Variable >::size_type
        erase(VariableMap self, std::map< std::string,Variable >::iterator position)
        erase(VariableMap self, std::map< std::string,Variable >::iterator first, std::map< std::string,Variable >::iterator last)
        """
        return _hsi.VariableMap_erase(self, *args)


    def find(self, x):
        """find(VariableMap self, std::map< std::string,Variable >::key_type const & x) -> std::map< std::string,Variable >::iterator"""
        return _hsi.VariableMap_find(self, x)


    def lower_bound(self, x):
        """lower_bound(VariableMap self, std::map< std::string,Variable >::key_type const & x) -> std::map< std::string,Variable >::iterator"""
        return _hsi.VariableMap_lower_bound(self, x)


    def upper_bound(self, x):
        """upper_bound(VariableMap self, std::map< std::string,Variable >::key_type const & x) -> std::map< std::string,Variable >::iterator"""
        return _hsi.VariableMap_upper_bound(self, x)

    __swig_destroy__ = _hsi.delete_VariableMap
    __del__ = lambda self: None
VariableMap_swigregister = _hsi.VariableMap_swigregister
VariableMap_swigregister(VariableMap)

class VariableMapVector(_object):
    """Proxy of C++ std::vector<(std::map<(std::string,Variable)>)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, VariableMapVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, VariableMapVector, name)
    __repr__ = _swig_repr

    def iterator(self):
        """iterator(VariableMapVector self) -> SwigPyIterator"""
        return _hsi.VariableMapVector_iterator(self)

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

    def __nonzero__(self):
        """__nonzero__(VariableMapVector self) -> bool"""
        return _hsi.VariableMapVector___nonzero__(self)


    def __bool__(self):
        """__bool__(VariableMapVector self) -> bool"""
        return _hsi.VariableMapVector___bool__(self)


    def __len__(self):
        """__len__(VariableMapVector self) -> std::vector< std::map< std::string,Variable > >::size_type"""
        return _hsi.VariableMapVector___len__(self)


    def pop(self):
        """pop(VariableMapVector self) -> std::vector< std::map< std::string,Variable > >::value_type"""
        return _hsi.VariableMapVector_pop(self)


    def __getslice__(self, i, j):
        """__getslice__(VariableMapVector self, std::vector< std::map< std::string,Variable > >::difference_type i, std::vector< std::map< std::string,Variable > >::difference_type j) -> std::vector< std::map< std::string,HuginBase::Variable,std::less< std::string >,std::allocator< std::pair< std::string const,HuginBase::Variable > > >,std::allocator< std::map< std::string,HuginBase::Variable,std::less< std::string >,std::allocator< std::pair< std::string const,HuginBase::Variable > > > > > *"""
        return _hsi.VariableMapVector___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(VariableMapVector self, std::vector< std::map< std::string,Variable > >::difference_type i, std::vector< std::map< std::string,Variable > >::difference_type j, std::vector< std::map< std::string,HuginBase::Variable,std::less< std::string >,std::allocator< std::pair< std::string const,HuginBase::Variable > > >,std::allocator< std::map< std::string,HuginBase::Variable,std::less< std::string >,std::allocator< std::pair< std::string const,HuginBase::Variable > > > > > const & v)
        __setslice__(VariableMapVector self, std::vector< std::map< std::string,Variable > >::difference_type i, std::vector< std::map< std::string,Variable > >::difference_type j)
        """
        return _hsi.VariableMapVector___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(VariableMapVector self, std::vector< std::map< std::string,Variable > >::difference_type i, std::vector< std::map< std::string,Variable > >::difference_type j)"""
        return _hsi.VariableMapVector___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(VariableMapVector self, std::vector< std::map< std::string,Variable > >::difference_type i)
        __delitem__(VariableMapVector self, PySliceObject * slice)
        """
        return _hsi.VariableMapVector___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(VariableMapVector self, PySliceObject * slice) -> std::vector< std::map< std::string,HuginBase::Variable,std::less< std::string >,std::allocator< std::pair< std::string const,HuginBase::Variable > > >,std::allocator< std::map< std::string,HuginBase::Variable,std::less< std::string >,std::allocator< std::pair< std::string const,HuginBase::Variable > > > > >
        __getitem__(VariableMapVector self, std::vector< std::map< std::string,Variable > >::difference_type i) -> std::vector< std::map< std::string,Variable > >::value_type const &
        """
        return _hsi.VariableMapVector___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(VariableMapVector self, PySliceObject * slice, std::vector< std::map< std::string,HuginBase::Variable,std::less< std::string >,std::allocator< std::pair< std::string const,HuginBase::Variable > > >,std::allocator< std::map< std::string,HuginBase::Variable,std::less< std::string >,std::allocator< std::pair< std::string const,HuginBase::Variable > > > > > const & v)
        __setitem__(VariableMapVector self, PySliceObject * slice)
        __setitem__(VariableMapVector self, std::vector< std::map< std::string,Variable > >::difference_type i, std::vector< std::map< std::string,Variable > >::value_type const & x)
        """
        return _hsi.VariableMapVector___setitem__(self, *args)


    def append(self, x):
        """append(VariableMapVector self, std::vector< std::map< std::string,Variable > >::value_type const & x)"""
        return _hsi.VariableMapVector_append(self, x)


    def empty(self):
        """empty(VariableMapVector self) -> bool"""
        return _hsi.VariableMapVector_empty(self)


    def size(self):
        """size(VariableMapVector self) -> std::vector< std::map< std::string,Variable > >::size_type"""
        return _hsi.VariableMapVector_size(self)


    def clear(self):
        """clear(VariableMapVector self)"""
        return _hsi.VariableMapVector_clear(self)


    def swap(self, v):
        """swap(VariableMapVector self, std::vector< std::map< std::string,HuginBase::Variable,std::less< std::string >,std::allocator< std::pair< std::string const,HuginBase::Variable > > > > & v)"""
        return _hsi.VariableMapVector_swap(self, v)


    def get_allocator(self):
        """get_allocator(VariableMapVector self) -> std::vector< std::map< std::string,Variable > >::allocator_type"""
        return _hsi.VariableMapVector_get_allocator(self)


    def begin(self):
        """begin(VariableMapVector self) -> std::vector< std::map< std::string,Variable > >::iterator"""
        return _hsi.VariableMapVector_begin(self)


    def end(self):
        """end(VariableMapVector self) -> std::vector< std::map< std::string,Variable > >::iterator"""
        return _hsi.VariableMapVector_end(self)


    def rbegin(self):
        """rbegin(VariableMapVector self) -> std::vector< std::map< std::string,Variable > >::reverse_iterator"""
        return _hsi.VariableMapVector_rbegin(self)


    def rend(self):
        """rend(VariableMapVector self) -> std::vector< std::map< std::string,Variable > >::reverse_iterator"""
        return _hsi.VariableMapVector_rend(self)


    def pop_back(self):
        """pop_back(VariableMapVector self)"""
        return _hsi.VariableMapVector_pop_back(self)


    def erase(self, *args):
        """
        erase(VariableMapVector self, std::vector< std::map< std::string,Variable > >::iterator pos) -> std::vector< std::map< std::string,Variable > >::iterator
        erase(VariableMapVector self, std::vector< std::map< std::string,Variable > >::iterator first, std::vector< std::map< std::string,Variable > >::iterator last) -> std::vector< std::map< std::string,Variable > >::iterator
        """
        return _hsi.VariableMapVector_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::vector<(std::map<(std::string,Variable)>)> self) -> VariableMapVector
        __init__(std::vector<(std::map<(std::string,Variable)>)> self, std::vector< std::map< std::string,HuginBase::Variable,std::less< std::string >,std::allocator< std::pair< std::string const,HuginBase::Variable > > > > const & arg2) -> VariableMapVector
        __init__(std::vector<(std::map<(std::string,Variable)>)> self, std::vector< std::map< std::string,Variable > >::size_type size) -> VariableMapVector
        __init__(std::vector<(std::map<(std::string,Variable)>)> self, std::vector< std::map< std::string,Variable > >::size_type size, std::vector< std::map< std::string,Variable > >::value_type const & value) -> VariableMapVector
        """
        this = _hsi.new_VariableMapVector(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def push_back(self, x):
        """push_back(VariableMapVector self, std::vector< std::map< std::string,Variable > >::value_type const & x)"""
        return _hsi.VariableMapVector_push_back(self, x)


    def front(self):
        """front(VariableMapVector self) -> std::vector< std::map< std::string,Variable > >::value_type const &"""
        return _hsi.VariableMapVector_front(self)


    def back(self):
        """back(VariableMapVector self) -> std::vector< std::map< std::string,Variable > >::value_type const &"""
        return _hsi.VariableMapVector_back(self)


    def assign(self, n, x):
        """assign(VariableMapVector self, std::vector< std::map< std::string,Variable > >::size_type n, std::vector< std::map< std::string,Variable > >::value_type const & x)"""
        return _hsi.VariableMapVector_assign(self, n, x)


    def resize(self, *args):
        """
        resize(VariableMapVector self, std::vector< std::map< std::string,Variable > >::size_type new_size)
        resize(VariableMapVector self, std::vector< std::map< std::string,Variable > >::size_type new_size, std::vector< std::map< std::string,Variable > >::value_type const & x)
        """
        return _hsi.VariableMapVector_resize(self, *args)


    def insert(self, *args):
        """
        insert(VariableMapVector self, std::vector< std::map< std::string,Variable > >::iterator pos, std::vector< std::map< std::string,Variable > >::value_type const & x) -> std::vector< std::map< std::string,Variable > >::iterator
        insert(VariableMapVector self, std::vector< std::map< std::string,Variable > >::iterator pos, std::vector< std::map< std::string,Variable > >::size_type n, std::vector< std::map< std::string,Variable > >::value_type const & x)
        """
        return _hsi.VariableMapVector_insert(self, *args)


    def reserve(self, n):
        """reserve(VariableMapVector self, std::vector< std::map< std::string,Variable > >::size_type n)"""
        return _hsi.VariableMapVector_reserve(self, n)


    def capacity(self):
        """capacity(VariableMapVector self) -> std::vector< std::map< std::string,Variable > >::size_type"""
        return _hsi.VariableMapVector_capacity(self)

    __swig_destroy__ = _hsi.delete_VariableMapVector
    __del__ = lambda self: None
VariableMapVector_swigregister = _hsi.VariableMapVector_swigregister
VariableMapVector_swigregister(VariableMapVector)

class MaskPolygonVector(_object):
    """Proxy of C++ std::vector<(MaskPolygon)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, MaskPolygonVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, MaskPolygonVector, name)
    __repr__ = _swig_repr

    def iterator(self):
        """iterator(MaskPolygonVector self) -> SwigPyIterator"""
        return _hsi.MaskPolygonVector_iterator(self)

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

    def __nonzero__(self):
        """__nonzero__(MaskPolygonVector self) -> bool"""
        return _hsi.MaskPolygonVector___nonzero__(self)


    def __bool__(self):
        """__bool__(MaskPolygonVector self) -> bool"""
        return _hsi.MaskPolygonVector___bool__(self)


    def __len__(self):
        """__len__(MaskPolygonVector self) -> std::vector< MaskPolygon >::size_type"""
        return _hsi.MaskPolygonVector___len__(self)


    def pop(self):
        """pop(MaskPolygonVector self) -> MaskPolygon"""
        return _hsi.MaskPolygonVector_pop(self)


    def __getslice__(self, i, j):
        """__getslice__(MaskPolygonVector self, std::vector< MaskPolygon >::difference_type i, std::vector< MaskPolygon >::difference_type j) -> std::vector< HuginBase::MaskPolygon,std::allocator< HuginBase::MaskPolygon > > *"""
        return _hsi.MaskPolygonVector___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(MaskPolygonVector self, std::vector< MaskPolygon >::difference_type i, std::vector< MaskPolygon >::difference_type j, std::vector< HuginBase::MaskPolygon,std::allocator< HuginBase::MaskPolygon > > const & v)
        __setslice__(MaskPolygonVector self, std::vector< MaskPolygon >::difference_type i, std::vector< MaskPolygon >::difference_type j)
        """
        return _hsi.MaskPolygonVector___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(MaskPolygonVector self, std::vector< MaskPolygon >::difference_type i, std::vector< MaskPolygon >::difference_type j)"""
        return _hsi.MaskPolygonVector___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(MaskPolygonVector self, std::vector< MaskPolygon >::difference_type i)
        __delitem__(MaskPolygonVector self, PySliceObject * slice)
        """
        return _hsi.MaskPolygonVector___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(MaskPolygonVector self, PySliceObject * slice) -> std::vector< HuginBase::MaskPolygon,std::allocator< HuginBase::MaskPolygon > >
        __getitem__(MaskPolygonVector self, std::vector< MaskPolygon >::difference_type i) -> MaskPolygon
        """
        return _hsi.MaskPolygonVector___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(MaskPolygonVector self, PySliceObject * slice, std::vector< HuginBase::MaskPolygon,std::allocator< HuginBase::MaskPolygon > > const & v)
        __setitem__(MaskPolygonVector self, PySliceObject * slice)
        __setitem__(MaskPolygonVector self, std::vector< MaskPolygon >::difference_type i, MaskPolygon x)
        """
        return _hsi.MaskPolygonVector___setitem__(self, *args)


    def append(self, x):
        """append(MaskPolygonVector self, MaskPolygon x)"""
        return _hsi.MaskPolygonVector_append(self, x)


    def empty(self):
        """empty(MaskPolygonVector self) -> bool"""
        return _hsi.MaskPolygonVector_empty(self)


    def size(self):
        """size(MaskPolygonVector self) -> std::vector< MaskPolygon >::size_type"""
        return _hsi.MaskPolygonVector_size(self)


    def clear(self):
        """clear(MaskPolygonVector self)"""
        return _hsi.MaskPolygonVector_clear(self)


    def swap(self, v):
        """swap(MaskPolygonVector self, MaskPolygonVector v)"""
        return _hsi.MaskPolygonVector_swap(self, v)


    def get_allocator(self):
        """get_allocator(MaskPolygonVector self) -> std::vector< MaskPolygon >::allocator_type"""
        return _hsi.MaskPolygonVector_get_allocator(self)


    def begin(self):
        """begin(MaskPolygonVector self) -> std::vector< MaskPolygon >::iterator"""
        return _hsi.MaskPolygonVector_begin(self)


    def end(self):
        """end(MaskPolygonVector self) -> std::vector< MaskPolygon >::iterator"""
        return _hsi.MaskPolygonVector_end(self)


    def rbegin(self):
        """rbegin(MaskPolygonVector self) -> std::vector< MaskPolygon >::reverse_iterator"""
        return _hsi.MaskPolygonVector_rbegin(self)


    def rend(self):
        """rend(MaskPolygonVector self) -> std::vector< MaskPolygon >::reverse_iterator"""
        return _hsi.MaskPolygonVector_rend(self)


    def pop_back(self):
        """pop_back(MaskPolygonVector self)"""
        return _hsi.MaskPolygonVector_pop_back(self)


    def erase(self, *args):
        """
        erase(MaskPolygonVector self, std::vector< MaskPolygon >::iterator pos) -> std::vector< MaskPolygon >::iterator
        erase(MaskPolygonVector self, std::vector< MaskPolygon >::iterator first, std::vector< MaskPolygon >::iterator last) -> std::vector< MaskPolygon >::iterator
        """
        return _hsi.MaskPolygonVector_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::vector<(MaskPolygon)> self) -> MaskPolygonVector
        __init__(std::vector<(MaskPolygon)> self, MaskPolygonVector arg2) -> MaskPolygonVector
        __init__(std::vector<(MaskPolygon)> self, std::vector< MaskPolygon >::size_type size) -> MaskPolygonVector
        __init__(std::vector<(MaskPolygon)> self, std::vector< MaskPolygon >::size_type size, MaskPolygon value) -> MaskPolygonVector
        """
        this = _hsi.new_MaskPolygonVector(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def push_back(self, x):
        """push_back(MaskPolygonVector self, MaskPolygon x)"""
        return _hsi.MaskPolygonVector_push_back(self, x)


    def front(self):
        """front(MaskPolygonVector self) -> MaskPolygon"""
        return _hsi.MaskPolygonVector_front(self)


    def back(self):
        """back(MaskPolygonVector self) -> MaskPolygon"""
        return _hsi.MaskPolygonVector_back(self)


    def assign(self, n, x):
        """assign(MaskPolygonVector self, std::vector< MaskPolygon >::size_type n, MaskPolygon x)"""
        return _hsi.MaskPolygonVector_assign(self, n, x)


    def resize(self, *args):
        """
        resize(MaskPolygonVector self, std::vector< MaskPolygon >::size_type new_size)
        resize(MaskPolygonVector self, std::vector< MaskPolygon >::size_type new_size, MaskPolygon x)
        """
        return _hsi.MaskPolygonVector_resize(self, *args)


    def insert(self, *args):
        """
        insert(MaskPolygonVector self, std::vector< MaskPolygon >::iterator pos, MaskPolygon x) -> std::vector< MaskPolygon >::iterator
        insert(MaskPolygonVector self, std::vector< MaskPolygon >::iterator pos, std::vector< MaskPolygon >::size_type n, MaskPolygon x)
        """
        return _hsi.MaskPolygonVector_insert(self, *args)


    def reserve(self, n):
        """reserve(MaskPolygonVector self, std::vector< MaskPolygon >::size_type n)"""
        return _hsi.MaskPolygonVector_reserve(self, n)


    def capacity(self):
        """capacity(MaskPolygonVector self) -> std::vector< MaskPolygon >::size_type"""
        return _hsi.MaskPolygonVector_capacity(self)

    __swig_destroy__ = _hsi.delete_MaskPolygonVector
    __del__ = lambda self: None
MaskPolygonVector_swigregister = _hsi.MaskPolygonVector_swigregister
MaskPolygonVector_swigregister(MaskPolygonVector)

class PTOVariableConverterNoOp(_object):
    """Proxy of C++ HuginBase::PTOVariableConverterNoOp class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, PTOVariableConverterNoOp, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, PTOVariableConverterNoOp, name)
    __repr__ = _swig_repr

    def checkApplicability(name):
        """checkApplicability(std::string const & name) -> bool"""
        return _hsi.PTOVariableConverterNoOp_checkApplicability(name)

    if _newclass:
        checkApplicability = staticmethod(checkApplicability)
    __swig_getmethods__["checkApplicability"] = lambda x: checkApplicability

    def __init__(self):
        """__init__(HuginBase::PTOVariableConverterNoOp self) -> PTOVariableConverterNoOp"""
        this = _hsi.new_PTOVariableConverterNoOp()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _hsi.delete_PTOVariableConverterNoOp
    __del__ = lambda self: None
PTOVariableConverterNoOp_swigregister = _hsi.PTOVariableConverterNoOp_swigregister
PTOVariableConverterNoOp_swigregister(PTOVariableConverterNoOp)

def PTOVariableConverterNoOp_checkApplicability(name):
    """PTOVariableConverterNoOp_checkApplicability(std::string const & name) -> bool"""
    return _hsi.PTOVariableConverterNoOp_checkApplicability(name)

class ConstImageVariableGroup(_object):
    """Proxy of C++ HuginBase::ConstImageVariableGroup class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ConstImageVariableGroup, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ConstImageVariableGroup, name)
    __repr__ = _swig_repr
    IVE_Filename = _hsi.ConstImageVariableGroup_IVE_Filename
    IVE_Size = _hsi.ConstImageVariableGroup_IVE_Size
    IVE_Projection = _hsi.ConstImageVariableGroup_IVE_Projection
    IVE_HFOV = _hsi.ConstImageVariableGroup_IVE_HFOV
    IVE_CropFactor = _hsi.ConstImageVariableGroup_IVE_CropFactor
    IVE_ResponseType = _hsi.ConstImageVariableGroup_IVE_ResponseType
    IVE_EMoRParams = _hsi.ConstImageVariableGroup_IVE_EMoRParams
    IVE_ExposureValue = _hsi.ConstImageVariableGroup_IVE_ExposureValue
    IVE_Gamma = _hsi.ConstImageVariableGroup_IVE_Gamma
    IVE_WhiteBalanceRed = _hsi.ConstImageVariableGroup_IVE_WhiteBalanceRed
    IVE_WhiteBalanceBlue = _hsi.ConstImageVariableGroup_IVE_WhiteBalanceBlue
    IVE_Roll = _hsi.ConstImageVariableGroup_IVE_Roll
    IVE_Pitch = _hsi.ConstImageVariableGroup_IVE_Pitch
    IVE_Yaw = _hsi.ConstImageVariableGroup_IVE_Yaw
    IVE_X = _hsi.ConstImageVariableGroup_IVE_X
    IVE_Y = _hsi.ConstImageVariableGroup_IVE_Y
    IVE_Z = _hsi.ConstImageVariableGroup_IVE_Z
    IVE_TranslationPlaneYaw = _hsi.ConstImageVariableGroup_IVE_TranslationPlaneYaw
    IVE_TranslationPlanePitch = _hsi.ConstImageVariableGroup_IVE_TranslationPlanePitch
    IVE_Stack = _hsi.ConstImageVariableGroup_IVE_Stack
    IVE_RadialDistortion = _hsi.ConstImageVariableGroup_IVE_RadialDistortion
    IVE_RadialDistortionRed = _hsi.ConstImageVariableGroup_IVE_RadialDistortionRed
    IVE_RadialDistortionBlue = _hsi.ConstImageVariableGroup_IVE_RadialDistortionBlue
    IVE_RadialDistortionCenterShift = _hsi.ConstImageVariableGroup_IVE_RadialDistortionCenterShift
    IVE_Shear = _hsi.ConstImageVariableGroup_IVE_Shear
    IVE_CropMode = _hsi.ConstImageVariableGroup_IVE_CropMode
    IVE_CropRect = _hsi.ConstImageVariableGroup_IVE_CropRect
    IVE_AutoCenterCrop = _hsi.ConstImageVariableGroup_IVE_AutoCenterCrop
    IVE_VigCorrMode = _hsi.ConstImageVariableGroup_IVE_VigCorrMode
    IVE_FlatfieldFilename = _hsi.ConstImageVariableGroup_IVE_FlatfieldFilename
    IVE_RadialVigCorrCoeff = _hsi.ConstImageVariableGroup_IVE_RadialVigCorrCoeff
    IVE_RadialVigCorrCenterShift = _hsi.ConstImageVariableGroup_IVE_RadialVigCorrCenterShift
    IVE_ExifModel = _hsi.ConstImageVariableGroup_IVE_ExifModel
    IVE_ExifMake = _hsi.ConstImageVariableGroup_IVE_ExifMake
    IVE_ExifLens = _hsi.ConstImageVariableGroup_IVE_ExifLens
    IVE_ExifFocalLength = _hsi.ConstImageVariableGroup_IVE_ExifFocalLength
    IVE_ExifOrientation = _hsi.ConstImageVariableGroup_IVE_ExifOrientation
    IVE_ExifAperture = _hsi.ConstImageVariableGroup_IVE_ExifAperture
    IVE_ExifISO = _hsi.ConstImageVariableGroup_IVE_ExifISO
    IVE_ExifDistance = _hsi.ConstImageVariableGroup_IVE_ExifDistance
    IVE_ExifFocalLength35 = _hsi.ConstImageVariableGroup_IVE_ExifFocalLength35
    IVE_ExifCropFactor = _hsi.ConstImageVariableGroup_IVE_ExifCropFactor
    IVE_ExifExposureTime = _hsi.ConstImageVariableGroup_IVE_ExifExposureTime
    IVE_ExifDate = _hsi.ConstImageVariableGroup_IVE_ExifDate
    IVE_ExifExposureMode = _hsi.ConstImageVariableGroup_IVE_ExifExposureMode
    IVE_ExifRedBalance = _hsi.ConstImageVariableGroup_IVE_ExifRedBalance
    IVE_ExifBlueBalance = _hsi.ConstImageVariableGroup_IVE_ExifBlueBalance
    IVE_Masks = _hsi.ConstImageVariableGroup_IVE_Masks
    IVE_ActiveMasks = _hsi.ConstImageVariableGroup_IVE_ActiveMasks
    IVE_Active = _hsi.ConstImageVariableGroup_IVE_Active

    def __init__(self, variables, pano):
        """__init__(HuginBase::ConstImageVariableGroup self, std::set< HuginBase::ConstImageVariableGroup::ImageVariableEnum,std::less< HuginBase::ConstImageVariableGroup::ImageVariableEnum >,std::allocator< HuginBase::ConstImageVariableGroup::ImageVariableEnum > > variables, PanoramaData pano) -> ConstImageVariableGroup"""
        this = _hsi.new_ConstImageVariableGroup(variables, pano)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _hsi.delete_ConstImageVariableGroup
    __del__ = lambda self: None

    def getPartNumber(self, imageNr):
        """getPartNumber(ConstImageVariableGroup self, unsigned int imageNr) -> unsigned int"""
        return _hsi.ConstImageVariableGroup_getPartNumber(self, imageNr)


    def getNumberOfParts(self):
        """getNumberOfParts(ConstImageVariableGroup self) -> std::size_t"""
        return _hsi.ConstImageVariableGroup_getNumberOfParts(self)


    def getVarLinkedInPart(self, variable, part):
        """getVarLinkedInPart(ConstImageVariableGroup self, HuginBase::ConstImageVariableGroup::ImageVariableEnum variable, std::size_t part) -> bool"""
        return _hsi.ConstImageVariableGroup_getVarLinkedInPart(self, variable, part)


    def updatePartNumbers(self):
        """updatePartNumbers(ConstImageVariableGroup self)"""
        return _hsi.ConstImageVariableGroup_updatePartNumbers(self)

ConstImageVariableGroup_swigregister = _hsi.ConstImageVariableGroup_swigregister
ConstImageVariableGroup_swigregister(ConstImageVariableGroup)

class ImageVariableGroup(ConstImageVariableGroup):
    """Proxy of C++ HuginBase::ImageVariableGroup class"""
    __swig_setmethods__ = {}
    for _s in [ConstImageVariableGroup]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ImageVariableGroup, name, value)
    __swig_getmethods__ = {}
    for _s in [ConstImageVariableGroup]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ImageVariableGroup, name)
    __repr__ = _swig_repr

    def __init__(self, variables, pano):
        """__init__(HuginBase::ImageVariableGroup self, std::set< HuginBase::ConstImageVariableGroup::ImageVariableEnum,std::less< HuginBase::ConstImageVariableGroup::ImageVariableEnum >,std::allocator< HuginBase::ConstImageVariableGroup::ImageVariableEnum > > variables, PanoramaData pano) -> ImageVariableGroup"""
        this = _hsi.new_ImageVariableGroup(variables, pano)
        try:
            self.this.append(this)
        except:
            self.this = this

    def unlinkVariablePart(self, variable, partNr):
        """unlinkVariablePart(ImageVariableGroup self, HuginBase::ConstImageVariableGroup::ImageVariableEnum variable, unsigned int partNr)"""
        return _hsi.ImageVariableGroup_unlinkVariablePart(self, variable, partNr)


    def unlinkVariableImage(self, variable, imageNr):
        """unlinkVariableImage(ImageVariableGroup self, HuginBase::ConstImageVariableGroup::ImageVariableEnum variable, unsigned int imageNr)"""
        return _hsi.ImageVariableGroup_unlinkVariableImage(self, variable, imageNr)


    def linkVariablePart(self, variable, partNr):
        """linkVariablePart(ImageVariableGroup self, HuginBase::ConstImageVariableGroup::ImageVariableEnum variable, unsigned int partNr)"""
        return _hsi.ImageVariableGroup_linkVariablePart(self, variable, partNr)


    def linkVariableImage(self, variable, imageNr):
        """linkVariableImage(ImageVariableGroup self, HuginBase::ConstImageVariableGroup::ImageVariableEnum variable, unsigned int imageNr)"""
        return _hsi.ImageVariableGroup_linkVariableImage(self, variable, imageNr)


    def switchParts(self, ImageNr, partNr):
        """switchParts(ImageVariableGroup self, unsigned int ImageNr, unsigned int partNr)"""
        return _hsi.ImageVariableGroup_switchParts(self, ImageNr, partNr)

    __swig_destroy__ = _hsi.delete_ImageVariableGroup
    __del__ = lambda self: None
ImageVariableGroup_swigregister = _hsi.ImageVariableGroup_swigregister
ImageVariableGroup_swigregister(ImageVariableGroup)

class ConstStandardImageVariableGroups(_object):
    """Proxy of C++ HuginBase::ConstStandardImageVariableGroups class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ConstStandardImageVariableGroups, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ConstStandardImageVariableGroups, name)
    __repr__ = _swig_repr

    def __init__(self, pano):
        """__init__(HuginBase::ConstStandardImageVariableGroups self, PanoramaData pano) -> ConstStandardImageVariableGroups"""
        this = _hsi.new_ConstStandardImageVariableGroups(pano)
        try:
            self.this.append(this)
        except:
            self.this = this

    def getLenses(self):
        """getLenses(ConstStandardImageVariableGroups self) -> ConstImageVariableGroup"""
        return _hsi.ConstStandardImageVariableGroups_getLenses(self)


    def getLensVariables():
        """getLensVariables() -> std::set< HuginBase::ConstImageVariableGroup::ImageVariableEnum,std::less< HuginBase::ConstImageVariableGroup::ImageVariableEnum >,std::allocator< HuginBase::ConstImageVariableGroup::ImageVariableEnum > > const &"""
        return _hsi.ConstStandardImageVariableGroups_getLensVariables()

    if _newclass:
        getLensVariables = staticmethod(getLensVariables)
    __swig_getmethods__["getLensVariables"] = lambda x: getLensVariables

    def getLens(self, lens_number):
        """getLens(ConstStandardImageVariableGroups self, std::size_t lens_number) -> Lens"""
        return _hsi.ConstStandardImageVariableGroups_getLens(self, lens_number)


    def getLensForImage(self, imgNr):
        """getLensForImage(ConstStandardImageVariableGroups self, std::size_t imgNr) -> Lens"""
        return _hsi.ConstStandardImageVariableGroups_getLensForImage(self, imgNr)


    def getStacks(self):
        """getStacks(ConstStandardImageVariableGroups self) -> ConstImageVariableGroup"""
        return _hsi.ConstStandardImageVariableGroups_getStacks(self)


    def getStackVariables():
        """getStackVariables() -> std::set< HuginBase::ConstImageVariableGroup::ImageVariableEnum,std::less< HuginBase::ConstImageVariableGroup::ImageVariableEnum >,std::allocator< HuginBase::ConstImageVariableGroup::ImageVariableEnum > > const &"""
        return _hsi.ConstStandardImageVariableGroups_getStackVariables()

    if _newclass:
        getStackVariables = staticmethod(getStackVariables)
    __swig_getmethods__["getStackVariables"] = lambda x: getStackVariables

    def update(self):
        """update(ConstStandardImageVariableGroups self)"""
        return _hsi.ConstStandardImageVariableGroups_update(self)

    __swig_destroy__ = _hsi.delete_ConstStandardImageVariableGroups
    __del__ = lambda self: None
ConstStandardImageVariableGroups_swigregister = _hsi.ConstStandardImageVariableGroups_swigregister
ConstStandardImageVariableGroups_swigregister(ConstStandardImageVariableGroups)

def ConstStandardImageVariableGroups_getLensVariables():
    """ConstStandardImageVariableGroups_getLensVariables() -> std::set< HuginBase::ConstImageVariableGroup::ImageVariableEnum,std::less< HuginBase::ConstImageVariableGroup::ImageVariableEnum >,std::allocator< HuginBase::ConstImageVariableGroup::ImageVariableEnum > > const &"""
    return _hsi.ConstStandardImageVariableGroups_getLensVariables()

def ConstStandardImageVariableGroups_getStackVariables():
    """ConstStandardImageVariableGroups_getStackVariables() -> std::set< HuginBase::ConstImageVariableGroup::ImageVariableEnum,std::less< HuginBase::ConstImageVariableGroup::ImageVariableEnum >,std::allocator< HuginBase::ConstImageVariableGroup::ImageVariableEnum > > const &"""
    return _hsi.ConstStandardImageVariableGroups_getStackVariables()

class StandardImageVariableGroups(ConstStandardImageVariableGroups):
    """Proxy of C++ HuginBase::StandardImageVariableGroups class"""
    __swig_setmethods__ = {}
    for _s in [ConstStandardImageVariableGroups]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, StandardImageVariableGroups, name, value)
    __swig_getmethods__ = {}
    for _s in [ConstStandardImageVariableGroups]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, StandardImageVariableGroups, name)
    __repr__ = _swig_repr

    def __init__(self, pano):
        """__init__(HuginBase::StandardImageVariableGroups self, PanoramaData pano) -> StandardImageVariableGroups"""
        this = _hsi.new_StandardImageVariableGroups(pano)
        try:
            self.this.append(this)
        except:
            self.this = this

    def getLenses(self):
        """getLenses(StandardImageVariableGroups self) -> ImageVariableGroup"""
        return _hsi.StandardImageVariableGroups_getLenses(self)


    def getStacks(self):
        """getStacks(StandardImageVariableGroups self) -> ImageVariableGroup"""
        return _hsi.StandardImageVariableGroups_getStacks(self)


    def update(self):
        """update(StandardImageVariableGroups self)"""
        return _hsi.StandardImageVariableGroups_update(self)

    __swig_destroy__ = _hsi.delete_StandardImageVariableGroups
    __del__ = lambda self: None
StandardImageVariableGroups_swigregister = _hsi.StandardImageVariableGroups_swigregister
StandardImageVariableGroups_swigregister(StandardImageVariableGroups)

class Variable(_object):
    """Proxy of C++ HuginBase::Variable class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Variable, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Variable, name)
    __repr__ = _swig_repr

    def __init__(self, name, val=0.0):
        """
        __init__(HuginBase::Variable self, std::string const & name, double val=0.0) -> Variable
        __init__(HuginBase::Variable self, std::string const & name) -> Variable
        """
        this = _hsi.new_Variable(name, val)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _hsi.delete_Variable
    __del__ = lambda self: None

    def _print(self, o):
        """_print(Variable self, ostream o) -> ostream"""
        return _hsi.Variable__print(self, o)


    def getName(self):
        """getName(Variable self) -> std::string const &"""
        return _hsi.Variable_getName(self)


    def setValue(self, v):
        """setValue(Variable self, double v)"""
        return _hsi.Variable_setValue(self, v)


    def getValue(self):
        """getValue(Variable self) -> double"""
        return _hsi.Variable_getValue(self)

Variable_swigregister = _hsi.Variable_swigregister
Variable_swigregister(Variable)

class LinkedVariable(Variable):
    """Proxy of C++ HuginBase::LinkedVariable class"""
    __swig_setmethods__ = {}
    for _s in [Variable]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, LinkedVariable, name, value)
    __swig_getmethods__ = {}
    for _s in [Variable]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, LinkedVariable, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(HuginBase::LinkedVariable self, std::string const & name="", double val=0.0, int link) -> LinkedVariable
        __init__(HuginBase::LinkedVariable self, std::string const & name="", double val=0.0) -> LinkedVariable
        __init__(HuginBase::LinkedVariable self, std::string const & name="") -> LinkedVariable
        __init__(HuginBase::LinkedVariable self) -> LinkedVariable
        """
        this = _hsi.new_LinkedVariable(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def isLinked(self):
        """isLinked(LinkedVariable self) -> bool"""
        return _hsi.LinkedVariable_isLinked(self)


    def getLink(self):
        """getLink(LinkedVariable self) -> int"""
        return _hsi.LinkedVariable_getLink(self)


    def setLink(self, link):
        """setLink(LinkedVariable self, int link)"""
        return _hsi.LinkedVariable_setLink(self, link)

    __swig_destroy__ = _hsi.delete_LinkedVariable
    __del__ = lambda self: None
LinkedVariable_swigregister = _hsi.LinkedVariable_swigregister
LinkedVariable_swigregister(LinkedVariable)

class LensVariable(Variable):
    """Proxy of C++ HuginBase::LensVariable class"""
    __swig_setmethods__ = {}
    for _s in [Variable]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, LensVariable, name, value)
    __swig_getmethods__ = {}
    for _s in [Variable]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, LensVariable, name)
    __repr__ = _swig_repr

    def __init__(self, name, value, link=False):
        """
        __init__(HuginBase::LensVariable self, std::string const & name, double value, bool link=False) -> LensVariable
        __init__(HuginBase::LensVariable self, std::string const & name, double value) -> LensVariable
        """
        this = _hsi.new_LensVariable(name, value, link)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _hsi.delete_LensVariable
    __del__ = lambda self: None

    def printLink(self, o, link):
        """printLink(LensVariable self, ostream o, unsigned int link) -> ostream"""
        return _hsi.LensVariable_printLink(self, o, link)


    def isLinked(self):
        """isLinked(LensVariable self) -> bool"""
        return _hsi.LensVariable_isLinked(self)


    def setLinked(self, l=True):
        """
        setLinked(LensVariable self, bool l=True)
        setLinked(LensVariable self)
        """
        return _hsi.LensVariable_setLinked(self, l)

LensVariable_swigregister = _hsi.LensVariable_swigregister
LensVariable_swigregister(LensVariable)


def fillVariableMap(vars):
    """fillVariableMap(HuginBase::VariableMap & vars)"""
    return _hsi.fillVariableMap(vars)

def printVariableMap(o, vars):
    """printVariableMap(ostream o, HuginBase::VariableMap const & vars)"""
    return _hsi.printVariableMap(o, vars)

def fillLensVarMap(vars):
    """fillLensVarMap(HuginBase::LensVarMap & vars)"""
    return _hsi.fillLensVarMap(vars)
class PanoramaOptions(_object):
    """Proxy of C++ HuginBase::PanoramaOptions class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, PanoramaOptions, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, PanoramaOptions, name)
    __repr__ = _swig_repr
    RECTILINEAR = _hsi.PanoramaOptions_RECTILINEAR
    CYLINDRICAL = _hsi.PanoramaOptions_CYLINDRICAL
    EQUIRECTANGULAR = _hsi.PanoramaOptions_EQUIRECTANGULAR
    FULL_FRAME_FISHEYE = _hsi.PanoramaOptions_FULL_FRAME_FISHEYE
    STEREOGRAPHIC = _hsi.PanoramaOptions_STEREOGRAPHIC
    MERCATOR = _hsi.PanoramaOptions_MERCATOR
    TRANSVERSE_MERCATOR = _hsi.PanoramaOptions_TRANSVERSE_MERCATOR
    SINUSOIDAL = _hsi.PanoramaOptions_SINUSOIDAL
    LAMBERT = _hsi.PanoramaOptions_LAMBERT
    LAMBERT_AZIMUTHAL = _hsi.PanoramaOptions_LAMBERT_AZIMUTHAL
    ALBERS_EQUAL_AREA_CONIC = _hsi.PanoramaOptions_ALBERS_EQUAL_AREA_CONIC
    MILLER_CYLINDRICAL = _hsi.PanoramaOptions_MILLER_CYLINDRICAL
    PANINI = _hsi.PanoramaOptions_PANINI
    ARCHITECTURAL = _hsi.PanoramaOptions_ARCHITECTURAL
    ORTHOGRAPHIC = _hsi.PanoramaOptions_ORTHOGRAPHIC
    EQUISOLID = _hsi.PanoramaOptions_EQUISOLID
    EQUI_PANINI = _hsi.PanoramaOptions_EQUI_PANINI
    BIPLANE = _hsi.PanoramaOptions_BIPLANE
    TRIPLANE = _hsi.PanoramaOptions_TRIPLANE
    GENERAL_PANINI = _hsi.PanoramaOptions_GENERAL_PANINI
    THOBY_PROJECTION = _hsi.PanoramaOptions_THOBY_PROJECTION
    HAMMER_AITOFF = _hsi.PanoramaOptions_HAMMER_AITOFF
    NO_SPEEDUP = _hsi.PanoramaOptions_NO_SPEEDUP
    MAX_SPEEDUP = _hsi.PanoramaOptions_MAX_SPEEDUP
    MEDIUM_SPEEDUP = _hsi.PanoramaOptions_MEDIUM_SPEEDUP
    JPEG = _hsi.PanoramaOptions_JPEG
    PNG = _hsi.PanoramaOptions_PNG
    TIFF = _hsi.PanoramaOptions_TIFF
    TIFF_m = _hsi.PanoramaOptions_TIFF_m
    TIFF_mask = _hsi.PanoramaOptions_TIFF_mask
    TIFF_multilayer = _hsi.PanoramaOptions_TIFF_multilayer
    TIFF_multilayer_mask = _hsi.PanoramaOptions_TIFF_multilayer_mask
    PICT = _hsi.PanoramaOptions_PICT
    PSD = _hsi.PanoramaOptions_PSD
    PSD_m = _hsi.PanoramaOptions_PSD_m
    PSD_mask = _hsi.PanoramaOptions_PSD_mask
    PAN = _hsi.PanoramaOptions_PAN
    IVR = _hsi.PanoramaOptions_IVR
    IVR_java = _hsi.PanoramaOptions_IVR_java
    VRML = _hsi.PanoramaOptions_VRML
    QTVR = _hsi.PanoramaOptions_QTVR
    HDR = _hsi.PanoramaOptions_HDR
    HDR_m = _hsi.PanoramaOptions_HDR_m
    EXR = _hsi.PanoramaOptions_EXR
    EXR_m = _hsi.PanoramaOptions_EXR_m
    FILEFORMAT_NULL = _hsi.PanoramaOptions_FILEFORMAT_NULL
    OUTPUT_LDR = _hsi.PanoramaOptions_OUTPUT_LDR
    OUTPUT_HDR = _hsi.PanoramaOptions_OUTPUT_HDR
    HDRMERGE_AVERAGE = _hsi.PanoramaOptions_HDRMERGE_AVERAGE
    HDRMERGE_DEGHOST = _hsi.PanoramaOptions_HDRMERGE_DEGHOST
    NO_BLEND = _hsi.PanoramaOptions_NO_BLEND
    PTBLENDER_BLEND = _hsi.PanoramaOptions_PTBLENDER_BLEND
    ENBLEND_BLEND = _hsi.PanoramaOptions_ENBLEND_BLEND
    SMARTBLEND_BLEND = _hsi.PanoramaOptions_SMARTBLEND_BLEND
    PTMASKER_BLEND = _hsi.PanoramaOptions_PTMASKER_BLEND
    NONA = _hsi.PanoramaOptions_NONA
    PTMENDER = _hsi.PanoramaOptions_PTMENDER
    NONE = _hsi.PanoramaOptions_NONE
    BRIGHTNESS_COLOR = _hsi.PanoramaOptions_BRIGHTNESS_COLOR
    BRIGHTNESS = _hsi.PanoramaOptions_BRIGHTNESS
    COLOR = _hsi.PanoramaOptions_COLOR

    def __init__(self):
        """__init__(HuginBase::PanoramaOptions self) -> PanoramaOptions"""
        this = _hsi.new_PanoramaOptions()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _hsi.delete_PanoramaOptions
    __del__ = lambda self: None

    def reset(self):
        """reset(PanoramaOptions self)"""
        return _hsi.PanoramaOptions_reset(self)


    def printScriptLine(self, o, forPTOptimizer=False):
        """
        printScriptLine(PanoramaOptions self, ostream o, bool forPTOptimizer=False)
        printScriptLine(PanoramaOptions self, ostream o)
        """
        return _hsi.PanoramaOptions_printScriptLine(self, o, forPTOptimizer)


    def getFormatName(f):
        """getFormatName(HuginBase::PanoramaOptions::FileFormat f) -> std::string const &"""
        return _hsi.PanoramaOptions_getFormatName(f)

    if _newclass:
        getFormatName = staticmethod(getFormatName)
    __swig_getmethods__["getFormatName"] = lambda x: getFormatName

    def getFormatFromName(name):
        """getFormatFromName(std::string const & name) -> HuginBase::PanoramaOptions::FileFormat"""
        return _hsi.PanoramaOptions_getFormatFromName(name)

    if _newclass:
        getFormatFromName = staticmethod(getFormatFromName)
    __swig_getmethods__["getFormatFromName"] = lambda x: getFormatFromName

    def getOutputExtension(self):
        """getOutputExtension(PanoramaOptions self) -> std::string const &"""
        return _hsi.PanoramaOptions_getOutputExtension(self)


    def setWidth(self, w, keepView=True):
        """
        setWidth(PanoramaOptions self, unsigned int w, bool keepView=True)
        setWidth(PanoramaOptions self, unsigned int w)
        """
        return _hsi.PanoramaOptions_setWidth(self, w, keepView)


    def setHeight(self, h):
        """setHeight(PanoramaOptions self, unsigned int h)"""
        return _hsi.PanoramaOptions_setHeight(self, h)


    def getWidth(self):
        """getWidth(PanoramaOptions self) -> unsigned int"""
        return _hsi.PanoramaOptions_getWidth(self)


    def getHeight(self):
        """getHeight(PanoramaOptions self) -> unsigned int"""
        return _hsi.PanoramaOptions_getHeight(self)


    def getSize(self):
        """getSize(PanoramaOptions self) -> Size2D"""
        return _hsi.PanoramaOptions_getSize(self)


    def getROI(self):
        """getROI(PanoramaOptions self) -> Rect2D"""
        return _hsi.PanoramaOptions_getROI(self)


    def setROI(self, val):
        """setROI(PanoramaOptions self, Rect2D val)"""
        return _hsi.PanoramaOptions_setROI(self, val)


    def setProjection(self, f):
        """setProjection(PanoramaOptions self, HuginBase::PanoramaOptions::ProjectionFormat f)"""
        return _hsi.PanoramaOptions_setProjection(self, f)


    def resetProjectionParameters(self):
        """resetProjectionParameters(PanoramaOptions self)"""
        return _hsi.PanoramaOptions_resetProjectionParameters(self)


    def getProjection(self):
        """getProjection(PanoramaOptions self) -> HuginBase::PanoramaOptions::ProjectionFormat"""
        return _hsi.PanoramaOptions_getProjection(self)


    def getProjectionParameters(self):
        """getProjectionParameters(PanoramaOptions self) -> std::vector< double,std::allocator< double > > const &"""
        return _hsi.PanoramaOptions_getProjectionParameters(self)


    def setProjectionParameters(self, params):
        """setProjectionParameters(PanoramaOptions self, std::vector< double,std::allocator< double > > const & params)"""
        return _hsi.PanoramaOptions_setProjectionParameters(self, params)


    def fovCalcSupported(self, f):
        """fovCalcSupported(PanoramaOptions self, HuginBase::PanoramaOptions::ProjectionFormat f) -> bool"""
        return _hsi.PanoramaOptions_fovCalcSupported(self, f)


    def setHFOV(self, h, keepView=True):
        """
        setHFOV(PanoramaOptions self, double h, bool keepView=True)
        setHFOV(PanoramaOptions self, double h)
        """
        return _hsi.PanoramaOptions_setHFOV(self, h, keepView)


    def getHFOV(self):
        """getHFOV(PanoramaOptions self) -> double"""
        return _hsi.PanoramaOptions_getHFOV(self)


    def setVFOV(self, v):
        """setVFOV(PanoramaOptions self, double v)"""
        return _hsi.PanoramaOptions_setVFOV(self, v)


    def getVFOV(self):
        """getVFOV(PanoramaOptions self) -> double"""
        return _hsi.PanoramaOptions_getVFOV(self)


    def getMaxHFOV(self):
        """getMaxHFOV(PanoramaOptions self) -> double"""
        return _hsi.PanoramaOptions_getMaxHFOV(self)


    def getMaxVFOV(self):
        """getMaxVFOV(PanoramaOptions self) -> double"""
        return _hsi.PanoramaOptions_getMaxVFOV(self)

    __swig_setmethods__["outfile"] = _hsi.PanoramaOptions_outfile_set
    __swig_getmethods__["outfile"] = _hsi.PanoramaOptions_outfile_get
    if _newclass:
        outfile = _swig_property(_hsi.PanoramaOptions_outfile_get, _hsi.PanoramaOptions_outfile_set)
    __swig_setmethods__["outputFormat"] = _hsi.PanoramaOptions_outputFormat_set
    __swig_getmethods__["outputFormat"] = _hsi.PanoramaOptions_outputFormat_get
    if _newclass:
        outputFormat = _swig_property(_hsi.PanoramaOptions_outputFormat_get, _hsi.PanoramaOptions_outputFormat_set)
    __swig_setmethods__["quality"] = _hsi.PanoramaOptions_quality_set
    __swig_getmethods__["quality"] = _hsi.PanoramaOptions_quality_get
    if _newclass:
        quality = _swig_property(_hsi.PanoramaOptions_quality_get, _hsi.PanoramaOptions_quality_set)
    __swig_setmethods__["tiffCompression"] = _hsi.PanoramaOptions_tiffCompression_set
    __swig_getmethods__["tiffCompression"] = _hsi.PanoramaOptions_tiffCompression_get
    if _newclass:
        tiffCompression = _swig_property(_hsi.PanoramaOptions_tiffCompression_get, _hsi.PanoramaOptions_tiffCompression_set)
    __swig_setmethods__["tiff_saveROI"] = _hsi.PanoramaOptions_tiff_saveROI_set
    __swig_getmethods__["tiff_saveROI"] = _hsi.PanoramaOptions_tiff_saveROI_get
    if _newclass:
        tiff_saveROI = _swig_property(_hsi.PanoramaOptions_tiff_saveROI_get, _hsi.PanoramaOptions_tiff_saveROI_set)
    __swig_setmethods__["colorCorrection"] = _hsi.PanoramaOptions_colorCorrection_set
    __swig_getmethods__["colorCorrection"] = _hsi.PanoramaOptions_colorCorrection_get
    if _newclass:
        colorCorrection = _swig_property(_hsi.PanoramaOptions_colorCorrection_get, _hsi.PanoramaOptions_colorCorrection_set)
    __swig_setmethods__["colorReferenceImage"] = _hsi.PanoramaOptions_colorReferenceImage_set
    __swig_getmethods__["colorReferenceImage"] = _hsi.PanoramaOptions_colorReferenceImage_get
    if _newclass:
        colorReferenceImage = _swig_property(_hsi.PanoramaOptions_colorReferenceImage_get, _hsi.PanoramaOptions_colorReferenceImage_set)
    __swig_setmethods__["gamma"] = _hsi.PanoramaOptions_gamma_set
    __swig_getmethods__["gamma"] = _hsi.PanoramaOptions_gamma_get
    if _newclass:
        gamma = _swig_property(_hsi.PanoramaOptions_gamma_get, _hsi.PanoramaOptions_gamma_set)
    __swig_setmethods__["interpolator"] = _hsi.PanoramaOptions_interpolator_set
    __swig_getmethods__["interpolator"] = _hsi.PanoramaOptions_interpolator_get
    if _newclass:
        interpolator = _swig_property(_hsi.PanoramaOptions_interpolator_get, _hsi.PanoramaOptions_interpolator_set)
    __swig_setmethods__["optimizeReferenceImage"] = _hsi.PanoramaOptions_optimizeReferenceImage_set
    __swig_getmethods__["optimizeReferenceImage"] = _hsi.PanoramaOptions_optimizeReferenceImage_get
    if _newclass:
        optimizeReferenceImage = _swig_property(_hsi.PanoramaOptions_optimizeReferenceImage_get, _hsi.PanoramaOptions_optimizeReferenceImage_set)
    __swig_setmethods__["remapAcceleration"] = _hsi.PanoramaOptions_remapAcceleration_set
    __swig_getmethods__["remapAcceleration"] = _hsi.PanoramaOptions_remapAcceleration_get
    if _newclass:
        remapAcceleration = _swig_property(_hsi.PanoramaOptions_remapAcceleration_get, _hsi.PanoramaOptions_remapAcceleration_set)
    __swig_setmethods__["blendMode"] = _hsi.PanoramaOptions_blendMode_set
    __swig_getmethods__["blendMode"] = _hsi.PanoramaOptions_blendMode_get
    if _newclass:
        blendMode = _swig_property(_hsi.PanoramaOptions_blendMode_get, _hsi.PanoramaOptions_blendMode_set)
    __swig_setmethods__["hdrMergeMode"] = _hsi.PanoramaOptions_hdrMergeMode_set
    __swig_getmethods__["hdrMergeMode"] = _hsi.PanoramaOptions_hdrMergeMode_get
    if _newclass:
        hdrMergeMode = _swig_property(_hsi.PanoramaOptions_hdrMergeMode_get, _hsi.PanoramaOptions_hdrMergeMode_set)
    __swig_setmethods__["remapper"] = _hsi.PanoramaOptions_remapper_set
    __swig_getmethods__["remapper"] = _hsi.PanoramaOptions_remapper_get
    if _newclass:
        remapper = _swig_property(_hsi.PanoramaOptions_remapper_get, _hsi.PanoramaOptions_remapper_set)
    __swig_setmethods__["remapUsingGPU"] = _hsi.PanoramaOptions_remapUsingGPU_set
    __swig_getmethods__["remapUsingGPU"] = _hsi.PanoramaOptions_remapUsingGPU_get
    if _newclass:
        remapUsingGPU = _swig_property(_hsi.PanoramaOptions_remapUsingGPU_get, _hsi.PanoramaOptions_remapUsingGPU_set)
    __swig_setmethods__["saveCoordImgs"] = _hsi.PanoramaOptions_saveCoordImgs_set
    __swig_getmethods__["saveCoordImgs"] = _hsi.PanoramaOptions_saveCoordImgs_get
    if _newclass:
        saveCoordImgs = _swig_property(_hsi.PanoramaOptions_saveCoordImgs_get, _hsi.PanoramaOptions_saveCoordImgs_set)
    __swig_setmethods__["huberSigma"] = _hsi.PanoramaOptions_huberSigma_set
    __swig_getmethods__["huberSigma"] = _hsi.PanoramaOptions_huberSigma_get
    if _newclass:
        huberSigma = _swig_property(_hsi.PanoramaOptions_huberSigma_get, _hsi.PanoramaOptions_huberSigma_set)
    __swig_setmethods__["photometricHuberSigma"] = _hsi.PanoramaOptions_photometricHuberSigma_set
    __swig_getmethods__["photometricHuberSigma"] = _hsi.PanoramaOptions_photometricHuberSigma_get
    if _newclass:
        photometricHuberSigma = _swig_property(_hsi.PanoramaOptions_photometricHuberSigma_get, _hsi.PanoramaOptions_photometricHuberSigma_set)
    __swig_setmethods__["photometricSymmetricError"] = _hsi.PanoramaOptions_photometricSymmetricError_set
    __swig_getmethods__["photometricSymmetricError"] = _hsi.PanoramaOptions_photometricSymmetricError_get
    if _newclass:
        photometricSymmetricError = _swig_property(_hsi.PanoramaOptions_photometricSymmetricError_get, _hsi.PanoramaOptions_photometricSymmetricError_set)
    __swig_setmethods__["outputMode"] = _hsi.PanoramaOptions_outputMode_set
    __swig_getmethods__["outputMode"] = _hsi.PanoramaOptions_outputMode_get
    if _newclass:
        outputMode = _swig_property(_hsi.PanoramaOptions_outputMode_get, _hsi.PanoramaOptions_outputMode_set)
    __swig_setmethods__["outputLDRBlended"] = _hsi.PanoramaOptions_outputLDRBlended_set
    __swig_getmethods__["outputLDRBlended"] = _hsi.PanoramaOptions_outputLDRBlended_get
    if _newclass:
        outputLDRBlended = _swig_property(_hsi.PanoramaOptions_outputLDRBlended_get, _hsi.PanoramaOptions_outputLDRBlended_set)
    __swig_setmethods__["outputLDRLayers"] = _hsi.PanoramaOptions_outputLDRLayers_set
    __swig_getmethods__["outputLDRLayers"] = _hsi.PanoramaOptions_outputLDRLayers_get
    if _newclass:
        outputLDRLayers = _swig_property(_hsi.PanoramaOptions_outputLDRLayers_get, _hsi.PanoramaOptions_outputLDRLayers_set)
    __swig_setmethods__["outputLDRExposureRemapped"] = _hsi.PanoramaOptions_outputLDRExposureRemapped_set
    __swig_getmethods__["outputLDRExposureRemapped"] = _hsi.PanoramaOptions_outputLDRExposureRemapped_get
    if _newclass:
        outputLDRExposureRemapped = _swig_property(_hsi.PanoramaOptions_outputLDRExposureRemapped_get, _hsi.PanoramaOptions_outputLDRExposureRemapped_set)
    __swig_setmethods__["outputLDRExposureLayers"] = _hsi.PanoramaOptions_outputLDRExposureLayers_set
    __swig_getmethods__["outputLDRExposureLayers"] = _hsi.PanoramaOptions_outputLDRExposureLayers_get
    if _newclass:
        outputLDRExposureLayers = _swig_property(_hsi.PanoramaOptions_outputLDRExposureLayers_get, _hsi.PanoramaOptions_outputLDRExposureLayers_set)
    __swig_setmethods__["outputLDRExposureLayersFused"] = _hsi.PanoramaOptions_outputLDRExposureLayersFused_set
    __swig_getmethods__["outputLDRExposureLayersFused"] = _hsi.PanoramaOptions_outputLDRExposureLayersFused_get
    if _newclass:
        outputLDRExposureLayersFused = _swig_property(_hsi.PanoramaOptions_outputLDRExposureLayersFused_get, _hsi.PanoramaOptions_outputLDRExposureLayersFused_set)
    __swig_setmethods__["outputLDRStacks"] = _hsi.PanoramaOptions_outputLDRStacks_set
    __swig_getmethods__["outputLDRStacks"] = _hsi.PanoramaOptions_outputLDRStacks_get
    if _newclass:
        outputLDRStacks = _swig_property(_hsi.PanoramaOptions_outputLDRStacks_get, _hsi.PanoramaOptions_outputLDRStacks_set)
    __swig_setmethods__["outputLDRExposureBlended"] = _hsi.PanoramaOptions_outputLDRExposureBlended_set
    __swig_getmethods__["outputLDRExposureBlended"] = _hsi.PanoramaOptions_outputLDRExposureBlended_get
    if _newclass:
        outputLDRExposureBlended = _swig_property(_hsi.PanoramaOptions_outputLDRExposureBlended_get, _hsi.PanoramaOptions_outputLDRExposureBlended_set)
    __swig_setmethods__["outputHDRBlended"] = _hsi.PanoramaOptions_outputHDRBlended_set
    __swig_getmethods__["outputHDRBlended"] = _hsi.PanoramaOptions_outputHDRBlended_get
    if _newclass:
        outputHDRBlended = _swig_property(_hsi.PanoramaOptions_outputHDRBlended_get, _hsi.PanoramaOptions_outputHDRBlended_set)
    __swig_setmethods__["outputHDRLayers"] = _hsi.PanoramaOptions_outputHDRLayers_set
    __swig_getmethods__["outputHDRLayers"] = _hsi.PanoramaOptions_outputHDRLayers_get
    if _newclass:
        outputHDRLayers = _swig_property(_hsi.PanoramaOptions_outputHDRLayers_get, _hsi.PanoramaOptions_outputHDRLayers_set)
    __swig_setmethods__["outputHDRStacks"] = _hsi.PanoramaOptions_outputHDRStacks_set
    __swig_getmethods__["outputHDRStacks"] = _hsi.PanoramaOptions_outputHDRStacks_get
    if _newclass:
        outputHDRStacks = _swig_property(_hsi.PanoramaOptions_outputHDRStacks_get, _hsi.PanoramaOptions_outputHDRStacks_set)
    __swig_setmethods__["outputLayersCompression"] = _hsi.PanoramaOptions_outputLayersCompression_set
    __swig_getmethods__["outputLayersCompression"] = _hsi.PanoramaOptions_outputLayersCompression_get
    if _newclass:
        outputLayersCompression = _swig_property(_hsi.PanoramaOptions_outputLayersCompression_get, _hsi.PanoramaOptions_outputLayersCompression_set)
    __swig_setmethods__["outputImageType"] = _hsi.PanoramaOptions_outputImageType_set
    __swig_getmethods__["outputImageType"] = _hsi.PanoramaOptions_outputImageType_get
    if _newclass:
        outputImageType = _swig_property(_hsi.PanoramaOptions_outputImageType_get, _hsi.PanoramaOptions_outputImageType_set)
    __swig_setmethods__["outputImageTypeCompression"] = _hsi.PanoramaOptions_outputImageTypeCompression_set
    __swig_getmethods__["outputImageTypeCompression"] = _hsi.PanoramaOptions_outputImageTypeCompression_get
    if _newclass:
        outputImageTypeCompression = _swig_property(_hsi.PanoramaOptions_outputImageTypeCompression_get, _hsi.PanoramaOptions_outputImageTypeCompression_set)
    __swig_setmethods__["outputImageTypeHDR"] = _hsi.PanoramaOptions_outputImageTypeHDR_set
    __swig_getmethods__["outputImageTypeHDR"] = _hsi.PanoramaOptions_outputImageTypeHDR_get
    if _newclass:
        outputImageTypeHDR = _swig_property(_hsi.PanoramaOptions_outputImageTypeHDR_get, _hsi.PanoramaOptions_outputImageTypeHDR_set)
    __swig_setmethods__["outputImageTypeHDRCompression"] = _hsi.PanoramaOptions_outputImageTypeHDRCompression_set
    __swig_getmethods__["outputImageTypeHDRCompression"] = _hsi.PanoramaOptions_outputImageTypeHDRCompression_get
    if _newclass:
        outputImageTypeHDRCompression = _swig_property(_hsi.PanoramaOptions_outputImageTypeHDRCompression_get, _hsi.PanoramaOptions_outputImageTypeHDRCompression_set)
    __swig_setmethods__["enblendOptions"] = _hsi.PanoramaOptions_enblendOptions_set
    __swig_getmethods__["enblendOptions"] = _hsi.PanoramaOptions_enblendOptions_get
    if _newclass:
        enblendOptions = _swig_property(_hsi.PanoramaOptions_enblendOptions_get, _hsi.PanoramaOptions_enblendOptions_set)
    __swig_setmethods__["enfuseOptions"] = _hsi.PanoramaOptions_enfuseOptions_set
    __swig_getmethods__["enfuseOptions"] = _hsi.PanoramaOptions_enfuseOptions_get
    if _newclass:
        enfuseOptions = _swig_property(_hsi.PanoramaOptions_enfuseOptions_get, _hsi.PanoramaOptions_enfuseOptions_set)
    __swig_setmethods__["hdrmergeOptions"] = _hsi.PanoramaOptions_hdrmergeOptions_set
    __swig_getmethods__["hdrmergeOptions"] = _hsi.PanoramaOptions_hdrmergeOptions_get
    if _newclass:
        hdrmergeOptions = _swig_property(_hsi.PanoramaOptions_hdrmergeOptions_get, _hsi.PanoramaOptions_hdrmergeOptions_set)
    __swig_setmethods__["outputExposureValue"] = _hsi.PanoramaOptions_outputExposureValue_set
    __swig_getmethods__["outputExposureValue"] = _hsi.PanoramaOptions_outputExposureValue_get
    if _newclass:
        outputExposureValue = _swig_property(_hsi.PanoramaOptions_outputExposureValue_get, _hsi.PanoramaOptions_outputExposureValue_set)
    __swig_setmethods__["outputEMoRParams"] = _hsi.PanoramaOptions_outputEMoRParams_set
    __swig_getmethods__["outputEMoRParams"] = _hsi.PanoramaOptions_outputEMoRParams_get
    if _newclass:
        outputEMoRParams = _swig_property(_hsi.PanoramaOptions_outputEMoRParams_get, _hsi.PanoramaOptions_outputEMoRParams_set)
    __swig_setmethods__["outputPixelType"] = _hsi.PanoramaOptions_outputPixelType_set
    __swig_getmethods__["outputPixelType"] = _hsi.PanoramaOptions_outputPixelType_get
    if _newclass:
        outputPixelType = _swig_property(_hsi.PanoramaOptions_outputPixelType_get, _hsi.PanoramaOptions_outputPixelType_set)
    __swig_setmethods__["outputStacksMinOverlap"] = _hsi.PanoramaOptions_outputStacksMinOverlap_set
    __swig_getmethods__["outputStacksMinOverlap"] = _hsi.PanoramaOptions_outputStacksMinOverlap_get
    if _newclass:
        outputStacksMinOverlap = _swig_property(_hsi.PanoramaOptions_outputStacksMinOverlap_get, _hsi.PanoramaOptions_outputStacksMinOverlap_set)
    __swig_setmethods__["outputLayersExposureDiff"] = _hsi.PanoramaOptions_outputLayersExposureDiff_set
    __swig_getmethods__["outputLayersExposureDiff"] = _hsi.PanoramaOptions_outputLayersExposureDiff_get
    if _newclass:
        outputLayersExposureDiff = _swig_property(_hsi.PanoramaOptions_outputLayersExposureDiff_get, _hsi.PanoramaOptions_outputLayersExposureDiff_set)
    __swig_setmethods__["m_projFeatures"] = _hsi.PanoramaOptions_m_projFeatures_set
    __swig_getmethods__["m_projFeatures"] = _hsi.PanoramaOptions_m_projFeatures_get
    if _newclass:
        m_projFeatures = _swig_property(_hsi.PanoramaOptions_m_projFeatures_get, _hsi.PanoramaOptions_m_projFeatures_set)
PanoramaOptions_swigregister = _hsi.PanoramaOptions_swigregister
PanoramaOptions_swigregister(PanoramaOptions)

def PanoramaOptions_getFormatName(f):
    """PanoramaOptions_getFormatName(HuginBase::PanoramaOptions::FileFormat f) -> std::string const &"""
    return _hsi.PanoramaOptions_getFormatName(f)

def PanoramaOptions_getFormatFromName(name):
    """PanoramaOptions_getFormatFromName(std::string const & name) -> HuginBase::PanoramaOptions::FileFormat"""
    return _hsi.PanoramaOptions_getFormatFromName(name)

class BaseSrcPanoImage(_object):
    """Proxy of C++ HuginBase::BaseSrcPanoImage class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, BaseSrcPanoImage, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, BaseSrcPanoImage, name)
    __repr__ = _swig_repr
    RECTILINEAR = _hsi.BaseSrcPanoImage_RECTILINEAR
    PANORAMIC = _hsi.BaseSrcPanoImage_PANORAMIC
    CIRCULAR_FISHEYE = _hsi.BaseSrcPanoImage_CIRCULAR_FISHEYE
    FULL_FRAME_FISHEYE = _hsi.BaseSrcPanoImage_FULL_FRAME_FISHEYE
    EQUIRECTANGULAR = _hsi.BaseSrcPanoImage_EQUIRECTANGULAR
    FISHEYE_ORTHOGRAPHIC = _hsi.BaseSrcPanoImage_FISHEYE_ORTHOGRAPHIC
    FISHEYE_STEREOGRAPHIC = _hsi.BaseSrcPanoImage_FISHEYE_STEREOGRAPHIC
    FISHEYE_EQUISOLID = _hsi.BaseSrcPanoImage_FISHEYE_EQUISOLID
    FISHEYE_THOBY = _hsi.BaseSrcPanoImage_FISHEYE_THOBY
    NO_CROP = _hsi.BaseSrcPanoImage_NO_CROP
    CROP_RECTANGLE = _hsi.BaseSrcPanoImage_CROP_RECTANGLE
    CROP_CIRCLE = _hsi.BaseSrcPanoImage_CROP_CIRCLE
    VIGCORR_NONE = _hsi.BaseSrcPanoImage_VIGCORR_NONE
    VIGCORR_RADIAL = _hsi.BaseSrcPanoImage_VIGCORR_RADIAL
    VIGCORR_FLATFIELD = _hsi.BaseSrcPanoImage_VIGCORR_FLATFIELD
    VIGCORR_DIV = _hsi.BaseSrcPanoImage_VIGCORR_DIV
    RESPONSE_EMOR = _hsi.BaseSrcPanoImage_RESPONSE_EMOR
    RESPONSE_LINEAR = _hsi.BaseSrcPanoImage_RESPONSE_LINEAR
    RESPONSE_GAMMA = _hsi.BaseSrcPanoImage_RESPONSE_GAMMA
    RESPONSE_FILE = _hsi.BaseSrcPanoImage_RESPONSE_FILE
    RESPONSE_ICC = _hsi.BaseSrcPanoImage_RESPONSE_ICC

    def __eq__(self, other):
        """__eq__(BaseSrcPanoImage self, BaseSrcPanoImage other) -> bool"""
        return _hsi.BaseSrcPanoImage___eq__(self, other)


    def __init__(self):
        """__init__(HuginBase::BaseSrcPanoImage self) -> BaseSrcPanoImage"""
        this = _hsi.new_BaseSrcPanoImage()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _hsi.delete_BaseSrcPanoImage
    __del__ = lambda self: None

    def getFilename(self):
        """getFilename(BaseSrcPanoImage self) -> std::string"""
        return _hsi.BaseSrcPanoImage_getFilename(self)


    def getSize(self):
        """getSize(BaseSrcPanoImage self) -> Size2D"""
        return _hsi.BaseSrcPanoImage_getSize(self)


    def getProjection(self):
        """getProjection(BaseSrcPanoImage self) -> HuginBase::BaseSrcPanoImage::Projection"""
        return _hsi.BaseSrcPanoImage_getProjection(self)


    def getHFOV(self):
        """getHFOV(BaseSrcPanoImage self) -> double"""
        return _hsi.BaseSrcPanoImage_getHFOV(self)


    def getCropFactor(self):
        """getCropFactor(BaseSrcPanoImage self) -> double"""
        return _hsi.BaseSrcPanoImage_getCropFactor(self)


    def getResponseType(self):
        """getResponseType(BaseSrcPanoImage self) -> HuginBase::BaseSrcPanoImage::ResponseType"""
        return _hsi.BaseSrcPanoImage_getResponseType(self)


    def getEMoRParams(self):
        """getEMoRParams(BaseSrcPanoImage self) -> std::vector< float,std::allocator< float > >"""
        return _hsi.BaseSrcPanoImage_getEMoRParams(self)


    def getExposureValue(self):
        """getExposureValue(BaseSrcPanoImage self) -> double"""
        return _hsi.BaseSrcPanoImage_getExposureValue(self)


    def getGamma(self):
        """getGamma(BaseSrcPanoImage self) -> double"""
        return _hsi.BaseSrcPanoImage_getGamma(self)


    def getWhiteBalanceRed(self):
        """getWhiteBalanceRed(BaseSrcPanoImage self) -> double"""
        return _hsi.BaseSrcPanoImage_getWhiteBalanceRed(self)


    def getWhiteBalanceBlue(self):
        """getWhiteBalanceBlue(BaseSrcPanoImage self) -> double"""
        return _hsi.BaseSrcPanoImage_getWhiteBalanceBlue(self)


    def getRoll(self):
        """getRoll(BaseSrcPanoImage self) -> double"""
        return _hsi.BaseSrcPanoImage_getRoll(self)


    def getPitch(self):
        """getPitch(BaseSrcPanoImage self) -> double"""
        return _hsi.BaseSrcPanoImage_getPitch(self)


    def getYaw(self):
        """getYaw(BaseSrcPanoImage self) -> double"""
        return _hsi.BaseSrcPanoImage_getYaw(self)


    def getX(self):
        """getX(BaseSrcPanoImage self) -> double"""
        return _hsi.BaseSrcPanoImage_getX(self)


    def getY(self):
        """getY(BaseSrcPanoImage self) -> double"""
        return _hsi.BaseSrcPanoImage_getY(self)


    def getZ(self):
        """getZ(BaseSrcPanoImage self) -> double"""
        return _hsi.BaseSrcPanoImage_getZ(self)


    def getTranslationPlaneYaw(self):
        """getTranslationPlaneYaw(BaseSrcPanoImage self) -> double"""
        return _hsi.BaseSrcPanoImage_getTranslationPlaneYaw(self)


    def getTranslationPlanePitch(self):
        """getTranslationPlanePitch(BaseSrcPanoImage self) -> double"""
        return _hsi.BaseSrcPanoImage_getTranslationPlanePitch(self)


    def getStack(self):
        """getStack(BaseSrcPanoImage self) -> double"""
        return _hsi.BaseSrcPanoImage_getStack(self)


    def getRadialDistortion(self):
        """getRadialDistortion(BaseSrcPanoImage self) -> std::vector< double,std::allocator< double > >"""
        return _hsi.BaseSrcPanoImage_getRadialDistortion(self)


    def getRadialDistortionRed(self):
        """getRadialDistortionRed(BaseSrcPanoImage self) -> std::vector< double,std::allocator< double > >"""
        return _hsi.BaseSrcPanoImage_getRadialDistortionRed(self)


    def getRadialDistortionBlue(self):
        """getRadialDistortionBlue(BaseSrcPanoImage self) -> std::vector< double,std::allocator< double > >"""
        return _hsi.BaseSrcPanoImage_getRadialDistortionBlue(self)


    def getRadialDistortionCenterShift(self):
        """getRadialDistortionCenterShift(BaseSrcPanoImage self) -> FDiff2D"""
        return _hsi.BaseSrcPanoImage_getRadialDistortionCenterShift(self)


    def getShear(self):
        """getShear(BaseSrcPanoImage self) -> FDiff2D"""
        return _hsi.BaseSrcPanoImage_getShear(self)


    def getCropMode(self):
        """getCropMode(BaseSrcPanoImage self) -> HuginBase::BaseSrcPanoImage::CropMode"""
        return _hsi.BaseSrcPanoImage_getCropMode(self)


    def getCropRect(self):
        """getCropRect(BaseSrcPanoImage self) -> Rect2D"""
        return _hsi.BaseSrcPanoImage_getCropRect(self)


    def getAutoCenterCrop(self):
        """getAutoCenterCrop(BaseSrcPanoImage self) -> bool"""
        return _hsi.BaseSrcPanoImage_getAutoCenterCrop(self)


    def getVigCorrMode(self):
        """getVigCorrMode(BaseSrcPanoImage self) -> int"""
        return _hsi.BaseSrcPanoImage_getVigCorrMode(self)


    def getFlatfieldFilename(self):
        """getFlatfieldFilename(BaseSrcPanoImage self) -> std::string"""
        return _hsi.BaseSrcPanoImage_getFlatfieldFilename(self)


    def getRadialVigCorrCoeff(self):
        """getRadialVigCorrCoeff(BaseSrcPanoImage self) -> std::vector< double,std::allocator< double > >"""
        return _hsi.BaseSrcPanoImage_getRadialVigCorrCoeff(self)


    def getRadialVigCorrCenterShift(self):
        """getRadialVigCorrCenterShift(BaseSrcPanoImage self) -> FDiff2D"""
        return _hsi.BaseSrcPanoImage_getRadialVigCorrCenterShift(self)


    def getExifModel(self):
        """getExifModel(BaseSrcPanoImage self) -> std::string"""
        return _hsi.BaseSrcPanoImage_getExifModel(self)


    def getExifMake(self):
        """getExifMake(BaseSrcPanoImage self) -> std::string"""
        return _hsi.BaseSrcPanoImage_getExifMake(self)


    def getExifLens(self):
        """getExifLens(BaseSrcPanoImage self) -> std::string"""
        return _hsi.BaseSrcPanoImage_getExifLens(self)


    def getExifFocalLength(self):
        """getExifFocalLength(BaseSrcPanoImage self) -> double"""
        return _hsi.BaseSrcPanoImage_getExifFocalLength(self)


    def getExifOrientation(self):
        """getExifOrientation(BaseSrcPanoImage self) -> double"""
        return _hsi.BaseSrcPanoImage_getExifOrientation(self)


    def getExifAperture(self):
        """getExifAperture(BaseSrcPanoImage self) -> double"""
        return _hsi.BaseSrcPanoImage_getExifAperture(self)


    def getExifISO(self):
        """getExifISO(BaseSrcPanoImage self) -> double"""
        return _hsi.BaseSrcPanoImage_getExifISO(self)


    def getExifDistance(self):
        """getExifDistance(BaseSrcPanoImage self) -> double"""
        return _hsi.BaseSrcPanoImage_getExifDistance(self)


    def getExifFocalLength35(self):
        """getExifFocalLength35(BaseSrcPanoImage self) -> double"""
        return _hsi.BaseSrcPanoImage_getExifFocalLength35(self)


    def getExifCropFactor(self):
        """getExifCropFactor(BaseSrcPanoImage self) -> double"""
        return _hsi.BaseSrcPanoImage_getExifCropFactor(self)


    def getExifExposureTime(self):
        """getExifExposureTime(BaseSrcPanoImage self) -> double"""
        return _hsi.BaseSrcPanoImage_getExifExposureTime(self)


    def getExifDate(self):
        """getExifDate(BaseSrcPanoImage self) -> std::string"""
        return _hsi.BaseSrcPanoImage_getExifDate(self)


    def getExifExposureMode(self):
        """getExifExposureMode(BaseSrcPanoImage self) -> int"""
        return _hsi.BaseSrcPanoImage_getExifExposureMode(self)


    def getExifRedBalance(self):
        """getExifRedBalance(BaseSrcPanoImage self) -> double"""
        return _hsi.BaseSrcPanoImage_getExifRedBalance(self)


    def getExifBlueBalance(self):
        """getExifBlueBalance(BaseSrcPanoImage self) -> double"""
        return _hsi.BaseSrcPanoImage_getExifBlueBalance(self)


    def getMasks(self):
        """getMasks(BaseSrcPanoImage self) -> HuginBase::MaskPolygonVector"""
        return _hsi.BaseSrcPanoImage_getMasks(self)


    def getActiveMasks(self):
        """getActiveMasks(BaseSrcPanoImage self) -> HuginBase::MaskPolygonVector"""
        return _hsi.BaseSrcPanoImage_getActiveMasks(self)


    def getActive(self):
        """getActive(BaseSrcPanoImage self) -> bool"""
        return _hsi.BaseSrcPanoImage_getActive(self)


    def getFilenameIV(self):
        """getFilenameIV(BaseSrcPanoImage self) -> HuginBase::ImageVariable< std::string > const &"""
        return _hsi.BaseSrcPanoImage_getFilenameIV(self)


    def getSizeIV(self):
        """getSizeIV(BaseSrcPanoImage self) -> HuginBase::ImageVariable< vigra::Size2D > const &"""
        return _hsi.BaseSrcPanoImage_getSizeIV(self)


    def getProjectionIV(self):
        """getProjectionIV(BaseSrcPanoImage self) -> HuginBase::ImageVariable< HuginBase::BaseSrcPanoImage::Projection > const &"""
        return _hsi.BaseSrcPanoImage_getProjectionIV(self)


    def getHFOVIV(self):
        """getHFOVIV(BaseSrcPanoImage self) -> HuginBase::ImageVariable< double > const &"""
        return _hsi.BaseSrcPanoImage_getHFOVIV(self)


    def getCropFactorIV(self):
        """getCropFactorIV(BaseSrcPanoImage self) -> HuginBase::ImageVariable< double > const &"""
        return _hsi.BaseSrcPanoImage_getCropFactorIV(self)


    def getResponseTypeIV(self):
        """getResponseTypeIV(BaseSrcPanoImage self) -> HuginBase::ImageVariable< HuginBase::BaseSrcPanoImage::ResponseType > const &"""
        return _hsi.BaseSrcPanoImage_getResponseTypeIV(self)


    def getEMoRParamsIV(self):
        """getEMoRParamsIV(BaseSrcPanoImage self) -> HuginBase::ImageVariable< std::vector< float,std::allocator< float > > > const &"""
        return _hsi.BaseSrcPanoImage_getEMoRParamsIV(self)


    def getExposureValueIV(self):
        """getExposureValueIV(BaseSrcPanoImage self) -> HuginBase::ImageVariable< double > const &"""
        return _hsi.BaseSrcPanoImage_getExposureValueIV(self)


    def getGammaIV(self):
        """getGammaIV(BaseSrcPanoImage self) -> HuginBase::ImageVariable< double > const &"""
        return _hsi.BaseSrcPanoImage_getGammaIV(self)


    def getWhiteBalanceRedIV(self):
        """getWhiteBalanceRedIV(BaseSrcPanoImage self) -> HuginBase::ImageVariable< double > const &"""
        return _hsi.BaseSrcPanoImage_getWhiteBalanceRedIV(self)


    def getWhiteBalanceBlueIV(self):
        """getWhiteBalanceBlueIV(BaseSrcPanoImage self) -> HuginBase::ImageVariable< double > const &"""
        return _hsi.BaseSrcPanoImage_getWhiteBalanceBlueIV(self)


    def getRollIV(self):
        """getRollIV(BaseSrcPanoImage self) -> HuginBase::ImageVariable< double > const &"""
        return _hsi.BaseSrcPanoImage_getRollIV(self)


    def getPitchIV(self):
        """getPitchIV(BaseSrcPanoImage self) -> HuginBase::ImageVariable< double > const &"""
        return _hsi.BaseSrcPanoImage_getPitchIV(self)


    def getYawIV(self):
        """getYawIV(BaseSrcPanoImage self) -> HuginBase::ImageVariable< double > const &"""
        return _hsi.BaseSrcPanoImage_getYawIV(self)


    def getXIV(self):
        """getXIV(BaseSrcPanoImage self) -> HuginBase::ImageVariable< double > const &"""
        return _hsi.BaseSrcPanoImage_getXIV(self)


    def getYIV(self):
        """getYIV(BaseSrcPanoImage self) -> HuginBase::ImageVariable< double > const &"""
        return _hsi.BaseSrcPanoImage_getYIV(self)


    def getZIV(self):
        """getZIV(BaseSrcPanoImage self) -> HuginBase::ImageVariable< double > const &"""
        return _hsi.BaseSrcPanoImage_getZIV(self)


    def getTranslationPlaneYawIV(self):
        """getTranslationPlaneYawIV(BaseSrcPanoImage self) -> HuginBase::ImageVariable< double > const &"""
        return _hsi.BaseSrcPanoImage_getTranslationPlaneYawIV(self)


    def getTranslationPlanePitchIV(self):
        """getTranslationPlanePitchIV(BaseSrcPanoImage self) -> HuginBase::ImageVariable< double > const &"""
        return _hsi.BaseSrcPanoImage_getTranslationPlanePitchIV(self)


    def getStackIV(self):
        """getStackIV(BaseSrcPanoImage self) -> HuginBase::ImageVariable< double > const &"""
        return _hsi.BaseSrcPanoImage_getStackIV(self)


    def getRadialDistortionIV(self):
        """getRadialDistortionIV(BaseSrcPanoImage self) -> HuginBase::ImageVariable< std::vector< double,std::allocator< double > > > const &"""
        return _hsi.BaseSrcPanoImage_getRadialDistortionIV(self)


    def getRadialDistortionRedIV(self):
        """getRadialDistortionRedIV(BaseSrcPanoImage self) -> HuginBase::ImageVariable< std::vector< double,std::allocator< double > > > const &"""
        return _hsi.BaseSrcPanoImage_getRadialDistortionRedIV(self)


    def getRadialDistortionBlueIV(self):
        """getRadialDistortionBlueIV(BaseSrcPanoImage self) -> HuginBase::ImageVariable< std::vector< double,std::allocator< double > > > const &"""
        return _hsi.BaseSrcPanoImage_getRadialDistortionBlueIV(self)


    def getRadialDistortionCenterShiftIV(self):
        """getRadialDistortionCenterShiftIV(BaseSrcPanoImage self) -> HuginBase::ImageVariable< hugin_utils::FDiff2D > const &"""
        return _hsi.BaseSrcPanoImage_getRadialDistortionCenterShiftIV(self)


    def getShearIV(self):
        """getShearIV(BaseSrcPanoImage self) -> HuginBase::ImageVariable< hugin_utils::FDiff2D > const &"""
        return _hsi.BaseSrcPanoImage_getShearIV(self)


    def getCropModeIV(self):
        """getCropModeIV(BaseSrcPanoImage self) -> HuginBase::ImageVariable< HuginBase::BaseSrcPanoImage::CropMode > const &"""
        return _hsi.BaseSrcPanoImage_getCropModeIV(self)


    def getCropRectIV(self):
        """getCropRectIV(BaseSrcPanoImage self) -> HuginBase::ImageVariable< vigra::Rect2D > const &"""
        return _hsi.BaseSrcPanoImage_getCropRectIV(self)


    def getAutoCenterCropIV(self):
        """getAutoCenterCropIV(BaseSrcPanoImage self) -> HuginBase::ImageVariable< bool > const &"""
        return _hsi.BaseSrcPanoImage_getAutoCenterCropIV(self)


    def getVigCorrModeIV(self):
        """getVigCorrModeIV(BaseSrcPanoImage self) -> HuginBase::ImageVariable< int > const &"""
        return _hsi.BaseSrcPanoImage_getVigCorrModeIV(self)


    def getFlatfieldFilenameIV(self):
        """getFlatfieldFilenameIV(BaseSrcPanoImage self) -> HuginBase::ImageVariable< std::string > const &"""
        return _hsi.BaseSrcPanoImage_getFlatfieldFilenameIV(self)


    def getRadialVigCorrCoeffIV(self):
        """getRadialVigCorrCoeffIV(BaseSrcPanoImage self) -> HuginBase::ImageVariable< std::vector< double,std::allocator< double > > > const &"""
        return _hsi.BaseSrcPanoImage_getRadialVigCorrCoeffIV(self)


    def getRadialVigCorrCenterShiftIV(self):
        """getRadialVigCorrCenterShiftIV(BaseSrcPanoImage self) -> HuginBase::ImageVariable< hugin_utils::FDiff2D > const &"""
        return _hsi.BaseSrcPanoImage_getRadialVigCorrCenterShiftIV(self)


    def getExifModelIV(self):
        """getExifModelIV(BaseSrcPanoImage self) -> HuginBase::ImageVariable< std::string > const &"""
        return _hsi.BaseSrcPanoImage_getExifModelIV(self)


    def getExifMakeIV(self):
        """getExifMakeIV(BaseSrcPanoImage self) -> HuginBase::ImageVariable< std::string > const &"""
        return _hsi.BaseSrcPanoImage_getExifMakeIV(self)


    def getExifLensIV(self):
        """getExifLensIV(BaseSrcPanoImage self) -> HuginBase::ImageVariable< std::string > const &"""
        return _hsi.BaseSrcPanoImage_getExifLensIV(self)


    def getExifFocalLengthIV(self):
        """getExifFocalLengthIV(BaseSrcPanoImage self) -> HuginBase::ImageVariable< double > const &"""
        return _hsi.BaseSrcPanoImage_getExifFocalLengthIV(self)


    def getExifOrientationIV(self):
        """getExifOrientationIV(BaseSrcPanoImage self) -> HuginBase::ImageVariable< double > const &"""
        return _hsi.BaseSrcPanoImage_getExifOrientationIV(self)


    def getExifApertureIV(self):
        """getExifApertureIV(BaseSrcPanoImage self) -> HuginBase::ImageVariable< double > const &"""
        return _hsi.BaseSrcPanoImage_getExifApertureIV(self)


    def getExifISOIV(self):
        """getExifISOIV(BaseSrcPanoImage self) -> HuginBase::ImageVariable< double > const &"""
        return _hsi.BaseSrcPanoImage_getExifISOIV(self)


    def getExifDistanceIV(self):
        """getExifDistanceIV(BaseSrcPanoImage self) -> HuginBase::ImageVariable< double > const &"""
        return _hsi.BaseSrcPanoImage_getExifDistanceIV(self)


    def getExifFocalLength35IV(self):
        """getExifFocalLength35IV(BaseSrcPanoImage self) -> HuginBase::ImageVariable< double > const &"""
        return _hsi.BaseSrcPanoImage_getExifFocalLength35IV(self)


    def getExifCropFactorIV(self):
        """getExifCropFactorIV(BaseSrcPanoImage self) -> HuginBase::ImageVariable< double > const &"""
        return _hsi.BaseSrcPanoImage_getExifCropFactorIV(self)


    def getExifExposureTimeIV(self):
        """getExifExposureTimeIV(BaseSrcPanoImage self) -> HuginBase::ImageVariable< double > const &"""
        return _hsi.BaseSrcPanoImage_getExifExposureTimeIV(self)


    def getExifDateIV(self):
        """getExifDateIV(BaseSrcPanoImage self) -> HuginBase::ImageVariable< std::string > const &"""
        return _hsi.BaseSrcPanoImage_getExifDateIV(self)


    def getExifExposureModeIV(self):
        """getExifExposureModeIV(BaseSrcPanoImage self) -> HuginBase::ImageVariable< int > const &"""
        return _hsi.BaseSrcPanoImage_getExifExposureModeIV(self)


    def getExifRedBalanceIV(self):
        """getExifRedBalanceIV(BaseSrcPanoImage self) -> HuginBase::ImageVariable< double > const &"""
        return _hsi.BaseSrcPanoImage_getExifRedBalanceIV(self)


    def getExifBlueBalanceIV(self):
        """getExifBlueBalanceIV(BaseSrcPanoImage self) -> HuginBase::ImageVariable< double > const &"""
        return _hsi.BaseSrcPanoImage_getExifBlueBalanceIV(self)


    def getMasksIV(self):
        """getMasksIV(BaseSrcPanoImage self) -> HuginBase::ImageVariable< HuginBase::MaskPolygonVector > const &"""
        return _hsi.BaseSrcPanoImage_getMasksIV(self)


    def getActiveMasksIV(self):
        """getActiveMasksIV(BaseSrcPanoImage self) -> HuginBase::ImageVariable< HuginBase::MaskPolygonVector > const &"""
        return _hsi.BaseSrcPanoImage_getActiveMasksIV(self)


    def getActiveIV(self):
        """getActiveIV(BaseSrcPanoImage self) -> HuginBase::ImageVariable< bool > const &"""
        return _hsi.BaseSrcPanoImage_getActiveIV(self)


    def setFilename(self, data):
        """setFilename(BaseSrcPanoImage self, std::string data)"""
        return _hsi.BaseSrcPanoImage_setFilename(self, data)


    def setSize(self, data):
        """setSize(BaseSrcPanoImage self, Size2D data)"""
        return _hsi.BaseSrcPanoImage_setSize(self, data)


    def setProjection(self, data):
        """setProjection(BaseSrcPanoImage self, HuginBase::BaseSrcPanoImage::Projection data)"""
        return _hsi.BaseSrcPanoImage_setProjection(self, data)


    def setHFOV(self, data):
        """setHFOV(BaseSrcPanoImage self, double data)"""
        return _hsi.BaseSrcPanoImage_setHFOV(self, data)


    def setCropFactor(self, data):
        """setCropFactor(BaseSrcPanoImage self, double data)"""
        return _hsi.BaseSrcPanoImage_setCropFactor(self, data)


    def setResponseType(self, data):
        """setResponseType(BaseSrcPanoImage self, HuginBase::BaseSrcPanoImage::ResponseType data)"""
        return _hsi.BaseSrcPanoImage_setResponseType(self, data)


    def setEMoRParams(self, data):
        """setEMoRParams(BaseSrcPanoImage self, std::vector< float,std::allocator< float > > data)"""
        return _hsi.BaseSrcPanoImage_setEMoRParams(self, data)


    def setExposureValue(self, data):
        """setExposureValue(BaseSrcPanoImage self, double data)"""
        return _hsi.BaseSrcPanoImage_setExposureValue(self, data)


    def setGamma(self, data):
        """setGamma(BaseSrcPanoImage self, double data)"""
        return _hsi.BaseSrcPanoImage_setGamma(self, data)


    def setWhiteBalanceRed(self, data):
        """setWhiteBalanceRed(BaseSrcPanoImage self, double data)"""
        return _hsi.BaseSrcPanoImage_setWhiteBalanceRed(self, data)


    def setWhiteBalanceBlue(self, data):
        """setWhiteBalanceBlue(BaseSrcPanoImage self, double data)"""
        return _hsi.BaseSrcPanoImage_setWhiteBalanceBlue(self, data)


    def setRoll(self, data):
        """setRoll(BaseSrcPanoImage self, double data)"""
        return _hsi.BaseSrcPanoImage_setRoll(self, data)


    def setPitch(self, data):
        """setPitch(BaseSrcPanoImage self, double data)"""
        return _hsi.BaseSrcPanoImage_setPitch(self, data)


    def setYaw(self, data):
        """setYaw(BaseSrcPanoImage self, double data)"""
        return _hsi.BaseSrcPanoImage_setYaw(self, data)


    def setX(self, data):
        """setX(BaseSrcPanoImage self, double data)"""
        return _hsi.BaseSrcPanoImage_setX(self, data)


    def setY(self, data):
        """setY(BaseSrcPanoImage self, double data)"""
        return _hsi.BaseSrcPanoImage_setY(self, data)


    def setZ(self, data):
        """setZ(BaseSrcPanoImage self, double data)"""
        return _hsi.BaseSrcPanoImage_setZ(self, data)


    def setTranslationPlaneYaw(self, data):
        """setTranslationPlaneYaw(BaseSrcPanoImage self, double data)"""
        return _hsi.BaseSrcPanoImage_setTranslationPlaneYaw(self, data)


    def setTranslationPlanePitch(self, data):
        """setTranslationPlanePitch(BaseSrcPanoImage self, double data)"""
        return _hsi.BaseSrcPanoImage_setTranslationPlanePitch(self, data)


    def setStack(self, data):
        """setStack(BaseSrcPanoImage self, double data)"""
        return _hsi.BaseSrcPanoImage_setStack(self, data)


    def setRadialDistortion(self, data):
        """setRadialDistortion(BaseSrcPanoImage self, std::vector< double,std::allocator< double > > data)"""
        return _hsi.BaseSrcPanoImage_setRadialDistortion(self, data)


    def setRadialDistortionRed(self, data):
        """setRadialDistortionRed(BaseSrcPanoImage self, std::vector< double,std::allocator< double > > data)"""
        return _hsi.BaseSrcPanoImage_setRadialDistortionRed(self, data)


    def setRadialDistortionBlue(self, data):
        """setRadialDistortionBlue(BaseSrcPanoImage self, std::vector< double,std::allocator< double > > data)"""
        return _hsi.BaseSrcPanoImage_setRadialDistortionBlue(self, data)


    def setRadialDistortionCenterShift(self, data):
        """setRadialDistortionCenterShift(BaseSrcPanoImage self, FDiff2D data)"""
        return _hsi.BaseSrcPanoImage_setRadialDistortionCenterShift(self, data)


    def setShear(self, data):
        """setShear(BaseSrcPanoImage self, FDiff2D data)"""
        return _hsi.BaseSrcPanoImage_setShear(self, data)


    def setCropMode(self, data):
        """setCropMode(BaseSrcPanoImage self, HuginBase::BaseSrcPanoImage::CropMode data)"""
        return _hsi.BaseSrcPanoImage_setCropMode(self, data)


    def setCropRect(self, data):
        """setCropRect(BaseSrcPanoImage self, Rect2D data)"""
        return _hsi.BaseSrcPanoImage_setCropRect(self, data)


    def setAutoCenterCrop(self, data):
        """setAutoCenterCrop(BaseSrcPanoImage self, bool data)"""
        return _hsi.BaseSrcPanoImage_setAutoCenterCrop(self, data)


    def setVigCorrMode(self, data):
        """setVigCorrMode(BaseSrcPanoImage self, int data)"""
        return _hsi.BaseSrcPanoImage_setVigCorrMode(self, data)


    def setFlatfieldFilename(self, data):
        """setFlatfieldFilename(BaseSrcPanoImage self, std::string data)"""
        return _hsi.BaseSrcPanoImage_setFlatfieldFilename(self, data)


    def setRadialVigCorrCoeff(self, data):
        """setRadialVigCorrCoeff(BaseSrcPanoImage self, std::vector< double,std::allocator< double > > data)"""
        return _hsi.BaseSrcPanoImage_setRadialVigCorrCoeff(self, data)


    def setRadialVigCorrCenterShift(self, data):
        """setRadialVigCorrCenterShift(BaseSrcPanoImage self, FDiff2D data)"""
        return _hsi.BaseSrcPanoImage_setRadialVigCorrCenterShift(self, data)


    def setExifModel(self, data):
        """setExifModel(BaseSrcPanoImage self, std::string data)"""
        return _hsi.BaseSrcPanoImage_setExifModel(self, data)


    def setExifMake(self, data):
        """setExifMake(BaseSrcPanoImage self, std::string data)"""
        return _hsi.BaseSrcPanoImage_setExifMake(self, data)


    def setExifLens(self, data):
        """setExifLens(BaseSrcPanoImage self, std::string data)"""
        return _hsi.BaseSrcPanoImage_setExifLens(self, data)


    def setExifFocalLength(self, data):
        """setExifFocalLength(BaseSrcPanoImage self, double data)"""
        return _hsi.BaseSrcPanoImage_setExifFocalLength(self, data)


    def setExifOrientation(self, data):
        """setExifOrientation(BaseSrcPanoImage self, double data)"""
        return _hsi.BaseSrcPanoImage_setExifOrientation(self, data)


    def setExifAperture(self, data):
        """setExifAperture(BaseSrcPanoImage self, double data)"""
        return _hsi.BaseSrcPanoImage_setExifAperture(self, data)


    def setExifISO(self, data):
        """setExifISO(BaseSrcPanoImage self, double data)"""
        return _hsi.BaseSrcPanoImage_setExifISO(self, data)


    def setExifDistance(self, data):
        """setExifDistance(BaseSrcPanoImage self, double data)"""
        return _hsi.BaseSrcPanoImage_setExifDistance(self, data)


    def setExifFocalLength35(self, data):
        """setExifFocalLength35(BaseSrcPanoImage self, double data)"""
        return _hsi.BaseSrcPanoImage_setExifFocalLength35(self, data)


    def setExifCropFactor(self, data):
        """setExifCropFactor(BaseSrcPanoImage self, double data)"""
        return _hsi.BaseSrcPanoImage_setExifCropFactor(self, data)


    def setExifExposureTime(self, data):
        """setExifExposureTime(BaseSrcPanoImage self, double data)"""
        return _hsi.BaseSrcPanoImage_setExifExposureTime(self, data)


    def setExifDate(self, data):
        """setExifDate(BaseSrcPanoImage self, std::string data)"""
        return _hsi.BaseSrcPanoImage_setExifDate(self, data)


    def setExifExposureMode(self, data):
        """setExifExposureMode(BaseSrcPanoImage self, int data)"""
        return _hsi.BaseSrcPanoImage_setExifExposureMode(self, data)


    def setExifRedBalance(self, data):
        """setExifRedBalance(BaseSrcPanoImage self, double data)"""
        return _hsi.BaseSrcPanoImage_setExifRedBalance(self, data)


    def setExifBlueBalance(self, data):
        """setExifBlueBalance(BaseSrcPanoImage self, double data)"""
        return _hsi.BaseSrcPanoImage_setExifBlueBalance(self, data)


    def setMasks(self, data):
        """setMasks(BaseSrcPanoImage self, HuginBase::MaskPolygonVector data)"""
        return _hsi.BaseSrcPanoImage_setMasks(self, data)


    def setActiveMasks(self, data):
        """setActiveMasks(BaseSrcPanoImage self, HuginBase::MaskPolygonVector data)"""
        return _hsi.BaseSrcPanoImage_setActiveMasks(self, data)


    def setActive(self, data):
        """setActive(BaseSrcPanoImage self, bool data)"""
        return _hsi.BaseSrcPanoImage_setActive(self, data)


    def linkFilename(self, target):
        """linkFilename(BaseSrcPanoImage self, BaseSrcPanoImage target)"""
        return _hsi.BaseSrcPanoImage_linkFilename(self, target)


    def linkSize(self, target):
        """linkSize(BaseSrcPanoImage self, BaseSrcPanoImage target)"""
        return _hsi.BaseSrcPanoImage_linkSize(self, target)


    def linkProjection(self, target):
        """linkProjection(BaseSrcPanoImage self, BaseSrcPanoImage target)"""
        return _hsi.BaseSrcPanoImage_linkProjection(self, target)


    def linkHFOV(self, target):
        """linkHFOV(BaseSrcPanoImage self, BaseSrcPanoImage target)"""
        return _hsi.BaseSrcPanoImage_linkHFOV(self, target)


    def linkCropFactor(self, target):
        """linkCropFactor(BaseSrcPanoImage self, BaseSrcPanoImage target)"""
        return _hsi.BaseSrcPanoImage_linkCropFactor(self, target)


    def linkResponseType(self, target):
        """linkResponseType(BaseSrcPanoImage self, BaseSrcPanoImage target)"""
        return _hsi.BaseSrcPanoImage_linkResponseType(self, target)


    def linkEMoRParams(self, target):
        """linkEMoRParams(BaseSrcPanoImage self, BaseSrcPanoImage target)"""
        return _hsi.BaseSrcPanoImage_linkEMoRParams(self, target)


    def linkExposureValue(self, target):
        """linkExposureValue(BaseSrcPanoImage self, BaseSrcPanoImage target)"""
        return _hsi.BaseSrcPanoImage_linkExposureValue(self, target)


    def linkGamma(self, target):
        """linkGamma(BaseSrcPanoImage self, BaseSrcPanoImage target)"""
        return _hsi.BaseSrcPanoImage_linkGamma(self, target)


    def linkWhiteBalanceRed(self, target):
        """linkWhiteBalanceRed(BaseSrcPanoImage self, BaseSrcPanoImage target)"""
        return _hsi.BaseSrcPanoImage_linkWhiteBalanceRed(self, target)


    def linkWhiteBalanceBlue(self, target):
        """linkWhiteBalanceBlue(BaseSrcPanoImage self, BaseSrcPanoImage target)"""
        return _hsi.BaseSrcPanoImage_linkWhiteBalanceBlue(self, target)


    def linkRoll(self, target):
        """linkRoll(BaseSrcPanoImage self, BaseSrcPanoImage target)"""
        return _hsi.BaseSrcPanoImage_linkRoll(self, target)


    def linkPitch(self, target):
        """linkPitch(BaseSrcPanoImage self, BaseSrcPanoImage target)"""
        return _hsi.BaseSrcPanoImage_linkPitch(self, target)


    def linkYaw(self, target):
        """linkYaw(BaseSrcPanoImage self, BaseSrcPanoImage target)"""
        return _hsi.BaseSrcPanoImage_linkYaw(self, target)


    def linkX(self, target):
        """linkX(BaseSrcPanoImage self, BaseSrcPanoImage target)"""
        return _hsi.BaseSrcPanoImage_linkX(self, target)


    def linkY(self, target):
        """linkY(BaseSrcPanoImage self, BaseSrcPanoImage target)"""
        return _hsi.BaseSrcPanoImage_linkY(self, target)


    def linkZ(self, target):
        """linkZ(BaseSrcPanoImage self, BaseSrcPanoImage target)"""
        return _hsi.BaseSrcPanoImage_linkZ(self, target)


    def linkTranslationPlaneYaw(self, target):
        """linkTranslationPlaneYaw(BaseSrcPanoImage self, BaseSrcPanoImage target)"""
        return _hsi.BaseSrcPanoImage_linkTranslationPlaneYaw(self, target)


    def linkTranslationPlanePitch(self, target):
        """linkTranslationPlanePitch(BaseSrcPanoImage self, BaseSrcPanoImage target)"""
        return _hsi.BaseSrcPanoImage_linkTranslationPlanePitch(self, target)


    def linkStack(self, target):
        """linkStack(BaseSrcPanoImage self, BaseSrcPanoImage target)"""
        return _hsi.BaseSrcPanoImage_linkStack(self, target)


    def linkRadialDistortion(self, target):
        """linkRadialDistortion(BaseSrcPanoImage self, BaseSrcPanoImage target)"""
        return _hsi.BaseSrcPanoImage_linkRadialDistortion(self, target)


    def linkRadialDistortionRed(self, target):
        """linkRadialDistortionRed(BaseSrcPanoImage self, BaseSrcPanoImage target)"""
        return _hsi.BaseSrcPanoImage_linkRadialDistortionRed(self, target)


    def linkRadialDistortionBlue(self, target):
        """linkRadialDistortionBlue(BaseSrcPanoImage self, BaseSrcPanoImage target)"""
        return _hsi.BaseSrcPanoImage_linkRadialDistortionBlue(self, target)


    def linkRadialDistortionCenterShift(self, target):
        """linkRadialDistortionCenterShift(BaseSrcPanoImage self, BaseSrcPanoImage target)"""
        return _hsi.BaseSrcPanoImage_linkRadialDistortionCenterShift(self, target)


    def linkShear(self, target):
        """linkShear(BaseSrcPanoImage self, BaseSrcPanoImage target)"""
        return _hsi.BaseSrcPanoImage_linkShear(self, target)


    def linkCropMode(self, target):
        """linkCropMode(BaseSrcPanoImage self, BaseSrcPanoImage target)"""
        return _hsi.BaseSrcPanoImage_linkCropMode(self, target)


    def linkCropRect(self, target):
        """linkCropRect(BaseSrcPanoImage self, BaseSrcPanoImage target)"""
        return _hsi.BaseSrcPanoImage_linkCropRect(self, target)


    def linkAutoCenterCrop(self, target):
        """linkAutoCenterCrop(BaseSrcPanoImage self, BaseSrcPanoImage target)"""
        return _hsi.BaseSrcPanoImage_linkAutoCenterCrop(self, target)


    def linkVigCorrMode(self, target):
        """linkVigCorrMode(BaseSrcPanoImage self, BaseSrcPanoImage target)"""
        return _hsi.BaseSrcPanoImage_linkVigCorrMode(self, target)


    def linkFlatfieldFilename(self, target):
        """linkFlatfieldFilename(BaseSrcPanoImage self, BaseSrcPanoImage target)"""
        return _hsi.BaseSrcPanoImage_linkFlatfieldFilename(self, target)


    def linkRadialVigCorrCoeff(self, target):
        """linkRadialVigCorrCoeff(BaseSrcPanoImage self, BaseSrcPanoImage target)"""
        return _hsi.BaseSrcPanoImage_linkRadialVigCorrCoeff(self, target)


    def linkRadialVigCorrCenterShift(self, target):
        """linkRadialVigCorrCenterShift(BaseSrcPanoImage self, BaseSrcPanoImage target)"""
        return _hsi.BaseSrcPanoImage_linkRadialVigCorrCenterShift(self, target)


    def linkExifModel(self, target):
        """linkExifModel(BaseSrcPanoImage self, BaseSrcPanoImage target)"""
        return _hsi.BaseSrcPanoImage_linkExifModel(self, target)


    def linkExifMake(self, target):
        """linkExifMake(BaseSrcPanoImage self, BaseSrcPanoImage target)"""
        return _hsi.BaseSrcPanoImage_linkExifMake(self, target)


    def linkExifLens(self, target):
        """linkExifLens(BaseSrcPanoImage self, BaseSrcPanoImage target)"""
        return _hsi.BaseSrcPanoImage_linkExifLens(self, target)


    def linkExifFocalLength(self, target):
        """linkExifFocalLength(BaseSrcPanoImage self, BaseSrcPanoImage target)"""
        return _hsi.BaseSrcPanoImage_linkExifFocalLength(self, target)


    def linkExifOrientation(self, target):
        """linkExifOrientation(BaseSrcPanoImage self, BaseSrcPanoImage target)"""
        return _hsi.BaseSrcPanoImage_linkExifOrientation(self, target)


    def linkExifAperture(self, target):
        """linkExifAperture(BaseSrcPanoImage self, BaseSrcPanoImage target)"""
        return _hsi.BaseSrcPanoImage_linkExifAperture(self, target)


    def linkExifISO(self, target):
        """linkExifISO(BaseSrcPanoImage self, BaseSrcPanoImage target)"""
        return _hsi.BaseSrcPanoImage_linkExifISO(self, target)


    def linkExifDistance(self, target):
        """linkExifDistance(BaseSrcPanoImage self, BaseSrcPanoImage target)"""
        return _hsi.BaseSrcPanoImage_linkExifDistance(self, target)


    def linkExifFocalLength35(self, target):
        """linkExifFocalLength35(BaseSrcPanoImage self, BaseSrcPanoImage target)"""
        return _hsi.BaseSrcPanoImage_linkExifFocalLength35(self, target)


    def linkExifCropFactor(self, target):
        """linkExifCropFactor(BaseSrcPanoImage self, BaseSrcPanoImage target)"""
        return _hsi.BaseSrcPanoImage_linkExifCropFactor(self, target)


    def linkExifExposureTime(self, target):
        """linkExifExposureTime(BaseSrcPanoImage self, BaseSrcPanoImage target)"""
        return _hsi.BaseSrcPanoImage_linkExifExposureTime(self, target)


    def linkExifDate(self, target):
        """linkExifDate(BaseSrcPanoImage self, BaseSrcPanoImage target)"""
        return _hsi.BaseSrcPanoImage_linkExifDate(self, target)


    def linkExifExposureMode(self, target):
        """linkExifExposureMode(BaseSrcPanoImage self, BaseSrcPanoImage target)"""
        return _hsi.BaseSrcPanoImage_linkExifExposureMode(self, target)


    def linkExifRedBalance(self, target):
        """linkExifRedBalance(BaseSrcPanoImage self, BaseSrcPanoImage target)"""
        return _hsi.BaseSrcPanoImage_linkExifRedBalance(self, target)


    def linkExifBlueBalance(self, target):
        """linkExifBlueBalance(BaseSrcPanoImage self, BaseSrcPanoImage target)"""
        return _hsi.BaseSrcPanoImage_linkExifBlueBalance(self, target)


    def linkMasks(self, target):
        """linkMasks(BaseSrcPanoImage self, BaseSrcPanoImage target)"""
        return _hsi.BaseSrcPanoImage_linkMasks(self, target)


    def linkActiveMasks(self, target):
        """linkActiveMasks(BaseSrcPanoImage self, BaseSrcPanoImage target)"""
        return _hsi.BaseSrcPanoImage_linkActiveMasks(self, target)


    def linkActive(self, target):
        """linkActive(BaseSrcPanoImage self, BaseSrcPanoImage target)"""
        return _hsi.BaseSrcPanoImage_linkActive(self, target)


    def unlinkFilename(self):
        """unlinkFilename(BaseSrcPanoImage self)"""
        return _hsi.BaseSrcPanoImage_unlinkFilename(self)


    def unlinkSize(self):
        """unlinkSize(BaseSrcPanoImage self)"""
        return _hsi.BaseSrcPanoImage_unlinkSize(self)


    def unlinkProjection(self):
        """unlinkProjection(BaseSrcPanoImage self)"""
        return _hsi.BaseSrcPanoImage_unlinkProjection(self)


    def unlinkHFOV(self):
        """unlinkHFOV(BaseSrcPanoImage self)"""
        return _hsi.BaseSrcPanoImage_unlinkHFOV(self)


    def unlinkCropFactor(self):
        """unlinkCropFactor(BaseSrcPanoImage self)"""
        return _hsi.BaseSrcPanoImage_unlinkCropFactor(self)


    def unlinkResponseType(self):
        """unlinkResponseType(BaseSrcPanoImage self)"""
        return _hsi.BaseSrcPanoImage_unlinkResponseType(self)


    def unlinkEMoRParams(self):
        """unlinkEMoRParams(BaseSrcPanoImage self)"""
        return _hsi.BaseSrcPanoImage_unlinkEMoRParams(self)


    def unlinkExposureValue(self):
        """unlinkExposureValue(BaseSrcPanoImage self)"""
        return _hsi.BaseSrcPanoImage_unlinkExposureValue(self)


    def unlinkGamma(self):
        """unlinkGamma(BaseSrcPanoImage self)"""
        return _hsi.BaseSrcPanoImage_unlinkGamma(self)


    def unlinkWhiteBalanceRed(self):
        """unlinkWhiteBalanceRed(BaseSrcPanoImage self)"""
        return _hsi.BaseSrcPanoImage_unlinkWhiteBalanceRed(self)


    def unlinkWhiteBalanceBlue(self):
        """unlinkWhiteBalanceBlue(BaseSrcPanoImage self)"""
        return _hsi.BaseSrcPanoImage_unlinkWhiteBalanceBlue(self)


    def unlinkRoll(self):
        """unlinkRoll(BaseSrcPanoImage self)"""
        return _hsi.BaseSrcPanoImage_unlinkRoll(self)


    def unlinkPitch(self):
        """unlinkPitch(BaseSrcPanoImage self)"""
        return _hsi.BaseSrcPanoImage_unlinkPitch(self)


    def unlinkYaw(self):
        """unlinkYaw(BaseSrcPanoImage self)"""
        return _hsi.BaseSrcPanoImage_unlinkYaw(self)


    def unlinkX(self):
        """unlinkX(BaseSrcPanoImage self)"""
        return _hsi.BaseSrcPanoImage_unlinkX(self)


    def unlinkY(self):
        """unlinkY(BaseSrcPanoImage self)"""
        return _hsi.BaseSrcPanoImage_unlinkY(self)


    def unlinkZ(self):
        """unlinkZ(BaseSrcPanoImage self)"""
        return _hsi.BaseSrcPanoImage_unlinkZ(self)


    def unlinkTranslationPlaneYaw(self):
        """unlinkTranslationPlaneYaw(BaseSrcPanoImage self)"""
        return _hsi.BaseSrcPanoImage_unlinkTranslationPlaneYaw(self)


    def unlinkTranslationPlanePitch(self):
        """unlinkTranslationPlanePitch(BaseSrcPanoImage self)"""
        return _hsi.BaseSrcPanoImage_unlinkTranslationPlanePitch(self)


    def unlinkStack(self):
        """unlinkStack(BaseSrcPanoImage self)"""
        return _hsi.BaseSrcPanoImage_unlinkStack(self)


    def unlinkRadialDistortion(self):
        """unlinkRadialDistortion(BaseSrcPanoImage self)"""
        return _hsi.BaseSrcPanoImage_unlinkRadialDistortion(self)


    def unlinkRadialDistortionRed(self):
        """unlinkRadialDistortionRed(BaseSrcPanoImage self)"""
        return _hsi.BaseSrcPanoImage_unlinkRadialDistortionRed(self)


    def unlinkRadialDistortionBlue(self):
        """unlinkRadialDistortionBlue(BaseSrcPanoImage self)"""
        return _hsi.BaseSrcPanoImage_unlinkRadialDistortionBlue(self)


    def unlinkRadialDistortionCenterShift(self):
        """unlinkRadialDistortionCenterShift(BaseSrcPanoImage self)"""
        return _hsi.BaseSrcPanoImage_unlinkRadialDistortionCenterShift(self)


    def unlinkShear(self):
        """unlinkShear(BaseSrcPanoImage self)"""
        return _hsi.BaseSrcPanoImage_unlinkShear(self)


    def unlinkCropMode(self):
        """unlinkCropMode(BaseSrcPanoImage self)"""
        return _hsi.BaseSrcPanoImage_unlinkCropMode(self)


    def unlinkCropRect(self):
        """unlinkCropRect(BaseSrcPanoImage self)"""
        return _hsi.BaseSrcPanoImage_unlinkCropRect(self)


    def unlinkAutoCenterCrop(self):
        """unlinkAutoCenterCrop(BaseSrcPanoImage self)"""
        return _hsi.BaseSrcPanoImage_unlinkAutoCenterCrop(self)


    def unlinkVigCorrMode(self):
        """unlinkVigCorrMode(BaseSrcPanoImage self)"""
        return _hsi.BaseSrcPanoImage_unlinkVigCorrMode(self)


    def unlinkFlatfieldFilename(self):
        """unlinkFlatfieldFilename(BaseSrcPanoImage self)"""
        return _hsi.BaseSrcPanoImage_unlinkFlatfieldFilename(self)


    def unlinkRadialVigCorrCoeff(self):
        """unlinkRadialVigCorrCoeff(BaseSrcPanoImage self)"""
        return _hsi.BaseSrcPanoImage_unlinkRadialVigCorrCoeff(self)


    def unlinkRadialVigCorrCenterShift(self):
        """unlinkRadialVigCorrCenterShift(BaseSrcPanoImage self)"""
        return _hsi.BaseSrcPanoImage_unlinkRadialVigCorrCenterShift(self)


    def unlinkExifModel(self):
        """unlinkExifModel(BaseSrcPanoImage self)"""
        return _hsi.BaseSrcPanoImage_unlinkExifModel(self)


    def unlinkExifMake(self):
        """unlinkExifMake(BaseSrcPanoImage self)"""
        return _hsi.BaseSrcPanoImage_unlinkExifMake(self)


    def unlinkExifLens(self):
        """unlinkExifLens(BaseSrcPanoImage self)"""
        return _hsi.BaseSrcPanoImage_unlinkExifLens(self)


    def unlinkExifFocalLength(self):
        """unlinkExifFocalLength(BaseSrcPanoImage self)"""
        return _hsi.BaseSrcPanoImage_unlinkExifFocalLength(self)


    def unlinkExifOrientation(self):
        """unlinkExifOrientation(BaseSrcPanoImage self)"""
        return _hsi.BaseSrcPanoImage_unlinkExifOrientation(self)


    def unlinkExifAperture(self):
        """unlinkExifAperture(BaseSrcPanoImage self)"""
        return _hsi.BaseSrcPanoImage_unlinkExifAperture(self)


    def unlinkExifISO(self):
        """unlinkExifISO(BaseSrcPanoImage self)"""
        return _hsi.BaseSrcPanoImage_unlinkExifISO(self)


    def unlinkExifDistance(self):
        """unlinkExifDistance(BaseSrcPanoImage self)"""
        return _hsi.BaseSrcPanoImage_unlinkExifDistance(self)


    def unlinkExifFocalLength35(self):
        """unlinkExifFocalLength35(BaseSrcPanoImage self)"""
        return _hsi.BaseSrcPanoImage_unlinkExifFocalLength35(self)


    def unlinkExifCropFactor(self):
        """unlinkExifCropFactor(BaseSrcPanoImage self)"""
        return _hsi.BaseSrcPanoImage_unlinkExifCropFactor(self)


    def unlinkExifExposureTime(self):
        """unlinkExifExposureTime(BaseSrcPanoImage self)"""
        return _hsi.BaseSrcPanoImage_unlinkExifExposureTime(self)


    def unlinkExifDate(self):
        """unlinkExifDate(BaseSrcPanoImage self)"""
        return _hsi.BaseSrcPanoImage_unlinkExifDate(self)


    def unlinkExifExposureMode(self):
        """unlinkExifExposureMode(BaseSrcPanoImage self)"""
        return _hsi.BaseSrcPanoImage_unlinkExifExposureMode(self)


    def unlinkExifRedBalance(self):
        """unlinkExifRedBalance(BaseSrcPanoImage self)"""
        return _hsi.BaseSrcPanoImage_unlinkExifRedBalance(self)


    def unlinkExifBlueBalance(self):
        """unlinkExifBlueBalance(BaseSrcPanoImage self)"""
        return _hsi.BaseSrcPanoImage_unlinkExifBlueBalance(self)


    def unlinkMasks(self):
        """unlinkMasks(BaseSrcPanoImage self)"""
        return _hsi.BaseSrcPanoImage_unlinkMasks(self)


    def unlinkActiveMasks(self):
        """unlinkActiveMasks(BaseSrcPanoImage self)"""
        return _hsi.BaseSrcPanoImage_unlinkActiveMasks(self)


    def unlinkActive(self):
        """unlinkActive(BaseSrcPanoImage self)"""
        return _hsi.BaseSrcPanoImage_unlinkActive(self)


    def FilenameisLinked(self):
        """FilenameisLinked(BaseSrcPanoImage self) -> bool"""
        return _hsi.BaseSrcPanoImage_FilenameisLinked(self)


    def SizeisLinked(self):
        """SizeisLinked(BaseSrcPanoImage self) -> bool"""
        return _hsi.BaseSrcPanoImage_SizeisLinked(self)


    def ProjectionisLinked(self):
        """ProjectionisLinked(BaseSrcPanoImage self) -> bool"""
        return _hsi.BaseSrcPanoImage_ProjectionisLinked(self)


    def HFOVisLinked(self):
        """HFOVisLinked(BaseSrcPanoImage self) -> bool"""
        return _hsi.BaseSrcPanoImage_HFOVisLinked(self)


    def CropFactorisLinked(self):
        """CropFactorisLinked(BaseSrcPanoImage self) -> bool"""
        return _hsi.BaseSrcPanoImage_CropFactorisLinked(self)


    def ResponseTypeisLinked(self):
        """ResponseTypeisLinked(BaseSrcPanoImage self) -> bool"""
        return _hsi.BaseSrcPanoImage_ResponseTypeisLinked(self)


    def EMoRParamsisLinked(self):
        """EMoRParamsisLinked(BaseSrcPanoImage self) -> bool"""
        return _hsi.BaseSrcPanoImage_EMoRParamsisLinked(self)


    def ExposureValueisLinked(self):
        """ExposureValueisLinked(BaseSrcPanoImage self) -> bool"""
        return _hsi.BaseSrcPanoImage_ExposureValueisLinked(self)


    def GammaisLinked(self):
        """GammaisLinked(BaseSrcPanoImage self) -> bool"""
        return _hsi.BaseSrcPanoImage_GammaisLinked(self)


    def WhiteBalanceRedisLinked(self):
        """WhiteBalanceRedisLinked(BaseSrcPanoImage self) -> bool"""
        return _hsi.BaseSrcPanoImage_WhiteBalanceRedisLinked(self)


    def WhiteBalanceBlueisLinked(self):
        """WhiteBalanceBlueisLinked(BaseSrcPanoImage self) -> bool"""
        return _hsi.BaseSrcPanoImage_WhiteBalanceBlueisLinked(self)


    def RollisLinked(self):
        """RollisLinked(BaseSrcPanoImage self) -> bool"""
        return _hsi.BaseSrcPanoImage_RollisLinked(self)


    def PitchisLinked(self):
        """PitchisLinked(BaseSrcPanoImage self) -> bool"""
        return _hsi.BaseSrcPanoImage_PitchisLinked(self)


    def YawisLinked(self):
        """YawisLinked(BaseSrcPanoImage self) -> bool"""
        return _hsi.BaseSrcPanoImage_YawisLinked(self)


    def XisLinked(self):
        """XisLinked(BaseSrcPanoImage self) -> bool"""
        return _hsi.BaseSrcPanoImage_XisLinked(self)


    def YisLinked(self):
        """YisLinked(BaseSrcPanoImage self) -> bool"""
        return _hsi.BaseSrcPanoImage_YisLinked(self)


    def ZisLinked(self):
        """ZisLinked(BaseSrcPanoImage self) -> bool"""
        return _hsi.BaseSrcPanoImage_ZisLinked(self)


    def TranslationPlaneYawisLinked(self):
        """TranslationPlaneYawisLinked(BaseSrcPanoImage self) -> bool"""
        return _hsi.BaseSrcPanoImage_TranslationPlaneYawisLinked(self)


    def TranslationPlanePitchisLinked(self):
        """TranslationPlanePitchisLinked(BaseSrcPanoImage self) -> bool"""
        return _hsi.BaseSrcPanoImage_TranslationPlanePitchisLinked(self)


    def StackisLinked(self):
        """StackisLinked(BaseSrcPanoImage self) -> bool"""
        return _hsi.BaseSrcPanoImage_StackisLinked(self)


    def RadialDistortionisLinked(self):
        """RadialDistortionisLinked(BaseSrcPanoImage self) -> bool"""
        return _hsi.BaseSrcPanoImage_RadialDistortionisLinked(self)


    def RadialDistortionRedisLinked(self):
        """RadialDistortionRedisLinked(BaseSrcPanoImage self) -> bool"""
        return _hsi.BaseSrcPanoImage_RadialDistortionRedisLinked(self)


    def RadialDistortionBlueisLinked(self):
        """RadialDistortionBlueisLinked(BaseSrcPanoImage self) -> bool"""
        return _hsi.BaseSrcPanoImage_RadialDistortionBlueisLinked(self)


    def RadialDistortionCenterShiftisLinked(self):
        """RadialDistortionCenterShiftisLinked(BaseSrcPanoImage self) -> bool"""
        return _hsi.BaseSrcPanoImage_RadialDistortionCenterShiftisLinked(self)


    def ShearisLinked(self):
        """ShearisLinked(BaseSrcPanoImage self) -> bool"""
        return _hsi.BaseSrcPanoImage_ShearisLinked(self)


    def CropModeisLinked(self):
        """CropModeisLinked(BaseSrcPanoImage self) -> bool"""
        return _hsi.BaseSrcPanoImage_CropModeisLinked(self)


    def CropRectisLinked(self):
        """CropRectisLinked(BaseSrcPanoImage self) -> bool"""
        return _hsi.BaseSrcPanoImage_CropRectisLinked(self)


    def AutoCenterCropisLinked(self):
        """AutoCenterCropisLinked(BaseSrcPanoImage self) -> bool"""
        return _hsi.BaseSrcPanoImage_AutoCenterCropisLinked(self)


    def VigCorrModeisLinked(self):
        """VigCorrModeisLinked(BaseSrcPanoImage self) -> bool"""
        return _hsi.BaseSrcPanoImage_VigCorrModeisLinked(self)


    def FlatfieldFilenameisLinked(self):
        """FlatfieldFilenameisLinked(BaseSrcPanoImage self) -> bool"""
        return _hsi.BaseSrcPanoImage_FlatfieldFilenameisLinked(self)


    def RadialVigCorrCoeffisLinked(self):
        """RadialVigCorrCoeffisLinked(BaseSrcPanoImage self) -> bool"""
        return _hsi.BaseSrcPanoImage_RadialVigCorrCoeffisLinked(self)


    def RadialVigCorrCenterShiftisLinked(self):
        """RadialVigCorrCenterShiftisLinked(BaseSrcPanoImage self) -> bool"""
        return _hsi.BaseSrcPanoImage_RadialVigCorrCenterShiftisLinked(self)


    def ExifModelisLinked(self):
        """ExifModelisLinked(BaseSrcPanoImage self) -> bool"""
        return _hsi.BaseSrcPanoImage_ExifModelisLinked(self)


    def ExifMakeisLinked(self):
        """ExifMakeisLinked(BaseSrcPanoImage self) -> bool"""
        return _hsi.BaseSrcPanoImage_ExifMakeisLinked(self)


    def ExifLensisLinked(self):
        """ExifLensisLinked(BaseSrcPanoImage self) -> bool"""
        return _hsi.BaseSrcPanoImage_ExifLensisLinked(self)


    def ExifFocalLengthisLinked(self):
        """ExifFocalLengthisLinked(BaseSrcPanoImage self) -> bool"""
        return _hsi.BaseSrcPanoImage_ExifFocalLengthisLinked(self)


    def ExifOrientationisLinked(self):
        """ExifOrientationisLinked(BaseSrcPanoImage self) -> bool"""
        return _hsi.BaseSrcPanoImage_ExifOrientationisLinked(self)


    def ExifApertureisLinked(self):
        """ExifApertureisLinked(BaseSrcPanoImage self) -> bool"""
        return _hsi.BaseSrcPanoImage_ExifApertureisLinked(self)


    def ExifISOisLinked(self):
        """ExifISOisLinked(BaseSrcPanoImage self) -> bool"""
        return _hsi.BaseSrcPanoImage_ExifISOisLinked(self)


    def ExifDistanceisLinked(self):
        """ExifDistanceisLinked(BaseSrcPanoImage self) -> bool"""
        return _hsi.BaseSrcPanoImage_ExifDistanceisLinked(self)


    def ExifFocalLength35isLinked(self):
        """ExifFocalLength35isLinked(BaseSrcPanoImage self) -> bool"""
        return _hsi.BaseSrcPanoImage_ExifFocalLength35isLinked(self)


    def ExifCropFactorisLinked(self):
        """ExifCropFactorisLinked(BaseSrcPanoImage self) -> bool"""
        return _hsi.BaseSrcPanoImage_ExifCropFactorisLinked(self)


    def ExifExposureTimeisLinked(self):
        """ExifExposureTimeisLinked(BaseSrcPanoImage self) -> bool"""
        return _hsi.BaseSrcPanoImage_ExifExposureTimeisLinked(self)


    def ExifDateisLinked(self):
        """ExifDateisLinked(BaseSrcPanoImage self) -> bool"""
        return _hsi.BaseSrcPanoImage_ExifDateisLinked(self)


    def ExifExposureModeisLinked(self):
        """ExifExposureModeisLinked(BaseSrcPanoImage self) -> bool"""
        return _hsi.BaseSrcPanoImage_ExifExposureModeisLinked(self)


    def ExifRedBalanceisLinked(self):
        """ExifRedBalanceisLinked(BaseSrcPanoImage self) -> bool"""
        return _hsi.BaseSrcPanoImage_ExifRedBalanceisLinked(self)


    def ExifBlueBalanceisLinked(self):
        """ExifBlueBalanceisLinked(BaseSrcPanoImage self) -> bool"""
        return _hsi.BaseSrcPanoImage_ExifBlueBalanceisLinked(self)


    def MasksisLinked(self):
        """MasksisLinked(BaseSrcPanoImage self) -> bool"""
        return _hsi.BaseSrcPanoImage_MasksisLinked(self)


    def ActiveMasksisLinked(self):
        """ActiveMasksisLinked(BaseSrcPanoImage self) -> bool"""
        return _hsi.BaseSrcPanoImage_ActiveMasksisLinked(self)


    def ActiveisLinked(self):
        """ActiveisLinked(BaseSrcPanoImage self) -> bool"""
        return _hsi.BaseSrcPanoImage_ActiveisLinked(self)


    def FilenameisLinkedWith(self, image):
        """FilenameisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_FilenameisLinkedWith(self, image)


    def SizeisLinkedWith(self, image):
        """SizeisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_SizeisLinkedWith(self, image)


    def ProjectionisLinkedWith(self, image):
        """ProjectionisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_ProjectionisLinkedWith(self, image)


    def HFOVisLinkedWith(self, image):
        """HFOVisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_HFOVisLinkedWith(self, image)


    def CropFactorisLinkedWith(self, image):
        """CropFactorisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_CropFactorisLinkedWith(self, image)


    def ResponseTypeisLinkedWith(self, image):
        """ResponseTypeisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_ResponseTypeisLinkedWith(self, image)


    def EMoRParamsisLinkedWith(self, image):
        """EMoRParamsisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_EMoRParamsisLinkedWith(self, image)


    def ExposureValueisLinkedWith(self, image):
        """ExposureValueisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_ExposureValueisLinkedWith(self, image)


    def GammaisLinkedWith(self, image):
        """GammaisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_GammaisLinkedWith(self, image)


    def WhiteBalanceRedisLinkedWith(self, image):
        """WhiteBalanceRedisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_WhiteBalanceRedisLinkedWith(self, image)


    def WhiteBalanceBlueisLinkedWith(self, image):
        """WhiteBalanceBlueisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_WhiteBalanceBlueisLinkedWith(self, image)


    def RollisLinkedWith(self, image):
        """RollisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_RollisLinkedWith(self, image)


    def PitchisLinkedWith(self, image):
        """PitchisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_PitchisLinkedWith(self, image)


    def YawisLinkedWith(self, image):
        """YawisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_YawisLinkedWith(self, image)


    def XisLinkedWith(self, image):
        """XisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_XisLinkedWith(self, image)


    def YisLinkedWith(self, image):
        """YisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_YisLinkedWith(self, image)


    def ZisLinkedWith(self, image):
        """ZisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_ZisLinkedWith(self, image)


    def TranslationPlaneYawisLinkedWith(self, image):
        """TranslationPlaneYawisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_TranslationPlaneYawisLinkedWith(self, image)


    def TranslationPlanePitchisLinkedWith(self, image):
        """TranslationPlanePitchisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_TranslationPlanePitchisLinkedWith(self, image)


    def StackisLinkedWith(self, image):
        """StackisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_StackisLinkedWith(self, image)


    def RadialDistortionisLinkedWith(self, image):
        """RadialDistortionisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_RadialDistortionisLinkedWith(self, image)


    def RadialDistortionRedisLinkedWith(self, image):
        """RadialDistortionRedisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_RadialDistortionRedisLinkedWith(self, image)


    def RadialDistortionBlueisLinkedWith(self, image):
        """RadialDistortionBlueisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_RadialDistortionBlueisLinkedWith(self, image)


    def RadialDistortionCenterShiftisLinkedWith(self, image):
        """RadialDistortionCenterShiftisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_RadialDistortionCenterShiftisLinkedWith(self, image)


    def ShearisLinkedWith(self, image):
        """ShearisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_ShearisLinkedWith(self, image)


    def CropModeisLinkedWith(self, image):
        """CropModeisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_CropModeisLinkedWith(self, image)


    def CropRectisLinkedWith(self, image):
        """CropRectisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_CropRectisLinkedWith(self, image)


    def AutoCenterCropisLinkedWith(self, image):
        """AutoCenterCropisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_AutoCenterCropisLinkedWith(self, image)


    def VigCorrModeisLinkedWith(self, image):
        """VigCorrModeisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_VigCorrModeisLinkedWith(self, image)


    def FlatfieldFilenameisLinkedWith(self, image):
        """FlatfieldFilenameisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_FlatfieldFilenameisLinkedWith(self, image)


    def RadialVigCorrCoeffisLinkedWith(self, image):
        """RadialVigCorrCoeffisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_RadialVigCorrCoeffisLinkedWith(self, image)


    def RadialVigCorrCenterShiftisLinkedWith(self, image):
        """RadialVigCorrCenterShiftisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_RadialVigCorrCenterShiftisLinkedWith(self, image)


    def ExifModelisLinkedWith(self, image):
        """ExifModelisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_ExifModelisLinkedWith(self, image)


    def ExifMakeisLinkedWith(self, image):
        """ExifMakeisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_ExifMakeisLinkedWith(self, image)


    def ExifLensisLinkedWith(self, image):
        """ExifLensisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_ExifLensisLinkedWith(self, image)


    def ExifFocalLengthisLinkedWith(self, image):
        """ExifFocalLengthisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_ExifFocalLengthisLinkedWith(self, image)


    def ExifOrientationisLinkedWith(self, image):
        """ExifOrientationisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_ExifOrientationisLinkedWith(self, image)


    def ExifApertureisLinkedWith(self, image):
        """ExifApertureisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_ExifApertureisLinkedWith(self, image)


    def ExifISOisLinkedWith(self, image):
        """ExifISOisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_ExifISOisLinkedWith(self, image)


    def ExifDistanceisLinkedWith(self, image):
        """ExifDistanceisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_ExifDistanceisLinkedWith(self, image)


    def ExifFocalLength35isLinkedWith(self, image):
        """ExifFocalLength35isLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_ExifFocalLength35isLinkedWith(self, image)


    def ExifCropFactorisLinkedWith(self, image):
        """ExifCropFactorisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_ExifCropFactorisLinkedWith(self, image)


    def ExifExposureTimeisLinkedWith(self, image):
        """ExifExposureTimeisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_ExifExposureTimeisLinkedWith(self, image)


    def ExifDateisLinkedWith(self, image):
        """ExifDateisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_ExifDateisLinkedWith(self, image)


    def ExifExposureModeisLinkedWith(self, image):
        """ExifExposureModeisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_ExifExposureModeisLinkedWith(self, image)


    def ExifRedBalanceisLinkedWith(self, image):
        """ExifRedBalanceisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_ExifRedBalanceisLinkedWith(self, image)


    def ExifBlueBalanceisLinkedWith(self, image):
        """ExifBlueBalanceisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_ExifBlueBalanceisLinkedWith(self, image)


    def MasksisLinkedWith(self, image):
        """MasksisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_MasksisLinkedWith(self, image)


    def ActiveMasksisLinkedWith(self, image):
        """ActiveMasksisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_ActiveMasksisLinkedWith(self, image)


    def ActiveisLinkedWith(self, image):
        """ActiveisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_ActiveisLinkedWith(self, image)

BaseSrcPanoImage_swigregister = _hsi.BaseSrcPanoImage_swigregister
BaseSrcPanoImage_swigregister(BaseSrcPanoImage)

class SrcPanoImage(BaseSrcPanoImage):
    """Proxy of C++ HuginBase::SrcPanoImage class"""
    __swig_setmethods__ = {}
    for _s in [BaseSrcPanoImage]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SrcPanoImage, name, value)
    __swig_getmethods__ = {}
    for _s in [BaseSrcPanoImage]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, SrcPanoImage, name)
    __repr__ = _swig_repr

    def __init__(self):
        """__init__(HuginBase::SrcPanoImage self) -> SrcPanoImage"""
        this = _hsi.new_SrcPanoImage()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _hsi.delete_SrcPanoImage
    __del__ = lambda self: None

    def resize(self, size):
        """resize(SrcPanoImage self, Size2D size)"""
        return _hsi.SrcPanoImage_resize(self, size)


    def isInside(self, p, ignoreMasks=False):
        """
        isInside(SrcPanoImage self, Point2D p, bool ignoreMasks=False) -> bool
        isInside(SrcPanoImage self, Point2D p) -> bool
        """
        return _hsi.SrcPanoImage_isInside(self, p, ignoreMasks)


    def horizontalWarpNeeded(self):
        """horizontalWarpNeeded(SrcPanoImage self) -> bool"""
        return _hsi.SrcPanoImage_horizontalWarpNeeded(self)


    def getCorrectTCA(self):
        """getCorrectTCA(SrcPanoImage self) -> bool"""
        return _hsi.SrcPanoImage_getCorrectTCA(self)


    def setCropMode(self, val):
        """setCropMode(SrcPanoImage self, HuginBase::BaseSrcPanoImage::CropMode val)"""
        return _hsi.SrcPanoImage_setCropMode(self, val)


    def isCircularCrop(self):
        """isCircularCrop(SrcPanoImage self) -> bool"""
        return _hsi.SrcPanoImage_isCircularCrop(self)


    def setSize(self, val):
        """setSize(SrcPanoImage self, Size2D val)"""
        return _hsi.SrcPanoImage_setSize(self, val)


    def getRadialDistortionCenter(self):
        """getRadialDistortionCenter(SrcPanoImage self) -> FDiff2D"""
        return _hsi.SrcPanoImage_getRadialDistortionCenter(self)


    def getRadialVigCorrCenter(self):
        """getRadialVigCorrCenter(SrcPanoImage self) -> FDiff2D"""
        return _hsi.SrcPanoImage_getRadialVigCorrCenter(self)


    def getExposure(self):
        """getExposure(SrcPanoImage self) -> double"""
        return _hsi.SrcPanoImage_getExposure(self)


    def setExposure(self, val):
        """setExposure(SrcPanoImage self, double const & val)"""
        return _hsi.SrcPanoImage_setExposure(self, val)


    def getWidth(self):
        """getWidth(SrcPanoImage self) -> int"""
        return _hsi.SrcPanoImage_getWidth(self)


    def getHeight(self):
        """getHeight(SrcPanoImage self) -> int"""
        return _hsi.SrcPanoImage_getHeight(self)


    def getVar(self, name):
        """getVar(SrcPanoImage self, std::string const & name) -> double"""
        return _hsi.SrcPanoImage_getVar(self, name)


    def setVar(self, name, val):
        """setVar(SrcPanoImage self, std::string const & name, double val)"""
        return _hsi.SrcPanoImage_setVar(self, name, val)


    def getVariableMap(self):
        """getVariableMap(SrcPanoImage self) -> HuginBase::VariableMap"""
        return _hsi.SrcPanoImage_getVariableMap(self)


    def getExifDateTime(self, datetime):
        """getExifDateTime(SrcPanoImage self, tm datetime) -> int const"""
        return _hsi.SrcPanoImage_getExifDateTime(self, datetime)


    def unlinkRadialVigCorrCoeff(self):
        """unlinkRadialVigCorrCoeff(SrcPanoImage self)"""
        return _hsi.SrcPanoImage_unlinkRadialVigCorrCoeff(self)


    def unlinkRadialVigCorrCenterShift(self):
        """unlinkRadialVigCorrCenterShift(SrcPanoImage self)"""
        return _hsi.SrcPanoImage_unlinkRadialVigCorrCenterShift(self)


    def unlinkEMoRParams(self):
        """unlinkEMoRParams(SrcPanoImage self)"""
        return _hsi.SrcPanoImage_unlinkEMoRParams(self)


    def linkRadialVigCorrCoeff(self, target):
        """linkRadialVigCorrCoeff(SrcPanoImage self, SrcPanoImage target)"""
        return _hsi.SrcPanoImage_linkRadialVigCorrCoeff(self, target)


    def linkRadialVigCorrCenterShift(self, target):
        """linkRadialVigCorrCenterShift(SrcPanoImage self, SrcPanoImage target)"""
        return _hsi.SrcPanoImage_linkRadialVigCorrCenterShift(self, target)


    def linkEMoRParams(self, target):
        """linkEMoRParams(SrcPanoImage self, SrcPanoImage target)"""
        return _hsi.SrcPanoImage_linkEMoRParams(self, target)


    def linkStack(self, target):
        """linkStack(SrcPanoImage self, SrcPanoImage target)"""
        return _hsi.SrcPanoImage_linkStack(self, target)


    def checkImageSizeKnown(self):
        """checkImageSizeKnown(SrcPanoImage self) -> bool"""
        return _hsi.SrcPanoImage_checkImageSizeKnown(self)


    def readEXIF(self):
        """readEXIF(SrcPanoImage self) -> bool"""
        return _hsi.SrcPanoImage_readEXIF(self)


    def applyEXIFValues(self, applyEVValue=True):
        """
        applyEXIFValues(SrcPanoImage self, bool applyEVValue=True) -> bool
        applyEXIFValues(SrcPanoImage self) -> bool
        """
        return _hsi.SrcPanoImage_applyEXIFValues(self, applyEVValue)


    def calcHFOV(proj, fl, crop, imageSize):
        """calcHFOV(HuginBase::SrcPanoImage::Projection proj, double fl, double crop, Size2D imageSize) -> double"""
        return _hsi.SrcPanoImage_calcHFOV(proj, fl, crop, imageSize)

    if _newclass:
        calcHFOV = staticmethod(calcHFOV)
    __swig_getmethods__["calcHFOV"] = lambda x: calcHFOV

    def calcFocalLength(proj, hfov, crop, imageSize):
        """calcFocalLength(HuginBase::SrcPanoImage::Projection proj, double hfov, double crop, Size2D imageSize) -> double"""
        return _hsi.SrcPanoImage_calcFocalLength(proj, hfov, crop, imageSize)

    if _newclass:
        calcFocalLength = staticmethod(calcFocalLength)
    __swig_getmethods__["calcFocalLength"] = lambda x: calcFocalLength

    def calcCropFactor(proj, hfov, focalLength, imageSize):
        """calcCropFactor(HuginBase::SrcPanoImage::Projection proj, double hfov, double focalLength, Size2D imageSize) -> double"""
        return _hsi.SrcPanoImage_calcCropFactor(proj, hfov, focalLength, imageSize)

    if _newclass:
        calcCropFactor = staticmethod(calcCropFactor)
    __swig_getmethods__["calcCropFactor"] = lambda x: calcCropFactor

    def calcExifExposureValue(self):
        """calcExifExposureValue(SrcPanoImage self) -> double"""
        return _hsi.SrcPanoImage_calcExifExposureValue(self)


    def updateFocalLength(self, newFocalLength):
        """updateFocalLength(SrcPanoImage self, double newFocalLength)"""
        return _hsi.SrcPanoImage_updateFocalLength(self, newFocalLength)


    def updateCropFactor(self, focalLength, newCropFactor):
        """updateCropFactor(SrcPanoImage self, double focalLength, double newCropFactor)"""
        return _hsi.SrcPanoImage_updateCropFactor(self, focalLength, newCropFactor)


    def readCropfactorFromDB(self):
        """readCropfactorFromDB(SrcPanoImage self) -> bool"""
        return _hsi.SrcPanoImage_readCropfactorFromDB(self)


    def readProjectionFromDB(self):
        """readProjectionFromDB(SrcPanoImage self) -> bool"""
        return _hsi.SrcPanoImage_readProjectionFromDB(self)


    def readDistortionFromDB(self):
        """readDistortionFromDB(SrcPanoImage self) -> bool"""
        return _hsi.SrcPanoImage_readDistortionFromDB(self)


    def readVignettingFromDB(self):
        """readVignettingFromDB(SrcPanoImage self) -> bool"""
        return _hsi.SrcPanoImage_readVignettingFromDB(self)


    def hasMasks(self):
        """hasMasks(SrcPanoImage self) -> bool"""
        return _hsi.SrcPanoImage_hasMasks(self)


    def hasPositiveMasks(self):
        """hasPositiveMasks(SrcPanoImage self) -> bool"""
        return _hsi.SrcPanoImage_hasPositiveMasks(self)


    def hasActiveMasks(self):
        """hasActiveMasks(SrcPanoImage self) -> bool"""
        return _hsi.SrcPanoImage_hasActiveMasks(self)


    def addMask(self, newMask):
        """addMask(SrcPanoImage self, MaskPolygon newMask)"""
        return _hsi.SrcPanoImage_addMask(self, newMask)


    def addActiveMask(self, newMask):
        """addActiveMask(SrcPanoImage self, MaskPolygon newMask)"""
        return _hsi.SrcPanoImage_addActiveMask(self, newMask)


    def clearActiveMasks(self):
        """clearActiveMasks(SrcPanoImage self)"""
        return _hsi.SrcPanoImage_clearActiveMasks(self)


    def changeMaskType(self, index, newType):
        """changeMaskType(SrcPanoImage self, unsigned int index, HuginBase::MaskPolygon::MaskType newType)"""
        return _hsi.SrcPanoImage_changeMaskType(self, index, newType)


    def deleteMask(self, index):
        """deleteMask(SrcPanoImage self, unsigned int index)"""
        return _hsi.SrcPanoImage_deleteMask(self, index)


    def deleteAllMasks(self):
        """deleteAllMasks(SrcPanoImage self)"""
        return _hsi.SrcPanoImage_deleteAllMasks(self)


    def printMaskLines(self, o, newImgNr):
        """printMaskLines(SrcPanoImage self, ostream o, unsigned int newImgNr)"""
        return _hsi.SrcPanoImage_printMaskLines(self, o, newImgNr)


    def isInsideMasks(self, p):
        """isInsideMasks(SrcPanoImage self, Point2D p) -> bool"""
        return _hsi.SrcPanoImage_isInsideMasks(self, p)

SrcPanoImage_swigregister = _hsi.SrcPanoImage_swigregister
SrcPanoImage_swigregister(SrcPanoImage)

def SrcPanoImage_calcHFOV(proj, fl, crop, imageSize):
    """SrcPanoImage_calcHFOV(HuginBase::SrcPanoImage::Projection proj, double fl, double crop, Size2D imageSize) -> double"""
    return _hsi.SrcPanoImage_calcHFOV(proj, fl, crop, imageSize)

def SrcPanoImage_calcFocalLength(proj, hfov, crop, imageSize):
    """SrcPanoImage_calcFocalLength(HuginBase::SrcPanoImage::Projection proj, double hfov, double crop, Size2D imageSize) -> double"""
    return _hsi.SrcPanoImage_calcFocalLength(proj, hfov, crop, imageSize)

def SrcPanoImage_calcCropFactor(proj, hfov, focalLength, imageSize):
    """SrcPanoImage_calcCropFactor(HuginBase::SrcPanoImage::Projection proj, double hfov, double focalLength, Size2D imageSize) -> double"""
    return _hsi.SrcPanoImage_calcCropFactor(proj, hfov, focalLength, imageSize)

class ControlPoint(_object):
    """Proxy of C++ HuginBase::ControlPoint class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ControlPoint, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ControlPoint, name)
    __repr__ = _swig_repr
    X_Y = _hsi.ControlPoint_X_Y
    X = _hsi.ControlPoint_X
    Y = _hsi.ControlPoint_Y

    def __init__(self, *args):
        """
        __init__(HuginBase::ControlPoint self) -> ControlPoint
        __init__(HuginBase::ControlPoint self, unsigned int img1, double sX, double sY, unsigned int img2, double dX, double dY, int mode=X_Y) -> ControlPoint
        __init__(HuginBase::ControlPoint self, unsigned int img1, double sX, double sY, unsigned int img2, double dX, double dY) -> ControlPoint
        """
        this = _hsi.new_ControlPoint(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __eq__(self, o):
        """__eq__(ControlPoint self, ControlPoint o) -> bool"""
        return _hsi.ControlPoint___eq__(self, o)


    def getModeName(self, mode):
        """getModeName(ControlPoint self, HuginBase::ControlPoint::OptimizeMode mode) -> std::string const &"""
        return _hsi.ControlPoint_getModeName(self, mode)


    def getCPString(self):
        """getCPString(ControlPoint self) -> std::string const"""
        return _hsi.ControlPoint_getCPString(self)


    def mirror(self):
        """mirror(ControlPoint self)"""
        return _hsi.ControlPoint_mirror(self)

    __swig_setmethods__["image1Nr"] = _hsi.ControlPoint_image1Nr_set
    __swig_getmethods__["image1Nr"] = _hsi.ControlPoint_image1Nr_get
    if _newclass:
        image1Nr = _swig_property(_hsi.ControlPoint_image1Nr_get, _hsi.ControlPoint_image1Nr_set)
    __swig_setmethods__["image2Nr"] = _hsi.ControlPoint_image2Nr_set
    __swig_getmethods__["image2Nr"] = _hsi.ControlPoint_image2Nr_get
    if _newclass:
        image2Nr = _swig_property(_hsi.ControlPoint_image2Nr_get, _hsi.ControlPoint_image2Nr_set)
    __swig_setmethods__["x1"] = _hsi.ControlPoint_x1_set
    __swig_getmethods__["x1"] = _hsi.ControlPoint_x1_get
    if _newclass:
        x1 = _swig_property(_hsi.ControlPoint_x1_get, _hsi.ControlPoint_x1_set)
    __swig_setmethods__["y1"] = _hsi.ControlPoint_y1_set
    __swig_getmethods__["y1"] = _hsi.ControlPoint_y1_get
    if _newclass:
        y1 = _swig_property(_hsi.ControlPoint_y1_get, _hsi.ControlPoint_y1_set)
    __swig_setmethods__["x2"] = _hsi.ControlPoint_x2_set
    __swig_getmethods__["x2"] = _hsi.ControlPoint_x2_get
    if _newclass:
        x2 = _swig_property(_hsi.ControlPoint_x2_get, _hsi.ControlPoint_x2_set)
    __swig_setmethods__["y2"] = _hsi.ControlPoint_y2_set
    __swig_getmethods__["y2"] = _hsi.ControlPoint_y2_get
    if _newclass:
        y2 = _swig_property(_hsi.ControlPoint_y2_get, _hsi.ControlPoint_y2_set)
    __swig_setmethods__["error"] = _hsi.ControlPoint_error_set
    __swig_getmethods__["error"] = _hsi.ControlPoint_error_get
    if _newclass:
        error = _swig_property(_hsi.ControlPoint_error_get, _hsi.ControlPoint_error_set)
    __swig_setmethods__["mode"] = _hsi.ControlPoint_mode_set
    __swig_getmethods__["mode"] = _hsi.ControlPoint_mode_get
    if _newclass:
        mode = _swig_property(_hsi.ControlPoint_mode_get, _hsi.ControlPoint_mode_set)
    __swig_destroy__ = _hsi.delete_ControlPoint
    __del__ = lambda self: None
ControlPoint_swigregister = _hsi.ControlPoint_swigregister
ControlPoint_swigregister(ControlPoint)

class Lens(_object):
    """Proxy of C++ HuginBase::Lens class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Lens, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Lens, name)
    __repr__ = _swig_repr

    def __init__(self):
        """__init__(HuginBase::Lens self) -> Lens"""
        this = _hsi.new_Lens()
        try:
            self.this.append(this)
        except:
            self.this = this

    def getProjection(self):
        """getProjection(Lens self) -> HuginBase::Lens::LensProjectionFormat"""
        return _hsi.Lens_getProjection(self)


    def setProjection(self, l):
        """setProjection(Lens self, HuginBase::Lens::LensProjectionFormat l)"""
        return _hsi.Lens_setProjection(self, l)


    def getHFOV(self):
        """getHFOV(Lens self) -> double"""
        return _hsi.Lens_getHFOV(self)


    def setHFOV(self, d):
        """setHFOV(Lens self, double d)"""
        return _hsi.Lens_setHFOV(self, d)


    def getFocalLength(self):
        """getFocalLength(Lens self) -> double"""
        return _hsi.Lens_getFocalLength(self)


    def getCropFactor(self):
        """getCropFactor(Lens self) -> double"""
        return _hsi.Lens_getCropFactor(self)


    def setCropFactor(self, newCropFactor):
        """setCropFactor(Lens self, double newCropFactor)"""
        return _hsi.Lens_setCropFactor(self, newCropFactor)


    def getAspectRatio(self):
        """getAspectRatio(Lens self) -> double"""
        return _hsi.Lens_getAspectRatio(self)


    def isLandscape(self):
        """isLandscape(Lens self) -> bool"""
        return _hsi.Lens_isLandscape(self)


    def setEV(self, ev):
        """setEV(Lens self, double ev)"""
        return _hsi.Lens_setEV(self, ev)


    def getImageSize(self):
        """getImageSize(Lens self) -> Size2D"""
        return _hsi.Lens_getImageSize(self)


    def setImageSize(self, sz):
        """setImageSize(Lens self, Size2D sz)"""
        return _hsi.Lens_setImageSize(self, sz)


    def update(self, l):
        """update(Lens self, Lens l)"""
        return _hsi.Lens_update(self, l)

    __swig_setmethods__["variables"] = _hsi.Lens_variables_set
    __swig_getmethods__["variables"] = _hsi.Lens_variables_get
    if _newclass:
        variables = _swig_property(_hsi.Lens_variables_get, _hsi.Lens_variables_set)
    __swig_setmethods__["m_hasExif"] = _hsi.Lens_m_hasExif_set
    __swig_getmethods__["m_hasExif"] = _hsi.Lens_m_hasExif_get
    if _newclass:
        m_hasExif = _swig_property(_hsi.Lens_m_hasExif_get, _hsi.Lens_m_hasExif_set)
    __swig_destroy__ = _hsi.delete_Lens
    __del__ = lambda self: None
Lens_swigregister = _hsi.Lens_swigregister
Lens_swigregister(Lens)

class MaskPolygon(_object):
    """Proxy of C++ HuginBase::MaskPolygon class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, MaskPolygon, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, MaskPolygon, name)
    __repr__ = _swig_repr
    Mask_negative = _hsi.MaskPolygon_Mask_negative
    Mask_positive = _hsi.MaskPolygon_Mask_positive
    Mask_Stack_negative = _hsi.MaskPolygon_Mask_Stack_negative
    Mask_Stack_positive = _hsi.MaskPolygon_Mask_Stack_positive
    Mask_negative_lens = _hsi.MaskPolygon_Mask_negative_lens

    def __init__(self):
        """__init__(HuginBase::MaskPolygon self) -> MaskPolygon"""
        this = _hsi.new_MaskPolygon()
        try:
            self.this.append(this)
        except:
            self.this = this

    def isInside(self, p):
        """isInside(MaskPolygon self, FDiff2D p) -> bool"""
        return _hsi.MaskPolygon_isInside(self, p)


    def getWindingNumber(self, p):
        """getWindingNumber(MaskPolygon self, FDiff2D p) -> int"""
        return _hsi.MaskPolygon_getWindingNumber(self, p)


    def getTotalWindingNumber(self):
        """getTotalWindingNumber(MaskPolygon self) -> int"""
        return _hsi.MaskPolygon_getTotalWindingNumber(self)


    def getMaskType(self):
        """getMaskType(MaskPolygon self) -> HuginBase::MaskPolygon::MaskType"""
        return _hsi.MaskPolygon_getMaskType(self)


    def setMaskType(self, newType):
        """setMaskType(MaskPolygon self, HuginBase::MaskPolygon::MaskType const newType)"""
        return _hsi.MaskPolygon_setMaskType(self, newType)


    def isPositive(self):
        """isPositive(MaskPolygon self) -> bool"""
        return _hsi.MaskPolygon_isPositive(self)


    def getMaskPolygon(self):
        """getMaskPolygon(MaskPolygon self) -> HuginBase::VectorPolygon"""
        return _hsi.MaskPolygon_getMaskPolygon(self)


    def setMaskPolygon(self, newMask):
        """setMaskPolygon(MaskPolygon self, HuginBase::VectorPolygon const & newMask)"""
        return _hsi.MaskPolygon_setMaskPolygon(self, newMask)


    def getImgNr(self):
        """getImgNr(MaskPolygon self) -> unsigned int"""
        return _hsi.MaskPolygon_getImgNr(self)


    def setImgNr(self, newImgNr):
        """setImgNr(MaskPolygon self, unsigned int const newImgNr)"""
        return _hsi.MaskPolygon_setImgNr(self, newImgNr)


    def setInverted(self, inverted):
        """setInverted(MaskPolygon self, bool const inverted)"""
        return _hsi.MaskPolygon_setInverted(self, inverted)


    def isInverted(self):
        """isInverted(MaskPolygon self) -> bool"""
        return _hsi.MaskPolygon_isInverted(self)


    def addPoint(self, p):
        """addPoint(MaskPolygon self, FDiff2D p)"""
        return _hsi.MaskPolygon_addPoint(self, p)


    def insertPoint(self, index, p):
        """insertPoint(MaskPolygon self, unsigned int const index, FDiff2D p)"""
        return _hsi.MaskPolygon_insertPoint(self, index, p)


    def removePoint(self, index):
        """removePoint(MaskPolygon self, unsigned int const index)"""
        return _hsi.MaskPolygon_removePoint(self, index)


    def movePointTo(self, index, p):
        """movePointTo(MaskPolygon self, unsigned int const index, FDiff2D p)"""
        return _hsi.MaskPolygon_movePointTo(self, index, p)


    def movePointBy(self, index, diff):
        """movePointBy(MaskPolygon self, unsigned int const index, FDiff2D diff)"""
        return _hsi.MaskPolygon_movePointBy(self, index, diff)


    def scale(self, *args):
        """
        scale(MaskPolygon self, double const factorx, double const factory)
        scale(MaskPolygon self, double const factor)
        """
        return _hsi.MaskPolygon_scale(self, *args)


    def transformPolygon(self, trans):
        """transformPolygon(MaskPolygon self, Transform trans)"""
        return _hsi.MaskPolygon_transformPolygon(self, trans)


    def clipPolygon(self, *args):
        """
        clipPolygon(MaskPolygon self, Rect2D rect) -> bool
        clipPolygon(MaskPolygon self, FDiff2D center, double const radius) -> bool
        """
        return _hsi.MaskPolygon_clipPolygon(self, *args)


    def rotate90(self, clockwise, maskWidth, maskHeight):
        """rotate90(MaskPolygon self, bool clockwise, unsigned int maskWidth, unsigned int maskHeight)"""
        return _hsi.MaskPolygon_rotate90(self, clockwise, maskWidth, maskHeight)


    def subSample(self, max_distance):
        """subSample(MaskPolygon self, double const max_distance)"""
        return _hsi.MaskPolygon_subSample(self, max_distance)


    def FindPointNearPos(self, p, tol):
        """FindPointNearPos(MaskPolygon self, FDiff2D p, double const tol) -> unsigned int"""
        return _hsi.MaskPolygon_FindPointNearPos(self, p, tol)


    def __eq__(self, otherPoly):
        """__eq__(MaskPolygon self, MaskPolygon otherPoly) -> bool const"""
        return _hsi.MaskPolygon___eq__(self, otherPoly)


    def parsePolygonString(self, polygonStr):
        """parsePolygonString(MaskPolygon self, std::string const & polygonStr) -> bool"""
        return _hsi.MaskPolygon_parsePolygonString(self, polygonStr)


    def printPolygonLine(self, o, newImgNr):
        """printPolygonLine(MaskPolygon self, ostream o, unsigned int const newImgNr)"""
        return _hsi.MaskPolygon_printPolygonLine(self, o, newImgNr)

    __swig_destroy__ = _hsi.delete_MaskPolygon
    __del__ = lambda self: None
MaskPolygon_swigregister = _hsi.MaskPolygon_swigregister
MaskPolygon_swigregister(MaskPolygon)
maskOffset = cvar.maskOffset


def LoadMaskFromStream(stream, imageSize, newMasks, imgNr):
    """LoadMaskFromStream(istream stream, Size2D imageSize, HuginBase::MaskPolygonVector & newMasks, size_t imgNr)"""
    return _hsi.LoadMaskFromStream(stream, imageSize, newMasks, imgNr)

def SaveMaskToStream(stream, imageSize, maskToWrite, imgNr):
    """SaveMaskToStream(ostream stream, Size2D imageSize, MaskPolygon maskToWrite, size_t imgNr)"""
    return _hsi.SaveMaskToStream(stream, imageSize, maskToWrite, imgNr)
class PanoramaMemento(PanoramaDataMemento):
    """Proxy of C++ HuginBase::PanoramaMemento class"""
    __swig_setmethods__ = {}
    for _s in [PanoramaDataMemento]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PanoramaMemento, name, value)
    __swig_getmethods__ = {}
    for _s in [PanoramaDataMemento]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, PanoramaMemento, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(HuginBase::PanoramaMemento self) -> PanoramaMemento
        __init__(HuginBase::PanoramaMemento self, PanoramaMemento o) -> PanoramaMemento
        """
        this = _hsi.new_PanoramaMemento(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _hsi.delete_PanoramaMemento
    __del__ = lambda self: None
PanoramaMemento_swigregister = _hsi.PanoramaMemento_swigregister
PanoramaMemento_swigregister(PanoramaMemento)

class Panorama(ManagedPanoramaData, DocumentData):
    """Proxy of C++ HuginBase::Panorama class"""
    __swig_setmethods__ = {}
    for _s in [ManagedPanoramaData, DocumentData]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Panorama, name, value)
    __swig_getmethods__ = {}
    for _s in [ManagedPanoramaData, DocumentData]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Panorama, name)
    __repr__ = _swig_repr

    def __init__(self):
        """__init__(HuginBase::Panorama self) -> Panorama"""
        this = _hsi.new_Panorama()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _hsi.delete_Panorama
    __del__ = lambda self: None

    def getSubset(self, imgs):
        """getSubset(Panorama self, HuginBase::UIntSet const & imgs) -> Panorama"""
        return _hsi.Panorama_getSubset(self, imgs)


    def duplicate(self):
        """duplicate(Panorama self) -> Panorama"""
        return _hsi.Panorama_duplicate(self)


    def getNewSubset(self, imgs):
        """getNewSubset(Panorama self, HuginBase::UIntSet const & imgs) -> PanoramaData"""
        return _hsi.Panorama_getNewSubset(self, imgs)


    def getNewCopy(self):
        """getNewCopy(Panorama self) -> PanoramaData"""
        return _hsi.Panorama_getNewCopy(self)


    def getNrOfImages(self):
        """getNrOfImages(Panorama self) -> std::size_t"""
        return _hsi.Panorama_getNrOfImages(self)


    def getImage(self, nr):
        """getImage(Panorama self, std::size_t nr) -> SrcPanoImage"""
        return _hsi.Panorama_getImage(self, nr)


    def setImage(self, nr, img):
        """setImage(Panorama self, std::size_t nr, SrcPanoImage img)"""
        return _hsi.Panorama_setImage(self, nr, img)


    def addImage(self, img):
        """addImage(Panorama self, SrcPanoImage img) -> unsigned int"""
        return _hsi.Panorama_addImage(self, img)


    def mergePanorama(self, newPano):
        """mergePanorama(Panorama self, Panorama newPano)"""
        return _hsi.Panorama_mergePanorama(self, newPano)


    def removeImage(self, nr):
        """removeImage(Panorama self, unsigned int nr)"""
        return _hsi.Panorama_removeImage(self, nr)


    def swapImages(self, img1, img2):
        """swapImages(Panorama self, unsigned int img1, unsigned int img2)"""
        return _hsi.Panorama_swapImages(self, img1, img2)


    def moveImage(self, img1, img2):
        """moveImage(Panorama self, size_t img1, size_t img2)"""
        return _hsi.Panorama_moveImage(self, img1, img2)


    def getSrcImage(self, imgNr):
        """getSrcImage(Panorama self, unsigned int imgNr) -> SrcPanoImage"""
        return _hsi.Panorama_getSrcImage(self, imgNr)


    def setSrcImage(self, nr, img):
        """setSrcImage(Panorama self, unsigned int nr, SrcPanoImage img)"""
        return _hsi.Panorama_setSrcImage(self, nr, img)


    def setImageFilename(self, img, fname):
        """setImageFilename(Panorama self, unsigned int img, std::string const & fname)"""
        return _hsi.Panorama_setImageFilename(self, img, fname)


    def activateImage(self, imgNr, active=True):
        """
        activateImage(Panorama self, unsigned int imgNr, bool active=True)
        activateImage(Panorama self, unsigned int imgNr)
        """
        return _hsi.Panorama_activateImage(self, imgNr, active)


    def getActiveImages(self):
        """getActiveImages(Panorama self) -> HuginBase::UIntSet"""
        return _hsi.Panorama_getActiveImages(self)


    def getNrOfCtrlPoints(self):
        """getNrOfCtrlPoints(Panorama self) -> std::size_t"""
        return _hsi.Panorama_getNrOfCtrlPoints(self)


    def getCtrlPoint(self, nr):
        """getCtrlPoint(Panorama self, std::size_t nr) -> ControlPoint"""
        return _hsi.Panorama_getCtrlPoint(self, nr)


    def getCtrlPoints(self):
        """getCtrlPoints(Panorama self) -> HuginBase::CPVector const &"""
        return _hsi.Panorama_getCtrlPoints(self)


    def getCtrlPointsForImage(self, imgNr):
        """getCtrlPointsForImage(Panorama self, unsigned int imgNr) -> std::vector< unsigned int,std::allocator< unsigned int > >"""
        return _hsi.Panorama_getCtrlPointsForImage(self, imgNr)


    def getCtrlPointsVectorForImage(self, imgNr):
        """getCtrlPointsVectorForImage(Panorama self, unsigned int imgNr) -> HuginBase::CPointVector"""
        return _hsi.Panorama_getCtrlPointsVectorForImage(self, imgNr)


    def setCtrlPoints(self, points):
        """setCtrlPoints(Panorama self, HuginBase::CPVector const & points)"""
        return _hsi.Panorama_setCtrlPoints(self, points)


    def addCtrlPoint(self, point):
        """addCtrlPoint(Panorama self, ControlPoint point) -> unsigned int"""
        return _hsi.Panorama_addCtrlPoint(self, point)


    def removeCtrlPoint(self, pNr):
        """removeCtrlPoint(Panorama self, unsigned int pNr)"""
        return _hsi.Panorama_removeCtrlPoint(self, pNr)


    def removeDuplicateCtrlPoints(self):
        """removeDuplicateCtrlPoints(Panorama self)"""
        return _hsi.Panorama_removeDuplicateCtrlPoints(self)


    def changeControlPoint(self, pNr, point):
        """changeControlPoint(Panorama self, unsigned int pNr, ControlPoint point)"""
        return _hsi.Panorama_changeControlPoint(self, pNr, point)


    def getNextCPTypeLineNumber(self):
        """getNextCPTypeLineNumber(Panorama self) -> int"""
        return _hsi.Panorama_getNextCPTypeLineNumber(self)


    def updateLineCtrlPoints(self):
        """updateLineCtrlPoints(Panorama self)"""
        return _hsi.Panorama_updateLineCtrlPoints(self)


    def updateCtrlPointErrors(self, *args):
        """
        updateCtrlPointErrors(Panorama self, HuginBase::CPVector const & controlPoints)
        updateCtrlPointErrors(Panorama self, HuginBase::UIntSet const & imgs, HuginBase::CPVector const & cps)
        """
        return _hsi.Panorama_updateCtrlPointErrors(self, *args)


    def getVariables(self):
        """getVariables(Panorama self) -> HuginBase::VariableMapVector"""
        return _hsi.Panorama_getVariables(self)


    def getImageVariables(self, imgNr):
        """getImageVariables(Panorama self, unsigned int imgNr) -> HuginBase::VariableMap const"""
        return _hsi.Panorama_getImageVariables(self, imgNr)


    def updateVariables(self, *args):
        """
        updateVariables(Panorama self, HuginBase::VariableMapVector const & vars)
        updateVariables(Panorama self, HuginBase::UIntSet const & imgs, HuginBase::VariableMapVector const & var)
        updateVariables(Panorama self, unsigned int imgNr, HuginBase::VariableMap const & var)
        """
        return _hsi.Panorama_updateVariables(self, *args)


    def updateVariable(self, imgNr, var):
        """updateVariable(Panorama self, unsigned int imgNr, Variable var)"""
        return _hsi.Panorama_updateVariable(self, imgNr, var)


    def UpdateFocalLength(self, imgs, newFocalLength):
        """UpdateFocalLength(Panorama self, HuginBase::UIntSet imgs, double newFocalLength)"""
        return _hsi.Panorama_UpdateFocalLength(self, imgs, newFocalLength)


    def UpdateCropFactor(self, imgs, newCropFactor):
        """UpdateCropFactor(Panorama self, HuginBase::UIntSet imgs, double newCropFactor)"""
        return _hsi.Panorama_UpdateCropFactor(self, imgs, newCropFactor)


    def linkImageVariableFilename(self, sourceImgNr, destImgNr):
        """linkImageVariableFilename(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableFilename(self, sourceImgNr, destImgNr)


    def linkImageVariableSize(self, sourceImgNr, destImgNr):
        """linkImageVariableSize(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableSize(self, sourceImgNr, destImgNr)


    def linkImageVariableProjection(self, sourceImgNr, destImgNr):
        """linkImageVariableProjection(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableProjection(self, sourceImgNr, destImgNr)


    def linkImageVariableHFOV(self, sourceImgNr, destImgNr):
        """linkImageVariableHFOV(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableHFOV(self, sourceImgNr, destImgNr)


    def linkImageVariableCropFactor(self, sourceImgNr, destImgNr):
        """linkImageVariableCropFactor(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableCropFactor(self, sourceImgNr, destImgNr)


    def linkImageVariableResponseType(self, sourceImgNr, destImgNr):
        """linkImageVariableResponseType(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableResponseType(self, sourceImgNr, destImgNr)


    def linkImageVariableEMoRParams(self, sourceImgNr, destImgNr):
        """linkImageVariableEMoRParams(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableEMoRParams(self, sourceImgNr, destImgNr)


    def linkImageVariableExposureValue(self, sourceImgNr, destImgNr):
        """linkImageVariableExposureValue(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableExposureValue(self, sourceImgNr, destImgNr)


    def linkImageVariableGamma(self, sourceImgNr, destImgNr):
        """linkImageVariableGamma(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableGamma(self, sourceImgNr, destImgNr)


    def linkImageVariableWhiteBalanceRed(self, sourceImgNr, destImgNr):
        """linkImageVariableWhiteBalanceRed(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableWhiteBalanceRed(self, sourceImgNr, destImgNr)


    def linkImageVariableWhiteBalanceBlue(self, sourceImgNr, destImgNr):
        """linkImageVariableWhiteBalanceBlue(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableWhiteBalanceBlue(self, sourceImgNr, destImgNr)


    def linkImageVariableRoll(self, sourceImgNr, destImgNr):
        """linkImageVariableRoll(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableRoll(self, sourceImgNr, destImgNr)


    def linkImageVariablePitch(self, sourceImgNr, destImgNr):
        """linkImageVariablePitch(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariablePitch(self, sourceImgNr, destImgNr)


    def linkImageVariableYaw(self, sourceImgNr, destImgNr):
        """linkImageVariableYaw(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableYaw(self, sourceImgNr, destImgNr)


    def linkImageVariableX(self, sourceImgNr, destImgNr):
        """linkImageVariableX(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableX(self, sourceImgNr, destImgNr)


    def linkImageVariableY(self, sourceImgNr, destImgNr):
        """linkImageVariableY(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableY(self, sourceImgNr, destImgNr)


    def linkImageVariableZ(self, sourceImgNr, destImgNr):
        """linkImageVariableZ(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableZ(self, sourceImgNr, destImgNr)


    def linkImageVariableTranslationPlaneYaw(self, sourceImgNr, destImgNr):
        """linkImageVariableTranslationPlaneYaw(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableTranslationPlaneYaw(self, sourceImgNr, destImgNr)


    def linkImageVariableTranslationPlanePitch(self, sourceImgNr, destImgNr):
        """linkImageVariableTranslationPlanePitch(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableTranslationPlanePitch(self, sourceImgNr, destImgNr)


    def linkImageVariableStack(self, sourceImgNr, destImgNr):
        """linkImageVariableStack(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableStack(self, sourceImgNr, destImgNr)


    def linkImageVariableRadialDistortion(self, sourceImgNr, destImgNr):
        """linkImageVariableRadialDistortion(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableRadialDistortion(self, sourceImgNr, destImgNr)


    def linkImageVariableRadialDistortionRed(self, sourceImgNr, destImgNr):
        """linkImageVariableRadialDistortionRed(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableRadialDistortionRed(self, sourceImgNr, destImgNr)


    def linkImageVariableRadialDistortionBlue(self, sourceImgNr, destImgNr):
        """linkImageVariableRadialDistortionBlue(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableRadialDistortionBlue(self, sourceImgNr, destImgNr)


    def linkImageVariableRadialDistortionCenterShift(self, sourceImgNr, destImgNr):
        """linkImageVariableRadialDistortionCenterShift(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableRadialDistortionCenterShift(self, sourceImgNr, destImgNr)


    def linkImageVariableShear(self, sourceImgNr, destImgNr):
        """linkImageVariableShear(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableShear(self, sourceImgNr, destImgNr)


    def linkImageVariableCropMode(self, sourceImgNr, destImgNr):
        """linkImageVariableCropMode(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableCropMode(self, sourceImgNr, destImgNr)


    def linkImageVariableCropRect(self, sourceImgNr, destImgNr):
        """linkImageVariableCropRect(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableCropRect(self, sourceImgNr, destImgNr)


    def linkImageVariableAutoCenterCrop(self, sourceImgNr, destImgNr):
        """linkImageVariableAutoCenterCrop(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableAutoCenterCrop(self, sourceImgNr, destImgNr)


    def linkImageVariableVigCorrMode(self, sourceImgNr, destImgNr):
        """linkImageVariableVigCorrMode(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableVigCorrMode(self, sourceImgNr, destImgNr)


    def linkImageVariableFlatfieldFilename(self, sourceImgNr, destImgNr):
        """linkImageVariableFlatfieldFilename(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableFlatfieldFilename(self, sourceImgNr, destImgNr)


    def linkImageVariableRadialVigCorrCoeff(self, sourceImgNr, destImgNr):
        """linkImageVariableRadialVigCorrCoeff(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableRadialVigCorrCoeff(self, sourceImgNr, destImgNr)


    def linkImageVariableRadialVigCorrCenterShift(self, sourceImgNr, destImgNr):
        """linkImageVariableRadialVigCorrCenterShift(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableRadialVigCorrCenterShift(self, sourceImgNr, destImgNr)


    def linkImageVariableExifModel(self, sourceImgNr, destImgNr):
        """linkImageVariableExifModel(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableExifModel(self, sourceImgNr, destImgNr)


    def linkImageVariableExifMake(self, sourceImgNr, destImgNr):
        """linkImageVariableExifMake(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableExifMake(self, sourceImgNr, destImgNr)


    def linkImageVariableExifLens(self, sourceImgNr, destImgNr):
        """linkImageVariableExifLens(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableExifLens(self, sourceImgNr, destImgNr)


    def linkImageVariableExifFocalLength(self, sourceImgNr, destImgNr):
        """linkImageVariableExifFocalLength(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableExifFocalLength(self, sourceImgNr, destImgNr)


    def linkImageVariableExifOrientation(self, sourceImgNr, destImgNr):
        """linkImageVariableExifOrientation(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableExifOrientation(self, sourceImgNr, destImgNr)


    def linkImageVariableExifAperture(self, sourceImgNr, destImgNr):
        """linkImageVariableExifAperture(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableExifAperture(self, sourceImgNr, destImgNr)


    def linkImageVariableExifISO(self, sourceImgNr, destImgNr):
        """linkImageVariableExifISO(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableExifISO(self, sourceImgNr, destImgNr)


    def linkImageVariableExifDistance(self, sourceImgNr, destImgNr):
        """linkImageVariableExifDistance(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableExifDistance(self, sourceImgNr, destImgNr)


    def linkImageVariableExifFocalLength35(self, sourceImgNr, destImgNr):
        """linkImageVariableExifFocalLength35(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableExifFocalLength35(self, sourceImgNr, destImgNr)


    def linkImageVariableExifCropFactor(self, sourceImgNr, destImgNr):
        """linkImageVariableExifCropFactor(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableExifCropFactor(self, sourceImgNr, destImgNr)


    def linkImageVariableExifExposureTime(self, sourceImgNr, destImgNr):
        """linkImageVariableExifExposureTime(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableExifExposureTime(self, sourceImgNr, destImgNr)


    def linkImageVariableExifDate(self, sourceImgNr, destImgNr):
        """linkImageVariableExifDate(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableExifDate(self, sourceImgNr, destImgNr)


    def linkImageVariableExifExposureMode(self, sourceImgNr, destImgNr):
        """linkImageVariableExifExposureMode(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableExifExposureMode(self, sourceImgNr, destImgNr)


    def linkImageVariableExifRedBalance(self, sourceImgNr, destImgNr):
        """linkImageVariableExifRedBalance(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableExifRedBalance(self, sourceImgNr, destImgNr)


    def linkImageVariableExifBlueBalance(self, sourceImgNr, destImgNr):
        """linkImageVariableExifBlueBalance(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableExifBlueBalance(self, sourceImgNr, destImgNr)


    def linkImageVariableMasks(self, sourceImgNr, destImgNr):
        """linkImageVariableMasks(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableMasks(self, sourceImgNr, destImgNr)


    def linkImageVariableActiveMasks(self, sourceImgNr, destImgNr):
        """linkImageVariableActiveMasks(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableActiveMasks(self, sourceImgNr, destImgNr)


    def linkImageVariableActive(self, sourceImgNr, destImgNr):
        """linkImageVariableActive(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableActive(self, sourceImgNr, destImgNr)


    def unlinkImageVariableFilename(self, imgNr):
        """unlinkImageVariableFilename(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableFilename(self, imgNr)


    def unlinkImageVariableSize(self, imgNr):
        """unlinkImageVariableSize(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableSize(self, imgNr)


    def unlinkImageVariableProjection(self, imgNr):
        """unlinkImageVariableProjection(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableProjection(self, imgNr)


    def unlinkImageVariableHFOV(self, imgNr):
        """unlinkImageVariableHFOV(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableHFOV(self, imgNr)


    def unlinkImageVariableCropFactor(self, imgNr):
        """unlinkImageVariableCropFactor(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableCropFactor(self, imgNr)


    def unlinkImageVariableResponseType(self, imgNr):
        """unlinkImageVariableResponseType(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableResponseType(self, imgNr)


    def unlinkImageVariableEMoRParams(self, imgNr):
        """unlinkImageVariableEMoRParams(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableEMoRParams(self, imgNr)


    def unlinkImageVariableExposureValue(self, imgNr):
        """unlinkImageVariableExposureValue(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableExposureValue(self, imgNr)


    def unlinkImageVariableGamma(self, imgNr):
        """unlinkImageVariableGamma(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableGamma(self, imgNr)


    def unlinkImageVariableWhiteBalanceRed(self, imgNr):
        """unlinkImageVariableWhiteBalanceRed(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableWhiteBalanceRed(self, imgNr)


    def unlinkImageVariableWhiteBalanceBlue(self, imgNr):
        """unlinkImageVariableWhiteBalanceBlue(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableWhiteBalanceBlue(self, imgNr)


    def unlinkImageVariableRoll(self, imgNr):
        """unlinkImageVariableRoll(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableRoll(self, imgNr)


    def unlinkImageVariablePitch(self, imgNr):
        """unlinkImageVariablePitch(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariablePitch(self, imgNr)


    def unlinkImageVariableYaw(self, imgNr):
        """unlinkImageVariableYaw(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableYaw(self, imgNr)


    def unlinkImageVariableX(self, imgNr):
        """unlinkImageVariableX(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableX(self, imgNr)


    def unlinkImageVariableY(self, imgNr):
        """unlinkImageVariableY(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableY(self, imgNr)


    def unlinkImageVariableZ(self, imgNr):
        """unlinkImageVariableZ(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableZ(self, imgNr)


    def unlinkImageVariableTranslationPlaneYaw(self, imgNr):
        """unlinkImageVariableTranslationPlaneYaw(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableTranslationPlaneYaw(self, imgNr)


    def unlinkImageVariableTranslationPlanePitch(self, imgNr):
        """unlinkImageVariableTranslationPlanePitch(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableTranslationPlanePitch(self, imgNr)


    def unlinkImageVariableStack(self, imgNr):
        """unlinkImageVariableStack(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableStack(self, imgNr)


    def unlinkImageVariableRadialDistortion(self, imgNr):
        """unlinkImageVariableRadialDistortion(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableRadialDistortion(self, imgNr)


    def unlinkImageVariableRadialDistortionRed(self, imgNr):
        """unlinkImageVariableRadialDistortionRed(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableRadialDistortionRed(self, imgNr)


    def unlinkImageVariableRadialDistortionBlue(self, imgNr):
        """unlinkImageVariableRadialDistortionBlue(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableRadialDistortionBlue(self, imgNr)


    def unlinkImageVariableRadialDistortionCenterShift(self, imgNr):
        """unlinkImageVariableRadialDistortionCenterShift(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableRadialDistortionCenterShift(self, imgNr)


    def unlinkImageVariableShear(self, imgNr):
        """unlinkImageVariableShear(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableShear(self, imgNr)


    def unlinkImageVariableCropMode(self, imgNr):
        """unlinkImageVariableCropMode(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableCropMode(self, imgNr)


    def unlinkImageVariableCropRect(self, imgNr):
        """unlinkImageVariableCropRect(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableCropRect(self, imgNr)


    def unlinkImageVariableAutoCenterCrop(self, imgNr):
        """unlinkImageVariableAutoCenterCrop(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableAutoCenterCrop(self, imgNr)


    def unlinkImageVariableVigCorrMode(self, imgNr):
        """unlinkImageVariableVigCorrMode(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableVigCorrMode(self, imgNr)


    def unlinkImageVariableFlatfieldFilename(self, imgNr):
        """unlinkImageVariableFlatfieldFilename(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableFlatfieldFilename(self, imgNr)


    def unlinkImageVariableRadialVigCorrCoeff(self, imgNr):
        """unlinkImageVariableRadialVigCorrCoeff(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableRadialVigCorrCoeff(self, imgNr)


    def unlinkImageVariableRadialVigCorrCenterShift(self, imgNr):
        """unlinkImageVariableRadialVigCorrCenterShift(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableRadialVigCorrCenterShift(self, imgNr)


    def unlinkImageVariableExifModel(self, imgNr):
        """unlinkImageVariableExifModel(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableExifModel(self, imgNr)


    def unlinkImageVariableExifMake(self, imgNr):
        """unlinkImageVariableExifMake(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableExifMake(self, imgNr)


    def unlinkImageVariableExifLens(self, imgNr):
        """unlinkImageVariableExifLens(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableExifLens(self, imgNr)


    def unlinkImageVariableExifFocalLength(self, imgNr):
        """unlinkImageVariableExifFocalLength(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableExifFocalLength(self, imgNr)


    def unlinkImageVariableExifOrientation(self, imgNr):
        """unlinkImageVariableExifOrientation(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableExifOrientation(self, imgNr)


    def unlinkImageVariableExifAperture(self, imgNr):
        """unlinkImageVariableExifAperture(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableExifAperture(self, imgNr)


    def unlinkImageVariableExifISO(self, imgNr):
        """unlinkImageVariableExifISO(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableExifISO(self, imgNr)


    def unlinkImageVariableExifDistance(self, imgNr):
        """unlinkImageVariableExifDistance(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableExifDistance(self, imgNr)


    def unlinkImageVariableExifFocalLength35(self, imgNr):
        """unlinkImageVariableExifFocalLength35(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableExifFocalLength35(self, imgNr)


    def unlinkImageVariableExifCropFactor(self, imgNr):
        """unlinkImageVariableExifCropFactor(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableExifCropFactor(self, imgNr)


    def unlinkImageVariableExifExposureTime(self, imgNr):
        """unlinkImageVariableExifExposureTime(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableExifExposureTime(self, imgNr)


    def unlinkImageVariableExifDate(self, imgNr):
        """unlinkImageVariableExifDate(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableExifDate(self, imgNr)


    def unlinkImageVariableExifExposureMode(self, imgNr):
        """unlinkImageVariableExifExposureMode(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableExifExposureMode(self, imgNr)


    def unlinkImageVariableExifRedBalance(self, imgNr):
        """unlinkImageVariableExifRedBalance(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableExifRedBalance(self, imgNr)


    def unlinkImageVariableExifBlueBalance(self, imgNr):
        """unlinkImageVariableExifBlueBalance(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableExifBlueBalance(self, imgNr)


    def unlinkImageVariableMasks(self, imgNr):
        """unlinkImageVariableMasks(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableMasks(self, imgNr)


    def unlinkImageVariableActiveMasks(self, imgNr):
        """unlinkImageVariableActiveMasks(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableActiveMasks(self, imgNr)


    def unlinkImageVariableActive(self, imgNr):
        """unlinkImageVariableActive(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableActive(self, imgNr)


    def updateWhiteBalance(self, redFactor, blueFactor):
        """updateWhiteBalance(Panorama self, double redFactor, double blueFactor)"""
        return _hsi.Panorama_updateWhiteBalance(self, redFactor, blueFactor)


    def getOptimizeVector(self):
        """getOptimizeVector(Panorama self) -> OptimizeVector"""
        return _hsi.Panorama_getOptimizeVector(self)


    def setOptimizeVector(self, optvec):
        """setOptimizeVector(Panorama self, OptimizeVector optvec)"""
        return _hsi.Panorama_setOptimizeVector(self, optvec)


    def getOptimizerSwitch(self):
        """getOptimizerSwitch(Panorama self) -> int const"""
        return _hsi.Panorama_getOptimizerSwitch(self)


    def setOptimizerSwitch(self, newSwitch):
        """setOptimizerSwitch(Panorama self, int const newSwitch)"""
        return _hsi.Panorama_setOptimizerSwitch(self, newSwitch)


    def getPhotometricOptimizerSwitch(self):
        """getPhotometricOptimizerSwitch(Panorama self) -> int const"""
        return _hsi.Panorama_getPhotometricOptimizerSwitch(self)


    def setPhotometricOptimizerSwitch(self, newSwitch):
        """setPhotometricOptimizerSwitch(Panorama self, int const newSwitch)"""
        return _hsi.Panorama_setPhotometricOptimizerSwitch(self, newSwitch)


    def getOptions(self):
        """getOptions(Panorama self) -> PanoramaOptions"""
        return _hsi.Panorama_getOptions(self)


    def setOptions(self, opt):
        """setOptions(Panorama self, PanoramaOptions opt)"""
        return _hsi.Panorama_setOptions(self, opt)


    def parseOptimizerScript(self, i, imgs, imgVars, ctrlPoints):
        """parseOptimizerScript(Panorama self, istream i, HuginBase::UIntSet const & imgs, HuginBase::VariableMapVector & imgVars, HuginBase::CPVector & ctrlPoints)"""
        return _hsi.Panorama_parseOptimizerScript(self, i, imgs, imgVars, ctrlPoints)


    def printPanoramaScript(self, o, optvars, options, imgs, forPTOptimizer, stripPrefix=""):
        """
        printPanoramaScript(Panorama self, ostream o, OptimizeVector optvars, PanoramaOptions options, HuginBase::UIntSet const & imgs, bool forPTOptimizer, std::string const & stripPrefix="")
        printPanoramaScript(Panorama self, ostream o, OptimizeVector optvars, PanoramaOptions options, HuginBase::UIntSet const & imgs, bool forPTOptimizer)
        """
        return _hsi.Panorama_printPanoramaScript(self, o, optvars, options, imgs, forPTOptimizer, stripPrefix)


    def printStitcherScript(self, o, target, imgs):
        """printStitcherScript(Panorama self, ostream o, PanoramaOptions target, HuginBase::UIntSet const & imgs)"""
        return _hsi.Panorama_printStitcherScript(self, o, target, imgs)


    def addObserver(self, o):
        """addObserver(Panorama self, PanoramaObserver o)"""
        return _hsi.Panorama_addObserver(self, o)


    def removeObserver(self, observer):
        """removeObserver(Panorama self, PanoramaObserver observer) -> bool"""
        return _hsi.Panorama_removeObserver(self, observer)


    def clearObservers(self):
        """clearObservers(Panorama self)"""
        return _hsi.Panorama_clearObservers(self)


    def hasPendingChanges(self):
        """hasPendingChanges(Panorama self) -> bool const"""
        return _hsi.Panorama_hasPendingChanges(self)


    def changeFinished(self, *args):
        """
        changeFinished(Panorama self, bool keepDirty)
        changeFinished(Panorama self)
        """
        return _hsi.Panorama_changeFinished(self, *args)


    def imageChanged(self, imgNr):
        """imageChanged(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_imageChanged(self, imgNr)


    def updateMasksForImage(self, imgNr, newMasks):
        """updateMasksForImage(Panorama self, unsigned int imgNr, HuginBase::MaskPolygonVector newMasks)"""
        return _hsi.Panorama_updateMasksForImage(self, imgNr, newMasks)


    def updateMasks(self, convertPosMaskToNeg=False):
        """
        updateMasks(Panorama self, bool convertPosMaskToNeg=False)
        updateMasks(Panorama self)
        """
        return _hsi.Panorama_updateMasks(self, convertPosMaskToNeg)


    def transferMask(self, mask, imgNr, targetImgs):
        """transferMask(Panorama self, MaskPolygon mask, unsigned int imgNr, HuginBase::UIntSet const targetImgs)"""
        return _hsi.Panorama_transferMask(self, mask, imgNr, targetImgs)


    def updateOptimizeVector(self):
        """updateOptimizeVector(Panorama self)"""
        return _hsi.Panorama_updateOptimizeVector(self)


    def getRefImages(self):
        """getRefImages(Panorama self) -> std::set< size_t,std::less< size_t >,std::allocator< size_t > >"""
        return _hsi.Panorama_getRefImages(self)


    def checkRefOptStatus(self, linkRefImgsYaw, linkRefImgsPitch, linkRefImgsRoll):
        """checkRefOptStatus(Panorama self, bool & linkRefImgsYaw, bool & linkRefImgsPitch, bool & linkRefImgsRoll)"""
        return _hsi.Panorama_checkRefOptStatus(self, linkRefImgsYaw, linkRefImgsPitch, linkRefImgsRoll)


    def getNewMemento(self):
        """getNewMemento(Panorama self) -> PanoramaDataMemento"""
        return _hsi.Panorama_getNewMemento(self)


    def setMementoToCopyOf(self, memento):
        """setMementoToCopyOf(Panorama self, PanoramaDataMemento memento) -> bool"""
        return _hsi.Panorama_setMementoToCopyOf(self, memento)


    def getMemento(self):
        """getMemento(Panorama self) -> PanoramaMemento"""
        return _hsi.Panorama_getMemento(self)


    def setMemento(self, memento):
        """setMemento(Panorama self, PanoramaMemento memento)"""
        return _hsi.Panorama_setMemento(self, memento)


    def needsOptimization(self):
        """needsOptimization(Panorama self) -> bool"""
        return _hsi.Panorama_needsOptimization(self)


    def markAsOptimized(self, optimized=True):
        """
        markAsOptimized(Panorama self, bool optimized=True)
        markAsOptimized(Panorama self)
        """
        return _hsi.Panorama_markAsOptimized(self, optimized)


    def readData(self, dataInput, documentType=""):
        """
        readData(Panorama self, istream dataInput, std::string documentType="") -> AppBase::DocumentData::ReadWriteError
        readData(Panorama self, istream dataInput) -> AppBase::DocumentData::ReadWriteError
        """
        return _hsi.Panorama_readData(self, dataInput, documentType)


    def writeData(self, dataOutput, documentType=""):
        """
        writeData(Panorama self, ostream dataOutput, std::string documentType="") -> AppBase::DocumentData::ReadWriteError
        writeData(Panorama self, ostream dataOutput) -> AppBase::DocumentData::ReadWriteError
        """
        return _hsi.Panorama_writeData(self, dataOutput, documentType)


    def isDirty(self):
        """isDirty(Panorama self) -> bool"""
        return _hsi.Panorama_isDirty(self)


    def clearDirty(self):
        """clearDirty(Panorama self)"""
        return _hsi.Panorama_clearDirty(self)


    def setFilePrefix(self, prefix):
        """setFilePrefix(Panorama self, std::string prefix)"""
        return _hsi.Panorama_setFilePrefix(self, prefix)


    def reset(self):
        """reset(Panorama self)"""
        return _hsi.Panorama_reset(self)

Panorama_swigregister = _hsi.Panorama_swigregister
Panorama_swigregister(Panorama)

class Transform(_object):
    """Proxy of C++ HuginBase::PTools::Transform class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Transform, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Transform, name)
    __repr__ = _swig_repr

    def __init__(self):
        """__init__(HuginBase::PTools::Transform self) -> Transform"""
        this = _hsi.new_Transform()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _hsi.delete_Transform
    __del__ = lambda self: None

    def createTransform(self, *args):
        """
        createTransform(Transform self, vigra::Diff2D const & srcSize, HuginBase::VariableMap srcVars, HuginBase::Lens::LensProjectionFormat srcProj, vigra::Diff2D const & destSize, HuginBase::PanoramaOptions::ProjectionFormat destProj, std::vector< double,std::allocator< double > > const & destProjParam, double destHFOV, vigra::Diff2D const & origSrcSize)
        createTransform(Transform self, PanoramaData pano, unsigned int imgNr, PanoramaOptions dest, vigra::Diff2D srcSize)
        createTransform(Transform self, PanoramaData pano, unsigned int imgNr, PanoramaOptions dest)
        createTransform(Transform self, SrcPanoImage src, PanoramaOptions dest)
        """
        return _hsi.Transform_createTransform(self, *args)


    def createInvTransform(self, *args):
        """
        createInvTransform(Transform self, vigra::Diff2D const & srcSize, HuginBase::VariableMap srcVars, HuginBase::Lens::LensProjectionFormat srcProj, vigra::Diff2D const & destSize, HuginBase::PanoramaOptions::ProjectionFormat destProj, std::vector< double,std::allocator< double > > const & destProjParam, double destHFOV, vigra::Diff2D const & origSrcSize)
        createInvTransform(Transform self, PanoramaData pano, unsigned int imgNr, PanoramaOptions dest, vigra::Diff2D srcSize)
        createInvTransform(Transform self, PanoramaData pano, unsigned int imgNr, PanoramaOptions dest)
        createInvTransform(Transform self, SrcPanoImage src, PanoramaOptions dest)
        """
        return _hsi.Transform_createInvTransform(self, *args)


    def transform(self, *args):
        """
        transform(Transform self, double & x_dest, double & y_dest, double x_src, double y_src) -> bool
        transform(Transform self, FDiff2D dest, FDiff2D src) -> bool
        """
        return _hsi.Transform_transform(self, *args)


    def transformImgCoordPartial(self, x_dest, y_dest, x_src, y_src):
        """transformImgCoordPartial(Transform self, double & x_dest, double & y_dest, double x_src, double y_src) -> bool"""
        return _hsi.Transform_transformImgCoordPartial(self, x_dest, y_dest, x_src, y_src)


    def transformImgCoord(self, *args):
        """
        transformImgCoord(Transform self, double & x_dest, double & y_dest, double x_src, double y_src) -> bool
        transformImgCoord(Transform self, FDiff2D dest, FDiff2D src) -> bool
        """
        return _hsi.Transform_transformImgCoord(self, *args)


    def emitGLSL(self, oss):
        """emitGLSL(Transform self, std::ostringstream & oss) -> bool"""
        return _hsi.Transform_emitGLSL(self, oss)

Transform_swigregister = _hsi.Transform_swigregister
Transform_swigregister(Transform)


def setDestImage(image, size, imageData, format, projParams, destHFOV):
    """setDestImage(Image & image, vigra::Diff2D size, unsigned char * imageData, HuginBase::PanoramaOptions::ProjectionFormat const & format, std::vector< double,std::allocator< double > > const & projParams, double destHFOV)"""
    return _hsi.setDestImage(image, size, imageData, format, projParams, destHFOV)

def setFullImage(image, size, imageData, vars, format, correctDistortions):
    """setFullImage(Image & image, vigra::Diff2D size, unsigned char * imageData, HuginBase::VariableMap const & vars, HuginBase::Lens::LensProjectionFormat const format, bool correctDistortions)"""
    return _hsi.setFullImage(image, size, imageData, vars, format, correctDistortions)

def freeImage(img):
    """freeImage(Image & img)"""
    return _hsi.freeImage(img)

def GetAlignInfoVariables(gl):
    """GetAlignInfoVariables(AlignInfo const & gl) -> HuginBase::VariableMapVector"""
    return _hsi.GetAlignInfoVariables(gl)

def GetAlignInfoCtrlPoints(gl):
    """GetAlignInfoCtrlPoints(AlignInfo const & gl) -> HuginBase::CPVector"""
    return _hsi.GetAlignInfoCtrlPoints(gl)

def optimize(pano, script=None):
    """
    optimize(PanoramaData pano, char const * script=None) -> unsigned int
    optimize(PanoramaData pano) -> unsigned int
    """
    return _hsi.optimize(pano, script)

def calcCtrlPointErrors(pano):
    """calcCtrlPointErrors(PanoramaData pano)"""
    return _hsi.calcCtrlPointErrors(pano)
class PanoramaAlgorithm(_object):
    """Proxy of C++ HuginBase::PanoramaAlgorithm class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, PanoramaAlgorithm, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, PanoramaAlgorithm, name)

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

    def modifiesPanoramaData(self):
        """modifiesPanoramaData(PanoramaAlgorithm self) -> bool"""
        return _hsi.PanoramaAlgorithm_modifiesPanoramaData(self)


    def hasRunSuccessfully(self):
        """hasRunSuccessfully(PanoramaAlgorithm self) -> bool"""
        return _hsi.PanoramaAlgorithm_hasRunSuccessfully(self)


    def run(self):
        """run(PanoramaAlgorithm self)"""
        return _hsi.PanoramaAlgorithm_run(self)


    def runAlgorithm(self):
        """runAlgorithm(PanoramaAlgorithm self) -> bool"""
        return _hsi.PanoramaAlgorithm_runAlgorithm(self)

PanoramaAlgorithm_swigregister = _hsi.PanoramaAlgorithm_swigregister
PanoramaAlgorithm_swigregister(PanoramaAlgorithm)

class TimeConsumingPanoramaAlgorithm(PanoramaAlgorithm):
    """Proxy of C++ HuginBase::TimeConsumingPanoramaAlgorithm class"""
    __swig_setmethods__ = {}
    for _s in [PanoramaAlgorithm]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TimeConsumingPanoramaAlgorithm, name, value)
    __swig_getmethods__ = {}
    for _s in [PanoramaAlgorithm]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, TimeConsumingPanoramaAlgorithm, name)

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

    def wasCancelled(self):
        """wasCancelled(TimeConsumingPanoramaAlgorithm self) -> bool"""
        return _hsi.TimeConsumingPanoramaAlgorithm_wasCancelled(self)

TimeConsumingPanoramaAlgorithm_swigregister = _hsi.TimeConsumingPanoramaAlgorithm_swigregister
TimeConsumingPanoramaAlgorithm_swigregister(TimeConsumingPanoramaAlgorithm)

class StitcherAlgorithm(TimeConsumingPanoramaAlgorithm):
    """Proxy of C++ HuginBase::StitcherAlgorithm class"""
    __swig_setmethods__ = {}
    for _s in [TimeConsumingPanoramaAlgorithm]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, StitcherAlgorithm, name, value)
    __swig_getmethods__ = {}
    for _s in [TimeConsumingPanoramaAlgorithm]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, StitcherAlgorithm, name)

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

    def runAlgorithm(self):
        """runAlgorithm(StitcherAlgorithm self) -> bool"""
        return _hsi.StitcherAlgorithm_runAlgorithm(self)


    def modifiesPanoramaData(self):
        """modifiesPanoramaData(StitcherAlgorithm self) -> bool"""
        return _hsi.StitcherAlgorithm_modifiesPanoramaData(self)

StitcherAlgorithm_swigregister = _hsi.StitcherAlgorithm_swigregister
StitcherAlgorithm_swigregister(StitcherAlgorithm)

class ImageStitcherAlgorithm(StitcherAlgorithm):
    """Proxy of C++ HuginBase::ImageStitcherAlgorithm class"""
    __swig_setmethods__ = {}
    for _s in [StitcherAlgorithm]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ImageStitcherAlgorithm, name, value)
    __swig_getmethods__ = {}
    for _s in [StitcherAlgorithm]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ImageStitcherAlgorithm, name)

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

class FileOutputStitcherAlgorithm(StitcherAlgorithm):
    """Proxy of C++ HuginBase::FileOutputStitcherAlgorithm class"""
    __swig_setmethods__ = {}
    for _s in [StitcherAlgorithm]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, FileOutputStitcherAlgorithm, name, value)
    __swig_getmethods__ = {}
    for _s in [StitcherAlgorithm]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, FileOutputStitcherAlgorithm, name)

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

class AssistantMakefilelibExport(PanoramaAlgorithm):
    """Proxy of C++ HuginBase::AssistantMakefilelibExport class"""
    __swig_setmethods__ = {}
    for _s in [PanoramaAlgorithm]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, AssistantMakefilelibExport, name, value)
    __swig_getmethods__ = {}
    for _s in [PanoramaAlgorithm]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, AssistantMakefilelibExport, name)
    __repr__ = _swig_repr

    def __init__(self, pano_, progs_, runLinefind_, runCeleste_, celesteThreshold_, celesteSmallRadius_, runCPClean_, scale_, makefile_, projectFile_):
        """__init__(HuginBase::AssistantMakefilelibExport self, PanoramaData pano_, HuginBase::AssistantMakefilelibExport::AssistantPrograms const & progs_, bool const & runLinefind_, bool const & runCeleste_, double const & celesteThreshold_, bool const & celesteSmallRadius_, bool const & runCPClean_, double const & scale_, ostream makefile_, std::string const & projectFile_) -> AssistantMakefilelibExport"""
        this = _hsi.new_AssistantMakefilelibExport(pano_, progs_, runLinefind_, runCeleste_, celesteThreshold_, celesteSmallRadius_, runCPClean_, scale_, makefile_, projectFile_)
        try:
            self.this.append(this)
        except:
            self.this = this

    def createMakefile(pano_, progs_, runLinefind_, runCeleste_, celesteThreshold_, celesteSmallRadius_, runCPClean_, scale_, makefile_, projectFile_):
        """createMakefile(PanoramaData pano_, HuginBase::AssistantMakefilelibExport::AssistantPrograms const & progs_, bool const & runLinefind_, bool const & runCeleste_, double const & celesteThreshold_, bool const & celesteSmallRadius_, bool const & runCPClean_, double const & scale_, ostream makefile_, std::string const & projectFile_)"""
        return _hsi.AssistantMakefilelibExport_createMakefile(pano_, progs_, runLinefind_, runCeleste_, celesteThreshold_, celesteSmallRadius_, runCPClean_, scale_, makefile_, projectFile_)

    if _newclass:
        createMakefile = staticmethod(createMakefile)
    __swig_getmethods__["createMakefile"] = lambda x: createMakefile

    def modifiesPanoramaData(self):
        """modifiesPanoramaData(AssistantMakefilelibExport self) -> bool"""
        return _hsi.AssistantMakefilelibExport_modifiesPanoramaData(self)


    def runAlgorithm(self):
        """runAlgorithm(AssistantMakefilelibExport self) -> bool"""
        return _hsi.AssistantMakefilelibExport_runAlgorithm(self)

    __swig_destroy__ = _hsi.delete_AssistantMakefilelibExport
    __del__ = lambda self: None
AssistantMakefilelibExport_swigregister = _hsi.AssistantMakefilelibExport_swigregister
AssistantMakefilelibExport_swigregister(AssistantMakefilelibExport)

def AssistantMakefilelibExport_createMakefile(pano_, progs_, runLinefind_, runCeleste_, celesteThreshold_, celesteSmallRadius_, runCPClean_, scale_, makefile_, projectFile_):
    """AssistantMakefilelibExport_createMakefile(PanoramaData pano_, HuginBase::AssistantMakefilelibExport::AssistantPrograms const & progs_, bool const & runLinefind_, bool const & runCeleste_, double const & celesteThreshold_, bool const & celesteSmallRadius_, bool const & runCPClean_, double const & scale_, ostream makefile_, std::string const & projectFile_)"""
    return _hsi.AssistantMakefilelibExport_createMakefile(pano_, progs_, runLinefind_, runCeleste_, celesteThreshold_, celesteSmallRadius_, runCPClean_, scale_, makefile_, projectFile_)

class CalculateCPStatistics(PanoramaAlgorithm):
    """Proxy of C++ HuginBase::CalculateCPStatistics class"""
    __swig_setmethods__ = {}
    for _s in [PanoramaAlgorithm]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CalculateCPStatistics, name, value)
    __swig_getmethods__ = {}
    for _s in [PanoramaAlgorithm]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CalculateCPStatistics, name)

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

    def modifiesPanoramaData(self):
        """modifiesPanoramaData(CalculateCPStatistics self) -> bool"""
        return _hsi.CalculateCPStatistics_modifiesPanoramaData(self)


    def runAlgorithm(self):
        """runAlgorithm(CalculateCPStatistics self) -> bool"""
        return _hsi.CalculateCPStatistics_runAlgorithm(self)


    def getResultMin(self):
        """getResultMin(CalculateCPStatistics self) -> double"""
        return _hsi.CalculateCPStatistics_getResultMin(self)


    def getResultMax(self):
        """getResultMax(CalculateCPStatistics self) -> double"""
        return _hsi.CalculateCPStatistics_getResultMax(self)


    def getResultMean(self):
        """getResultMean(CalculateCPStatistics self) -> double"""
        return _hsi.CalculateCPStatistics_getResultMean(self)


    def getResultVariance(self):
        """getResultVariance(CalculateCPStatistics self) -> double"""
        return _hsi.CalculateCPStatistics_getResultVariance(self)

CalculateCPStatistics_swigregister = _hsi.CalculateCPStatistics_swigregister
CalculateCPStatistics_swigregister(CalculateCPStatistics)

class CalculateCPStatisticsError(CalculateCPStatistics):
    """Proxy of C++ HuginBase::CalculateCPStatisticsError class"""
    __swig_setmethods__ = {}
    for _s in [CalculateCPStatistics]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CalculateCPStatisticsError, name, value)
    __swig_getmethods__ = {}
    for _s in [CalculateCPStatistics]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CalculateCPStatisticsError, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(HuginBase::CalculateCPStatisticsError self, PanoramaData panorama, int const & imgNr) -> CalculateCPStatisticsError
        __init__(HuginBase::CalculateCPStatisticsError self, PanoramaData panorama) -> CalculateCPStatisticsError
        """
        this = _hsi.new_CalculateCPStatisticsError(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _hsi.delete_CalculateCPStatisticsError
    __del__ = lambda self: None

    def calcCtrlPntsErrorStats(pano, min, max, mean, var, imgNr):
        """
        calcCtrlPntsErrorStats(PanoramaData pano, double & min, double & max, double & mean, double & var, int const & imgNr)
        calcCtrlPntsErrorStats(PanoramaData pano, double & min, double & max, double & mean, double & var)
        """
        return _hsi.CalculateCPStatisticsError_calcCtrlPntsErrorStats(pano, min, max, mean, var, imgNr)

    if _newclass:
        calcCtrlPntsErrorStats = staticmethod(calcCtrlPntsErrorStats)
    __swig_getmethods__["calcCtrlPntsErrorStats"] = lambda x: calcCtrlPntsErrorStats

    def runAlgorithm(self):
        """runAlgorithm(CalculateCPStatisticsError self) -> bool"""
        return _hsi.CalculateCPStatisticsError_runAlgorithm(self)

CalculateCPStatisticsError_swigregister = _hsi.CalculateCPStatisticsError_swigregister
CalculateCPStatisticsError_swigregister(CalculateCPStatisticsError)

def CalculateCPStatisticsError_calcCtrlPntsErrorStats(pano, min, max, mean, var, imgNr):
    """
    calcCtrlPntsErrorStats(PanoramaData pano, double & min, double & max, double & mean, double & var, int const & imgNr)
    CalculateCPStatisticsError_calcCtrlPntsErrorStats(PanoramaData pano, double & min, double & max, double & mean, double & var)
    """
    return _hsi.CalculateCPStatisticsError_calcCtrlPntsErrorStats(pano, min, max, mean, var, imgNr)

class CalculateCPStatisticsRadial(CalculateCPStatistics):
    """Proxy of C++ HuginBase::CalculateCPStatisticsRadial class"""
    __swig_setmethods__ = {}
    for _s in [CalculateCPStatistics]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CalculateCPStatisticsRadial, name, value)
    __swig_getmethods__ = {}
    for _s in [CalculateCPStatistics]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CalculateCPStatisticsRadial, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(HuginBase::CalculateCPStatisticsRadial self, PanoramaData panorama, int const & imgNr) -> CalculateCPStatisticsRadial
        __init__(HuginBase::CalculateCPStatisticsRadial self, PanoramaData panorama) -> CalculateCPStatisticsRadial
        """
        this = _hsi.new_CalculateCPStatisticsRadial(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _hsi.delete_CalculateCPStatisticsRadial
    __del__ = lambda self: None

    def calcCtrlPntsRadiStats(pano, min, max, mean, var, q10, q90, imgNr):
        """
        calcCtrlPntsRadiStats(PanoramaData pano, double & min, double & max, double & mean, double & var, double & q10, double & q90, int const & imgNr)
        calcCtrlPntsRadiStats(PanoramaData pano, double & min, double & max, double & mean, double & var, double & q10, double & q90)
        """
        return _hsi.CalculateCPStatisticsRadial_calcCtrlPntsRadiStats(pano, min, max, mean, var, q10, q90, imgNr)

    if _newclass:
        calcCtrlPntsRadiStats = staticmethod(calcCtrlPntsRadiStats)
    __swig_getmethods__["calcCtrlPntsRadiStats"] = lambda x: calcCtrlPntsRadiStats

    def getResultPercentile10(self):
        """getResultPercentile10(CalculateCPStatisticsRadial self) -> double"""
        return _hsi.CalculateCPStatisticsRadial_getResultPercentile10(self)


    def getResultPercentile90(self):
        """getResultPercentile90(CalculateCPStatisticsRadial self) -> double"""
        return _hsi.CalculateCPStatisticsRadial_getResultPercentile90(self)


    def runAlgorithm(self):
        """runAlgorithm(CalculateCPStatisticsRadial self) -> bool"""
        return _hsi.CalculateCPStatisticsRadial_runAlgorithm(self)

CalculateCPStatisticsRadial_swigregister = _hsi.CalculateCPStatisticsRadial_swigregister
CalculateCPStatisticsRadial_swigregister(CalculateCPStatisticsRadial)

def CalculateCPStatisticsRadial_calcCtrlPntsRadiStats(pano, min, max, mean, var, q10, q90, imgNr):
    """
    calcCtrlPntsRadiStats(PanoramaData pano, double & min, double & max, double & mean, double & var, double & q10, double & q90, int const & imgNr)
    CalculateCPStatisticsRadial_calcCtrlPntsRadiStats(PanoramaData pano, double & min, double & max, double & mean, double & var, double & q10, double & q90)
    """
    return _hsi.CalculateCPStatisticsRadial_calcCtrlPntsRadiStats(pano, min, max, mean, var, q10, q90, imgNr)

class CalculateMeanExposure(PanoramaAlgorithm):
    """Proxy of C++ HuginBase::CalculateMeanExposure class"""
    __swig_setmethods__ = {}
    for _s in [PanoramaAlgorithm]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CalculateMeanExposure, name, value)
    __swig_getmethods__ = {}
    for _s in [PanoramaAlgorithm]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CalculateMeanExposure, name)
    __repr__ = _swig_repr

    def __init__(self, panorama):
        """__init__(HuginBase::CalculateMeanExposure self, PanoramaData panorama) -> CalculateMeanExposure"""
        this = _hsi.new_CalculateMeanExposure(panorama)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _hsi.delete_CalculateMeanExposure
    __del__ = lambda self: None

    def modifiesPanoramaData(self):
        """modifiesPanoramaData(CalculateMeanExposure self) -> bool"""
        return _hsi.CalculateMeanExposure_modifiesPanoramaData(self)


    def runAlgorithm(self):
        """runAlgorithm(CalculateMeanExposure self) -> bool"""
        return _hsi.CalculateMeanExposure_runAlgorithm(self)


    def calcMeanExposure(pano):
        """calcMeanExposure(PanoramaData pano) -> double"""
        return _hsi.CalculateMeanExposure_calcMeanExposure(pano)

    if _newclass:
        calcMeanExposure = staticmethod(calcMeanExposure)
    __swig_getmethods__["calcMeanExposure"] = lambda x: calcMeanExposure

    def getResultExposure(self):
        """getResultExposure(CalculateMeanExposure self) -> double"""
        return _hsi.CalculateMeanExposure_getResultExposure(self)

CalculateMeanExposure_swigregister = _hsi.CalculateMeanExposure_swigregister
CalculateMeanExposure_swigregister(CalculateMeanExposure)

def CalculateMeanExposure_calcMeanExposure(pano):
    """CalculateMeanExposure_calcMeanExposure(PanoramaData pano) -> double"""
    return _hsi.CalculateMeanExposure_calcMeanExposure(pano)

class CalculateOptimalROI(PanoramaAlgorithm):
    """Proxy of C++ HuginBase::CalculateOptimalROI class"""
    __swig_setmethods__ = {}
    for _s in [PanoramaAlgorithm]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CalculateOptimalROI, name, value)
    __swig_getmethods__ = {}
    for _s in [PanoramaAlgorithm]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CalculateOptimalROI, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(HuginBase::CalculateOptimalROI self, PanoramaData panorama, bool intersect=False) -> CalculateOptimalROI
        __init__(HuginBase::CalculateOptimalROI self, PanoramaData panorama) -> CalculateOptimalROI
        __init__(HuginBase::CalculateOptimalROI self, PanoramaData panorama, std::vector< HuginBase::UIntSet,std::allocator< HuginBase::UIntSet > > hdr_stacks) -> CalculateOptimalROI
        """
        this = _hsi.new_CalculateOptimalROI(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _hsi.delete_CalculateOptimalROI
    __del__ = lambda self: None

    def modifiesPanoramaData(self):
        """modifiesPanoramaData(CalculateOptimalROI self) -> bool"""
        return _hsi.CalculateOptimalROI_modifiesPanoramaData(self)


    def runAlgorithm(self):
        """runAlgorithm(CalculateOptimalROI self) -> bool"""
        return _hsi.CalculateOptimalROI_runAlgorithm(self)


    def calcOptimalROI(self, panorama):
        """calcOptimalROI(CalculateOptimalROI self, PanoramaData panorama) -> bool"""
        return _hsi.CalculateOptimalROI_calcOptimalROI(self, panorama)


    def getResultOptimalROI(self):
        """getResultOptimalROI(CalculateOptimalROI self) -> Rect2D"""
        return _hsi.CalculateOptimalROI_getResultOptimalROI(self)


    def getResultOptimalSize(self):
        """getResultOptimalSize(CalculateOptimalROI self) -> Size2D"""
        return _hsi.CalculateOptimalROI_getResultOptimalSize(self)


    def setStacks(self, hdr_stacks):
        """setStacks(CalculateOptimalROI self, std::vector< HuginBase::UIntSet,std::allocator< HuginBase::UIntSet > > hdr_stacks)"""
        return _hsi.CalculateOptimalROI_setStacks(self, hdr_stacks)

CalculateOptimalROI_swigregister = _hsi.CalculateOptimalROI_swigregister
CalculateOptimalROI_swigregister(CalculateOptimalROI)

class CalculateOptimalScale(PanoramaAlgorithm):
    """Proxy of C++ HuginBase::CalculateOptimalScale class"""
    __swig_setmethods__ = {}
    for _s in [PanoramaAlgorithm]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CalculateOptimalScale, name, value)
    __swig_getmethods__ = {}
    for _s in [PanoramaAlgorithm]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CalculateOptimalScale, name)
    __repr__ = _swig_repr

    def __init__(self, panorama):
        """__init__(HuginBase::CalculateOptimalScale self, PanoramaData panorama) -> CalculateOptimalScale"""
        this = _hsi.new_CalculateOptimalScale(panorama)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _hsi.delete_CalculateOptimalScale
    __del__ = lambda self: None

    def modifiesPanoramaData(self):
        """modifiesPanoramaData(CalculateOptimalScale self) -> bool"""
        return _hsi.CalculateOptimalScale_modifiesPanoramaData(self)


    def runAlgorithm(self):
        """runAlgorithm(CalculateOptimalScale self) -> bool"""
        return _hsi.CalculateOptimalScale_runAlgorithm(self)


    def calcOptimalScale(panorama):
        """calcOptimalScale(PanoramaData panorama) -> double"""
        return _hsi.CalculateOptimalScale_calcOptimalScale(panorama)

    if _newclass:
        calcOptimalScale = staticmethod(calcOptimalScale)
    __swig_getmethods__["calcOptimalScale"] = lambda x: calcOptimalScale

    def calcOptimalPanoScale(src, dest):
        """calcOptimalPanoScale(SrcPanoImage src, PanoramaOptions dest) -> double"""
        return _hsi.CalculateOptimalScale_calcOptimalPanoScale(src, dest)

    if _newclass:
        calcOptimalPanoScale = staticmethod(calcOptimalPanoScale)
    __swig_getmethods__["calcOptimalPanoScale"] = lambda x: calcOptimalPanoScale

    def getResultOptimalScale(self):
        """getResultOptimalScale(CalculateOptimalScale self) -> double"""
        return _hsi.CalculateOptimalScale_getResultOptimalScale(self)


    def getResultOptimalWidth(self):
        """getResultOptimalWidth(CalculateOptimalScale self) -> unsigned int"""
        return _hsi.CalculateOptimalScale_getResultOptimalWidth(self)

CalculateOptimalScale_swigregister = _hsi.CalculateOptimalScale_swigregister
CalculateOptimalScale_swigregister(CalculateOptimalScale)

def CalculateOptimalScale_calcOptimalScale(panorama):
    """CalculateOptimalScale_calcOptimalScale(PanoramaData panorama) -> double"""
    return _hsi.CalculateOptimalScale_calcOptimalScale(panorama)

def CalculateOptimalScale_calcOptimalPanoScale(src, dest):
    """CalculateOptimalScale_calcOptimalPanoScale(SrcPanoImage src, PanoramaOptions dest) -> double"""
    return _hsi.CalculateOptimalScale_calcOptimalPanoScale(src, dest)

class SetWidthOptimal(CalculateOptimalScale):
    """Proxy of C++ HuginBase::SetWidthOptimal class"""
    __swig_setmethods__ = {}
    for _s in [CalculateOptimalScale]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SetWidthOptimal, name, value)
    __swig_getmethods__ = {}
    for _s in [CalculateOptimalScale]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, SetWidthOptimal, name)
    __repr__ = _swig_repr

    def __init__(self, panorama):
        """__init__(HuginBase::SetWidthOptimal self, PanoramaData panorama) -> SetWidthOptimal"""
        this = _hsi.new_SetWidthOptimal(panorama)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _hsi.delete_SetWidthOptimal
    __del__ = lambda self: None

    def modifiesPanoramaData(self):
        """modifiesPanoramaData(SetWidthOptimal self) -> bool"""
        return _hsi.SetWidthOptimal_modifiesPanoramaData(self)


    def runAlgorithm(self):
        """runAlgorithm(SetWidthOptimal self) -> bool"""
        return _hsi.SetWidthOptimal_runAlgorithm(self)

SetWidthOptimal_swigregister = _hsi.SetWidthOptimal_swigregister
SetWidthOptimal_swigregister(SetWidthOptimal)

class CalculateImageOverlap(_object):
    """Proxy of C++ HuginBase::CalculateImageOverlap class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CalculateImageOverlap, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CalculateImageOverlap, name)
    __repr__ = _swig_repr

    def __init__(self, pano):
        """__init__(HuginBase::CalculateImageOverlap self, PanoramaData pano) -> CalculateImageOverlap"""
        this = _hsi.new_CalculateImageOverlap(pano)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _hsi.delete_CalculateImageOverlap
    __del__ = lambda self: None

    def calculate(self, steps):
        """calculate(CalculateImageOverlap self, unsigned int steps)"""
        return _hsi.CalculateImageOverlap_calculate(self, steps)


    def getOverlap(self, i, j):
        """getOverlap(CalculateImageOverlap self, unsigned int i, unsigned int j) -> double"""
        return _hsi.CalculateImageOverlap_getOverlap(self, i, j)


    def limitToImages(self, img):
        """limitToImages(CalculateImageOverlap self, HuginBase::UIntSet img)"""
        return _hsi.CalculateImageOverlap_limitToImages(self, img)


    def getOverlapForImage(self, i):
        """getOverlapForImage(CalculateImageOverlap self, unsigned int i) -> HuginBase::UIntSet"""
        return _hsi.CalculateImageOverlap_getOverlapForImage(self, i)

CalculateImageOverlap_swigregister = _hsi.CalculateImageOverlap_swigregister
CalculateImageOverlap_swigregister(CalculateImageOverlap)

class RotatePanorama(PanoramaAlgorithm):
    """Proxy of C++ HuginBase::RotatePanorama class"""
    __swig_setmethods__ = {}
    for _s in [PanoramaAlgorithm]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, RotatePanorama, name, value)
    __swig_getmethods__ = {}
    for _s in [PanoramaAlgorithm]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, RotatePanorama, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(HuginBase::RotatePanorama self, PanoramaData panorama, Matrix3 const & transformMat) -> RotatePanorama
        __init__(HuginBase::RotatePanorama self, PanoramaData panorama, double yaw, double pitch, double roll) -> RotatePanorama
        """
        this = _hsi.new_RotatePanorama(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _hsi.delete_RotatePanorama
    __del__ = lambda self: None

    def rotatePano(panorama, transformMat):
        """rotatePano(PanoramaData panorama, Matrix3 const & transformMat)"""
        return _hsi.RotatePanorama_rotatePano(panorama, transformMat)

    if _newclass:
        rotatePano = staticmethod(rotatePano)
    __swig_getmethods__["rotatePano"] = lambda x: rotatePano

    def modifiesPanoramaData(self):
        """modifiesPanoramaData(RotatePanorama self) -> bool"""
        return _hsi.RotatePanorama_modifiesPanoramaData(self)


    def runAlgorithm(self):
        """runAlgorithm(RotatePanorama self) -> bool"""
        return _hsi.RotatePanorama_runAlgorithm(self)

RotatePanorama_swigregister = _hsi.RotatePanorama_swigregister
RotatePanorama_swigregister(RotatePanorama)

def RotatePanorama_rotatePano(panorama, transformMat):
    """RotatePanorama_rotatePano(PanoramaData panorama, Matrix3 const & transformMat)"""
    return _hsi.RotatePanorama_rotatePano(panorama, transformMat)


def getHDRStacks(pano, allImgs, opts):
    """getHDRStacks(PanoramaData pano, HuginBase::UIntSet allImgs, PanoramaOptions opts) -> std::vector< HuginBase::UIntSet,std::allocator< HuginBase::UIntSet > >"""
    return _hsi.getHDRStacks(pano, allImgs, opts)

def getExposureLayers(pano, allImgs, opts):
    """getExposureLayers(PanoramaData pano, HuginBase::UIntSet allImgs, PanoramaOptions opts) -> std::vector< HuginBase::UIntSet,std::allocator< HuginBase::UIntSet > >"""
    return _hsi.getExposureLayers(pano, allImgs, opts)

def getImagesinROI(pano, activeImages):
    """getImagesinROI(PanoramaData pano, HuginBase::UIntSet const activeImages) -> HuginBase::UIntSet"""
    return _hsi.getImagesinROI(pano, activeImages)
class StraightenPanorama(RotatePanorama):
    """Proxy of C++ HuginBase::StraightenPanorama class"""
    __swig_setmethods__ = {}
    for _s in [RotatePanorama]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, StraightenPanorama, name, value)
    __swig_getmethods__ = {}
    for _s in [RotatePanorama]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, StraightenPanorama, name)
    __repr__ = _swig_repr

    def __init__(self, panorama):
        """__init__(HuginBase::StraightenPanorama self, PanoramaData panorama) -> StraightenPanorama"""
        this = _hsi.new_StraightenPanorama(panorama)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _hsi.delete_StraightenPanorama
    __del__ = lambda self: None

    def calcStraighteningRotation(panorama):
        """calcStraighteningRotation(PanoramaData panorama) -> Matrix3"""
        return _hsi.StraightenPanorama_calcStraighteningRotation(panorama)

    if _newclass:
        calcStraighteningRotation = staticmethod(calcStraighteningRotation)
    __swig_getmethods__["calcStraighteningRotation"] = lambda x: calcStraighteningRotation

    def runAlgorithm(self):
        """runAlgorithm(StraightenPanorama self) -> bool"""
        return _hsi.StraightenPanorama_runAlgorithm(self)

StraightenPanorama_swigregister = _hsi.StraightenPanorama_swigregister
StraightenPanorama_swigregister(StraightenPanorama)

def StraightenPanorama_calcStraighteningRotation(panorama):
    """StraightenPanorama_calcStraighteningRotation(PanoramaData panorama) -> Matrix3"""
    return _hsi.StraightenPanorama_calcStraighteningRotation(panorama)

class TranslatePanorama(PanoramaAlgorithm):
    """Proxy of C++ HuginBase::TranslatePanorama class"""
    __swig_setmethods__ = {}
    for _s in [PanoramaAlgorithm]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TranslatePanorama, name, value)
    __swig_getmethods__ = {}
    for _s in [PanoramaAlgorithm]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, TranslatePanorama, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(HuginBase::TranslatePanorama self, PanoramaData panorama, double const x, double const y, double const z) -> TranslatePanorama
        __init__(HuginBase::TranslatePanorama self, PanoramaData panorama) -> TranslatePanorama
        """
        this = _hsi.new_TranslatePanorama(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _hsi.delete_TranslatePanorama
    __del__ = lambda self: None

    def translatePano(panorama, x, y, z):
        """translatePano(PanoramaData panorama, double const x, double const y, double const z)"""
        return _hsi.TranslatePanorama_translatePano(panorama, x, y, z)

    if _newclass:
        translatePano = staticmethod(translatePano)
    __swig_getmethods__["translatePano"] = lambda x: translatePano

    def modifiesPanoramaData(self):
        """modifiesPanoramaData(TranslatePanorama self) -> bool"""
        return _hsi.TranslatePanorama_modifiesPanoramaData(self)


    def runAlgorithm(self):
        """runAlgorithm(TranslatePanorama self) -> bool"""
        return _hsi.TranslatePanorama_runAlgorithm(self)

TranslatePanorama_swigregister = _hsi.TranslatePanorama_swigregister
TranslatePanorama_swigregister(TranslatePanorama)

def TranslatePanorama_translatePano(panorama, x, y, z):
    """TranslatePanorama_translatePano(PanoramaData panorama, double const x, double const y, double const z)"""
    return _hsi.TranslatePanorama_translatePano(panorama, x, y, z)


def getCPoutsideLimit_pair(pano, n=2.0):
    """
    getCPoutsideLimit_pair(Panorama pano, double n=2.0) -> HuginBase::UIntSet
    getCPoutsideLimit_pair(Panorama pano) -> HuginBase::UIntSet
    """
    return _hsi.getCPoutsideLimit_pair(pano, n)

def getCPoutsideLimit(pano, n=2.0, skipOptimisation=False, includeLineCp=False):
    """
    getCPoutsideLimit(Panorama pano, double n=2.0, bool skipOptimisation=False, bool includeLineCp=False) -> HuginBase::UIntSet
    getCPoutsideLimit(Panorama pano, double n=2.0, bool skipOptimisation=False) -> HuginBase::UIntSet
    getCPoutsideLimit(Panorama pano, double n=2.0) -> HuginBase::UIntSet
    getCPoutsideLimit(Panorama pano) -> HuginBase::UIntSet
    """
    return _hsi.getCPoutsideLimit(pano, n, skipOptimisation, includeLineCp)

def getCPinMasks(pano):
    """getCPinMasks(Panorama pano) -> HuginBase::UIntSet"""
    return _hsi.getCPinMasks(pano)
class CalculateFOV(PanoramaAlgorithm):
    """Proxy of C++ HuginBase::CalculateFOV class"""
    __swig_setmethods__ = {}
    for _s in [PanoramaAlgorithm]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CalculateFOV, name, value)
    __swig_getmethods__ = {}
    for _s in [PanoramaAlgorithm]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CalculateFOV, name)
    __repr__ = _swig_repr

    def __init__(self, panorama):
        """__init__(HuginBase::CalculateFOV self, PanoramaData panorama) -> CalculateFOV"""
        this = _hsi.new_CalculateFOV(panorama)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _hsi.delete_CalculateFOV
    __del__ = lambda self: None

    def modifiesPanoramaData(self):
        """modifiesPanoramaData(CalculateFOV self) -> bool"""
        return _hsi.CalculateFOV_modifiesPanoramaData(self)


    def runAlgorithm(self):
        """runAlgorithm(CalculateFOV self) -> bool"""
        return _hsi.CalculateFOV_runAlgorithm(self)


    def calcFOV(panorama):
        """calcFOV(PanoramaData panorama) -> FDiff2D"""
        return _hsi.CalculateFOV_calcFOV(panorama)

    if _newclass:
        calcFOV = staticmethod(calcFOV)
    __swig_getmethods__["calcFOV"] = lambda x: calcFOV

    def getResultHorizontalFOV(self):
        """getResultHorizontalFOV(CalculateFOV self) -> double"""
        return _hsi.CalculateFOV_getResultHorizontalFOV(self)


    def getResultVerticalFOV(self):
        """getResultVerticalFOV(CalculateFOV self) -> double"""
        return _hsi.CalculateFOV_getResultVerticalFOV(self)


    def getResultFOV(self):
        """getResultFOV(CalculateFOV self) -> FDiff2D"""
        return _hsi.CalculateFOV_getResultFOV(self)

CalculateFOV_swigregister = _hsi.CalculateFOV_swigregister
CalculateFOV_swigregister(CalculateFOV)

def CalculateFOV_calcFOV(panorama):
    """CalculateFOV_calcFOV(PanoramaData panorama) -> FDiff2D"""
    return _hsi.CalculateFOV_calcFOV(panorama)

class CenterHorizontally(PanoramaAlgorithm):
    """Proxy of C++ HuginBase::CenterHorizontally class"""
    __swig_setmethods__ = {}
    for _s in [PanoramaAlgorithm]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CenterHorizontally, name, value)
    __swig_getmethods__ = {}
    for _s in [PanoramaAlgorithm]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CenterHorizontally, name)
    __repr__ = _swig_repr

    def __init__(self, panorama):
        """__init__(HuginBase::CenterHorizontally self, PanoramaData panorama) -> CenterHorizontally"""
        this = _hsi.new_CenterHorizontally(panorama)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _hsi.delete_CenterHorizontally
    __del__ = lambda self: None

    def modifiesPanoramaData(self):
        """modifiesPanoramaData(CenterHorizontally self) -> bool"""
        return _hsi.CenterHorizontally_modifiesPanoramaData(self)


    def runAlgorithm(self):
        """runAlgorithm(CenterHorizontally self) -> bool"""
        return _hsi.CenterHorizontally_runAlgorithm(self)


    def centerHorizontically(panorama):
        """centerHorizontically(PanoramaData panorama)"""
        return _hsi.CenterHorizontally_centerHorizontically(panorama)

    if _newclass:
        centerHorizontically = staticmethod(centerHorizontically)
    __swig_getmethods__["centerHorizontically"] = lambda x: centerHorizontically
CenterHorizontally_swigregister = _hsi.CenterHorizontally_swigregister
CenterHorizontally_swigregister(CenterHorizontally)

def CenterHorizontally_centerHorizontically(panorama):
    """CenterHorizontally_centerHorizontically(PanoramaData panorama)"""
    return _hsi.CenterHorizontally_centerHorizontically(panorama)


def estimateOutputROI(pano, opts, i):
    """estimateOutputROI(PanoramaData pano, PanoramaOptions opts, unsigned int i) -> Rect2D"""
    return _hsi.estimateOutputROI(pano, opts, i)
class ComputeImageROI(PanoramaAlgorithm):
    """Proxy of C++ HuginBase::ComputeImageROI class"""
    __swig_setmethods__ = {}
    for _s in [PanoramaAlgorithm]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ComputeImageROI, name, value)
    __swig_getmethods__ = {}
    for _s in [PanoramaAlgorithm]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ComputeImageROI, name)
    __repr__ = _swig_repr

    def __init__(self, panorama, images):
        """__init__(HuginBase::ComputeImageROI self, PanoramaData panorama, HuginBase::UIntSet const & images) -> ComputeImageROI"""
        this = _hsi.new_ComputeImageROI(panorama, images)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _hsi.delete_ComputeImageROI
    __del__ = lambda self: None

    def modifiesPanoramaData(self):
        """modifiesPanoramaData(ComputeImageROI self) -> bool"""
        return _hsi.ComputeImageROI_modifiesPanoramaData(self)


    def runAlgorithm(self):
        """runAlgorithm(ComputeImageROI self) -> bool"""
        return _hsi.ComputeImageROI_runAlgorithm(self)


    def getROIS(self):
        """getROIS(ComputeImageROI self) -> std::vector< vigra::Rect2D,std::allocator< vigra::Rect2D > >"""
        return _hsi.ComputeImageROI_getROIS(self)


    def computeROIS(panorama, opts, images):
        """computeROIS(PanoramaData panorama, PanoramaOptions opts, HuginBase::UIntSet const & images) -> std::vector< vigra::Rect2D,std::allocator< vigra::Rect2D > >"""
        return _hsi.ComputeImageROI_computeROIS(panorama, opts, images)

    if _newclass:
        computeROIS = staticmethod(computeROIS)
    __swig_getmethods__["computeROIS"] = lambda x: computeROIS
ComputeImageROI_swigregister = _hsi.ComputeImageROI_swigregister
ComputeImageROI_swigregister(ComputeImageROI)

def ComputeImageROI_computeROIS(panorama, opts, images):
    """ComputeImageROI_computeROIS(PanoramaData panorama, PanoramaOptions opts, HuginBase::UIntSet const & images) -> std::vector< vigra::Rect2D,std::allocator< vigra::Rect2D > >"""
    return _hsi.ComputeImageROI_computeROIS(panorama, opts, images)

class CalculateFitPanorama(PanoramaAlgorithm):
    """Proxy of C++ HuginBase::CalculateFitPanorama class"""
    __swig_setmethods__ = {}
    for _s in [PanoramaAlgorithm]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CalculateFitPanorama, name, value)
    __swig_getmethods__ = {}
    for _s in [PanoramaAlgorithm]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CalculateFitPanorama, name)
    __repr__ = _swig_repr

    def __init__(self, panorama):
        """__init__(HuginBase::CalculateFitPanorama self, PanoramaData panorama) -> CalculateFitPanorama"""
        this = _hsi.new_CalculateFitPanorama(panorama)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _hsi.delete_CalculateFitPanorama
    __del__ = lambda self: None

    def modifiesPanoramaData(self):
        """modifiesPanoramaData(CalculateFitPanorama self) -> bool"""
        return _hsi.CalculateFitPanorama_modifiesPanoramaData(self)


    def runAlgorithm(self):
        """runAlgorithm(CalculateFitPanorama self) -> bool"""
        return _hsi.CalculateFitPanorama_runAlgorithm(self)


    def fitPano(panorama, HFOV, height):
        """fitPano(PanoramaData panorama, double & HFOV, double & height)"""
        return _hsi.CalculateFitPanorama_fitPano(panorama, HFOV, height)

    if _newclass:
        fitPano = staticmethod(fitPano)
    __swig_getmethods__["fitPano"] = lambda x: fitPano

    def getResultHorizontalFOV(self):
        """getResultHorizontalFOV(CalculateFitPanorama self) -> double"""
        return _hsi.CalculateFitPanorama_getResultHorizontalFOV(self)


    def getResultHeight(self):
        """getResultHeight(CalculateFitPanorama self) -> double"""
        return _hsi.CalculateFitPanorama_getResultHeight(self)

CalculateFitPanorama_swigregister = _hsi.CalculateFitPanorama_swigregister
CalculateFitPanorama_swigregister(CalculateFitPanorama)

def CalculateFitPanorama_fitPano(panorama, HFOV, height):
    """CalculateFitPanorama_fitPano(PanoramaData panorama, double & HFOV, double & height)"""
    return _hsi.CalculateFitPanorama_fitPano(panorama, HFOV, height)

class FitPanorama(CalculateFitPanorama):
    """Proxy of C++ HuginBase::FitPanorama class"""
    __swig_setmethods__ = {}
    for _s in [CalculateFitPanorama]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, FitPanorama, name, value)
    __swig_getmethods__ = {}
    for _s in [CalculateFitPanorama]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, FitPanorama, name)
    __repr__ = _swig_repr

    def __init__(self, panorama):
        """__init__(HuginBase::FitPanorama self, PanoramaData panorama) -> FitPanorama"""
        this = _hsi.new_FitPanorama(panorama)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _hsi.delete_FitPanorama
    __del__ = lambda self: None

    def modifiesPanoramaData(self):
        """modifiesPanoramaData(FitPanorama self) -> bool"""
        return _hsi.FitPanorama_modifiesPanoramaData(self)


    def runAlgorithm(self):
        """runAlgorithm(FitPanorama self) -> bool"""
        return _hsi.FitPanorama_runAlgorithm(self)

FitPanorama_swigregister = _hsi.FitPanorama_swigregister
FitPanorama_swigregister(FitPanorama)

class NonaFileOutputStitcher(FileOutputStitcherAlgorithm):
    """Proxy of C++ HuginBase::NonaFileOutputStitcher class"""
    __swig_setmethods__ = {}
    for _s in [FileOutputStitcherAlgorithm]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, NonaFileOutputStitcher, name, value)
    __swig_getmethods__ = {}
    for _s in [FileOutputStitcherAlgorithm]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, NonaFileOutputStitcher, name)
    __repr__ = _swig_repr

    def __init__(self, panoramaData, progressDisplay, options, usedImages, filename):
        """__init__(HuginBase::NonaFileOutputStitcher self, PanoramaData panoramaData, AppBase::ProgressDisplay * progressDisplay, PanoramaOptions options, HuginBase::UIntSet const & usedImages, HuginBase::FileOutputStitcherAlgorithm::String const & filename) -> NonaFileOutputStitcher"""
        this = _hsi.new_NonaFileOutputStitcher(panoramaData, progressDisplay, options, usedImages, filename)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _hsi.delete_NonaFileOutputStitcher
    __del__ = lambda self: None
NonaFileOutputStitcher_swigregister = _hsi.NonaFileOutputStitcher_swigregister
NonaFileOutputStitcher_swigregister(NonaFileOutputStitcher)

class PTOptimizer(PanoramaAlgorithm):
    """Proxy of C++ HuginBase::PTOptimizer class"""
    __swig_setmethods__ = {}
    for _s in [PanoramaAlgorithm]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PTOptimizer, name, value)
    __swig_getmethods__ = {}
    for _s in [PanoramaAlgorithm]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, PTOptimizer, name)
    __repr__ = _swig_repr

    def __init__(self, panorama):
        """__init__(HuginBase::PTOptimizer self, PanoramaData panorama) -> PTOptimizer"""
        this = _hsi.new_PTOptimizer(panorama)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _hsi.delete_PTOptimizer
    __del__ = lambda self: None

    def modifiesPanoramaData(self):
        """modifiesPanoramaData(PTOptimizer self) -> bool"""
        return _hsi.PTOptimizer_modifiesPanoramaData(self)


    def runAlgorithm(self):
        """runAlgorithm(PTOptimizer self) -> bool"""
        return _hsi.PTOptimizer_runAlgorithm(self)

PTOptimizer_swigregister = _hsi.PTOptimizer_swigregister
PTOptimizer_swigregister(PTOptimizer)

class RANSACOptimizer(PanoramaAlgorithm):
    """Proxy of C++ HuginBase::RANSACOptimizer class"""
    __swig_setmethods__ = {}
    for _s in [PanoramaAlgorithm]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, RANSACOptimizer, name, value)
    __swig_getmethods__ = {}
    for _s in [PanoramaAlgorithm]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, RANSACOptimizer, name)
    __repr__ = _swig_repr
    AUTO = _hsi.RANSACOptimizer_AUTO
    HOMOGRAPHY = _hsi.RANSACOptimizer_HOMOGRAPHY
    RPY = _hsi.RANSACOptimizer_RPY
    RPYV = _hsi.RANSACOptimizer_RPYV
    RPYVB = _hsi.RANSACOptimizer_RPYVB

    def __init__(self, panorama, i1, i2, maxError, mode=RPY):
        """
        __init__(HuginBase::RANSACOptimizer self, PanoramaData panorama, int i1, int i2, double maxError, HuginBase::RANSACOptimizer::Mode mode=RPY) -> RANSACOptimizer
        __init__(HuginBase::RANSACOptimizer self, PanoramaData panorama, int i1, int i2, double maxError) -> RANSACOptimizer
        """
        this = _hsi.new_RANSACOptimizer(panorama, i1, i2, maxError, mode)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _hsi.delete_RANSACOptimizer
    __del__ = lambda self: None

    def modifiesPanoramaData(self):
        """modifiesPanoramaData(RANSACOptimizer self) -> bool"""
        return _hsi.RANSACOptimizer_modifiesPanoramaData(self)


    def findInliers(pano, i1, i2, maxError, mode=RPY):
        """
        findInliers(PanoramaData pano, int i1, int i2, double maxError, HuginBase::RANSACOptimizer::Mode mode=RPY) -> std::vector< int,std::allocator< int > >
        findInliers(PanoramaData pano, int i1, int i2, double maxError) -> std::vector< int,std::allocator< int > >
        """
        return _hsi.RANSACOptimizer_findInliers(pano, i1, i2, maxError, mode)

    if _newclass:
        findInliers = staticmethod(findInliers)
    __swig_getmethods__["findInliers"] = lambda x: findInliers

    def runAlgorithm(self):
        """runAlgorithm(RANSACOptimizer self) -> bool"""
        return _hsi.RANSACOptimizer_runAlgorithm(self)

RANSACOptimizer_swigregister = _hsi.RANSACOptimizer_swigregister
RANSACOptimizer_swigregister(RANSACOptimizer)

def RANSACOptimizer_findInliers(pano, i1, i2, maxError, mode=RPY):
    """
    findInliers(PanoramaData pano, int i1, int i2, double maxError, HuginBase::RANSACOptimizer::Mode mode=RPY) -> std::vector< int,std::allocator< int > >
    RANSACOptimizer_findInliers(PanoramaData pano, int i1, int i2, double maxError) -> std::vector< int,std::allocator< int > >
    """
    return _hsi.RANSACOptimizer_findInliers(pano, i1, i2, maxError, mode)

class AutoOptimise(PTOptimizer):
    """Proxy of C++ HuginBase::AutoOptimise class"""
    __swig_setmethods__ = {}
    for _s in [PTOptimizer]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, AutoOptimise, name, value)
    __swig_getmethods__ = {}
    for _s in [PTOptimizer]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, AutoOptimise, name)
    __repr__ = _swig_repr

    def __init__(self, panorama, optRoll=True):
        """
        __init__(HuginBase::AutoOptimise self, PanoramaData panorama, bool optRoll=True) -> AutoOptimise
        __init__(HuginBase::AutoOptimise self, PanoramaData panorama) -> AutoOptimise
        """
        this = _hsi.new_AutoOptimise(panorama, optRoll)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _hsi.delete_AutoOptimise
    __del__ = lambda self: None

    def autoOptimise(pano, optRoll=True):
        """
        autoOptimise(PanoramaData pano, bool optRoll=True)
        autoOptimise(PanoramaData pano)
        """
        return _hsi.AutoOptimise_autoOptimise(pano, optRoll)

    if _newclass:
        autoOptimise = staticmethod(autoOptimise)
    __swig_getmethods__["autoOptimise"] = lambda x: autoOptimise

    def runAlgorithm(self):
        """runAlgorithm(AutoOptimise self) -> bool"""
        return _hsi.AutoOptimise_runAlgorithm(self)

AutoOptimise_swigregister = _hsi.AutoOptimise_swigregister
AutoOptimise_swigregister(AutoOptimise)

def AutoOptimise_autoOptimise(pano, optRoll=True):
    """
    autoOptimise(PanoramaData pano, bool optRoll=True)
    AutoOptimise_autoOptimise(PanoramaData pano)
    """
    return _hsi.AutoOptimise_autoOptimise(pano, optRoll)

class SmartOptimizerStub(_object):
    """Proxy of C++ HuginBase::SmartOptimizerStub class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SmartOptimizerStub, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SmartOptimizerStub, name)
    __repr__ = _swig_repr
    OPT_POS = _hsi.SmartOptimizerStub_OPT_POS
    OPT_B = _hsi.SmartOptimizerStub_OPT_B
    OPT_AC = _hsi.SmartOptimizerStub_OPT_AC
    OPT_DE = _hsi.SmartOptimizerStub_OPT_DE
    OPT_HFOV = _hsi.SmartOptimizerStub_OPT_HFOV
    OPT_GT = _hsi.SmartOptimizerStub_OPT_GT
    OPT_VIG = _hsi.SmartOptimizerStub_OPT_VIG
    OPT_VIGCENTRE = _hsi.SmartOptimizerStub_OPT_VIGCENTRE
    OPT_EXP = _hsi.SmartOptimizerStub_OPT_EXP
    OPT_WB = _hsi.SmartOptimizerStub_OPT_WB
    OPT_RESP = _hsi.SmartOptimizerStub_OPT_RESP

    def createOptVars(optPano, mode, anchorImg=0):
        """
        createOptVars(PanoramaData optPano, int mode, unsigned int anchorImg=0) -> OptimizeVector
        createOptVars(PanoramaData optPano, int mode) -> OptimizeVector
        """
        return _hsi.SmartOptimizerStub_createOptVars(optPano, mode, anchorImg)

    if _newclass:
        createOptVars = staticmethod(createOptVars)
    __swig_getmethods__["createOptVars"] = lambda x: createOptVars

    def __init__(self):
        """__init__(HuginBase::SmartOptimizerStub self) -> SmartOptimizerStub"""
        this = _hsi.new_SmartOptimizerStub()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _hsi.delete_SmartOptimizerStub
    __del__ = lambda self: None
SmartOptimizerStub_swigregister = _hsi.SmartOptimizerStub_swigregister
SmartOptimizerStub_swigregister(SmartOptimizerStub)

def SmartOptimizerStub_createOptVars(optPano, mode, anchorImg=0):
    """
    createOptVars(PanoramaData optPano, int mode, unsigned int anchorImg=0) -> OptimizeVector
    SmartOptimizerStub_createOptVars(PanoramaData optPano, int mode) -> OptimizeVector
    """
    return _hsi.SmartOptimizerStub_createOptVars(optPano, mode, anchorImg)

class SmartOptimise(PTOptimizer):
    """Proxy of C++ HuginBase::SmartOptimise class"""
    __swig_setmethods__ = {}
    for _s in [PTOptimizer]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SmartOptimise, name, value)
    __swig_getmethods__ = {}
    for _s in [PTOptimizer]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, SmartOptimise, name)
    __repr__ = _swig_repr

    def __init__(self, panorama):
        """__init__(HuginBase::SmartOptimise self, PanoramaData panorama) -> SmartOptimise"""
        this = _hsi.new_SmartOptimise(panorama)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _hsi.delete_SmartOptimise
    __del__ = lambda self: None

    def smartOptimize(pano):
        """smartOptimize(PanoramaData pano)"""
        return _hsi.SmartOptimise_smartOptimize(pano)

    if _newclass:
        smartOptimize = staticmethod(smartOptimize)
    __swig_getmethods__["smartOptimize"] = lambda x: smartOptimize

    def runAlgorithm(self):
        """runAlgorithm(SmartOptimise self) -> bool"""
        return _hsi.SmartOptimise_runAlgorithm(self)

SmartOptimise_swigregister = _hsi.SmartOptimise_swigregister
SmartOptimise_swigregister(SmartOptimise)

def SmartOptimise_smartOptimize(pano):
    """SmartOptimise_smartOptimize(PanoramaData pano)"""
    return _hsi.SmartOptimise_smartOptimize(pano)

class PhotometricOptimizer(TimeConsumingPanoramaAlgorithm):
    """Proxy of C++ HuginBase::PhotometricOptimizer class"""
    __swig_setmethods__ = {}
    for _s in [TimeConsumingPanoramaAlgorithm]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PhotometricOptimizer, name, value)
    __swig_getmethods__ = {}
    for _s in [TimeConsumingPanoramaAlgorithm]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, PhotometricOptimizer, name)
    __repr__ = _swig_repr

    def __init__(self, panorama, progressDisplay, vars, correspondences):
        """__init__(HuginBase::PhotometricOptimizer self, PanoramaData panorama, AppBase::ProgressDisplay * progressDisplay, OptimizeVector vars, HuginBase::PhotometricOptimizer::PointPairs const & correspondences) -> PhotometricOptimizer"""
        this = _hsi.new_PhotometricOptimizer(panorama, progressDisplay, vars, correspondences)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _hsi.delete_PhotometricOptimizer
    __del__ = lambda self: None

    def optimizePhotometric(pano, vars, correspondences, progress, error):
        """optimizePhotometric(PanoramaData pano, OptimizeVector vars, HuginBase::PhotometricOptimizer::PointPairs const & correspondences, AppBase::ProgressReporter & progress, double & error)"""
        return _hsi.PhotometricOptimizer_optimizePhotometric(pano, vars, correspondences, progress, error)

    if _newclass:
        optimizePhotometric = staticmethod(optimizePhotometric)
    __swig_getmethods__["optimizePhotometric"] = lambda x: optimizePhotometric

    def modifiesPanoramaData(self):
        """modifiesPanoramaData(PhotometricOptimizer self) -> bool"""
        return _hsi.PhotometricOptimizer_modifiesPanoramaData(self)


    def runAlgorithm(self):
        """runAlgorithm(PhotometricOptimizer self) -> bool"""
        return _hsi.PhotometricOptimizer_runAlgorithm(self)


    def getResultError(self):
        """getResultError(PhotometricOptimizer self) -> double"""
        return _hsi.PhotometricOptimizer_getResultError(self)

PhotometricOptimizer_swigregister = _hsi.PhotometricOptimizer_swigregister
PhotometricOptimizer_swigregister(PhotometricOptimizer)

def PhotometricOptimizer_optimizePhotometric(pano, vars, correspondences, progress, error):
    """PhotometricOptimizer_optimizePhotometric(PanoramaData pano, OptimizeVector vars, HuginBase::PhotometricOptimizer::PointPairs const & correspondences, AppBase::ProgressReporter & progress, double & error)"""
    return _hsi.PhotometricOptimizer_optimizePhotometric(pano, vars, correspondences, progress, error)

class SmartPhotometricOptimizer(PhotometricOptimizer):
    """Proxy of C++ HuginBase::SmartPhotometricOptimizer class"""
    __swig_setmethods__ = {}
    for _s in [PhotometricOptimizer]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SmartPhotometricOptimizer, name, value)
    __swig_getmethods__ = {}
    for _s in [PhotometricOptimizer]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, SmartPhotometricOptimizer, name)
    __repr__ = _swig_repr
    OPT_PHOTOMETRIC_LDR = _hsi.SmartPhotometricOptimizer_OPT_PHOTOMETRIC_LDR
    OPT_PHOTOMETRIC_LDR_WB = _hsi.SmartPhotometricOptimizer_OPT_PHOTOMETRIC_LDR_WB
    OPT_PHOTOMETRIC_HDR = _hsi.SmartPhotometricOptimizer_OPT_PHOTOMETRIC_HDR
    OPT_PHOTOMETRIC_HDR_WB = _hsi.SmartPhotometricOptimizer_OPT_PHOTOMETRIC_HDR_WB

    def __init__(self, panorama, progressDisplay, vars, correspondences, optMode):
        """__init__(HuginBase::SmartPhotometricOptimizer self, PanoramaData panorama, AppBase::ProgressDisplay * progressDisplay, OptimizeVector vars, HuginBase::PhotometricOptimizer::PointPairs const & correspondences, HuginBase::SmartPhotometricOptimizer::PhotometricOptimizeMode optMode) -> SmartPhotometricOptimizer"""
        this = _hsi.new_SmartPhotometricOptimizer(panorama, progressDisplay, vars, correspondences, optMode)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _hsi.delete_SmartPhotometricOptimizer
    __del__ = lambda self: None

    def smartOptimizePhotometric(pano, mode, correspondences, progress, error):
        """smartOptimizePhotometric(PanoramaData pano, HuginBase::SmartPhotometricOptimizer::PhotometricOptimizeMode mode, std::vector< vigra_ext::PointPairRGB,std::allocator< vigra_ext::PointPairRGB > > const & correspondences, AppBase::ProgressReporter & progress, double & error)"""
        return _hsi.SmartPhotometricOptimizer_smartOptimizePhotometric(pano, mode, correspondences, progress, error)

    if _newclass:
        smartOptimizePhotometric = staticmethod(smartOptimizePhotometric)
    __swig_getmethods__["smartOptimizePhotometric"] = lambda x: smartOptimizePhotometric

    def runAlgorithm(self):
        """runAlgorithm(SmartPhotometricOptimizer self) -> bool"""
        return _hsi.SmartPhotometricOptimizer_runAlgorithm(self)

SmartPhotometricOptimizer_swigregister = _hsi.SmartPhotometricOptimizer_swigregister
SmartPhotometricOptimizer_swigregister(SmartPhotometricOptimizer)

def SmartPhotometricOptimizer_smartOptimizePhotometric(pano, mode, correspondences, progress, error):
    """SmartPhotometricOptimizer_smartOptimizePhotometric(PanoramaData pano, HuginBase::SmartPhotometricOptimizer::PhotometricOptimizeMode mode, std::vector< vigra_ext::PointPairRGB,std::allocator< vigra_ext::PointPairRGB > > const & correspondences, AppBase::ProgressReporter & progress, double & error)"""
    return _hsi.SmartPhotometricOptimizer_smartOptimizePhotometric(pano, mode, correspondences, progress, error)

class PanoramaMakefilelibExport(PanoramaAlgorithm):
    """Proxy of C++ HuginBase::PanoramaMakefilelibExport class"""
    __swig_setmethods__ = {}
    for _s in [PanoramaAlgorithm]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PanoramaMakefilelibExport, name, value)
    __swig_getmethods__ = {}
    for _s in [PanoramaAlgorithm]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, PanoramaMakefilelibExport, name)
    __repr__ = _swig_repr

    def __init__(self, pano_, images_, ptofile_, outputPrefix_, progs_, includePath_, outputFiles_, makefile_, tmpDir_, copyMetadata_, generateGPanoTags_, nrThreads_):
        """__init__(HuginBase::PanoramaMakefilelibExport self, PanoramaData pano_, HuginBase::UIntSet const & images_, std::string const & ptofile_, std::string const & outputPrefix_, HuginBase::PanoramaMakefilelibExport::PTPrograms const & progs_, std::string const & includePath_, std::vector< std::string,std::allocator< std::string > > & outputFiles_, ostream makefile_, std::string const & tmpDir_, bool const copyMetadata_, bool const generateGPanoTags_, int const nrThreads_) -> PanoramaMakefilelibExport"""
        this = _hsi.new_PanoramaMakefilelibExport(pano_, images_, ptofile_, outputPrefix_, progs_, includePath_, outputFiles_, makefile_, tmpDir_, copyMetadata_, generateGPanoTags_, nrThreads_)
        try:
            self.this.append(this)
        except:
            self.this = this

    def createMakefile(pano_, images_, ptofile_, outputPrefix_, progs_, includePath_, outputFiles_, makefile_, tmpDir_, copyMetadata_, generateGPanoTags_, nrThreads_):
        """createMakefile(PanoramaData pano_, HuginBase::UIntSet const & images_, std::string const & ptofile_, std::string const & outputPrefix_, HuginBase::PanoramaMakefilelibExport::PTPrograms const & progs_, std::string const & includePath_, std::vector< std::string,std::allocator< std::string > > & outputFiles_, ostream makefile_, std::string const & tmpDir_, bool const copyMetadata_, bool const generateGPanoTags_, int const nrThreads_)"""
        return _hsi.PanoramaMakefilelibExport_createMakefile(pano_, images_, ptofile_, outputPrefix_, progs_, includePath_, outputFiles_, makefile_, tmpDir_, copyMetadata_, generateGPanoTags_, nrThreads_)

    if _newclass:
        createMakefile = staticmethod(createMakefile)
    __swig_getmethods__["createMakefile"] = lambda x: createMakefile

    def modifiesPanoramaData(self):
        """modifiesPanoramaData(PanoramaMakefilelibExport self) -> bool"""
        return _hsi.PanoramaMakefilelibExport_modifiesPanoramaData(self)


    def runAlgorithm(self):
        """runAlgorithm(PanoramaMakefilelibExport self) -> bool"""
        return _hsi.PanoramaMakefilelibExport_runAlgorithm(self)

    __swig_destroy__ = _hsi.delete_PanoramaMakefilelibExport
    __del__ = lambda self: None
PanoramaMakefilelibExport_swigregister = _hsi.PanoramaMakefilelibExport_swigregister
PanoramaMakefilelibExport_swigregister(PanoramaMakefilelibExport)

def PanoramaMakefilelibExport_createMakefile(pano_, images_, ptofile_, outputPrefix_, progs_, includePath_, outputFiles_, makefile_, tmpDir_, copyMetadata_, generateGPanoTags_, nrThreads_):
    """PanoramaMakefilelibExport_createMakefile(PanoramaData pano_, HuginBase::UIntSet const & images_, std::string const & ptofile_, std::string const & outputPrefix_, HuginBase::PanoramaMakefilelibExport::PTPrograms const & progs_, std::string const & includePath_, std::vector< std::string,std::allocator< std::string > > & outputFiles_, ostream makefile_, std::string const & tmpDir_, bool const copyMetadata_, bool const generateGPanoTags_, int const nrThreads_)"""
    return _hsi.PanoramaMakefilelibExport_createMakefile(pano_, images_, ptofile_, outputPrefix_, progs_, includePath_, outputFiles_, makefile_, tmpDir_, copyMetadata_, generateGPanoTags_, nrThreads_)


def printstacks(stackdata):
    """printstacks(std::vector< HuginBase::UIntSet,std::allocator< HuginBase::UIntSet > > const & stackdata)"""
    return _hsi.printstacks(stackdata)

def CheckExifToolArgfile(progs):
    """CheckExifToolArgfile(HuginBase::PanoramaMakefilelibExport::PTPrograms & progs)"""
    return _hsi.CheckExifToolArgfile(progs)
class PointSampler(TimeConsumingPanoramaAlgorithm):
    """Proxy of C++ HuginBase::PointSampler class"""
    __swig_setmethods__ = {}
    for _s in [TimeConsumingPanoramaAlgorithm]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PointSampler, name, value)
    __swig_getmethods__ = {}
    for _s in [TimeConsumingPanoramaAlgorithm]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, PointSampler, name)

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

    def extractPoints(pano, images, nPoints, randomPoints, progress, points):
        """extractPoints(PanoramaData pano, std::vector< vigra::FRGBImage *,std::allocator< vigra::FRGBImage * > > images, int nPoints, bool randomPoints, AppBase::ProgressReporter & progress, std::vector< vigra_ext::PointPairRGB,std::allocator< vigra_ext::PointPairRGB > > & points)"""
        return _hsi.PointSampler_extractPoints(pano, images, nPoints, randomPoints, progress, points)

    if _newclass:
        extractPoints = staticmethod(extractPoints)
    __swig_getmethods__["extractPoints"] = lambda x: extractPoints

    def modifiesPanoramaData(self):
        """modifiesPanoramaData(PointSampler self) -> bool"""
        return _hsi.PointSampler_modifiesPanoramaData(self)


    def runAlgorithm(self):
        """runAlgorithm(PointSampler self) -> bool"""
        return _hsi.PointSampler_runAlgorithm(self)


    def execute(self):
        """execute(PointSampler self) -> PointSampler"""
        return _hsi.PointSampler_execute(self)


    def getResultPoints(self):
        """getResultPoints(PointSampler self) -> HuginBase::PointSampler::PointPairs"""
        return _hsi.PointSampler_getResultPoints(self)

PointSampler_swigregister = _hsi.PointSampler_swigregister
PointSampler_swigregister(PointSampler)

def PointSampler_extractPoints(pano, images, nPoints, randomPoints, progress, points):
    """PointSampler_extractPoints(PanoramaData pano, std::vector< vigra::FRGBImage *,std::allocator< vigra::FRGBImage * > > images, int nPoints, bool randomPoints, AppBase::ProgressReporter & progress, std::vector< vigra_ext::PointPairRGB,std::allocator< vigra_ext::PointPairRGB > > & points)"""
    return _hsi.PointSampler_extractPoints(pano, images, nPoints, randomPoints, progress, points)

class AllPointSampler(PointSampler):
    """Proxy of C++ HuginBase::AllPointSampler class"""
    __swig_setmethods__ = {}
    for _s in [PointSampler]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, AllPointSampler, name, value)
    __swig_getmethods__ = {}
    for _s in [PointSampler]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, AllPointSampler, name)
    __repr__ = _swig_repr

    def __init__(self, panorama, progressDisplay, images, nPoints):
        """__init__(HuginBase::AllPointSampler self, PanoramaData panorama, AppBase::ProgressDisplay * progressDisplay, std::vector< vigra::FRGBImage *,std::allocator< vigra::FRGBImage * > > images, int nPoints) -> AllPointSampler"""
        this = _hsi.new_AllPointSampler(panorama, progressDisplay, images, nPoints)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _hsi.delete_AllPointSampler
    __del__ = lambda self: None
AllPointSampler_swigregister = _hsi.AllPointSampler_swigregister
AllPointSampler_swigregister(AllPointSampler)

class RandomPointSampler(PointSampler):
    """Proxy of C++ HuginBase::RandomPointSampler class"""
    __swig_setmethods__ = {}
    for _s in [PointSampler]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, RandomPointSampler, name, value)
    __swig_getmethods__ = {}
    for _s in [PointSampler]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, RandomPointSampler, name)
    __repr__ = _swig_repr

    def __init__(self, panorama, progressDisplay, images, nPoints):
        """__init__(HuginBase::RandomPointSampler self, PanoramaData panorama, AppBase::ProgressDisplay * progressDisplay, std::vector< vigra::FRGBImage *,std::allocator< vigra::FRGBImage * > > images, int nPoints) -> RandomPointSampler"""
        this = _hsi.new_RandomPointSampler(panorama, progressDisplay, images, nPoints)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _hsi.delete_RandomPointSampler
    __del__ = lambda self: None
RandomPointSampler_swigregister = _hsi.RandomPointSampler_swigregister
RandomPointSampler_swigregister(RandomPointSampler)

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


