# This file was automatically generated by SWIG (http://www.swig.org).
# Version 2.0.11
#
# 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):
        self.__dict__[name] = value
    else:
        raise AttributeError("You cannot add attributes to %s" % self)

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

def _swig_getattr(self,class_type,name):
    if (name == "thisown"): return self.this.own()
    method = class_type.__swig_getmethods__.get(name,None)
    if method: return method(self)
    raise AttributeError(name)

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, *args):
        """distance(SwigPyIterator self, SwigPyIterator x) -> ptrdiff_t"""
        return _hsi.SwigPyIterator_distance(self, *args)

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

    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, *args):
        """advance(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
        return _hsi.SwigPyIterator_advance(self, *args)

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

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

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

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

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

    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, *args):
        """register_callback(ios_base self, std::ios_base::event_callback __fn, int __index)"""
        return _hsi.ios_base_register_callback(self, *args)

    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, *args):
        """unsetf(ios_base self, std::ios_base::fmtflags __mask)"""
        return _hsi.ios_base_unsetf(self, *args)

    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, *args):
        """imbue(ios_base self, std::locale const & __loc) -> std::locale"""
        return _hsi.ios_base_imbue(self, *args)

    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, *args):
        """iword(ios_base self, int __ix) -> long &"""
        return _hsi.ios_base_iword(self, *args)

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

    __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=goodbit)
        clear(ios self)
        """
        return _hsi.ios_clear(self, *args)

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

    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, *args): 
        """__init__(std::basic_ios<(char)> self, std::basic_streambuf< char,std::char_traits< char > > * __sb) -> ios"""
        this = _hsi.new_ios(*args)
        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, *args):
        """copyfmt(ios self, ios __rhs) -> ios"""
        return _hsi.ios_copyfmt(self, *args)

    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, *args):
        """imbue(ios self, std::locale const & __loc) -> std::locale"""
        return _hsi.ios_imbue(self, *args)

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

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

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, *args): 
        """__init__(std::basic_ostream<(char)> self, std::basic_streambuf< char,std::char_traits< char > > * __sb) -> ostream"""
        this = _hsi.new_ostream(*args)
        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, *args):
        """put(ostream self, std::basic_ostream< char >::char_type __c) -> ostream"""
        return _hsi.ostream_put(self, *args)

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

    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, *args): 
        """__init__(std::basic_istream<(char)> self, std::basic_streambuf< char,std::char_traits< char > > * __sb) -> istream"""
        this = _hsi.new_istream(*args)
        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=std::char_traits< char >::eof()) -> 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, *args):
        """read(istream self, std::basic_istream< char >::char_type * __s, std::streamsize __n) -> istream"""
        return _hsi.istream_read(self, *args)

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

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

    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, *args): 
        """__init__(std::basic_iostream<(char)> self, std::basic_streambuf< char,std::char_traits< char > > * __sb) -> iostream"""
        this = _hsi.new_iostream(*args)
        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(*args):
  """endl(ostream arg1) -> ostream"""
  return _hsi.endl(*args)
endl = _hsi.endl
ends_cb_ptr = _hsi.ends_cb_ptr

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

