# This file was automatically generated by SWIG (http://www.swig.org).
# Version 4.0.2
#
# Do not make changes to this file unless you know what you are doing--modify
# the SWIG interface file instead.

from sys import version_info as _swig_python_version_info
if _swig_python_version_info < (2, 7, 0):
    raise RuntimeError("Python 2.7 or later required")

# Import the low-level C/C++ module
if __package__ or "." in __name__:
    from . import _hsi
else:
    import _hsi

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

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


def _swig_setattr_nondynamic_instance_variable(set):
    def set_instance_attr(self, name, value):
        if name == "thisown":
            self.this.own(value)
        elif name == "this":
            set(self, name, value)
        elif hasattr(self, name) and isinstance(getattr(type(self), name), property):
            set(self, name, value)
        else:
            raise AttributeError("You cannot add instance attributes to %s" % self)
    return set_instance_attr


def _swig_setattr_nondynamic_class_variable(set):
    def set_class_attr(cls, name, value):
        if hasattr(cls, name) and not isinstance(getattr(cls, name), property):
            set(cls, name, value)
        else:
            raise AttributeError("You cannot add class attributes to %s" % cls)
    return set_class_attr


def _swig_add_metaclass(metaclass):
    """Class decorator for adding a metaclass to a SWIG wrapped class - a slimmed down version of six.add_metaclass"""
    def wrapper(cls):
        return metaclass(cls.__name__, cls.__bases__, cls.__dict__.copy())
    return wrapper


class _SwigNonDynamicMeta(type):
    """Meta class to enforce nondynamic attributes (no new attributes) for a class"""
    __setattr__ = _swig_setattr_nondynamic_class_variable(type.__setattr__)


class SwigPyIterator(object):
    r"""Proxy of C++ swig::SwigPyIterator class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

# Register SwigPyIterator in _hsi:
_hsi.SwigPyIterator_swigregister(SwigPyIterator)

class ios_base(object):
    r"""Proxy of C++ std::ios_base class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

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

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

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

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

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

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

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

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

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

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

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

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

# Register ios_base in _hsi:
_hsi.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):
    r"""ios_base_sync_with_stdio(bool __sync=True) -> bool"""
    return _hsi.ios_base_sync_with_stdio(__sync)

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

class ios(ios_base):
    r"""Proxy of C++ std::basic_ios< char > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

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

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

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

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

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

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

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

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

    def __init__(self, __sb):
        r"""__init__(ios self, std::basic_streambuf< char,std::char_traits< char > > * __sb) -> ios"""
        _hsi.ios_swiginit(self, _hsi.new_ios(__sb))
    __swig_destroy__ = _hsi.delete_ios

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

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

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

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

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

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

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

# Register ios in _hsi:
_hsi.ios_swigregister(ios)

class ostream(ios):
    r"""Proxy of C++ std::basic_ostream< char > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, __sb):
        r"""__init__(ostream self, std::basic_streambuf< char,std::char_traits< char > > * __sb) -> ostream"""
        _hsi.ostream_swiginit(self, _hsi.new_ostream(__sb))
    __swig_destroy__ = _hsi.delete_ostream

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

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

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

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

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

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

# Register ostream in _hsi:
_hsi.ostream_swigregister(ostream)
cin = cvar.cin
cout = cvar.cout
cerr = cvar.cerr
clog = cvar.clog

class istream(ios):
    r"""Proxy of C++ std::basic_istream< char > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, __sb):
        r"""__init__(istream self, std::basic_streambuf< char,std::char_traits< char > > * __sb) -> istream"""
        _hsi.istream_swiginit(self, _hsi.new_istream(__sb))
    __swig_destroy__ = _hsi.delete_istream

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

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

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

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

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

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

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

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

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

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

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

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

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

# Register istream in _hsi:
_hsi.istream_swigregister(istream)

class iostream(istream, ostream):
    r"""Proxy of C++ std::basic_iostream< char > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, __sb):
        r"""__init__(iostream self, std::basic_streambuf< char,std::char_traits< char > > * __sb) -> iostream"""
        _hsi.iostream_swiginit(self, _hsi.new_iostream(__sb))
    __swig_destroy__ = _hsi.delete_iostream

# Register iostream in _hsi:
_hsi.iostream_swigregister(iostream)

endl_cb_ptr = _hsi.endl_cb_ptr

endl = _hsi.endl
ends_cb_ptr = _hsi.ends_cb_ptr

ends = _hsi.ends
flush_cb_ptr = _hsi.flush_cb_ptr

flush = _hsi.flush
class ifstream(istream):
    r"""Proxy of C++ std::ifstream class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, filename):
        r"""__init__(ifstream self, char * filename) -> ifstream"""
        _hsi.ifstream_swiginit(self, _hsi.new_ifstream(filename))
    __swig_destroy__ = _hsi.delete_ifstream

# Register ifstream in _hsi:
_hsi.ifstream_swigregister(ifstream)

class ofstream(ostream):
    r"""Proxy of C++ std::ofstream class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, filename):
        r"""__init__(ofstream self, char * filename) -> ofstream"""
        _hsi.ofstream_swiginit(self, _hsi.new_ofstream(filename))
    __swig_destroy__ = _hsi.delete_ofstream

# Register ofstream in _hsi:
_hsi.ofstream_swigregister(ofstream)

class UIntVector(object):
    r"""Proxy of C++ std::vector< unsigned int > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def __init__(self, *args):
        r"""
        __init__(UIntVector self) -> UIntVector
        __init__(UIntVector self, UIntVector other) -> UIntVector
        __init__(UIntVector self, std::vector< unsigned int >::size_type size) -> UIntVector
        __init__(UIntVector self, std::vector< unsigned int >::size_type size, std::vector< unsigned int >::value_type const & value) -> UIntVector
        """
        _hsi.UIntVector_swiginit(self, _hsi.new_UIntVector(*args))

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

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

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

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

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

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

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

    def capacity(self):
        r"""capacity(UIntVector self) -> std::vector< unsigned int >::size_type"""
        return _hsi.UIntVector_capacity(self)
    __swig_destroy__ = _hsi.delete_UIntVector

# Register UIntVector in _hsi:
_hsi.UIntVector_swigregister(UIntVector)

class UIntSet(object):
    r"""Proxy of C++ std::set< unsigned int > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

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

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

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

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

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

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

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

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

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

    def __init__(self, *args):
        r"""
        __init__(UIntSet self, std::less< unsigned int > const & other) -> UIntSet
        __init__(UIntSet self) -> UIntSet
        __init__(UIntSet self, UIntSet other) -> UIntSet
        """
        _hsi.UIntSet_swiginit(self, _hsi.new_UIntSet(*args))

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

# Register UIntSet in _hsi:
_hsi.UIntSet_swigregister(UIntSet)

class DoubleVector(object):
    r"""Proxy of C++ std::vector< double > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def __init__(self, *args):
        r"""
        __init__(DoubleVector self) -> DoubleVector
        __init__(DoubleVector self, DoubleVector other) -> DoubleVector
        __init__(DoubleVector self, std::vector< double >::size_type size) -> DoubleVector
        __init__(DoubleVector self, std::vector< double >::size_type size, std::vector< double >::value_type const & value) -> DoubleVector
        """
        _hsi.DoubleVector_swiginit(self, _hsi.new_DoubleVector(*args))

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

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

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

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

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

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

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

    def capacity(self):
        r"""capacity(DoubleVector self) -> std::vector< double >::size_type"""
        return _hsi.DoubleVector_capacity(self)
    __swig_destroy__ = _hsi.delete_DoubleVector

# Register DoubleVector in _hsi:
_hsi.DoubleVector_swigregister(DoubleVector)

class Size2D(object):
    r"""Proxy of C++ vigra::Size2D class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    x = property(_hsi.Size2D_x_get, _hsi.Size2D_x_set, doc=r"""x : int""")
    y = property(_hsi.Size2D_y_get, _hsi.Size2D_y_set, doc=r"""y : int""")

    def __init__(self, *args):
        r"""
        __init__(Size2D self) -> Size2D
        __init__(Size2D self, int ix, int iy) -> Size2D
        """
        _hsi.Size2D_swiginit(self, _hsi.new_Size2D(*args))

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

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

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

    def setHeight(self, h):
        r"""setHeight(Size2D self, int h)"""
        return _hsi.Size2D_setHeight(self, h)
    __swig_destroy__ = _hsi.delete_Size2D

# Register Size2D in _hsi:
_hsi.Size2D_swigregister(Size2D)

class Point2D(object):
    r"""Proxy of C++ vigra::Point2D class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    x = property(_hsi.Point2D_x_get, _hsi.Point2D_x_set, doc=r"""x : int""")
    y = property(_hsi.Point2D_y_get, _hsi.Point2D_y_set, doc=r"""y : int""")

    def __init__(self, *args):
        r"""
        __init__(Point2D self) -> Point2D
        __init__(Point2D self, int ix, int iy) -> Point2D
        """
        _hsi.Point2D_swiginit(self, _hsi.new_Point2D(*args))
    __swig_destroy__ = _hsi.delete_Point2D

# Register Point2D in _hsi:
_hsi.Point2D_swigregister(Point2D)

class Rect2D(object):
    r"""Proxy of C++ vigra::Rect2D class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(Rect2D self) -> Rect2D
        __init__(Rect2D self, int l, int t, int r, int b) -> Rect2D
        """
        _hsi.Rect2D_swiginit(self, _hsi.new_Rect2D(*args))

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

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

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

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

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

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

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

    def height(self):
        r"""height(Rect2D self) -> int"""
        return _hsi.Rect2D_height(self)
    __swig_destroy__ = _hsi.delete_Rect2D

# Register Rect2D in _hsi:
_hsi.Rect2D_swigregister(Rect2D)

class FDiff2D(object):
    r"""Proxy of C++ hugin_utils::FDiff2D class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    x = property(_hsi.FDiff2D_x_get, _hsi.FDiff2D_x_set, doc=r"""x : double""")
    y = property(_hsi.FDiff2D_y_get, _hsi.FDiff2D_y_set, doc=r"""y : double""")

    def __init__(self, *args):
        r"""
        __init__(FDiff2D self) -> FDiff2D
        __init__(FDiff2D self, double ix, double iy) -> FDiff2D
        """
        _hsi.FDiff2D_swiginit(self, _hsi.new_FDiff2D(*args))
    __swig_destroy__ = _hsi.delete_FDiff2D

# Register FDiff2D in _hsi:
_hsi.FDiff2D_swigregister(FDiff2D)

class tm(object):
    r"""Proxy of C++ tm class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    tm_sec = property(_hsi.tm_tm_sec_get, _hsi.tm_tm_sec_set, doc=r"""tm_sec : int""")
    tm_min = property(_hsi.tm_tm_min_get, _hsi.tm_tm_min_set, doc=r"""tm_min : int""")
    tm_hour = property(_hsi.tm_tm_hour_get, _hsi.tm_tm_hour_set, doc=r"""tm_hour : int""")
    tm_mday = property(_hsi.tm_tm_mday_get, _hsi.tm_tm_mday_set, doc=r"""tm_mday : int""")
    tm_mon = property(_hsi.tm_tm_mon_get, _hsi.tm_tm_mon_set, doc=r"""tm_mon : int""")
    tm_year = property(_hsi.tm_tm_year_get, _hsi.tm_tm_year_set, doc=r"""tm_year : int""")
    tm_wday = property(_hsi.tm_tm_wday_get, _hsi.tm_tm_wday_set, doc=r"""tm_wday : int""")
    tm_yday = property(_hsi.tm_tm_yday_get, _hsi.tm_tm_yday_set, doc=r"""tm_yday : int""")
    tm_isdst = property(_hsi.tm_tm_isdst_get, _hsi.tm_tm_isdst_set, doc=r"""tm_isdst : int""")

    def __init__(self):
        r"""__init__(tm self) -> tm"""
        _hsi.tm_swiginit(self, _hsi.new_tm())
    __swig_destroy__ = _hsi.delete_tm

# Register tm in _hsi:
_hsi.tm_swigregister(tm)

class DocumentData(object):
    r"""Proxy of C++ AppBase::DocumentData class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

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

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

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

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

# Register DocumentData in _hsi:
_hsi.DocumentData_swigregister(DocumentData)

class PanoramaData(object):
    r"""Proxy of C++ HuginBase::PanoramaData class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

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

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

    def getUnlinkedSubset(self, imageGroups):
        r"""getUnlinkedSubset(PanoramaData self, HuginBase::UIntSetVector & imageGroups) -> PanoramaData"""
        return _hsi.PanoramaData_getUnlinkedSubset(self, imageGroups)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def linkImageVariableFileMetadata(self, sourceImgNr, destImgNr):
        r"""linkImageVariableFileMetadata(PanoramaData self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.PanoramaData_linkImageVariableFileMetadata(self, sourceImgNr, destImgNr)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def unlinkImageVariableFileMetadata(self, imgNr):
        r"""unlinkImageVariableFileMetadata(PanoramaData self, unsigned int imgNr)"""
        return _hsi.PanoramaData_unlinkImageVariableFileMetadata(self, imgNr)

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

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

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

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

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

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

    def getCtrlPointsForImage(self, imgNr):
        r"""getCtrlPointsForImage(PanoramaData self, unsigned int imgNr) -> UIntVector"""
        return _hsi.PanoramaData_getCtrlPointsForImage(self, imgNr)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

# Register PanoramaData in _hsi:
_hsi.PanoramaData_swigregister(PanoramaData)

class PanoramaObserver(object):
    r"""Proxy of C++ HuginBase::PanoramaObserver class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

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

    def panoramaImagesChanged(self, pano, changed):
        r"""panoramaImagesChanged(PanoramaObserver self, Panorama pano, UIntSet changed)"""
        return _hsi.PanoramaObserver_panoramaImagesChanged(self, pano, changed)

# Register PanoramaObserver in _hsi:
_hsi.PanoramaObserver_swigregister(PanoramaObserver)

class PanoramaDataMemento(object):
    r"""Proxy of C++ HuginBase::PanoramaDataMemento class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

# Register PanoramaDataMemento in _hsi:
_hsi.PanoramaDataMemento_swigregister(PanoramaDataMemento)

class ManagedPanoramaData(PanoramaData):
    r"""Proxy of C++ HuginBase::ManagedPanoramaData class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

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

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

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

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

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

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

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

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

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

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

# Register ManagedPanoramaData in _hsi:
_hsi.ManagedPanoramaData_swigregister(ManagedPanoramaData)

class CPoint(object):
    r"""Proxy of C++ std::pair< unsigned int,ControlPoint > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(CPoint self) -> CPoint
        __init__(CPoint self, unsigned int first, ControlPoint second) -> CPoint
        __init__(CPoint self, CPoint other) -> CPoint
        """
        _hsi.CPoint_swiginit(self, _hsi.new_CPoint(*args))
    first = property(_hsi.CPoint_first_get, _hsi.CPoint_first_set, doc=r"""first : unsigned int""")
    second = property(_hsi.CPoint_second_get, _hsi.CPoint_second_set, doc=r"""second : ControlPoint""")
    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

# Register CPoint in _hsi:
_hsi.CPoint_swigregister(CPoint)

class CPointVector(object):
    r"""Proxy of C++ std::vector< std::pair< unsigned int,ControlPoint > > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def __init__(self, *args):
        r"""
        __init__(CPointVector self) -> CPointVector
        __init__(CPointVector self, std::vector< std::pair< unsigned int,HuginBase::ControlPoint > > const & other) -> CPointVector
        __init__(CPointVector self, std::vector< std::pair< unsigned int,ControlPoint > >::size_type size) -> CPointVector
        __init__(CPointVector self, std::vector< std::pair< unsigned int,ControlPoint > >::size_type size, std::vector< std::pair< unsigned int,ControlPoint > >::value_type const & value) -> CPointVector
        """
        _hsi.CPointVector_swiginit(self, _hsi.new_CPointVector(*args))

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

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

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

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

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

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

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

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

# Register CPointVector in _hsi:
_hsi.CPointVector_swigregister(CPointVector)

class CPVector(object):
    r"""Proxy of C++ std::vector< ControlPoint > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def __init__(self, *args):
        r"""
        __init__(CPVector self) -> CPVector
        __init__(CPVector self, CPVector other) -> CPVector
        __init__(CPVector self, std::vector< ControlPoint >::size_type size) -> CPVector
        __init__(CPVector self, std::vector< ControlPoint >::size_type size, ControlPoint value) -> CPVector
        """
        _hsi.CPVector_swiginit(self, _hsi.new_CPVector(*args))

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

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

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

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

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

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

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

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

# Register CPVector in _hsi:
_hsi.CPVector_swigregister(CPVector)

class ImageVector(object):
    r"""Proxy of C++ std::vector< SrcPanoImage > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def __init__(self, *args):
        r"""
        __init__(ImageVector self) -> ImageVector
        __init__(ImageVector self, ImageVector other) -> ImageVector
        __init__(ImageVector self, std::vector< SrcPanoImage >::size_type size) -> ImageVector
        __init__(ImageVector self, std::vector< SrcPanoImage >::size_type size, SrcPanoImage value) -> ImageVector
        """
        _hsi.ImageVector_swiginit(self, _hsi.new_ImageVector(*args))

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

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

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

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

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

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

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

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

# Register ImageVector in _hsi:
_hsi.ImageVector_swigregister(ImageVector)

class LensVarMap(object):
    r"""Proxy of C++ std::map< std::string,LensVariable > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

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

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

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

    def __len__(self):
        r"""__len__(LensVarMap self) -> std::map< std::string,LensVariable >::size_type"""
        return _hsi.LensVarMap___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

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

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

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

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

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

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

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

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

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

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

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

    def __init__(self, *args):
        r"""
        __init__(LensVarMap self, std::less< std::string > const & other) -> LensVarMap
        __init__(LensVarMap self) -> LensVarMap
        __init__(LensVarMap self, LensVarMap other) -> LensVarMap
        """
        _hsi.LensVarMap_swiginit(self, _hsi.new_LensVarMap(*args))

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

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

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

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

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

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

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

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

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

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

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

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

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

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

# Register LensVarMap in _hsi:
_hsi.LensVarMap_swigregister(LensVarMap)

class OptimizeVector(object):
    r"""Proxy of C++ std::vector< std::set< std::string > > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def __init__(self, *args):
        r"""
        __init__(OptimizeVector self) -> OptimizeVector
        __init__(OptimizeVector self, OptimizeVector other) -> OptimizeVector
        __init__(OptimizeVector self, std::vector< std::set< std::string > >::size_type size) -> OptimizeVector
        __init__(OptimizeVector self, std::vector< std::set< std::string > >::size_type size, std::vector< std::set< std::string > >::value_type const & value) -> OptimizeVector
        """
        _hsi.OptimizeVector_swiginit(self, _hsi.new_OptimizeVector(*args))

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

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

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

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

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

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

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

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

# Register OptimizeVector in _hsi:
_hsi.OptimizeVector_swigregister(OptimizeVector)

class VariableMap(object):
    r"""Proxy of C++ std::map< std::string,Variable > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

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

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

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

    def __len__(self):
        r"""__len__(VariableMap self) -> std::map< std::string,Variable >::size_type"""
        return _hsi.VariableMap___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

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

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

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

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

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

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

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

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

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

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

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

    def __init__(self, *args):
        r"""
        __init__(VariableMap self, std::less< std::string > const & other) -> VariableMap
        __init__(VariableMap self) -> VariableMap
        __init__(VariableMap self, VariableMap other) -> VariableMap
        """
        _hsi.VariableMap_swiginit(self, _hsi.new_VariableMap(*args))

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

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

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

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

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

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

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

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

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

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

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

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

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

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

# Register VariableMap in _hsi:
_hsi.VariableMap_swigregister(VariableMap)

class VariableMapVector(object):
    r"""Proxy of C++ std::vector< std::map< std::string,Variable > > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def __init__(self, *args):
        r"""
        __init__(VariableMapVector self) -> VariableMapVector
        __init__(VariableMapVector self, std::vector< std::map< std::string,HuginBase::Variable,std::less< std::string >,std::allocator< std::pair< std::string const,HuginBase::Variable > > > > const & other) -> VariableMapVector
        __init__(VariableMapVector self, std::vector< std::map< std::string,Variable > >::size_type size) -> VariableMapVector
        __init__(VariableMapVector self, std::vector< std::map< std::string,Variable > >::size_type size, std::vector< std::map< std::string,Variable > >::value_type const & value) -> VariableMapVector
        """
        _hsi.VariableMapVector_swiginit(self, _hsi.new_VariableMapVector(*args))

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

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

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

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

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

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

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

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

# Register VariableMapVector in _hsi:
_hsi.VariableMapVector_swigregister(VariableMapVector)

class MaskPolygonVector(object):
    r"""Proxy of C++ std::vector< MaskPolygon > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def __init__(self, *args):
        r"""
        __init__(MaskPolygonVector self) -> MaskPolygonVector
        __init__(MaskPolygonVector self, MaskPolygonVector other) -> MaskPolygonVector
        __init__(MaskPolygonVector self, std::vector< MaskPolygon >::size_type size) -> MaskPolygonVector
        __init__(MaskPolygonVector self, std::vector< MaskPolygon >::size_type size, MaskPolygon value) -> MaskPolygonVector
        """
        _hsi.MaskPolygonVector_swiginit(self, _hsi.new_MaskPolygonVector(*args))

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

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

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

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

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

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

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

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

# Register MaskPolygonVector in _hsi:
_hsi.MaskPolygonVector_swigregister(MaskPolygonVector)

class PTOVariableConverterNoOp(object):
    r"""Proxy of C++ HuginBase::PTOVariableConverterNoOp class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

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

    def __init__(self):
        r"""__init__(PTOVariableConverterNoOp self) -> PTOVariableConverterNoOp"""
        _hsi.PTOVariableConverterNoOp_swiginit(self, _hsi.new_PTOVariableConverterNoOp())
    __swig_destroy__ = _hsi.delete_PTOVariableConverterNoOp

# Register PTOVariableConverterNoOp in _hsi:
_hsi.PTOVariableConverterNoOp_swigregister(PTOVariableConverterNoOp)

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

class ConstImageVariableGroup(object):
    r"""Proxy of C++ HuginBase::ConstImageVariableGroup class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    IVE_Filename = _hsi.ConstImageVariableGroup_IVE_Filename
    
    IVE_Size = _hsi.ConstImageVariableGroup_IVE_Size
    
    IVE_Projection = _hsi.ConstImageVariableGroup_IVE_Projection
    
    IVE_HFOV = _hsi.ConstImageVariableGroup_IVE_HFOV
    
    IVE_CropFactor = _hsi.ConstImageVariableGroup_IVE_CropFactor
    
    IVE_ResponseType = _hsi.ConstImageVariableGroup_IVE_ResponseType
    
    IVE_EMoRParams = _hsi.ConstImageVariableGroup_IVE_EMoRParams
    
    IVE_ExposureValue = _hsi.ConstImageVariableGroup_IVE_ExposureValue
    
    IVE_Gamma = _hsi.ConstImageVariableGroup_IVE_Gamma
    
    IVE_WhiteBalanceRed = _hsi.ConstImageVariableGroup_IVE_WhiteBalanceRed
    
    IVE_WhiteBalanceBlue = _hsi.ConstImageVariableGroup_IVE_WhiteBalanceBlue
    
    IVE_Roll = _hsi.ConstImageVariableGroup_IVE_Roll
    
    IVE_Pitch = _hsi.ConstImageVariableGroup_IVE_Pitch
    
    IVE_Yaw = _hsi.ConstImageVariableGroup_IVE_Yaw
    
    IVE_X = _hsi.ConstImageVariableGroup_IVE_X
    
    IVE_Y = _hsi.ConstImageVariableGroup_IVE_Y
    
    IVE_Z = _hsi.ConstImageVariableGroup_IVE_Z
    
    IVE_TranslationPlaneYaw = _hsi.ConstImageVariableGroup_IVE_TranslationPlaneYaw
    
    IVE_TranslationPlanePitch = _hsi.ConstImageVariableGroup_IVE_TranslationPlanePitch
    
    IVE_Stack = _hsi.ConstImageVariableGroup_IVE_Stack
    
    IVE_RadialDistortion = _hsi.ConstImageVariableGroup_IVE_RadialDistortion
    
    IVE_RadialDistortionRed = _hsi.ConstImageVariableGroup_IVE_RadialDistortionRed
    
    IVE_RadialDistortionBlue = _hsi.ConstImageVariableGroup_IVE_RadialDistortionBlue
    
    IVE_RadialDistortionCenterShift = _hsi.ConstImageVariableGroup_IVE_RadialDistortionCenterShift
    
    IVE_Shear = _hsi.ConstImageVariableGroup_IVE_Shear
    
    IVE_CropMode = _hsi.ConstImageVariableGroup_IVE_CropMode
    
    IVE_CropRect = _hsi.ConstImageVariableGroup_IVE_CropRect
    
    IVE_AutoCenterCrop = _hsi.ConstImageVariableGroup_IVE_AutoCenterCrop
    
    IVE_VigCorrMode = _hsi.ConstImageVariableGroup_IVE_VigCorrMode
    
    IVE_FlatfieldFilename = _hsi.ConstImageVariableGroup_IVE_FlatfieldFilename
    
    IVE_RadialVigCorrCoeff = _hsi.ConstImageVariableGroup_IVE_RadialVigCorrCoeff
    
    IVE_RadialVigCorrCenterShift = _hsi.ConstImageVariableGroup_IVE_RadialVigCorrCenterShift
    
    IVE_ExifModel = _hsi.ConstImageVariableGroup_IVE_ExifModel
    
    IVE_ExifMake = _hsi.ConstImageVariableGroup_IVE_ExifMake
    
    IVE_ExifLens = _hsi.ConstImageVariableGroup_IVE_ExifLens
    
    IVE_ExifFocalLength = _hsi.ConstImageVariableGroup_IVE_ExifFocalLength
    
    IVE_ExifOrientation = _hsi.ConstImageVariableGroup_IVE_ExifOrientation
    
    IVE_ExifAperture = _hsi.ConstImageVariableGroup_IVE_ExifAperture
    
    IVE_ExifISO = _hsi.ConstImageVariableGroup_IVE_ExifISO
    
    IVE_ExifDistance = _hsi.ConstImageVariableGroup_IVE_ExifDistance
    
    IVE_ExifFocalLength35 = _hsi.ConstImageVariableGroup_IVE_ExifFocalLength35
    
    IVE_ExifCropFactor = _hsi.ConstImageVariableGroup_IVE_ExifCropFactor
    
    IVE_ExifExposureTime = _hsi.ConstImageVariableGroup_IVE_ExifExposureTime
    
    IVE_ExifDate = _hsi.ConstImageVariableGroup_IVE_ExifDate
    
    IVE_ExifExposureMode = _hsi.ConstImageVariableGroup_IVE_ExifExposureMode
    
    IVE_ExifRedBalance = _hsi.ConstImageVariableGroup_IVE_ExifRedBalance
    
    IVE_ExifBlueBalance = _hsi.ConstImageVariableGroup_IVE_ExifBlueBalance
    
    IVE_FileMetadata = _hsi.ConstImageVariableGroup_IVE_FileMetadata
    
    IVE_Masks = _hsi.ConstImageVariableGroup_IVE_Masks
    
    IVE_ActiveMasks = _hsi.ConstImageVariableGroup_IVE_ActiveMasks
    
    IVE_Active = _hsi.ConstImageVariableGroup_IVE_Active
    

    def __init__(self, variables, pano):
        r"""__init__(ConstImageVariableGroup self, std::set< HuginBase::ConstImageVariableGroup::ImageVariableEnum,std::less< HuginBase::ConstImageVariableGroup::ImageVariableEnum >,std::allocator< HuginBase::ConstImageVariableGroup::ImageVariableEnum > > variables, PanoramaData pano) -> ConstImageVariableGroup"""
        _hsi.ConstImageVariableGroup_swiginit(self, _hsi.new_ConstImageVariableGroup(variables, pano))
    __swig_destroy__ = _hsi.delete_ConstImageVariableGroup

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

    def getPartsSet(self):
        r"""getPartsSet(ConstImageVariableGroup self) -> HuginBase::UIntSetVector"""
        return _hsi.ConstImageVariableGroup_getPartsSet(self)

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

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

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

# Register ConstImageVariableGroup in _hsi:
_hsi.ConstImageVariableGroup_swigregister(ConstImageVariableGroup)

class ImageVariableGroup(ConstImageVariableGroup):
    r"""Proxy of C++ HuginBase::ImageVariableGroup class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, variables, pano):
        r"""__init__(ImageVariableGroup self, std::set< HuginBase::ConstImageVariableGroup::ImageVariableEnum,std::less< HuginBase::ConstImageVariableGroup::ImageVariableEnum >,std::allocator< HuginBase::ConstImageVariableGroup::ImageVariableEnum > > variables, PanoramaData pano) -> ImageVariableGroup"""
        _hsi.ImageVariableGroup_swiginit(self, _hsi.new_ImageVariableGroup(variables, pano))

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

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

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

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

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

