hugin-tools 2011.4.0+dfsg-1 / usr / share / pyshared / hsi.py

# This file was automatically generated by SWIG (http://www.swig.org).
# Version 2.0.4
#
# 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(self) -> PyObject"""
        return _hsi.SwigPyIterator_value(self)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def __sub__(self, *args):
        """
        __sub__(self, ptrdiff_t n) -> SwigPyIterator
        __sub__(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(self, event_callback __fn, int __index)"""
        return _hsi.ios_base_register_callback(self, *args)

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

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

    def unsetf(self, *args):
        """unsetf(self, fmtflags __mask)"""
        return _hsi.ios_base_unsetf(self, *args)

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

    def width(self, *args):
        """
        width(self) -> streamsize
        width(self, streamsize __wide) -> 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(self, locale __loc) -> locale"""
        return _hsi.ios_base_imbue(self, *args)

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

    def pword(self, *args):
        """pword(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(self) -> iostate"""
        return _hsi.ios_rdstate(self)

    def clear(self, *args):
        """
        clear(self, iostate __state = goodbit)
        clear(self)
        """
        return _hsi.ios_clear(self, *args)

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

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

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

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

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

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

    def __init__(self, *args): 
        """__init__(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(self) -> ostream
        tie(self, ostream __tiestr) -> ostream
        """
        return _hsi.ios_tie(self, *args)

    def rdbuf(self, *args):
        """
        rdbuf(self) -> std::basic_streambuf<(char,std::char_traits<(char)>)>
        rdbuf(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(self, ios __rhs) -> ios"""
        return _hsi.ios_copyfmt(self, *args)

    def fill(self, *args):
        """
        fill(self) -> char_type
        fill(self, char_type __ch) -> char_type
        """
        return _hsi.ios_fill(self, *args)

    def imbue(self, *args):
        """imbue(self, locale __loc) -> locale"""
        return _hsi.ios_imbue(self, *args)

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

    def widen(self, *args):
        """widen(self, char __c) -> 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__(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__(self, ostream __pf) -> ostream
        __lshift__(self, ios __pf) -> ostream
        __lshift__(self, ios_base __pf) -> ostream
        __lshift__(self, long __n) -> ostream
        __lshift__(self, unsigned long __n) -> ostream
        __lshift__(self, bool __n) -> ostream
        __lshift__(self, short __n) -> ostream
        __lshift__(self, unsigned short __n) -> ostream
        __lshift__(self, int __n) -> ostream
        __lshift__(self, unsigned int __n) -> ostream
        __lshift__(self, long long __n) -> ostream
        __lshift__(self, unsigned long long __n) -> ostream
        __lshift__(self, double __f) -> ostream
        __lshift__(self, float __f) -> ostream
        __lshift__(self, long double __f) -> ostream
        __lshift__(self, void __p) -> ostream
        __lshift__(self, std::basic_streambuf<(char,std::char_traits<(char)>)> __sb) -> ostream
        __lshift__(self, std::basic_string<(char,std::char_traits<(char)>,std::allocator<(char)>)> s) -> ostream
        """
        return _hsi.ostream___lshift__(self, *args)

    def put(self, *args):
        """put(self, char_type __c) -> ostream"""
        return _hsi.ostream_put(self, *args)

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

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

    def tellp(self):
        """tellp(self) -> pos_type"""
        return _hsi.ostream_tellp(self)

    def seekp(self, *args):
        """
        seekp(self, pos_type arg0) -> ostream
        seekp(self, off_type arg0, seekdir arg1) -> 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__(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__(self, istream __pf) -> istream
        __rshift__(self, ios __pf) -> istream
        __rshift__(self, ios_base __pf) -> istream
        __rshift__(self, bool __n) -> istream
        __rshift__(self, short __n) -> istream
        __rshift__(self, unsigned short __n) -> istream
        __rshift__(self, int __n) -> istream
        __rshift__(self, unsigned int __n) -> istream
        __rshift__(self, long __n) -> istream
        __rshift__(self, unsigned long __n) -> istream
        __rshift__(self, long long __n) -> istream
        __rshift__(self, unsigned long long __n) -> istream
        __rshift__(self, float __f) -> istream
        __rshift__(self, double __f) -> istream
        __rshift__(self, long double __f) -> istream
        __rshift__(self, void __p) -> istream
        __rshift__(self, std::basic_streambuf<(char,std::char_traits<(char)>)> __sb) -> istream
        """
        return _hsi.istream___rshift__(self, *args)

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

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

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

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

    def peek(self):
        """peek(self) -> int_type"""
        return _hsi.istream_peek(self)

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

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

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

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

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

    def tellg(self):
        """tellg(self) -> pos_type"""
        return _hsi.istream_tellg(self)

    def seekg(self, *args):
        """
        seekg(self, pos_type arg0) -> istream
        seekg(self, off_type arg0, seekdir arg1) -> 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__(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 arg0) -> ostream"""
  return _hsi.endl(*args)
endl = _hsi.endl
ends_cb_ptr = _hsi.ends_cb_ptr

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