def flush(*args):
  """flush(ostream arg1) -> ostream"""
  return _hsi.flush(*args)
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, *args): 
        """__init__(std::ifstream self, char * filename) -> ifstream"""
        this = _hsi.new_ifstream(*args)
        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, *args): 
        """__init__(std::ofstream self, char * filename) -> ofstream"""
        this = _hsi.new_ofstream(*args)
        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, *args):
        """__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, *args)

    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=std::vector< unsigned int,std::allocator< unsigned int > >())
        __setslice__(UIntVector self, vector< unsigned int >::difference_type i, vector< unsigned int >::difference_type j)
        """
        return _hsi.UIntVector___setslice__(self, *args)

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

    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, *args):
        """append(UIntVector self, vector< unsigned int >::value_type const & x)"""
        return _hsi.UIntVector_append(self, *args)

    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, *args):
        """swap(UIntVector self, UIntVector v)"""
        return _hsi.UIntVector_swap(self, *args)

    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, *args):
        """push_back(UIntVector self, vector< unsigned int >::value_type const & x)"""
        return _hsi.UIntVector_push_back(self, *args)

    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, *args):
        """assign(UIntVector self, vector< unsigned int >::size_type n, vector< unsigned int >::value_type const & x)"""
        return _hsi.UIntVector_assign(self, *args)

    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, *args):
        """reserve(UIntVector self, vector< unsigned int >::size_type n)"""
        return _hsi.UIntVector_reserve(self, *args)

    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, *args):
        """append(UIntSet self, set< unsigned int >::value_type x)"""
        return _hsi.UIntSet_append(self, *args)

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

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

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

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

    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, *args):
        """swap(UIntSet self, UIntSet v)"""
        return _hsi.UIntSet_swap(self, *args)

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

    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, *args):
        """find(UIntSet self, set< unsigned int >::key_type const & x) -> set< unsigned int >::iterator"""
        return _hsi.UIntSet_find(self, *args)

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

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

    def equal_range(self, *args):
        """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, *args)

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

    __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, *args):
        """__getslice__(DoubleVector self, vector< double >::difference_type i, vector< double >::difference_type j) -> std::vector< double,std::allocator< double > > *"""
        return _hsi.DoubleVector___getslice__(self, *args)

    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=std::vector< double,std::allocator< double > >())
        __setslice__(DoubleVector self, vector< double >::difference_type i, vector< double >::difference_type j)
        """
        return _hsi.DoubleVector___setslice__(self, *args)

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

    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, *args):
        """append(DoubleVector self, vector< double >::value_type const & x)"""
        return _hsi.DoubleVector_append(self, *args)

    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, *args):
        """swap(DoubleVector self, DoubleVector v)"""
        return _hsi.DoubleVector_swap(self, *args)

    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, *args):
        """push_back(DoubleVector self, vector< double >::value_type const & x)"""
        return _hsi.DoubleVector_push_back(self, *args)

    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, *args):
        """assign(DoubleVector self, vector< double >::size_type n, vector< double >::value_type const & x)"""
        return _hsi.DoubleVector_assign(self, *args)

    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, *args):
        """reserve(DoubleVector self, vector< double >::size_type n)"""
        return _hsi.DoubleVector_reserve(self, *args)

    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, *args):
        """setWidth(Size2D self, int w)"""
        return _hsi.Size2D_setWidth(self, *args)

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

    __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, *args):
        """
        readData(DocumentData self, istream dataInput, std::string documentType="") -> AppBase::DocumentData::ReadWriteError
        readData(DocumentData self, istream dataInput) -> AppBase::DocumentData::ReadWriteError
        """
        return _hsi.DocumentData_readData(self, *args)

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

    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, *args):
        """getNewSubset(PanoramaData self, HuginBase::UIntSet const & imgs) -> PanoramaData"""
        return _hsi.PanoramaData_getNewSubset(self, *args)

    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, *args):
        """getImage(PanoramaData self, std::size_t nr) -> SrcPanoImage"""
        return _hsi.PanoramaData_getImage(self, *args)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    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, *args):
        """getImageVariables(PanoramaData self, unsigned int imgNr) -> VariableMap const"""
        return _hsi.PanoramaData_getImageVariables(self, *args)

    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, *args):
        """updateVariable(PanoramaData self, unsigned int imgNr, Variable var)"""
        return _hsi.PanoramaData_updateVariable(self, *args)

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

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

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

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

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

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

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

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

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

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

    def printPanoramaScript(self, *args):
        """
        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, *args)

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

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

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

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

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

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

    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, *args):
        """checkRefOptStatus(PanoramaData self, bool & linkRefImgsYaw, bool & linkRefImgsPitch, bool & linkRefImgsRoll)"""
        return _hsi.PanoramaData_checkRefOptStatus(self, *args)

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, *args):
        """panoramaChanged(PanoramaObserver self, PanoramaData pano)"""
        return _hsi.PanoramaObserver_panoramaChanged(self, *args)

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

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, *args):
        """addObserver(ManagedPanoramaData self, PanoramaObserver o)"""
        return _hsi.ManagedPanoramaData_addObserver(self, *args)

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

    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, *args):
        """imageChanged(ManagedPanoramaData self, unsigned int imgNr)"""
        return _hsi.ManagedPanoramaData_imageChanged(self, *args)

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

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

    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, *args):
        """__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, *args)

    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=std::vector< std::pair< unsigned int,ControlPoint >,std::allocator< std::pair< unsigned int,ControlPoint > > >())
        __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, *args):
        """__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, *args)

    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, *args):
        """append(CPointVector self, std::vector< std::pair< unsigned int,ControlPoint > >::value_type const & x)"""
        return _hsi.CPointVector_append(self, *args)

    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, *args):
        """swap(CPointVector self, std::vector< std::pair< unsigned int,HuginBase::ControlPoint > > & v)"""
        return _hsi.CPointVector_swap(self, *args)

    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, *args):
        """push_back(CPointVector self, std::vector< std::pair< unsigned int,ControlPoint > >::value_type const & x)"""
        return _hsi.CPointVector_push_back(self, *args)

    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, *args):
        """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, *args)

    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, *args):
        """reserve(CPointVector self, std::vector< std::pair< unsigned int,ControlPoint > >::size_type n)"""
        return _hsi.CPointVector_reserve(self, *args)

    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, *args):
        """__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, *args)

    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=std::vector< ControlPoint,std::allocator< ControlPoint > >())
        __setslice__(CPVector self, std::vector< ControlPoint >::difference_type i, std::vector< ControlPoint >::difference_type j)
        """
        return _hsi.CPVector___setslice__(self, *args)

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

    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, *args):
        """append(CPVector self, ControlPoint x)"""
        return _hsi.CPVector_append(self, *args)

    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, *args):
        """swap(CPVector self, CPVector v)"""
        return _hsi.CPVector_swap(self, *args)

    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, *args):
        """push_back(CPVector self, ControlPoint x)"""
        return _hsi.CPVector_push_back(self, *args)

    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, *args):
        """assign(CPVector self, std::vector< ControlPoint >::size_type n, ControlPoint x)"""
        return _hsi.CPVector_assign(self, *args)

    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, *args):
        """reserve(CPVector self, std::vector< ControlPoint >::size_type n)"""
        return _hsi.CPVector_reserve(self, *args)

    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, *args):
        """__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, *args)

    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=std::vector< SrcPanoImage,std::allocator< SrcPanoImage > >())
        __setslice__(ImageVector self, std::vector< SrcPanoImage >::difference_type i, std::vector< SrcPanoImage >::difference_type j)
        """
        return _hsi.ImageVector___setslice__(self, *args)

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

    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, *args):
        """append(ImageVector self, SrcPanoImage x)"""
        return _hsi.ImageVector_append(self, *args)

    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, *args):
        """swap(ImageVector self, ImageVector v)"""
        return _hsi.ImageVector_swap(self, *args)

    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, *args):
        """push_back(ImageVector self, SrcPanoImage x)"""
        return _hsi.ImageVector_push_back(self, *args)

    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, *args):
        """assign(ImageVector self, std::vector< SrcPanoImage >::size_type n, SrcPanoImage x)"""
        return _hsi.ImageVector_assign(self, *args)

    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, *args):
        """reserve(ImageVector self, std::vector< SrcPanoImage >::size_type n)"""
        return _hsi.ImageVector_reserve(self, *args)

    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, *args):
        """__getitem__(LensVarMap self, std::map< std::string,LensVariable >::key_type const & key) -> LensVariable"""
        return _hsi.LensVarMap___getitem__(self, *args)

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

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

    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, *args):
        """__contains__(LensVarMap self, std::map< std::string,LensVariable >::key_type const & key) -> bool"""
        return _hsi.LensVarMap___contains__(self, *args)

    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, *args):
        """swap(LensVarMap self, LensVarMap v)"""
        return _hsi.LensVarMap_swap(self, *args)

    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, *args):
        """count(LensVarMap self, std::map< std::string,LensVariable >::key_type const & x) -> std::map< std::string,LensVariable >::size_type"""
        return _hsi.LensVarMap_count(self, *args)

    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, *args):
        """find(LensVarMap self, std::map< std::string,LensVariable >::key_type const & x) -> std::map< std::string,LensVariable >::iterator"""
        return _hsi.LensVarMap_find(self, *args)

    def lower_bound(self, *args):
        """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, *args)

    def upper_bound(self, *args):
        """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, *args)

    __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, *args):
        """__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, *args)

    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=std::vector< std::set< std::string,std::less< std::string >,std::allocator< std::string > >,std::allocator< std::set< std::string,std::less< std::string >,std::allocator< std::string > > > >())
        __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, *args):
        """__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, *args)

    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, *args):
        """append(OptimizeVector self, std::vector< std::set< std::string > >::value_type const & x)"""
        return _hsi.OptimizeVector_append(self, *args)

    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, *args):
        """swap(OptimizeVector self, OptimizeVector v)"""
        return _hsi.OptimizeVector_swap(self, *args)

    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, *args):
        """push_back(OptimizeVector self, std::vector< std::set< std::string > >::value_type const & x)"""
        return _hsi.OptimizeVector_push_back(self, *args)

    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, *args):
        """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, *args)

    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, *args):
        """reserve(OptimizeVector self, std::vector< std::set< std::string > >::size_type n)"""
        return _hsi.OptimizeVector_reserve(self, *args)

    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, *args):
        """__getitem__(VariableMap self, std::map< std::string,Variable >::key_type const & key) -> Variable"""
        return _hsi.VariableMap___getitem__(self, *args)

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

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

    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, *args):
        """__contains__(VariableMap self, std::map< std::string,Variable >::key_type const & key) -> bool"""
        return _hsi.VariableMap___contains__(self, *args)

    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, *args):
        """swap(VariableMap self, VariableMap v)"""
        return _hsi.VariableMap_swap(self, *args)

    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, *args):
        """count(VariableMap self, std::map< std::string,Variable >::key_type const & x) -> std::map< std::string,Variable >::size_type"""
        return _hsi.VariableMap_count(self, *args)

    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, *args):
        """find(VariableMap self, std::map< std::string,Variable >::key_type const & x) -> std::map< std::string,Variable >::iterator"""
        return _hsi.VariableMap_find(self, *args)

    def lower_bound(self, *args):
        """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, *args)

    def upper_bound(self, *args):
        """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, *args)

    __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, *args):
        """__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, *args)

    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=std::vector< std::map< std::string,Variable,std::less< std::string >,std::allocator< std::pair< std::string const,Variable > > >,std::allocator< std::map< std::string,Variable,std::less< std::string >,std::allocator< std::pair< std::string const,Variable > > > > >())
        __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, *args):
        """__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, *args)

    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, *args):
        """append(VariableMapVector self, std::vector< std::map< std::string,Variable > >::value_type const & x)"""
        return _hsi.VariableMapVector_append(self, *args)

    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, *args):
        """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, *args)

    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, *args):
        """push_back(VariableMapVector self, std::vector< std::map< std::string,Variable > >::value_type const & x)"""
        return _hsi.VariableMapVector_push_back(self, *args)

    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, *args):
        """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, *args)

    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, *args):
        """reserve(VariableMapVector self, std::vector< std::map< std::string,Variable > >::size_type n)"""
        return _hsi.VariableMapVector_reserve(self, *args)

    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, *args):
        """__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, *args)

    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=std::vector< MaskPolygon,std::allocator< MaskPolygon > >())
        __setslice__(MaskPolygonVector self, std::vector< MaskPolygon >::difference_type i, std::vector< MaskPolygon >::difference_type j)
        """
        return _hsi.MaskPolygonVector___setslice__(self, *args)

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

    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, *args):
        """append(MaskPolygonVector self, MaskPolygon x)"""
        return _hsi.MaskPolygonVector_append(self, *args)

    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, *args):
        """swap(MaskPolygonVector self, MaskPolygonVector v)"""
        return _hsi.MaskPolygonVector_swap(self, *args)

    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, *args):
        """push_back(MaskPolygonVector self, MaskPolygon x)"""
        return _hsi.MaskPolygonVector_push_back(self, *args)

    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, *args):
        """assign(MaskPolygonVector self, std::vector< MaskPolygon >::size_type n, MaskPolygon x)"""
        return _hsi.MaskPolygonVector_assign(self, *args)

    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, *args):
        """reserve(MaskPolygonVector self, std::vector< MaskPolygon >::size_type n)"""
        return _hsi.MaskPolygonVector_reserve(self, *args)

    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(*args):
        """checkApplicability(std::string const name) -> bool"""
        return _hsi.PTOVariableConverterNoOp_checkApplicability(*args)

    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(*args):
  """PTOVariableConverterNoOp_checkApplicability(std::string const name) -> bool"""
  return _hsi.PTOVariableConverterNoOp_checkApplicability(*args)

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_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_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_ExifCropFactor = _hsi.ConstImageVariableGroup_IVE_ExifCropFactor
    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_ExifExposureTime = _hsi.ConstImageVariableGroup_IVE_ExifExposureTime
    IVE_ExifDate = _hsi.ConstImageVariableGroup_IVE_ExifDate
    IVE_ExifExposureMode = _hsi.ConstImageVariableGroup_IVE_ExifExposureMode
    IVE_Masks = _hsi.ConstImageVariableGroup_IVE_Masks
    IVE_ActiveMasks = _hsi.ConstImageVariableGroup_IVE_ActiveMasks
    IVE_Active = _hsi.ConstImageVariableGroup_IVE_Active
    def __init__(self, *args): 
        """
        __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(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _hsi.delete_ConstImageVariableGroup
    __del__ = lambda self : None;
    def getPartNumber(self, *args):
        """getPartNumber(ConstImageVariableGroup self, unsigned int imageNr) -> unsigned int"""
        return _hsi.ConstImageVariableGroup_getPartNumber(self, *args)

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

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

    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, *args): 
        """
        __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(*args)
        try: self.this.append(this)
        except: self.this = this
    def unlinkVariablePart(self, *args):
        """unlinkVariablePart(ImageVariableGroup self, HuginBase::ConstImageVariableGroup::ImageVariableEnum variable, unsigned int partNr)"""
        return _hsi.ImageVariableGroup_unlinkVariablePart(self, *args)

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

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

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

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

    __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, *args): 
        """__init__(HuginBase::ConstStandardImageVariableGroups self, PanoramaData pano) -> ConstStandardImageVariableGroups"""
        this = _hsi.new_ConstStandardImageVariableGroups(*args)
        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, *args):
        """getLens(ConstStandardImageVariableGroups self, std::size_t lens_number) -> Lens"""
        return _hsi.ConstStandardImageVariableGroups_getLens(self, *args)

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

    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, *args): 
        """__init__(HuginBase::StandardImageVariableGroups self, PanoramaData pano) -> StandardImageVariableGroups"""
        this = _hsi.new_StandardImageVariableGroups(*args)
        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, *args): 
        """
        __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(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _hsi.delete_Variable
    __del__ = lambda self : None;
    def _print(self, *args):
        """_print(Variable self, ostream o) -> ostream"""
        return _hsi.Variable__print(self, *args)

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

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

    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=-1) -> 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, *args):
        """setLink(LinkedVariable self, int link)"""
        return _hsi.LinkedVariable_setLink(self, *args)

    __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, *args): 
        """
        __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(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _hsi.delete_LensVariable
    __del__ = lambda self : None;
    def printLink(self, *args):
        """printLink(LensVariable self, ostream o, unsigned int link) -> ostream"""
        return _hsi.LensVariable_printLink(self, *args)

    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(*args):
  """fillVariableMap(HuginBase::VariableMap & vars)"""
  return _hsi.fillVariableMap(*args)

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

def fillLensVarMap(*args):
  """fillLensVarMap(HuginBase::LensVarMap & vars)"""
  return _hsi.fillLensVarMap(*args)
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
    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, *args):
        """
        printScriptLine(PanoramaOptions self, ostream o, bool forPTOptimizer=False)
        printScriptLine(PanoramaOptions self, ostream o)
        """
        return _hsi.PanoramaOptions_printScriptLine(self, *args)

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

    if _newclass:getFormatName = staticmethod(getFormatName)
    __swig_getmethods__["getFormatName"] = lambda x: getFormatName
    def getFormatFromName(*args):
        """getFormatFromName(std::string const & name) -> HuginBase::PanoramaOptions::FileFormat"""
        return _hsi.PanoramaOptions_getFormatFromName(*args)

    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, *args):
        """
        setWidth(PanoramaOptions self, unsigned int w, bool keepView=True)
        setWidth(PanoramaOptions self, unsigned int w)
        """
        return _hsi.PanoramaOptions_setWidth(self, *args)

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

    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, *args):
        """setROI(PanoramaOptions self, Rect2D val)"""
        return _hsi.PanoramaOptions_setROI(self, *args)

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

    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, *args):
        """setProjectionParameters(PanoramaOptions self, std::vector< double,std::allocator< double > > const & params)"""
        return _hsi.PanoramaOptions_setProjectionParameters(self, *args)

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

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

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

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

    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(*args):
  """PanoramaOptions_getFormatName(HuginBase::PanoramaOptions::FileFormat f) -> std::string const &"""
  return _hsi.PanoramaOptions_getFormatName(*args)

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

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, *args):
        """__eq__(BaseSrcPanoImage self, BaseSrcPanoImage other) -> bool"""
        return _hsi.BaseSrcPanoImage___eq__(self, *args)

    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 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 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 getExifCropFactor(self):
        """getExifCropFactor(BaseSrcPanoImage self) -> double"""
        return _hsi.BaseSrcPanoImage_getExifCropFactor(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 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 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 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 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 getExifCropFactorIV(self):
        """getExifCropFactorIV(BaseSrcPanoImage self) -> HuginBase::ImageVariable< double > const &"""
        return _hsi.BaseSrcPanoImage_getExifCropFactorIV(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 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 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, *args):
        """setFilename(BaseSrcPanoImage self, std::string data)"""
        return _hsi.BaseSrcPanoImage_setFilename(self, *args)

    def setSize(self, *args):
        """setSize(BaseSrcPanoImage self, Size2D data)"""
        return _hsi.BaseSrcPanoImage_setSize(self, *args)

    def setProjection(self, *args):
        """setProjection(BaseSrcPanoImage self, HuginBase::BaseSrcPanoImage::Projection data)"""
        return _hsi.BaseSrcPanoImage_setProjection(self, *args)

    def setHFOV(self, *args):
        """setHFOV(BaseSrcPanoImage self, double data)"""
        return _hsi.BaseSrcPanoImage_setHFOV(self, *args)

    def setResponseType(self, *args):
        """setResponseType(BaseSrcPanoImage self, HuginBase::BaseSrcPanoImage::ResponseType data)"""
        return _hsi.BaseSrcPanoImage_setResponseType(self, *args)

    def setEMoRParams(self, *args):
        """setEMoRParams(BaseSrcPanoImage self, std::vector< float,std::allocator< float > > data)"""
        return _hsi.BaseSrcPanoImage_setEMoRParams(self, *args)

    def setExposureValue(self, *args):
        """setExposureValue(BaseSrcPanoImage self, double data)"""
        return _hsi.BaseSrcPanoImage_setExposureValue(self, *args)

    def setGamma(self, *args):
        """setGamma(BaseSrcPanoImage self, double data)"""
        return _hsi.BaseSrcPanoImage_setGamma(self, *args)

    def setWhiteBalanceRed(self, *args):
        """setWhiteBalanceRed(BaseSrcPanoImage self, double data)"""
        return _hsi.BaseSrcPanoImage_setWhiteBalanceRed(self, *args)

    def setWhiteBalanceBlue(self, *args):
        """setWhiteBalanceBlue(BaseSrcPanoImage self, double data)"""
        return _hsi.BaseSrcPanoImage_setWhiteBalanceBlue(self, *args)

    def setRoll(self, *args):
        """setRoll(BaseSrcPanoImage self, double data)"""
        return _hsi.BaseSrcPanoImage_setRoll(self, *args)

    def setPitch(self, *args):
        """setPitch(BaseSrcPanoImage self, double data)"""
        return _hsi.BaseSrcPanoImage_setPitch(self, *args)

    def setYaw(self, *args):
        """setYaw(BaseSrcPanoImage self, double data)"""
        return _hsi.BaseSrcPanoImage_setYaw(self, *args)

    def setX(self, *args):
        """setX(BaseSrcPanoImage self, double data)"""
        return _hsi.BaseSrcPanoImage_setX(self, *args)

    def setY(self, *args):
        """setY(BaseSrcPanoImage self, double data)"""
        return _hsi.BaseSrcPanoImage_setY(self, *args)

    def setZ(self, *args):
        """setZ(BaseSrcPanoImage self, double data)"""
        return _hsi.BaseSrcPanoImage_setZ(self, *args)

    def setStack(self, *args):
        """setStack(BaseSrcPanoImage self, double data)"""
        return _hsi.BaseSrcPanoImage_setStack(self, *args)

    def setRadialDistortion(self, *args):
        """setRadialDistortion(BaseSrcPanoImage self, std::vector< double,std::allocator< double > > data)"""
        return _hsi.BaseSrcPanoImage_setRadialDistortion(self, *args)

    def setRadialDistortionRed(self, *args):
        """setRadialDistortionRed(BaseSrcPanoImage self, std::vector< double,std::allocator< double > > data)"""
        return _hsi.BaseSrcPanoImage_setRadialDistortionRed(self, *args)

    def setRadialDistortionBlue(self, *args):
        """setRadialDistortionBlue(BaseSrcPanoImage self, std::vector< double,std::allocator< double > > data)"""
        return _hsi.BaseSrcPanoImage_setRadialDistortionBlue(self, *args)

    def setRadialDistortionCenterShift(self, *args):
        """setRadialDistortionCenterShift(BaseSrcPanoImage self, FDiff2D data)"""
        return _hsi.BaseSrcPanoImage_setRadialDistortionCenterShift(self, *args)

    def setShear(self, *args):
        """setShear(BaseSrcPanoImage self, FDiff2D data)"""
        return _hsi.BaseSrcPanoImage_setShear(self, *args)

    def setCropMode(self, *args):
        """setCropMode(BaseSrcPanoImage self, HuginBase::BaseSrcPanoImage::CropMode data)"""
        return _hsi.BaseSrcPanoImage_setCropMode(self, *args)

    def setCropRect(self, *args):
        """setCropRect(BaseSrcPanoImage self, Rect2D data)"""
        return _hsi.BaseSrcPanoImage_setCropRect(self, *args)

    def setAutoCenterCrop(self, *args):
        """setAutoCenterCrop(BaseSrcPanoImage self, bool data)"""
        return _hsi.BaseSrcPanoImage_setAutoCenterCrop(self, *args)

    def setVigCorrMode(self, *args):
        """setVigCorrMode(BaseSrcPanoImage self, int data)"""
        return _hsi.BaseSrcPanoImage_setVigCorrMode(self, *args)

    def setFlatfieldFilename(self, *args):
        """setFlatfieldFilename(BaseSrcPanoImage self, std::string data)"""
        return _hsi.BaseSrcPanoImage_setFlatfieldFilename(self, *args)

    def setRadialVigCorrCoeff(self, *args):
        """setRadialVigCorrCoeff(BaseSrcPanoImage self, std::vector< double,std::allocator< double > > data)"""
        return _hsi.BaseSrcPanoImage_setRadialVigCorrCoeff(self, *args)

    def setRadialVigCorrCenterShift(self, *args):
        """setRadialVigCorrCenterShift(BaseSrcPanoImage self, FDiff2D data)"""
        return _hsi.BaseSrcPanoImage_setRadialVigCorrCenterShift(self, *args)

    def setExifModel(self, *args):
        """setExifModel(BaseSrcPanoImage self, std::string data)"""
        return _hsi.BaseSrcPanoImage_setExifModel(self, *args)

    def setExifMake(self, *args):
        """setExifMake(BaseSrcPanoImage self, std::string data)"""
        return _hsi.BaseSrcPanoImage_setExifMake(self, *args)

    def setExifLens(self, *args):
        """setExifLens(BaseSrcPanoImage self, std::string data)"""
        return _hsi.BaseSrcPanoImage_setExifLens(self, *args)

    def setExifCropFactor(self, *args):
        """setExifCropFactor(BaseSrcPanoImage self, double data)"""
        return _hsi.BaseSrcPanoImage_setExifCropFactor(self, *args)

    def setExifFocalLength(self, *args):
        """setExifFocalLength(BaseSrcPanoImage self, double data)"""
        return _hsi.BaseSrcPanoImage_setExifFocalLength(self, *args)

    def setExifOrientation(self, *args):
        """setExifOrientation(BaseSrcPanoImage self, double data)"""
        return _hsi.BaseSrcPanoImage_setExifOrientation(self, *args)

    def setExifAperture(self, *args):
        """setExifAperture(BaseSrcPanoImage self, double data)"""
        return _hsi.BaseSrcPanoImage_setExifAperture(self, *args)

    def setExifISO(self, *args):
        """setExifISO(BaseSrcPanoImage self, double data)"""
        return _hsi.BaseSrcPanoImage_setExifISO(self, *args)

    def setExifDistance(self, *args):
        """setExifDistance(BaseSrcPanoImage self, double data)"""
        return _hsi.BaseSrcPanoImage_setExifDistance(self, *args)

    def setExifFocalLength35(self, *args):
        """setExifFocalLength35(BaseSrcPanoImage self, double data)"""
        return _hsi.BaseSrcPanoImage_setExifFocalLength35(self, *args)

    def setExifExposureTime(self, *args):
        """setExifExposureTime(BaseSrcPanoImage self, double data)"""
        return _hsi.BaseSrcPanoImage_setExifExposureTime(self, *args)

    def setExifDate(self, *args):
        """setExifDate(BaseSrcPanoImage self, std::string data)"""
        return _hsi.BaseSrcPanoImage_setExifDate(self, *args)

    def setExifExposureMode(self, *args):
        """setExifExposureMode(BaseSrcPanoImage self, int data)"""
        return _hsi.BaseSrcPanoImage_setExifExposureMode(self, *args)

    def setMasks(self, *args):
        """setMasks(BaseSrcPanoImage self, HuginBase::MaskPolygonVector data)"""
        return _hsi.BaseSrcPanoImage_setMasks(self, *args)

    def setActiveMasks(self, *args):
        """setActiveMasks(BaseSrcPanoImage self, HuginBase::MaskPolygonVector data)"""
        return _hsi.BaseSrcPanoImage_setActiveMasks(self, *args)

    def setActive(self, *args):
        """setActive(BaseSrcPanoImage self, bool data)"""
        return _hsi.BaseSrcPanoImage_setActive(self, *args)

    def linkFilename(self, *args):
        """linkFilename(BaseSrcPanoImage self, BaseSrcPanoImage target)"""
        return _hsi.BaseSrcPanoImage_linkFilename(self, *args)

    def linkSize(self, *args):
        """linkSize(BaseSrcPanoImage self, BaseSrcPanoImage target)"""
        return _hsi.BaseSrcPanoImage_linkSize(self, *args)

    def linkProjection(self, *args):
        """linkProjection(BaseSrcPanoImage self, BaseSrcPanoImage target)"""
        return _hsi.BaseSrcPanoImage_linkProjection(self, *args)

    def linkHFOV(self, *args):
        """linkHFOV(BaseSrcPanoImage self, BaseSrcPanoImage target)"""
        return _hsi.BaseSrcPanoImage_linkHFOV(self, *args)

    def linkResponseType(self, *args):
        """linkResponseType(BaseSrcPanoImage self, BaseSrcPanoImage target)"""
        return _hsi.BaseSrcPanoImage_linkResponseType(self, *args)

    def linkEMoRParams(self, *args):
        """linkEMoRParams(BaseSrcPanoImage self, BaseSrcPanoImage target)"""
        return _hsi.BaseSrcPanoImage_linkEMoRParams(self, *args)

    def linkExposureValue(self, *args):
        """linkExposureValue(BaseSrcPanoImage self, BaseSrcPanoImage target)"""
        return _hsi.BaseSrcPanoImage_linkExposureValue(self, *args)

    def linkGamma(self, *args):
        """linkGamma(BaseSrcPanoImage self, BaseSrcPanoImage target)"""
        return _hsi.BaseSrcPanoImage_linkGamma(self, *args)

    def linkWhiteBalanceRed(self, *args):
        """linkWhiteBalanceRed(BaseSrcPanoImage self, BaseSrcPanoImage target)"""
        return _hsi.BaseSrcPanoImage_linkWhiteBalanceRed(self, *args)

    def linkWhiteBalanceBlue(self, *args):
        """linkWhiteBalanceBlue(BaseSrcPanoImage self, BaseSrcPanoImage target)"""
        return _hsi.BaseSrcPanoImage_linkWhiteBalanceBlue(self, *args)

    def linkRoll(self, *args):
        """linkRoll(BaseSrcPanoImage self, BaseSrcPanoImage target)"""
        return _hsi.BaseSrcPanoImage_linkRoll(self, *args)

    def linkPitch(self, *args):
        """linkPitch(BaseSrcPanoImage self, BaseSrcPanoImage target)"""
        return _hsi.BaseSrcPanoImage_linkPitch(self, *args)

    def linkYaw(self, *args):
        """linkYaw(BaseSrcPanoImage self, BaseSrcPanoImage target)"""
        return _hsi.BaseSrcPanoImage_linkYaw(self, *args)

    def linkX(self, *args):
        """linkX(BaseSrcPanoImage self, BaseSrcPanoImage target)"""
        return _hsi.BaseSrcPanoImage_linkX(self, *args)

    def linkY(self, *args):
        """linkY(BaseSrcPanoImage self, BaseSrcPanoImage target)"""
        return _hsi.BaseSrcPanoImage_linkY(self, *args)

    def linkZ(self, *args):
        """linkZ(BaseSrcPanoImage self, BaseSrcPanoImage target)"""
        return _hsi.BaseSrcPanoImage_linkZ(self, *args)

    def linkStack(self, *args):
        """linkStack(BaseSrcPanoImage self, BaseSrcPanoImage target)"""
        return _hsi.BaseSrcPanoImage_linkStack(self, *args)

    def linkRadialDistortion(self, *args):
        """linkRadialDistortion(BaseSrcPanoImage self, BaseSrcPanoImage target)"""
        return _hsi.BaseSrcPanoImage_linkRadialDistortion(self, *args)

    def linkRadialDistortionRed(self, *args):
        """linkRadialDistortionRed(BaseSrcPanoImage self, BaseSrcPanoImage target)"""
        return _hsi.BaseSrcPanoImage_linkRadialDistortionRed(self, *args)

    def linkRadialDistortionBlue(self, *args):
        """linkRadialDistortionBlue(BaseSrcPanoImage self, BaseSrcPanoImage target)"""
        return _hsi.BaseSrcPanoImage_linkRadialDistortionBlue(self, *args)

    def linkRadialDistortionCenterShift(self, *args):
        """linkRadialDistortionCenterShift(BaseSrcPanoImage self, BaseSrcPanoImage target)"""
        return _hsi.BaseSrcPanoImage_linkRadialDistortionCenterShift(self, *args)

    def linkShear(self, *args):
        """linkShear(BaseSrcPanoImage self, BaseSrcPanoImage target)"""
        return _hsi.BaseSrcPanoImage_linkShear(self, *args)

    def linkCropMode(self, *args):
        """linkCropMode(BaseSrcPanoImage self, BaseSrcPanoImage target)"""
        return _hsi.BaseSrcPanoImage_linkCropMode(self, *args)

    def linkCropRect(self, *args):
        """linkCropRect(BaseSrcPanoImage self, BaseSrcPanoImage target)"""
        return _hsi.BaseSrcPanoImage_linkCropRect(self, *args)

    def linkAutoCenterCrop(self, *args):
        """linkAutoCenterCrop(BaseSrcPanoImage self, BaseSrcPanoImage target)"""
        return _hsi.BaseSrcPanoImage_linkAutoCenterCrop(self, *args)

    def linkVigCorrMode(self, *args):
        """linkVigCorrMode(BaseSrcPanoImage self, BaseSrcPanoImage target)"""
        return _hsi.BaseSrcPanoImage_linkVigCorrMode(self, *args)

    def linkFlatfieldFilename(self, *args):
        """linkFlatfieldFilename(BaseSrcPanoImage self, BaseSrcPanoImage target)"""
        return _hsi.BaseSrcPanoImage_linkFlatfieldFilename(self, *args)

    def linkRadialVigCorrCoeff(self, *args):
        """linkRadialVigCorrCoeff(BaseSrcPanoImage self, BaseSrcPanoImage target)"""
        return _hsi.BaseSrcPanoImage_linkRadialVigCorrCoeff(self, *args)

    def linkRadialVigCorrCenterShift(self, *args):
        """linkRadialVigCorrCenterShift(BaseSrcPanoImage self, BaseSrcPanoImage target)"""
        return _hsi.BaseSrcPanoImage_linkRadialVigCorrCenterShift(self, *args)

    def linkExifModel(self, *args):
        """linkExifModel(BaseSrcPanoImage self, BaseSrcPanoImage target)"""
        return _hsi.BaseSrcPanoImage_linkExifModel(self, *args)

    def linkExifMake(self, *args):
        """linkExifMake(BaseSrcPanoImage self, BaseSrcPanoImage target)"""
        return _hsi.BaseSrcPanoImage_linkExifMake(self, *args)

    def linkExifLens(self, *args):
        """linkExifLens(BaseSrcPanoImage self, BaseSrcPanoImage target)"""
        return _hsi.BaseSrcPanoImage_linkExifLens(self, *args)

    def linkExifCropFactor(self, *args):
        """linkExifCropFactor(BaseSrcPanoImage self, BaseSrcPanoImage target)"""
        return _hsi.BaseSrcPanoImage_linkExifCropFactor(self, *args)

    def linkExifFocalLength(self, *args):
        """linkExifFocalLength(BaseSrcPanoImage self, BaseSrcPanoImage target)"""
        return _hsi.BaseSrcPanoImage_linkExifFocalLength(self, *args)

    def linkExifOrientation(self, *args):
        """linkExifOrientation(BaseSrcPanoImage self, BaseSrcPanoImage target)"""
        return _hsi.BaseSrcPanoImage_linkExifOrientation(self, *args)

    def linkExifAperture(self, *args):
        """linkExifAperture(BaseSrcPanoImage self, BaseSrcPanoImage target)"""
        return _hsi.BaseSrcPanoImage_linkExifAperture(self, *args)

    def linkExifISO(self, *args):
        """linkExifISO(BaseSrcPanoImage self, BaseSrcPanoImage target)"""
        return _hsi.BaseSrcPanoImage_linkExifISO(self, *args)

    def linkExifDistance(self, *args):
        """linkExifDistance(BaseSrcPanoImage self, BaseSrcPanoImage target)"""
        return _hsi.BaseSrcPanoImage_linkExifDistance(self, *args)

    def linkExifFocalLength35(self, *args):
        """linkExifFocalLength35(BaseSrcPanoImage self, BaseSrcPanoImage target)"""
        return _hsi.BaseSrcPanoImage_linkExifFocalLength35(self, *args)

    def linkExifExposureTime(self, *args):
        """linkExifExposureTime(BaseSrcPanoImage self, BaseSrcPanoImage target)"""
        return _hsi.BaseSrcPanoImage_linkExifExposureTime(self, *args)

    def linkExifDate(self, *args):
        """linkExifDate(BaseSrcPanoImage self, BaseSrcPanoImage target)"""
        return _hsi.BaseSrcPanoImage_linkExifDate(self, *args)

    def linkExifExposureMode(self, *args):
        """linkExifExposureMode(BaseSrcPanoImage self, BaseSrcPanoImage target)"""
        return _hsi.BaseSrcPanoImage_linkExifExposureMode(self, *args)

    def linkMasks(self, *args):
        """linkMasks(BaseSrcPanoImage self, BaseSrcPanoImage target)"""
        return _hsi.BaseSrcPanoImage_linkMasks(self, *args)

    def linkActiveMasks(self, *args):
        """linkActiveMasks(BaseSrcPanoImage self, BaseSrcPanoImage target)"""
        return _hsi.BaseSrcPanoImage_linkActiveMasks(self, *args)

    def linkActive(self, *args):
        """linkActive(BaseSrcPanoImage self, BaseSrcPanoImage target)"""
        return _hsi.BaseSrcPanoImage_linkActive(self, *args)

    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 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 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 unlinkExifCropFactor(self):
        """unlinkExifCropFactor(BaseSrcPanoImage self)"""
        return _hsi.BaseSrcPanoImage_unlinkExifCropFactor(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 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 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 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 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 ExifCropFactorisLinked(self):
        """ExifCropFactorisLinked(BaseSrcPanoImage self) -> bool"""
        return _hsi.BaseSrcPanoImage_ExifCropFactorisLinked(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 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 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, *args):
        """FilenameisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_FilenameisLinkedWith(self, *args)

    def SizeisLinkedWith(self, *args):
        """SizeisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_SizeisLinkedWith(self, *args)

    def ProjectionisLinkedWith(self, *args):
        """ProjectionisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_ProjectionisLinkedWith(self, *args)

    def HFOVisLinkedWith(self, *args):
        """HFOVisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_HFOVisLinkedWith(self, *args)

    def ResponseTypeisLinkedWith(self, *args):
        """ResponseTypeisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_ResponseTypeisLinkedWith(self, *args)

    def EMoRParamsisLinkedWith(self, *args):
        """EMoRParamsisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_EMoRParamsisLinkedWith(self, *args)

    def ExposureValueisLinkedWith(self, *args):
        """ExposureValueisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_ExposureValueisLinkedWith(self, *args)

    def GammaisLinkedWith(self, *args):
        """GammaisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_GammaisLinkedWith(self, *args)

    def WhiteBalanceRedisLinkedWith(self, *args):
        """WhiteBalanceRedisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_WhiteBalanceRedisLinkedWith(self, *args)

    def WhiteBalanceBlueisLinkedWith(self, *args):
        """WhiteBalanceBlueisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_WhiteBalanceBlueisLinkedWith(self, *args)

    def RollisLinkedWith(self, *args):
        """RollisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_RollisLinkedWith(self, *args)

    def PitchisLinkedWith(self, *args):
        """PitchisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_PitchisLinkedWith(self, *args)

    def YawisLinkedWith(self, *args):
        """YawisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_YawisLinkedWith(self, *args)

    def XisLinkedWith(self, *args):
        """XisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_XisLinkedWith(self, *args)

    def YisLinkedWith(self, *args):
        """YisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_YisLinkedWith(self, *args)

    def ZisLinkedWith(self, *args):
        """ZisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_ZisLinkedWith(self, *args)

    def StackisLinkedWith(self, *args):
        """StackisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_StackisLinkedWith(self, *args)

    def RadialDistortionisLinkedWith(self, *args):
        """RadialDistortionisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_RadialDistortionisLinkedWith(self, *args)

    def RadialDistortionRedisLinkedWith(self, *args):
        """RadialDistortionRedisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_RadialDistortionRedisLinkedWith(self, *args)

    def RadialDistortionBlueisLinkedWith(self, *args):
        """RadialDistortionBlueisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_RadialDistortionBlueisLinkedWith(self, *args)

    def RadialDistortionCenterShiftisLinkedWith(self, *args):
        """RadialDistortionCenterShiftisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_RadialDistortionCenterShiftisLinkedWith(self, *args)

    def ShearisLinkedWith(self, *args):
        """ShearisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_ShearisLinkedWith(self, *args)

    def CropModeisLinkedWith(self, *args):
        """CropModeisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_CropModeisLinkedWith(self, *args)

    def CropRectisLinkedWith(self, *args):
        """CropRectisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_CropRectisLinkedWith(self, *args)

    def AutoCenterCropisLinkedWith(self, *args):
        """AutoCenterCropisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_AutoCenterCropisLinkedWith(self, *args)

    def VigCorrModeisLinkedWith(self, *args):
        """VigCorrModeisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_VigCorrModeisLinkedWith(self, *args)

    def FlatfieldFilenameisLinkedWith(self, *args):
        """FlatfieldFilenameisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_FlatfieldFilenameisLinkedWith(self, *args)

    def RadialVigCorrCoeffisLinkedWith(self, *args):
        """RadialVigCorrCoeffisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_RadialVigCorrCoeffisLinkedWith(self, *args)

    def RadialVigCorrCenterShiftisLinkedWith(self, *args):
        """RadialVigCorrCenterShiftisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_RadialVigCorrCenterShiftisLinkedWith(self, *args)

    def ExifModelisLinkedWith(self, *args):
        """ExifModelisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_ExifModelisLinkedWith(self, *args)

    def ExifMakeisLinkedWith(self, *args):
        """ExifMakeisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_ExifMakeisLinkedWith(self, *args)

    def ExifLensisLinkedWith(self, *args):
        """ExifLensisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_ExifLensisLinkedWith(self, *args)

    def ExifCropFactorisLinkedWith(self, *args):
        """ExifCropFactorisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_ExifCropFactorisLinkedWith(self, *args)

    def ExifFocalLengthisLinkedWith(self, *args):
        """ExifFocalLengthisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_ExifFocalLengthisLinkedWith(self, *args)

    def ExifOrientationisLinkedWith(self, *args):
        """ExifOrientationisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_ExifOrientationisLinkedWith(self, *args)

    def ExifApertureisLinkedWith(self, *args):
        """ExifApertureisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_ExifApertureisLinkedWith(self, *args)

    def ExifISOisLinkedWith(self, *args):
        """ExifISOisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_ExifISOisLinkedWith(self, *args)

    def ExifDistanceisLinkedWith(self, *args):
        """ExifDistanceisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_ExifDistanceisLinkedWith(self, *args)

    def ExifFocalLength35isLinkedWith(self, *args):
        """ExifFocalLength35isLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_ExifFocalLength35isLinkedWith(self, *args)

    def ExifExposureTimeisLinkedWith(self, *args):
        """ExifExposureTimeisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_ExifExposureTimeisLinkedWith(self, *args)

    def ExifDateisLinkedWith(self, *args):
        """ExifDateisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_ExifDateisLinkedWith(self, *args)

    def ExifExposureModeisLinkedWith(self, *args):
        """ExifExposureModeisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_ExifExposureModeisLinkedWith(self, *args)

    def MasksisLinkedWith(self, *args):
        """MasksisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_MasksisLinkedWith(self, *args)

    def ActiveMasksisLinkedWith(self, *args):
        """ActiveMasksisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_ActiveMasksisLinkedWith(self, *args)

    def ActiveisLinkedWith(self, *args):
        """ActiveisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_ActiveisLinkedWith(self, *args)

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
    __swig_destroy__ = _hsi.delete_SrcPanoImage
    __del__ = lambda self : None;
    def __init__(self, *args): 
        """
        __init__(HuginBase::SrcPanoImage self) -> SrcPanoImage
        __init__(HuginBase::SrcPanoImage self, std::string const & filename) -> SrcPanoImage
        """
        this = _hsi.new_SrcPanoImage(*args)
        try: self.this.append(this)
        except: self.this = this
    def hasEXIFread(self):
        """hasEXIFread(SrcPanoImage self) -> bool const"""
        return _hsi.SrcPanoImage_hasEXIFread(self)

    def resize(self, *args):
        """resize(SrcPanoImage self, Size2D size)"""
        return _hsi.SrcPanoImage_resize(self, *args)

    def isInside(self, *args):
        """
        isInside(SrcPanoImage self, Point2D p, bool ignoreMasks=False) -> bool
        isInside(SrcPanoImage self, Point2D p) -> bool
        """
        return _hsi.SrcPanoImage_isInside(self, *args)

    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, *args):
        """setCropMode(SrcPanoImage self, HuginBase::BaseSrcPanoImage::CropMode val)"""
        return _hsi.SrcPanoImage_setCropMode(self, *args)

    def isCircularCrop(self):
        """isCircularCrop(SrcPanoImage self) -> bool"""
        return _hsi.SrcPanoImage_isCircularCrop(self)

    def setSize(self, *args):
        """setSize(SrcPanoImage self, Size2D val)"""
        return _hsi.SrcPanoImage_setSize(self, *args)

    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, *args):
        """setExposure(SrcPanoImage self, double const & val)"""
        return _hsi.SrcPanoImage_setExposure(self, *args)

    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, *args):
        """getVar(SrcPanoImage self, std::string const & name) -> double"""
        return _hsi.SrcPanoImage_getVar(self, *args)

    def setVar(self, *args):
        """setVar(SrcPanoImage self, std::string const & name, double val)"""
        return _hsi.SrcPanoImage_setVar(self, *args)

    def getVariableMap(self):
        """getVariableMap(SrcPanoImage self) -> HuginBase::VariableMap"""
        return _hsi.SrcPanoImage_getVariableMap(self)

    def getExifDateTime(self, *args):
        """getExifDateTime(SrcPanoImage self, tm datetime) -> int const"""
        return _hsi.SrcPanoImage_getExifDateTime(self, *args)

    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, *args):
        """linkRadialVigCorrCoeff(SrcPanoImage self, SrcPanoImage target)"""
        return _hsi.SrcPanoImage_linkRadialVigCorrCoeff(self, *args)

    def linkRadialVigCorrCenterShift(self, *args):
        """linkRadialVigCorrCenterShift(SrcPanoImage self, SrcPanoImage target)"""
        return _hsi.SrcPanoImage_linkRadialVigCorrCenterShift(self, *args)

    def linkEMoRParams(self, *args):
        """linkEMoRParams(SrcPanoImage self, SrcPanoImage target)"""
        return _hsi.SrcPanoImage_linkEMoRParams(self, *args)

    def linkStack(self, *args):
        """linkStack(SrcPanoImage self, SrcPanoImage target)"""
        return _hsi.SrcPanoImage_linkStack(self, *args)

    def readEXIF(self, *args):
        """
        readEXIF(SrcPanoImage self, double & focalLength, double & cropFactor, bool applyEXIF, bool applyExposureValue) -> bool
        readEXIF(SrcPanoImage self, double & focalLength, double & cropFactor, double & eV, bool applyEXIF, bool applyExposureValue) -> bool
        """
        return _hsi.SrcPanoImage_readEXIF(self, *args)

    def calcHFOV(*args):
        """calcHFOV(HuginBase::SrcPanoImage::Projection proj, double fl, double crop, Size2D imageSize) -> double"""
        return _hsi.SrcPanoImage_calcHFOV(*args)

    if _newclass:calcHFOV = staticmethod(calcHFOV)
    __swig_getmethods__["calcHFOV"] = lambda x: calcHFOV
    def calcFocalLength(*args):
        """calcFocalLength(HuginBase::SrcPanoImage::Projection proj, double hfov, double crop, Size2D imageSize) -> double"""
        return _hsi.SrcPanoImage_calcFocalLength(*args)

    if _newclass:calcFocalLength = staticmethod(calcFocalLength)
    __swig_getmethods__["calcFocalLength"] = lambda x: calcFocalLength
    def calcCropFactor(*args):
        """calcCropFactor(HuginBase::SrcPanoImage::Projection proj, double hfov, double focalLength, Size2D imageSize) -> double"""
        return _hsi.SrcPanoImage_calcCropFactor(*args)

    if _newclass:calcCropFactor = staticmethod(calcCropFactor)
    __swig_getmethods__["calcCropFactor"] = lambda x: calcCropFactor
    def updateFocalLength(self, *args):
        """updateFocalLength(SrcPanoImage self, double newFocalLength)"""
        return _hsi.SrcPanoImage_updateFocalLength(self, *args)

    def updateCropFactor(self, *args):
        """updateCropFactor(SrcPanoImage self, double focalLength, double newCropFactor)"""
        return _hsi.SrcPanoImage_updateCropFactor(self, *args)

    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, *args):
        """addMask(SrcPanoImage self, MaskPolygon newMask)"""
        return _hsi.SrcPanoImage_addMask(self, *args)

    def addActiveMask(self, *args):
        """addActiveMask(SrcPanoImage self, MaskPolygon newMask)"""
        return _hsi.SrcPanoImage_addActiveMask(self, *args)

    def clearActiveMasks(self):
        """clearActiveMasks(SrcPanoImage self)"""
        return _hsi.SrcPanoImage_clearActiveMasks(self)

    def changeMaskType(self, *args):
        """changeMaskType(SrcPanoImage self, unsigned int index, HuginBase::MaskPolygon::MaskType newType)"""
        return _hsi.SrcPanoImage_changeMaskType(self, *args)

    def deleteMask(self, *args):
        """deleteMask(SrcPanoImage self, unsigned int index)"""
        return _hsi.SrcPanoImage_deleteMask(self, *args)

    def deleteAllMasks(self):
        """deleteAllMasks(SrcPanoImage self)"""
        return _hsi.SrcPanoImage_deleteAllMasks(self)

    def printMaskLines(self, *args):
        """printMaskLines(SrcPanoImage self, ostream o, unsigned int newImgNr)"""
        return _hsi.SrcPanoImage_printMaskLines(self, *args)

    def isInsideMasks(self, *args):
        """isInsideMasks(SrcPanoImage self, Point2D p) -> bool"""
        return _hsi.SrcPanoImage_isInsideMasks(self, *args)