# Register ImageVariableGroup in _hsi:
_hsi.ImageVariableGroup_swigregister(ImageVariableGroup)

class ConstStandardImageVariableGroups(object):
    r"""Proxy of C++ HuginBase::ConstStandardImageVariableGroups class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, pano):
        r"""__init__(ConstStandardImageVariableGroups self, PanoramaData pano) -> ConstStandardImageVariableGroups"""
        _hsi.ConstStandardImageVariableGroups_swiginit(self, _hsi.new_ConstStandardImageVariableGroups(pano))

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

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

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

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

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

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

    def update(self):
        r"""update(ConstStandardImageVariableGroups self)"""
        return _hsi.ConstStandardImageVariableGroups_update(self)
    __swig_destroy__ = _hsi.delete_ConstStandardImageVariableGroups

# Register ConstStandardImageVariableGroups in _hsi:
_hsi.ConstStandardImageVariableGroups_swigregister(ConstStandardImageVariableGroups)

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

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

class StandardImageVariableGroups(ConstStandardImageVariableGroups):
    r"""Proxy of C++ HuginBase::StandardImageVariableGroups class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, pano):
        r"""__init__(StandardImageVariableGroups self, PanoramaData pano) -> StandardImageVariableGroups"""
        _hsi.StandardImageVariableGroups_swiginit(self, _hsi.new_StandardImageVariableGroups(pano))

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

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

    def update(self):
        r"""update(StandardImageVariableGroups self)"""
        return _hsi.StandardImageVariableGroups_update(self)
    __swig_destroy__ = _hsi.delete_StandardImageVariableGroups

# Register StandardImageVariableGroups in _hsi:
_hsi.StandardImageVariableGroups_swigregister(StandardImageVariableGroups)

class Variable(object):
    r"""Proxy of C++ HuginBase::Variable class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, name, val=0.0):
        r"""__init__(Variable self, std::string const & name, double val=0.0) -> Variable"""
        _hsi.Variable_swiginit(self, _hsi.new_Variable(name, val))
    __swig_destroy__ = _hsi.delete_Variable

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

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

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

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

# Register Variable in _hsi:
_hsi.Variable_swigregister(Variable)

class LinkedVariable(Variable):
    r"""Proxy of C++ HuginBase::LinkedVariable class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""__init__(LinkedVariable self, std::string const & name="", double val=0.0, int link=-1) -> LinkedVariable"""
        _hsi.LinkedVariable_swiginit(self, _hsi.new_LinkedVariable(*args))

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

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

    def setLink(self, link):
        r"""setLink(LinkedVariable self, int link)"""
        return _hsi.LinkedVariable_setLink(self, link)
    __swig_destroy__ = _hsi.delete_LinkedVariable

# Register LinkedVariable in _hsi:
_hsi.LinkedVariable_swigregister(LinkedVariable)

class LensVariable(Variable):
    r"""Proxy of C++ HuginBase::LensVariable class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, name, value, link=False):
        r"""__init__(LensVariable self, std::string const & name, double value, bool link=False) -> LensVariable"""
        _hsi.LensVariable_swiginit(self, _hsi.new_LensVariable(name, value, link))
    __swig_destroy__ = _hsi.delete_LensVariable

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

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

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

# Register LensVariable in _hsi:
_hsi.LensVariable_swigregister(LensVariable)


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

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

def fillLensVarMap(vars):
    r"""fillLensVarMap(HuginBase::LensVarMap & vars)"""
    return _hsi.fillLensVarMap(vars)