def flush(*args):
  """flush(ostream arg0) -> 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__(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__(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(self) -> SwigPyIterator"""
        return _hsi.UIntVector_iterator(self)

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

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

    def __len__(self):
        """__len__(self) -> size_type"""
        return _hsi.UIntVector___len__(self)

    def pop(self):
        """pop(self) -> value_type"""
        return _hsi.UIntVector_pop(self)

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

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

    def __delslice__(self, *args):
        """__delslice__(self, difference_type i, difference_type j)"""
        return _hsi.UIntVector___delslice__(self, *args)

    def __delitem__(self, *args):
        """
        __delitem__(self, difference_type i)
        __delitem__(self, PySliceObject slice)
        """
        return _hsi.UIntVector___delitem__(self, *args)

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

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

    def append(self, *args):
        """append(self, value_type x)"""
        return _hsi.UIntVector_append(self, *args)

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

    def size(self):
        """size(self) -> size_type"""
        return _hsi.UIntVector_size(self)

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

    def swap(self, *args):
        """swap(self, std::vector<(unsigned int)> v)"""
        return _hsi.UIntVector_swap(self, *args)

    def get_allocator(self):
        """get_allocator(self) -> allocator_type"""
        return _hsi.UIntVector_get_allocator(self)

    def begin(self):
        """begin(self) -> iterator"""
        return _hsi.UIntVector_begin(self)

    def end(self):
        """end(self) -> iterator"""
        return _hsi.UIntVector_end(self)

    def rbegin(self):
        """rbegin(self) -> reverse_iterator"""
        return _hsi.UIntVector_rbegin(self)

    def rend(self):
        """rend(self) -> reverse_iterator"""
        return _hsi.UIntVector_rend(self)

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

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

    def __init__(self, *args): 
        """
        __init__(self) -> UIntVector
        __init__(self, std::vector<(unsigned int)> arg0) -> UIntVector
        __init__(self, size_type size) -> UIntVector
        __init__(self, size_type size, value_type value) -> UIntVector
        """
        this = _hsi.new_UIntVector(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args):
        """push_back(self, value_type x)"""
        return _hsi.UIntVector_push_back(self, *args)

    def front(self):
        """front(self) -> value_type"""
        return _hsi.UIntVector_front(self)

    def back(self):
        """back(self) -> value_type"""
        return _hsi.UIntVector_back(self)

    def assign(self, *args):
        """assign(self, size_type n, value_type x)"""
        return _hsi.UIntVector_assign(self, *args)

    def resize(self, *args):
        """
        resize(self, size_type new_size)
        resize(self, size_type new_size, value_type x)
        """
        return _hsi.UIntVector_resize(self, *args)

    def insert(self, *args):
        """
        insert(self, iterator pos, value_type x) -> iterator
        insert(self, iterator pos, size_type n, value_type x)
        """
        return _hsi.UIntVector_insert(self, *args)

    def reserve(self, *args):
        """reserve(self, size_type n)"""
        return _hsi.UIntVector_reserve(self, *args)

    def capacity(self):
        """capacity(self) -> 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(self) -> SwigPyIterator"""
        return _hsi.UIntSet_iterator(self)

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

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

    def __len__(self):
        """__len__(self) -> size_type"""
        return _hsi.UIntSet___len__(self)

    def append(self, *args):
        """append(self, value_type x)"""
        return _hsi.UIntSet_append(self, *args)

    def __contains__(self, *args):
        """__contains__(self, value_type x) -> bool"""
        return _hsi.UIntSet___contains__(self, *args)

    def __getitem__(self, *args):
        """__getitem__(self, difference_type i) -> value_type"""
        return _hsi.UIntSet___getitem__(self, *args)

    def __init__(self, *args): 
        """
        __init__(self, std::less<(unsigned int)> arg0) -> UIntSet
        __init__(self) -> UIntSet
        __init__(self, std::set<(unsigned int)> arg0) -> UIntSet
        """
        this = _hsi.new_UIntSet(*args)
        try: self.this.append(this)
        except: self.this = this
    def empty(self):
        """empty(self) -> bool"""
        return _hsi.UIntSet_empty(self)

    def size(self):
        """size(self) -> size_type"""
        return _hsi.UIntSet_size(self)

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

    def swap(self, *args):
        """swap(self, std::set<(unsigned int)> v)"""
        return _hsi.UIntSet_swap(self, *args)

    def count(self, *args):
        """count(self, key_type x) -> size_type"""
        return _hsi.UIntSet_count(self, *args)

    def begin(self):
        """begin(self) -> iterator"""
        return _hsi.UIntSet_begin(self)

    def end(self):
        """end(self) -> iterator"""
        return _hsi.UIntSet_end(self)

    def rbegin(self):
        """rbegin(self) -> reverse_iterator"""
        return _hsi.UIntSet_rbegin(self)

    def rend(self):
        """rend(self) -> reverse_iterator"""
        return _hsi.UIntSet_rend(self)

    def erase(self, *args):
        """
        erase(self, key_type x) -> size_type
        erase(self, iterator pos)
        erase(self, iterator first, iterator last)
        """
        return _hsi.UIntSet_erase(self, *args)

    def find(self, *args):
        """find(self, key_type x) -> iterator"""
        return _hsi.UIntSet_find(self, *args)

    def lower_bound(self, *args):
        """lower_bound(self, key_type x) -> iterator"""
        return _hsi.UIntSet_lower_bound(self, *args)

    def upper_bound(self, *args):
        """upper_bound(self, key_type x) -> iterator"""
        return _hsi.UIntSet_upper_bound(self, *args)

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

    def insert(self, *args):
        """insert(self, value_type __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(self) -> SwigPyIterator"""
        return _hsi.DoubleVector_iterator(self)

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

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

    def __len__(self):
        """__len__(self) -> size_type"""
        return _hsi.DoubleVector___len__(self)

    def pop(self):
        """pop(self) -> value_type"""
        return _hsi.DoubleVector_pop(self)

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

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

    def __delslice__(self, *args):
        """__delslice__(self, difference_type i, difference_type j)"""
        return _hsi.DoubleVector___delslice__(self, *args)

    def __delitem__(self, *args):
        """
        __delitem__(self, difference_type i)
        __delitem__(self, PySliceObject slice)
        """
        return _hsi.DoubleVector___delitem__(self, *args)

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

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

    def append(self, *args):
        """append(self, value_type x)"""
        return _hsi.DoubleVector_append(self, *args)

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

    def size(self):
        """size(self) -> size_type"""
        return _hsi.DoubleVector_size(self)

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

    def swap(self, *args):
        """swap(self, std::vector<(double)> v)"""
        return _hsi.DoubleVector_swap(self, *args)

    def get_allocator(self):
        """get_allocator(self) -> allocator_type"""
        return _hsi.DoubleVector_get_allocator(self)

    def begin(self):
        """begin(self) -> iterator"""
        return _hsi.DoubleVector_begin(self)

    def end(self):
        """end(self) -> iterator"""
        return _hsi.DoubleVector_end(self)

    def rbegin(self):
        """rbegin(self) -> reverse_iterator"""
        return _hsi.DoubleVector_rbegin(self)

    def rend(self):
        """rend(self) -> reverse_iterator"""
        return _hsi.DoubleVector_rend(self)

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

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

    def __init__(self, *args): 
        """
        __init__(self) -> DoubleVector
        __init__(self, std::vector<(double)> arg0) -> DoubleVector
        __init__(self, size_type size) -> DoubleVector
        __init__(self, size_type size, value_type value) -> DoubleVector
        """
        this = _hsi.new_DoubleVector(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args):
        """push_back(self, value_type x)"""
        return _hsi.DoubleVector_push_back(self, *args)

    def front(self):
        """front(self) -> value_type"""
        return _hsi.DoubleVector_front(self)

    def back(self):
        """back(self) -> value_type"""
        return _hsi.DoubleVector_back(self)

    def assign(self, *args):
        """assign(self, size_type n, value_type x)"""
        return _hsi.DoubleVector_assign(self, *args)

    def resize(self, *args):
        """
        resize(self, size_type new_size)
        resize(self, size_type new_size, value_type x)
        """
        return _hsi.DoubleVector_resize(self, *args)

    def insert(self, *args):
        """
        insert(self, iterator pos, value_type x) -> iterator
        insert(self, iterator pos, size_type n, value_type x)
        """
        return _hsi.DoubleVector_insert(self, *args)

    def reserve(self, *args):
        """reserve(self, size_type n)"""
        return _hsi.DoubleVector_reserve(self, *args)

    def capacity(self):
        """capacity(self) -> 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__(self) -> Size2D
        __init__(self, int ix, int iy) -> Size2D
        """
        this = _hsi.new_Size2D(*args)
        try: self.this.append(this)
        except: self.this = this
    def width(self):
        """width(self) -> int"""
        return _hsi.Size2D_width(self)

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

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

    def setHeight(self, *args):
        """setHeight(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__(self) -> Point2D
        __init__(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__(self) -> Rect2D
        __init__(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(self) -> Point2D"""
        return _hsi.Rect2D_upperLeft(self)

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

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

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

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

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

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

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

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

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

    def clearDirty(self):
        """clearDirty(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(self, UIntSet imgs) -> PanoramaData"""
        return _hsi.PanoramaData_getNewSubset(self, *args)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def printPanoramaScript(self, *args):
        """
        printPanoramaScript(self, ostream o, OptimizeVector optvars, PanoramaOptions options, 
            UIntSet imgs, bool forPTOptimizer, string stripPrefix = "")
        printPanoramaScript(self, ostream o, OptimizeVector optvars, PanoramaOptions options, 
            UIntSet imgs, bool forPTOptimizer)
        """
        return _hsi.PanoramaData_printPanoramaScript(self, *args)

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

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

    def imageChanged(self, *args):
        """imageChanged(self, unsigned int imgNr)"""
        return _hsi.PanoramaData_imageChanged(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(self, PanoramaData pano)"""
        return _hsi.PanoramaObserver_panoramaChanged(self, *args)

    def panoramaImagesChanged(self, *args):
        """panoramaImagesChanged(self, PanoramaData pano, UIntSet 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(self, PanoramaObserver o)"""
        return _hsi.ManagedPanoramaData_addObserver(self, *args)

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

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

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

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

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

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

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

    def markAsOptimized(self, optimized = True):
        """
        markAsOptimized(self, bool optimized = True)
        markAsOptimized(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__(self) -> CPoint
        __init__(self, unsigned int first, ControlPoint second) -> CPoint
        __init__(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(self) -> SwigPyIterator"""
        return _hsi.CPointVector_iterator(self)

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

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

    def __len__(self):
        """__len__(self) -> size_type"""
        return _hsi.CPointVector___len__(self)

    def pop(self):
        """pop(self) -> value_type"""
        return _hsi.CPointVector_pop(self)

    def __getslice__(self, *args):
        """__getslice__(self, difference_type i, 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__(self, difference_type i, difference_type j, std::vector<(std::pair<(unsigned int,HuginBase::ControlPoint)>,std::allocator<(std::pair<(unsigned int,HuginBase::ControlPoint)>)>)> v = std::vector< std::pair< unsigned int,ControlPoint >,std::allocator< std::pair< unsigned int,ControlPoint > > >())
        __setslice__(self, difference_type i, difference_type j)
        """
        return _hsi.CPointVector___setslice__(self, *args)

    def __delslice__(self, *args):
        """__delslice__(self, difference_type i, difference_type j)"""
        return _hsi.CPointVector___delslice__(self, *args)

    def __delitem__(self, *args):
        """
        __delitem__(self, difference_type i)
        __delitem__(self, PySliceObject slice)
        """
        return _hsi.CPointVector___delitem__(self, *args)

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

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

    def append(self, *args):
        """append(self, value_type x)"""
        return _hsi.CPointVector_append(self, *args)

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

    def size(self):
        """size(self) -> size_type"""
        return _hsi.CPointVector_size(self)

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

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

    def get_allocator(self):
        """get_allocator(self) -> allocator_type"""
        return _hsi.CPointVector_get_allocator(self)

    def begin(self):
        """begin(self) -> iterator"""
        return _hsi.CPointVector_begin(self)

    def end(self):
        """end(self) -> iterator"""
        return _hsi.CPointVector_end(self)

    def rbegin(self):
        """rbegin(self) -> reverse_iterator"""
        return _hsi.CPointVector_rbegin(self)

    def rend(self):
        """rend(self) -> reverse_iterator"""
        return _hsi.CPointVector_rend(self)

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

    def erase(self, *args):
        """
        erase(self, iterator pos) -> iterator
        erase(self, iterator first, iterator last) -> iterator
        """
        return _hsi.CPointVector_erase(self, *args)

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

    def front(self):
        """front(self) -> value_type"""
        return _hsi.CPointVector_front(self)

    def back(self):
        """back(self) -> value_type"""
        return _hsi.CPointVector_back(self)

    def assign(self, *args):
        """assign(self, size_type n, value_type x)"""
        return _hsi.CPointVector_assign(self, *args)

    def resize(self, *args):
        """
        resize(self, size_type new_size)
        resize(self, size_type new_size, value_type x)
        """
        return _hsi.CPointVector_resize(self, *args)

    def insert(self, *args):
        """
        insert(self, iterator pos, value_type x) -> iterator
        insert(self, iterator pos, size_type n, value_type x)
        """
        return _hsi.CPointVector_insert(self, *args)

    def reserve(self, *args):
        """reserve(self, size_type n)"""
        return _hsi.CPointVector_reserve(self, *args)

    def capacity(self):
        """capacity(self) -> 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(self) -> SwigPyIterator"""
        return _hsi.CPVector_iterator(self)

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

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

    def __len__(self):
        """__len__(self) -> size_type"""
        return _hsi.CPVector___len__(self)

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

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

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

    def __delslice__(self, *args):
        """__delslice__(self, difference_type i, difference_type j)"""
        return _hsi.CPVector___delslice__(self, *args)

    def __delitem__(self, *args):
        """
        __delitem__(self, difference_type i)
        __delitem__(self, PySliceObject slice)
        """
        return _hsi.CPVector___delitem__(self, *args)

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

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

    def append(self, *args):
        """append(self, value_type x)"""
        return _hsi.CPVector_append(self, *args)

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

    def size(self):
        """size(self) -> size_type"""
        return _hsi.CPVector_size(self)

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

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

    def get_allocator(self):
        """get_allocator(self) -> allocator_type"""
        return _hsi.CPVector_get_allocator(self)

    def begin(self):
        """begin(self) -> iterator"""
        return _hsi.CPVector_begin(self)

    def end(self):
        """end(self) -> iterator"""
        return _hsi.CPVector_end(self)

    def rbegin(self):
        """rbegin(self) -> reverse_iterator"""
        return _hsi.CPVector_rbegin(self)

    def rend(self):
        """rend(self) -> reverse_iterator"""
        return _hsi.CPVector_rend(self)

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

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

    def __init__(self, *args): 
        """
        __init__(self) -> CPVector
        __init__(self, CPVector arg0) -> CPVector
        __init__(self, size_type size) -> CPVector
        __init__(self, size_type size, value_type value) -> CPVector
        """
        this = _hsi.new_CPVector(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args):
        """push_back(self, value_type x)"""
        return _hsi.CPVector_push_back(self, *args)

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

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

    def assign(self, *args):
        """assign(self, size_type n, value_type x)"""
        return _hsi.CPVector_assign(self, *args)

    def resize(self, *args):
        """
        resize(self, size_type new_size)
        resize(self, size_type new_size, value_type x)
        """
        return _hsi.CPVector_resize(self, *args)

    def insert(self, *args):
        """
        insert(self, iterator pos, value_type x) -> iterator
        insert(self, iterator pos, size_type n, value_type x)
        """
        return _hsi.CPVector_insert(self, *args)

    def reserve(self, *args):
        """reserve(self, size_type n)"""
        return _hsi.CPVector_reserve(self, *args)

    def capacity(self):
        """capacity(self) -> 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(self) -> SwigPyIterator"""
        return _hsi.ImageVector_iterator(self)

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

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

    def __len__(self):
        """__len__(self) -> size_type"""
        return _hsi.ImageVector___len__(self)

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

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

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

    def __delslice__(self, *args):
        """__delslice__(self, difference_type i, difference_type j)"""
        return _hsi.ImageVector___delslice__(self, *args)

    def __delitem__(self, *args):
        """
        __delitem__(self, difference_type i)
        __delitem__(self, PySliceObject slice)
        """
        return _hsi.ImageVector___delitem__(self, *args)

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

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

    def append(self, *args):
        """append(self, value_type x)"""
        return _hsi.ImageVector_append(self, *args)

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

    def size(self):
        """size(self) -> size_type"""
        return _hsi.ImageVector_size(self)

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

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

    def get_allocator(self):
        """get_allocator(self) -> allocator_type"""
        return _hsi.ImageVector_get_allocator(self)

    def begin(self):
        """begin(self) -> iterator"""
        return _hsi.ImageVector_begin(self)

    def end(self):
        """end(self) -> iterator"""
        return _hsi.ImageVector_end(self)

    def rbegin(self):
        """rbegin(self) -> reverse_iterator"""
        return _hsi.ImageVector_rbegin(self)

    def rend(self):
        """rend(self) -> reverse_iterator"""
        return _hsi.ImageVector_rend(self)

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

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

    def __init__(self, *args): 
        """
        __init__(self) -> ImageVector
        __init__(self, ImageVector arg0) -> ImageVector
        __init__(self, size_type size) -> ImageVector
        __init__(self, size_type size, value_type value) -> ImageVector
        """
        this = _hsi.new_ImageVector(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args):
        """push_back(self, value_type x)"""
        return _hsi.ImageVector_push_back(self, *args)

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

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

    def assign(self, *args):
        """assign(self, size_type n, value_type x)"""
        return _hsi.ImageVector_assign(self, *args)

    def resize(self, *args):
        """
        resize(self, size_type new_size)
        resize(self, size_type new_size, value_type x)
        """
        return _hsi.ImageVector_resize(self, *args)

    def insert(self, *args):
        """
        insert(self, iterator pos, value_type x) -> iterator
        insert(self, iterator pos, size_type n, value_type x)
        """
        return _hsi.ImageVector_insert(self, *args)

    def reserve(self, *args):
        """reserve(self, size_type n)"""
        return _hsi.ImageVector_reserve(self, *args)

    def capacity(self):
        """capacity(self) -> 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(self) -> SwigPyIterator"""
        return _hsi.LensVarMap_iterator(self)

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

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

    def __len__(self):
        """__len__(self) -> 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__(self, key_type key) -> mapped_type"""
        return _hsi.LensVarMap___getitem__(self, *args)

    def __delitem__(self, *args):
        """__delitem__(self, key_type key)"""
        return _hsi.LensVarMap___delitem__(self, *args)

    def has_key(self, *args):
        """has_key(self, key_type key) -> bool"""
        return _hsi.LensVarMap_has_key(self, *args)

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

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

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

    def __contains__(self, *args):
        """__contains__(self, key_type key) -> bool"""
        return _hsi.LensVarMap___contains__(self, *args)

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

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

    def __setitem__(self, *args):
        """
        __setitem__(self, key_type key)
        __setitem__(self, key_type key, mapped_type x)
        """
        return _hsi.LensVarMap___setitem__(self, *args)

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

    def __init__(self, *args): 
        """
        __init__(self, std::less<(std::string)> arg0) -> LensVarMap
        __init__(self) -> LensVarMap
        __init__(self, LensVarMap arg0) -> LensVarMap
        """
        this = _hsi.new_LensVarMap(*args)
        try: self.this.append(this)
        except: self.this = this
    def empty(self):
        """empty(self) -> bool"""
        return _hsi.LensVarMap_empty(self)

    def size(self):
        """size(self) -> size_type"""
        return _hsi.LensVarMap_size(self)

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

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

    def get_allocator(self):
        """get_allocator(self) -> allocator_type"""
        return _hsi.LensVarMap_get_allocator(self)

    def begin(self):
        """begin(self) -> iterator"""
        return _hsi.LensVarMap_begin(self)

    def end(self):
        """end(self) -> iterator"""
        return _hsi.LensVarMap_end(self)

    def rbegin(self):
        """rbegin(self) -> reverse_iterator"""
        return _hsi.LensVarMap_rbegin(self)

    def rend(self):
        """rend(self) -> reverse_iterator"""
        return _hsi.LensVarMap_rend(self)

    def count(self, *args):
        """count(self, key_type x) -> size_type"""
        return _hsi.LensVarMap_count(self, *args)

    def erase(self, *args):
        """
        erase(self, key_type x) -> size_type
        erase(self, iterator position)
        erase(self, iterator first, iterator last)
        """
        return _hsi.LensVarMap_erase(self, *args)

    def find(self, *args):
        """find(self, key_type x) -> iterator"""
        return _hsi.LensVarMap_find(self, *args)

    def lower_bound(self, *args):
        """lower_bound(self, key_type x) -> iterator"""
        return _hsi.LensVarMap_lower_bound(self, *args)

    def upper_bound(self, *args):
        """upper_bound(self, key_type x) -> 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(self) -> SwigPyIterator"""
        return _hsi.OptimizeVector_iterator(self)

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

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

    def __len__(self):
        """__len__(self) -> size_type"""
        return _hsi.OptimizeVector___len__(self)

    def pop(self):
        """pop(self) -> value_type"""
        return _hsi.OptimizeVector_pop(self)

    def __getslice__(self, *args):
        """__getslice__(self, difference_type i, difference_type j) -> OptimizeVector"""
        return _hsi.OptimizeVector___getslice__(self, *args)

    def __setslice__(self, *args):
        """
        __setslice__(self, difference_type i, 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__(self, difference_type i, difference_type j)
        """
        return _hsi.OptimizeVector___setslice__(self, *args)

    def __delslice__(self, *args):
        """__delslice__(self, difference_type i, difference_type j)"""
        return _hsi.OptimizeVector___delslice__(self, *args)

    def __delitem__(self, *args):
        """
        __delitem__(self, difference_type i)
        __delitem__(self, PySliceObject slice)
        """
        return _hsi.OptimizeVector___delitem__(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(self, PySliceObject slice) -> OptimizeVector
        __getitem__(self, difference_type i) -> value_type
        """
        return _hsi.OptimizeVector___getitem__(self, *args)

    def __setitem__(self, *args):
        """
        __setitem__(self, PySliceObject slice, OptimizeVector v)
        __setitem__(self, PySliceObject slice)
        __setitem__(self, difference_type i, value_type x)
        """
        return _hsi.OptimizeVector___setitem__(self, *args)

    def append(self, *args):
        """append(self, value_type x)"""
        return _hsi.OptimizeVector_append(self, *args)

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

    def size(self):
        """size(self) -> size_type"""
        return _hsi.OptimizeVector_size(self)

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

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

    def get_allocator(self):
        """get_allocator(self) -> allocator_type"""
        return _hsi.OptimizeVector_get_allocator(self)

    def begin(self):
        """begin(self) -> iterator"""
        return _hsi.OptimizeVector_begin(self)

    def end(self):
        """end(self) -> iterator"""
        return _hsi.OptimizeVector_end(self)

    def rbegin(self):
        """rbegin(self) -> reverse_iterator"""
        return _hsi.OptimizeVector_rbegin(self)

    def rend(self):
        """rend(self) -> reverse_iterator"""
        return _hsi.OptimizeVector_rend(self)

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

    def erase(self, *args):
        """
        erase(self, iterator pos) -> iterator
        erase(self, iterator first, iterator last) -> iterator
        """
        return _hsi.OptimizeVector_erase(self, *args)

    def __init__(self, *args): 
        """
        __init__(self) -> OptimizeVector
        __init__(self, OptimizeVector arg0) -> OptimizeVector
        __init__(self, size_type size) -> OptimizeVector
        __init__(self, size_type size, value_type value) -> OptimizeVector
        """
        this = _hsi.new_OptimizeVector(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args):
        """push_back(self, value_type x)"""
        return _hsi.OptimizeVector_push_back(self, *args)

    def front(self):
        """front(self) -> value_type"""
        return _hsi.OptimizeVector_front(self)

    def back(self):
        """back(self) -> value_type"""
        return _hsi.OptimizeVector_back(self)

    def assign(self, *args):
        """assign(self, size_type n, value_type x)"""
        return _hsi.OptimizeVector_assign(self, *args)

    def resize(self, *args):
        """
        resize(self, size_type new_size)
        resize(self, size_type new_size, value_type x)
        """
        return _hsi.OptimizeVector_resize(self, *args)

    def insert(self, *args):
        """
        insert(self, iterator pos, value_type x) -> iterator
        insert(self, iterator pos, size_type n, value_type x)
        """
        return _hsi.OptimizeVector_insert(self, *args)

    def reserve(self, *args):
        """reserve(self, size_type n)"""
        return _hsi.OptimizeVector_reserve(self, *args)

    def capacity(self):
        """capacity(self) -> 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(self) -> SwigPyIterator"""
        return _hsi.VariableMap_iterator(self)

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

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

    def __len__(self):
        """__len__(self) -> 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__(self, key_type key) -> mapped_type"""
        return _hsi.VariableMap___getitem__(self, *args)

    def __delitem__(self, *args):
        """__delitem__(self, key_type key)"""
        return _hsi.VariableMap___delitem__(self, *args)

    def has_key(self, *args):
        """has_key(self, key_type key) -> bool"""
        return _hsi.VariableMap_has_key(self, *args)

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

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

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

    def __contains__(self, *args):
        """__contains__(self, key_type key) -> bool"""
        return _hsi.VariableMap___contains__(self, *args)

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

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

    def __setitem__(self, *args):
        """
        __setitem__(self, key_type key)
        __setitem__(self, key_type key, mapped_type x)
        """
        return _hsi.VariableMap___setitem__(self, *args)

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

    def __init__(self, *args): 
        """
        __init__(self, std::less<(std::string)> arg0) -> VariableMap
        __init__(self) -> VariableMap
        __init__(self, VariableMap arg0) -> VariableMap
        """
        this = _hsi.new_VariableMap(*args)
        try: self.this.append(this)
        except: self.this = this
    def empty(self):
        """empty(self) -> bool"""
        return _hsi.VariableMap_empty(self)

    def size(self):
        """size(self) -> size_type"""
        return _hsi.VariableMap_size(self)

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

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

    def get_allocator(self):
        """get_allocator(self) -> allocator_type"""
        return _hsi.VariableMap_get_allocator(self)

    def begin(self):
        """begin(self) -> iterator"""
        return _hsi.VariableMap_begin(self)

    def end(self):
        """end(self) -> iterator"""
        return _hsi.VariableMap_end(self)

    def rbegin(self):
        """rbegin(self) -> reverse_iterator"""
        return _hsi.VariableMap_rbegin(self)

    def rend(self):
        """rend(self) -> reverse_iterator"""
        return _hsi.VariableMap_rend(self)

    def count(self, *args):
        """count(self, key_type x) -> size_type"""
        return _hsi.VariableMap_count(self, *args)

    def erase(self, *args):
        """
        erase(self, key_type x) -> size_type
        erase(self, iterator position)
        erase(self, iterator first, iterator last)
        """
        return _hsi.VariableMap_erase(self, *args)

    def find(self, *args):
        """find(self, key_type x) -> iterator"""
        return _hsi.VariableMap_find(self, *args)

    def lower_bound(self, *args):
        """lower_bound(self, key_type x) -> iterator"""
        return _hsi.VariableMap_lower_bound(self, *args)

    def upper_bound(self, *args):
        """upper_bound(self, key_type x) -> 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(self) -> SwigPyIterator"""
        return _hsi.VariableMapVector_iterator(self)

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

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

    def __len__(self):
        """__len__(self) -> size_type"""
        return _hsi.VariableMapVector___len__(self)

    def pop(self):
        """pop(self) -> value_type"""
        return _hsi.VariableMapVector_pop(self)

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

    def __setslice__(self, *args):
        """
        __setslice__(self, difference_type i, difference_type j, std::vector<(std::map<(std::string,HuginBase::Variable,std::less<(std::string)>,std::allocator<(std::pair<(q(const).std::string,HuginBase::Variable)>)>)>,std::allocator<(std::map<(std::string,HuginBase::Variable,std::less<(std::string)>,std::allocator<(std::pair<(q(const).std::string,HuginBase::Variable)>)>)>)>)> 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__(self, difference_type i, difference_type j)
        """
        return _hsi.VariableMapVector___setslice__(self, *args)

    def __delslice__(self, *args):
        """__delslice__(self, difference_type i, difference_type j)"""
        return _hsi.VariableMapVector___delslice__(self, *args)

    def __delitem__(self, *args):
        """
        __delitem__(self, difference_type i)
        __delitem__(self, PySliceObject slice)
        """
        return _hsi.VariableMapVector___delitem__(self, *args)

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

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

    def append(self, *args):
        """append(self, value_type x)"""
        return _hsi.VariableMapVector_append(self, *args)

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

    def size(self):
        """size(self) -> size_type"""
        return _hsi.VariableMapVector_size(self)

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

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

    def get_allocator(self):
        """get_allocator(self) -> allocator_type"""
        return _hsi.VariableMapVector_get_allocator(self)

    def begin(self):
        """begin(self) -> iterator"""
        return _hsi.VariableMapVector_begin(self)

    def end(self):
        """end(self) -> iterator"""
        return _hsi.VariableMapVector_end(self)

    def rbegin(self):
        """rbegin(self) -> reverse_iterator"""
        return _hsi.VariableMapVector_rbegin(self)

    def rend(self):
        """rend(self) -> reverse_iterator"""
        return _hsi.VariableMapVector_rend(self)

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

    def erase(self, *args):
        """
        erase(self, iterator pos) -> iterator
        erase(self, iterator first, iterator last) -> iterator
        """
        return _hsi.VariableMapVector_erase(self, *args)

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

    def front(self):
        """front(self) -> value_type"""
        return _hsi.VariableMapVector_front(self)

    def back(self):
        """back(self) -> value_type"""
        return _hsi.VariableMapVector_back(self)

    def assign(self, *args):
        """assign(self, size_type n, value_type x)"""
        return _hsi.VariableMapVector_assign(self, *args)

    def resize(self, *args):
        """
        resize(self, size_type new_size)
        resize(self, size_type new_size, value_type x)
        """
        return _hsi.VariableMapVector_resize(self, *args)

    def insert(self, *args):
        """
        insert(self, iterator pos, value_type x) -> iterator
        insert(self, iterator pos, size_type n, value_type x)
        """
        return _hsi.VariableMapVector_insert(self, *args)

    def reserve(self, *args):
        """reserve(self, size_type n)"""
        return _hsi.VariableMapVector_reserve(self, *args)

    def capacity(self):
        """capacity(self) -> 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(self) -> SwigPyIterator"""
        return _hsi.MaskPolygonVector_iterator(self)

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

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

    def __len__(self):
        """__len__(self) -> size_type"""
        return _hsi.MaskPolygonVector___len__(self)

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

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

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

    def __delslice__(self, *args):
        """__delslice__(self, difference_type i, difference_type j)"""
        return _hsi.MaskPolygonVector___delslice__(self, *args)

    def __delitem__(self, *args):
        """
        __delitem__(self, difference_type i)
        __delitem__(self, PySliceObject slice)
        """
        return _hsi.MaskPolygonVector___delitem__(self, *args)

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

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

    def append(self, *args):
        """append(self, value_type x)"""
        return _hsi.MaskPolygonVector_append(self, *args)

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

    def size(self):
        """size(self) -> size_type"""
        return _hsi.MaskPolygonVector_size(self)

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

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

    def get_allocator(self):
        """get_allocator(self) -> allocator_type"""
        return _hsi.MaskPolygonVector_get_allocator(self)

    def begin(self):
        """begin(self) -> iterator"""
        return _hsi.MaskPolygonVector_begin(self)

    def end(self):
        """end(self) -> iterator"""
        return _hsi.MaskPolygonVector_end(self)

    def rbegin(self):
        """rbegin(self) -> reverse_iterator"""
        return _hsi.MaskPolygonVector_rbegin(self)

    def rend(self):
        """rend(self) -> reverse_iterator"""
        return _hsi.MaskPolygonVector_rend(self)

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

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

    def __init__(self, *args): 
        """
        __init__(self) -> MaskPolygonVector
        __init__(self, MaskPolygonVector arg0) -> MaskPolygonVector
        __init__(self, size_type size) -> MaskPolygonVector
        __init__(self, size_type size, value_type value) -> MaskPolygonVector
        """
        this = _hsi.new_MaskPolygonVector(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args):
        """push_back(self, value_type x)"""
        return _hsi.MaskPolygonVector_push_back(self, *args)

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

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

    def assign(self, *args):
        """assign(self, size_type n, value_type x)"""
        return _hsi.MaskPolygonVector_assign(self, *args)

    def resize(self, *args):
        """
        resize(self, size_type new_size)
        resize(self, size_type new_size, value_type x)
        """
        return _hsi.MaskPolygonVector_resize(self, *args)

    def insert(self, *args):
        """
        insert(self, iterator pos, value_type x) -> iterator
        insert(self, iterator pos, size_type n, value_type x)
        """
        return _hsi.MaskPolygonVector_insert(self, *args)

    def reserve(self, *args):
        """reserve(self, size_type n)"""
        return _hsi.MaskPolygonVector_reserve(self, *args)

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

    if _newclass:checkApplicability = staticmethod(checkApplicability)
    __swig_getmethods__["checkApplicability"] = lambda x: checkApplicability
    def __init__(self): 
        """__init__(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(string 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__(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(self, unsigned int imageNr) -> unsigned int"""
        return _hsi.ConstImageVariableGroup_getPartNumber(self, *args)

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

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

    def updatePartNumbers(self):
        """updatePartNumbers(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__(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(self, ImageVariableEnum variable, unsigned int partNr)"""
        return _hsi.ImageVariableGroup_unlinkVariablePart(self, *args)

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

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

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

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

    if _newclass:getLensVariables = staticmethod(getLensVariables)
    __swig_getmethods__["getLensVariables"] = lambda x: getLensVariables
    def getLens(self, *args):
        """getLens(self, std::size_t lens_number) -> Lens"""
        return _hsi.ConstStandardImageVariableGroups_getLens(self, *args)

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

    def getStacks(self):
        """getStacks(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)>)>"""
        return _hsi.ConstStandardImageVariableGroups_getStackVariables()

    if _newclass:getStackVariables = staticmethod(getStackVariables)
    __swig_getmethods__["getStackVariables"] = lambda x: getStackVariables
    def update(self):
        """update(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)>)>"""
  return _hsi.ConstStandardImageVariableGroups_getLensVariables()

def ConstStandardImageVariableGroups_getStackVariables():
  """ConstStandardImageVariableGroups_getStackVariables() -> std::set<(HuginBase::ConstImageVariableGroup::ImageVariableEnum,std::less<(HuginBase::ConstImageVariableGroup::ImageVariableEnum)>,std::allocator<(HuginBase::ConstImageVariableGroup::ImageVariableEnum)>)>"""
  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__(self, PanoramaData pano) -> StandardImageVariableGroups"""
        this = _hsi.new_StandardImageVariableGroups(*args)
        try: self.this.append(this)
        except: self.this = this
    def getLenses(self):
        """getLenses(self) -> ImageVariableGroup"""
        return _hsi.StandardImageVariableGroups_getLenses(self)

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

    def update(self):
        """update(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__(self, string name, double val = 0.0) -> Variable
        __init__(self, string 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(self, ostream o) -> ostream"""
        return _hsi.Variable__print(self, *args)

    def getName(self):
        """getName(self) -> string"""
        return _hsi.Variable_getName(self)

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

    def getValue(self):
        """getValue(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__(self, string name = "", double val = 0.0, int link = -1) -> LinkedVariable
        __init__(self, string name = "", double val = 0.0) -> LinkedVariable
        __init__(self, string name = "") -> LinkedVariable
        __init__(self) -> LinkedVariable
        """
        this = _hsi.new_LinkedVariable(*args)
        try: self.this.append(this)
        except: self.this = this
    def isLinked(self):
        """isLinked(self) -> bool"""
        return _hsi.LinkedVariable_isLinked(self)

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

    def setLink(self, *args):
        """setLink(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__(self, string name, double value, bool link = False) -> LensVariable
        __init__(self, string 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(self, ostream o, unsigned int link) -> ostream"""
        return _hsi.LensVariable_printLink(self, *args)

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

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

LensVariable_swigregister = _hsi.LensVariable_swigregister
LensVariable_swigregister(LensVariable)


def fillVariableMap(*args):
  """fillVariableMap(VariableMap vars)"""
  return _hsi.fillVariableMap(*args)

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

def fillLensVarMap(*args):
  """fillLensVarMap(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__(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(self)"""
        return _hsi.PanoramaOptions_reset(self)

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

    def getFormatName(*args):
        """getFormatName(FileFormat f) -> string"""
        return _hsi.PanoramaOptions_getFormatName(*args)

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

    if _newclass:getFormatFromName = staticmethod(getFormatFromName)
    __swig_getmethods__["getFormatFromName"] = lambda x: getFormatFromName
    def getOutputExtension(self):
        """getOutputExtension(self) -> string"""
        return _hsi.PanoramaOptions_getOutputExtension(self)

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

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

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

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

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

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

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

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

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

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

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

    def setProjectionParameters(self, *args):
        """setProjectionParameters(self, std::vector<(double,std::allocator<(double)>)> params)"""
        return _hsi.PanoramaOptions_setProjectionParameters(self, *args)

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

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

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

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

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

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

    def getMaxVFOV(self):
        """getMaxVFOV(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__["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__["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(FileFormat f) -> string"""
  return _hsi.PanoramaOptions_getFormatName(*args)

def PanoramaOptions_getFormatFromName(*args):
  """PanoramaOptions_getFormatFromName(string name) -> 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__(self, BaseSrcPanoImage other) -> bool"""
        return _hsi.BaseSrcPanoImage___eq__(self, *args)

    def __init__(self): 
        """__init__(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(self) -> string"""
        return _hsi.BaseSrcPanoImage_getFilename(self)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def getExifCropFactor(self):
        """getExifCropFactor(self) -> double"""
        return _hsi.BaseSrcPanoImage_getExifCropFactor(self)

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

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

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

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

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

    def getExifFocalLength35(self):
        """getExifFocalLength35(self) -> double"""
        return _hsi.BaseSrcPanoImage_getExifFocalLength35(self)

    def getExifExposureTime(self):
        """getExifExposureTime(self) -> double"""
        return _hsi.BaseSrcPanoImage_getExifExposureTime(self)

    def getExifDate(self):
        """getExifDate(self) -> string"""
        return _hsi.BaseSrcPanoImage_getExifDate(self)

    def getExifExposureMode(self):
        """getExifExposureMode(self) -> int"""
        return _hsi.BaseSrcPanoImage_getExifExposureMode(self)

    def getMasks(self):
        """getMasks(self) -> MaskPolygonVector"""
        return _hsi.BaseSrcPanoImage_getMasks(self)

    def getActiveMasks(self):
        """getActiveMasks(self) -> MaskPolygonVector"""
        return _hsi.BaseSrcPanoImage_getActiveMasks(self)

    def getActive(self):
        """getActive(self) -> bool"""
        return _hsi.BaseSrcPanoImage_getActive(self)

    def getFilenameIV(self):
        """getFilenameIV(self) -> HuginBase::ImageVariable<(std::string)>"""
        return _hsi.BaseSrcPanoImage_getFilenameIV(self)

    def getSizeIV(self):
        """getSizeIV(self) -> HuginBase::ImageVariable<(vigra::Size2D)>"""
        return _hsi.BaseSrcPanoImage_getSizeIV(self)

    def getProjectionIV(self):
        """getProjectionIV(self) -> HuginBase::ImageVariable<(HuginBase::BaseSrcPanoImage::Projection)>"""
        return _hsi.BaseSrcPanoImage_getProjectionIV(self)

    def getHFOVIV(self):
        """getHFOVIV(self) -> HuginBase::ImageVariable<(double)>"""
        return _hsi.BaseSrcPanoImage_getHFOVIV(self)

    def getResponseTypeIV(self):
        """getResponseTypeIV(self) -> HuginBase::ImageVariable<(HuginBase::BaseSrcPanoImage::ResponseType)>"""
        return _hsi.BaseSrcPanoImage_getResponseTypeIV(self)

    def getEMoRParamsIV(self):
        """getEMoRParamsIV(self) -> HuginBase::ImageVariable<(std::vector<(float,std::allocator<(float)>)>)>"""
        return _hsi.BaseSrcPanoImage_getEMoRParamsIV(self)

    def getExposureValueIV(self):
        """getExposureValueIV(self) -> HuginBase::ImageVariable<(double)>"""
        return _hsi.BaseSrcPanoImage_getExposureValueIV(self)

    def getGammaIV(self):
        """getGammaIV(self) -> HuginBase::ImageVariable<(double)>"""
        return _hsi.BaseSrcPanoImage_getGammaIV(self)

    def getWhiteBalanceRedIV(self):
        """getWhiteBalanceRedIV(self) -> HuginBase::ImageVariable<(double)>"""
        return _hsi.BaseSrcPanoImage_getWhiteBalanceRedIV(self)

    def getWhiteBalanceBlueIV(self):
        """getWhiteBalanceBlueIV(self) -> HuginBase::ImageVariable<(double)>"""
        return _hsi.BaseSrcPanoImage_getWhiteBalanceBlueIV(self)

    def getRollIV(self):
        """getRollIV(self) -> HuginBase::ImageVariable<(double)>"""
        return _hsi.BaseSrcPanoImage_getRollIV(self)

    def getPitchIV(self):
        """getPitchIV(self) -> HuginBase::ImageVariable<(double)>"""
        return _hsi.BaseSrcPanoImage_getPitchIV(self)

    def getYawIV(self):
        """getYawIV(self) -> HuginBase::ImageVariable<(double)>"""
        return _hsi.BaseSrcPanoImage_getYawIV(self)

    def getXIV(self):
        """getXIV(self) -> HuginBase::ImageVariable<(double)>"""
        return _hsi.BaseSrcPanoImage_getXIV(self)

    def getYIV(self):
        """getYIV(self) -> HuginBase::ImageVariable<(double)>"""
        return _hsi.BaseSrcPanoImage_getYIV(self)

    def getZIV(self):
        """getZIV(self) -> HuginBase::ImageVariable<(double)>"""
        return _hsi.BaseSrcPanoImage_getZIV(self)

    def getStackIV(self):
        """getStackIV(self) -> HuginBase::ImageVariable<(double)>"""
        return _hsi.BaseSrcPanoImage_getStackIV(self)

    def getRadialDistortionIV(self):
        """getRadialDistortionIV(self) -> HuginBase::ImageVariable<(std::vector<(double,std::allocator<(double)>)>)>"""
        return _hsi.BaseSrcPanoImage_getRadialDistortionIV(self)

    def getRadialDistortionRedIV(self):
        """getRadialDistortionRedIV(self) -> HuginBase::ImageVariable<(std::vector<(double,std::allocator<(double)>)>)>"""
        return _hsi.BaseSrcPanoImage_getRadialDistortionRedIV(self)

    def getRadialDistortionBlueIV(self):
        """getRadialDistortionBlueIV(self) -> HuginBase::ImageVariable<(std::vector<(double,std::allocator<(double)>)>)>"""
        return _hsi.BaseSrcPanoImage_getRadialDistortionBlueIV(self)

    def getRadialDistortionCenterShiftIV(self):
        """getRadialDistortionCenterShiftIV(self) -> HuginBase::ImageVariable<(hugin_utils::FDiff2D)>"""
        return _hsi.BaseSrcPanoImage_getRadialDistortionCenterShiftIV(self)

    def getShearIV(self):
        """getShearIV(self) -> HuginBase::ImageVariable<(hugin_utils::FDiff2D)>"""
        return _hsi.BaseSrcPanoImage_getShearIV(self)

    def getCropModeIV(self):
        """getCropModeIV(self) -> HuginBase::ImageVariable<(HuginBase::BaseSrcPanoImage::CropMode)>"""
        return _hsi.BaseSrcPanoImage_getCropModeIV(self)

    def getCropRectIV(self):
        """getCropRectIV(self) -> HuginBase::ImageVariable<(vigra::Rect2D)>"""
        return _hsi.BaseSrcPanoImage_getCropRectIV(self)

    def getAutoCenterCropIV(self):
        """getAutoCenterCropIV(self) -> HuginBase::ImageVariable<(bool)>"""
        return _hsi.BaseSrcPanoImage_getAutoCenterCropIV(self)

    def getVigCorrModeIV(self):
        """getVigCorrModeIV(self) -> HuginBase::ImageVariable<(int)>"""
        return _hsi.BaseSrcPanoImage_getVigCorrModeIV(self)

    def getFlatfieldFilenameIV(self):
        """getFlatfieldFilenameIV(self) -> HuginBase::ImageVariable<(std::string)>"""
        return _hsi.BaseSrcPanoImage_getFlatfieldFilenameIV(self)

    def getRadialVigCorrCoeffIV(self):
        """getRadialVigCorrCoeffIV(self) -> HuginBase::ImageVariable<(std::vector<(double,std::allocator<(double)>)>)>"""
        return _hsi.BaseSrcPanoImage_getRadialVigCorrCoeffIV(self)

    def getRadialVigCorrCenterShiftIV(self):
        """getRadialVigCorrCenterShiftIV(self) -> HuginBase::ImageVariable<(hugin_utils::FDiff2D)>"""
        return _hsi.BaseSrcPanoImage_getRadialVigCorrCenterShiftIV(self)

    def getExifModelIV(self):
        """getExifModelIV(self) -> HuginBase::ImageVariable<(std::string)>"""
        return _hsi.BaseSrcPanoImage_getExifModelIV(self)

    def getExifMakeIV(self):
        """getExifMakeIV(self) -> HuginBase::ImageVariable<(std::string)>"""
        return _hsi.BaseSrcPanoImage_getExifMakeIV(self)

    def getExifLensIV(self):
        """getExifLensIV(self) -> HuginBase::ImageVariable<(std::string)>"""
        return _hsi.BaseSrcPanoImage_getExifLensIV(self)

    def getExifCropFactorIV(self):
        """getExifCropFactorIV(self) -> HuginBase::ImageVariable<(double)>"""
        return _hsi.BaseSrcPanoImage_getExifCropFactorIV(self)

    def getExifFocalLengthIV(self):
        """getExifFocalLengthIV(self) -> HuginBase::ImageVariable<(double)>"""
        return _hsi.BaseSrcPanoImage_getExifFocalLengthIV(self)

    def getExifOrientationIV(self):
        """getExifOrientationIV(self) -> HuginBase::ImageVariable<(double)>"""
        return _hsi.BaseSrcPanoImage_getExifOrientationIV(self)

    def getExifApertureIV(self):
        """getExifApertureIV(self) -> HuginBase::ImageVariable<(double)>"""
        return _hsi.BaseSrcPanoImage_getExifApertureIV(self)

    def getExifISOIV(self):
        """getExifISOIV(self) -> HuginBase::ImageVariable<(double)>"""
        return _hsi.BaseSrcPanoImage_getExifISOIV(self)

    def getExifDistanceIV(self):
        """getExifDistanceIV(self) -> HuginBase::ImageVariable<(double)>"""
        return _hsi.BaseSrcPanoImage_getExifDistanceIV(self)

    def getExifFocalLength35IV(self):
        """getExifFocalLength35IV(self) -> HuginBase::ImageVariable<(double)>"""
        return _hsi.BaseSrcPanoImage_getExifFocalLength35IV(self)

    def getExifExposureTimeIV(self):
        """getExifExposureTimeIV(self) -> HuginBase::ImageVariable<(double)>"""
        return _hsi.BaseSrcPanoImage_getExifExposureTimeIV(self)

    def getExifDateIV(self):
        """getExifDateIV(self) -> HuginBase::ImageVariable<(std::string)>"""
        return _hsi.BaseSrcPanoImage_getExifDateIV(self)

    def getExifExposureModeIV(self):
        """getExifExposureModeIV(self) -> HuginBase::ImageVariable<(int)>"""
        return _hsi.BaseSrcPanoImage_getExifExposureModeIV(self)

    def getMasksIV(self):
        """getMasksIV(self) -> HuginBase::ImageVariable<(HuginBase::MaskPolygonVector)>"""
        return _hsi.BaseSrcPanoImage_getMasksIV(self)

    def getActiveMasksIV(self):
        """getActiveMasksIV(self) -> HuginBase::ImageVariable<(HuginBase::MaskPolygonVector)>"""
        return _hsi.BaseSrcPanoImage_getActiveMasksIV(self)

    def getActiveIV(self):
        """getActiveIV(self) -> HuginBase::ImageVariable<(bool)>"""
        return _hsi.BaseSrcPanoImage_getActiveIV(self)

    def setFilename(self, *args):
        """setFilename(self, string data)"""
        return _hsi.BaseSrcPanoImage_setFilename(self, *args)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def unlinkFilename(self):
        """unlinkFilename(self)"""
        return _hsi.BaseSrcPanoImage_unlinkFilename(self)

    def unlinkSize(self):
        """unlinkSize(self)"""
        return _hsi.BaseSrcPanoImage_unlinkSize(self)

    def unlinkProjection(self):
        """unlinkProjection(self)"""
        return _hsi.BaseSrcPanoImage_unlinkProjection(self)

    def unlinkHFOV(self):
        """unlinkHFOV(self)"""
        return _hsi.BaseSrcPanoImage_unlinkHFOV(self)

    def unlinkResponseType(self):
        """unlinkResponseType(self)"""
        return _hsi.BaseSrcPanoImage_unlinkResponseType(self)

    def unlinkEMoRParams(self):
        """unlinkEMoRParams(self)"""
        return _hsi.BaseSrcPanoImage_unlinkEMoRParams(self)

    def unlinkExposureValue(self):
        """unlinkExposureValue(self)"""
        return _hsi.BaseSrcPanoImage_unlinkExposureValue(self)

    def unlinkGamma(self):
        """unlinkGamma(self)"""
        return _hsi.BaseSrcPanoImage_unlinkGamma(self)

    def unlinkWhiteBalanceRed(self):
        """unlinkWhiteBalanceRed(self)"""
        return _hsi.BaseSrcPanoImage_unlinkWhiteBalanceRed(self)

    def unlinkWhiteBalanceBlue(self):
        """unlinkWhiteBalanceBlue(self)"""
        return _hsi.BaseSrcPanoImage_unlinkWhiteBalanceBlue(self)

    def unlinkRoll(self):
        """unlinkRoll(self)"""
        return _hsi.BaseSrcPanoImage_unlinkRoll(self)

    def unlinkPitch(self):
        """unlinkPitch(self)"""
        return _hsi.BaseSrcPanoImage_unlinkPitch(self)

    def unlinkYaw(self):
        """unlinkYaw(self)"""
        return _hsi.BaseSrcPanoImage_unlinkYaw(self)

    def unlinkX(self):
        """unlinkX(self)"""
        return _hsi.BaseSrcPanoImage_unlinkX(self)

    def unlinkY(self):
        """unlinkY(self)"""
        return _hsi.BaseSrcPanoImage_unlinkY(self)

    def unlinkZ(self):
        """unlinkZ(self)"""
        return _hsi.BaseSrcPanoImage_unlinkZ(self)

    def unlinkStack(self):
        """unlinkStack(self)"""
        return _hsi.BaseSrcPanoImage_unlinkStack(self)

    def unlinkRadialDistortion(self):
        """unlinkRadialDistortion(self)"""
        return _hsi.BaseSrcPanoImage_unlinkRadialDistortion(self)

    def unlinkRadialDistortionRed(self):
        """unlinkRadialDistortionRed(self)"""
        return _hsi.BaseSrcPanoImage_unlinkRadialDistortionRed(self)

    def unlinkRadialDistortionBlue(self):
        """unlinkRadialDistortionBlue(self)"""
        return _hsi.BaseSrcPanoImage_unlinkRadialDistortionBlue(self)

    def unlinkRadialDistortionCenterShift(self):
        """unlinkRadialDistortionCenterShift(self)"""
        return _hsi.BaseSrcPanoImage_unlinkRadialDistortionCenterShift(self)

    def unlinkShear(self):
        """unlinkShear(self)"""
        return _hsi.BaseSrcPanoImage_unlinkShear(self)

    def unlinkCropMode(self):
        """unlinkCropMode(self)"""
        return _hsi.BaseSrcPanoImage_unlinkCropMode(self)

    def unlinkCropRect(self):
        """unlinkCropRect(self)"""
        return _hsi.BaseSrcPanoImage_unlinkCropRect(self)

    def unlinkAutoCenterCrop(self):
        """unlinkAutoCenterCrop(self)"""
        return _hsi.BaseSrcPanoImage_unlinkAutoCenterCrop(self)

    def unlinkVigCorrMode(self):
        """unlinkVigCorrMode(self)"""
        return _hsi.BaseSrcPanoImage_unlinkVigCorrMode(self)

    def unlinkFlatfieldFilename(self):
        """unlinkFlatfieldFilename(self)"""
        return _hsi.BaseSrcPanoImage_unlinkFlatfieldFilename(self)

    def unlinkRadialVigCorrCoeff(self):
        """unlinkRadialVigCorrCoeff(self)"""
        return _hsi.BaseSrcPanoImage_unlinkRadialVigCorrCoeff(self)

    def unlinkRadialVigCorrCenterShift(self):
        """unlinkRadialVigCorrCenterShift(self)"""
        return _hsi.BaseSrcPanoImage_unlinkRadialVigCorrCenterShift(self)

    def unlinkExifModel(self):
        """unlinkExifModel(self)"""
        return _hsi.BaseSrcPanoImage_unlinkExifModel(self)

    def unlinkExifMake(self):
        """unlinkExifMake(self)"""
        return _hsi.BaseSrcPanoImage_unlinkExifMake(self)

    def unlinkExifLens(self):
        """unlinkExifLens(self)"""
        return _hsi.BaseSrcPanoImage_unlinkExifLens(self)

    def unlinkExifCropFactor(self):
        """unlinkExifCropFactor(self)"""
        return _hsi.BaseSrcPanoImage_unlinkExifCropFactor(self)

    def unlinkExifFocalLength(self):
        """unlinkExifFocalLength(self)"""
        return _hsi.BaseSrcPanoImage_unlinkExifFocalLength(self)

    def unlinkExifOrientation(self):
        """unlinkExifOrientation(self)"""
        return _hsi.BaseSrcPanoImage_unlinkExifOrientation(self)

    def unlinkExifAperture(self):
        """unlinkExifAperture(self)"""
        return _hsi.BaseSrcPanoImage_unlinkExifAperture(self)

    def unlinkExifISO(self):
        """unlinkExifISO(self)"""
        return _hsi.BaseSrcPanoImage_unlinkExifISO(self)

    def unlinkExifDistance(self):
        """unlinkExifDistance(self)"""
        return _hsi.BaseSrcPanoImage_unlinkExifDistance(self)

    def unlinkExifFocalLength35(self):
        """unlinkExifFocalLength35(self)"""
        return _hsi.BaseSrcPanoImage_unlinkExifFocalLength35(self)

    def unlinkExifExposureTime(self):
        """unlinkExifExposureTime(self)"""
        return _hsi.BaseSrcPanoImage_unlinkExifExposureTime(self)

    def unlinkExifDate(self):
        """unlinkExifDate(self)"""
        return _hsi.BaseSrcPanoImage_unlinkExifDate(self)

    def unlinkExifExposureMode(self):
        """unlinkExifExposureMode(self)"""
        return _hsi.BaseSrcPanoImage_unlinkExifExposureMode(self)

    def unlinkMasks(self):
        """unlinkMasks(self)"""
        return _hsi.BaseSrcPanoImage_unlinkMasks(self)

    def unlinkActiveMasks(self):
        """unlinkActiveMasks(self)"""
        return _hsi.BaseSrcPanoImage_unlinkActiveMasks(self)

    def unlinkActive(self):
        """unlinkActive(self)"""
        return _hsi.BaseSrcPanoImage_unlinkActive(self)

    def FilenameisLinked(self):
        """FilenameisLinked(self) -> bool"""
        return _hsi.BaseSrcPanoImage_FilenameisLinked(self)

    def SizeisLinked(self):
        """SizeisLinked(self) -> bool"""
        return _hsi.BaseSrcPanoImage_SizeisLinked(self)

    def ProjectionisLinked(self):
        """ProjectionisLinked(self) -> bool"""
        return _hsi.BaseSrcPanoImage_ProjectionisLinked(self)

    def HFOVisLinked(self):
        """HFOVisLinked(self) -> bool"""
        return _hsi.BaseSrcPanoImage_HFOVisLinked(self)

    def ResponseTypeisLinked(self):
        """ResponseTypeisLinked(self) -> bool"""
        return _hsi.BaseSrcPanoImage_ResponseTypeisLinked(self)

    def EMoRParamsisLinked(self):
        """EMoRParamsisLinked(self) -> bool"""
        return _hsi.BaseSrcPanoImage_EMoRParamsisLinked(self)

    def ExposureValueisLinked(self):
        """ExposureValueisLinked(self) -> bool"""
        return _hsi.BaseSrcPanoImage_ExposureValueisLinked(self)

    def GammaisLinked(self):
        """GammaisLinked(self) -> bool"""
        return _hsi.BaseSrcPanoImage_GammaisLinked(self)

    def WhiteBalanceRedisLinked(self):
        """WhiteBalanceRedisLinked(self) -> bool"""
        return _hsi.BaseSrcPanoImage_WhiteBalanceRedisLinked(self)

    def WhiteBalanceBlueisLinked(self):
        """WhiteBalanceBlueisLinked(self) -> bool"""
        return _hsi.BaseSrcPanoImage_WhiteBalanceBlueisLinked(self)

    def RollisLinked(self):
        """RollisLinked(self) -> bool"""
        return _hsi.BaseSrcPanoImage_RollisLinked(self)

    def PitchisLinked(self):
        """PitchisLinked(self) -> bool"""
        return _hsi.BaseSrcPanoImage_PitchisLinked(self)

    def YawisLinked(self):
        """YawisLinked(self) -> bool"""
        return _hsi.BaseSrcPanoImage_YawisLinked(self)

    def XisLinked(self):
        """XisLinked(self) -> bool"""
        return _hsi.BaseSrcPanoImage_XisLinked(self)

    def YisLinked(self):
        """YisLinked(self) -> bool"""
        return _hsi.BaseSrcPanoImage_YisLinked(self)

    def ZisLinked(self):
        """ZisLinked(self) -> bool"""
        return _hsi.BaseSrcPanoImage_ZisLinked(self)

    def StackisLinked(self):
        """StackisLinked(self) -> bool"""
        return _hsi.BaseSrcPanoImage_StackisLinked(self)

    def RadialDistortionisLinked(self):
        """RadialDistortionisLinked(self) -> bool"""
        return _hsi.BaseSrcPanoImage_RadialDistortionisLinked(self)

    def RadialDistortionRedisLinked(self):
        """RadialDistortionRedisLinked(self) -> bool"""
        return _hsi.BaseSrcPanoImage_RadialDistortionRedisLinked(self)

    def RadialDistortionBlueisLinked(self):
        """RadialDistortionBlueisLinked(self) -> bool"""
        return _hsi.BaseSrcPanoImage_RadialDistortionBlueisLinked(self)

    def RadialDistortionCenterShiftisLinked(self):
        """RadialDistortionCenterShiftisLinked(self) -> bool"""
        return _hsi.BaseSrcPanoImage_RadialDistortionCenterShiftisLinked(self)

    def ShearisLinked(self):
        """ShearisLinked(self) -> bool"""
        return _hsi.BaseSrcPanoImage_ShearisLinked(self)

    def CropModeisLinked(self):
        """CropModeisLinked(self) -> bool"""
        return _hsi.BaseSrcPanoImage_CropModeisLinked(self)

    def CropRectisLinked(self):
        """CropRectisLinked(self) -> bool"""
        return _hsi.BaseSrcPanoImage_CropRectisLinked(self)

    def AutoCenterCropisLinked(self):
        """AutoCenterCropisLinked(self) -> bool"""
        return _hsi.BaseSrcPanoImage_AutoCenterCropisLinked(self)

    def VigCorrModeisLinked(self):
        """VigCorrModeisLinked(self) -> bool"""
        return _hsi.BaseSrcPanoImage_VigCorrModeisLinked(self)

    def FlatfieldFilenameisLinked(self):
        """FlatfieldFilenameisLinked(self) -> bool"""
        return _hsi.BaseSrcPanoImage_FlatfieldFilenameisLinked(self)

    def RadialVigCorrCoeffisLinked(self):
        """RadialVigCorrCoeffisLinked(self) -> bool"""
        return _hsi.BaseSrcPanoImage_RadialVigCorrCoeffisLinked(self)

    def RadialVigCorrCenterShiftisLinked(self):
        """RadialVigCorrCenterShiftisLinked(self) -> bool"""
        return _hsi.BaseSrcPanoImage_RadialVigCorrCenterShiftisLinked(self)

    def ExifModelisLinked(self):
        """ExifModelisLinked(self) -> bool"""
        return _hsi.BaseSrcPanoImage_ExifModelisLinked(self)

    def ExifMakeisLinked(self):
        """ExifMakeisLinked(self) -> bool"""
        return _hsi.BaseSrcPanoImage_ExifMakeisLinked(self)

    def ExifLensisLinked(self):
        """ExifLensisLinked(self) -> bool"""
        return _hsi.BaseSrcPanoImage_ExifLensisLinked(self)

    def ExifCropFactorisLinked(self):
        """ExifCropFactorisLinked(self) -> bool"""
        return _hsi.BaseSrcPanoImage_ExifCropFactorisLinked(self)

    def ExifFocalLengthisLinked(self):
        """ExifFocalLengthisLinked(self) -> bool"""
        return _hsi.BaseSrcPanoImage_ExifFocalLengthisLinked(self)

    def ExifOrientationisLinked(self):
        """ExifOrientationisLinked(self) -> bool"""
        return _hsi.BaseSrcPanoImage_ExifOrientationisLinked(self)

    def ExifApertureisLinked(self):
        """ExifApertureisLinked(self) -> bool"""
        return _hsi.BaseSrcPanoImage_ExifApertureisLinked(self)

    def ExifISOisLinked(self):
        """ExifISOisLinked(self) -> bool"""
        return _hsi.BaseSrcPanoImage_ExifISOisLinked(self)

    def ExifDistanceisLinked(self):
        """ExifDistanceisLinked(self) -> bool"""
        return _hsi.BaseSrcPanoImage_ExifDistanceisLinked(self)

    def ExifFocalLength35isLinked(self):
        """ExifFocalLength35isLinked(self) -> bool"""
        return _hsi.BaseSrcPanoImage_ExifFocalLength35isLinked(self)

    def ExifExposureTimeisLinked(self):
        """ExifExposureTimeisLinked(self) -> bool"""
        return _hsi.BaseSrcPanoImage_ExifExposureTimeisLinked(self)

    def ExifDateisLinked(self):
        """ExifDateisLinked(self) -> bool"""
        return _hsi.BaseSrcPanoImage_ExifDateisLinked(self)

    def ExifExposureModeisLinked(self):
        """ExifExposureModeisLinked(self) -> bool"""
        return _hsi.BaseSrcPanoImage_ExifExposureModeisLinked(self)

    def MasksisLinked(self):
        """MasksisLinked(self) -> bool"""
        return _hsi.BaseSrcPanoImage_MasksisLinked(self)

    def ActiveMasksisLinked(self):
        """ActiveMasksisLinked(self) -> bool"""
        return _hsi.BaseSrcPanoImage_ActiveMasksisLinked(self)

    def ActiveisLinked(self):
        """ActiveisLinked(self) -> bool"""
        return _hsi.BaseSrcPanoImage_ActiveisLinked(self)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def ActiveisLinkedWith(self, *args):
        """ActiveisLinkedWith(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__(self) -> SrcPanoImage
        __init__(self, string filename) -> SrcPanoImage
        """
        this = _hsi.new_SrcPanoImage(*args)
        try: self.this.append(this)
        except: self.this = this
    def hasEXIFread(self):
        """hasEXIFread(self) -> bool"""
        return _hsi.SrcPanoImage_hasEXIFread(self)

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

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

    def horizontalWarpNeeded(self):
        """horizontalWarpNeeded(self) -> bool"""
        return _hsi.SrcPanoImage_horizontalWarpNeeded(self)

    def getCorrectTCA(self):
        """getCorrectTCA(self) -> bool"""
        return _hsi.SrcPanoImage_getCorrectTCA(self)

    def setCropMode(self, *args):
        """setCropMode(self, CropMode val)"""
        return _hsi.SrcPanoImage_setCropMode(self, *args)

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

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

    def getRadialDistortionCenter(self):
        """getRadialDistortionCenter(self) -> FDiff2D"""
        return _hsi.SrcPanoImage_getRadialDistortionCenter(self)

    def getRadialVigCorrCenter(self):
        """getRadialVigCorrCenter(self) -> FDiff2D"""
        return _hsi.SrcPanoImage_getRadialVigCorrCenter(self)

    def getExposure(self):
        """getExposure(self) -> double"""
        return _hsi.SrcPanoImage_getExposure(self)

    def setExposure(self, *args):
        """setExposure(self, double val)"""
        return _hsi.SrcPanoImage_setExposure(self, *args)

    def getWidth(self):
        """getWidth(self) -> int"""
        return _hsi.SrcPanoImage_getWidth(self)

    def getHeight(self):
        """getHeight(self) -> int"""
        return _hsi.SrcPanoImage_getHeight(self)

    def getVar(self, *args):
        """getVar(self, string name) -> double"""
        return _hsi.SrcPanoImage_getVar(self, *args)

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

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

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

    def unlinkRadialVigCorrCoeff(self):
        """unlinkRadialVigCorrCoeff(self)"""
        return _hsi.SrcPanoImage_unlinkRadialVigCorrCoeff(self)

    def unlinkRadialVigCorrCenterShift(self):
        """unlinkRadialVigCorrCenterShift(self)"""
        return _hsi.SrcPanoImage_unlinkRadialVigCorrCenterShift(self)

    def unlinkEMoRParams(self):
        """unlinkEMoRParams(self)"""
        return _hsi.SrcPanoImage_unlinkEMoRParams(self)

    def linkRadialVigCorrCoeff(self, *args):
        """linkRadialVigCorrCoeff(self, SrcPanoImage target)"""
        return _hsi.SrcPanoImage_linkRadialVigCorrCoeff(self, *args)

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

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

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

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

    def calcHFOV(*args):
        """calcHFOV(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(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(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(self, double newFocalLength)"""
        return _hsi.SrcPanoImage_updateFocalLength(self, *args)

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

    def hasMasks(self):
        """hasMasks(self) -> bool"""
        return _hsi.SrcPanoImage_hasMasks(self)

    def hasPositiveMasks(self):
        """hasPositiveMasks(self) -> bool"""
        return _hsi.SrcPanoImage_hasPositiveMasks(self)

    def hasActiveMasks(self):
        """hasActiveMasks(self) -> bool"""
        return _hsi.SrcPanoImage_hasActiveMasks(self)

    def addMask(self, *args):
        """addMask(self, MaskPolygon newMask)"""
        return _hsi.SrcPanoImage_addMask(self, *args)

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

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

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

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

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

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

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

SrcPanoImage_swigregister = _hsi.SrcPanoImage_swigregister
SrcPanoImage_swigregister(SrcPanoImage)

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

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

def SrcPanoImage_calcCropFactor(*args):
  """SrcPanoImage_calcCropFactor(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__(self) -> ControlPoint
        __init__(self, unsigned int img1, double sX, double sY, unsigned int img2, 
            double dX, double dY, int mode = X_Y) -> ControlPoint
        __init__(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__(self, ControlPoint o) -> bool"""
        return _hsi.ControlPoint___eq__(self, *args)

    def getModeName(self, *args):
        """getModeName(self, OptimizeMode mode) -> string"""
        return _hsi.ControlPoint_getModeName(self, *args)

    def getCPString(self):
        """getCPString(self) -> string"""
        return _hsi.ControlPoint_getCPString(self)

    def mirror(self):
        """mirror(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__(self) -> Lens"""
        this = _hsi.new_Lens()
        try: self.this.append(this)
        except: self.this = this
    def getProjection(self):
        """getProjection(self) -> LensProjectionFormat"""
        return _hsi.Lens_getProjection(self)

    def setProjection(self, *args):
        """setProjection(self, LensProjectionFormat l)"""
        return _hsi.Lens_setProjection(self, *args)

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

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

    def getFocalLength(self):
        """getFocalLength(self) -> double"""
        return _hsi.Lens_getFocalLength(self)

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

    def setCropFactor(self, *args):
        """setCropFactor(self, double newCropFactor)"""
        return _hsi.Lens_setCropFactor(self, *args)

    def getAspectRatio(self):
        """getAspectRatio(self) -> double"""
        return _hsi.Lens_getAspectRatio(self)

    def isLandscape(self):
        """isLandscape(self) -> bool"""
        return _hsi.Lens_isLandscape(self)

    def setEV(self, *args):
        """setEV(self, double ev)"""
        return _hsi.Lens_setEV(self, *args)

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

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

    def update(self, *args):
        """update(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__(self) -> MaskPolygon"""
        this = _hsi.new_MaskPolygon()
        try: self.this.append(this)
        except: self.this = this
    def isInside(self, *args):
        """isInside(self, FDiff2D p) -> bool"""
        return _hsi.MaskPolygon_isInside(self, *args)

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

    def getTotalWindingNumber(self):
        """getTotalWindingNumber(self) -> int"""
        return _hsi.MaskPolygon_getTotalWindingNumber(self)

    def getMaskType(self):
        """getMaskType(self) -> MaskType"""
        return _hsi.MaskPolygon_getMaskType(self)

    def setMaskType(self, *args):
        """setMaskType(self, MaskType newType)"""
        return _hsi.MaskPolygon_setMaskType(self, *args)

    def isPositive(self):
        """isPositive(self) -> bool"""
        return _hsi.MaskPolygon_isPositive(self)

    def getMaskPolygon(self):
        """getMaskPolygon(self) -> VectorPolygon"""
        return _hsi.MaskPolygon_getMaskPolygon(self)

    def setMaskPolygon(self, *args):
        """setMaskPolygon(self, VectorPolygon newMask)"""
        return _hsi.MaskPolygon_setMaskPolygon(self, *args)

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

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

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

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

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

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

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

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

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

    def scale(self, *args):
        """
        scale(self, double factorx, double factory)
        scale(self, double factor)
        """
        return _hsi.MaskPolygon_scale(self, *args)

    def transformPolygon(self, *args):
        """transformPolygon(self, Transform trans)"""
        return _hsi.MaskPolygon_transformPolygon(self, *args)

    def clipPolygon(self, *args):
        """
        clipPolygon(self, Rect2D rect) -> bool
        clipPolygon(self, FDiff2D center, double radius) -> bool
        """
        return _hsi.MaskPolygon_clipPolygon(self, *args)

    def rotate90(self, *args):
        """rotate90(self, bool clockwise, unsigned int maskWidth, unsigned int maskHeight)"""
        return _hsi.MaskPolygon_rotate90(self, *args)

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

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

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

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

    def printPolygonLine(self, *args):
        """printPolygonLine(self, ostream o, unsigned int 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__(self) -> PanoramaMemento
        __init__(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__(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(self, UIntSet imgs) -> Panorama"""
        return _hsi.Panorama_getSubset(self, *args)

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

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

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

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

    def getImage(self, *args):
        """getImage(self, std::size_t nr) -> SrcPanoImage"""
        return _hsi.Panorama_getImage(self, *args)

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

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

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

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

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

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

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

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

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

    def getActiveImages(self):
        """getActiveImages(self) -> UIntSet"""
        return _hsi.Panorama_getActiveImages(self)

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

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

    def getCtrlPoints(self):
        """getCtrlPoints(self) -> CPVector"""
        return _hsi.Panorama_getCtrlPoints(self)

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

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

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

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

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

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

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

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

    def updateLineCtrlPoints(self):
        """updateLineCtrlPoints(self)"""
        return _hsi.Panorama_updateLineCtrlPoints(self)

    def updateCtrlPointErrors(self, *args):
        """
        updateCtrlPointErrors(self, CPVector controlPoints)
        updateCtrlPointErrors(self, UIntSet imgs, CPVector cps)
        """
        return _hsi.Panorama_updateCtrlPointErrors(self, *args)

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

    def getImageVariables(self, *args):
        """getImageVariables(self, unsigned int imgNr) -> VariableMap"""
        return _hsi.Panorama_getImageVariables(self, *args)

    def updateVariables(self, *args):
        """
        updateVariables(self, VariableMapVector vars)
        updateVariables(self, UIntSet imgs, VariableMapVector var)
        updateVariables(self, unsigned int imgNr, VariableMap var)
        """
        return _hsi.Panorama_updateVariables(self, *args)

    def updateVariable(self, *args):
        """updateVariable(self, unsigned int imgNr, Variable var)"""
        return _hsi.Panorama_updateVariable(self, *args)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def printPanoramaScript(self, *args):
        """
        printPanoramaScript(self, ostream o, OptimizeVector optvars, PanoramaOptions options, 
            UIntSet imgs, bool forPTOptimizer, string stripPrefix = "")
        printPanoramaScript(self, ostream o, OptimizeVector optvars, PanoramaOptions options, 
            UIntSet imgs, bool forPTOptimizer)
        """
        return _hsi.Panorama_printPanoramaScript(self, *args)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def readData(self, *args):
        """
        readData(self, istream dataInput, string documentType = "") -> ReadWriteError
        readData(self, istream dataInput) -> ReadWriteError
        """
        return _hsi.Panorama_readData(self, *args)

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

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

    def clearDirty(self):
        """clearDirty(self)"""
        return _hsi.Panorama_clearDirty(self)

    def setFilePrefix(self, *args):
        """setFilePrefix(self, string prefix)"""
        return _hsi.Panorama_setFilePrefix(self, *args)

    def reset(self):
        """reset(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__(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(self, Diff2D srcSize, VariableMap srcVars, LensProjectionFormat srcProj, 
            Diff2D destSize, ProjectionFormat destProj, 
            std::vector<(double,std::allocator<(double)>)> destProjParam, 
            double destHFOV, 
            Diff2D origSrcSize)
        createTransform(self, PanoramaData pano, unsigned int imgNr, PanoramaOptions dest, 
            Diff2D srcSize = vigra::Diff2D(0,0))
        createTransform(self, PanoramaData pano, unsigned int imgNr, PanoramaOptions dest)
        createTransform(self, SrcPanoImage src, PanoramaOptions dest)
        """
        return _hsi.Transform_createTransform(self, *args)

    def createInvTransform(self, *args):
        """
        createInvTransform(self, Diff2D srcSize, VariableMap srcVars, LensProjectionFormat srcProj, 
            Diff2D destSize, ProjectionFormat destProj, 
            std::vector<(double,std::allocator<(double)>)> destProjParam, 
            double destHFOV, 
            Diff2D origSrcSize)
        createInvTransform(self, PanoramaData pano, unsigned int imgNr, PanoramaOptions dest, 
            Diff2D srcSize = vigra::Diff2D(0,0))
        createInvTransform(self, PanoramaData pano, unsigned int imgNr, PanoramaOptions dest)
        createInvTransform(self, SrcPanoImage src, PanoramaOptions dest)
        """
        return _hsi.Transform_createInvTransform(self, *args)

    def transform(self, *args):
        """
        transform(self, double x_dest, double y_dest, double x_src, double y_src) -> bool
        transform(self, FDiff2D dest, FDiff2D src) -> bool
        """
        return _hsi.Transform_transform(self, *args)

    def transformImgCoordPartial(self, *args):
        """transformImgCoordPartial(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(self, double x_dest, double y_dest, double x_src, double y_src) -> bool
        transformImgCoord(self, FDiff2D dest, FDiff2D src) -> bool
        """
        return _hsi.Transform_transformImgCoord(self, *args)

    def emitGLSL(self, *args):
        """emitGLSL(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__(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(self, PanoramaData pano) -> bool"""
        return _hsi.AlignInfoWrap_setInfo(self, *args)

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

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

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

AlignInfoWrap_swigregister = _hsi.AlignInfoWrap_swigregister
AlignInfoWrap_swigregister(AlignInfoWrap)


def setDestImage(*args):
  """
    setDestImage(Image image, Diff2D size, unsigned char imageData, 
        ProjectionFormat format, std::vector<(double,std::allocator<(double)>)> projParams, 
        double destHFOV)
    """
  return _hsi.setDestImage(*args)

def setFullImage(*args):
  """
    setFullImage(Image image, Diff2D size, unsigned char imageData, 
        VariableMap vars, LensProjectionFormat 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, 
        VariableMap vars, LensProjectionFormat 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)>)> optvars)"""
  return _hsi.setOptVars(*args)

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

def GetAlignInfoCtrlPoints(*args):
  """GetAlignInfoCtrlPoints(AlignInfo gl) -> CPVector"""
  return _hsi.GetAlignInfoCtrlPoints(*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(self) -> bool"""
        return _hsi.PanoramaAlgorithm_modifiesPanoramaData(self)

    def hasRunSuccessfully(self):
        """hasRunSuccessfully(self) -> bool"""
        return _hsi.PanoramaAlgorithm_hasRunSuccessfully(self)

    def run(self):
        """run(self)"""
        return _hsi.PanoramaAlgorithm_run(self)

    def runAlgorithm(self):
        """runAlgorithm(self) -> bool"""
        return _hsi.PanoramaAlgorithm_runAlgorithm(self)

PanoramaAlgorithm_swigregister = _hsi.PanoramaAlgorithm_swigregister
PanoramaAlgorithm_swigregister(PanoramaAlgorithm)

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

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(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(self) -> bool"""
        return _hsi.StitcherAlgorithm_runAlgorithm(self)

    def modifiesPanoramaData(self):
        """modifiesPanoramaData(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__(self, PanoramaData pano_, AssistantPrograms progs_, bool runLinefind_, 
            bool runCeleste_, double celesteThreshold_, 
            bool celesteSmallRadius_, bool runCPClean_, 
            double scale_, ostream makefile_, 
            string projectFile_) -> AssistantMakefilelibExport
        """
        this = _hsi.new_AssistantMakefilelibExport(*args)
        try: self.this.append(this)
        except: self.this = this
    def createMakefile(*args):
        """
        createMakefile(PanoramaData pano_, AssistantPrograms progs_, bool runLinefind_, 
            bool runCeleste_, double celesteThreshold_, 
            bool celesteSmallRadius_, bool runCPClean_, 
            double scale_, ostream makefile_, 
            string projectFile_)
        """
        return _hsi.AssistantMakefilelibExport_createMakefile(*args)

    if _newclass:createMakefile = staticmethod(createMakefile)
    __swig_getmethods__["createMakefile"] = lambda x: createMakefile
    def modifiesPanoramaData(self):
        """modifiesPanoramaData(self) -> bool"""
        return _hsi.AssistantMakefilelibExport_modifiesPanoramaData(self)

    def runAlgorithm(self):
        """runAlgorithm(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_, AssistantPrograms progs_, bool runLinefind_, 
        bool runCeleste_, double celesteThreshold_, 
        bool celesteSmallRadius_, bool runCPClean_, 
        double scale_, ostream makefile_, 
        string 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(self) -> bool"""
        return _hsi.CalculateCPStatistics_modifiesPanoramaData(self)

    def runAlgorithm(self):
        """runAlgorithm(self) -> bool"""
        return _hsi.CalculateCPStatistics_runAlgorithm(self)

    def getResultMin(self):
        """getResultMin(self) -> double"""
        return _hsi.CalculateCPStatistics_getResultMin(self)

    def getResultMax(self):
        """getResultMax(self) -> double"""
        return _hsi.CalculateCPStatistics_getResultMax(self)

    def getResultMean(self):
        """getResultMean(self) -> double"""
        return _hsi.CalculateCPStatistics_getResultMean(self)

    def getResultVariance(self):
        """getResultVariance(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__(self, PanoramaData panorama, int imgNr = -1) -> CalculateCPStatisticsError
        __init__(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 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(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 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__(self, PanoramaData panorama, int imgNr = -1) -> CalculateCPStatisticsRadial
        __init__(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 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(self) -> double"""
        return _hsi.CalculateCPStatisticsRadial_getResultPercentile10(self)

    def getResultPercentile90(self):
        """getResultPercentile90(self) -> double"""
        return _hsi.CalculateCPStatisticsRadial_getResultPercentile90(self)

    def runAlgorithm(self):
        """runAlgorithm(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 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__(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(self) -> bool"""
        return _hsi.CalculateMeanExposure_modifiesPanoramaData(self)

    def runAlgorithm(self):
        """runAlgorithm(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(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__(self, PanoramaData panorama, bool intersect = False) -> CalculateOptimalROI
        __init__(self, PanoramaData panorama) -> 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(self) -> bool"""
        return _hsi.CalculateOptimalROI_modifiesPanoramaData(self)

    def runAlgorithm(self):
        """runAlgorithm(self) -> bool"""
        return _hsi.CalculateOptimalROI_runAlgorithm(self)

    def calcOptimalROI(self, *args):
        """calcOptimalROI(self, PanoramaData panorama) -> bool"""
        return _hsi.CalculateOptimalROI_calcOptimalROI(self, *args)

    def getResultOptimalROI(self):
        """getResultOptimalROI(self) -> Rect2D"""
        return _hsi.CalculateOptimalROI_getResultOptimalROI(self)

    def getResultOptimalSize(self):
        """getResultOptimalSize(self) -> Size2D"""
        return _hsi.CalculateOptimalROI_getResultOptimalSize(self)

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__(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(self) -> bool"""
        return _hsi.CalculateOptimalScale_modifiesPanoramaData(self)

    def runAlgorithm(self):
        """runAlgorithm(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(self) -> double"""
        return _hsi.CalculateOptimalScale_getResultOptimalScale(self)

    def getResultOptimalWidth(self):
        """getResultOptimalWidth(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__(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(self) -> bool"""
        return _hsi.SetWidthOptimal_modifiesPanoramaData(self)

    def runAlgorithm(self):
        """runAlgorithm(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__(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(self, unsigned int steps)"""
        return _hsi.CalculateImageOverlap_calculate(self, *args)

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

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

    def getOverlapForImage(self, *args):
        """getOverlapForImage(self, unsigned int i) -> 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__(self, PanoramaData panorama, Matrix3 transformMat) -> RotatePanorama
        __init__(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 transformMat)"""
        return _hsi.RotatePanorama_rotatePano(*args)

    if _newclass:rotatePano = staticmethod(rotatePano)
    __swig_getmethods__["rotatePano"] = lambda x: rotatePano
    def modifiesPanoramaData(self):
        """modifiesPanoramaData(self) -> bool"""
        return _hsi.RotatePanorama_modifiesPanoramaData(self)

    def runAlgorithm(self):
        """runAlgorithm(self) -> bool"""
        return _hsi.RotatePanorama_runAlgorithm(self)

RotatePanorama_swigregister = _hsi.RotatePanorama_swigregister
RotatePanorama_swigregister(RotatePanorama)

def RotatePanorama_rotatePano(*args):
  """RotatePanorama_rotatePano(PanoramaData panorama, Matrix3 transformMat)"""
  return _hsi.RotatePanorama_rotatePano(*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__(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(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__(self, PanoramaData panorama, double x, double y, double z) -> TranslatePanorama
        __init__(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 x, double y, double z)"""
        return _hsi.TranslatePanorama_translatePano(*args)

    if _newclass:translatePano = staticmethod(translatePano)
    __swig_getmethods__["translatePano"] = lambda x: translatePano
    def modifiesPanoramaData(self):
        """modifiesPanoramaData(self) -> bool"""
        return _hsi.TranslatePanorama_modifiesPanoramaData(self)

    def runAlgorithm(self):
        """runAlgorithm(self) -> bool"""
        return _hsi.TranslatePanorama_runAlgorithm(self)

TranslatePanorama_swigregister = _hsi.TranslatePanorama_swigregister
TranslatePanorama_swigregister(TranslatePanorama)

def TranslatePanorama_translatePano(*args):
  """TranslatePanorama_translatePano(PanoramaData panorama, double x, double y, double z)"""
  return _hsi.TranslatePanorama_translatePano(*args)


def getCPinMasks(*args):
  """getCPinMasks(Panorama pano) -> 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__(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(self) -> bool"""
        return _hsi.CalculateFOV_modifiesPanoramaData(self)

    def runAlgorithm(self):
        """runAlgorithm(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(self) -> double"""
        return _hsi.CalculateFOV_getResultHorizontalFOV(self)

    def getResultVerticalFOV(self):
        """getResultVerticalFOV(self) -> double"""
        return _hsi.CalculateFOV_getResultVerticalFOV(self)

    def getResultFOV(self):
        """getResultFOV(self) -> FDiff2D"""
        return _hsi.CalculateFOV_getResultFOV(self)

CalculateFOV_swigregister = _hsi.CalculateFOV_swigregister
CalculateFOV_swigregister(CalculateFOV)

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

def getCPoutsideLimit(*args):
  """
    getCPoutsideLimit(Panorama pano, double n = 2.0, bool skipOptimisation = False) -> UIntSet
    getCPoutsideLimit(Panorama pano, double n = 2.0) -> UIntSet
    getCPoutsideLimit(Panorama pano) -> UIntSet
    """
  return _hsi.getCPoutsideLimit(*args)

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__(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(self) -> bool"""
        return _hsi.CenterHorizontally_modifiesPanoramaData(self)

    def runAlgorithm(self):
        """runAlgorithm(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__(self, PanoramaData panorama, UIntSet 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(self) -> bool"""
        return _hsi.ComputeImageROI_modifiesPanoramaData(self)

    def runAlgorithm(self):
        """runAlgorithm(self) -> bool"""
        return _hsi.ComputeImageROI_runAlgorithm(self)

    def getROIS(self):
        """getROIS(self) -> std::vector<(vigra::Rect2D,std::allocator<(vigra::Rect2D)>)>"""
        return _hsi.ComputeImageROI_getROIS(self)

    def computeROIS(*args):
        """computeROIS(PanoramaData panorama, PanoramaOptions opts, UIntSet 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, UIntSet 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__(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(self) -> bool"""
        return _hsi.CalculateFitPanorama_modifiesPanoramaData(self)

    def runAlgorithm(self):
        """runAlgorithm(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(self) -> double"""
        return _hsi.CalculateFitPanorama_getResultHorizontalFOV(self)

    def getResultHeight(self):
        """getResultHeight(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__(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(self) -> bool"""
        return _hsi.FitPanorama_modifiesPanoramaData(self)

    def runAlgorithm(self):
        """runAlgorithm(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__(self, PanoramaData panoramaData, AppBase::ProgressDisplay progressDisplay, 
            PanoramaOptions options, UIntSet usedImages, 
            String 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__(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(self) -> bool"""
        return _hsi.PTOptimizer_modifiesPanoramaData(self)

    def runAlgorithm(self):
        """runAlgorithm(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__(self, PanoramaData panorama, int i1, int i2, double maxError, 
            Mode mode = RPY) -> RANSACOptimizer
        __init__(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(self) -> bool"""
        return _hsi.RANSACOptimizer_modifiesPanoramaData(self)

    def findInliers(*args):
        """
        findInliers(PanoramaData pano, int i1, int i2, double maxError, 
            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(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, 
        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__(self, PanoramaData panorama, bool optRoll = True) -> AutoOptimise
        __init__(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(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__(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__(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(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__(self, PanoramaData panorama, AppBase::ProgressDisplay progressDisplay, 
            OptimizeVector vars, PointPairs 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, PointPairs 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(self) -> bool"""
        return _hsi.PhotometricOptimizer_modifiesPanoramaData(self)

    def runAlgorithm(self):
        """runAlgorithm(self) -> bool"""
        return _hsi.PhotometricOptimizer_runAlgorithm(self)

    def getResultError(self):
        """getResultError(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, PointPairs 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__(self, PanoramaData panorama, AppBase::ProgressDisplay progressDisplay, 
            OptimizeVector vars, PointPairs correspondences, 
            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, PhotometricOptimizeMode mode, std::vector<(vigra_ext::PointPairRGB,std::allocator<(vigra_ext::PointPairRGB)>)> 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(self) -> bool"""
        return _hsi.SmartPhotometricOptimizer_runAlgorithm(self)

SmartPhotometricOptimizer_swigregister = _hsi.SmartPhotometricOptimizer_swigregister
SmartPhotometricOptimizer_swigregister(SmartPhotometricOptimizer)

def SmartPhotometricOptimizer_smartOptimizePhotometric(*args):
  """
    SmartPhotometricOptimizer_smartOptimizePhotometric(PanoramaData pano, PhotometricOptimizeMode mode, std::vector<(vigra_ext::PointPairRGB,std::allocator<(vigra_ext::PointPairRGB)>)> correspondences, 
        AppBase::ProgressReporter progress, 
        double error)
    """
  return _hsi.SmartPhotometricOptimizer_smartOptimizePhotometric(*args)


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

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

def getImagesinROI(*args):
  """getImagesinROI(PanoramaData pano, UIntSet activeImages) -> UIntSet"""
  return _hsi.getImagesinROI(*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__(self, PanoramaData pano_, UIntSet images_, string ptofile_, 
            string outputPrefix_, PTPrograms progs_, string includePath_, 
            std::vector<(std::string,std::allocator<(std::string)>)> outputFiles_, 
            ostream makefile_, 
            string tmpDir_, bool copyMetadata_, 
            int nrThreads_) -> PanoramaMakefilelibExport
        """
        this = _hsi.new_PanoramaMakefilelibExport(*args)
        try: self.this.append(this)
        except: self.this = this
    def createMakefile(*args):
        """
        createMakefile(PanoramaData pano_, UIntSet images_, string ptofile_, 
            string outputPrefix_, PTPrograms progs_, string includePath_, 
            std::vector<(std::string,std::allocator<(std::string)>)> outputFiles_, 
            ostream makefile_, 
            string tmpDir_, bool copyMetadata_, 
            int nrThreads_)
        """
        return _hsi.PanoramaMakefilelibExport_createMakefile(*args)

    if _newclass:createMakefile = staticmethod(createMakefile)
    __swig_getmethods__["createMakefile"] = lambda x: createMakefile
    def modifiesPanoramaData(self):
        """modifiesPanoramaData(self) -> bool"""
        return _hsi.PanoramaMakefilelibExport_modifiesPanoramaData(self)

    def runAlgorithm(self):
        """runAlgorithm(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_, UIntSet images_, string ptofile_, 
        string outputPrefix_, PTPrograms progs_, string includePath_, 
        std::vector<(std::string,std::allocator<(std::string)>)> outputFiles_, 
        ostream makefile_, 
        string tmpDir_, bool copyMetadata_, 
        int nrThreads_)
    """
  return _hsi.PanoramaMakefilelibExport_createMakefile(*args)


def printstacks(*args):
  """printstacks(std::vector<(HuginBase::UIntSet,std::allocator<(HuginBase::UIntSet)>)> 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<(p.vigra::FRGBImage,std::allocator<(p.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(self) -> bool"""
        return _hsi.PointSampler_modifiesPanoramaData(self)

    def runAlgorithm(self):
        """runAlgorithm(self) -> bool"""
        return _hsi.PointSampler_runAlgorithm(self)

    def execute(self):
        """execute(self) -> PointSampler"""
        return _hsi.PointSampler_execute(self)

    def getResultPoints(self):
        """getResultPoints(self) -> PointPairs"""
        return _hsi.PointSampler_getResultPoints(self)

PointSampler_swigregister = _hsi.PointSampler_swigregister
PointSampler_swigregister(PointSampler)

def PointSampler_extractPoints(*args):
  """
    PointSampler_extractPoints(PanoramaData pano, std::vector<(p.vigra::FRGBImage,std::allocator<(p.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__(self, PanoramaData panorama, AppBase::ProgressDisplay progressDisplay, 
            std::vector<(p.vigra::FRGBImage,std::allocator<(p.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__(self, PanoramaData panorama, AppBase::ProgressDisplay progressDisplay, 
            std::vector<(p.vigra::FRGBImage,std::allocator<(p.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.