SrcPanoImage_swigregister = _hsi.SrcPanoImage_swigregister
SrcPanoImage_swigregister(SrcPanoImage)

def SrcPanoImage_calcHFOV(*args):
  """SrcPanoImage_calcHFOV(HuginBase::SrcPanoImage::Projection proj, double fl, double crop, Size2D imageSize) -> double"""
  return _hsi.SrcPanoImage_calcHFOV(*args)

def SrcPanoImage_calcFocalLength(*args):
  """SrcPanoImage_calcFocalLength(HuginBase::SrcPanoImage::Projection proj, double hfov, double crop, Size2D imageSize) -> double"""
  return _hsi.SrcPanoImage_calcFocalLength(*args)

def SrcPanoImage_calcCropFactor(*args):
  """SrcPanoImage_calcCropFactor(HuginBase::SrcPanoImage::Projection proj, double hfov, double focalLength, Size2D imageSize) -> double"""
  return _hsi.SrcPanoImage_calcCropFactor(*args)

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, *args):
        """__eq__(ControlPoint self, ControlPoint o) -> bool"""
        return _hsi.ControlPoint___eq__(self, *args)

    def getModeName(self, *args):
        """getModeName(ControlPoint self, HuginBase::ControlPoint::OptimizeMode mode) -> std::string const &"""
        return _hsi.ControlPoint_getModeName(self, *args)

    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, *args):
        """setProjection(Lens self, HuginBase::Lens::LensProjectionFormat l)"""
        return _hsi.Lens_setProjection(self, *args)

    def getHFOV(self):
        """getHFOV(Lens self) -> double"""
        return _hsi.Lens_getHFOV(self)

    def setHFOV(self, *args):
        """setHFOV(Lens self, double d)"""
        return _hsi.Lens_setHFOV(self, *args)

    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, *args):
        """setCropFactor(Lens self, double newCropFactor)"""
        return _hsi.Lens_setCropFactor(self, *args)

    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, *args):
        """setEV(Lens self, double ev)"""
        return _hsi.Lens_setEV(self, *args)

    def getImageSize(self):
        """getImageSize(Lens self) -> Size2D"""
        return _hsi.Lens_getImageSize(self)

    def setImageSize(self, *args):
        """setImageSize(Lens self, Size2D sz)"""
        return _hsi.Lens_setImageSize(self, *args)

    def update(self, *args):
        """update(Lens self, Lens l)"""
        return _hsi.Lens_update(self, *args)

    __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, *args):
        """isInside(MaskPolygon self, FDiff2D p) -> bool"""
        return _hsi.MaskPolygon_isInside(self, *args)

    def getWindingNumber(self, *args):
        """getWindingNumber(MaskPolygon self, FDiff2D p) -> int"""
        return _hsi.MaskPolygon_getWindingNumber(self, *args)

    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, *args):
        """setMaskType(MaskPolygon self, HuginBase::MaskPolygon::MaskType const newType)"""
        return _hsi.MaskPolygon_setMaskType(self, *args)

    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, *args):
        """setMaskPolygon(MaskPolygon self, HuginBase::VectorPolygon const newMask)"""
        return _hsi.MaskPolygon_setMaskPolygon(self, *args)

    def getImgNr(self):
        """getImgNr(MaskPolygon self) -> unsigned int"""
        return _hsi.MaskPolygon_getImgNr(self)

    def setImgNr(self, *args):
        """setImgNr(MaskPolygon self, unsigned int const newImgNr)"""
        return _hsi.MaskPolygon_setImgNr(self, *args)

    def setInverted(self, *args):
        """setInverted(MaskPolygon self, bool const inverted)"""
        return _hsi.MaskPolygon_setInverted(self, *args)

    def isInverted(self):
        """isInverted(MaskPolygon self) -> bool"""
        return _hsi.MaskPolygon_isInverted(self)

    def addPoint(self, *args):
        """addPoint(MaskPolygon self, FDiff2D p)"""
        return _hsi.MaskPolygon_addPoint(self, *args)

    def insertPoint(self, *args):
        """insertPoint(MaskPolygon self, unsigned int const index, FDiff2D p)"""
        return _hsi.MaskPolygon_insertPoint(self, *args)

    def removePoint(self, *args):
        """removePoint(MaskPolygon self, unsigned int const index)"""
        return _hsi.MaskPolygon_removePoint(self, *args)

    def movePointTo(self, *args):
        """movePointTo(MaskPolygon self, unsigned int const index, FDiff2D p)"""
        return _hsi.MaskPolygon_movePointTo(self, *args)

    def movePointBy(self, *args):
        """movePointBy(MaskPolygon self, unsigned int const index, FDiff2D diff)"""
        return _hsi.MaskPolygon_movePointBy(self, *args)

    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, *args):
        """transformPolygon(MaskPolygon self, Transform trans)"""
        return _hsi.MaskPolygon_transformPolygon(self, *args)

    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, *args):
        """rotate90(MaskPolygon self, bool clockwise, unsigned int maskWidth, unsigned int maskHeight)"""
        return _hsi.MaskPolygon_rotate90(self, *args)

    def subSample(self, *args):
        """subSample(MaskPolygon self, double const max_distance)"""
        return _hsi.MaskPolygon_subSample(self, *args)

    def FindPointNearPos(self, *args):
        """FindPointNearPos(MaskPolygon self, FDiff2D p, double const tol) -> unsigned int"""
        return _hsi.MaskPolygon_FindPointNearPos(self, *args)

    def __eq__(self, *args):
        """__eq__(MaskPolygon self, MaskPolygon otherPoly) -> bool const"""
        return _hsi.MaskPolygon___eq__(self, *args)

    def parsePolygonString(self, *args):
        """parsePolygonString(MaskPolygon self, std::string const polygonStr) -> bool"""
        return _hsi.MaskPolygon_parsePolygonString(self, *args)

    def printPolygonLine(self, *args):
        """printPolygonLine(MaskPolygon self, ostream o, unsigned int const newImgNr)"""
        return _hsi.MaskPolygon_printPolygonLine(self, *args)

    __swig_destroy__ = _hsi.delete_MaskPolygon
    __del__ = lambda self : None;