class PanoramaOptions(object):
    r"""Proxy of C++ HuginBase::PanoramaOptions class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    RECTILINEAR = _hsi.PanoramaOptions_RECTILINEAR
    
    CYLINDRICAL = _hsi.PanoramaOptions_CYLINDRICAL
    
    EQUIRECTANGULAR = _hsi.PanoramaOptions_EQUIRECTANGULAR
    
    FULL_FRAME_FISHEYE = _hsi.PanoramaOptions_FULL_FRAME_FISHEYE
    
    STEREOGRAPHIC = _hsi.PanoramaOptions_STEREOGRAPHIC
    
    MERCATOR = _hsi.PanoramaOptions_MERCATOR
    
    TRANSVERSE_MERCATOR = _hsi.PanoramaOptions_TRANSVERSE_MERCATOR
    
    SINUSOIDAL = _hsi.PanoramaOptions_SINUSOIDAL
    
    LAMBERT = _hsi.PanoramaOptions_LAMBERT
    
    LAMBERT_AZIMUTHAL = _hsi.PanoramaOptions_LAMBERT_AZIMUTHAL
    
    ALBERS_EQUAL_AREA_CONIC = _hsi.PanoramaOptions_ALBERS_EQUAL_AREA_CONIC
    
    MILLER_CYLINDRICAL = _hsi.PanoramaOptions_MILLER_CYLINDRICAL
    
    PANINI = _hsi.PanoramaOptions_PANINI
    
    ARCHITECTURAL = _hsi.PanoramaOptions_ARCHITECTURAL
    
    ORTHOGRAPHIC = _hsi.PanoramaOptions_ORTHOGRAPHIC
    
    EQUISOLID = _hsi.PanoramaOptions_EQUISOLID
    
    EQUI_PANINI = _hsi.PanoramaOptions_EQUI_PANINI
    
    BIPLANE = _hsi.PanoramaOptions_BIPLANE
    
    TRIPLANE = _hsi.PanoramaOptions_TRIPLANE
    
    GENERAL_PANINI = _hsi.PanoramaOptions_GENERAL_PANINI
    
    THOBY_PROJECTION = _hsi.PanoramaOptions_THOBY_PROJECTION
    
    HAMMER_AITOFF = _hsi.PanoramaOptions_HAMMER_AITOFF
    
    NO_SPEEDUP = _hsi.PanoramaOptions_NO_SPEEDUP
    
    MAX_SPEEDUP = _hsi.PanoramaOptions_MAX_SPEEDUP
    
    MEDIUM_SPEEDUP = _hsi.PanoramaOptions_MEDIUM_SPEEDUP
    
    JPEG = _hsi.PanoramaOptions_JPEG
    
    JPEG_m = _hsi.PanoramaOptions_JPEG_m
    
    PNG = _hsi.PanoramaOptions_PNG
    
    PNG_m = _hsi.PanoramaOptions_PNG_m
    
    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
    
    INTERNAL_BLEND = _hsi.PanoramaOptions_INTERNAL_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):
        r"""__init__(PanoramaOptions self) -> PanoramaOptions"""
        _hsi.PanoramaOptions_swiginit(self, _hsi.new_PanoramaOptions())
    __swig_destroy__ = _hsi.delete_PanoramaOptions

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def getProjectionParameters(self):
        r"""getProjectionParameters(PanoramaOptions self) -> DoubleVector"""
        return _hsi.PanoramaOptions_getProjectionParameters(self)

    def setProjectionParameters(self, params):
        r"""setProjectionParameters(PanoramaOptions self, DoubleVector params)"""
        return _hsi.PanoramaOptions_setProjectionParameters(self, params)

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

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

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

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

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

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

    def getMaxVFOV(self):
        r"""getMaxVFOV(PanoramaOptions self) -> double"""
        return _hsi.PanoramaOptions_getMaxVFOV(self)
    outputFormat = property(_hsi.PanoramaOptions_outputFormat_get, _hsi.PanoramaOptions_outputFormat_set, doc=r"""outputFormat : HuginBase::PanoramaOptions::FileFormat""")
    quality = property(_hsi.PanoramaOptions_quality_get, _hsi.PanoramaOptions_quality_set, doc=r"""quality : int""")
    tiffCompression = property(_hsi.PanoramaOptions_tiffCompression_get, _hsi.PanoramaOptions_tiffCompression_set, doc=r"""tiffCompression : std::string""")
    tiff_saveROI = property(_hsi.PanoramaOptions_tiff_saveROI_get, _hsi.PanoramaOptions_tiff_saveROI_set, doc=r"""tiff_saveROI : bool""")
    colorCorrection = property(_hsi.PanoramaOptions_colorCorrection_get, _hsi.PanoramaOptions_colorCorrection_set, doc=r"""colorCorrection : HuginBase::PanoramaOptions::ColorCorrection""")
    colorReferenceImage = property(_hsi.PanoramaOptions_colorReferenceImage_get, _hsi.PanoramaOptions_colorReferenceImage_set, doc=r"""colorReferenceImage : unsigned int""")
    interpolator = property(_hsi.PanoramaOptions_interpolator_get, _hsi.PanoramaOptions_interpolator_set, doc=r"""interpolator : vigra_ext::Interpolator""")
    optimizeReferenceImage = property(_hsi.PanoramaOptions_optimizeReferenceImage_get, _hsi.PanoramaOptions_optimizeReferenceImage_set, doc=r"""optimizeReferenceImage : unsigned int""")
    blendMode = property(_hsi.PanoramaOptions_blendMode_get, _hsi.PanoramaOptions_blendMode_set, doc=r"""blendMode : HuginBase::PanoramaOptions::BlendingMechanism""")
    hdrMergeMode = property(_hsi.PanoramaOptions_hdrMergeMode_get, _hsi.PanoramaOptions_hdrMergeMode_set, doc=r"""hdrMergeMode : HuginBase::PanoramaOptions::HDRMergeType""")
    remapper = property(_hsi.PanoramaOptions_remapper_get, _hsi.PanoramaOptions_remapper_set, doc=r"""remapper : HuginBase::PanoramaOptions::Remapper""")
    remapUsingGPU = property(_hsi.PanoramaOptions_remapUsingGPU_get, _hsi.PanoramaOptions_remapUsingGPU_set, doc=r"""remapUsingGPU : bool""")
    saveCoordImgs = property(_hsi.PanoramaOptions_saveCoordImgs_get, _hsi.PanoramaOptions_saveCoordImgs_set, doc=r"""saveCoordImgs : bool""")
    huberSigma = property(_hsi.PanoramaOptions_huberSigma_get, _hsi.PanoramaOptions_huberSigma_set, doc=r"""huberSigma : double""")
    photometricHuberSigma = property(_hsi.PanoramaOptions_photometricHuberSigma_get, _hsi.PanoramaOptions_photometricHuberSigma_set, doc=r"""photometricHuberSigma : double""")
    outputMode = property(_hsi.PanoramaOptions_outputMode_get, _hsi.PanoramaOptions_outputMode_set, doc=r"""outputMode : HuginBase::PanoramaOptions::OutputMode""")
    outputLDRBlended = property(_hsi.PanoramaOptions_outputLDRBlended_get, _hsi.PanoramaOptions_outputLDRBlended_set, doc=r"""outputLDRBlended : bool""")
    outputLDRLayers = property(_hsi.PanoramaOptions_outputLDRLayers_get, _hsi.PanoramaOptions_outputLDRLayers_set, doc=r"""outputLDRLayers : bool""")
    outputLDRExposureRemapped = property(_hsi.PanoramaOptions_outputLDRExposureRemapped_get, _hsi.PanoramaOptions_outputLDRExposureRemapped_set, doc=r"""outputLDRExposureRemapped : bool""")
    outputLDRExposureLayers = property(_hsi.PanoramaOptions_outputLDRExposureLayers_get, _hsi.PanoramaOptions_outputLDRExposureLayers_set, doc=r"""outputLDRExposureLayers : bool""")
    outputLDRExposureLayersFused = property(_hsi.PanoramaOptions_outputLDRExposureLayersFused_get, _hsi.PanoramaOptions_outputLDRExposureLayersFused_set, doc=r"""outputLDRExposureLayersFused : bool""")
    outputLDRStacks = property(_hsi.PanoramaOptions_outputLDRStacks_get, _hsi.PanoramaOptions_outputLDRStacks_set, doc=r"""outputLDRStacks : bool""")
    outputLDRExposureBlended = property(_hsi.PanoramaOptions_outputLDRExposureBlended_get, _hsi.PanoramaOptions_outputLDRExposureBlended_set, doc=r"""outputLDRExposureBlended : bool""")
    outputHDRBlended = property(_hsi.PanoramaOptions_outputHDRBlended_get, _hsi.PanoramaOptions_outputHDRBlended_set, doc=r"""outputHDRBlended : bool""")
    outputHDRLayers = property(_hsi.PanoramaOptions_outputHDRLayers_get, _hsi.PanoramaOptions_outputHDRLayers_set, doc=r"""outputHDRLayers : bool""")
    outputHDRStacks = property(_hsi.PanoramaOptions_outputHDRStacks_get, _hsi.PanoramaOptions_outputHDRStacks_set, doc=r"""outputHDRStacks : bool""")
    outputLayersCompression = property(_hsi.PanoramaOptions_outputLayersCompression_get, _hsi.PanoramaOptions_outputLayersCompression_set, doc=r"""outputLayersCompression : std::string""")
    outputImageType = property(_hsi.PanoramaOptions_outputImageType_get, _hsi.PanoramaOptions_outputImageType_set, doc=r"""outputImageType : std::string""")
    outputImageTypeCompression = property(_hsi.PanoramaOptions_outputImageTypeCompression_get, _hsi.PanoramaOptions_outputImageTypeCompression_set, doc=r"""outputImageTypeCompression : std::string""")
    outputImageTypeHDR = property(_hsi.PanoramaOptions_outputImageTypeHDR_get, _hsi.PanoramaOptions_outputImageTypeHDR_set, doc=r"""outputImageTypeHDR : std::string""")
    outputImageTypeHDRCompression = property(_hsi.PanoramaOptions_outputImageTypeHDRCompression_get, _hsi.PanoramaOptions_outputImageTypeHDRCompression_set, doc=r"""outputImageTypeHDRCompression : std::string""")
    enblendOptions = property(_hsi.PanoramaOptions_enblendOptions_get, _hsi.PanoramaOptions_enblendOptions_set, doc=r"""enblendOptions : std::string""")
    enfuseOptions = property(_hsi.PanoramaOptions_enfuseOptions_get, _hsi.PanoramaOptions_enfuseOptions_set, doc=r"""enfuseOptions : std::string""")
    hdrmergeOptions = property(_hsi.PanoramaOptions_hdrmergeOptions_get, _hsi.PanoramaOptions_hdrmergeOptions_set, doc=r"""hdrmergeOptions : std::string""")
    verdandiOptions = property(_hsi.PanoramaOptions_verdandiOptions_get, _hsi.PanoramaOptions_verdandiOptions_set, doc=r"""verdandiOptions : std::string""")
    outputExposureValue = property(_hsi.PanoramaOptions_outputExposureValue_get, _hsi.PanoramaOptions_outputExposureValue_set, doc=r"""outputExposureValue : double""")
    outputEMoRParams = property(_hsi.PanoramaOptions_outputEMoRParams_get, _hsi.PanoramaOptions_outputEMoRParams_set, doc=r"""outputEMoRParams : std::vector<(float,std::allocator<(float)>)>""")
    outputRangeCompression = property(_hsi.PanoramaOptions_outputRangeCompression_get, _hsi.PanoramaOptions_outputRangeCompression_set, doc=r"""outputRangeCompression : double""")
    outputPixelType = property(_hsi.PanoramaOptions_outputPixelType_get, _hsi.PanoramaOptions_outputPixelType_set, doc=r"""outputPixelType : std::string""")
    outputStacksMinOverlap = property(_hsi.PanoramaOptions_outputStacksMinOverlap_get, _hsi.PanoramaOptions_outputStacksMinOverlap_set, doc=r"""outputStacksMinOverlap : double""")
    outputLayersExposureDiff = property(_hsi.PanoramaOptions_outputLayersExposureDiff_get, _hsi.PanoramaOptions_outputLayersExposureDiff_set, doc=r"""outputLayersExposureDiff : double""")
    m_projFeatures = property(_hsi.PanoramaOptions_m_projFeatures_get, _hsi.PanoramaOptions_m_projFeatures_set, doc=r"""m_projFeatures : pano_projection_features""")

# Register PanoramaOptions in _hsi:
_hsi.PanoramaOptions_swigregister(PanoramaOptions)

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

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

class BaseSrcPanoImage(object):
    r"""Proxy of C++ HuginBase::BaseSrcPanoImage class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    RECTILINEAR = _hsi.BaseSrcPanoImage_RECTILINEAR
    
    PANORAMIC = _hsi.BaseSrcPanoImage_PANORAMIC
    
    CIRCULAR_FISHEYE = _hsi.BaseSrcPanoImage_CIRCULAR_FISHEYE
    
    FULL_FRAME_FISHEYE = _hsi.BaseSrcPanoImage_FULL_FRAME_FISHEYE
    
    EQUIRECTANGULAR = _hsi.BaseSrcPanoImage_EQUIRECTANGULAR
    
    FISHEYE_ORTHOGRAPHIC = _hsi.BaseSrcPanoImage_FISHEYE_ORTHOGRAPHIC
    
    FISHEYE_STEREOGRAPHIC = _hsi.BaseSrcPanoImage_FISHEYE_STEREOGRAPHIC
    
    FISHEYE_EQUISOLID = _hsi.BaseSrcPanoImage_FISHEYE_EQUISOLID
    
    FISHEYE_THOBY = _hsi.BaseSrcPanoImage_FISHEYE_THOBY
    
    NO_CROP = _hsi.BaseSrcPanoImage_NO_CROP
    
    CROP_RECTANGLE = _hsi.BaseSrcPanoImage_CROP_RECTANGLE
    
    CROP_CIRCLE = _hsi.BaseSrcPanoImage_CROP_CIRCLE
    
    VIGCORR_NONE = _hsi.BaseSrcPanoImage_VIGCORR_NONE
    
    VIGCORR_RADIAL = _hsi.BaseSrcPanoImage_VIGCORR_RADIAL
    
    VIGCORR_FLATFIELD = _hsi.BaseSrcPanoImage_VIGCORR_FLATFIELD
    
    VIGCORR_DIV = _hsi.BaseSrcPanoImage_VIGCORR_DIV
    
    RESPONSE_EMOR = _hsi.BaseSrcPanoImage_RESPONSE_EMOR
    
    RESPONSE_LINEAR = _hsi.BaseSrcPanoImage_RESPONSE_LINEAR
    
    RESPONSE_GAMMA = _hsi.BaseSrcPanoImage_RESPONSE_GAMMA
    
    RESPONSE_FILE = _hsi.BaseSrcPanoImage_RESPONSE_FILE
    
    RESPONSE_ICC = _hsi.BaseSrcPanoImage_RESPONSE_ICC
    

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

    def __init__(self):
        r"""__init__(BaseSrcPanoImage self) -> BaseSrcPanoImage"""
        _hsi.BaseSrcPanoImage_swiginit(self, _hsi.new_BaseSrcPanoImage())
    __swig_destroy__ = _hsi.delete_BaseSrcPanoImage

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def getRadialDistortion(self):
        r"""getRadialDistortion(BaseSrcPanoImage self) -> DoubleVector"""
        return _hsi.BaseSrcPanoImage_getRadialDistortion(self)

    def getRadialDistortionRed(self):
        r"""getRadialDistortionRed(BaseSrcPanoImage self) -> DoubleVector"""
        return _hsi.BaseSrcPanoImage_getRadialDistortionRed(self)

    def getRadialDistortionBlue(self):
        r"""getRadialDistortionBlue(BaseSrcPanoImage self) -> DoubleVector"""
        return _hsi.BaseSrcPanoImage_getRadialDistortionBlue(self)

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

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

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

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

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

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

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

    def getRadialVigCorrCoeff(self):
        r"""getRadialVigCorrCoeff(BaseSrcPanoImage self) -> DoubleVector"""
        return _hsi.BaseSrcPanoImage_getRadialVigCorrCoeff(self)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def getExifRedBalance(self):
        r"""getExifRedBalance(BaseSrcPanoImage self) -> double"""
        return _hsi.BaseSrcPanoImage_getExifRedBalance(self)

    def getExifBlueBalance(self):
        r"""getExifBlueBalance(BaseSrcPanoImage self) -> double"""
        return _hsi.BaseSrcPanoImage_getExifBlueBalance(self)

    def getFileMetadata(self):
        r"""getFileMetadata(BaseSrcPanoImage self) -> HuginBase::FileMetaData"""
        return _hsi.BaseSrcPanoImage_getFileMetadata(self)

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

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

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

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

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

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

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

    def getCropFactorIV(self):
        r"""getCropFactorIV(BaseSrcPanoImage self) -> HuginBase::ImageVariable< double > const &"""
        return _hsi.BaseSrcPanoImage_getCropFactorIV(self)

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

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

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

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

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

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

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

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

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

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

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

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

    def getTranslationPlaneYawIV(self):
        r"""getTranslationPlaneYawIV(BaseSrcPanoImage self) -> HuginBase::ImageVariable< double > const &"""
        return _hsi.BaseSrcPanoImage_getTranslationPlaneYawIV(self)

    def getTranslationPlanePitchIV(self):
        r"""getTranslationPlanePitchIV(BaseSrcPanoImage self) -> HuginBase::ImageVariable< double > const &"""
        return _hsi.BaseSrcPanoImage_getTranslationPlanePitchIV(self)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def getExifRedBalanceIV(self):
        r"""getExifRedBalanceIV(BaseSrcPanoImage self) -> HuginBase::ImageVariable< double > const &"""
        return _hsi.BaseSrcPanoImage_getExifRedBalanceIV(self)

    def getExifBlueBalanceIV(self):
        r"""getExifBlueBalanceIV(BaseSrcPanoImage self) -> HuginBase::ImageVariable< double > const &"""
        return _hsi.BaseSrcPanoImage_getExifBlueBalanceIV(self)

    def getFileMetadataIV(self):
        r"""getFileMetadataIV(BaseSrcPanoImage self) -> HuginBase::ImageVariable< HuginBase::FileMetaData > const &"""
        return _hsi.BaseSrcPanoImage_getFileMetadataIV(self)

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

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

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

    def setFilename(self, data):
        r"""setFilename(BaseSrcPanoImage self, std::string data)"""
        return _hsi.BaseSrcPanoImage_setFilename(self, data)

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

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

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

    def setCropFactor(self, data):
        r"""setCropFactor(BaseSrcPanoImage self, double data)"""
        return _hsi.BaseSrcPanoImage_setCropFactor(self, data)

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

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

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

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

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

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

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

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

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

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

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

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

    def setTranslationPlaneYaw(self, data):
        r"""setTranslationPlaneYaw(BaseSrcPanoImage self, double data)"""
        return _hsi.BaseSrcPanoImage_setTranslationPlaneYaw(self, data)

    def setTranslationPlanePitch(self, data):
        r"""setTranslationPlanePitch(BaseSrcPanoImage self, double data)"""
        return _hsi.BaseSrcPanoImage_setTranslationPlanePitch(self, data)

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

    def setRadialDistortion(self, data):
        r"""setRadialDistortion(BaseSrcPanoImage self, DoubleVector data)"""
        return _hsi.BaseSrcPanoImage_setRadialDistortion(self, data)

    def setRadialDistortionRed(self, data):
        r"""setRadialDistortionRed(BaseSrcPanoImage self, DoubleVector data)"""
        return _hsi.BaseSrcPanoImage_setRadialDistortionRed(self, data)

    def setRadialDistortionBlue(self, data):
        r"""setRadialDistortionBlue(BaseSrcPanoImage self, DoubleVector data)"""
        return _hsi.BaseSrcPanoImage_setRadialDistortionBlue(self, data)

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

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

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

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

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

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

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

    def setRadialVigCorrCoeff(self, data):
        r"""setRadialVigCorrCoeff(BaseSrcPanoImage self, DoubleVector data)"""
        return _hsi.BaseSrcPanoImage_setRadialVigCorrCoeff(self, data)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def setExifRedBalance(self, data):
        r"""setExifRedBalance(BaseSrcPanoImage self, double data)"""
        return _hsi.BaseSrcPanoImage_setExifRedBalance(self, data)

    def setExifBlueBalance(self, data):
        r"""setExifBlueBalance(BaseSrcPanoImage self, double data)"""
        return _hsi.BaseSrcPanoImage_setExifBlueBalance(self, data)

    def setFileMetadata(self, data):
        r"""setFileMetadata(BaseSrcPanoImage self, HuginBase::FileMetaData data)"""
        return _hsi.BaseSrcPanoImage_setFileMetadata(self, data)

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

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

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

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

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

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

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

    def linkCropFactor(self, target):
        r"""linkCropFactor(BaseSrcPanoImage self, BaseSrcPanoImage target)"""
        return _hsi.BaseSrcPanoImage_linkCropFactor(self, target)

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

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

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

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

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

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

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

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

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

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

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

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

    def linkTranslationPlaneYaw(self, target):
        r"""linkTranslationPlaneYaw(BaseSrcPanoImage self, BaseSrcPanoImage target)"""
        return _hsi.BaseSrcPanoImage_linkTranslationPlaneYaw(self, target)

    def linkTranslationPlanePitch(self, target):
        r"""linkTranslationPlanePitch(BaseSrcPanoImage self, BaseSrcPanoImage target)"""
        return _hsi.BaseSrcPanoImage_linkTranslationPlanePitch(self, target)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def linkExifRedBalance(self, target):
        r"""linkExifRedBalance(BaseSrcPanoImage self, BaseSrcPanoImage target)"""
        return _hsi.BaseSrcPanoImage_linkExifRedBalance(self, target)

    def linkExifBlueBalance(self, target):
        r"""linkExifBlueBalance(BaseSrcPanoImage self, BaseSrcPanoImage target)"""
        return _hsi.BaseSrcPanoImage_linkExifBlueBalance(self, target)

    def linkFileMetadata(self, target):
        r"""linkFileMetadata(BaseSrcPanoImage self, BaseSrcPanoImage target)"""
        return _hsi.BaseSrcPanoImage_linkFileMetadata(self, target)

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

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

    def linkActive(self, target):
        r"""linkActive(BaseSrcPanoImage self, BaseSrcPanoImage target)"""
        return _hsi.BaseSrcPanoImage_linkActive(self, target)

    def unlinkFilename(self):
        r"""unlinkFilename(BaseSrcPanoImage self)"""
        return _hsi.BaseSrcPanoImage_unlinkFilename(self)

    def unlinkSize(self):
        r"""unlinkSize(BaseSrcPanoImage self)"""
        return _hsi.BaseSrcPanoImage_unlinkSize(self)

    def unlinkProjection(self):
        r"""unlinkProjection(BaseSrcPanoImage self)"""
        return _hsi.BaseSrcPanoImage_unlinkProjection(self)

    def unlinkHFOV(self):
        r"""unlinkHFOV(BaseSrcPanoImage self)"""
        return _hsi.BaseSrcPanoImage_unlinkHFOV(self)

    def unlinkCropFactor(self):
        r"""unlinkCropFactor(BaseSrcPanoImage self)"""
        return _hsi.BaseSrcPanoImage_unlinkCropFactor(self)

    def unlinkResponseType(self):
        r"""unlinkResponseType(BaseSrcPanoImage self)"""
        return _hsi.BaseSrcPanoImage_unlinkResponseType(self)

    def unlinkEMoRParams(self):
        r"""unlinkEMoRParams(BaseSrcPanoImage self)"""
        return _hsi.BaseSrcPanoImage_unlinkEMoRParams(self)

    def unlinkExposureValue(self):
        r"""unlinkExposureValue(BaseSrcPanoImage self)"""
        return _hsi.BaseSrcPanoImage_unlinkExposureValue(self)

    def unlinkGamma(self):
        r"""unlinkGamma(BaseSrcPanoImage self)"""
        return _hsi.BaseSrcPanoImage_unlinkGamma(self)

    def unlinkWhiteBalanceRed(self):
        r"""unlinkWhiteBalanceRed(BaseSrcPanoImage self)"""
        return _hsi.BaseSrcPanoImage_unlinkWhiteBalanceRed(self)

    def unlinkWhiteBalanceBlue(self):
        r"""unlinkWhiteBalanceBlue(BaseSrcPanoImage self)"""
        return _hsi.BaseSrcPanoImage_unlinkWhiteBalanceBlue(self)

    def unlinkRoll(self):
        r"""unlinkRoll(BaseSrcPanoImage self)"""
        return _hsi.BaseSrcPanoImage_unlinkRoll(self)

    def unlinkPitch(self):
        r"""unlinkPitch(BaseSrcPanoImage self)"""
        return _hsi.BaseSrcPanoImage_unlinkPitch(self)

    def unlinkYaw(self):
        r"""unlinkYaw(BaseSrcPanoImage self)"""
        return _hsi.BaseSrcPanoImage_unlinkYaw(self)

    def unlinkX(self):
        r"""unlinkX(BaseSrcPanoImage self)"""
        return _hsi.BaseSrcPanoImage_unlinkX(self)

    def unlinkY(self):
        r"""unlinkY(BaseSrcPanoImage self)"""
        return _hsi.BaseSrcPanoImage_unlinkY(self)

    def unlinkZ(self):
        r"""unlinkZ(BaseSrcPanoImage self)"""
        return _hsi.BaseSrcPanoImage_unlinkZ(self)

    def unlinkTranslationPlaneYaw(self):
        r"""unlinkTranslationPlaneYaw(BaseSrcPanoImage self)"""
        return _hsi.BaseSrcPanoImage_unlinkTranslationPlaneYaw(self)

    def unlinkTranslationPlanePitch(self):
        r"""unlinkTranslationPlanePitch(BaseSrcPanoImage self)"""
        return _hsi.BaseSrcPanoImage_unlinkTranslationPlanePitch(self)

    def unlinkStack(self):
        r"""unlinkStack(BaseSrcPanoImage self)"""
        return _hsi.BaseSrcPanoImage_unlinkStack(self)

    def unlinkRadialDistortion(self):
        r"""unlinkRadialDistortion(BaseSrcPanoImage self)"""
        return _hsi.BaseSrcPanoImage_unlinkRadialDistortion(self)

    def unlinkRadialDistortionRed(self):
        r"""unlinkRadialDistortionRed(BaseSrcPanoImage self)"""
        return _hsi.BaseSrcPanoImage_unlinkRadialDistortionRed(self)

    def unlinkRadialDistortionBlue(self):
        r"""unlinkRadialDistortionBlue(BaseSrcPanoImage self)"""
        return _hsi.BaseSrcPanoImage_unlinkRadialDistortionBlue(self)

    def unlinkRadialDistortionCenterShift(self):
        r"""unlinkRadialDistortionCenterShift(BaseSrcPanoImage self)"""
        return _hsi.BaseSrcPanoImage_unlinkRadialDistortionCenterShift(self)

    def unlinkShear(self):
        r"""unlinkShear(BaseSrcPanoImage self)"""
        return _hsi.BaseSrcPanoImage_unlinkShear(self)

    def unlinkCropMode(self):
        r"""unlinkCropMode(BaseSrcPanoImage self)"""
        return _hsi.BaseSrcPanoImage_unlinkCropMode(self)

    def unlinkCropRect(self):
        r"""unlinkCropRect(BaseSrcPanoImage self)"""
        return _hsi.BaseSrcPanoImage_unlinkCropRect(self)

    def unlinkAutoCenterCrop(self):
        r"""unlinkAutoCenterCrop(BaseSrcPanoImage self)"""
        return _hsi.BaseSrcPanoImage_unlinkAutoCenterCrop(self)

    def unlinkVigCorrMode(self):
        r"""unlinkVigCorrMode(BaseSrcPanoImage self)"""
        return _hsi.BaseSrcPanoImage_unlinkVigCorrMode(self)

    def unlinkFlatfieldFilename(self):
        r"""unlinkFlatfieldFilename(BaseSrcPanoImage self)"""
        return _hsi.BaseSrcPanoImage_unlinkFlatfieldFilename(self)

    def unlinkRadialVigCorrCoeff(self):
        r"""unlinkRadialVigCorrCoeff(BaseSrcPanoImage self)"""
        return _hsi.BaseSrcPanoImage_unlinkRadialVigCorrCoeff(self)

    def unlinkRadialVigCorrCenterShift(self):
        r"""unlinkRadialVigCorrCenterShift(BaseSrcPanoImage self)"""
        return _hsi.BaseSrcPanoImage_unlinkRadialVigCorrCenterShift(self)

    def unlinkExifModel(self):
        r"""unlinkExifModel(BaseSrcPanoImage self)"""
        return _hsi.BaseSrcPanoImage_unlinkExifModel(self)

    def unlinkExifMake(self):
        r"""unlinkExifMake(BaseSrcPanoImage self)"""
        return _hsi.BaseSrcPanoImage_unlinkExifMake(self)

    def unlinkExifLens(self):
        r"""unlinkExifLens(BaseSrcPanoImage self)"""
        return _hsi.BaseSrcPanoImage_unlinkExifLens(self)

    def unlinkExifFocalLength(self):
        r"""unlinkExifFocalLength(BaseSrcPanoImage self)"""
        return _hsi.BaseSrcPanoImage_unlinkExifFocalLength(self)

    def unlinkExifOrientation(self):
        r"""unlinkExifOrientation(BaseSrcPanoImage self)"""
        return _hsi.BaseSrcPanoImage_unlinkExifOrientation(self)

    def unlinkExifAperture(self):
        r"""unlinkExifAperture(BaseSrcPanoImage self)"""
        return _hsi.BaseSrcPanoImage_unlinkExifAperture(self)

    def unlinkExifISO(self):
        r"""unlinkExifISO(BaseSrcPanoImage self)"""
        return _hsi.BaseSrcPanoImage_unlinkExifISO(self)

    def unlinkExifDistance(self):
        r"""unlinkExifDistance(BaseSrcPanoImage self)"""
        return _hsi.BaseSrcPanoImage_unlinkExifDistance(self)

    def unlinkExifFocalLength35(self):
        r"""unlinkExifFocalLength35(BaseSrcPanoImage self)"""
        return _hsi.BaseSrcPanoImage_unlinkExifFocalLength35(self)

    def unlinkExifCropFactor(self):
        r"""unlinkExifCropFactor(BaseSrcPanoImage self)"""
        return _hsi.BaseSrcPanoImage_unlinkExifCropFactor(self)

    def unlinkExifExposureTime(self):
        r"""unlinkExifExposureTime(BaseSrcPanoImage self)"""
        return _hsi.BaseSrcPanoImage_unlinkExifExposureTime(self)

    def unlinkExifDate(self):
        r"""unlinkExifDate(BaseSrcPanoImage self)"""
        return _hsi.BaseSrcPanoImage_unlinkExifDate(self)

    def unlinkExifExposureMode(self):
        r"""unlinkExifExposureMode(BaseSrcPanoImage self)"""
        return _hsi.BaseSrcPanoImage_unlinkExifExposureMode(self)

    def unlinkExifRedBalance(self):
        r"""unlinkExifRedBalance(BaseSrcPanoImage self)"""
        return _hsi.BaseSrcPanoImage_unlinkExifRedBalance(self)

    def unlinkExifBlueBalance(self):
        r"""unlinkExifBlueBalance(BaseSrcPanoImage self)"""
        return _hsi.BaseSrcPanoImage_unlinkExifBlueBalance(self)

    def unlinkFileMetadata(self):
        r"""unlinkFileMetadata(BaseSrcPanoImage self)"""
        return _hsi.BaseSrcPanoImage_unlinkFileMetadata(self)

    def unlinkMasks(self):
        r"""unlinkMasks(BaseSrcPanoImage self)"""
        return _hsi.BaseSrcPanoImage_unlinkMasks(self)

    def unlinkActiveMasks(self):
        r"""unlinkActiveMasks(BaseSrcPanoImage self)"""
        return _hsi.BaseSrcPanoImage_unlinkActiveMasks(self)

    def unlinkActive(self):
        r"""unlinkActive(BaseSrcPanoImage self)"""
        return _hsi.BaseSrcPanoImage_unlinkActive(self)

    def FilenameisLinked(self):
        r"""FilenameisLinked(BaseSrcPanoImage self) -> bool"""
        return _hsi.BaseSrcPanoImage_FilenameisLinked(self)

    def SizeisLinked(self):
        r"""SizeisLinked(BaseSrcPanoImage self) -> bool"""
        return _hsi.BaseSrcPanoImage_SizeisLinked(self)

    def ProjectionisLinked(self):
        r"""ProjectionisLinked(BaseSrcPanoImage self) -> bool"""
        return _hsi.BaseSrcPanoImage_ProjectionisLinked(self)

    def HFOVisLinked(self):
        r"""HFOVisLinked(BaseSrcPanoImage self) -> bool"""
        return _hsi.BaseSrcPanoImage_HFOVisLinked(self)

    def CropFactorisLinked(self):
        r"""CropFactorisLinked(BaseSrcPanoImage self) -> bool"""
        return _hsi.BaseSrcPanoImage_CropFactorisLinked(self)

    def ResponseTypeisLinked(self):
        r"""ResponseTypeisLinked(BaseSrcPanoImage self) -> bool"""
        return _hsi.BaseSrcPanoImage_ResponseTypeisLinked(self)

    def EMoRParamsisLinked(self):
        r"""EMoRParamsisLinked(BaseSrcPanoImage self) -> bool"""
        return _hsi.BaseSrcPanoImage_EMoRParamsisLinked(self)

    def ExposureValueisLinked(self):
        r"""ExposureValueisLinked(BaseSrcPanoImage self) -> bool"""
        return _hsi.BaseSrcPanoImage_ExposureValueisLinked(self)

    def GammaisLinked(self):
        r"""GammaisLinked(BaseSrcPanoImage self) -> bool"""
        return _hsi.BaseSrcPanoImage_GammaisLinked(self)

    def WhiteBalanceRedisLinked(self):
        r"""WhiteBalanceRedisLinked(BaseSrcPanoImage self) -> bool"""
        return _hsi.BaseSrcPanoImage_WhiteBalanceRedisLinked(self)

    def WhiteBalanceBlueisLinked(self):
        r"""WhiteBalanceBlueisLinked(BaseSrcPanoImage self) -> bool"""
        return _hsi.BaseSrcPanoImage_WhiteBalanceBlueisLinked(self)

    def RollisLinked(self):
        r"""RollisLinked(BaseSrcPanoImage self) -> bool"""
        return _hsi.BaseSrcPanoImage_RollisLinked(self)

    def PitchisLinked(self):
        r"""PitchisLinked(BaseSrcPanoImage self) -> bool"""
        return _hsi.BaseSrcPanoImage_PitchisLinked(self)

    def YawisLinked(self):
        r"""YawisLinked(BaseSrcPanoImage self) -> bool"""
        return _hsi.BaseSrcPanoImage_YawisLinked(self)

    def XisLinked(self):
        r"""XisLinked(BaseSrcPanoImage self) -> bool"""
        return _hsi.BaseSrcPanoImage_XisLinked(self)

    def YisLinked(self):
        r"""YisLinked(BaseSrcPanoImage self) -> bool"""
        return _hsi.BaseSrcPanoImage_YisLinked(self)

    def ZisLinked(self):
        r"""ZisLinked(BaseSrcPanoImage self) -> bool"""
        return _hsi.BaseSrcPanoImage_ZisLinked(self)

    def TranslationPlaneYawisLinked(self):
        r"""TranslationPlaneYawisLinked(BaseSrcPanoImage self) -> bool"""
        return _hsi.BaseSrcPanoImage_TranslationPlaneYawisLinked(self)

    def TranslationPlanePitchisLinked(self):
        r"""TranslationPlanePitchisLinked(BaseSrcPanoImage self) -> bool"""
        return _hsi.BaseSrcPanoImage_TranslationPlanePitchisLinked(self)

    def StackisLinked(self):
        r"""StackisLinked(BaseSrcPanoImage self) -> bool"""
        return _hsi.BaseSrcPanoImage_StackisLinked(self)

    def RadialDistortionisLinked(self):
        r"""RadialDistortionisLinked(BaseSrcPanoImage self) -> bool"""
        return _hsi.BaseSrcPanoImage_RadialDistortionisLinked(self)

    def RadialDistortionRedisLinked(self):
        r"""RadialDistortionRedisLinked(BaseSrcPanoImage self) -> bool"""
        return _hsi.BaseSrcPanoImage_RadialDistortionRedisLinked(self)

    def RadialDistortionBlueisLinked(self):
        r"""RadialDistortionBlueisLinked(BaseSrcPanoImage self) -> bool"""
        return _hsi.BaseSrcPanoImage_RadialDistortionBlueisLinked(self)

    def RadialDistortionCenterShiftisLinked(self):
        r"""RadialDistortionCenterShiftisLinked(BaseSrcPanoImage self) -> bool"""
        return _hsi.BaseSrcPanoImage_RadialDistortionCenterShiftisLinked(self)

    def ShearisLinked(self):
        r"""ShearisLinked(BaseSrcPanoImage self) -> bool"""
        return _hsi.BaseSrcPanoImage_ShearisLinked(self)

    def CropModeisLinked(self):
        r"""CropModeisLinked(BaseSrcPanoImage self) -> bool"""
        return _hsi.BaseSrcPanoImage_CropModeisLinked(self)

    def CropRectisLinked(self):
        r"""CropRectisLinked(BaseSrcPanoImage self) -> bool"""
        return _hsi.BaseSrcPanoImage_CropRectisLinked(self)

    def AutoCenterCropisLinked(self):
        r"""AutoCenterCropisLinked(BaseSrcPanoImage self) -> bool"""
        return _hsi.BaseSrcPanoImage_AutoCenterCropisLinked(self)

    def VigCorrModeisLinked(self):
        r"""VigCorrModeisLinked(BaseSrcPanoImage self) -> bool"""
        return _hsi.BaseSrcPanoImage_VigCorrModeisLinked(self)

    def FlatfieldFilenameisLinked(self):
        r"""FlatfieldFilenameisLinked(BaseSrcPanoImage self) -> bool"""
        return _hsi.BaseSrcPanoImage_FlatfieldFilenameisLinked(self)

    def RadialVigCorrCoeffisLinked(self):
        r"""RadialVigCorrCoeffisLinked(BaseSrcPanoImage self) -> bool"""
        return _hsi.BaseSrcPanoImage_RadialVigCorrCoeffisLinked(self)

    def RadialVigCorrCenterShiftisLinked(self):
        r"""RadialVigCorrCenterShiftisLinked(BaseSrcPanoImage self) -> bool"""
        return _hsi.BaseSrcPanoImage_RadialVigCorrCenterShiftisLinked(self)

    def ExifModelisLinked(self):
        r"""ExifModelisLinked(BaseSrcPanoImage self) -> bool"""
        return _hsi.BaseSrcPanoImage_ExifModelisLinked(self)

    def ExifMakeisLinked(self):
        r"""ExifMakeisLinked(BaseSrcPanoImage self) -> bool"""
        return _hsi.BaseSrcPanoImage_ExifMakeisLinked(self)

    def ExifLensisLinked(self):
        r"""ExifLensisLinked(BaseSrcPanoImage self) -> bool"""
        return _hsi.BaseSrcPanoImage_ExifLensisLinked(self)

    def ExifFocalLengthisLinked(self):
        r"""ExifFocalLengthisLinked(BaseSrcPanoImage self) -> bool"""
        return _hsi.BaseSrcPanoImage_ExifFocalLengthisLinked(self)

    def ExifOrientationisLinked(self):
        r"""ExifOrientationisLinked(BaseSrcPanoImage self) -> bool"""
        return _hsi.BaseSrcPanoImage_ExifOrientationisLinked(self)

    def ExifApertureisLinked(self):
        r"""ExifApertureisLinked(BaseSrcPanoImage self) -> bool"""
        return _hsi.BaseSrcPanoImage_ExifApertureisLinked(self)

    def ExifISOisLinked(self):
        r"""ExifISOisLinked(BaseSrcPanoImage self) -> bool"""
        return _hsi.BaseSrcPanoImage_ExifISOisLinked(self)

    def ExifDistanceisLinked(self):
        r"""ExifDistanceisLinked(BaseSrcPanoImage self) -> bool"""
        return _hsi.BaseSrcPanoImage_ExifDistanceisLinked(self)

    def ExifFocalLength35isLinked(self):
        r"""ExifFocalLength35isLinked(BaseSrcPanoImage self) -> bool"""
        return _hsi.BaseSrcPanoImage_ExifFocalLength35isLinked(self)

    def ExifCropFactorisLinked(self):
        r"""ExifCropFactorisLinked(BaseSrcPanoImage self) -> bool"""
        return _hsi.BaseSrcPanoImage_ExifCropFactorisLinked(self)

    def ExifExposureTimeisLinked(self):
        r"""ExifExposureTimeisLinked(BaseSrcPanoImage self) -> bool"""
        return _hsi.BaseSrcPanoImage_ExifExposureTimeisLinked(self)

    def ExifDateisLinked(self):
        r"""ExifDateisLinked(BaseSrcPanoImage self) -> bool"""
        return _hsi.BaseSrcPanoImage_ExifDateisLinked(self)

    def ExifExposureModeisLinked(self):
        r"""ExifExposureModeisLinked(BaseSrcPanoImage self) -> bool"""
        return _hsi.BaseSrcPanoImage_ExifExposureModeisLinked(self)

    def ExifRedBalanceisLinked(self):
        r"""ExifRedBalanceisLinked(BaseSrcPanoImage self) -> bool"""
        return _hsi.BaseSrcPanoImage_ExifRedBalanceisLinked(self)

    def ExifBlueBalanceisLinked(self):
        r"""ExifBlueBalanceisLinked(BaseSrcPanoImage self) -> bool"""
        return _hsi.BaseSrcPanoImage_ExifBlueBalanceisLinked(self)

    def FileMetadataisLinked(self):
        r"""FileMetadataisLinked(BaseSrcPanoImage self) -> bool"""
        return _hsi.BaseSrcPanoImage_FileMetadataisLinked(self)

    def MasksisLinked(self):
        r"""MasksisLinked(BaseSrcPanoImage self) -> bool"""
        return _hsi.BaseSrcPanoImage_MasksisLinked(self)

    def ActiveMasksisLinked(self):
        r"""ActiveMasksisLinked(BaseSrcPanoImage self) -> bool"""
        return _hsi.BaseSrcPanoImage_ActiveMasksisLinked(self)

    def ActiveisLinked(self):
        r"""ActiveisLinked(BaseSrcPanoImage self) -> bool"""
        return _hsi.BaseSrcPanoImage_ActiveisLinked(self)

    def FilenameisLinkedWith(self, image):
        r"""FilenameisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_FilenameisLinkedWith(self, image)

    def SizeisLinkedWith(self, image):
        r"""SizeisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_SizeisLinkedWith(self, image)

    def ProjectionisLinkedWith(self, image):
        r"""ProjectionisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_ProjectionisLinkedWith(self, image)

    def HFOVisLinkedWith(self, image):
        r"""HFOVisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_HFOVisLinkedWith(self, image)

    def CropFactorisLinkedWith(self, image):
        r"""CropFactorisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_CropFactorisLinkedWith(self, image)

    def ResponseTypeisLinkedWith(self, image):
        r"""ResponseTypeisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_ResponseTypeisLinkedWith(self, image)

    def EMoRParamsisLinkedWith(self, image):
        r"""EMoRParamsisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_EMoRParamsisLinkedWith(self, image)

    def ExposureValueisLinkedWith(self, image):
        r"""ExposureValueisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_ExposureValueisLinkedWith(self, image)

    def GammaisLinkedWith(self, image):
        r"""GammaisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_GammaisLinkedWith(self, image)

    def WhiteBalanceRedisLinkedWith(self, image):
        r"""WhiteBalanceRedisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_WhiteBalanceRedisLinkedWith(self, image)

    def WhiteBalanceBlueisLinkedWith(self, image):
        r"""WhiteBalanceBlueisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_WhiteBalanceBlueisLinkedWith(self, image)

    def RollisLinkedWith(self, image):
        r"""RollisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_RollisLinkedWith(self, image)

    def PitchisLinkedWith(self, image):
        r"""PitchisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_PitchisLinkedWith(self, image)

    def YawisLinkedWith(self, image):
        r"""YawisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_YawisLinkedWith(self, image)

    def XisLinkedWith(self, image):
        r"""XisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_XisLinkedWith(self, image)

    def YisLinkedWith(self, image):
        r"""YisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_YisLinkedWith(self, image)

    def ZisLinkedWith(self, image):
        r"""ZisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_ZisLinkedWith(self, image)

    def TranslationPlaneYawisLinkedWith(self, image):
        r"""TranslationPlaneYawisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_TranslationPlaneYawisLinkedWith(self, image)

    def TranslationPlanePitchisLinkedWith(self, image):
        r"""TranslationPlanePitchisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_TranslationPlanePitchisLinkedWith(self, image)

    def StackisLinkedWith(self, image):
        r"""StackisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_StackisLinkedWith(self, image)

    def RadialDistortionisLinkedWith(self, image):
        r"""RadialDistortionisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_RadialDistortionisLinkedWith(self, image)

    def RadialDistortionRedisLinkedWith(self, image):
        r"""RadialDistortionRedisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_RadialDistortionRedisLinkedWith(self, image)

    def RadialDistortionBlueisLinkedWith(self, image):
        r"""RadialDistortionBlueisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_RadialDistortionBlueisLinkedWith(self, image)

    def RadialDistortionCenterShiftisLinkedWith(self, image):
        r"""RadialDistortionCenterShiftisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_RadialDistortionCenterShiftisLinkedWith(self, image)

    def ShearisLinkedWith(self, image):
        r"""ShearisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_ShearisLinkedWith(self, image)

    def CropModeisLinkedWith(self, image):
        r"""CropModeisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_CropModeisLinkedWith(self, image)

    def CropRectisLinkedWith(self, image):
        r"""CropRectisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_CropRectisLinkedWith(self, image)

    def AutoCenterCropisLinkedWith(self, image):
        r"""AutoCenterCropisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_AutoCenterCropisLinkedWith(self, image)

    def VigCorrModeisLinkedWith(self, image):
        r"""VigCorrModeisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_VigCorrModeisLinkedWith(self, image)

    def FlatfieldFilenameisLinkedWith(self, image):
        r"""FlatfieldFilenameisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_FlatfieldFilenameisLinkedWith(self, image)

    def RadialVigCorrCoeffisLinkedWith(self, image):
        r"""RadialVigCorrCoeffisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_RadialVigCorrCoeffisLinkedWith(self, image)

    def RadialVigCorrCenterShiftisLinkedWith(self, image):
        r"""RadialVigCorrCenterShiftisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_RadialVigCorrCenterShiftisLinkedWith(self, image)

    def ExifModelisLinkedWith(self, image):
        r"""ExifModelisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_ExifModelisLinkedWith(self, image)

    def ExifMakeisLinkedWith(self, image):
        r"""ExifMakeisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_ExifMakeisLinkedWith(self, image)

    def ExifLensisLinkedWith(self, image):
        r"""ExifLensisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_ExifLensisLinkedWith(self, image)

    def ExifFocalLengthisLinkedWith(self, image):
        r"""ExifFocalLengthisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_ExifFocalLengthisLinkedWith(self, image)

    def ExifOrientationisLinkedWith(self, image):
        r"""ExifOrientationisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_ExifOrientationisLinkedWith(self, image)

    def ExifApertureisLinkedWith(self, image):
        r"""ExifApertureisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_ExifApertureisLinkedWith(self, image)

    def ExifISOisLinkedWith(self, image):
        r"""ExifISOisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_ExifISOisLinkedWith(self, image)

    def ExifDistanceisLinkedWith(self, image):
        r"""ExifDistanceisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_ExifDistanceisLinkedWith(self, image)

    def ExifFocalLength35isLinkedWith(self, image):
        r"""ExifFocalLength35isLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_ExifFocalLength35isLinkedWith(self, image)

    def ExifCropFactorisLinkedWith(self, image):
        r"""ExifCropFactorisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_ExifCropFactorisLinkedWith(self, image)

    def ExifExposureTimeisLinkedWith(self, image):
        r"""ExifExposureTimeisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_ExifExposureTimeisLinkedWith(self, image)

    def ExifDateisLinkedWith(self, image):
        r"""ExifDateisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_ExifDateisLinkedWith(self, image)

    def ExifExposureModeisLinkedWith(self, image):
        r"""ExifExposureModeisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_ExifExposureModeisLinkedWith(self, image)

    def ExifRedBalanceisLinkedWith(self, image):
        r"""ExifRedBalanceisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_ExifRedBalanceisLinkedWith(self, image)

    def ExifBlueBalanceisLinkedWith(self, image):
        r"""ExifBlueBalanceisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_ExifBlueBalanceisLinkedWith(self, image)

    def FileMetadataisLinkedWith(self, image):
        r"""FileMetadataisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_FileMetadataisLinkedWith(self, image)

    def MasksisLinkedWith(self, image):
        r"""MasksisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_MasksisLinkedWith(self, image)

    def ActiveMasksisLinkedWith(self, image):
        r"""ActiveMasksisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_ActiveMasksisLinkedWith(self, image)

    def ActiveisLinkedWith(self, image):
        r"""ActiveisLinkedWith(BaseSrcPanoImage self, BaseSrcPanoImage image) -> bool"""
        return _hsi.BaseSrcPanoImage_ActiveisLinkedWith(self, image)

# Register BaseSrcPanoImage in _hsi:
_hsi.BaseSrcPanoImage_swigregister(BaseSrcPanoImage)

class SrcPanoImage(BaseSrcPanoImage):
    r"""Proxy of C++ HuginBase::SrcPanoImage class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(SrcPanoImage self) -> SrcPanoImage
        __init__(SrcPanoImage self, HuginBase::BaseSrcPanoImage::Projection const projection, double const hfov, Size2D size) -> SrcPanoImage
        """
        _hsi.SrcPanoImage_swiginit(self, _hsi.new_SrcPanoImage(*args))
    __swig_destroy__ = _hsi.delete_SrcPanoImage

    def resize(self, size):
        r"""resize(SrcPanoImage self, Size2D size)"""
        return _hsi.SrcPanoImage_resize(self, size)

    def isInside(self, p, ignoreMasks=False):
        r"""isInside(SrcPanoImage self, Point2D p, bool ignoreMasks=False) -> bool"""
        return _hsi.SrcPanoImage_isInside(self, p, ignoreMasks)

    def horizontalWarpNeeded(self):
        r"""horizontalWarpNeeded(SrcPanoImage self) -> bool"""
        return _hsi.SrcPanoImage_horizontalWarpNeeded(self)

    def getCorrectTCA(self):
        r"""getCorrectTCA(SrcPanoImage self) -> bool"""
        return _hsi.SrcPanoImage_getCorrectTCA(self)

    def setCropMode(self, val):
        r"""setCropMode(SrcPanoImage self, HuginBase::BaseSrcPanoImage::CropMode val)"""
        return _hsi.SrcPanoImage_setCropMode(self, val)

    def isCircularCrop(self):
        r"""isCircularCrop(SrcPanoImage self) -> bool"""
        return _hsi.SrcPanoImage_isCircularCrop(self)

    def setSize(self, val):
        r"""setSize(SrcPanoImage self, Size2D val)"""
        return _hsi.SrcPanoImage_setSize(self, val)

    def getRadialDistortionCenter(self):
        r"""getRadialDistortionCenter(SrcPanoImage self) -> FDiff2D"""
        return _hsi.SrcPanoImage_getRadialDistortionCenter(self)

    def getRadialVigCorrCenter(self):
        r"""getRadialVigCorrCenter(SrcPanoImage self) -> FDiff2D"""
        return _hsi.SrcPanoImage_getRadialVigCorrCenter(self)

    def getExposure(self):
        r"""getExposure(SrcPanoImage self) -> double"""
        return _hsi.SrcPanoImage_getExposure(self)

    def setExposure(self, val):
        r"""setExposure(SrcPanoImage self, double const & val)"""
        return _hsi.SrcPanoImage_setExposure(self, val)

    def getWidth(self):
        r"""getWidth(SrcPanoImage self) -> int"""
        return _hsi.SrcPanoImage_getWidth(self)

    def getHeight(self):
        r"""getHeight(SrcPanoImage self) -> int"""
        return _hsi.SrcPanoImage_getHeight(self)

    def getVar(self, name):
        r"""getVar(SrcPanoImage self, std::string const & name) -> double"""
        return _hsi.SrcPanoImage_getVar(self, name)

    def setVar(self, name, val):
        r"""setVar(SrcPanoImage self, std::string const & name, double val)"""
        return _hsi.SrcPanoImage_setVar(self, name, val)

    def getVariableMap(self):
        r"""getVariableMap(SrcPanoImage self) -> HuginBase::VariableMap"""
        return _hsi.SrcPanoImage_getVariableMap(self)

    def getExifDateTime(self, datetime):
        r"""getExifDateTime(SrcPanoImage self, tm datetime) -> int const"""
        return _hsi.SrcPanoImage_getExifDateTime(self, datetime)

    def unlinkRadialVigCorrCoeff(self):
        r"""unlinkRadialVigCorrCoeff(SrcPanoImage self)"""
        return _hsi.SrcPanoImage_unlinkRadialVigCorrCoeff(self)

    def unlinkRadialVigCorrCenterShift(self):
        r"""unlinkRadialVigCorrCenterShift(SrcPanoImage self)"""
        return _hsi.SrcPanoImage_unlinkRadialVigCorrCenterShift(self)

    def unlinkEMoRParams(self):
        r"""unlinkEMoRParams(SrcPanoImage self)"""
        return _hsi.SrcPanoImage_unlinkEMoRParams(self)

    def linkRadialVigCorrCoeff(self, target):
        r"""linkRadialVigCorrCoeff(SrcPanoImage self, SrcPanoImage target)"""
        return _hsi.SrcPanoImage_linkRadialVigCorrCoeff(self, target)

    def linkRadialVigCorrCenterShift(self, target):
        r"""linkRadialVigCorrCenterShift(SrcPanoImage self, SrcPanoImage target)"""
        return _hsi.SrcPanoImage_linkRadialVigCorrCenterShift(self, target)

    def linkEMoRParams(self, target):
        r"""linkEMoRParams(SrcPanoImage self, SrcPanoImage target)"""
        return _hsi.SrcPanoImage_linkEMoRParams(self, target)

    def linkStack(self, target):
        r"""linkStack(SrcPanoImage self, SrcPanoImage target)"""
        return _hsi.SrcPanoImage_linkStack(self, target)

    def checkImageSizeKnown(self):
        r"""checkImageSizeKnown(SrcPanoImage self) -> bool"""
        return _hsi.SrcPanoImage_checkImageSizeKnown(self)

    def readEXIF(self):
        r"""readEXIF(SrcPanoImage self) -> bool"""
        return _hsi.SrcPanoImage_readEXIF(self)

    def applyEXIFValues(self, applyEVValue=True):
        r"""applyEXIFValues(SrcPanoImage self, bool applyEVValue=True) -> bool"""
        return _hsi.SrcPanoImage_applyEXIFValues(self, applyEVValue)

    @staticmethod
    def calcHFOV(proj, fl, crop, imageSize):
        r"""calcHFOV(HuginBase::SrcPanoImage::Projection proj, double fl, double crop, Size2D imageSize) -> double"""
        return _hsi.SrcPanoImage_calcHFOV(proj, fl, crop, imageSize)

    @staticmethod
    def calcFocalLength(proj, hfov, crop, imageSize):
        r"""calcFocalLength(HuginBase::SrcPanoImage::Projection proj, double hfov, double crop, Size2D imageSize) -> double"""
        return _hsi.SrcPanoImage_calcFocalLength(proj, hfov, crop, imageSize)

    @staticmethod
    def calcCropFactor(proj, hfov, focalLength, imageSize):
        r"""calcCropFactor(HuginBase::SrcPanoImage::Projection proj, double hfov, double focalLength, Size2D imageSize) -> double"""
        return _hsi.SrcPanoImage_calcCropFactor(proj, hfov, focalLength, imageSize)

    def calcExifExposureValue(self):
        r"""calcExifExposureValue(SrcPanoImage self) -> double"""
        return _hsi.SrcPanoImage_calcExifExposureValue(self)

    def updateFocalLength(self, newFocalLength):
        r"""updateFocalLength(SrcPanoImage self, double newFocalLength)"""
        return _hsi.SrcPanoImage_updateFocalLength(self, newFocalLength)

    def updateCropFactor(self, focalLength, newCropFactor):
        r"""updateCropFactor(SrcPanoImage self, double focalLength, double newCropFactor)"""
        return _hsi.SrcPanoImage_updateCropFactor(self, focalLength, newCropFactor)

    def readCropfactorFromDB(self):
        r"""readCropfactorFromDB(SrcPanoImage self) -> bool"""
        return _hsi.SrcPanoImage_readCropfactorFromDB(self)

    def readProjectionFromDB(self, ignoreFovRectilinear=True):
        r"""readProjectionFromDB(SrcPanoImage self, bool const ignoreFovRectilinear=True) -> bool"""
        return _hsi.SrcPanoImage_readProjectionFromDB(self, ignoreFovRectilinear)

    def readDistortionFromDB(self):
        r"""readDistortionFromDB(SrcPanoImage self) -> bool"""
        return _hsi.SrcPanoImage_readDistortionFromDB(self)

    def readVignettingFromDB(self):
        r"""readVignettingFromDB(SrcPanoImage self) -> bool"""
        return _hsi.SrcPanoImage_readVignettingFromDB(self)

    def getDBLensName(self):
        r"""getDBLensName(SrcPanoImage self) -> std::string"""
        return _hsi.SrcPanoImage_getDBLensName(self)

    def hasMasks(self):
        r"""hasMasks(SrcPanoImage self) -> bool"""
        return _hsi.SrcPanoImage_hasMasks(self)

    def hasPositiveMasks(self):
        r"""hasPositiveMasks(SrcPanoImage self) -> bool"""
        return _hsi.SrcPanoImage_hasPositiveMasks(self)

    def hasActiveMasks(self):
        r"""hasActiveMasks(SrcPanoImage self) -> bool"""
        return _hsi.SrcPanoImage_hasActiveMasks(self)

    def addMask(self, newMask):
        r"""addMask(SrcPanoImage self, MaskPolygon newMask)"""
        return _hsi.SrcPanoImage_addMask(self, newMask)

    def addActiveMask(self, newMask):
        r"""addActiveMask(SrcPanoImage self, MaskPolygon newMask)"""
        return _hsi.SrcPanoImage_addActiveMask(self, newMask)

    def clearActiveMasks(self):
        r"""clearActiveMasks(SrcPanoImage self)"""
        return _hsi.SrcPanoImage_clearActiveMasks(self)

    def changeMaskType(self, index, newType):
        r"""changeMaskType(SrcPanoImage self, unsigned int index, HuginBase::MaskPolygon::MaskType newType)"""
        return _hsi.SrcPanoImage_changeMaskType(self, index, newType)

    def deleteMask(self, index):
        r"""deleteMask(SrcPanoImage self, unsigned int index)"""
        return _hsi.SrcPanoImage_deleteMask(self, index)

    def deleteAllMasks(self):
        r"""deleteAllMasks(SrcPanoImage self)"""
        return _hsi.SrcPanoImage_deleteAllMasks(self)

    def printMaskLines(self, o, newImgNr):
        r"""printMaskLines(SrcPanoImage self, ostream o, unsigned int newImgNr)"""
        return _hsi.SrcPanoImage_printMaskLines(self, o, newImgNr)

    def isInsideMasks(self, p):
        r"""isInsideMasks(SrcPanoImage self, Point2D p) -> bool"""
        return _hsi.SrcPanoImage_isInsideMasks(self, p)

# Register SrcPanoImage in _hsi:
_hsi.SrcPanoImage_swigregister(SrcPanoImage)

def SrcPanoImage_calcHFOV(proj, fl, crop, imageSize):
    r"""SrcPanoImage_calcHFOV(HuginBase::SrcPanoImage::Projection proj, double fl, double crop, Size2D imageSize) -> double"""
    return _hsi.SrcPanoImage_calcHFOV(proj, fl, crop, imageSize)

def SrcPanoImage_calcFocalLength(proj, hfov, crop, imageSize):
    r"""SrcPanoImage_calcFocalLength(HuginBase::SrcPanoImage::Projection proj, double hfov, double crop, Size2D imageSize) -> double"""
    return _hsi.SrcPanoImage_calcFocalLength(proj, hfov, crop, imageSize)

def SrcPanoImage_calcCropFactor(proj, hfov, focalLength, imageSize):
    r"""SrcPanoImage_calcCropFactor(HuginBase::SrcPanoImage::Projection proj, double hfov, double focalLength, Size2D imageSize) -> double"""
    return _hsi.SrcPanoImage_calcCropFactor(proj, hfov, focalLength, imageSize)