MaskPolygon_swigregister = _hsi.MaskPolygon_swigregister
MaskPolygon_swigregister(MaskPolygon)
maskOffset = cvar.maskOffset

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, *args):
        """getSubset(Panorama self, HuginBase::UIntSet const & imgs) -> Panorama"""
        return _hsi.Panorama_getSubset(self, *args)

    def duplicate(self):
        """duplicate(Panorama self) -> Panorama"""
        return _hsi.Panorama_duplicate(self)

    def getNewSubset(self, *args):
        """getNewSubset(Panorama self, HuginBase::UIntSet const & imgs) -> PanoramaData"""
        return _hsi.Panorama_getNewSubset(self, *args)

    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, *args):
        """getImage(Panorama self, std::size_t nr) -> SrcPanoImage"""
        return _hsi.Panorama_getImage(self, *args)

    def setImage(self, *args):
        """setImage(Panorama self, std::size_t nr, SrcPanoImage img)"""
        return _hsi.Panorama_setImage(self, *args)

    def addImage(self, *args):
        """addImage(Panorama self, SrcPanoImage img) -> unsigned int"""
        return _hsi.Panorama_addImage(self, *args)

    def mergePanorama(self, *args):
        """mergePanorama(Panorama self, Panorama newPano)"""
        return _hsi.Panorama_mergePanorama(self, *args)

    def removeImage(self, *args):
        """removeImage(Panorama self, unsigned int nr)"""
        return _hsi.Panorama_removeImage(self, *args)

    def swapImages(self, *args):
        """swapImages(Panorama self, unsigned int img1, unsigned int img2)"""
        return _hsi.Panorama_swapImages(self, *args)

    def moveImage(self, *args):
        """moveImage(Panorama self, size_t img1, size_t img2)"""
        return _hsi.Panorama_moveImage(self, *args)

    def getSrcImage(self, *args):
        """getSrcImage(Panorama self, unsigned int imgNr) -> SrcPanoImage"""
        return _hsi.Panorama_getSrcImage(self, *args)

    def setSrcImage(self, *args):
        """setSrcImage(Panorama self, unsigned int nr, SrcPanoImage img)"""
        return _hsi.Panorama_setSrcImage(self, *args)

    def setImageFilename(self, *args):
        """setImageFilename(Panorama self, unsigned int img, std::string const & fname)"""
        return _hsi.Panorama_setImageFilename(self, *args)

    def activateImage(self, *args):
        """
        activateImage(Panorama self, unsigned int imgNr, bool active=True)
        activateImage(Panorama self, unsigned int imgNr)
        """
        return _hsi.Panorama_activateImage(self, *args)

    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, *args):
        """getCtrlPoint(Panorama self, std::size_t nr) -> ControlPoint"""
        return _hsi.Panorama_getCtrlPoint(self, *args)

    def getCtrlPoints(self):
        """getCtrlPoints(Panorama self) -> HuginBase::CPVector const &"""
        return _hsi.Panorama_getCtrlPoints(self)

    def getCtrlPointsForImage(self, *args):
        """getCtrlPointsForImage(Panorama self, unsigned int imgNr) -> std::vector< unsigned int,std::allocator< unsigned int > >"""
        return _hsi.Panorama_getCtrlPointsForImage(self, *args)

    def getCtrlPointsVectorForImage(self, *args):
        """getCtrlPointsVectorForImage(Panorama self, unsigned int imgNr) -> HuginBase::CPointVector"""
        return _hsi.Panorama_getCtrlPointsVectorForImage(self, *args)

    def setCtrlPoints(self, *args):
        """setCtrlPoints(Panorama self, HuginBase::CPVector const & points)"""
        return _hsi.Panorama_setCtrlPoints(self, *args)

    def addCtrlPoint(self, *args):
        """addCtrlPoint(Panorama self, ControlPoint point) -> unsigned int"""
        return _hsi.Panorama_addCtrlPoint(self, *args)

    def removeCtrlPoint(self, *args):
        """removeCtrlPoint(Panorama self, unsigned int pNr)"""
        return _hsi.Panorama_removeCtrlPoint(self, *args)

    def removeDuplicateCtrlPoints(self):
        """removeDuplicateCtrlPoints(Panorama self)"""
        return _hsi.Panorama_removeDuplicateCtrlPoints(self)

    def changeControlPoint(self, *args):
        """changeControlPoint(Panorama self, unsigned int pNr, ControlPoint point)"""
        return _hsi.Panorama_changeControlPoint(self, *args)

    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, *args):
        """getImageVariables(Panorama self, unsigned int imgNr) -> HuginBase::VariableMap const"""
        return _hsi.Panorama_getImageVariables(self, *args)

    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, *args):
        """updateVariable(Panorama self, unsigned int imgNr, Variable var)"""
        return _hsi.Panorama_updateVariable(self, *args)

    def UpdateFocalLength(self, *args):
        """UpdateFocalLength(Panorama self, HuginBase::UIntSet imgs, double newFocalLength)"""
        return _hsi.Panorama_UpdateFocalLength(self, *args)

    def UpdateCropFactor(self, *args):
        """UpdateCropFactor(Panorama self, HuginBase::UIntSet imgs, double newCropFactor)"""
        return _hsi.Panorama_UpdateCropFactor(self, *args)

    def linkImageVariableFilename(self, *args):
        """linkImageVariableFilename(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableFilename(self, *args)

    def linkImageVariableSize(self, *args):
        """linkImageVariableSize(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableSize(self, *args)

    def linkImageVariableProjection(self, *args):
        """linkImageVariableProjection(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableProjection(self, *args)

    def linkImageVariableHFOV(self, *args):
        """linkImageVariableHFOV(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableHFOV(self, *args)

    def linkImageVariableResponseType(self, *args):
        """linkImageVariableResponseType(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableResponseType(self, *args)

    def linkImageVariableEMoRParams(self, *args):
        """linkImageVariableEMoRParams(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableEMoRParams(self, *args)

    def linkImageVariableExposureValue(self, *args):
        """linkImageVariableExposureValue(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableExposureValue(self, *args)

    def linkImageVariableGamma(self, *args):
        """linkImageVariableGamma(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableGamma(self, *args)

    def linkImageVariableWhiteBalanceRed(self, *args):
        """linkImageVariableWhiteBalanceRed(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableWhiteBalanceRed(self, *args)

    def linkImageVariableWhiteBalanceBlue(self, *args):
        """linkImageVariableWhiteBalanceBlue(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableWhiteBalanceBlue(self, *args)

    def linkImageVariableRoll(self, *args):
        """linkImageVariableRoll(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableRoll(self, *args)

    def linkImageVariablePitch(self, *args):
        """linkImageVariablePitch(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariablePitch(self, *args)

    def linkImageVariableYaw(self, *args):
        """linkImageVariableYaw(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableYaw(self, *args)

    def linkImageVariableX(self, *args):
        """linkImageVariableX(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableX(self, *args)

    def linkImageVariableY(self, *args):
        """linkImageVariableY(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableY(self, *args)

    def linkImageVariableZ(self, *args):
        """linkImageVariableZ(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableZ(self, *args)

    def linkImageVariableStack(self, *args):
        """linkImageVariableStack(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableStack(self, *args)

    def linkImageVariableRadialDistortion(self, *args):
        """linkImageVariableRadialDistortion(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableRadialDistortion(self, *args)

    def linkImageVariableRadialDistortionRed(self, *args):
        """linkImageVariableRadialDistortionRed(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableRadialDistortionRed(self, *args)

    def linkImageVariableRadialDistortionBlue(self, *args):
        """linkImageVariableRadialDistortionBlue(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableRadialDistortionBlue(self, *args)

    def linkImageVariableRadialDistortionCenterShift(self, *args):
        """linkImageVariableRadialDistortionCenterShift(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableRadialDistortionCenterShift(self, *args)

    def linkImageVariableShear(self, *args):
        """linkImageVariableShear(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableShear(self, *args)

    def linkImageVariableCropMode(self, *args):
        """linkImageVariableCropMode(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableCropMode(self, *args)

    def linkImageVariableCropRect(self, *args):
        """linkImageVariableCropRect(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableCropRect(self, *args)

    def linkImageVariableAutoCenterCrop(self, *args):
        """linkImageVariableAutoCenterCrop(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableAutoCenterCrop(self, *args)

    def linkImageVariableVigCorrMode(self, *args):
        """linkImageVariableVigCorrMode(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableVigCorrMode(self, *args)

    def linkImageVariableFlatfieldFilename(self, *args):
        """linkImageVariableFlatfieldFilename(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableFlatfieldFilename(self, *args)

    def linkImageVariableRadialVigCorrCoeff(self, *args):
        """linkImageVariableRadialVigCorrCoeff(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableRadialVigCorrCoeff(self, *args)

    def linkImageVariableRadialVigCorrCenterShift(self, *args):
        """linkImageVariableRadialVigCorrCenterShift(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableRadialVigCorrCenterShift(self, *args)

    def linkImageVariableExifModel(self, *args):
        """linkImageVariableExifModel(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableExifModel(self, *args)

    def linkImageVariableExifMake(self, *args):
        """linkImageVariableExifMake(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableExifMake(self, *args)

    def linkImageVariableExifLens(self, *args):
        """linkImageVariableExifLens(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableExifLens(self, *args)

    def linkImageVariableExifCropFactor(self, *args):
        """linkImageVariableExifCropFactor(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableExifCropFactor(self, *args)

    def linkImageVariableExifFocalLength(self, *args):
        """linkImageVariableExifFocalLength(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableExifFocalLength(self, *args)

    def linkImageVariableExifOrientation(self, *args):
        """linkImageVariableExifOrientation(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableExifOrientation(self, *args)

    def linkImageVariableExifAperture(self, *args):
        """linkImageVariableExifAperture(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableExifAperture(self, *args)

    def linkImageVariableExifISO(self, *args):
        """linkImageVariableExifISO(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableExifISO(self, *args)

    def linkImageVariableExifDistance(self, *args):
        """linkImageVariableExifDistance(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableExifDistance(self, *args)

    def linkImageVariableExifFocalLength35(self, *args):
        """linkImageVariableExifFocalLength35(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableExifFocalLength35(self, *args)

    def linkImageVariableExifExposureTime(self, *args):
        """linkImageVariableExifExposureTime(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableExifExposureTime(self, *args)

    def linkImageVariableExifDate(self, *args):
        """linkImageVariableExifDate(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableExifDate(self, *args)

    def linkImageVariableExifExposureMode(self, *args):
        """linkImageVariableExifExposureMode(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableExifExposureMode(self, *args)

    def linkImageVariableMasks(self, *args):
        """linkImageVariableMasks(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableMasks(self, *args)

    def linkImageVariableActiveMasks(self, *args):
        """linkImageVariableActiveMasks(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableActiveMasks(self, *args)

    def linkImageVariableActive(self, *args):
        """linkImageVariableActive(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableActive(self, *args)

    def unlinkImageVariableFilename(self, *args):
        """unlinkImageVariableFilename(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableFilename(self, *args)

    def unlinkImageVariableSize(self, *args):
        """unlinkImageVariableSize(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableSize(self, *args)

    def unlinkImageVariableProjection(self, *args):
        """unlinkImageVariableProjection(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableProjection(self, *args)

    def unlinkImageVariableHFOV(self, *args):
        """unlinkImageVariableHFOV(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableHFOV(self, *args)

    def unlinkImageVariableResponseType(self, *args):
        """unlinkImageVariableResponseType(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableResponseType(self, *args)

    def unlinkImageVariableEMoRParams(self, *args):
        """unlinkImageVariableEMoRParams(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableEMoRParams(self, *args)

    def unlinkImageVariableExposureValue(self, *args):
        """unlinkImageVariableExposureValue(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableExposureValue(self, *args)

    def unlinkImageVariableGamma(self, *args):
        """unlinkImageVariableGamma(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableGamma(self, *args)

    def unlinkImageVariableWhiteBalanceRed(self, *args):
        """unlinkImageVariableWhiteBalanceRed(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableWhiteBalanceRed(self, *args)

    def unlinkImageVariableWhiteBalanceBlue(self, *args):
        """unlinkImageVariableWhiteBalanceBlue(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableWhiteBalanceBlue(self, *args)

    def unlinkImageVariableRoll(self, *args):
        """unlinkImageVariableRoll(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableRoll(self, *args)

    def unlinkImageVariablePitch(self, *args):
        """unlinkImageVariablePitch(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariablePitch(self, *args)

    def unlinkImageVariableYaw(self, *args):
        """unlinkImageVariableYaw(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableYaw(self, *args)

    def unlinkImageVariableX(self, *args):
        """unlinkImageVariableX(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableX(self, *args)

    def unlinkImageVariableY(self, *args):
        """unlinkImageVariableY(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableY(self, *args)

    def unlinkImageVariableZ(self, *args):
        """unlinkImageVariableZ(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableZ(self, *args)

    def unlinkImageVariableStack(self, *args):
        """unlinkImageVariableStack(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableStack(self, *args)

    def unlinkImageVariableRadialDistortion(self, *args):
        """unlinkImageVariableRadialDistortion(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableRadialDistortion(self, *args)

    def unlinkImageVariableRadialDistortionRed(self, *args):
        """unlinkImageVariableRadialDistortionRed(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableRadialDistortionRed(self, *args)

    def unlinkImageVariableRadialDistortionBlue(self, *args):
        """unlinkImageVariableRadialDistortionBlue(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableRadialDistortionBlue(self, *args)

    def unlinkImageVariableRadialDistortionCenterShift(self, *args):
        """unlinkImageVariableRadialDistortionCenterShift(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableRadialDistortionCenterShift(self, *args)

    def unlinkImageVariableShear(self, *args):
        """unlinkImageVariableShear(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableShear(self, *args)

    def unlinkImageVariableCropMode(self, *args):
        """unlinkImageVariableCropMode(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableCropMode(self, *args)

    def unlinkImageVariableCropRect(self, *args):
        """unlinkImageVariableCropRect(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableCropRect(self, *args)

    def unlinkImageVariableAutoCenterCrop(self, *args):
        """unlinkImageVariableAutoCenterCrop(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableAutoCenterCrop(self, *args)

    def unlinkImageVariableVigCorrMode(self, *args):
        """unlinkImageVariableVigCorrMode(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableVigCorrMode(self, *args)

    def unlinkImageVariableFlatfieldFilename(self, *args):
        """unlinkImageVariableFlatfieldFilename(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableFlatfieldFilename(self, *args)

    def unlinkImageVariableRadialVigCorrCoeff(self, *args):
        """unlinkImageVariableRadialVigCorrCoeff(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableRadialVigCorrCoeff(self, *args)

    def unlinkImageVariableRadialVigCorrCenterShift(self, *args):
        """unlinkImageVariableRadialVigCorrCenterShift(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableRadialVigCorrCenterShift(self, *args)

    def unlinkImageVariableExifModel(self, *args):
        """unlinkImageVariableExifModel(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableExifModel(self, *args)

    def unlinkImageVariableExifMake(self, *args):
        """unlinkImageVariableExifMake(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableExifMake(self, *args)

    def unlinkImageVariableExifLens(self, *args):
        """unlinkImageVariableExifLens(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableExifLens(self, *args)

    def unlinkImageVariableExifCropFactor(self, *args):
        """unlinkImageVariableExifCropFactor(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableExifCropFactor(self, *args)

    def unlinkImageVariableExifFocalLength(self, *args):
        """unlinkImageVariableExifFocalLength(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableExifFocalLength(self, *args)

    def unlinkImageVariableExifOrientation(self, *args):
        """unlinkImageVariableExifOrientation(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableExifOrientation(self, *args)

    def unlinkImageVariableExifAperture(self, *args):
        """unlinkImageVariableExifAperture(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableExifAperture(self, *args)

    def unlinkImageVariableExifISO(self, *args):
        """unlinkImageVariableExifISO(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableExifISO(self, *args)

    def unlinkImageVariableExifDistance(self, *args):
        """unlinkImageVariableExifDistance(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableExifDistance(self, *args)

    def unlinkImageVariableExifFocalLength35(self, *args):
        """unlinkImageVariableExifFocalLength35(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableExifFocalLength35(self, *args)

    def unlinkImageVariableExifExposureTime(self, *args):
        """unlinkImageVariableExifExposureTime(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableExifExposureTime(self, *args)

    def unlinkImageVariableExifDate(self, *args):
        """unlinkImageVariableExifDate(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableExifDate(self, *args)

    def unlinkImageVariableExifExposureMode(self, *args):
        """unlinkImageVariableExifExposureMode(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableExifExposureMode(self, *args)

    def unlinkImageVariableMasks(self, *args):
        """unlinkImageVariableMasks(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableMasks(self, *args)

    def unlinkImageVariableActiveMasks(self, *args):
        """unlinkImageVariableActiveMasks(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableActiveMasks(self, *args)

    def unlinkImageVariableActive(self, *args):
        """unlinkImageVariableActive(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableActive(self, *args)

    def updateWhiteBalance(self, *args):
        """updateWhiteBalance(Panorama self, double redFactor, double blueFactor)"""
        return _hsi.Panorama_updateWhiteBalance(self, *args)

    def getOptimizeVector(self):
        """getOptimizeVector(Panorama self) -> OptimizeVector"""
        return _hsi.Panorama_getOptimizeVector(self)

    def setOptimizeVector(self, *args):
        """setOptimizeVector(Panorama self, OptimizeVector optvec)"""
        return _hsi.Panorama_setOptimizeVector(self, *args)

    def getOptimizerSwitch(self):
        """getOptimizerSwitch(Panorama self) -> int const"""
        return _hsi.Panorama_getOptimizerSwitch(self)

    def setOptimizerSwitch(self, *args):
        """setOptimizerSwitch(Panorama self, int const newSwitch)"""
        return _hsi.Panorama_setOptimizerSwitch(self, *args)

    def getPhotometricOptimizerSwitch(self):
        """getPhotometricOptimizerSwitch(Panorama self) -> int const"""
        return _hsi.Panorama_getPhotometricOptimizerSwitch(self)

    def setPhotometricOptimizerSwitch(self, *args):
        """setPhotometricOptimizerSwitch(Panorama self, int const newSwitch)"""
        return _hsi.Panorama_setPhotometricOptimizerSwitch(self, *args)

    def getOptions(self):
        """getOptions(Panorama self) -> PanoramaOptions"""
        return _hsi.Panorama_getOptions(self)

    def setOptions(self, *args):
        """setOptions(Panorama self, PanoramaOptions opt)"""
        return _hsi.Panorama_setOptions(self, *args)

    def parseOptimizerScript(self, *args):
        """
        parseOptimizerScript(Panorama self, istream i, HuginBase::UIntSet const & imgs, HuginBase::VariableMapVector & imgVars, 
            HuginBase::CPVector & ctrlPoints)
        """
        return _hsi.Panorama_parseOptimizerScript(self, *args)

    def printPanoramaScript(self, *args):
        """
        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, *args)

    def printStitcherScript(self, *args):
        """printStitcherScript(Panorama self, ostream o, PanoramaOptions target, HuginBase::UIntSet const & imgs)"""
        return _hsi.Panorama_printStitcherScript(self, *args)

    def addObserver(self, *args):
        """addObserver(Panorama self, PanoramaObserver o)"""
        return _hsi.Panorama_addObserver(self, *args)

    def removeObserver(self, *args):
        """removeObserver(Panorama self, PanoramaObserver observer) -> bool"""
        return _hsi.Panorama_removeObserver(self, *args)

    def clearObservers(self):
        """clearObservers(Panorama self)"""
        return _hsi.Panorama_clearObservers(self)

    def changeFinished(self, *args):
        """
        changeFinished(Panorama self, bool keepDirty)
        changeFinished(Panorama self)
        """
        return _hsi.Panorama_changeFinished(self, *args)

    def imageChanged(self, *args):
        """imageChanged(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_imageChanged(self, *args)

    def updateMasksForImage(self, *args):
        """updateMasksForImage(Panorama self, unsigned int imgNr, HuginBase::MaskPolygonVector newMasks)"""
        return _hsi.Panorama_updateMasksForImage(self, *args)

    def updateMasks(self, convertPosMaskToNeg=False):
        """
        updateMasks(Panorama self, bool convertPosMaskToNeg=False)
        updateMasks(Panorama self)
        """
        return _hsi.Panorama_updateMasks(self, convertPosMaskToNeg)

    def transferMask(self, *args):
        """transferMask(Panorama self, MaskPolygon mask, unsigned int imgNr, HuginBase::UIntSet const targetImgs)"""
        return _hsi.Panorama_transferMask(self, *args)

    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, *args):
        """checkRefOptStatus(Panorama self, bool & linkRefImgsYaw, bool & linkRefImgsPitch, bool & linkRefImgsRoll)"""
        return _hsi.Panorama_checkRefOptStatus(self, *args)

    def getNewMemento(self):
        """getNewMemento(Panorama self) -> PanoramaDataMemento"""
        return _hsi.Panorama_getNewMemento(self)

    def setMementoToCopyOf(self, *args):
        """setMementoToCopyOf(Panorama self, PanoramaDataMemento memento) -> bool"""
        return _hsi.Panorama_setMementoToCopyOf(self, *args)

    def getMemento(self):
        """getMemento(Panorama self) -> PanoramaMemento"""
        return _hsi.Panorama_getMemento(self)

    def setMemento(self, *args):
        """setMemento(Panorama self, PanoramaMemento memento)"""
        return _hsi.Panorama_setMemento(self, *args)

    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, *args):
        """
        readData(Panorama self, istream dataInput, std::string documentType="") -> AppBase::DocumentData::ReadWriteError
        readData(Panorama self, istream dataInput) -> AppBase::DocumentData::ReadWriteError
        """
        return _hsi.Panorama_readData(self, *args)

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

    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, *args):
        """setFilePrefix(Panorama self, std::string prefix)"""
        return _hsi.Panorama_setFilePrefix(self, *args)

    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=vigra::Diff2D(0,0))
        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=vigra::Diff2D(0,0))
        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, *args):
        """transformImgCoordPartial(Transform self, double & x_dest, double & y_dest, double x_src, double y_src) -> bool"""
        return _hsi.Transform_transformImgCoordPartial(self, *args)

    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, *args):
        """emitGLSL(Transform self, std::ostringstream & oss) -> bool"""
        return _hsi.Transform_emitGLSL(self, *args)

Transform_swigregister = _hsi.Transform_swigregister
Transform_swigregister(Transform)

class AlignInfoWrap(_object):
    """Proxy of C++ HuginBase::PTools::AlignInfoWrap class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, AlignInfoWrap, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, AlignInfoWrap, name)
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(HuginBase::PTools::AlignInfoWrap self) -> AlignInfoWrap"""
        this = _hsi.new_AlignInfoWrap()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _hsi.delete_AlignInfoWrap
    __del__ = lambda self : None;
    def setInfo(self, *args):
        """setInfo(AlignInfoWrap self, PanoramaData pano) -> bool"""
        return _hsi.AlignInfoWrap_setInfo(self, *args)

    def setGlobal(self):
        """setGlobal(AlignInfoWrap self)"""
        return _hsi.AlignInfoWrap_setGlobal(self)

    def getVariables(self):
        """getVariables(AlignInfoWrap self) -> HuginBase::VariableMapVector"""
        return _hsi.AlignInfoWrap_getVariables(self)

    def getCtrlPoints(self):
        """getCtrlPoints(AlignInfoWrap self) -> HuginBase::CPVector"""
        return _hsi.AlignInfoWrap_getCtrlPoints(self)

AlignInfoWrap_swigregister = _hsi.AlignInfoWrap_swigregister
AlignInfoWrap_swigregister(AlignInfoWrap)


def setDestImage(*args):
  """
    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(*args)

def setFullImage(*args):
  """
    setFullImage(Image & image, vigra::Diff2D size, unsigned char * imageData, HuginBase::VariableMap const & vars, 
        HuginBase::Lens::LensProjectionFormat const format, bool correctDistortions)
    """
  return _hsi.setFullImage(*args)

def createAdjustPrefs(*args):
  """createAdjustPrefs(aPrefs & p, TrformStr & transf)"""
  return _hsi.createAdjustPrefs(*args)

def setAdjustSrcImg(*args):
  """
    setAdjustSrcImg(TrformStr & trf, aPrefs & ap, int width, int height, unsigned char * imageData, HuginBase::VariableMap const & vars, 
        HuginBase::Lens::LensProjectionFormat const format, 
        bool correctDistortions)
    """
  return _hsi.setAdjustSrcImg(*args)

def setAdjustDestImg(*args):
  """setAdjustDestImg(TrformStr & trf, aPrefs & ap, int width, int height, unsigned char * imageData, PanoramaOptions opts)"""
  return _hsi.setAdjustDestImg(*args)

def createAdjustTrform(*args):
  """createAdjustTrform(TrformStr & trf)"""
  return _hsi.createAdjustTrform(*args)

def freeTrform(*args):
  """freeTrform(TrformStr & trf)"""
  return _hsi.freeTrform(*args)

def freeImage(*args):
  """freeImage(Image & img)"""
  return _hsi.freeImage(*args)

def setOptVars(*args):
  """setOptVars(optVars & opt, std::set< std::string,std::less< std::string >,std::allocator< std::string > > const & optvars)"""
  return _hsi.setOptVars(*args)

def GetAlignInfoVariables(*args):
  """GetAlignInfoVariables(AlignInfo const & gl) -> HuginBase::VariableMapVector"""
  return _hsi.GetAlignInfoVariables(*args)

def GetAlignInfoCtrlPoints(*args):
  """GetAlignInfoCtrlPoints(AlignInfo const & gl) -> HuginBase::CPVector"""
  return _hsi.GetAlignInfoCtrlPoints(*args)

def optimize(*args):
  """
    optimize(PanoramaData pano, char const * script=None) -> unsigned int
    optimize(PanoramaData pano) -> unsigned int
    """
  return _hsi.optimize(*args)

def calcCtrlPointErrors(*args):
  """calcCtrlPointErrors(PanoramaData pano)"""
  return _hsi.calcCtrlPointErrors(*args)
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, *args): 
        """
        __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(*args)
        try: self.this.append(this)
        except: self.this = this
    def createMakefile(*args):
        """
        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(*args)

    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(*args):
  """
    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(*args)

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=-1) -> 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(*args):
        """
        calcCtrlPntsErrorStats(PanoramaData pano, double & min, double & max, double & mean, double & var, int const & imgNr=-1)
        calcCtrlPntsErrorStats(PanoramaData pano, double & min, double & max, double & mean, double & var)
        """
        return _hsi.CalculateCPStatisticsError_calcCtrlPntsErrorStats(*args)

    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(*args):
  """
    calcCtrlPntsErrorStats(PanoramaData pano, double & min, double & max, double & mean, double & var, int const & imgNr=-1)
    CalculateCPStatisticsError_calcCtrlPntsErrorStats(PanoramaData pano, double & min, double & max, double & mean, double & var)
    """
  return _hsi.CalculateCPStatisticsError_calcCtrlPntsErrorStats(*args)

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=-1) -> 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(*args):
        """
        calcCtrlPntsRadiStats(PanoramaData pano, double & min, double & max, double & mean, double & var, double & q10, 
            double & q90, int const & imgNr=-1)
        calcCtrlPntsRadiStats(PanoramaData pano, double & min, double & max, double & mean, double & var, double & q10, 
            double & q90)
        """
        return _hsi.CalculateCPStatisticsRadial_calcCtrlPntsRadiStats(*args)

    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(*args):
  """
    calcCtrlPntsRadiStats(PanoramaData pano, double & min, double & max, double & mean, double & var, double & q10, 
        double & q90, int const & imgNr=-1)
    CalculateCPStatisticsRadial_calcCtrlPntsRadiStats(PanoramaData pano, double & min, double & max, double & mean, double & var, double & q10, 
        double & q90)
    """
  return _hsi.CalculateCPStatisticsRadial_calcCtrlPntsRadiStats(*args)

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, *args): 
        """__init__(HuginBase::CalculateMeanExposure self, PanoramaData panorama) -> CalculateMeanExposure"""
        this = _hsi.new_CalculateMeanExposure(*args)
        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(*args):
        """calcMeanExposure(PanoramaData pano) -> double"""
        return _hsi.CalculateMeanExposure_calcMeanExposure(*args)

    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(*args):
  """CalculateMeanExposure_calcMeanExposure(PanoramaData pano) -> double"""
  return _hsi.CalculateMeanExposure_calcMeanExposure(*args)

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, *args):
        """calcOptimalROI(CalculateOptimalROI self, PanoramaData panorama) -> bool"""
        return _hsi.CalculateOptimalROI_calcOptimalROI(self, *args)

    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, *args):
        """setStacks(CalculateOptimalROI self, std::vector< HuginBase::UIntSet,std::allocator< HuginBase::UIntSet > > hdr_stacks)"""
        return _hsi.CalculateOptimalROI_setStacks(self, *args)

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, *args): 
        """__init__(HuginBase::CalculateOptimalScale self, PanoramaData panorama) -> CalculateOptimalScale"""
        this = _hsi.new_CalculateOptimalScale(*args)
        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(*args):
        """calcOptimalScale(PanoramaData panorama) -> double"""
        return _hsi.CalculateOptimalScale_calcOptimalScale(*args)

    if _newclass:calcOptimalScale = staticmethod(calcOptimalScale)
    __swig_getmethods__["calcOptimalScale"] = lambda x: calcOptimalScale
    def calcOptimalPanoScale(*args):
        """calcOptimalPanoScale(SrcPanoImage src, PanoramaOptions dest) -> double"""
        return _hsi.CalculateOptimalScale_calcOptimalPanoScale(*args)

    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(*args):
  """CalculateOptimalScale_calcOptimalScale(PanoramaData panorama) -> double"""
  return _hsi.CalculateOptimalScale_calcOptimalScale(*args)

def CalculateOptimalScale_calcOptimalPanoScale(*args):
  """CalculateOptimalScale_calcOptimalPanoScale(SrcPanoImage src, PanoramaOptions dest) -> double"""
  return _hsi.CalculateOptimalScale_calcOptimalPanoScale(*args)

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, *args): 
        """__init__(HuginBase::SetWidthOptimal self, PanoramaData panorama) -> SetWidthOptimal"""
        this = _hsi.new_SetWidthOptimal(*args)
        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, *args): 
        """__init__(HuginBase::CalculateImageOverlap self, PanoramaData pano) -> CalculateImageOverlap"""
        this = _hsi.new_CalculateImageOverlap(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _hsi.delete_CalculateImageOverlap
    __del__ = lambda self : None;
    def calculate(self, *args):
        """calculate(CalculateImageOverlap self, unsigned int steps)"""
        return _hsi.CalculateImageOverlap_calculate(self, *args)

    def getOverlap(self, *args):
        """getOverlap(CalculateImageOverlap self, unsigned int i, unsigned int j) -> double"""
        return _hsi.CalculateImageOverlap_getOverlap(self, *args)

    def limitToImages(self, *args):
        """limitToImages(CalculateImageOverlap self, HuginBase::UIntSet img)"""
        return _hsi.CalculateImageOverlap_limitToImages(self, *args)

    def getOverlapForImage(self, *args):
        """getOverlapForImage(CalculateImageOverlap self, unsigned int i) -> HuginBase::UIntSet"""
        return _hsi.CalculateImageOverlap_getOverlapForImage(self, *args)

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(*args):
        """rotatePano(PanoramaData panorama, Matrix3 const & transformMat)"""
        return _hsi.RotatePanorama_rotatePano(*args)

    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(*args):
  """RotatePanorama_rotatePano(PanoramaData panorama, Matrix3 const & transformMat)"""
  return _hsi.RotatePanorama_rotatePano(*args)


def getHDRStacks(*args):
  """getHDRStacks(PanoramaData pano, HuginBase::UIntSet allImgs, PanoramaOptions opts) -> std::vector< HuginBase::UIntSet,std::allocator< HuginBase::UIntSet > >"""
  return _hsi.getHDRStacks(*args)

def getExposureLayers(*args):
  """getExposureLayers(PanoramaData pano, HuginBase::UIntSet allImgs, PanoramaOptions opts) -> std::vector< HuginBase::UIntSet,std::allocator< HuginBase::UIntSet > >"""
  return _hsi.getExposureLayers(*args)

def getImagesinROI(*args):
  """getImagesinROI(PanoramaData pano, HuginBase::UIntSet const activeImages) -> HuginBase::UIntSet"""
  return _hsi.getImagesinROI(*args)
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, *args): 
        """__init__(HuginBase::StraightenPanorama self, PanoramaData panorama) -> StraightenPanorama"""
        this = _hsi.new_StraightenPanorama(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _hsi.delete_StraightenPanorama
    __del__ = lambda self : None;
    def calcStraighteningRotation(*args):
        """calcStraighteningRotation(PanoramaData panorama) -> Matrix3"""
        return _hsi.StraightenPanorama_calcStraighteningRotation(*args)

    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(*args):
  """StraightenPanorama_calcStraighteningRotation(PanoramaData panorama) -> Matrix3"""
  return _hsi.StraightenPanorama_calcStraighteningRotation(*args)

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(*args):
        """translatePano(PanoramaData panorama, double const x, double const y, double const z)"""
        return _hsi.TranslatePanorama_translatePano(*args)

    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(*args):
  """TranslatePanorama_translatePano(PanoramaData panorama, double const x, double const y, double const z)"""
  return _hsi.TranslatePanorama_translatePano(*args)


def getCPoutsideLimit_pair(*args):
  """
    getCPoutsideLimit_pair(Panorama pano, double n=2.0) -> HuginBase::UIntSet
    getCPoutsideLimit_pair(Panorama pano) -> HuginBase::UIntSet
    """
  return _hsi.getCPoutsideLimit_pair(*args)

def getCPoutsideLimit(*args):
  """
    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(*args)

def getCPinMasks(*args):
  """getCPinMasks(Panorama pano) -> HuginBase::UIntSet"""
  return _hsi.getCPinMasks(*args)
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, *args): 
        """__init__(HuginBase::CalculateFOV self, PanoramaData panorama) -> CalculateFOV"""
        this = _hsi.new_CalculateFOV(*args)
        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(*args):
        """calcFOV(PanoramaData panorama) -> FDiff2D"""
        return _hsi.CalculateFOV_calcFOV(*args)

    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(*args):
  """CalculateFOV_calcFOV(PanoramaData panorama) -> FDiff2D"""
  return _hsi.CalculateFOV_calcFOV(*args)

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, *args): 
        """__init__(HuginBase::CenterHorizontally self, PanoramaData panorama) -> CenterHorizontally"""
        this = _hsi.new_CenterHorizontally(*args)
        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(*args):
        """centerHorizontically(PanoramaData panorama)"""
        return _hsi.CenterHorizontally_centerHorizontically(*args)

    if _newclass:centerHorizontically = staticmethod(centerHorizontically)
    __swig_getmethods__["centerHorizontically"] = lambda x: centerHorizontically
CenterHorizontally_swigregister = _hsi.CenterHorizontally_swigregister
CenterHorizontally_swigregister(CenterHorizontally)

def CenterHorizontally_centerHorizontically(*args):
  """CenterHorizontally_centerHorizontically(PanoramaData panorama)"""
  return _hsi.CenterHorizontally_centerHorizontically(*args)


def estimateOutputROI(*args):
  """estimateOutputROI(PanoramaData pano, PanoramaOptions opts, unsigned int i) -> Rect2D"""
  return _hsi.estimateOutputROI(*args)
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, *args): 
        """__init__(HuginBase::ComputeImageROI self, PanoramaData panorama, HuginBase::UIntSet const & images) -> ComputeImageROI"""
        this = _hsi.new_ComputeImageROI(*args)
        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(*args):
        """computeROIS(PanoramaData panorama, PanoramaOptions opts, HuginBase::UIntSet const & images) -> std::vector< vigra::Rect2D,std::allocator< vigra::Rect2D > >"""
        return _hsi.ComputeImageROI_computeROIS(*args)

    if _newclass:computeROIS = staticmethod(computeROIS)
    __swig_getmethods__["computeROIS"] = lambda x: computeROIS
ComputeImageROI_swigregister = _hsi.ComputeImageROI_swigregister
ComputeImageROI_swigregister(ComputeImageROI)

def ComputeImageROI_computeROIS(*args):
  """ComputeImageROI_computeROIS(PanoramaData panorama, PanoramaOptions opts, HuginBase::UIntSet const & images) -> std::vector< vigra::Rect2D,std::allocator< vigra::Rect2D > >"""
  return _hsi.ComputeImageROI_computeROIS(*args)

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, *args): 
        """__init__(HuginBase::CalculateFitPanorama self, PanoramaData panorama) -> CalculateFitPanorama"""
        this = _hsi.new_CalculateFitPanorama(*args)
        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(*args):
        """fitPano(PanoramaData panorama, double & HFOV, double & height)"""
        return _hsi.CalculateFitPanorama_fitPano(*args)

    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(*args):
  """CalculateFitPanorama_fitPano(PanoramaData panorama, double & HFOV, double & height)"""
  return _hsi.CalculateFitPanorama_fitPano(*args)

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, *args): 
        """__init__(HuginBase::FitPanorama self, PanoramaData panorama) -> FitPanorama"""
        this = _hsi.new_FitPanorama(*args)
        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, *args): 
        """
        __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(*args)
        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, *args): 
        """__init__(HuginBase::PTOptimizer self, PanoramaData panorama) -> PTOptimizer"""
        this = _hsi.new_PTOptimizer(*args)
        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, *args): 
        """
        __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(*args)
        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(*args):
        """
        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(*args)

    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(*args):
  """
    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(*args)

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, *args): 
        """
        __init__(HuginBase::AutoOptimise self, PanoramaData panorama, bool optRoll=True) -> AutoOptimise
        __init__(HuginBase::AutoOptimise self, PanoramaData panorama) -> AutoOptimise
        """
        this = _hsi.new_AutoOptimise(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _hsi.delete_AutoOptimise
    __del__ = lambda self : None;
    def autoOptimise(*args):
        """
        autoOptimise(PanoramaData pano, bool optRoll=True)
        autoOptimise(PanoramaData pano)
        """
        return _hsi.AutoOptimise_autoOptimise(*args)

    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(*args):
  """
    autoOptimise(PanoramaData pano, bool optRoll=True)
    AutoOptimise_autoOptimise(PanoramaData pano)
    """
  return _hsi.AutoOptimise_autoOptimise(*args)

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(*args):
        """
        createOptVars(PanoramaData optPano, int mode, unsigned int anchorImg=0) -> OptimizeVector
        createOptVars(PanoramaData optPano, int mode) -> OptimizeVector
        """
        return _hsi.SmartOptimizerStub_createOptVars(*args)

    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(*args):
  """
    createOptVars(PanoramaData optPano, int mode, unsigned int anchorImg=0) -> OptimizeVector
    SmartOptimizerStub_createOptVars(PanoramaData optPano, int mode) -> OptimizeVector
    """
  return _hsi.SmartOptimizerStub_createOptVars(*args)

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, *args): 
        """__init__(HuginBase::SmartOptimise self, PanoramaData panorama) -> SmartOptimise"""
        this = _hsi.new_SmartOptimise(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _hsi.delete_SmartOptimise
    __del__ = lambda self : None;
    def smartOptimize(*args):
        """smartOptimize(PanoramaData pano)"""
        return _hsi.SmartOptimise_smartOptimize(*args)

    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(*args):
  """SmartOptimise_smartOptimize(PanoramaData pano)"""
  return _hsi.SmartOptimise_smartOptimize(*args)

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, *args): 
        """
        __init__(HuginBase::PhotometricOptimizer self, PanoramaData panorama, AppBase::ProgressDisplay * progressDisplay, OptimizeVector vars, 
            HuginBase::PhotometricOptimizer::PointPairs const & correspondences) -> PhotometricOptimizer
        """
        this = _hsi.new_PhotometricOptimizer(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _hsi.delete_PhotometricOptimizer
    __del__ = lambda self : None;
    def optimizePhotometric(*args):
        """
        optimizePhotometric(PanoramaData pano, OptimizeVector vars, HuginBase::PhotometricOptimizer::PointPairs const & correspondences, 
            AppBase::ProgressReporter & progress, double & error)
        """
        return _hsi.PhotometricOptimizer_optimizePhotometric(*args)

    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(*args):
  """
    PhotometricOptimizer_optimizePhotometric(PanoramaData pano, OptimizeVector vars, HuginBase::PhotometricOptimizer::PointPairs const & correspondences, 
        AppBase::ProgressReporter & progress, double & error)
    """
  return _hsi.PhotometricOptimizer_optimizePhotometric(*args)

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, *args): 
        """
        __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(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _hsi.delete_SmartPhotometricOptimizer
    __del__ = lambda self : None;
    def smartOptimizePhotometric(*args):
        """
        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(*args)

    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(*args):
  """
    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(*args)

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, *args): 
        """
        __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_, int const nrThreads_) -> PanoramaMakefilelibExport
        """
        this = _hsi.new_PanoramaMakefilelibExport(*args)
        try: self.this.append(this)
        except: self.this = this
    def createMakefile(*args):
        """
        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_, int const nrThreads_)
        """
        return _hsi.PanoramaMakefilelibExport_createMakefile(*args)

    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(*args):
  """
    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_, int const nrThreads_)
    """
  return _hsi.PanoramaMakefilelibExport_createMakefile(*args)


def printstacks(*args):
  """printstacks(std::vector< HuginBase::UIntSet,std::allocator< HuginBase::UIntSet > > const & stackdata)"""
  return _hsi.printstacks(*args)
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(*args):
        """
        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(*args)

    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(*args):
  """
    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(*args)

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, *args): 
        """
        __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(*args)
        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, *args): 
        """
        __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(*args)
        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.