class ControlPoint(object):
    r"""Proxy of C++ HuginBase::ControlPoint class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    X_Y = _hsi.ControlPoint_X_Y
    
    X = _hsi.ControlPoint_X
    
    Y = _hsi.ControlPoint_Y
    

    def __init__(self, *args):
        r"""
        __init__(ControlPoint self) -> ControlPoint
        __init__(ControlPoint self, unsigned int img1, double sX, double sY, unsigned int img2, double dX, double dY, int mode=X_Y) -> ControlPoint
        """
        _hsi.ControlPoint_swiginit(self, _hsi.new_ControlPoint(*args))

    def __eq__(self, o):
        r"""__eq__(ControlPoint self, ControlPoint o) -> bool"""
        return _hsi.ControlPoint___eq__(self, o)

    def getCPString(self):
        r"""getCPString(ControlPoint self) -> std::string const"""
        return _hsi.ControlPoint_getCPString(self)

    def mirror(self):
        r"""mirror(ControlPoint self)"""
        return _hsi.ControlPoint_mirror(self)
    image1Nr = property(_hsi.ControlPoint_image1Nr_get, _hsi.ControlPoint_image1Nr_set, doc=r"""image1Nr : unsigned int""")
    image2Nr = property(_hsi.ControlPoint_image2Nr_get, _hsi.ControlPoint_image2Nr_set, doc=r"""image2Nr : unsigned int""")
    x1 = property(_hsi.ControlPoint_x1_get, _hsi.ControlPoint_x1_set, doc=r"""x1 : double""")
    y1 = property(_hsi.ControlPoint_y1_get, _hsi.ControlPoint_y1_set, doc=r"""y1 : double""")
    x2 = property(_hsi.ControlPoint_x2_get, _hsi.ControlPoint_x2_set, doc=r"""x2 : double""")
    y2 = property(_hsi.ControlPoint_y2_get, _hsi.ControlPoint_y2_set, doc=r"""y2 : double""")
    error = property(_hsi.ControlPoint_error_get, _hsi.ControlPoint_error_set, doc=r"""error : double""")
    mode = property(_hsi.ControlPoint_mode_get, _hsi.ControlPoint_mode_set, doc=r"""mode : int""")
    __swig_destroy__ = _hsi.delete_ControlPoint

# Register ControlPoint in _hsi:
_hsi.ControlPoint_swigregister(ControlPoint)

class Lens(object):
    r"""Proxy of C++ HuginBase::Lens class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(Lens self) -> Lens"""
        _hsi.Lens_swiginit(self, _hsi.new_Lens())

    def getProjection(self):
        r"""getProjection(Lens self) -> HuginBase::Lens::LensProjectionFormat"""
        return _hsi.Lens_getProjection(self)

    def setProjection(self, l):
        r"""setProjection(Lens self, HuginBase::Lens::LensProjectionFormat l)"""
        return _hsi.Lens_setProjection(self, l)

    def getHFOV(self):
        r"""getHFOV(Lens self) -> double"""
        return _hsi.Lens_getHFOV(self)

    def setHFOV(self, d):
        r"""setHFOV(Lens self, double d)"""
        return _hsi.Lens_setHFOV(self, d)

    def getFocalLength(self):
        r"""getFocalLength(Lens self) -> double"""
        return _hsi.Lens_getFocalLength(self)

    def getCropFactor(self):
        r"""getCropFactor(Lens self) -> double"""
        return _hsi.Lens_getCropFactor(self)

    def setCropFactor(self, newCropFactor):
        r"""setCropFactor(Lens self, double newCropFactor)"""
        return _hsi.Lens_setCropFactor(self, newCropFactor)

    def getAspectRatio(self):
        r"""getAspectRatio(Lens self) -> double"""
        return _hsi.Lens_getAspectRatio(self)

    def isLandscape(self):
        r"""isLandscape(Lens self) -> bool"""
        return _hsi.Lens_isLandscape(self)

    def getImageSize(self):
        r"""getImageSize(Lens self) -> Size2D"""
        return _hsi.Lens_getImageSize(self)

    def setImageSize(self, sz):
        r"""setImageSize(Lens self, Size2D sz)"""
        return _hsi.Lens_setImageSize(self, sz)

    def update(self, l):
        r"""update(Lens self, Lens l)"""
        return _hsi.Lens_update(self, l)
    variables = property(_hsi.Lens_variables_get, _hsi.Lens_variables_set, doc=r"""variables : HuginBase::LensVarMap""")
    m_hasExif = property(_hsi.Lens_m_hasExif_get, _hsi.Lens_m_hasExif_set, doc=r"""m_hasExif : bool""")
    __swig_destroy__ = _hsi.delete_Lens

# Register Lens in _hsi:
_hsi.Lens_swigregister(Lens)

class MaskPolygon(object):
    r"""Proxy of C++ HuginBase::MaskPolygon class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __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):
        r"""__init__(MaskPolygon self) -> MaskPolygon"""
        _hsi.MaskPolygon_swiginit(self, _hsi.new_MaskPolygon())

    def isInside(self, p):
        r"""isInside(MaskPolygon self, FDiff2D p) -> bool"""
        return _hsi.MaskPolygon_isInside(self, p)

    def getWindingNumber(self, p):
        r"""getWindingNumber(MaskPolygon self, FDiff2D p) -> int"""
        return _hsi.MaskPolygon_getWindingNumber(self, p)

    def getTotalWindingNumber(self):
        r"""getTotalWindingNumber(MaskPolygon self) -> int"""
        return _hsi.MaskPolygon_getTotalWindingNumber(self)

    def getMaskType(self):
        r"""getMaskType(MaskPolygon self) -> HuginBase::MaskPolygon::MaskType"""
        return _hsi.MaskPolygon_getMaskType(self)

    def setMaskType(self, newType):
        r"""setMaskType(MaskPolygon self, HuginBase::MaskPolygon::MaskType const newType)"""
        return _hsi.MaskPolygon_setMaskType(self, newType)

    def isPositive(self):
        r"""isPositive(MaskPolygon self) -> bool"""
        return _hsi.MaskPolygon_isPositive(self)

    def getMaskPolygon(self):
        r"""getMaskPolygon(MaskPolygon self) -> HuginBase::VectorPolygon"""
        return _hsi.MaskPolygon_getMaskPolygon(self)

    def setMaskPolygon(self, newMask):
        r"""setMaskPolygon(MaskPolygon self, HuginBase::VectorPolygon const & newMask)"""
        return _hsi.MaskPolygon_setMaskPolygon(self, newMask)

    def getImgNr(self):
        r"""getImgNr(MaskPolygon self) -> unsigned int"""
        return _hsi.MaskPolygon_getImgNr(self)

    def setImgNr(self, newImgNr):
        r"""setImgNr(MaskPolygon self, unsigned int const newImgNr)"""
        return _hsi.MaskPolygon_setImgNr(self, newImgNr)

    def setInverted(self, inverted):
        r"""setInverted(MaskPolygon self, bool const inverted)"""
        return _hsi.MaskPolygon_setInverted(self, inverted)

    def isInverted(self):
        r"""isInverted(MaskPolygon self) -> bool"""
        return _hsi.MaskPolygon_isInverted(self)

    def addPoint(self, p):
        r"""addPoint(MaskPolygon self, FDiff2D p)"""
        return _hsi.MaskPolygon_addPoint(self, p)

    def insertPoint(self, index, p):
        r"""insertPoint(MaskPolygon self, unsigned int const index, FDiff2D p)"""
        return _hsi.MaskPolygon_insertPoint(self, index, p)

    def removePoint(self, index):
        r"""removePoint(MaskPolygon self, unsigned int const index)"""
        return _hsi.MaskPolygon_removePoint(self, index)

    def movePointTo(self, index, p):
        r"""movePointTo(MaskPolygon self, unsigned int const index, FDiff2D p)"""
        return _hsi.MaskPolygon_movePointTo(self, index, p)

    def movePointBy(self, index, diff):
        r"""movePointBy(MaskPolygon self, unsigned int const index, FDiff2D diff)"""
        return _hsi.MaskPolygon_movePointBy(self, index, diff)

    def scale(self, *args):
        r"""
        scale(MaskPolygon self, double const factorx, double const factory)
        scale(MaskPolygon self, double const factor)
        """
        return _hsi.MaskPolygon_scale(self, *args)

    def transformPolygon(self, trans):
        r"""transformPolygon(MaskPolygon self, Transform trans)"""
        return _hsi.MaskPolygon_transformPolygon(self, trans)

    def clipPolygon(self, *args):
        r"""
        clipPolygon(MaskPolygon self, Rect2D rect) -> bool
        clipPolygon(MaskPolygon self, FDiff2D center, double const radius) -> bool
        """
        return _hsi.MaskPolygon_clipPolygon(self, *args)

    def rotate90(self, clockwise, maskWidth, maskHeight):
        r"""rotate90(MaskPolygon self, bool clockwise, unsigned int maskWidth, unsigned int maskHeight)"""
        return _hsi.MaskPolygon_rotate90(self, clockwise, maskWidth, maskHeight)

    def subSample(self, max_distance):
        r"""subSample(MaskPolygon self, double const max_distance)"""
        return _hsi.MaskPolygon_subSample(self, max_distance)

    def FindPointNearPos(self, p, tol):
        r"""FindPointNearPos(MaskPolygon self, FDiff2D p, double const tol) -> unsigned int"""
        return _hsi.MaskPolygon_FindPointNearPos(self, p, tol)

    def __eq__(self, otherPoly):
        r"""__eq__(MaskPolygon self, MaskPolygon otherPoly) -> bool const"""
        return _hsi.MaskPolygon___eq__(self, otherPoly)

    def parsePolygonString(self, polygonStr):
        r"""parsePolygonString(MaskPolygon self, std::string const & polygonStr) -> bool"""
        return _hsi.MaskPolygon_parsePolygonString(self, polygonStr)

    def printPolygonLine(self, o, newImgNr):
        r"""printPolygonLine(MaskPolygon self, ostream o, unsigned int const newImgNr)"""
        return _hsi.MaskPolygon_printPolygonLine(self, o, newImgNr)
    __swig_destroy__ = _hsi.delete_MaskPolygon

# Register MaskPolygon in _hsi:
_hsi.MaskPolygon_swigregister(MaskPolygon)
maskOffset = cvar.maskOffset


def LoadMaskFromStream(stream, imageSize, newMasks, imgNr):
    r"""LoadMaskFromStream(istream stream, Size2D imageSize, HuginBase::MaskPolygonVector & newMasks, size_t imgNr)"""
    return _hsi.LoadMaskFromStream(stream, imageSize, newMasks, imgNr)

def SaveMaskToStream(stream, imageSize, maskToWrite, imgNr):
    r"""SaveMaskToStream(ostream stream, Size2D imageSize, MaskPolygon maskToWrite, size_t imgNr)"""
    return _hsi.SaveMaskToStream(stream, imageSize, maskToWrite, imgNr)
class PanoramaMemento(PanoramaDataMemento):
    r"""Proxy of C++ HuginBase::PanoramaMemento class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(PanoramaMemento self) -> PanoramaMemento
        __init__(PanoramaMemento self, PanoramaMemento o) -> PanoramaMemento
        """
        _hsi.PanoramaMemento_swiginit(self, _hsi.new_PanoramaMemento(*args))
    __swig_destroy__ = _hsi.delete_PanoramaMemento

    def loadPTScript(self, *args):
        r"""loadPTScript(PanoramaMemento self, istream i, int & ptoVersion, std::string const & prefix="") -> bool"""
        return _hsi.PanoramaMemento_loadPTScript(self, *args)

# Register PanoramaMemento in _hsi:
_hsi.PanoramaMemento_swigregister(PanoramaMemento)

class Panorama(ManagedPanoramaData, DocumentData):
    r"""Proxy of C++ HuginBase::Panorama class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(Panorama self) -> Panorama"""
        _hsi.Panorama_swiginit(self, _hsi.new_Panorama())
    __swig_destroy__ = _hsi.delete_Panorama

    def getSubset(self, imgs):
        r"""getSubset(Panorama self, UIntSet imgs) -> Panorama"""
        return _hsi.Panorama_getSubset(self, imgs)

    def duplicate(self):
        r"""duplicate(Panorama self) -> Panorama"""
        return _hsi.Panorama_duplicate(self)

    def getNewSubset(self, imgs):
        r"""getNewSubset(Panorama self, UIntSet imgs) -> PanoramaData"""
        return _hsi.Panorama_getNewSubset(self, imgs)

    def getNewCopy(self):
        r"""getNewCopy(Panorama self) -> PanoramaData"""
        return _hsi.Panorama_getNewCopy(self)

    def getUnlinkedSubset(self, imageGroups):
        r"""getUnlinkedSubset(Panorama self, HuginBase::UIntSetVector & imageGroups) -> PanoramaData"""
        return _hsi.Panorama_getUnlinkedSubset(self, imageGroups)

    def getNrOfImages(self):
        r"""getNrOfImages(Panorama self) -> std::size_t"""
        return _hsi.Panorama_getNrOfImages(self)

    def getImage(self, nr):
        r"""getImage(Panorama self, std::size_t nr) -> SrcPanoImage"""
        return _hsi.Panorama_getImage(self, nr)

    def setImage(self, nr, img):
        r"""setImage(Panorama self, std::size_t nr, SrcPanoImage img)"""
        return _hsi.Panorama_setImage(self, nr, img)

    def addImage(self, img):
        r"""addImage(Panorama self, SrcPanoImage img) -> unsigned int"""
        return _hsi.Panorama_addImage(self, img)

    def mergePanorama(self, newPano):
        r"""mergePanorama(Panorama self, Panorama newPano)"""
        return _hsi.Panorama_mergePanorama(self, newPano)

    def removeImage(self, nr):
        r"""removeImage(Panorama self, unsigned int nr)"""
        return _hsi.Panorama_removeImage(self, nr)

    def swapImages(self, img1, img2):
        r"""swapImages(Panorama self, unsigned int img1, unsigned int img2)"""
        return _hsi.Panorama_swapImages(self, img1, img2)

    def moveImage(self, img1, img2):
        r"""moveImage(Panorama self, size_t img1, size_t img2)"""
        return _hsi.Panorama_moveImage(self, img1, img2)

    def getSrcImage(self, imgNr):
        r"""getSrcImage(Panorama self, unsigned int imgNr) -> SrcPanoImage"""
        return _hsi.Panorama_getSrcImage(self, imgNr)

    def setSrcImage(self, nr, img):
        r"""setSrcImage(Panorama self, unsigned int nr, SrcPanoImage img)"""
        return _hsi.Panorama_setSrcImage(self, nr, img)

    def setImageFilename(self, img, fname):
        r"""setImageFilename(Panorama self, unsigned int img, std::string const & fname)"""
        return _hsi.Panorama_setImageFilename(self, img, fname)

    def activateImage(self, imgNr, active=True):
        r"""activateImage(Panorama self, unsigned int imgNr, bool active=True)"""
        return _hsi.Panorama_activateImage(self, imgNr, active)

    def getActiveImages(self):
        r"""getActiveImages(Panorama self) -> UIntSet"""
        return _hsi.Panorama_getActiveImages(self)

    def getNrOfCtrlPoints(self):
        r"""getNrOfCtrlPoints(Panorama self) -> std::size_t"""
        return _hsi.Panorama_getNrOfCtrlPoints(self)

    def getCtrlPoint(self, nr):
        r"""getCtrlPoint(Panorama self, std::size_t nr) -> ControlPoint"""
        return _hsi.Panorama_getCtrlPoint(self, nr)

    def getCtrlPoints(self):
        r"""getCtrlPoints(Panorama self) -> HuginBase::CPVector const &"""
        return _hsi.Panorama_getCtrlPoints(self)

    def getCtrlPointsForImage(self, imgNr):
        r"""getCtrlPointsForImage(Panorama self, unsigned int imgNr) -> UIntVector"""
        return _hsi.Panorama_getCtrlPointsForImage(self, imgNr)

    def getCtrlPointsVectorForImage(self, imgNr):
        r"""getCtrlPointsVectorForImage(Panorama self, unsigned int imgNr) -> HuginBase::CPointVector"""
        return _hsi.Panorama_getCtrlPointsVectorForImage(self, imgNr)

    def setCtrlPoints(self, points):
        r"""setCtrlPoints(Panorama self, HuginBase::CPVector const & points)"""
        return _hsi.Panorama_setCtrlPoints(self, points)

    def addCtrlPoint(self, point):
        r"""addCtrlPoint(Panorama self, ControlPoint point) -> unsigned int"""
        return _hsi.Panorama_addCtrlPoint(self, point)

    def removeCtrlPoint(self, pNr):
        r"""removeCtrlPoint(Panorama self, unsigned int pNr)"""
        return _hsi.Panorama_removeCtrlPoint(self, pNr)

    def removeDuplicateCtrlPoints(self):
        r"""removeDuplicateCtrlPoints(Panorama self)"""
        return _hsi.Panorama_removeDuplicateCtrlPoints(self)

    def changeControlPoint(self, pNr, point):
        r"""changeControlPoint(Panorama self, unsigned int pNr, ControlPoint point)"""
        return _hsi.Panorama_changeControlPoint(self, pNr, point)

    def getNextCPTypeLineNumber(self):
        r"""getNextCPTypeLineNumber(Panorama self) -> int"""
        return _hsi.Panorama_getNextCPTypeLineNumber(self)

    def updateLineCtrlPoints(self):
        r"""updateLineCtrlPoints(Panorama self)"""
        return _hsi.Panorama_updateLineCtrlPoints(self)

    def updateCtrlPointErrors(self, *args):
        r"""
        updateCtrlPointErrors(Panorama self, HuginBase::CPVector const & controlPoints)
        updateCtrlPointErrors(Panorama self, UIntSet imgs, HuginBase::CPVector const & cps)
        """
        return _hsi.Panorama_updateCtrlPointErrors(self, *args)

    def getICCProfileDesc(self):
        r"""getICCProfileDesc(Panorama self) -> std::string const"""
        return _hsi.Panorama_getICCProfileDesc(self)

    def setICCProfileDesc(self, newDesc):
        r"""setICCProfileDesc(Panorama self, std::string const & newDesc)"""
        return _hsi.Panorama_setICCProfileDesc(self, newDesc)

    def getNrOfBands(self):
        r"""getNrOfBands(Panorama self) -> int const"""
        return _hsi.Panorama_getNrOfBands(self)

    def setNrOfBands(self, nrBands):
        r"""setNrOfBands(Panorama self, int const nrBands)"""
        return _hsi.Panorama_setNrOfBands(self, nrBands)

    def getVariables(self):
        r"""getVariables(Panorama self) -> HuginBase::VariableMapVector"""
        return _hsi.Panorama_getVariables(self)

    def getImageVariables(self, imgNr):
        r"""getImageVariables(Panorama self, unsigned int imgNr) -> HuginBase::VariableMap const"""
        return _hsi.Panorama_getImageVariables(self, imgNr)

    def updateVariables(self, *args):
        r"""
        updateVariables(Panorama self, HuginBase::VariableMapVector const & vars)
        updateVariables(Panorama self, UIntSet imgs, HuginBase::VariableMapVector const & var)
        updateVariables(Panorama self, unsigned int imgNr, HuginBase::VariableMap const & var)
        """
        return _hsi.Panorama_updateVariables(self, *args)

    def updateVariable(self, imgNr, var):
        r"""updateVariable(Panorama self, unsigned int imgNr, Variable var)"""
        return _hsi.Panorama_updateVariable(self, imgNr, var)

    def UpdateFocalLength(self, imgs, newFocalLength):
        r"""UpdateFocalLength(Panorama self, UIntSet imgs, double newFocalLength)"""
        return _hsi.Panorama_UpdateFocalLength(self, imgs, newFocalLength)

    def UpdateCropFactor(self, imgs, newCropFactor):
        r"""UpdateCropFactor(Panorama self, UIntSet imgs, double newCropFactor)"""
        return _hsi.Panorama_UpdateCropFactor(self, imgs, newCropFactor)

    def linkImageVariableFilename(self, sourceImgNr, destImgNr):
        r"""linkImageVariableFilename(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableFilename(self, sourceImgNr, destImgNr)

    def linkImageVariableSize(self, sourceImgNr, destImgNr):
        r"""linkImageVariableSize(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableSize(self, sourceImgNr, destImgNr)

    def linkImageVariableProjection(self, sourceImgNr, destImgNr):
        r"""linkImageVariableProjection(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableProjection(self, sourceImgNr, destImgNr)

    def linkImageVariableHFOV(self, sourceImgNr, destImgNr):
        r"""linkImageVariableHFOV(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableHFOV(self, sourceImgNr, destImgNr)

    def linkImageVariableCropFactor(self, sourceImgNr, destImgNr):
        r"""linkImageVariableCropFactor(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableCropFactor(self, sourceImgNr, destImgNr)

    def linkImageVariableResponseType(self, sourceImgNr, destImgNr):
        r"""linkImageVariableResponseType(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableResponseType(self, sourceImgNr, destImgNr)

    def linkImageVariableEMoRParams(self, sourceImgNr, destImgNr):
        r"""linkImageVariableEMoRParams(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableEMoRParams(self, sourceImgNr, destImgNr)

    def linkImageVariableExposureValue(self, sourceImgNr, destImgNr):
        r"""linkImageVariableExposureValue(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableExposureValue(self, sourceImgNr, destImgNr)

    def linkImageVariableGamma(self, sourceImgNr, destImgNr):
        r"""linkImageVariableGamma(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableGamma(self, sourceImgNr, destImgNr)

    def linkImageVariableWhiteBalanceRed(self, sourceImgNr, destImgNr):
        r"""linkImageVariableWhiteBalanceRed(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableWhiteBalanceRed(self, sourceImgNr, destImgNr)

    def linkImageVariableWhiteBalanceBlue(self, sourceImgNr, destImgNr):
        r"""linkImageVariableWhiteBalanceBlue(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableWhiteBalanceBlue(self, sourceImgNr, destImgNr)

    def linkImageVariableRoll(self, sourceImgNr, destImgNr):
        r"""linkImageVariableRoll(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableRoll(self, sourceImgNr, destImgNr)

    def linkImageVariablePitch(self, sourceImgNr, destImgNr):
        r"""linkImageVariablePitch(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariablePitch(self, sourceImgNr, destImgNr)

    def linkImageVariableYaw(self, sourceImgNr, destImgNr):
        r"""linkImageVariableYaw(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableYaw(self, sourceImgNr, destImgNr)

    def linkImageVariableX(self, sourceImgNr, destImgNr):
        r"""linkImageVariableX(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableX(self, sourceImgNr, destImgNr)

    def linkImageVariableY(self, sourceImgNr, destImgNr):
        r"""linkImageVariableY(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableY(self, sourceImgNr, destImgNr)

    def linkImageVariableZ(self, sourceImgNr, destImgNr):
        r"""linkImageVariableZ(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableZ(self, sourceImgNr, destImgNr)

    def linkImageVariableTranslationPlaneYaw(self, sourceImgNr, destImgNr):
        r"""linkImageVariableTranslationPlaneYaw(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableTranslationPlaneYaw(self, sourceImgNr, destImgNr)

    def linkImageVariableTranslationPlanePitch(self, sourceImgNr, destImgNr):
        r"""linkImageVariableTranslationPlanePitch(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableTranslationPlanePitch(self, sourceImgNr, destImgNr)

    def linkImageVariableStack(self, sourceImgNr, destImgNr):
        r"""linkImageVariableStack(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableStack(self, sourceImgNr, destImgNr)

    def linkImageVariableRadialDistortion(self, sourceImgNr, destImgNr):
        r"""linkImageVariableRadialDistortion(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableRadialDistortion(self, sourceImgNr, destImgNr)

    def linkImageVariableRadialDistortionRed(self, sourceImgNr, destImgNr):
        r"""linkImageVariableRadialDistortionRed(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableRadialDistortionRed(self, sourceImgNr, destImgNr)

    def linkImageVariableRadialDistortionBlue(self, sourceImgNr, destImgNr):
        r"""linkImageVariableRadialDistortionBlue(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableRadialDistortionBlue(self, sourceImgNr, destImgNr)

    def linkImageVariableRadialDistortionCenterShift(self, sourceImgNr, destImgNr):
        r"""linkImageVariableRadialDistortionCenterShift(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableRadialDistortionCenterShift(self, sourceImgNr, destImgNr)

    def linkImageVariableShear(self, sourceImgNr, destImgNr):
        r"""linkImageVariableShear(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableShear(self, sourceImgNr, destImgNr)

    def linkImageVariableCropMode(self, sourceImgNr, destImgNr):
        r"""linkImageVariableCropMode(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableCropMode(self, sourceImgNr, destImgNr)

    def linkImageVariableCropRect(self, sourceImgNr, destImgNr):
        r"""linkImageVariableCropRect(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableCropRect(self, sourceImgNr, destImgNr)

    def linkImageVariableAutoCenterCrop(self, sourceImgNr, destImgNr):
        r"""linkImageVariableAutoCenterCrop(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableAutoCenterCrop(self, sourceImgNr, destImgNr)

    def linkImageVariableVigCorrMode(self, sourceImgNr, destImgNr):
        r"""linkImageVariableVigCorrMode(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableVigCorrMode(self, sourceImgNr, destImgNr)

    def linkImageVariableFlatfieldFilename(self, sourceImgNr, destImgNr):
        r"""linkImageVariableFlatfieldFilename(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableFlatfieldFilename(self, sourceImgNr, destImgNr)

    def linkImageVariableRadialVigCorrCoeff(self, sourceImgNr, destImgNr):
        r"""linkImageVariableRadialVigCorrCoeff(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableRadialVigCorrCoeff(self, sourceImgNr, destImgNr)

    def linkImageVariableRadialVigCorrCenterShift(self, sourceImgNr, destImgNr):
        r"""linkImageVariableRadialVigCorrCenterShift(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableRadialVigCorrCenterShift(self, sourceImgNr, destImgNr)

    def linkImageVariableExifModel(self, sourceImgNr, destImgNr):
        r"""linkImageVariableExifModel(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableExifModel(self, sourceImgNr, destImgNr)

    def linkImageVariableExifMake(self, sourceImgNr, destImgNr):
        r"""linkImageVariableExifMake(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableExifMake(self, sourceImgNr, destImgNr)

    def linkImageVariableExifLens(self, sourceImgNr, destImgNr):
        r"""linkImageVariableExifLens(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableExifLens(self, sourceImgNr, destImgNr)

    def linkImageVariableExifFocalLength(self, sourceImgNr, destImgNr):
        r"""linkImageVariableExifFocalLength(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableExifFocalLength(self, sourceImgNr, destImgNr)

    def linkImageVariableExifOrientation(self, sourceImgNr, destImgNr):
        r"""linkImageVariableExifOrientation(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableExifOrientation(self, sourceImgNr, destImgNr)

    def linkImageVariableExifAperture(self, sourceImgNr, destImgNr):
        r"""linkImageVariableExifAperture(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableExifAperture(self, sourceImgNr, destImgNr)

    def linkImageVariableExifISO(self, sourceImgNr, destImgNr):
        r"""linkImageVariableExifISO(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableExifISO(self, sourceImgNr, destImgNr)

    def linkImageVariableExifDistance(self, sourceImgNr, destImgNr):
        r"""linkImageVariableExifDistance(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableExifDistance(self, sourceImgNr, destImgNr)

    def linkImageVariableExifFocalLength35(self, sourceImgNr, destImgNr):
        r"""linkImageVariableExifFocalLength35(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableExifFocalLength35(self, sourceImgNr, destImgNr)

    def linkImageVariableExifCropFactor(self, sourceImgNr, destImgNr):
        r"""linkImageVariableExifCropFactor(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableExifCropFactor(self, sourceImgNr, destImgNr)

    def linkImageVariableExifExposureTime(self, sourceImgNr, destImgNr):
        r"""linkImageVariableExifExposureTime(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableExifExposureTime(self, sourceImgNr, destImgNr)

    def linkImageVariableExifDate(self, sourceImgNr, destImgNr):
        r"""linkImageVariableExifDate(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableExifDate(self, sourceImgNr, destImgNr)

    def linkImageVariableExifExposureMode(self, sourceImgNr, destImgNr):
        r"""linkImageVariableExifExposureMode(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableExifExposureMode(self, sourceImgNr, destImgNr)

    def linkImageVariableExifRedBalance(self, sourceImgNr, destImgNr):
        r"""linkImageVariableExifRedBalance(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableExifRedBalance(self, sourceImgNr, destImgNr)

    def linkImageVariableExifBlueBalance(self, sourceImgNr, destImgNr):
        r"""linkImageVariableExifBlueBalance(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableExifBlueBalance(self, sourceImgNr, destImgNr)

    def linkImageVariableFileMetadata(self, sourceImgNr, destImgNr):
        r"""linkImageVariableFileMetadata(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableFileMetadata(self, sourceImgNr, destImgNr)

    def linkImageVariableMasks(self, sourceImgNr, destImgNr):
        r"""linkImageVariableMasks(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableMasks(self, sourceImgNr, destImgNr)

    def linkImageVariableActiveMasks(self, sourceImgNr, destImgNr):
        r"""linkImageVariableActiveMasks(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableActiveMasks(self, sourceImgNr, destImgNr)

    def linkImageVariableActive(self, sourceImgNr, destImgNr):
        r"""linkImageVariableActive(Panorama self, unsigned int sourceImgNr, unsigned int destImgNr)"""
        return _hsi.Panorama_linkImageVariableActive(self, sourceImgNr, destImgNr)

    def unlinkImageVariableFilename(self, imgNr):
        r"""unlinkImageVariableFilename(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableFilename(self, imgNr)

    def unlinkImageVariableSize(self, imgNr):
        r"""unlinkImageVariableSize(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableSize(self, imgNr)

    def unlinkImageVariableProjection(self, imgNr):
        r"""unlinkImageVariableProjection(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableProjection(self, imgNr)

    def unlinkImageVariableHFOV(self, imgNr):
        r"""unlinkImageVariableHFOV(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableHFOV(self, imgNr)

    def unlinkImageVariableCropFactor(self, imgNr):
        r"""unlinkImageVariableCropFactor(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableCropFactor(self, imgNr)

    def unlinkImageVariableResponseType(self, imgNr):
        r"""unlinkImageVariableResponseType(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableResponseType(self, imgNr)

    def unlinkImageVariableEMoRParams(self, imgNr):
        r"""unlinkImageVariableEMoRParams(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableEMoRParams(self, imgNr)

    def unlinkImageVariableExposureValue(self, imgNr):
        r"""unlinkImageVariableExposureValue(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableExposureValue(self, imgNr)

    def unlinkImageVariableGamma(self, imgNr):
        r"""unlinkImageVariableGamma(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableGamma(self, imgNr)

    def unlinkImageVariableWhiteBalanceRed(self, imgNr):
        r"""unlinkImageVariableWhiteBalanceRed(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableWhiteBalanceRed(self, imgNr)

    def unlinkImageVariableWhiteBalanceBlue(self, imgNr):
        r"""unlinkImageVariableWhiteBalanceBlue(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableWhiteBalanceBlue(self, imgNr)

    def unlinkImageVariableRoll(self, imgNr):
        r"""unlinkImageVariableRoll(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableRoll(self, imgNr)

    def unlinkImageVariablePitch(self, imgNr):
        r"""unlinkImageVariablePitch(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariablePitch(self, imgNr)

    def unlinkImageVariableYaw(self, imgNr):
        r"""unlinkImageVariableYaw(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableYaw(self, imgNr)

    def unlinkImageVariableX(self, imgNr):
        r"""unlinkImageVariableX(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableX(self, imgNr)

    def unlinkImageVariableY(self, imgNr):
        r"""unlinkImageVariableY(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableY(self, imgNr)

    def unlinkImageVariableZ(self, imgNr):
        r"""unlinkImageVariableZ(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableZ(self, imgNr)

    def unlinkImageVariableTranslationPlaneYaw(self, imgNr):
        r"""unlinkImageVariableTranslationPlaneYaw(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableTranslationPlaneYaw(self, imgNr)

    def unlinkImageVariableTranslationPlanePitch(self, imgNr):
        r"""unlinkImageVariableTranslationPlanePitch(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableTranslationPlanePitch(self, imgNr)

    def unlinkImageVariableStack(self, imgNr):
        r"""unlinkImageVariableStack(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableStack(self, imgNr)

    def unlinkImageVariableRadialDistortion(self, imgNr):
        r"""unlinkImageVariableRadialDistortion(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableRadialDistortion(self, imgNr)

    def unlinkImageVariableRadialDistortionRed(self, imgNr):
        r"""unlinkImageVariableRadialDistortionRed(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableRadialDistortionRed(self, imgNr)

    def unlinkImageVariableRadialDistortionBlue(self, imgNr):
        r"""unlinkImageVariableRadialDistortionBlue(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableRadialDistortionBlue(self, imgNr)

    def unlinkImageVariableRadialDistortionCenterShift(self, imgNr):
        r"""unlinkImageVariableRadialDistortionCenterShift(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableRadialDistortionCenterShift(self, imgNr)

    def unlinkImageVariableShear(self, imgNr):
        r"""unlinkImageVariableShear(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableShear(self, imgNr)

    def unlinkImageVariableCropMode(self, imgNr):
        r"""unlinkImageVariableCropMode(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableCropMode(self, imgNr)

    def unlinkImageVariableCropRect(self, imgNr):
        r"""unlinkImageVariableCropRect(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableCropRect(self, imgNr)

    def unlinkImageVariableAutoCenterCrop(self, imgNr):
        r"""unlinkImageVariableAutoCenterCrop(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableAutoCenterCrop(self, imgNr)

    def unlinkImageVariableVigCorrMode(self, imgNr):
        r"""unlinkImageVariableVigCorrMode(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableVigCorrMode(self, imgNr)

    def unlinkImageVariableFlatfieldFilename(self, imgNr):
        r"""unlinkImageVariableFlatfieldFilename(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableFlatfieldFilename(self, imgNr)

    def unlinkImageVariableRadialVigCorrCoeff(self, imgNr):
        r"""unlinkImageVariableRadialVigCorrCoeff(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableRadialVigCorrCoeff(self, imgNr)

    def unlinkImageVariableRadialVigCorrCenterShift(self, imgNr):
        r"""unlinkImageVariableRadialVigCorrCenterShift(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableRadialVigCorrCenterShift(self, imgNr)

    def unlinkImageVariableExifModel(self, imgNr):
        r"""unlinkImageVariableExifModel(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableExifModel(self, imgNr)

    def unlinkImageVariableExifMake(self, imgNr):
        r"""unlinkImageVariableExifMake(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableExifMake(self, imgNr)

    def unlinkImageVariableExifLens(self, imgNr):
        r"""unlinkImageVariableExifLens(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableExifLens(self, imgNr)

    def unlinkImageVariableExifFocalLength(self, imgNr):
        r"""unlinkImageVariableExifFocalLength(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableExifFocalLength(self, imgNr)

    def unlinkImageVariableExifOrientation(self, imgNr):
        r"""unlinkImageVariableExifOrientation(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableExifOrientation(self, imgNr)

    def unlinkImageVariableExifAperture(self, imgNr):
        r"""unlinkImageVariableExifAperture(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableExifAperture(self, imgNr)

    def unlinkImageVariableExifISO(self, imgNr):
        r"""unlinkImageVariableExifISO(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableExifISO(self, imgNr)

    def unlinkImageVariableExifDistance(self, imgNr):
        r"""unlinkImageVariableExifDistance(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableExifDistance(self, imgNr)

    def unlinkImageVariableExifFocalLength35(self, imgNr):
        r"""unlinkImageVariableExifFocalLength35(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableExifFocalLength35(self, imgNr)

    def unlinkImageVariableExifCropFactor(self, imgNr):
        r"""unlinkImageVariableExifCropFactor(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableExifCropFactor(self, imgNr)

    def unlinkImageVariableExifExposureTime(self, imgNr):
        r"""unlinkImageVariableExifExposureTime(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableExifExposureTime(self, imgNr)

    def unlinkImageVariableExifDate(self, imgNr):
        r"""unlinkImageVariableExifDate(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableExifDate(self, imgNr)

    def unlinkImageVariableExifExposureMode(self, imgNr):
        r"""unlinkImageVariableExifExposureMode(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableExifExposureMode(self, imgNr)

    def unlinkImageVariableExifRedBalance(self, imgNr):
        r"""unlinkImageVariableExifRedBalance(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableExifRedBalance(self, imgNr)

    def unlinkImageVariableExifBlueBalance(self, imgNr):
        r"""unlinkImageVariableExifBlueBalance(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableExifBlueBalance(self, imgNr)

    def unlinkImageVariableFileMetadata(self, imgNr):
        r"""unlinkImageVariableFileMetadata(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableFileMetadata(self, imgNr)

    def unlinkImageVariableMasks(self, imgNr):
        r"""unlinkImageVariableMasks(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableMasks(self, imgNr)

    def unlinkImageVariableActiveMasks(self, imgNr):
        r"""unlinkImageVariableActiveMasks(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableActiveMasks(self, imgNr)

    def unlinkImageVariableActive(self, imgNr):
        r"""unlinkImageVariableActive(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_unlinkImageVariableActive(self, imgNr)

    def updateWhiteBalance(self, redFactor, blueFactor):
        r"""updateWhiteBalance(Panorama self, double redFactor, double blueFactor)"""
        return _hsi.Panorama_updateWhiteBalance(self, redFactor, blueFactor)

    def getMaxExposureDifference(self):
        r"""getMaxExposureDifference(Panorama self) -> double const"""
        return _hsi.Panorama_getMaxExposureDifference(self)

    def hasPossibleStacks(self):
        r"""hasPossibleStacks(Panorama self) -> bool const"""
        return _hsi.Panorama_hasPossibleStacks(self)

    def linkPossibleStacks(self, linkPosition):
        r"""linkPossibleStacks(Panorama self, bool linkPosition)"""
        return _hsi.Panorama_linkPossibleStacks(self, linkPosition)

    def getOptimizeVector(self):
        r"""getOptimizeVector(Panorama self) -> OptimizeVector"""
        return _hsi.Panorama_getOptimizeVector(self)

    def setOptimizeVector(self, optvec):
        r"""setOptimizeVector(Panorama self, OptimizeVector optvec)"""
        return _hsi.Panorama_setOptimizeVector(self, optvec)

    def getOptimizerSwitch(self):
        r"""getOptimizerSwitch(Panorama self) -> int const"""
        return _hsi.Panorama_getOptimizerSwitch(self)

    def setOptimizerSwitch(self, newSwitch):
        r"""setOptimizerSwitch(Panorama self, int const newSwitch)"""
        return _hsi.Panorama_setOptimizerSwitch(self, newSwitch)

    def getPhotometricOptimizerSwitch(self):
        r"""getPhotometricOptimizerSwitch(Panorama self) -> int const"""
        return _hsi.Panorama_getPhotometricOptimizerSwitch(self)

    def setPhotometricOptimizerSwitch(self, newSwitch):
        r"""setPhotometricOptimizerSwitch(Panorama self, int const newSwitch)"""
        return _hsi.Panorama_setPhotometricOptimizerSwitch(self, newSwitch)

    def getOptions(self):
        r"""getOptions(Panorama self) -> PanoramaOptions"""
        return _hsi.Panorama_getOptions(self)

    def setOptions(self, opt):
        r"""setOptions(Panorama self, PanoramaOptions opt)"""
        return _hsi.Panorama_setOptions(self, opt)

    def parseOptimizerScript(self, i, imgs, imgVars, ctrlPoints):
        r"""parseOptimizerScript(Panorama self, istream i, UIntSet imgs, HuginBase::VariableMapVector & imgVars, HuginBase::CPVector & ctrlPoints)"""
        return _hsi.Panorama_parseOptimizerScript(self, i, imgs, imgVars, ctrlPoints)

    def printPanoramaScript(self, *args):
        r"""printPanoramaScript(Panorama self, ostream o, OptimizeVector optvars, PanoramaOptions options, UIntSet imgs, bool forPTOptimizer, std::string const & stripPrefix="")"""
        return _hsi.Panorama_printPanoramaScript(self, *args)

    def printStitcherScript(self, o, target, imgs):
        r"""printStitcherScript(Panorama self, ostream o, PanoramaOptions target, UIntSet imgs)"""
        return _hsi.Panorama_printStitcherScript(self, o, target, imgs)

    def addObserver(self, o):
        r"""addObserver(Panorama self, PanoramaObserver o)"""
        return _hsi.Panorama_addObserver(self, o)

    def removeObserver(self, observer):
        r"""removeObserver(Panorama self, PanoramaObserver observer) -> bool"""
        return _hsi.Panorama_removeObserver(self, observer)

    def clearObservers(self):
        r"""clearObservers(Panorama self)"""
        return _hsi.Panorama_clearObservers(self)

    def hasPendingChanges(self):
        r"""hasPendingChanges(Panorama self) -> bool const"""
        return _hsi.Panorama_hasPendingChanges(self)

    def changeFinished(self, *args):
        r"""
        changeFinished(Panorama self, bool keepDirty)
        changeFinished(Panorama self)
        """
        return _hsi.Panorama_changeFinished(self, *args)

    def imageChanged(self, imgNr):
        r"""imageChanged(Panorama self, unsigned int imgNr)"""
        return _hsi.Panorama_imageChanged(self, imgNr)

    def updateMasksForImage(self, imgNr, newMasks):
        r"""updateMasksForImage(Panorama self, unsigned int imgNr, HuginBase::MaskPolygonVector newMasks)"""
        return _hsi.Panorama_updateMasksForImage(self, imgNr, newMasks)

    def updateMasks(self, convertPosMaskToNeg=False):
        r"""updateMasks(Panorama self, bool convertPosMaskToNeg=False)"""
        return _hsi.Panorama_updateMasks(self, convertPosMaskToNeg)

    def transferMask(self, mask, imgNr, targetImgs):
        r"""transferMask(Panorama self, MaskPolygon mask, unsigned int imgNr, UIntSet targetImgs)"""
        return _hsi.Panorama_transferMask(self, mask, imgNr, targetImgs)

    def updateOptimizeVector(self):
        r"""updateOptimizeVector(Panorama self)"""
        return _hsi.Panorama_updateOptimizeVector(self)

    def getRefImages(self):
        r"""getRefImages(Panorama self) -> std::set< size_t,std::less< size_t >,std::allocator< size_t > >"""
        return _hsi.Panorama_getRefImages(self)

    def checkRefOptStatus(self, linkRefImgsYaw, linkRefImgsPitch, linkRefImgsRoll):
        r"""checkRefOptStatus(Panorama self, bool & linkRefImgsYaw, bool & linkRefImgsPitch, bool & linkRefImgsRoll)"""
        return _hsi.Panorama_checkRefOptStatus(self, linkRefImgsYaw, linkRefImgsPitch, linkRefImgsRoll)

    def getNewMemento(self):
        r"""getNewMemento(Panorama self) -> PanoramaDataMemento"""
        return _hsi.Panorama_getNewMemento(self)

    def setMementoToCopyOf(self, memento):
        r"""setMementoToCopyOf(Panorama self, PanoramaDataMemento memento) -> bool"""
        return _hsi.Panorama_setMementoToCopyOf(self, memento)

    def getMemento(self):
        r"""getMemento(Panorama self) -> PanoramaMemento"""
        return _hsi.Panorama_getMemento(self)

    def setMemento(self, memento):
        r"""setMemento(Panorama self, PanoramaMemento memento)"""
        return _hsi.Panorama_setMemento(self, memento)

    def needsOptimization(self):
        r"""needsOptimization(Panorama self) -> bool"""
        return _hsi.Panorama_needsOptimization(self)

    def markAsOptimized(self, optimized=True):
        r"""markAsOptimized(Panorama self, bool optimized=True)"""
        return _hsi.Panorama_markAsOptimized(self, optimized)

    def readData(self, *args):
        r"""readData(Panorama self, istream dataInput, std::string documentType="") -> AppBase::DocumentData::ReadWriteError"""
        return _hsi.Panorama_readData(self, *args)

    def writeData(self, *args):
        r"""writeData(Panorama self, ostream dataOutput, std::string documentType="") -> AppBase::DocumentData::ReadWriteError"""
        return _hsi.Panorama_writeData(self, *args)

    def isDirty(self):
        r"""isDirty(Panorama self) -> bool"""
        return _hsi.Panorama_isDirty(self)

    def clearDirty(self):
        r"""clearDirty(Panorama self)"""
        return _hsi.Panorama_clearDirty(self)

    def setFilePrefix(self, prefix):
        r"""setFilePrefix(Panorama self, std::string prefix)"""
        return _hsi.Panorama_setFilePrefix(self, prefix)

    def reset(self):
        r"""reset(Panorama self)"""
        return _hsi.Panorama_reset(self)

# Register Panorama in _hsi:
_hsi.Panorama_swigregister(Panorama)

class Transform(object):
    r"""Proxy of C++ HuginBase::PTools::Transform class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(Transform self) -> Transform"""
        _hsi.Transform_swiginit(self, _hsi.new_Transform())
    __swig_destroy__ = _hsi.delete_Transform

    def createTransform(self, *args):
        r"""
        createTransform(Transform self, vigra::Diff2D const & srcSize, HuginBase::VariableMap srcVars, HuginBase::Lens::LensProjectionFormat srcProj, vigra::Diff2D const & destSize, HuginBase::PanoramaOptions::ProjectionFormat destProj, DoubleVector destProjParam, double destHFOV, vigra::Diff2D const & origSrcSize)
        createTransform(Transform self, PanoramaData pano, unsigned int imgNr, PanoramaOptions dest, vigra::Diff2D srcSize=vigra::Diff2D(0,0))
        createTransform(Transform self, SrcPanoImage src, PanoramaOptions dest)
        """
        return _hsi.Transform_createTransform(self, *args)

    def createInvTransform(self, *args):
        r"""
        createInvTransform(Transform self, vigra::Diff2D const & srcSize, HuginBase::VariableMap srcVars, HuginBase::Lens::LensProjectionFormat srcProj, vigra::Diff2D const & destSize, HuginBase::PanoramaOptions::ProjectionFormat destProj, DoubleVector destProjParam, double destHFOV, vigra::Diff2D const & origSrcSize)
        createInvTransform(Transform self, PanoramaData pano, unsigned int imgNr, PanoramaOptions dest, vigra::Diff2D srcSize=vigra::Diff2D(0,0))
        createInvTransform(Transform self, SrcPanoImage src, PanoramaOptions dest)
        """
        return _hsi.Transform_createInvTransform(self, *args)

    def transform(self, *args):
        r"""
        transform(Transform self, double & x_dest, double & y_dest, double x_src, double y_src) -> bool
        transform(Transform self, FDiff2D dest, FDiff2D src) -> bool
        """
        return _hsi.Transform_transform(self, *args)

    def transformImgCoordPartial(self, x_dest, y_dest, x_src, y_src):
        r"""transformImgCoordPartial(Transform self, double & x_dest, double & y_dest, double x_src, double y_src) -> bool"""
        return _hsi.Transform_transformImgCoordPartial(self, x_dest, y_dest, x_src, y_src)

    def transformImgCoord(self, *args):
        r"""
        transformImgCoord(Transform self, double & x_dest, double & y_dest, double x_src, double y_src) -> bool
        transformImgCoord(Transform self, FDiff2D dest, FDiff2D src) -> bool
        """
        return _hsi.Transform_transformImgCoord(self, *args)

    def emitGLSL(self, oss):
        r"""emitGLSL(Transform self, std::ostringstream & oss) -> bool"""
        return _hsi.Transform_emitGLSL(self, oss)

# Register Transform in _hsi:
_hsi.Transform_swigregister(Transform)


def setDestImage(image, size, imageData, format, projParams, destHFOV):
    r"""setDestImage(Image & image, vigra::Diff2D size, unsigned char * imageData, HuginBase::PanoramaOptions::ProjectionFormat const & format, DoubleVector projParams, double destHFOV)"""
    return _hsi.setDestImage(image, size, imageData, format, projParams, destHFOV)

def setFullImage(image, size, imageData, vars, format, correctDistortions):
    r"""setFullImage(Image & image, vigra::Diff2D size, unsigned char * imageData, HuginBase::VariableMap const & vars, HuginBase::Lens::LensProjectionFormat const format, bool correctDistortions)"""
    return _hsi.setFullImage(image, size, imageData, vars, format, correctDistortions)

def freeImage(img):
    r"""freeImage(Image & img)"""
    return _hsi.freeImage(img)

def GetAlignInfoVariables(gl):
    r"""GetAlignInfoVariables(AlignInfo const & gl) -> HuginBase::VariableMapVector"""
    return _hsi.GetAlignInfoVariables(gl)

def GetAlignInfoCtrlPoints(gl):
    r"""GetAlignInfoCtrlPoints(AlignInfo const & gl) -> HuginBase::CPVector"""
    return _hsi.GetAlignInfoCtrlPoints(gl)

def optimize(pano, script=None):
    r"""optimize(PanoramaData pano, char const * script=None) -> unsigned int"""
    return _hsi.optimize(pano, script)

def calcCtrlPointErrors(pano):
    r"""calcCtrlPointErrors(PanoramaData pano)"""
    return _hsi.calcCtrlPointErrors(pano)
class PanoramaAlgorithm(object):
    r"""Proxy of C++ HuginBase::PanoramaAlgorithm class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _hsi.delete_PanoramaAlgorithm

    def modifiesPanoramaData(self):
        r"""modifiesPanoramaData(PanoramaAlgorithm self) -> bool"""
        return _hsi.PanoramaAlgorithm_modifiesPanoramaData(self)

    def hasRunSuccessfully(self):
        r"""hasRunSuccessfully(PanoramaAlgorithm self) -> bool"""
        return _hsi.PanoramaAlgorithm_hasRunSuccessfully(self)

    def run(self):
        r"""run(PanoramaAlgorithm self)"""
        return _hsi.PanoramaAlgorithm_run(self)

    def runAlgorithm(self):
        r"""runAlgorithm(PanoramaAlgorithm self) -> bool"""
        return _hsi.PanoramaAlgorithm_runAlgorithm(self)

# Register PanoramaAlgorithm in _hsi:
_hsi.PanoramaAlgorithm_swigregister(PanoramaAlgorithm)

class TimeConsumingPanoramaAlgorithm(PanoramaAlgorithm):
    r"""Proxy of C++ HuginBase::TimeConsumingPanoramaAlgorithm class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _hsi.delete_TimeConsumingPanoramaAlgorithm

    def wasCancelled(self):
        r"""wasCancelled(TimeConsumingPanoramaAlgorithm self) -> bool"""
        return _hsi.TimeConsumingPanoramaAlgorithm_wasCancelled(self)

# Register TimeConsumingPanoramaAlgorithm in _hsi:
_hsi.TimeConsumingPanoramaAlgorithm_swigregister(TimeConsumingPanoramaAlgorithm)

class StitcherAlgorithm(TimeConsumingPanoramaAlgorithm):
    r"""Proxy of C++ HuginBase::StitcherAlgorithm class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _hsi.delete_StitcherAlgorithm

    def runAlgorithm(self):
        r"""runAlgorithm(StitcherAlgorithm self) -> bool"""
        return _hsi.StitcherAlgorithm_runAlgorithm(self)

    def modifiesPanoramaData(self):
        r"""modifiesPanoramaData(StitcherAlgorithm self) -> bool"""
        return _hsi.StitcherAlgorithm_modifiesPanoramaData(self)

# Register StitcherAlgorithm in _hsi:
_hsi.StitcherAlgorithm_swigregister(StitcherAlgorithm)

class ImageStitcherAlgorithm(StitcherAlgorithm):
    r"""Proxy of C++ HuginBase::ImageStitcherAlgorithm class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _hsi.delete_ImageStitcherAlgorithm

# Register ImageStitcherAlgorithm in _hsi:
_hsi.ImageStitcherAlgorithm_swigregister(ImageStitcherAlgorithm)

class FileOutputStitcherAlgorithm(StitcherAlgorithm):
    r"""Proxy of C++ HuginBase::FileOutputStitcherAlgorithm class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _hsi.delete_FileOutputStitcherAlgorithm

# Register FileOutputStitcherAlgorithm in _hsi:
_hsi.FileOutputStitcherAlgorithm_swigregister(FileOutputStitcherAlgorithm)

class CalculateCPStatistics(PanoramaAlgorithm):
    r"""Proxy of C++ HuginBase::CalculateCPStatistics class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _hsi.delete_CalculateCPStatistics

    def modifiesPanoramaData(self):
        r"""modifiesPanoramaData(CalculateCPStatistics self) -> bool"""
        return _hsi.CalculateCPStatistics_modifiesPanoramaData(self)

    def runAlgorithm(self):
        r"""runAlgorithm(CalculateCPStatistics self) -> bool"""
        return _hsi.CalculateCPStatistics_runAlgorithm(self)

    def getResultMin(self):
        r"""getResultMin(CalculateCPStatistics self) -> double"""
        return _hsi.CalculateCPStatistics_getResultMin(self)

    def getResultMax(self):
        r"""getResultMax(CalculateCPStatistics self) -> double"""
        return _hsi.CalculateCPStatistics_getResultMax(self)

    def getResultMean(self):
        r"""getResultMean(CalculateCPStatistics self) -> double"""
        return _hsi.CalculateCPStatistics_getResultMean(self)

    def getResultVariance(self):
        r"""getResultVariance(CalculateCPStatistics self) -> double"""
        return _hsi.CalculateCPStatistics_getResultVariance(self)

# Register CalculateCPStatistics in _hsi:
_hsi.CalculateCPStatistics_swigregister(CalculateCPStatistics)

class CalculateCPStatisticsError(CalculateCPStatistics):
    r"""Proxy of C++ HuginBase::CalculateCPStatisticsError class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(CalculateCPStatisticsError self, PanoramaData panorama, int const & imgNr=-1) -> CalculateCPStatisticsError
        __init__(CalculateCPStatisticsError self, PanoramaData panorama, bool const onlyActive, bool const ignoreLineCps=False) -> CalculateCPStatisticsError
        """
        _hsi.CalculateCPStatisticsError_swiginit(self, _hsi.new_CalculateCPStatisticsError(*args))
    __swig_destroy__ = _hsi.delete_CalculateCPStatisticsError

    @staticmethod
    def calcCtrlPntsErrorStats(pano, min, max, mean, var, imgNr=-1, onlyActive=False, ignoreLineCp=False):
        r"""calcCtrlPntsErrorStats(PanoramaData pano, double & min, double & max, double & mean, double & var, int const & imgNr=-1, bool const onlyActive=False, bool const ignoreLineCp=False)"""
        return _hsi.CalculateCPStatisticsError_calcCtrlPntsErrorStats(pano, min, max, mean, var, imgNr, onlyActive, ignoreLineCp)

    def runAlgorithm(self):
        r"""runAlgorithm(CalculateCPStatisticsError self) -> bool"""
        return _hsi.CalculateCPStatisticsError_runAlgorithm(self)

# Register CalculateCPStatisticsError in _hsi:
_hsi.CalculateCPStatisticsError_swigregister(CalculateCPStatisticsError)

def CalculateCPStatisticsError_calcCtrlPntsErrorStats(pano, min, max, mean, var, imgNr=-1, onlyActive=False, ignoreLineCp=False):
    r"""CalculateCPStatisticsError_calcCtrlPntsErrorStats(PanoramaData pano, double & min, double & max, double & mean, double & var, int const & imgNr=-1, bool const onlyActive=False, bool const ignoreLineCp=False)"""
    return _hsi.CalculateCPStatisticsError_calcCtrlPntsErrorStats(pano, min, max, mean, var, imgNr, onlyActive, ignoreLineCp)

class CalculateCPStatisticsRadial(CalculateCPStatistics):
    r"""Proxy of C++ HuginBase::CalculateCPStatisticsRadial class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, panorama, imgNr=-1):
        r"""__init__(CalculateCPStatisticsRadial self, PanoramaData panorama, int const & imgNr=-1) -> CalculateCPStatisticsRadial"""
        _hsi.CalculateCPStatisticsRadial_swiginit(self, _hsi.new_CalculateCPStatisticsRadial(panorama, imgNr))
    __swig_destroy__ = _hsi.delete_CalculateCPStatisticsRadial

    @staticmethod
    def calcCtrlPntsRadiStats(pano, min, max, mean, var, q10, q90, imgNr=-1):
        r"""calcCtrlPntsRadiStats(PanoramaData pano, double & min, double & max, double & mean, double & var, double & q10, double & q90, int const & imgNr=-1)"""
        return _hsi.CalculateCPStatisticsRadial_calcCtrlPntsRadiStats(pano, min, max, mean, var, q10, q90, imgNr)

    def getResultPercentile10(self):
        r"""getResultPercentile10(CalculateCPStatisticsRadial self) -> double"""
        return _hsi.CalculateCPStatisticsRadial_getResultPercentile10(self)

    def getResultPercentile90(self):
        r"""getResultPercentile90(CalculateCPStatisticsRadial self) -> double"""
        return _hsi.CalculateCPStatisticsRadial_getResultPercentile90(self)

    def runAlgorithm(self):
        r"""runAlgorithm(CalculateCPStatisticsRadial self) -> bool"""
        return _hsi.CalculateCPStatisticsRadial_runAlgorithm(self)

# Register CalculateCPStatisticsRadial in _hsi:
_hsi.CalculateCPStatisticsRadial_swigregister(CalculateCPStatisticsRadial)

def CalculateCPStatisticsRadial_calcCtrlPntsRadiStats(pano, min, max, mean, var, q10, q90, imgNr=-1):
    r"""CalculateCPStatisticsRadial_calcCtrlPntsRadiStats(PanoramaData pano, double & min, double & max, double & mean, double & var, double & q10, double & q90, int const & imgNr=-1)"""
    return _hsi.CalculateCPStatisticsRadial_calcCtrlPntsRadiStats(pano, min, max, mean, var, q10, q90, imgNr)

class CalculateMeanExposure(PanoramaAlgorithm):
    r"""Proxy of C++ HuginBase::CalculateMeanExposure class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, panorama):
        r"""__init__(CalculateMeanExposure self, PanoramaData panorama) -> CalculateMeanExposure"""
        _hsi.CalculateMeanExposure_swiginit(self, _hsi.new_CalculateMeanExposure(panorama))
    __swig_destroy__ = _hsi.delete_CalculateMeanExposure

    def modifiesPanoramaData(self):
        r"""modifiesPanoramaData(CalculateMeanExposure self) -> bool"""
        return _hsi.CalculateMeanExposure_modifiesPanoramaData(self)

    def runAlgorithm(self):
        r"""runAlgorithm(CalculateMeanExposure self) -> bool"""
        return _hsi.CalculateMeanExposure_runAlgorithm(self)

    @staticmethod
    def calcMeanExposure(pano):
        r"""calcMeanExposure(PanoramaData pano) -> double"""
        return _hsi.CalculateMeanExposure_calcMeanExposure(pano)

    def getResultExposure(self):
        r"""getResultExposure(CalculateMeanExposure self) -> double"""
        return _hsi.CalculateMeanExposure_getResultExposure(self)

# Register CalculateMeanExposure in _hsi:
_hsi.CalculateMeanExposure_swigregister(CalculateMeanExposure)

def CalculateMeanExposure_calcMeanExposure(pano):
    r"""CalculateMeanExposure_calcMeanExposure(PanoramaData pano) -> double"""
    return _hsi.CalculateMeanExposure_calcMeanExposure(pano)

class CalculateOptimalROI(TimeConsumingPanoramaAlgorithm):
    r"""Proxy of C++ HuginBase::CalculateOptimalROI class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(CalculateOptimalROI self, PanoramaData panorama, AppBase::ProgressDisplay * progress, bool intersect=False) -> CalculateOptimalROI
        __init__(CalculateOptimalROI self, PanoramaData panorama, AppBase::ProgressDisplay * progress, std::vector< HuginBase::UIntSet,std::allocator< HuginBase::UIntSet > > hdr_stacks) -> CalculateOptimalROI
        """
        _hsi.CalculateOptimalROI_swiginit(self, _hsi.new_CalculateOptimalROI(*args))
    __swig_destroy__ = _hsi.delete_CalculateOptimalROI

    def modifiesPanoramaData(self):
        r"""modifiesPanoramaData(CalculateOptimalROI self) -> bool"""
        return _hsi.CalculateOptimalROI_modifiesPanoramaData(self)

    def runAlgorithm(self):
        r"""runAlgorithm(CalculateOptimalROI self) -> bool"""
        return _hsi.CalculateOptimalROI_runAlgorithm(self)

    def getResultOptimalROI(self):
        r"""getResultOptimalROI(CalculateOptimalROI self) -> Rect2D"""
        return _hsi.CalculateOptimalROI_getResultOptimalROI(self)

    def setStacks(self, hdr_stacks):
        r"""setStacks(CalculateOptimalROI self, std::vector< HuginBase::UIntSet,std::allocator< HuginBase::UIntSet > > hdr_stacks)"""
        return _hsi.CalculateOptimalROI_setStacks(self, hdr_stacks)

# Register CalculateOptimalROI in _hsi:
_hsi.CalculateOptimalROI_swigregister(CalculateOptimalROI)

class CalculateOptimalScale(PanoramaAlgorithm):
    r"""Proxy of C++ HuginBase::CalculateOptimalScale class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, panorama):
        r"""__init__(CalculateOptimalScale self, PanoramaData panorama) -> CalculateOptimalScale"""
        _hsi.CalculateOptimalScale_swiginit(self, _hsi.new_CalculateOptimalScale(panorama))
    __swig_destroy__ = _hsi.delete_CalculateOptimalScale

    def modifiesPanoramaData(self):
        r"""modifiesPanoramaData(CalculateOptimalScale self) -> bool"""
        return _hsi.CalculateOptimalScale_modifiesPanoramaData(self)

    def runAlgorithm(self):
        r"""runAlgorithm(CalculateOptimalScale self) -> bool"""
        return _hsi.CalculateOptimalScale_runAlgorithm(self)

    @staticmethod
    def calcOptimalScale(panorama):
        r"""calcOptimalScale(PanoramaData panorama) -> double"""
        return _hsi.CalculateOptimalScale_calcOptimalScale(panorama)

    @staticmethod
    def calcOptimalPanoScale(src, dest):
        r"""calcOptimalPanoScale(SrcPanoImage src, PanoramaOptions dest) -> double"""
        return _hsi.CalculateOptimalScale_calcOptimalPanoScale(src, dest)

    def getResultOptimalScale(self):
        r"""getResultOptimalScale(CalculateOptimalScale self) -> double"""
        return _hsi.CalculateOptimalScale_getResultOptimalScale(self)

    def getResultOptimalWidth(self):
        r"""getResultOptimalWidth(CalculateOptimalScale self) -> unsigned int"""
        return _hsi.CalculateOptimalScale_getResultOptimalWidth(self)

# Register CalculateOptimalScale in _hsi:
_hsi.CalculateOptimalScale_swigregister(CalculateOptimalScale)

def CalculateOptimalScale_calcOptimalScale(panorama):
    r"""CalculateOptimalScale_calcOptimalScale(PanoramaData panorama) -> double"""
    return _hsi.CalculateOptimalScale_calcOptimalScale(panorama)

def CalculateOptimalScale_calcOptimalPanoScale(src, dest):
    r"""CalculateOptimalScale_calcOptimalPanoScale(SrcPanoImage src, PanoramaOptions dest) -> double"""
    return _hsi.CalculateOptimalScale_calcOptimalPanoScale(src, dest)

class SetWidthOptimal(CalculateOptimalScale):
    r"""Proxy of C++ HuginBase::SetWidthOptimal class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, panorama):
        r"""__init__(SetWidthOptimal self, PanoramaData panorama) -> SetWidthOptimal"""
        _hsi.SetWidthOptimal_swiginit(self, _hsi.new_SetWidthOptimal(panorama))
    __swig_destroy__ = _hsi.delete_SetWidthOptimal

    def modifiesPanoramaData(self):
        r"""modifiesPanoramaData(SetWidthOptimal self) -> bool"""
        return _hsi.SetWidthOptimal_modifiesPanoramaData(self)

    def runAlgorithm(self):
        r"""runAlgorithm(SetWidthOptimal self) -> bool"""
        return _hsi.SetWidthOptimal_runAlgorithm(self)

# Register SetWidthOptimal in _hsi:
_hsi.SetWidthOptimal_swigregister(SetWidthOptimal)

class CalculateImageOverlap(object):
    r"""Proxy of C++ HuginBase::CalculateImageOverlap class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, pano):
        r"""__init__(CalculateImageOverlap self, PanoramaData pano) -> CalculateImageOverlap"""
        _hsi.CalculateImageOverlap_swiginit(self, _hsi.new_CalculateImageOverlap(pano))
    __swig_destroy__ = _hsi.delete_CalculateImageOverlap

    def calculate(self, steps):
        r"""calculate(CalculateImageOverlap self, unsigned int steps)"""
        return _hsi.CalculateImageOverlap_calculate(self, steps)

    def getOverlap(self, i, j):
        r"""getOverlap(CalculateImageOverlap self, unsigned int i, unsigned int j) -> double"""
        return _hsi.CalculateImageOverlap_getOverlap(self, i, j)

    def limitToImages(self, img):
        r"""limitToImages(CalculateImageOverlap self, UIntSet img)"""
        return _hsi.CalculateImageOverlap_limitToImages(self, img)

    def getOverlapForImage(self, i):
        r"""getOverlapForImage(CalculateImageOverlap self, unsigned int i) -> UIntSet"""
        return _hsi.CalculateImageOverlap_getOverlapForImage(self, i)

    def getNrOfImages(self):
        r"""getNrOfImages(CalculateImageOverlap self) -> unsigned int"""
        return _hsi.CalculateImageOverlap_getNrOfImages(self)

# Register CalculateImageOverlap in _hsi:
_hsi.CalculateImageOverlap_swigregister(CalculateImageOverlap)

class RotatePanorama(PanoramaAlgorithm):
    r"""Proxy of C++ HuginBase::RotatePanorama class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(RotatePanorama self, PanoramaData panorama, Matrix3 const & transformMat) -> RotatePanorama
        __init__(RotatePanorama self, PanoramaData panorama, double yaw, double pitch, double roll) -> RotatePanorama
        """
        _hsi.RotatePanorama_swiginit(self, _hsi.new_RotatePanorama(*args))
    __swig_destroy__ = _hsi.delete_RotatePanorama

    @staticmethod
    def rotatePano(panorama, transformMat):
        r"""rotatePano(PanoramaData panorama, Matrix3 const & transformMat)"""
        return _hsi.RotatePanorama_rotatePano(panorama, transformMat)

    def modifiesPanoramaData(self):
        r"""modifiesPanoramaData(RotatePanorama self) -> bool"""
        return _hsi.RotatePanorama_modifiesPanoramaData(self)

    def runAlgorithm(self):
        r"""runAlgorithm(RotatePanorama self) -> bool"""
        return _hsi.RotatePanorama_runAlgorithm(self)

# Register RotatePanorama in _hsi:
_hsi.RotatePanorama_swigregister(RotatePanorama)

def RotatePanorama_rotatePano(panorama, transformMat):
    r"""RotatePanorama_rotatePano(PanoramaData panorama, Matrix3 const & transformMat)"""
    return _hsi.RotatePanorama_rotatePano(panorama, transformMat)


def getHDRStacks(pano, allImgs, opts):
    r"""getHDRStacks(PanoramaData pano, UIntSet allImgs, PanoramaOptions opts) -> HuginBase::UIntSetVector"""
    return _hsi.getHDRStacks(pano, allImgs, opts)

def getExposureLayers(*args):
    r"""
    getExposureLayers(PanoramaData pano, UIntSet allImgs, PanoramaOptions opts) -> HuginBase::UIntSetVector
    getExposureLayers(PanoramaData pano, UIntSet allImgs, double const maxEVDiff) -> HuginBase::UIntSetVector
    """
    return _hsi.getExposureLayers(*args)

def getImagesinROI(*args):
    r"""
    getImagesinROI(PanoramaData pano, UIntSet activeImages) -> UIntSet
    getImagesinROI(PanoramaData pano, UIntSet activeImages, Rect2D panoROI) -> UIntSet
    """
    return _hsi.getImagesinROI(*args)

def getSortedStacks(pano):
    r"""getSortedStacks(Panorama pano) -> std::vector< HuginBase::UIntVector,std::allocator< HuginBase::UIntVector > >"""
    return _hsi.getSortedStacks(pano)

def getEstimatedBlendingOrder(pano, images, referenceImage):
    r"""getEstimatedBlendingOrder(PanoramaData pano, UIntSet images, unsigned int const referenceImage) -> UIntVector"""
    return _hsi.getEstimatedBlendingOrder(pano, images, referenceImage)
class StraightenPanorama(RotatePanorama):
    r"""Proxy of C++ HuginBase::StraightenPanorama class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, panorama):
        r"""__init__(StraightenPanorama self, PanoramaData panorama) -> StraightenPanorama"""
        _hsi.StraightenPanorama_swiginit(self, _hsi.new_StraightenPanorama(panorama))
    __swig_destroy__ = _hsi.delete_StraightenPanorama

    @staticmethod
    def calcStraighteningRotation(panorama):
        r"""calcStraighteningRotation(PanoramaData panorama) -> Matrix3"""
        return _hsi.StraightenPanorama_calcStraighteningRotation(panorama)

    def runAlgorithm(self):
        r"""runAlgorithm(StraightenPanorama self) -> bool"""
        return _hsi.StraightenPanorama_runAlgorithm(self)

# Register StraightenPanorama in _hsi:
_hsi.StraightenPanorama_swigregister(StraightenPanorama)

def StraightenPanorama_calcStraighteningRotation(panorama):
    r"""StraightenPanorama_calcStraighteningRotation(PanoramaData panorama) -> Matrix3"""
    return _hsi.StraightenPanorama_calcStraighteningRotation(panorama)

class TranslatePanorama(PanoramaAlgorithm):
    r"""Proxy of C++ HuginBase::TranslatePanorama class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, panorama, x=0, y=0, z=0):
        r"""__init__(TranslatePanorama self, PanoramaData panorama, double const x=0, double const y=0, double const z=0) -> TranslatePanorama"""
        _hsi.TranslatePanorama_swiginit(self, _hsi.new_TranslatePanorama(panorama, x, y, z))
    __swig_destroy__ = _hsi.delete_TranslatePanorama

    @staticmethod
    def translatePano(panorama, x, y, z):
        r"""translatePano(PanoramaData panorama, double const x, double const y, double const z)"""
        return _hsi.TranslatePanorama_translatePano(panorama, x, y, z)

    def modifiesPanoramaData(self):
        r"""modifiesPanoramaData(TranslatePanorama self) -> bool"""
        return _hsi.TranslatePanorama_modifiesPanoramaData(self)

    def runAlgorithm(self):
        r"""runAlgorithm(TranslatePanorama self) -> bool"""
        return _hsi.TranslatePanorama_runAlgorithm(self)

# Register TranslatePanorama in _hsi:
_hsi.TranslatePanorama_swigregister(TranslatePanorama)

def TranslatePanorama_translatePano(panorama, x, y, z):
    r"""TranslatePanorama_translatePano(PanoramaData panorama, double const x, double const y, double const z)"""
    return _hsi.TranslatePanorama_translatePano(panorama, x, y, z)


def getCPoutsideLimit_pair(pano, progress, n=2.0):
    r"""getCPoutsideLimit_pair(Panorama pano, AppBase::ProgressDisplay & progress, double n=2.0) -> UIntSet"""
    return _hsi.getCPoutsideLimit_pair(pano, progress, n)

def getCPoutsideLimit(pano, n=2.0, skipOptimisation=False, includeLineCp=False):
    r"""getCPoutsideLimit(Panorama pano, double n=2.0, bool skipOptimisation=False, bool includeLineCp=False) -> UIntSet"""
    return _hsi.getCPoutsideLimit(pano, n, skipOptimisation, includeLineCp)

def getCPinMasks(pano):
    r"""getCPinMasks(Panorama pano) -> UIntSet"""
    return _hsi.getCPinMasks(pano)
class CalculateFOV(PanoramaAlgorithm):
    r"""Proxy of C++ HuginBase::CalculateFOV class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, panorama):
        r"""__init__(CalculateFOV self, PanoramaData panorama) -> CalculateFOV"""
        _hsi.CalculateFOV_swiginit(self, _hsi.new_CalculateFOV(panorama))
    __swig_destroy__ = _hsi.delete_CalculateFOV

    def modifiesPanoramaData(self):
        r"""modifiesPanoramaData(CalculateFOV self) -> bool"""
        return _hsi.CalculateFOV_modifiesPanoramaData(self)

    def runAlgorithm(self):
        r"""runAlgorithm(CalculateFOV self) -> bool"""
        return _hsi.CalculateFOV_runAlgorithm(self)

    @staticmethod
    def calcFOV(panorama):
        r"""calcFOV(PanoramaData panorama) -> FDiff2D"""
        return _hsi.CalculateFOV_calcFOV(panorama)

    def getResultHorizontalFOV(self):
        r"""getResultHorizontalFOV(CalculateFOV self) -> double"""
        return _hsi.CalculateFOV_getResultHorizontalFOV(self)

    def getResultVerticalFOV(self):
        r"""getResultVerticalFOV(CalculateFOV self) -> double"""
        return _hsi.CalculateFOV_getResultVerticalFOV(self)

    def getResultFOV(self):
        r"""getResultFOV(CalculateFOV self) -> FDiff2D"""
        return _hsi.CalculateFOV_getResultFOV(self)

# Register CalculateFOV in _hsi:
_hsi.CalculateFOV_swigregister(CalculateFOV)

def CalculateFOV_calcFOV(panorama):
    r"""CalculateFOV_calcFOV(PanoramaData panorama) -> FDiff2D"""
    return _hsi.CalculateFOV_calcFOV(panorama)

class CenterHorizontally(PanoramaAlgorithm):
    r"""Proxy of C++ HuginBase::CenterHorizontally class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, panorama):
        r"""__init__(CenterHorizontally self, PanoramaData panorama) -> CenterHorizontally"""
        _hsi.CenterHorizontally_swiginit(self, _hsi.new_CenterHorizontally(panorama))
    __swig_destroy__ = _hsi.delete_CenterHorizontally

    def modifiesPanoramaData(self):
        r"""modifiesPanoramaData(CenterHorizontally self) -> bool"""
        return _hsi.CenterHorizontally_modifiesPanoramaData(self)

    def runAlgorithm(self):
        r"""runAlgorithm(CenterHorizontally self) -> bool"""
        return _hsi.CenterHorizontally_runAlgorithm(self)

    @staticmethod
    def centerHorizontically(panorama):
        r"""centerHorizontically(PanoramaData panorama)"""
        return _hsi.CenterHorizontally_centerHorizontically(panorama)

# Register CenterHorizontally in _hsi:
_hsi.CenterHorizontally_swigregister(CenterHorizontally)

def CenterHorizontally_centerHorizontically(panorama):
    r"""CenterHorizontally_centerHorizontically(PanoramaData panorama)"""
    return _hsi.CenterHorizontally_centerHorizontically(panorama)


def estimateOutputROI(pano, opts, i):
    r"""estimateOutputROI(PanoramaData pano, PanoramaOptions opts, unsigned int i) -> Rect2D"""
    return _hsi.estimateOutputROI(pano, opts, i)
class ComputeImageROI(PanoramaAlgorithm):
    r"""Proxy of C++ HuginBase::ComputeImageROI class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, panorama, images):
        r"""__init__(ComputeImageROI self, PanoramaData panorama, UIntSet images) -> ComputeImageROI"""
        _hsi.ComputeImageROI_swiginit(self, _hsi.new_ComputeImageROI(panorama, images))
    __swig_destroy__ = _hsi.delete_ComputeImageROI

    def modifiesPanoramaData(self):
        r"""modifiesPanoramaData(ComputeImageROI self) -> bool"""
        return _hsi.ComputeImageROI_modifiesPanoramaData(self)

    def runAlgorithm(self):
        r"""runAlgorithm(ComputeImageROI self) -> bool"""
        return _hsi.ComputeImageROI_runAlgorithm(self)

    def getROIS(self):
        r"""getROIS(ComputeImageROI self) -> std::vector< vigra::Rect2D,std::allocator< vigra::Rect2D > >"""
        return _hsi.ComputeImageROI_getROIS(self)

    @staticmethod
    def computeROIS(panorama, opts, images):
        r"""computeROIS(PanoramaData panorama, PanoramaOptions opts, UIntSet images) -> std::vector< vigra::Rect2D,std::allocator< vigra::Rect2D > >"""
        return _hsi.ComputeImageROI_computeROIS(panorama, opts, images)

# Register ComputeImageROI in _hsi:
_hsi.ComputeImageROI_swigregister(ComputeImageROI)

def ComputeImageROI_computeROIS(panorama, opts, images):
    r"""ComputeImageROI_computeROIS(PanoramaData panorama, PanoramaOptions opts, UIntSet images) -> std::vector< vigra::Rect2D,std::allocator< vigra::Rect2D > >"""
    return _hsi.ComputeImageROI_computeROIS(panorama, opts, images)

class CalculateFitPanorama(PanoramaAlgorithm):
    r"""Proxy of C++ HuginBase::CalculateFitPanorama class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, panorama):
        r"""__init__(CalculateFitPanorama self, PanoramaData panorama) -> CalculateFitPanorama"""
        _hsi.CalculateFitPanorama_swiginit(self, _hsi.new_CalculateFitPanorama(panorama))
    __swig_destroy__ = _hsi.delete_CalculateFitPanorama

    def modifiesPanoramaData(self):
        r"""modifiesPanoramaData(CalculateFitPanorama self) -> bool"""
        return _hsi.CalculateFitPanorama_modifiesPanoramaData(self)

    def runAlgorithm(self):
        r"""runAlgorithm(CalculateFitPanorama self) -> bool"""
        return _hsi.CalculateFitPanorama_runAlgorithm(self)

    @staticmethod
    def fitPano(panorama, HFOV, height):
        r"""fitPano(PanoramaData panorama, double & HFOV, double & height)"""
        return _hsi.CalculateFitPanorama_fitPano(panorama, HFOV, height)

    def getResultHorizontalFOV(self):
        r"""getResultHorizontalFOV(CalculateFitPanorama self) -> double"""
        return _hsi.CalculateFitPanorama_getResultHorizontalFOV(self)

    def getResultHeight(self):
        r"""getResultHeight(CalculateFitPanorama self) -> double"""
        return _hsi.CalculateFitPanorama_getResultHeight(self)

# Register CalculateFitPanorama in _hsi:
_hsi.CalculateFitPanorama_swigregister(CalculateFitPanorama)

def CalculateFitPanorama_fitPano(panorama, HFOV, height):
    r"""CalculateFitPanorama_fitPano(PanoramaData panorama, double & HFOV, double & height)"""
    return _hsi.CalculateFitPanorama_fitPano(panorama, HFOV, height)

class FitPanorama(CalculateFitPanorama):
    r"""Proxy of C++ HuginBase::FitPanorama class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, panorama):
        r"""__init__(FitPanorama self, PanoramaData panorama) -> FitPanorama"""
        _hsi.FitPanorama_swiginit(self, _hsi.new_FitPanorama(panorama))
    __swig_destroy__ = _hsi.delete_FitPanorama

    def modifiesPanoramaData(self):
        r"""modifiesPanoramaData(FitPanorama self) -> bool"""
        return _hsi.FitPanorama_modifiesPanoramaData(self)

    def runAlgorithm(self):
        r"""runAlgorithm(FitPanorama self) -> bool"""
        return _hsi.FitPanorama_runAlgorithm(self)

# Register FitPanorama in _hsi:
_hsi.FitPanorama_swigregister(FitPanorama)

class NonaFileOutputStitcher(FileOutputStitcherAlgorithm):
    r"""Proxy of C++ HuginBase::NonaFileOutputStitcher class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, panoramaData, progressDisplay, options, usedImages, filename, advOptions):
        r"""__init__(NonaFileOutputStitcher self, PanoramaData panoramaData, AppBase::ProgressDisplay * progressDisplay, PanoramaOptions options, UIntSet usedImages, HuginBase::FileOutputStitcherAlgorithm::String const & filename, Nona::AdvancedOptions const & advOptions) -> NonaFileOutputStitcher"""
        _hsi.NonaFileOutputStitcher_swiginit(self, _hsi.new_NonaFileOutputStitcher(panoramaData, progressDisplay, options, usedImages, filename, advOptions))
    __swig_destroy__ = _hsi.delete_NonaFileOutputStitcher

# Register NonaFileOutputStitcher in _hsi:
_hsi.NonaFileOutputStitcher_swigregister(NonaFileOutputStitcher)

class PTOptimizer(PanoramaAlgorithm):
    r"""Proxy of C++ HuginBase::PTOptimizer class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, panorama):
        r"""__init__(PTOptimizer self, PanoramaData panorama) -> PTOptimizer"""
        _hsi.PTOptimizer_swiginit(self, _hsi.new_PTOptimizer(panorama))
    __swig_destroy__ = _hsi.delete_PTOptimizer

    def modifiesPanoramaData(self):
        r"""modifiesPanoramaData(PTOptimizer self) -> bool"""
        return _hsi.PTOptimizer_modifiesPanoramaData(self)

    def runAlgorithm(self):
        r"""runAlgorithm(PTOptimizer self) -> bool"""
        return _hsi.PTOptimizer_runAlgorithm(self)

# Register PTOptimizer in _hsi:
_hsi.PTOptimizer_swigregister(PTOptimizer)

class RANSACOptimizer(PanoramaAlgorithm):
    r"""Proxy of C++ HuginBase::RANSACOptimizer class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __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):
        r"""__init__(RANSACOptimizer self, PanoramaData panorama, int i1, int i2, double maxError, HuginBase::RANSACOptimizer::Mode mode=RPY) -> RANSACOptimizer"""
        _hsi.RANSACOptimizer_swiginit(self, _hsi.new_RANSACOptimizer(*args))
    __swig_destroy__ = _hsi.delete_RANSACOptimizer

    def modifiesPanoramaData(self):
        r"""modifiesPanoramaData(RANSACOptimizer self) -> bool"""
        return _hsi.RANSACOptimizer_modifiesPanoramaData(self)

    @staticmethod
    def findInliers(*args):
        r"""findInliers(PanoramaData pano, int i1, int i2, double maxError, HuginBase::RANSACOptimizer::Mode mode=RPY) -> std::vector< int,std::allocator< int > >"""
        return _hsi.RANSACOptimizer_findInliers(*args)

    def runAlgorithm(self):
        r"""runAlgorithm(RANSACOptimizer self) -> bool"""
        return _hsi.RANSACOptimizer_runAlgorithm(self)

# Register RANSACOptimizer in _hsi:
_hsi.RANSACOptimizer_swigregister(RANSACOptimizer)

def RANSACOptimizer_findInliers(*args):
    r"""RANSACOptimizer_findInliers(PanoramaData pano, int i1, int i2, double maxError, HuginBase::RANSACOptimizer::Mode mode=RPY) -> std::vector< int,std::allocator< int > >"""
    return _hsi.RANSACOptimizer_findInliers(*args)

class AutoOptimise(PTOptimizer):
    r"""Proxy of C++ HuginBase::AutoOptimise class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, panorama, optRoll=True):
        r"""__init__(AutoOptimise self, PanoramaData panorama, bool optRoll=True) -> AutoOptimise"""
        _hsi.AutoOptimise_swiginit(self, _hsi.new_AutoOptimise(panorama, optRoll))
    __swig_destroy__ = _hsi.delete_AutoOptimise

    @staticmethod
    def autoOptimise(pano, optRoll=True):
        r"""autoOptimise(PanoramaData pano, bool optRoll=True)"""
        return _hsi.AutoOptimise_autoOptimise(pano, optRoll)

    def runAlgorithm(self):
        r"""runAlgorithm(AutoOptimise self) -> bool"""
        return _hsi.AutoOptimise_runAlgorithm(self)

# Register AutoOptimise in _hsi:
_hsi.AutoOptimise_swigregister(AutoOptimise)

def AutoOptimise_autoOptimise(pano, optRoll=True):
    r"""AutoOptimise_autoOptimise(PanoramaData pano, bool optRoll=True)"""
    return _hsi.AutoOptimise_autoOptimise(pano, optRoll)

class SmartOptimizerStub(object):
    r"""Proxy of C++ HuginBase::SmartOptimizerStub class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __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
    

    @staticmethod
    def createOptVars(optPano, mode, anchorImg=0):
        r"""createOptVars(PanoramaData optPano, int mode, unsigned int anchorImg=0) -> OptimizeVector"""
        return _hsi.SmartOptimizerStub_createOptVars(optPano, mode, anchorImg)

    def __init__(self):
        r"""__init__(SmartOptimizerStub self) -> SmartOptimizerStub"""
        _hsi.SmartOptimizerStub_swiginit(self, _hsi.new_SmartOptimizerStub())
    __swig_destroy__ = _hsi.delete_SmartOptimizerStub

# Register SmartOptimizerStub in _hsi:
_hsi.SmartOptimizerStub_swigregister(SmartOptimizerStub)

def SmartOptimizerStub_createOptVars(optPano, mode, anchorImg=0):
    r"""SmartOptimizerStub_createOptVars(PanoramaData optPano, int mode, unsigned int anchorImg=0) -> OptimizeVector"""
    return _hsi.SmartOptimizerStub_createOptVars(optPano, mode, anchorImg)

class SmartOptimise(PTOptimizer):
    r"""Proxy of C++ HuginBase::SmartOptimise class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, panorama):
        r"""__init__(SmartOptimise self, PanoramaData panorama) -> SmartOptimise"""
        _hsi.SmartOptimise_swiginit(self, _hsi.new_SmartOptimise(panorama))
    __swig_destroy__ = _hsi.delete_SmartOptimise

    @staticmethod
    def smartOptimize(pano):
        r"""smartOptimize(PanoramaData pano)"""
        return _hsi.SmartOptimise_smartOptimize(pano)

    def runAlgorithm(self):
        r"""runAlgorithm(SmartOptimise self) -> bool"""
        return _hsi.SmartOptimise_runAlgorithm(self)

# Register SmartOptimise in _hsi:
_hsi.SmartOptimise_swigregister(SmartOptimise)

def SmartOptimise_smartOptimize(pano):
    r"""SmartOptimise_smartOptimize(PanoramaData pano)"""
    return _hsi.SmartOptimise_smartOptimize(pano)

class PhotometricOptimizer(TimeConsumingPanoramaAlgorithm):
    r"""Proxy of C++ HuginBase::PhotometricOptimizer class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, panorama, progressDisplay, vars, correspondences, imageStepSize):
        r"""__init__(PhotometricOptimizer self, PanoramaData panorama, AppBase::ProgressDisplay * progressDisplay, OptimizeVector vars, HuginBase::PhotometricOptimizer::PointPairs const & correspondences, float const imageStepSize) -> PhotometricOptimizer"""
        _hsi.PhotometricOptimizer_swiginit(self, _hsi.new_PhotometricOptimizer(panorama, progressDisplay, vars, correspondences, imageStepSize))
    __swig_destroy__ = _hsi.delete_PhotometricOptimizer

    @staticmethod
    def optimizePhotometric(pano, vars, correspondences, imageStepSize, progress, error):
        r"""optimizePhotometric(PanoramaData pano, OptimizeVector vars, HuginBase::PhotometricOptimizer::PointPairs const & correspondences, float const imageStepSize, AppBase::ProgressDisplay * progress, double & error)"""
        return _hsi.PhotometricOptimizer_optimizePhotometric(pano, vars, correspondences, imageStepSize, progress, error)

    def modifiesPanoramaData(self):
        r"""modifiesPanoramaData(PhotometricOptimizer self) -> bool"""
        return _hsi.PhotometricOptimizer_modifiesPanoramaData(self)

    def runAlgorithm(self):
        r"""runAlgorithm(PhotometricOptimizer self) -> bool"""
        return _hsi.PhotometricOptimizer_runAlgorithm(self)

    def getResultError(self):
        r"""getResultError(PhotometricOptimizer self) -> double"""
        return _hsi.PhotometricOptimizer_getResultError(self)

# Register PhotometricOptimizer in _hsi:
_hsi.PhotometricOptimizer_swigregister(PhotometricOptimizer)

def PhotometricOptimizer_optimizePhotometric(pano, vars, correspondences, imageStepSize, progress, error):
    r"""PhotometricOptimizer_optimizePhotometric(PanoramaData pano, OptimizeVector vars, HuginBase::PhotometricOptimizer::PointPairs const & correspondences, float const imageStepSize, AppBase::ProgressDisplay * progress, double & error)"""
    return _hsi.PhotometricOptimizer_optimizePhotometric(pano, vars, correspondences, imageStepSize, progress, error)

class SmartPhotometricOptimizer(PhotometricOptimizer):
    r"""Proxy of C++ HuginBase::SmartPhotometricOptimizer class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    OPT_PHOTOMETRIC_LDR = _hsi.SmartPhotometricOptimizer_OPT_PHOTOMETRIC_LDR
    
    OPT_PHOTOMETRIC_LDR_WB = _hsi.SmartPhotometricOptimizer_OPT_PHOTOMETRIC_LDR_WB
    
    OPT_PHOTOMETRIC_HDR = _hsi.SmartPhotometricOptimizer_OPT_PHOTOMETRIC_HDR
    
    OPT_PHOTOMETRIC_HDR_WB = _hsi.SmartPhotometricOptimizer_OPT_PHOTOMETRIC_HDR_WB
    

    def __init__(self, panorama, progressDisplay, vars, correspondences, imageStepSize, optMode):
        r"""__init__(SmartPhotometricOptimizer self, PanoramaData panorama, AppBase::ProgressDisplay * progressDisplay, OptimizeVector vars, HuginBase::PhotometricOptimizer::PointPairs const & correspondences, float const imageStepSize, HuginBase::SmartPhotometricOptimizer::PhotometricOptimizeMode optMode) -> SmartPhotometricOptimizer"""
        _hsi.SmartPhotometricOptimizer_swiginit(self, _hsi.new_SmartPhotometricOptimizer(panorama, progressDisplay, vars, correspondences, imageStepSize, optMode))
    __swig_destroy__ = _hsi.delete_SmartPhotometricOptimizer

    @staticmethod
    def smartOptimizePhotometric(pano, mode, correspondences, imageStepSize, progress, error):
        r"""smartOptimizePhotometric(PanoramaData pano, HuginBase::SmartPhotometricOptimizer::PhotometricOptimizeMode mode, std::vector< vigra_ext::PointPairRGB,std::allocator< vigra_ext::PointPairRGB > > const & correspondences, float const imageStepSize, AppBase::ProgressDisplay * progress, double & error)"""
        return _hsi.SmartPhotometricOptimizer_smartOptimizePhotometric(pano, mode, correspondences, imageStepSize, progress, error)

    def runAlgorithm(self):
        r"""runAlgorithm(SmartPhotometricOptimizer self) -> bool"""
        return _hsi.SmartPhotometricOptimizer_runAlgorithm(self)

# Register SmartPhotometricOptimizer in _hsi:
_hsi.SmartPhotometricOptimizer_swigregister(SmartPhotometricOptimizer)

def SmartPhotometricOptimizer_smartOptimizePhotometric(pano, mode, correspondences, imageStepSize, progress, error):
    r"""SmartPhotometricOptimizer_smartOptimizePhotometric(PanoramaData pano, HuginBase::SmartPhotometricOptimizer::PhotometricOptimizeMode mode, std::vector< vigra_ext::PointPairRGB,std::allocator< vigra_ext::PointPairRGB > > const & correspondences, float const imageStepSize, AppBase::ProgressDisplay * progress, double & error)"""
    return _hsi.SmartPhotometricOptimizer_smartOptimizePhotometric(pano, mode, correspondences, imageStepSize, progress, error)

class LimitIntensity(object):
    r"""Proxy of C++ HuginBase::LimitIntensity class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    LIMIT_UINT8 = _hsi.LimitIntensity_LIMIT_UINT8
    
    LIMIT_UINT16 = _hsi.LimitIntensity_LIMIT_UINT16
    
    LIMIT_FLOAT = _hsi.LimitIntensity_LIMIT_FLOAT
    

    def __init__(self, *args):
        r"""
        __init__(LimitIntensity self) -> LimitIntensity
        __init__(LimitIntensity self, HuginBase::LimitIntensity::LimitType limit) -> LimitIntensity
        """
        _hsi.LimitIntensity_swiginit(self, _hsi.new_LimitIntensity(*args))

    def GetMinI(self):
        r"""GetMinI(LimitIntensity self) -> float const"""
        return _hsi.LimitIntensity_GetMinI(self)

    def GetMaxI(self):
        r"""GetMaxI(LimitIntensity self) -> float const"""
        return _hsi.LimitIntensity_GetMaxI(self)
    __swig_destroy__ = _hsi.delete_LimitIntensity

# Register LimitIntensity in _hsi:
_hsi.LimitIntensity_swigregister(LimitIntensity)

class PointSampler(TimeConsumingPanoramaAlgorithm):
    r"""Proxy of C++ HuginBase::PointSampler class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _hsi.delete_PointSampler

    def modifiesPanoramaData(self):
        r"""modifiesPanoramaData(PointSampler self) -> bool"""
        return _hsi.PointSampler_modifiesPanoramaData(self)

    def runAlgorithm(self):
        r"""runAlgorithm(PointSampler self) -> bool"""
        return _hsi.PointSampler_runAlgorithm(self)

    def execute(self):
        r"""execute(PointSampler self) -> PointSampler"""
        return _hsi.PointSampler_execute(self)

    def getResultPoints(self):
        r"""getResultPoints(PointSampler self) -> HuginBase::PointSampler::PointPairs"""
        return _hsi.PointSampler_getResultPoints(self)

# Register PointSampler in _hsi:
_hsi.PointSampler_swigregister(PointSampler)

class AllPointSampler(PointSampler):
    r"""Proxy of C++ HuginBase::AllPointSampler class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, panorama, progressDisplay, images, limits, nPoints):
        r"""__init__(AllPointSampler self, PanoramaData panorama, AppBase::ProgressDisplay * progressDisplay, std::vector< vigra::FRGBImage *,std::allocator< vigra::FRGBImage * > > images, HuginBase::LimitIntensityVector limits, int nPoints) -> AllPointSampler"""
        _hsi.AllPointSampler_swiginit(self, _hsi.new_AllPointSampler(panorama, progressDisplay, images, limits, nPoints))
    __swig_destroy__ = _hsi.delete_AllPointSampler

# Register AllPointSampler in _hsi:
_hsi.AllPointSampler_swigregister(AllPointSampler)

class RandomPointSampler(PointSampler):
    r"""Proxy of C++ HuginBase::RandomPointSampler class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, panorama, progressDisplay, images, limits, nPoints):
        r"""__init__(RandomPointSampler self, PanoramaData panorama, AppBase::ProgressDisplay * progressDisplay, std::vector< vigra::FRGBImage *,std::allocator< vigra::FRGBImage * > > images, HuginBase::LimitIntensityVector limits, int nPoints) -> RandomPointSampler"""
        _hsi.RandomPointSampler_swiginit(self, _hsi.new_RandomPointSampler(panorama, progressDisplay, images, limits, nPoints))
    __swig_destroy__ = _hsi.delete_RandomPointSampler

# Register RandomPointSampler in _hsi:
_hsi.RandomPointSampler_swigregister(RandomPointSampler)



