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


"""
Geospatial Image Processing for Python
"""


from sys import version_info
if version_info >= (2,6,0):
    def swig_import_helper():
        from os.path import dirname
        import imp
        fp = None
        try:
            fp, pathname, description = imp.find_module('_gippy', [dirname(__file__)])
        except ImportError:
            import _gippy
            return _gippy
        if fp is not None:
            try:
                _mod = imp.load_module('_gippy', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _gippy = swig_import_helper()
    del swig_import_helper
else:
    import _gippy
del version_info
try:
    _swig_property = property
except NameError:
    pass # Python < 2.2 doesn't have 'property'.
def _swig_setattr_nondynamic(self,class_type,name,value,static=1):
    if (name == "thisown"): return self.this.own(value)
    if (name == "this"):
        if type(value).__name__ == 'SwigPyObject':
            self.__dict__[name] = value
            return
    method = class_type.__swig_setmethods__.get(name,None)
    if method: return method(self,value)
    if (not static):
        self.__dict__[name] = value
    else:
        raise AttributeError("You cannot add attributes to %s" % self)

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

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

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

try:
    _object = object
    _newclass = 1
except AttributeError:
    class _object : pass
    _newclass = 0


class SwigPyIterator(_object):
    """Proxy of C++ swig::SwigPyIterator class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SwigPyIterator, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SwigPyIterator, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _gippy.delete_SwigPyIterator
    __del__ = lambda self : None;
    def value(self):
        """
        value(SwigPyIterator self) -> PyObject *

        Parameters:
            self: swig::SwigPyIterator const *

        """
        return _gippy.SwigPyIterator_value(self)

    def incr(self, n=1):
        """
        incr(SwigPyIterator self, size_t n=1) -> SwigPyIterator

        Parameters:
            n: size_t

        """
        return _gippy.SwigPyIterator_incr(self, n)

    def decr(self, n=1):
        """
        decr(SwigPyIterator self, size_t n=1) -> SwigPyIterator

        Parameters:
            n: size_t

        """
        return _gippy.SwigPyIterator_decr(self, n)

    def distance(self, *args, **kwargs):
        """
        distance(SwigPyIterator self, SwigPyIterator x) -> ptrdiff_t

        Parameters:
            x: swig::SwigPyIterator const &

        """
        return _gippy.SwigPyIterator_distance(self, *args, **kwargs)

    def equal(self, *args, **kwargs):
        """
        equal(SwigPyIterator self, SwigPyIterator x) -> bool

        Parameters:
            x: swig::SwigPyIterator const &

        """
        return _gippy.SwigPyIterator_equal(self, *args, **kwargs)

    def copy(self):
        """
        copy(SwigPyIterator self) -> SwigPyIterator

        Parameters:
            self: swig::SwigPyIterator const *

        """
        return _gippy.SwigPyIterator_copy(self)

    def next(self):
        """
        next(SwigPyIterator self) -> PyObject *

        Parameters:
            self: swig::SwigPyIterator *

        """
        return _gippy.SwigPyIterator_next(self)

    def __next__(self):
        """
        __next__(SwigPyIterator self) -> PyObject *

        Parameters:
            self: swig::SwigPyIterator *

        """
        return _gippy.SwigPyIterator___next__(self)

    def previous(self):
        """
        previous(SwigPyIterator self) -> PyObject *

        Parameters:
            self: swig::SwigPyIterator *

        """
        return _gippy.SwigPyIterator_previous(self)

    def advance(self, *args, **kwargs):
        """
        advance(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator

        Parameters:
            n: ptrdiff_t

        """
        return _gippy.SwigPyIterator_advance(self, *args, **kwargs)

    def __eq__(self, *args, **kwargs):
        """
        __eq__(SwigPyIterator self, SwigPyIterator x) -> bool

        Parameters:
            x: swig::SwigPyIterator const &

        """
        return _gippy.SwigPyIterator___eq__(self, *args, **kwargs)

    def __ne__(self, *args, **kwargs):
        """
        __ne__(SwigPyIterator self, SwigPyIterator x) -> bool

        Parameters:
            x: swig::SwigPyIterator const &

        """
        return _gippy.SwigPyIterator___ne__(self, *args, **kwargs)

    def __iadd__(self, *args, **kwargs):
        """
        __iadd__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator

        Parameters:
            n: ptrdiff_t

        """
        return _gippy.SwigPyIterator___iadd__(self, *args, **kwargs)

    def __isub__(self, *args, **kwargs):
        """
        __isub__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator

        Parameters:
            n: ptrdiff_t

        """
        return _gippy.SwigPyIterator___isub__(self, *args, **kwargs)

    def __add__(self, *args, **kwargs):
        """
        __add__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator

        Parameters:
            n: ptrdiff_t

        """
        return _gippy.SwigPyIterator___add__(self, *args, **kwargs)

    def __sub__(self, *args):
        """
        __sub__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator

        Parameters:
            n: ptrdiff_t

        __sub__(SwigPyIterator self, SwigPyIterator x) -> ptrdiff_t

        Parameters:
            x: swig::SwigPyIterator const &

        """
        return _gippy.SwigPyIterator___sub__(self, *args)

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

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

        Parameters:
            self: std::vector< std::string > *

        """
        return _gippy.svector_iterator(self)

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

        Parameters:
            self: std::vector< std::string > const *

        """
        return _gippy.svector___nonzero__(self)

    def __bool__(self):
        """
        __bool__(svector self) -> bool

        Parameters:
            self: std::vector< std::string > const *

        """
        return _gippy.svector___bool__(self)

    def __len__(self):
        """
        __len__(svector self) -> std::vector< std::string >::size_type

        Parameters:
            self: std::vector< std::string > const *

        """
        return _gippy.svector___len__(self)

    def pop(self):
        """
        pop(svector self) -> std::vector< std::string >::value_type

        Parameters:
            self: std::vector< std::string > *

        """
        return _gippy.svector_pop(self)

    def __getslice__(self, *args, **kwargs):
        """
        __getslice__(svector self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j) -> svector

        Parameters:
            i: std::vector< std::string >::difference_type
            j: std::vector< std::string >::difference_type

        """
        return _gippy.svector___getslice__(self, *args, **kwargs)

    def __setslice__(self, *args, **kwargs):
        """
        __setslice__(svector self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j, 
            svector v=std::vector< std::string,std::allocator< std::string > >())

        Parameters:
            i: std::vector< std::string >::difference_type
            j: std::vector< std::string >::difference_type
            v: std::vector< std::string,std::allocator< std::string > > const &

        """
        return _gippy.svector___setslice__(self, *args, **kwargs)

    def __delslice__(self, *args, **kwargs):
        """
        __delslice__(svector self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j)

        Parameters:
            i: std::vector< std::string >::difference_type
            j: std::vector< std::string >::difference_type

        """
        return _gippy.svector___delslice__(self, *args, **kwargs)

    def __delitem__(self, *args):
        """
        __delitem__(svector self, std::vector< std::string >::difference_type i)

        Parameters:
            i: std::vector< std::string >::difference_type

        __delitem__(svector self, PySliceObject * slice)

        Parameters:
            slice: PySliceObject *

        """
        return _gippy.svector___delitem__(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(svector self, PySliceObject * slice) -> svector

        Parameters:
            slice: PySliceObject *

        __getitem__(svector self, std::vector< std::string >::difference_type i) -> std::vector< std::string >::value_type const &

        Parameters:
            i: std::vector< std::string >::difference_type

        """
        return _gippy.svector___getitem__(self, *args)

    def __setitem__(self, *args):
        """
        __setitem__(svector self, PySliceObject * slice, svector v)

        Parameters:
            slice: PySliceObject *
            v: std::vector< std::string,std::allocator< std::string > > const &

        __setitem__(svector self, PySliceObject * slice)

        Parameters:
            slice: PySliceObject *

        __setitem__(svector self, std::vector< std::string >::difference_type i, std::vector< std::string >::value_type const & x)

        Parameters:
            i: std::vector< std::string >::difference_type
            x: std::vector< std::string >::value_type const &

        """
        return _gippy.svector___setitem__(self, *args)

    def append(self, *args, **kwargs):
        """
        append(svector self, std::vector< std::string >::value_type const & x)

        Parameters:
            x: std::vector< std::string >::value_type const &

        """
        return _gippy.svector_append(self, *args, **kwargs)

    def empty(self):
        """
        empty(svector self) -> bool

        Parameters:
            self: std::vector< std::string > const *

        """
        return _gippy.svector_empty(self)

    def size(self):
        """
        size(svector self) -> std::vector< std::string >::size_type

        Parameters:
            self: std::vector< std::string > const *

        """
        return _gippy.svector_size(self)

    def clear(self):
        """
        clear(svector self)

        Parameters:
            self: std::vector< std::string > *

        """
        return _gippy.svector_clear(self)

    def swap(self, *args, **kwargs):
        """
        swap(svector self, svector v)

        Parameters:
            v: std::vector< std::string > &

        """
        return _gippy.svector_swap(self, *args, **kwargs)

    def get_allocator(self):
        """
        get_allocator(svector self) -> std::vector< std::string >::allocator_type

        Parameters:
            self: std::vector< std::string > const *

        """
        return _gippy.svector_get_allocator(self)

    def begin(self):
        """
        begin(svector self) -> std::vector< std::string >::iterator

        Parameters:
            self: std::vector< std::string > *

        """
        return _gippy.svector_begin(self)

    def end(self):
        """
        end(svector self) -> std::vector< std::string >::iterator

        Parameters:
            self: std::vector< std::string > *

        """
        return _gippy.svector_end(self)

    def rbegin(self):
        """
        rbegin(svector self) -> std::vector< std::string >::reverse_iterator

        Parameters:
            self: std::vector< std::string > *

        """
        return _gippy.svector_rbegin(self)

    def rend(self):
        """
        rend(svector self) -> std::vector< std::string >::reverse_iterator

        Parameters:
            self: std::vector< std::string > *

        """
        return _gippy.svector_rend(self)

    def pop_back(self):
        """
        pop_back(svector self)

        Parameters:
            self: std::vector< std::string > *

        """
        return _gippy.svector_pop_back(self)

    def erase(self, *args):
        """
        erase(svector self, std::vector< std::string >::iterator pos) -> std::vector< std::string >::iterator

        Parameters:
            pos: std::vector< std::string >::iterator

        erase(svector self, std::vector< std::string >::iterator first, std::vector< std::string >::iterator last) -> std::vector< std::string >::iterator

        Parameters:
            first: std::vector< std::string >::iterator
            last: std::vector< std::string >::iterator

        """
        return _gippy.svector_erase(self, *args)

    def __init__(self, *args): 
        """
        __init__(std::vector<(std::string)> self) -> svector
        __init__(std::vector<(std::string)> self, svector arg2) -> svector

        Parameters:
            arg2: std::vector< std::string > const &

        __init__(std::vector<(std::string)> self, std::vector< std::string >::size_type size) -> svector

        Parameters:
            size: std::vector< std::string >::size_type

        __init__(std::vector<(std::string)> self, std::vector< std::string >::size_type size, std::vector< std::string >::value_type const & value) -> svector

        Parameters:
            size: std::vector< std::string >::size_type
            value: std::vector< std::string >::value_type const &

        """
        this = _gippy.new_svector(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args, **kwargs):
        """
        push_back(svector self, std::vector< std::string >::value_type const & x)

        Parameters:
            x: std::vector< std::string >::value_type const &

        """
        return _gippy.svector_push_back(self, *args, **kwargs)

    def front(self):
        """
        front(svector self) -> std::vector< std::string >::value_type const &

        Parameters:
            self: std::vector< std::string > const *

        """
        return _gippy.svector_front(self)

    def back(self):
        """
        back(svector self) -> std::vector< std::string >::value_type const &

        Parameters:
            self: std::vector< std::string > const *

        """
        return _gippy.svector_back(self)

    def assign(self, *args, **kwargs):
        """
        assign(svector self, std::vector< std::string >::size_type n, std::vector< std::string >::value_type const & x)

        Parameters:
            n: std::vector< std::string >::size_type
            x: std::vector< std::string >::value_type const &

        """
        return _gippy.svector_assign(self, *args, **kwargs)

    def resize(self, *args):
        """
        resize(svector self, std::vector< std::string >::size_type new_size)

        Parameters:
            new_size: std::vector< std::string >::size_type

        resize(svector self, std::vector< std::string >::size_type new_size, std::vector< std::string >::value_type const & x)

        Parameters:
            new_size: std::vector< std::string >::size_type
            x: std::vector< std::string >::value_type const &

        """
        return _gippy.svector_resize(self, *args)

    def insert(self, *args):
        """
        insert(svector self, std::vector< std::string >::iterator pos, std::vector< std::string >::value_type const & x) -> std::vector< std::string >::iterator

        Parameters:
            pos: std::vector< std::string >::iterator
            x: std::vector< std::string >::value_type const &

        insert(svector self, std::vector< std::string >::iterator pos, std::vector< std::string >::size_type n, 
            std::vector< std::string >::value_type const & x)

        Parameters:
            pos: std::vector< std::string >::iterator
            n: std::vector< std::string >::size_type
            x: std::vector< std::string >::value_type const &

        """
        return _gippy.svector_insert(self, *args)

    def reserve(self, *args, **kwargs):
        """
        reserve(svector self, std::vector< std::string >::size_type n)

        Parameters:
            n: std::vector< std::string >::size_type

        """
        return _gippy.svector_reserve(self, *args, **kwargs)

    def capacity(self):
        """
        capacity(svector self) -> std::vector< std::string >::size_type

        Parameters:
            self: std::vector< std::string > const *

        """
        return _gippy.svector_capacity(self)

    __swig_destroy__ = _gippy.delete_svector
    __del__ = lambda self : None;
svector_swigregister = _gippy.svector_swigregister
svector_swigregister(svector)

class ivector(_object):
    """Proxy of C++ std::vector<(int)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ivector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ivector, name)
    __repr__ = _swig_repr
    def iterator(self):
        """
        iterator(ivector self) -> SwigPyIterator

        Parameters:
            self: std::vector< int > *

        """
        return _gippy.ivector_iterator(self)

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

        Parameters:
            self: std::vector< int > const *

        """
        return _gippy.ivector___nonzero__(self)

    def __bool__(self):
        """
        __bool__(ivector self) -> bool

        Parameters:
            self: std::vector< int > const *

        """
        return _gippy.ivector___bool__(self)

    def __len__(self):
        """
        __len__(ivector self) -> std::vector< int >::size_type

        Parameters:
            self: std::vector< int > const *

        """
        return _gippy.ivector___len__(self)

    def pop(self):
        """
        pop(ivector self) -> std::vector< int >::value_type

        Parameters:
            self: std::vector< int > *

        """
        return _gippy.ivector_pop(self)

    def __getslice__(self, *args, **kwargs):
        """
        __getslice__(ivector self, std::vector< int >::difference_type i, std::vector< int >::difference_type j) -> ivector

        Parameters:
            i: std::vector< int >::difference_type
            j: std::vector< int >::difference_type

        """
        return _gippy.ivector___getslice__(self, *args, **kwargs)

    def __setslice__(self, *args, **kwargs):
        """
        __setslice__(ivector self, std::vector< int >::difference_type i, std::vector< int >::difference_type j, ivector v=std::vector< int,std::allocator< int > >())

        Parameters:
            i: std::vector< int >::difference_type
            j: std::vector< int >::difference_type
            v: std::vector< int,std::allocator< int > > const &

        """
        return _gippy.ivector___setslice__(self, *args, **kwargs)

    def __delslice__(self, *args, **kwargs):
        """
        __delslice__(ivector self, std::vector< int >::difference_type i, std::vector< int >::difference_type j)

        Parameters:
            i: std::vector< int >::difference_type
            j: std::vector< int >::difference_type

        """
        return _gippy.ivector___delslice__(self, *args, **kwargs)

    def __delitem__(self, *args):
        """
        __delitem__(ivector self, std::vector< int >::difference_type i)

        Parameters:
            i: std::vector< int >::difference_type

        __delitem__(ivector self, PySliceObject * slice)

        Parameters:
            slice: PySliceObject *

        """
        return _gippy.ivector___delitem__(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(ivector self, PySliceObject * slice) -> ivector

        Parameters:
            slice: PySliceObject *

        __getitem__(ivector self, std::vector< int >::difference_type i) -> std::vector< int >::value_type const &

        Parameters:
            i: std::vector< int >::difference_type

        """
        return _gippy.ivector___getitem__(self, *args)

    def __setitem__(self, *args):
        """
        __setitem__(ivector self, PySliceObject * slice, ivector v)

        Parameters:
            slice: PySliceObject *
            v: std::vector< int,std::allocator< int > > const &

        __setitem__(ivector self, PySliceObject * slice)

        Parameters:
            slice: PySliceObject *

        __setitem__(ivector self, std::vector< int >::difference_type i, std::vector< int >::value_type const & x)

        Parameters:
            i: std::vector< int >::difference_type
            x: std::vector< int >::value_type const &

        """
        return _gippy.ivector___setitem__(self, *args)

    def append(self, *args, **kwargs):
        """
        append(ivector self, std::vector< int >::value_type const & x)

        Parameters:
            x: std::vector< int >::value_type const &

        """
        return _gippy.ivector_append(self, *args, **kwargs)

    def empty(self):
        """
        empty(ivector self) -> bool

        Parameters:
            self: std::vector< int > const *

        """
        return _gippy.ivector_empty(self)

    def size(self):
        """
        size(ivector self) -> std::vector< int >::size_type

        Parameters:
            self: std::vector< int > const *

        """
        return _gippy.ivector_size(self)

    def clear(self):
        """
        clear(ivector self)

        Parameters:
            self: std::vector< int > *

        """
        return _gippy.ivector_clear(self)

    def swap(self, *args, **kwargs):
        """
        swap(ivector self, ivector v)

        Parameters:
            v: std::vector< int > &

        """
        return _gippy.ivector_swap(self, *args, **kwargs)

    def get_allocator(self):
        """
        get_allocator(ivector self) -> std::vector< int >::allocator_type

        Parameters:
            self: std::vector< int > const *

        """
        return _gippy.ivector_get_allocator(self)

    def begin(self):
        """
        begin(ivector self) -> std::vector< int >::iterator

        Parameters:
            self: std::vector< int > *

        """
        return _gippy.ivector_begin(self)

    def end(self):
        """
        end(ivector self) -> std::vector< int >::iterator

        Parameters:
            self: std::vector< int > *

        """
        return _gippy.ivector_end(self)

    def rbegin(self):
        """
        rbegin(ivector self) -> std::vector< int >::reverse_iterator

        Parameters:
            self: std::vector< int > *

        """
        return _gippy.ivector_rbegin(self)

    def rend(self):
        """
        rend(ivector self) -> std::vector< int >::reverse_iterator

        Parameters:
            self: std::vector< int > *

        """
        return _gippy.ivector_rend(self)

    def pop_back(self):
        """
        pop_back(ivector self)

        Parameters:
            self: std::vector< int > *

        """
        return _gippy.ivector_pop_back(self)

    def erase(self, *args):
        """
        erase(ivector self, std::vector< int >::iterator pos) -> std::vector< int >::iterator

        Parameters:
            pos: std::vector< int >::iterator

        erase(ivector self, std::vector< int >::iterator first, std::vector< int >::iterator last) -> std::vector< int >::iterator

        Parameters:
            first: std::vector< int >::iterator
            last: std::vector< int >::iterator

        """
        return _gippy.ivector_erase(self, *args)

    def __init__(self, *args): 
        """
        __init__(std::vector<(int)> self) -> ivector
        __init__(std::vector<(int)> self, ivector arg2) -> ivector

        Parameters:
            arg2: std::vector< int > const &

        __init__(std::vector<(int)> self, std::vector< int >::size_type size) -> ivector

        Parameters:
            size: std::vector< int >::size_type

        __init__(std::vector<(int)> self, std::vector< int >::size_type size, std::vector< int >::value_type const & value) -> ivector

        Parameters:
            size: std::vector< int >::size_type
            value: std::vector< int >::value_type const &

        """
        this = _gippy.new_ivector(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args, **kwargs):
        """
        push_back(ivector self, std::vector< int >::value_type const & x)

        Parameters:
            x: std::vector< int >::value_type const &

        """
        return _gippy.ivector_push_back(self, *args, **kwargs)

    def front(self):
        """
        front(ivector self) -> std::vector< int >::value_type const &

        Parameters:
            self: std::vector< int > const *

        """
        return _gippy.ivector_front(self)

    def back(self):
        """
        back(ivector self) -> std::vector< int >::value_type const &

        Parameters:
            self: std::vector< int > const *

        """
        return _gippy.ivector_back(self)

    def assign(self, *args, **kwargs):
        """
        assign(ivector self, std::vector< int >::size_type n, std::vector< int >::value_type const & x)

        Parameters:
            n: std::vector< int >::size_type
            x: std::vector< int >::value_type const &

        """
        return _gippy.ivector_assign(self, *args, **kwargs)

    def resize(self, *args):
        """
        resize(ivector self, std::vector< int >::size_type new_size)

        Parameters:
            new_size: std::vector< int >::size_type

        resize(ivector self, std::vector< int >::size_type new_size, std::vector< int >::value_type const & x)

        Parameters:
            new_size: std::vector< int >::size_type
            x: std::vector< int >::value_type const &

        """
        return _gippy.ivector_resize(self, *args)

    def insert(self, *args):
        """
        insert(ivector self, std::vector< int >::iterator pos, std::vector< int >::value_type const & x) -> std::vector< int >::iterator

        Parameters:
            pos: std::vector< int >::iterator
            x: std::vector< int >::value_type const &

        insert(ivector self, std::vector< int >::iterator pos, std::vector< int >::size_type n, std::vector< int >::value_type const & x)

        Parameters:
            pos: std::vector< int >::iterator
            n: std::vector< int >::size_type
            x: std::vector< int >::value_type const &

        """
        return _gippy.ivector_insert(self, *args)

    def reserve(self, *args, **kwargs):
        """
        reserve(ivector self, std::vector< int >::size_type n)

        Parameters:
            n: std::vector< int >::size_type

        """
        return _gippy.ivector_reserve(self, *args, **kwargs)

    def capacity(self):
        """
        capacity(ivector self) -> std::vector< int >::size_type

        Parameters:
            self: std::vector< int > const *

        """
        return _gippy.ivector_capacity(self)

    __swig_destroy__ = _gippy.delete_ivector
    __del__ = lambda self : None;
ivector_swigregister = _gippy.ivector_swigregister
ivector_swigregister(ivector)

cimg_verbosity = _gippy.cimg_verbosity
cimg_display = _gippy.cimg_display
cimg_plugin = _gippy.cimg_plugin
cimg_plugin1 = _gippy.cimg_plugin1
cimg_plugin2 = _gippy.cimg_plugin2

def init():
  """init()"""
  return _gippy.init()
class Options(_object):
    """Proxy of C++ gip::Options class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Options, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Options, name)
    __repr__ = _swig_repr
    def defaultformat():
        """defaultformat() -> std::string"""
        return _gippy.Options_defaultformat()

    if _newclass:defaultformat = staticmethod(defaultformat)
    __swig_getmethods__["defaultformat"] = lambda x: defaultformat
    def set_defaultformat(*args, **kwargs):
        """
        set_defaultformat(std::string str)

        Parameters:
            str: std::string

        """
        return _gippy.Options_set_defaultformat(*args, **kwargs)

    if _newclass:set_defaultformat = staticmethod(set_defaultformat)
    __swig_getmethods__["set_defaultformat"] = lambda x: set_defaultformat
    def chunksize():
        """chunksize() -> float"""
        return _gippy.Options_chunksize()

    if _newclass:chunksize = staticmethod(chunksize)
    __swig_getmethods__["chunksize"] = lambda x: chunksize
    def set_chunksize(*args, **kwargs):
        """
        set_chunksize(float sz)

        Parameters:
            sz: float

        """
        return _gippy.Options_set_chunksize(*args, **kwargs)

    if _newclass:set_chunksize = staticmethod(set_chunksize)
    __swig_getmethods__["set_chunksize"] = lambda x: set_chunksize
    def verbose():
        """verbose() -> int"""
        return _gippy.Options_verbose()

    if _newclass:verbose = staticmethod(verbose)
    __swig_getmethods__["verbose"] = lambda x: verbose
    def set_verbose(*args, **kwargs):
        """
        set_verbose(int v)

        Parameters:
            v: int

        """
        return _gippy.Options_set_verbose(*args, **kwargs)

    if _newclass:set_verbose = staticmethod(set_verbose)
    __swig_getmethods__["set_verbose"] = lambda x: set_verbose
    def cores():
        """cores() -> int"""
        return _gippy.Options_cores()

    if _newclass:cores = staticmethod(cores)
    __swig_getmethods__["cores"] = lambda x: cores
    def set_cores(*args, **kwargs):
        """
        set_cores(int n)

        Parameters:
            n: int

        """
        return _gippy.Options_set_cores(*args, **kwargs)

    if _newclass:set_cores = staticmethod(set_cores)
    __swig_getmethods__["set_cores"] = lambda x: set_cores
    def __init__(self): 
        """__init__(gip::Options self) -> Options"""
        this = _gippy.new_Options()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _gippy.delete_Options
    __del__ = lambda self : None;
Options_swigregister = _gippy.Options_swigregister
Options_swigregister(Options)

def Options_defaultformat():
  """Options_defaultformat() -> std::string"""
  return _gippy.Options_defaultformat()

def Options_set_defaultformat(*args, **kwargs):
  """
    Options_set_defaultformat(std::string str)

    Parameters:
        str: std::string

    """
  return _gippy.Options_set_defaultformat(*args, **kwargs)

def Options_chunksize():
  """Options_chunksize() -> float"""
  return _gippy.Options_chunksize()

def Options_set_chunksize(*args, **kwargs):
  """
    Options_set_chunksize(float sz)

    Parameters:
        sz: float

    """
  return _gippy.Options_set_chunksize(*args, **kwargs)

def Options_verbose():
  """Options_verbose() -> int"""
  return _gippy.Options_verbose()

def Options_set_verbose(*args, **kwargs):
  """
    Options_set_verbose(int v)

    Parameters:
        v: int

    """
  return _gippy.Options_set_verbose(*args, **kwargs)

def Options_cores():
  """Options_cores() -> int"""
  return _gippy.Options_cores()

def Options_set_cores(*args, **kwargs):
  """
    Options_set_cores(int n)

    Parameters:
        n: int

    """
  return _gippy.Options_set_cores(*args, **kwargs)

class iPoint(_object):
    """Proxy of C++ gip::Point<(int)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, iPoint, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, iPoint, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(gip::Point<(int)> self) -> iPoint
        __init__(gip::Point<(int)> self, int x, int y) -> iPoint

        Parameters:
            x: int
            y: int

        """
        this = _gippy.new_iPoint(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _gippy.delete_iPoint
    __del__ = lambda self : None;
    def __sub__(self, *args, **kwargs):
        """
        __sub__(iPoint self, iPoint p) -> iPoint

        Parameters:
            p: gip::Point< int > const &

        """
        return _gippy.iPoint___sub__(self, *args, **kwargs)

    def __add__(self, *args, **kwargs):
        """
        __add__(iPoint self, iPoint p) -> iPoint

        Parameters:
            p: gip::Point< int > const &

        """
        return _gippy.iPoint___add__(self, *args, **kwargs)

    def __eq__(self, *args, **kwargs):
        """
        __eq__(iPoint self, iPoint p) -> bool

        Parameters:
            p: gip::Point< int > const &

        """
        return _gippy.iPoint___eq__(self, *args, **kwargs)

    def __ne__(self, *args, **kwargs):
        """
        __ne__(iPoint self, iPoint p) -> bool

        Parameters:
            p: gip::Point< int > const &

        """
        return _gippy.iPoint___ne__(self, *args, **kwargs)

    def x(self):
        """
        x(iPoint self) -> int

        Parameters:
            self: gip::Point< int > const *

        """
        return _gippy.iPoint_x(self)

    def y(self):
        """
        y(iPoint self) -> int

        Parameters:
            self: gip::Point< int > const *

        """
        return _gippy.iPoint_y(self)

    def transform(self, *args, **kwargs):
        """
        transform(iPoint self, std::string src, std::string dst) -> iPoint

        Parameters:
            src: std::string
            dst: std::string

        """
        return _gippy.iPoint_transform(self, *args, **kwargs)

iPoint_swigregister = _gippy.iPoint_swigregister
iPoint_swigregister(iPoint)

class dPoint(_object):
    """Proxy of C++ gip::Point<(double)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, dPoint, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, dPoint, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(gip::Point<(double)> self) -> dPoint
        __init__(gip::Point<(double)> self, double x, double y) -> dPoint

        Parameters:
            x: double
            y: double

        """
        this = _gippy.new_dPoint(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _gippy.delete_dPoint
    __del__ = lambda self : None;
    def __sub__(self, *args, **kwargs):
        """
        __sub__(dPoint self, dPoint p) -> dPoint

        Parameters:
            p: gip::Point< double > const &

        """
        return _gippy.dPoint___sub__(self, *args, **kwargs)

    def __add__(self, *args, **kwargs):
        """
        __add__(dPoint self, dPoint p) -> dPoint

        Parameters:
            p: gip::Point< double > const &

        """
        return _gippy.dPoint___add__(self, *args, **kwargs)

    def __eq__(self, *args, **kwargs):
        """
        __eq__(dPoint self, dPoint p) -> bool

        Parameters:
            p: gip::Point< double > const &

        """
        return _gippy.dPoint___eq__(self, *args, **kwargs)

    def __ne__(self, *args, **kwargs):
        """
        __ne__(dPoint self, dPoint p) -> bool

        Parameters:
            p: gip::Point< double > const &

        """
        return _gippy.dPoint___ne__(self, *args, **kwargs)

    def x(self):
        """
        x(dPoint self) -> double

        Parameters:
            self: gip::Point< double > const *

        """
        return _gippy.dPoint_x(self)

    def y(self):
        """
        y(dPoint self) -> double

        Parameters:
            self: gip::Point< double > const *

        """
        return _gippy.dPoint_y(self)

    def transform(self, *args, **kwargs):
        """
        transform(dPoint self, std::string src, std::string dst) -> dPoint

        Parameters:
            src: std::string
            dst: std::string

        """
        return _gippy.dPoint_transform(self, *args, **kwargs)

dPoint_swigregister = _gippy.dPoint_swigregister
dPoint_swigregister(dPoint)

class Chunk(_object):
    """Proxy of C++ gip::Rect<(int)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Chunk, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Chunk, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(gip::Rect<(int)> self) -> Chunk
        __init__(gip::Rect<(int)> self, int x, int y, int width, int height) -> Chunk

        Parameters:
            x: int
            y: int
            width: int
            height: int

        __init__(gip::Rect<(int)> self, iPoint p0, iPoint p1) -> Chunk

        Parameters:
            p0: gip::Point< int >
            p1: gip::Point< int >

        __init__(gip::Rect<(int)> self, Chunk rect) -> Chunk

        Parameters:
            rect: gip::Rect< int > const &

        """
        this = _gippy.new_Chunk(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _gippy.delete_Chunk
    __del__ = lambda self : None;
    def p0(self):
        """
        p0(Chunk self) -> iPoint

        Parameters:
            self: gip::Rect< int > const *

        """
        return _gippy.Chunk_p0(self)

    def p1(self):
        """
        p1(Chunk self) -> iPoint

        Parameters:
            self: gip::Rect< int > const *

        """
        return _gippy.Chunk_p1(self)

    def valid(self):
        """
        valid(Chunk self) -> int

        Parameters:
            self: gip::Rect< int > const *

        """
        return _gippy.Chunk_valid(self)

    def area(self):
        """
        area(Chunk self) -> int

        Parameters:
            self: gip::Rect< int > const *

        """
        return _gippy.Chunk_area(self)

    def width(self):
        """
        width(Chunk self) -> int

        Parameters:
            self: gip::Rect< int > const *

        """
        return _gippy.Chunk_width(self)

    def height(self):
        """
        height(Chunk self) -> int

        Parameters:
            self: gip::Rect< int > const *

        """
        return _gippy.Chunk_height(self)

    def x0(self):
        """
        x0(Chunk self) -> int

        Parameters:
            self: gip::Rect< int > const *

        """
        return _gippy.Chunk_x0(self)

    def y0(self):
        """
        y0(Chunk self) -> int

        Parameters:
            self: gip::Rect< int > const *

        """
        return _gippy.Chunk_y0(self)

    def x1(self):
        """
        x1(Chunk self) -> int

        Parameters:
            self: gip::Rect< int > const *

        """
        return _gippy.Chunk_x1(self)

    def y1(self):
        """
        y1(Chunk self) -> int

        Parameters:
            self: gip::Rect< int > const *

        """
        return _gippy.Chunk_y1(self)

    def __eq__(self, *args, **kwargs):
        """
        __eq__(Chunk self, Chunk rect) -> bool

        Parameters:
            rect: gip::Rect< int > const &

        """
        return _gippy.Chunk___eq__(self, *args, **kwargs)

    def __ne__(self, *args, **kwargs):
        """
        __ne__(Chunk self, Chunk rect) -> bool

        Parameters:
            rect: gip::Rect< int > const &

        """
        return _gippy.Chunk___ne__(self, *args, **kwargs)

    def transform(self, *args, **kwargs):
        """
        transform(Chunk self, std::string src, std::string dst) -> Chunk

        Parameters:
            src: std::string
            dst: std::string

        """
        return _gippy.Chunk_transform(self, *args, **kwargs)

    def intersect(self, *args, **kwargs):
        """
        intersect(Chunk self, Chunk rect) -> Chunk

        Parameters:
            rect: gip::Rect< int > const &

        """
        return _gippy.Chunk_intersect(self, *args, **kwargs)

    def padding(self, *args):
        """
        padding(Chunk self) -> int
        padding(Chunk self, int padding) -> Chunk

        Parameters:
            padding: int

        """
        return _gippy.Chunk_padding(self, *args)

    def pad(self, *args):
        """
        pad(Chunk self) -> Chunk
        pad(Chunk self, int pad) -> Chunk

        Parameters:
            pad: int

        """
        return _gippy.Chunk_pad(self, *args)

    def union_with(self, *args, **kwargs):
        """
        union_with(Chunk self, Chunk rect) -> Chunk

        Parameters:
            rect: gip::Rect< int > const &

        """
        return _gippy.Chunk_union_with(self, *args, **kwargs)

Chunk_swigregister = _gippy.Chunk_swigregister
Chunk_swigregister(Chunk)

class BoundingBox(_object):
    """Proxy of C++ gip::Rect<(double)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, BoundingBox, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, BoundingBox, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(gip::Rect<(double)> self) -> BoundingBox
        __init__(gip::Rect<(double)> self, double x, double y, double width, double height) -> BoundingBox

        Parameters:
            x: double
            y: double
            width: double
            height: double

        __init__(gip::Rect<(double)> self, dPoint p0, dPoint p1) -> BoundingBox

        Parameters:
            p0: gip::Point< double >
            p1: gip::Point< double >

        __init__(gip::Rect<(double)> self, BoundingBox rect) -> BoundingBox

        Parameters:
            rect: gip::Rect< double > const &

        """
        this = _gippy.new_BoundingBox(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _gippy.delete_BoundingBox
    __del__ = lambda self : None;
    def p0(self):
        """
        p0(BoundingBox self) -> dPoint

        Parameters:
            self: gip::Rect< double > const *

        """
        return _gippy.BoundingBox_p0(self)

    def p1(self):
        """
        p1(BoundingBox self) -> dPoint

        Parameters:
            self: gip::Rect< double > const *

        """
        return _gippy.BoundingBox_p1(self)

    def valid(self):
        """
        valid(BoundingBox self) -> double

        Parameters:
            self: gip::Rect< double > const *

        """
        return _gippy.BoundingBox_valid(self)

    def area(self):
        """
        area(BoundingBox self) -> double

        Parameters:
            self: gip::Rect< double > const *

        """
        return _gippy.BoundingBox_area(self)

    def width(self):
        """
        width(BoundingBox self) -> double

        Parameters:
            self: gip::Rect< double > const *

        """
        return _gippy.BoundingBox_width(self)

    def height(self):
        """
        height(BoundingBox self) -> double

        Parameters:
            self: gip::Rect< double > const *

        """
        return _gippy.BoundingBox_height(self)

    def x0(self):
        """
        x0(BoundingBox self) -> double

        Parameters:
            self: gip::Rect< double > const *

        """
        return _gippy.BoundingBox_x0(self)

    def y0(self):
        """
        y0(BoundingBox self) -> double

        Parameters:
            self: gip::Rect< double > const *

        """
        return _gippy.BoundingBox_y0(self)

    def x1(self):
        """
        x1(BoundingBox self) -> double

        Parameters:
            self: gip::Rect< double > const *

        """
        return _gippy.BoundingBox_x1(self)

    def y1(self):
        """
        y1(BoundingBox self) -> double

        Parameters:
            self: gip::Rect< double > const *

        """
        return _gippy.BoundingBox_y1(self)

    def __eq__(self, *args, **kwargs):
        """
        __eq__(BoundingBox self, BoundingBox rect) -> bool

        Parameters:
            rect: gip::Rect< double > const &

        """
        return _gippy.BoundingBox___eq__(self, *args, **kwargs)

    def __ne__(self, *args, **kwargs):
        """
        __ne__(BoundingBox self, BoundingBox rect) -> bool

        Parameters:
            rect: gip::Rect< double > const &

        """
        return _gippy.BoundingBox___ne__(self, *args, **kwargs)

    def transform(self, *args, **kwargs):
        """
        transform(BoundingBox self, std::string src, std::string dst) -> BoundingBox

        Parameters:
            src: std::string
            dst: std::string

        """
        return _gippy.BoundingBox_transform(self, *args, **kwargs)

    def intersect(self, *args, **kwargs):
        """
        intersect(BoundingBox self, BoundingBox rect) -> BoundingBox

        Parameters:
            rect: gip::Rect< double > const &

        """
        return _gippy.BoundingBox_intersect(self, *args, **kwargs)

    def padding(self, *args):
        """
        padding(BoundingBox self) -> double
        padding(BoundingBox self, double padding) -> BoundingBox

        Parameters:
            padding: double

        """
        return _gippy.BoundingBox_padding(self, *args)

    def pad(self, *args):
        """
        pad(BoundingBox self) -> BoundingBox
        pad(BoundingBox self, double pad) -> BoundingBox

        Parameters:
            pad: double

        """
        return _gippy.BoundingBox_pad(self, *args)

    def union_with(self, *args, **kwargs):
        """
        union_with(BoundingBox self, BoundingBox rect) -> BoundingBox

        Parameters:
            rect: gip::Rect< double > const &

        """
        return _gippy.BoundingBox_union_with(self, *args, **kwargs)

BoundingBox_swigregister = _gippy.BoundingBox_swigregister
BoundingBox_swigregister(BoundingBox)

class chvector(_object):
    """Proxy of C++ std::vector<(gip::Rect<(int)>)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, chvector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, chvector, name)
    __repr__ = _swig_repr
    def iterator(self):
        """
        iterator(chvector self) -> SwigPyIterator

        Parameters:
            self: std::vector< gip::Rect< int > > *

        """
        return _gippy.chvector_iterator(self)

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

        Parameters:
            self: std::vector< gip::Rect< int > > const *

        """
        return _gippy.chvector___nonzero__(self)

    def __bool__(self):
        """
        __bool__(chvector self) -> bool

        Parameters:
            self: std::vector< gip::Rect< int > > const *

        """
        return _gippy.chvector___bool__(self)

    def __len__(self):
        """
        __len__(chvector self) -> std::vector< gip::Rect< int > >::size_type

        Parameters:
            self: std::vector< gip::Rect< int > > const *

        """
        return _gippy.chvector___len__(self)

    def pop(self):
        """
        pop(chvector self) -> Chunk

        Parameters:
            self: std::vector< gip::Rect< int > > *

        """
        return _gippy.chvector_pop(self)

    def __getslice__(self, *args, **kwargs):
        """
        __getslice__(chvector self, std::vector< gip::Rect< int > >::difference_type i, std::vector< gip::Rect< int > >::difference_type j) -> chvector

        Parameters:
            i: std::vector< gip::Rect< int > >::difference_type
            j: std::vector< gip::Rect< int > >::difference_type

        """
        return _gippy.chvector___getslice__(self, *args, **kwargs)

    def __setslice__(self, *args, **kwargs):
        """
        __setslice__(chvector self, std::vector< gip::Rect< int > >::difference_type i, std::vector< gip::Rect< int > >::difference_type j, 
            chvector v=std::vector< gip::Rect< int >,std::allocator< gip::Rect< int > > >())

        Parameters:
            i: std::vector< gip::Rect< int > >::difference_type
            j: std::vector< gip::Rect< int > >::difference_type
            v: std::vector< gip::Rect< int >,std::allocator< gip::Rect< int > > > const &

        """
        return _gippy.chvector___setslice__(self, *args, **kwargs)

    def __delslice__(self, *args, **kwargs):
        """
        __delslice__(chvector self, std::vector< gip::Rect< int > >::difference_type i, std::vector< gip::Rect< int > >::difference_type j)

        Parameters:
            i: std::vector< gip::Rect< int > >::difference_type
            j: std::vector< gip::Rect< int > >::difference_type

        """
        return _gippy.chvector___delslice__(self, *args, **kwargs)

    def __delitem__(self, *args):
        """
        __delitem__(chvector self, std::vector< gip::Rect< int > >::difference_type i)

        Parameters:
            i: std::vector< gip::Rect< int > >::difference_type

        __delitem__(chvector self, PySliceObject * slice)

        Parameters:
            slice: PySliceObject *

        """
        return _gippy.chvector___delitem__(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(chvector self, PySliceObject * slice) -> chvector

        Parameters:
            slice: PySliceObject *

        __getitem__(chvector self, std::vector< gip::Rect< int > >::difference_type i) -> Chunk

        Parameters:
            i: std::vector< gip::Rect< int > >::difference_type

        """
        return _gippy.chvector___getitem__(self, *args)

    def __setitem__(self, *args):
        """
        __setitem__(chvector self, PySliceObject * slice, chvector v)

        Parameters:
            slice: PySliceObject *
            v: std::vector< gip::Rect< int >,std::allocator< gip::Rect< int > > > const &

        __setitem__(chvector self, PySliceObject * slice)

        Parameters:
            slice: PySliceObject *

        __setitem__(chvector self, std::vector< gip::Rect< int > >::difference_type i, Chunk x)

        Parameters:
            i: std::vector< gip::Rect< int > >::difference_type
            x: std::vector< gip::Rect< int > >::value_type const &

        """
        return _gippy.chvector___setitem__(self, *args)

    def append(self, *args, **kwargs):
        """
        append(chvector self, Chunk x)

        Parameters:
            x: std::vector< gip::Rect< int > >::value_type const &

        """
        return _gippy.chvector_append(self, *args, **kwargs)

    def empty(self):
        """
        empty(chvector self) -> bool

        Parameters:
            self: std::vector< gip::Rect< int > > const *

        """
        return _gippy.chvector_empty(self)

    def size(self):
        """
        size(chvector self) -> std::vector< gip::Rect< int > >::size_type

        Parameters:
            self: std::vector< gip::Rect< int > > const *

        """
        return _gippy.chvector_size(self)

    def clear(self):
        """
        clear(chvector self)

        Parameters:
            self: std::vector< gip::Rect< int > > *

        """
        return _gippy.chvector_clear(self)

    def swap(self, *args, **kwargs):
        """
        swap(chvector self, chvector v)

        Parameters:
            v: std::vector< gip::Rect< int > > &

        """
        return _gippy.chvector_swap(self, *args, **kwargs)

    def get_allocator(self):
        """
        get_allocator(chvector self) -> std::vector< gip::Rect< int > >::allocator_type

        Parameters:
            self: std::vector< gip::Rect< int > > const *

        """
        return _gippy.chvector_get_allocator(self)

    def begin(self):
        """
        begin(chvector self) -> std::vector< gip::Rect< int > >::iterator

        Parameters:
            self: std::vector< gip::Rect< int > > *

        """
        return _gippy.chvector_begin(self)

    def end(self):
        """
        end(chvector self) -> std::vector< gip::Rect< int > >::iterator

        Parameters:
            self: std::vector< gip::Rect< int > > *

        """
        return _gippy.chvector_end(self)

    def rbegin(self):
        """
        rbegin(chvector self) -> std::vector< gip::Rect< int > >::reverse_iterator

        Parameters:
            self: std::vector< gip::Rect< int > > *

        """
        return _gippy.chvector_rbegin(self)

    def rend(self):
        """
        rend(chvector self) -> std::vector< gip::Rect< int > >::reverse_iterator

        Parameters:
            self: std::vector< gip::Rect< int > > *

        """
        return _gippy.chvector_rend(self)

    def pop_back(self):
        """
        pop_back(chvector self)

        Parameters:
            self: std::vector< gip::Rect< int > > *

        """
        return _gippy.chvector_pop_back(self)

    def erase(self, *args):
        """
        erase(chvector self, std::vector< gip::Rect< int > >::iterator pos) -> std::vector< gip::Rect< int > >::iterator

        Parameters:
            pos: std::vector< gip::Rect< int > >::iterator

        erase(chvector self, std::vector< gip::Rect< int > >::iterator first, std::vector< gip::Rect< int > >::iterator last) -> std::vector< gip::Rect< int > >::iterator

        Parameters:
            first: std::vector< gip::Rect< int > >::iterator
            last: std::vector< gip::Rect< int > >::iterator

        """
        return _gippy.chvector_erase(self, *args)

    def __init__(self, *args): 
        """
        __init__(std::vector<(gip::Rect<(int)>)> self) -> chvector
        __init__(std::vector<(gip::Rect<(int)>)> self, chvector arg2) -> chvector

        Parameters:
            arg2: std::vector< gip::Rect< int > > const &

        __init__(std::vector<(gip::Rect<(int)>)> self, std::vector< gip::Rect< int > >::size_type size) -> chvector

        Parameters:
            size: std::vector< gip::Rect< int > >::size_type

        __init__(std::vector<(gip::Rect<(int)>)> self, std::vector< gip::Rect< int > >::size_type size, Chunk value) -> chvector

        Parameters:
            size: std::vector< gip::Rect< int > >::size_type
            value: std::vector< gip::Rect< int > >::value_type const &

        """
        this = _gippy.new_chvector(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args, **kwargs):
        """
        push_back(chvector self, Chunk x)

        Parameters:
            x: std::vector< gip::Rect< int > >::value_type const &

        """
        return _gippy.chvector_push_back(self, *args, **kwargs)

    def front(self):
        """
        front(chvector self) -> Chunk

        Parameters:
            self: std::vector< gip::Rect< int > > const *

        """
        return _gippy.chvector_front(self)

    def back(self):
        """
        back(chvector self) -> Chunk

        Parameters:
            self: std::vector< gip::Rect< int > > const *

        """
        return _gippy.chvector_back(self)

    def assign(self, *args, **kwargs):
        """
        assign(chvector self, std::vector< gip::Rect< int > >::size_type n, Chunk x)

        Parameters:
            n: std::vector< gip::Rect< int > >::size_type
            x: std::vector< gip::Rect< int > >::value_type const &

        """
        return _gippy.chvector_assign(self, *args, **kwargs)

    def resize(self, *args):
        """
        resize(chvector self, std::vector< gip::Rect< int > >::size_type new_size)

        Parameters:
            new_size: std::vector< gip::Rect< int > >::size_type

        resize(chvector self, std::vector< gip::Rect< int > >::size_type new_size, Chunk x)

        Parameters:
            new_size: std::vector< gip::Rect< int > >::size_type
            x: std::vector< gip::Rect< int > >::value_type const &

        """
        return _gippy.chvector_resize(self, *args)

    def insert(self, *args):
        """
        insert(chvector self, std::vector< gip::Rect< int > >::iterator pos, Chunk x) -> std::vector< gip::Rect< int > >::iterator

        Parameters:
            pos: std::vector< gip::Rect< int > >::iterator
            x: std::vector< gip::Rect< int > >::value_type const &

        insert(chvector self, std::vector< gip::Rect< int > >::iterator pos, std::vector< gip::Rect< int > >::size_type n, 
            Chunk x)

        Parameters:
            pos: std::vector< gip::Rect< int > >::iterator
            n: std::vector< gip::Rect< int > >::size_type
            x: std::vector< gip::Rect< int > >::value_type const &

        """
        return _gippy.chvector_insert(self, *args)

    def reserve(self, *args, **kwargs):
        """
        reserve(chvector self, std::vector< gip::Rect< int > >::size_type n)

        Parameters:
            n: std::vector< gip::Rect< int > >::size_type

        """
        return _gippy.chvector_reserve(self, *args, **kwargs)

    def capacity(self):
        """
        capacity(chvector self) -> std::vector< gip::Rect< int > >::size_type

        Parameters:
            self: std::vector< gip::Rect< int > > const *

        """
        return _gippy.chvector_capacity(self)

    __swig_destroy__ = _gippy.delete_chvector
    __del__ = lambda self : None;
chvector_swigregister = _gippy.chvector_swigregister
chvector_swigregister(chvector)

class bbvector(_object):
    """Proxy of C++ std::vector<(gip::Rect<(double)>)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, bbvector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, bbvector, name)
    __repr__ = _swig_repr
    def iterator(self):
        """
        iterator(bbvector self) -> SwigPyIterator

        Parameters:
            self: std::vector< gip::Rect< double > > *

        """
        return _gippy.bbvector_iterator(self)

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

        Parameters:
            self: std::vector< gip::Rect< double > > const *

        """
        return _gippy.bbvector___nonzero__(self)

    def __bool__(self):
        """
        __bool__(bbvector self) -> bool

        Parameters:
            self: std::vector< gip::Rect< double > > const *

        """
        return _gippy.bbvector___bool__(self)

    def __len__(self):
        """
        __len__(bbvector self) -> std::vector< gip::Rect< double > >::size_type

        Parameters:
            self: std::vector< gip::Rect< double > > const *

        """
        return _gippy.bbvector___len__(self)

    def pop(self):
        """
        pop(bbvector self) -> BoundingBox

        Parameters:
            self: std::vector< gip::Rect< double > > *

        """
        return _gippy.bbvector_pop(self)

    def __getslice__(self, *args, **kwargs):
        """
        __getslice__(bbvector self, std::vector< gip::Rect< double > >::difference_type i, std::vector< gip::Rect< double > >::difference_type j) -> bbvector

        Parameters:
            i: std::vector< gip::Rect< double > >::difference_type
            j: std::vector< gip::Rect< double > >::difference_type

        """
        return _gippy.bbvector___getslice__(self, *args, **kwargs)

    def __setslice__(self, *args, **kwargs):
        """
        __setslice__(bbvector self, std::vector< gip::Rect< double > >::difference_type i, std::vector< gip::Rect< double > >::difference_type j, 
            bbvector v=std::vector< gip::Rect< double >,std::allocator< gip::Rect< double > > >())

        Parameters:
            i: std::vector< gip::Rect< double > >::difference_type
            j: std::vector< gip::Rect< double > >::difference_type
            v: std::vector< gip::Rect< double >,std::allocator< gip::Rect< double > > > const &

        """
        return _gippy.bbvector___setslice__(self, *args, **kwargs)

    def __delslice__(self, *args, **kwargs):
        """
        __delslice__(bbvector self, std::vector< gip::Rect< double > >::difference_type i, std::vector< gip::Rect< double > >::difference_type j)

        Parameters:
            i: std::vector< gip::Rect< double > >::difference_type
            j: std::vector< gip::Rect< double > >::difference_type

        """
        return _gippy.bbvector___delslice__(self, *args, **kwargs)

    def __delitem__(self, *args):
        """
        __delitem__(bbvector self, std::vector< gip::Rect< double > >::difference_type i)

        Parameters:
            i: std::vector< gip::Rect< double > >::difference_type

        __delitem__(bbvector self, PySliceObject * slice)

        Parameters:
            slice: PySliceObject *

        """
        return _gippy.bbvector___delitem__(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(bbvector self, PySliceObject * slice) -> bbvector

        Parameters:
            slice: PySliceObject *

        __getitem__(bbvector self, std::vector< gip::Rect< double > >::difference_type i) -> BoundingBox

        Parameters:
            i: std::vector< gip::Rect< double > >::difference_type

        """
        return _gippy.bbvector___getitem__(self, *args)

    def __setitem__(self, *args):
        """
        __setitem__(bbvector self, PySliceObject * slice, bbvector v)

        Parameters:
            slice: PySliceObject *
            v: std::vector< gip::Rect< double >,std::allocator< gip::Rect< double > > > const &

        __setitem__(bbvector self, PySliceObject * slice)

        Parameters:
            slice: PySliceObject *

        __setitem__(bbvector self, std::vector< gip::Rect< double > >::difference_type i, BoundingBox x)

        Parameters:
            i: std::vector< gip::Rect< double > >::difference_type
            x: std::vector< gip::Rect< double > >::value_type const &

        """
        return _gippy.bbvector___setitem__(self, *args)

    def append(self, *args, **kwargs):
        """
        append(bbvector self, BoundingBox x)

        Parameters:
            x: std::vector< gip::Rect< double > >::value_type const &

        """
        return _gippy.bbvector_append(self, *args, **kwargs)

    def empty(self):
        """
        empty(bbvector self) -> bool

        Parameters:
            self: std::vector< gip::Rect< double > > const *

        """
        return _gippy.bbvector_empty(self)

    def size(self):
        """
        size(bbvector self) -> std::vector< gip::Rect< double > >::size_type

        Parameters:
            self: std::vector< gip::Rect< double > > const *

        """
        return _gippy.bbvector_size(self)

    def clear(self):
        """
        clear(bbvector self)

        Parameters:
            self: std::vector< gip::Rect< double > > *

        """
        return _gippy.bbvector_clear(self)

    def swap(self, *args, **kwargs):
        """
        swap(bbvector self, bbvector v)

        Parameters:
            v: std::vector< gip::Rect< double > > &

        """
        return _gippy.bbvector_swap(self, *args, **kwargs)

    def get_allocator(self):
        """
        get_allocator(bbvector self) -> std::vector< gip::Rect< double > >::allocator_type

        Parameters:
            self: std::vector< gip::Rect< double > > const *

        """
        return _gippy.bbvector_get_allocator(self)

    def begin(self):
        """
        begin(bbvector self) -> std::vector< gip::Rect< double > >::iterator

        Parameters:
            self: std::vector< gip::Rect< double > > *

        """
        return _gippy.bbvector_begin(self)

    def end(self):
        """
        end(bbvector self) -> std::vector< gip::Rect< double > >::iterator

        Parameters:
            self: std::vector< gip::Rect< double > > *

        """
        return _gippy.bbvector_end(self)

    def rbegin(self):
        """
        rbegin(bbvector self) -> std::vector< gip::Rect< double > >::reverse_iterator

        Parameters:
            self: std::vector< gip::Rect< double > > *

        """
        return _gippy.bbvector_rbegin(self)

    def rend(self):
        """
        rend(bbvector self) -> std::vector< gip::Rect< double > >::reverse_iterator

        Parameters:
            self: std::vector< gip::Rect< double > > *

        """
        return _gippy.bbvector_rend(self)

    def pop_back(self):
        """
        pop_back(bbvector self)

        Parameters:
            self: std::vector< gip::Rect< double > > *

        """
        return _gippy.bbvector_pop_back(self)

    def erase(self, *args):
        """
        erase(bbvector self, std::vector< gip::Rect< double > >::iterator pos) -> std::vector< gip::Rect< double > >::iterator

        Parameters:
            pos: std::vector< gip::Rect< double > >::iterator

        erase(bbvector self, std::vector< gip::Rect< double > >::iterator first, std::vector< gip::Rect< double > >::iterator last) -> std::vector< gip::Rect< double > >::iterator

        Parameters:
            first: std::vector< gip::Rect< double > >::iterator
            last: std::vector< gip::Rect< double > >::iterator

        """
        return _gippy.bbvector_erase(self, *args)

    def __init__(self, *args): 
        """
        __init__(std::vector<(gip::Rect<(double)>)> self) -> bbvector
        __init__(std::vector<(gip::Rect<(double)>)> self, bbvector arg2) -> bbvector

        Parameters:
            arg2: std::vector< gip::Rect< double > > const &

        __init__(std::vector<(gip::Rect<(double)>)> self, std::vector< gip::Rect< double > >::size_type size) -> bbvector

        Parameters:
            size: std::vector< gip::Rect< double > >::size_type

        __init__(std::vector<(gip::Rect<(double)>)> self, std::vector< gip::Rect< double > >::size_type size, BoundingBox value) -> bbvector

        Parameters:
            size: std::vector< gip::Rect< double > >::size_type
            value: std::vector< gip::Rect< double > >::value_type const &

        """
        this = _gippy.new_bbvector(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args, **kwargs):
        """
        push_back(bbvector self, BoundingBox x)

        Parameters:
            x: std::vector< gip::Rect< double > >::value_type const &

        """
        return _gippy.bbvector_push_back(self, *args, **kwargs)

    def front(self):
        """
        front(bbvector self) -> BoundingBox

        Parameters:
            self: std::vector< gip::Rect< double > > const *

        """
        return _gippy.bbvector_front(self)

    def back(self):
        """
        back(bbvector self) -> BoundingBox

        Parameters:
            self: std::vector< gip::Rect< double > > const *

        """
        return _gippy.bbvector_back(self)

    def assign(self, *args, **kwargs):
        """
        assign(bbvector self, std::vector< gip::Rect< double > >::size_type n, BoundingBox x)

        Parameters:
            n: std::vector< gip::Rect< double > >::size_type
            x: std::vector< gip::Rect< double > >::value_type const &

        """
        return _gippy.bbvector_assign(self, *args, **kwargs)

    def resize(self, *args):
        """
        resize(bbvector self, std::vector< gip::Rect< double > >::size_type new_size)

        Parameters:
            new_size: std::vector< gip::Rect< double > >::size_type

        resize(bbvector self, std::vector< gip::Rect< double > >::size_type new_size, BoundingBox x)

        Parameters:
            new_size: std::vector< gip::Rect< double > >::size_type
            x: std::vector< gip::Rect< double > >::value_type const &

        """
        return _gippy.bbvector_resize(self, *args)

    def insert(self, *args):
        """
        insert(bbvector self, std::vector< gip::Rect< double > >::iterator pos, BoundingBox x) -> std::vector< gip::Rect< double > >::iterator

        Parameters:
            pos: std::vector< gip::Rect< double > >::iterator
            x: std::vector< gip::Rect< double > >::value_type const &

        insert(bbvector self, std::vector< gip::Rect< double > >::iterator pos, std::vector< gip::Rect< double > >::size_type n, 
            BoundingBox x)

        Parameters:
            pos: std::vector< gip::Rect< double > >::iterator
            n: std::vector< gip::Rect< double > >::size_type
            x: std::vector< gip::Rect< double > >::value_type const &

        """
        return _gippy.bbvector_insert(self, *args)

    def reserve(self, *args, **kwargs):
        """
        reserve(bbvector self, std::vector< gip::Rect< double > >::size_type n)

        Parameters:
            n: std::vector< gip::Rect< double > >::size_type

        """
        return _gippy.bbvector_reserve(self, *args, **kwargs)

    def capacity(self):
        """
        capacity(bbvector self) -> std::vector< gip::Rect< double > >::size_type

        Parameters:
            self: std::vector< gip::Rect< double > > const *

        """
        return _gippy.bbvector_capacity(self)

    __swig_destroy__ = _gippy.delete_bbvector
    __del__ = lambda self : None;
bbvector_swigregister = _gippy.bbvector_swigregister
bbvector_swigregister(bbvector)

class DataType(_object):
    """Proxy of C++ gip::DataType class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, DataType, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, DataType, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(gip::DataType self) -> DataType
        __init__(gip::DataType self, int dtype) -> DataType

        Parameters:
            dtype: int

        __init__(gip::DataType self, GDALDataType dtype) -> DataType

        Parameters:
            dtype: GDALDataType

        __init__(gip::DataType self, std::string dtype) -> DataType

        Parameters:
            dtype: std::string

        __init__(gip::DataType self, std::type_info const & info) -> DataType

        Parameters:
            info: std::type_info const &

        """
        this = _gippy.new_DataType(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _gippy.delete_DataType
    __del__ = lambda self : None;
    def type(self):
        """
        type(DataType self) -> int

        Parameters:
            self: gip::DataType *

        """
        return _gippy.DataType_type(self)

    def string(self):
        """
        string(DataType self) -> std::string

        Parameters:
            self: gip::DataType *

        """
        return _gippy.DataType_string(self)

    def maxval(self):
        """
        maxval(DataType self) -> double

        Parameters:
            self: gip::DataType const *

        """
        return _gippy.DataType_maxval(self)

    def minval(self):
        """
        minval(DataType self) -> double

        Parameters:
            self: gip::DataType const *

        """
        return _gippy.DataType_minval(self)

    def nodata(self):
        """
        nodata(DataType self) -> double

        Parameters:
            self: gip::DataType const *

        """
        return _gippy.DataType_nodata(self)

DataType_swigregister = _gippy.DataType_swigregister
DataType_swigregister(DataType)

class GeoResource(_object):
    """Proxy of C++ gip::GeoResource class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GeoResource, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GeoResource, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(gip::GeoResource self) -> GeoResource
        __init__(gip::GeoResource self, std::string filename, bool update=False, bool temp=False) -> GeoResource

        Parameters:
            filename: std::string
            update: bool
            temp: bool

        __init__(gip::GeoResource self, std::string arg2, int arg3, int arg4, int arg5, std::string arg6, BoundingBox arg7, 
            DataType arg8, std::string arg9, bool arg10, gip::dictionary arg11) -> GeoResource

        Parameters:
            arg2: std::string
            arg3: int
            arg4: int
            arg5: int
            arg6: std::string
            arg7: gip::BoundingBox
            arg8: gip::DataType
            arg9: std::string
            arg10: bool
            arg11: gip::dictionary

        __init__(gip::GeoResource self, GeoResource resource) -> GeoResource

        Parameters:
            resource: gip::GeoResource const &

        """
        this = _gippy.new_GeoResource(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _gippy.delete_GeoResource
    __del__ = lambda self : None;
    def filename(self):
        """
        filename(GeoResource self) -> std::string

        Parameters:
            self: gip::GeoResource const *

        """
        return _gippy.GeoResource_filename(self)

    def basename(self):
        """
        basename(GeoResource self) -> std::string

        Parameters:
            self: gip::GeoResource const *

        """
        return _gippy.GeoResource_basename(self)

    def extension(self):
        """
        extension(GeoResource self) -> std::string

        Parameters:
            self: gip::GeoResource const *

        """
        return _gippy.GeoResource_extension(self)

    def format(self):
        """
        format(GeoResource self) -> std::string

        Parameters:
            self: gip::GeoResource const *

        """
        return _gippy.GeoResource_format(self)

    def xsize(self):
        """
        xsize(GeoResource self) -> unsigned int

        Parameters:
            self: gip::GeoResource const *

        """
        return _gippy.GeoResource_xsize(self)

    def ysize(self):
        """
        ysize(GeoResource self) -> unsigned int

        Parameters:
            self: gip::GeoResource const *

        """
        return _gippy.GeoResource_ysize(self)

    def size(self):
        """
        size(GeoResource self) -> unsigned long

        Parameters:
            self: gip::GeoResource const *

        """
        return _gippy.GeoResource_size(self)

    def geoloc(self, *args, **kwargs):
        """
        geoloc(GeoResource self, float xloc, float yloc) -> dPoint

        Parameters:
            xloc: float
            yloc: float

        """
        return _gippy.GeoResource_geoloc(self, *args, **kwargs)

    def latlon(self, *args, **kwargs):
        """
        latlon(GeoResource self, float xloc, float yloc) -> dPoint

        Parameters:
            xloc: float
            yloc: float

        """
        return _gippy.GeoResource_latlon(self, *args, **kwargs)

    def minxy(self):
        """
        minxy(GeoResource self) -> dPoint

        Parameters:
            self: gip::GeoResource const *

        """
        return _gippy.GeoResource_minxy(self)

    def maxxy(self):
        """
        maxxy(GeoResource self) -> dPoint

        Parameters:
            self: gip::GeoResource const *

        """
        return _gippy.GeoResource_maxxy(self)

    def extent(self):
        """
        extent(GeoResource self) -> BoundingBox

        Parameters:
            self: gip::GeoResource const *

        """
        return _gippy.GeoResource_extent(self)

    def geo_extent(self):
        """
        geo_extent(GeoResource self) -> BoundingBox

        Parameters:
            self: gip::GeoResource const *

        """
        return _gippy.GeoResource_geo_extent(self)

    def srs(self):
        """
        srs(GeoResource self) -> std::string

        Parameters:
            self: gip::GeoResource const *

        """
        return _gippy.GeoResource_srs(self)

    def set_srs(self, *args, **kwargs):
        """
        set_srs(GeoResource self, std::string proj) -> GeoResource

        Parameters:
            proj: std::string

        """
        return _gippy.GeoResource_set_srs(self, *args, **kwargs)

    def affine(self):
        """
        affine(GeoResource self) -> CImg< double >

        Parameters:
            self: gip::GeoResource const *

        """
        return _gippy.GeoResource_affine(self)

    def set_affine(self, *args, **kwargs):
        """
        set_affine(GeoResource self, CImg< double > affine) -> GeoResource

        Parameters:
            affine: CImg< double >

        """
        return _gippy.GeoResource_set_affine(self, *args, **kwargs)

    def resolution(self):
        """
        resolution(GeoResource self) -> dPoint

        Parameters:
            self: gip::GeoResource const *

        """
        return _gippy.GeoResource_resolution(self)

    def chunks(self, padding=0, numchunks=0):
        """
        chunks(GeoResource self, unsigned int padding=0, unsigned int numchunks=0) -> chvector

        Parameters:
            padding: unsigned int
            numchunks: unsigned int

        """
        return _gippy.GeoResource_chunks(self, padding, numchunks)

    def meta(self, *args):
        """
        meta(GeoResource self, std::string key) -> std::string

        Parameters:
            key: std::string

        meta(GeoResource self) -> gip::dictionary

        Parameters:
            self: gip::GeoResource const *

        """
        return _gippy.GeoResource_meta(self, *args)

    def add_meta(self, *args):
        """
        add_meta(GeoResource self, std::string key, std::string item) -> GeoResource

        Parameters:
            key: std::string
            item: std::string

        add_meta(GeoResource self, gip::dictionary items) -> GeoResource

        Parameters:
            items: gip::dictionary

        """
        return _gippy.GeoResource_add_meta(self, *args)

GeoResource_swigregister = _gippy.GeoResource_swigregister
GeoResource_swigregister(GeoResource)

class GeoRaster(GeoResource):
    """Proxy of C++ gip::GeoRaster class"""
    __swig_setmethods__ = {}
    for _s in [GeoResource]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, GeoRaster, name, value)
    __swig_getmethods__ = {}
    for _s in [GeoResource]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, GeoRaster, name)
    __repr__ = _swig_repr
    def __init__(self, *args, **kwargs): 
        """
        __init__(gip::GeoRaster self, GeoRaster image) -> GeoRaster

        Parameters:
            image: gip::GeoRaster const &

        """
        this = _gippy.new_GeoRaster(*args, **kwargs)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _gippy.delete_GeoRaster
    __del__ = lambda self : None;
    def basename(self):
        """
        basename(GeoRaster self) -> std::string

        Parameters:
            self: gip::GeoRaster const *

        """
        return _gippy.GeoRaster_basename(self)

    def xsize(self):
        """
        xsize(GeoRaster self) -> unsigned int

        Parameters:
            self: gip::GeoRaster const *

        """
        return _gippy.GeoRaster_xsize(self)

    def ysize(self):
        """
        ysize(GeoRaster self) -> unsigned int

        Parameters:
            self: gip::GeoRaster const *

        """
        return _gippy.GeoRaster_ysize(self)

    def type(self):
        """
        type(GeoRaster self) -> DataType

        Parameters:
            self: gip::GeoRaster const *

        """
        return _gippy.GeoRaster_type(self)

    def info(self, showstats=False):
        """
        info(GeoRaster self, bool showstats=False) -> std::string

        Parameters:
            showstats: bool

        """
        return _gippy.GeoRaster_info(self, showstats)

    def description(self):
        """
        description(GeoRaster self) -> std::string

        Parameters:
            self: gip::GeoRaster const *

        """
        return _gippy.GeoRaster_description(self)

    def gain(self):
        """
        gain(GeoRaster self) -> double

        Parameters:
            self: gip::GeoRaster const *

        """
        return _gippy.GeoRaster_gain(self)

    def offset(self):
        """
        offset(GeoRaster self) -> double

        Parameters:
            self: gip::GeoRaster const *

        """
        return _gippy.GeoRaster_offset(self)

    def set_gain(self, *args, **kwargs):
        """
        set_gain(GeoRaster self, double gain) -> GeoRaster

        Parameters:
            gain: double

        """
        return _gippy.GeoRaster_set_gain(self, *args, **kwargs)

    def set_offset(self, *args, **kwargs):
        """
        set_offset(GeoRaster self, double offset) -> GeoRaster

        Parameters:
            offset: double

        """
        return _gippy.GeoRaster_set_offset(self, *args, **kwargs)

    def is_processed(self):
        """
        is_processed(GeoRaster self) -> bool

        Parameters:
            self: gip::GeoRaster const *

        """
        return _gippy.GeoRaster_is_processed(self)

    def clear_functions(self):
        """
        clear_functions(GeoRaster self) -> GeoRaster

        Parameters:
            self: gip::GeoRaster *

        """
        return _gippy.GeoRaster_clear_functions(self)

    def is_double(self):
        """
        is_double(GeoRaster self) -> bool

        Parameters:
            self: gip::GeoRaster const *

        """
        return _gippy.GeoRaster_is_double(self)

    def nodata(self):
        """
        nodata(GeoRaster self) -> double

        Parameters:
            self: gip::GeoRaster const *

        """
        return _gippy.GeoRaster_nodata(self)

    def set_nodata(self, *args, **kwargs):
        """
        set_nodata(GeoRaster self, double val) -> GeoRaster

        Parameters:
            val: double

        """
        return _gippy.GeoRaster_set_nodata(self, *args, **kwargs)

    def bandmeta(self, *args):
        """
        bandmeta(GeoRaster self, std::string key) -> std::string

        Parameters:
            key: std::string

        bandmeta(GeoRaster self) -> gip::dictionary

        Parameters:
            self: gip::GeoRaster const *

        """
        return _gippy.GeoRaster_bandmeta(self, *args)

    def add_bandmeta(self, *args):
        """
        add_bandmeta(GeoRaster self, std::string key, std::string item) -> GeoRaster

        Parameters:
            key: std::string
            item: std::string

        add_bandmeta(GeoRaster self, gip::dictionary items) -> GeoRaster

        Parameters:
            items: gip::dictionary

        """
        return _gippy.GeoRaster_add_bandmeta(self, *args)

    def set_color(self, *args, **kwargs):
        """
        set_color(GeoRaster self, std::string col) -> GeoRaster

        Parameters:
            col: std::string

        """
        return _gippy.GeoRaster_set_color(self, *args, **kwargs)

    def add_colortable(self, *args, **kwargs):
        """
        add_colortable(GeoRaster self, CImg< uint8_t > color1, CImg< uint8_t > color2, unsigned char value1=0, unsigned char value2=255) -> GeoRaster

        Parameters:
            color1: CImg< uint8_t >
            color2: CImg< uint8_t >
            value1: unsigned char
            value2: unsigned char

        """
        return _gippy.GeoRaster_add_colortable(self, *args, **kwargs)

    def clear_colortable(self):
        """
        clear_colortable(GeoRaster self) -> GeoRaster

        Parameters:
            self: gip::GeoRaster *

        """
        return _gippy.GeoRaster_clear_colortable(self)

    def saturation_mask(self, *args, **kwargs):
        """
        saturation_mask(GeoRaster self, float maxDC, Chunk chunk=gip::Chunk()) -> CImg< unsigned char >

        Parameters:
            maxDC: float
            chunk: gip::Chunk

        """
        return _gippy.GeoRaster_saturation_mask(self, *args, **kwargs)

    def add_mask(self, *args, **kwargs):
        """
        add_mask(GeoRaster self, GeoRaster band) -> GeoRaster

        Parameters:
            band: gip::GeoRaster const &

        """
        return _gippy.GeoRaster_add_mask(self, *args, **kwargs)

    def clear_masks(self):
        """
        clear_masks(GeoRaster self) -> GeoRaster

        Parameters:
            self: gip::GeoRaster const *

        """
        return _gippy.GeoRaster_clear_masks(self)

    def dilate(self, *args, **kwargs):
        """
        dilate(GeoRaster self, double const & w, double const & h) -> GeoRaster

        Parameters:
            w: double const &
            h: double const &

        """
        return _gippy.GeoRaster_dilate(self, *args, **kwargs)

    def erode(self, *args, **kwargs):
        """
        erode(GeoRaster self, double const & w, double const & h) -> GeoRaster

        Parameters:
            w: double const &
            h: double const &

        """
        return _gippy.GeoRaster_erode(self, *args, **kwargs)

    def skeletonize(self):
        """
        skeletonize(GeoRaster self) -> GeoRaster

        Parameters:
            self: gip::GeoRaster const *

        """
        return _gippy.GeoRaster_skeletonize(self)

    def __gt__(self, *args, **kwargs):
        """
        __gt__(GeoRaster self, double const & val) -> GeoRaster

        Parameters:
            val: double const &

        """
        return _gippy.GeoRaster___gt__(self, *args, **kwargs)

    def __ge__(self, *args, **kwargs):
        """
        __ge__(GeoRaster self, double const & val) -> GeoRaster

        Parameters:
            val: double const &

        """
        return _gippy.GeoRaster___ge__(self, *args, **kwargs)

    def __lt__(self, *args, **kwargs):
        """
        __lt__(GeoRaster self, double const & val) -> GeoRaster

        Parameters:
            val: double const &

        """
        return _gippy.GeoRaster___lt__(self, *args, **kwargs)

    def __le__(self, *args, **kwargs):
        """
        __le__(GeoRaster self, double const & val) -> GeoRaster

        Parameters:
            val: double const &

        """
        return _gippy.GeoRaster___le__(self, *args, **kwargs)

    def __eq__(self, *args, **kwargs):
        """
        __eq__(GeoRaster self, double const & val) -> GeoRaster

        Parameters:
            val: double const &

        """
        return _gippy.GeoRaster___eq__(self, *args, **kwargs)

    def bxor(self, *args, **kwargs):
        """
        bxor(GeoRaster self, double const val) -> GeoRaster

        Parameters:
            val: double const

        """
        return _gippy.GeoRaster_bxor(self, *args, **kwargs)

    def convolve(self, *args, **kwargs):
        """
        convolve(GeoRaster self, CImg< double > const kernel, bool const boundary=True, bool const nodata=False) -> GeoRaster

        Parameters:
            kernel: CImg< double > const
            boundary: bool const
            nodata: bool const

        """
        return _gippy.GeoRaster_convolve(self, *args, **kwargs)

    def laplacian(self):
        """
        laplacian(GeoRaster self) -> GeoRaster

        Parameters:
            self: gip::GeoRaster const *

        """
        return _gippy.GeoRaster_laplacian(self)

    def __add__(self, *args, **kwargs):
        """
        __add__(GeoRaster self, double const & val) -> GeoRaster

        Parameters:
            val: double const &

        """
        return _gippy.GeoRaster___add__(self, *args, **kwargs)

    def __sub__(self, *args, **kwargs):
        """
        __sub__(GeoRaster self, double const & val) -> GeoRaster

        Parameters:
            val: double const &

        """
        return _gippy.GeoRaster___sub__(self, *args, **kwargs)

    def __mul__(self, *args, **kwargs):
        """
        __mul__(GeoRaster self, double const & val) -> GeoRaster

        Parameters:
            val: double const &

        """
        return _gippy.GeoRaster___mul__(self, *args, **kwargs)

    def __div__(self, *args, **kwargs):
        """
        __div__(GeoRaster self, double const & val) -> GeoRaster

        Parameters:
            val: double const &

        """
        return _gippy.GeoRaster___div__(self, *args, **kwargs)

    def pow(self, *args, **kwargs):
        """
        pow(GeoRaster self, double const & val) -> GeoRaster

        Parameters:
            val: double const &

        """
        return _gippy.GeoRaster_pow(self, *args, **kwargs)

    def sqrt(self):
        """
        sqrt(GeoRaster self) -> GeoRaster

        Parameters:
            self: gip::GeoRaster const *

        """
        return _gippy.GeoRaster_sqrt(self)

    def log(self):
        """
        log(GeoRaster self) -> GeoRaster

        Parameters:
            self: gip::GeoRaster const *

        """
        return _gippy.GeoRaster_log(self)

    def log10(self):
        """
        log10(GeoRaster self) -> GeoRaster

        Parameters:
            self: gip::GeoRaster const *

        """
        return _gippy.GeoRaster_log10(self)

    def exp(self):
        """
        exp(GeoRaster self) -> GeoRaster

        Parameters:
            self: gip::GeoRaster const *

        """
        return _gippy.GeoRaster_exp(self)

    def abs(self):
        """
        abs(GeoRaster self) -> GeoRaster

        Parameters:
            self: gip::GeoRaster const *

        """
        return _gippy.GeoRaster_abs(self)

    def sign(self):
        """
        sign(GeoRaster self) -> GeoRaster

        Parameters:
            self: gip::GeoRaster const *

        """
        return _gippy.GeoRaster_sign(self)

    def cos(self):
        """
        cos(GeoRaster self) -> GeoRaster

        Parameters:
            self: gip::GeoRaster const *

        """
        return _gippy.GeoRaster_cos(self)

    def sin(self):
        """
        sin(GeoRaster self) -> GeoRaster

        Parameters:
            self: gip::GeoRaster const *

        """
        return _gippy.GeoRaster_sin(self)

    def tan(self):
        """
        tan(GeoRaster self) -> GeoRaster

        Parameters:
            self: gip::GeoRaster const *

        """
        return _gippy.GeoRaster_tan(self)

    def acos(self):
        """
        acos(GeoRaster self) -> GeoRaster

        Parameters:
            self: gip::GeoRaster const *

        """
        return _gippy.GeoRaster_acos(self)

    def asin(self):
        """
        asin(GeoRaster self) -> GeoRaster

        Parameters:
            self: gip::GeoRaster const *

        """
        return _gippy.GeoRaster_asin(self)

    def atan(self):
        """
        atan(GeoRaster self) -> GeoRaster

        Parameters:
            self: gip::GeoRaster const *

        """
        return _gippy.GeoRaster_atan(self)

    def cosh(self):
        """
        cosh(GeoRaster self) -> GeoRaster

        Parameters:
            self: gip::GeoRaster const *

        """
        return _gippy.GeoRaster_cosh(self)

    def sinh(self):
        """
        sinh(GeoRaster self) -> GeoRaster

        Parameters:
            self: gip::GeoRaster const *

        """
        return _gippy.GeoRaster_sinh(self)

    def tanh(self):
        """
        tanh(GeoRaster self) -> GeoRaster

        Parameters:
            self: gip::GeoRaster const *

        """
        return _gippy.GeoRaster_tanh(self)

    def sinc(self):
        """
        sinc(GeoRaster self) -> GeoRaster

        Parameters:
            self: gip::GeoRaster const *

        """
        return _gippy.GeoRaster_sinc(self)

    def stats(self):
        """
        stats(GeoRaster self) -> CImg< float >

        Parameters:
            self: gip::GeoRaster const *

        """
        return _gippy.GeoRaster_stats(self)

    def min(self, *args):
        """
        min(GeoRaster self, double const & val) -> GeoRaster

        Parameters:
            val: double const &

        min(GeoRaster self) -> double

        Parameters:
            self: gip::GeoRaster const *

        """
        return _gippy.GeoRaster_min(self, *args)

    def max(self, *args):
        """
        max(GeoRaster self, double const & val) -> GeoRaster

        Parameters:
            val: double const &

        max(GeoRaster self) -> double

        Parameters:
            self: gip::GeoRaster const *

        """
        return _gippy.GeoRaster_max(self, *args)

    def mean(self):
        """
        mean(GeoRaster self) -> double

        Parameters:
            self: gip::GeoRaster const *

        """
        return _gippy.GeoRaster_mean(self)

    def stddev(self):
        """
        stddev(GeoRaster self) -> double

        Parameters:
            self: gip::GeoRaster const *

        """
        return _gippy.GeoRaster_stddev(self)

    def histogram(self, bins=100, normalize=True, cumulative=False):
        """
        histogram(GeoRaster self, unsigned int bins=100, bool normalize=True, bool cumulative=False) -> CImg< double >

        Parameters:
            bins: unsigned int
            normalize: bool
            cumulative: bool

        """
        return _gippy.GeoRaster_histogram(self, bins, normalize, cumulative)

    def percentile(self, *args, **kwargs):
        """
        percentile(GeoRaster self, double const & p) -> double

        Parameters:
            p: double const &

        """
        return _gippy.GeoRaster_percentile(self, *args, **kwargs)

    def scale(self, *args, **kwargs):
        """
        scale(GeoRaster self, double const & minin, double const & maxin, double const & minout, double const & maxout) -> GeoRaster

        Parameters:
            minin: double const &
            maxin: double const &
            minout: double const &
            maxout: double const &

        """
        return _gippy.GeoRaster_scale(self, *args, **kwargs)

    def autoscale(self, *args, **kwargs):
        """
        autoscale(GeoRaster self, double const & minout, double const & maxout, double const & percent=0.0) -> GeoRaster

        Parameters:
            minout: double const &
            maxout: double const &
            percent: double const &

        """
        return _gippy.GeoRaster_autoscale(self, *args, **kwargs)

    def warp_into(self, *args, **kwargs):
        """
        warp_into(GeoRaster self, GeoRaster arg2, GeoFeature arg3=GeoFeature(), int arg4=0, bool arg5=False) -> GeoRaster

        Parameters:
            arg2: gip::GeoRaster &
            arg3: GeoFeature
            arg4: int
            arg5: bool

        """
        return _gippy.GeoRaster_warp_into(self, *args, **kwargs)

    def nodata_mask(self, *args, **kwargs):
        """
        nodata_mask(GeoRaster self, Chunk chunk=gip::Chunk()) -> CImg< unsigned char >

        Parameters:
            chunk: gip::Chunk

        """
        return _gippy.GeoRaster_nodata_mask(self, *args, **kwargs)

    def data_mask(self, *args, **kwargs):
        """
        data_mask(GeoRaster self, Chunk chunk=gip::Chunk()) -> CImg< unsigned char >

        Parameters:
            chunk: gip::Chunk

        """
        return _gippy.GeoRaster_data_mask(self, *args, **kwargs)

    def save(self, *args, **kwargs):
        """
        save(GeoRaster self, GeoRaster raster) -> GeoRaster

        Parameters:
            raster: gip::GeoRaster &

        """
        return _gippy.GeoRaster_save(self, *args, **kwargs)

    def read_raw(self, *args, **kwargs):
        """
        read_raw(GeoRaster self, Chunk chunk=gip::Chunk()) -> PyObject *

        Parameters:
            chunk: gip::Chunk

        """
        return _gippy.GeoRaster_read_raw(self, *args, **kwargs)

    def read(self, *args, **kwargs):
        """
        read(GeoRaster self, Chunk chunk=gip::Chunk()) -> PyObject *

        Parameters:
            chunk: gip::Chunk


        PyObject returned is a numpy.array.
        Enjoy!
         
        """
        return _gippy.GeoRaster_read(self, *args, **kwargs)

    def write(self, *args, **kwargs):
        """
        write(GeoRaster self, PyObject * obj, Chunk chunk=gip::Chunk()) -> GeoRaster

        Parameters:
            obj: PyObject *
            chunk: gip::Chunk


        PyObject passed in is a numpy.array.
        Comply!
         
        """
        return _gippy.GeoRaster_write(self, *args, **kwargs)

GeoRaster_swigregister = _gippy.GeoRaster_swigregister
GeoRaster_swigregister(GeoRaster)

class GeoImage(GeoResource):
    """Proxy of C++ gip::GeoImage class"""
    __swig_setmethods__ = {}
    for _s in [GeoResource]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, GeoImage, name, value)
    __swig_getmethods__ = {}
    for _s in [GeoResource]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, GeoImage, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(gip::GeoImage self) -> GeoImage
        __init__(gip::GeoImage self, std::string filename, bool update=False) -> GeoImage

        Parameters:
            filename: std::string
            update: bool

        __init__(gip::GeoImage self, svector filenames, bool update=False) -> GeoImage

        Parameters:
            filenames: std::vector< std::string,std::allocator< std::string > >
            update: bool

        __init__(gip::GeoImage self, std::string filename, int xsz, int ysz, int nb, std::string proj, BoundingBox bbox, 
            DataType dt, std::string format="", bool temp=False, gip::dictionary options=gip::dictionary()) -> GeoImage

        Parameters:
            filename: std::string
            xsz: int
            ysz: int
            nb: int
            proj: std::string
            bbox: gip::BoundingBox
            dt: gip::DataType
            format: std::string
            temp: bool
            options: gip::dictionary

        __init__(gip::GeoImage self, GeoImage image) -> GeoImage

        Parameters:
            image: gip::GeoImage const &

        """
        this = _gippy.new_GeoImage(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _gippy.delete_GeoImage
    __del__ = lambda self : None;
    def create(*args, **kwargs):
        """
        create(std::string filename="", unsigned int xsz=1, unsigned int ysz=1, unsigned int nb=1, 
            std::string proj="EPSG:4326", CImg< double > bbox=CImg< double >(4, 1, 1, 1, 0.0, 0.0, 1.0, 1.0), 
            std::string dtype="uint8", std::string format="", 
            bool temp=False, gip::dictionary options=gip::dictionary()) -> GeoImage

        Parameters:
            filename: std::string
            xsz: unsigned int
            ysz: unsigned int
            nb: unsigned int
            proj: std::string
            bbox: CImg< double >
            dtype: std::string
            format: std::string
            temp: bool
            options: gip::dictionary

        """
        return _gippy.GeoImage_create(*args, **kwargs)

    if _newclass:create = staticmethod(create)
    __swig_getmethods__["create"] = lambda x: create
    def create_from(*args, **kwargs):
        """
        create_from(GeoImage geoimg, std::string filename="", unsigned int nb=0, std::string dtype="unknown", 
            std::string format="", bool temp=False, gip::dictionary options=gip::dictionary()) -> GeoImage

        Parameters:
            geoimg: gip::GeoImage
            filename: std::string
            nb: unsigned int
            dtype: std::string
            format: std::string
            temp: bool
            options: gip::dictionary

        """
        return _gippy.GeoImage_create_from(*args, **kwargs)

    if _newclass:create_from = staticmethod(create_from)
    __swig_getmethods__["create_from"] = lambda x: create_from
    def open(*args, **kwargs):
        """
        open(svector filenames, bool update=True, float nodata=NAN, svector bandnames=std::vector< std::string >({}), 
            double gain=1.0, double offset=0.0) -> GeoImage

        Parameters:
            filenames: std::vector< std::string,std::allocator< std::string > >
            update: bool
            nodata: float
            bandnames: std::vector< std::string,std::allocator< std::string > >
            gain: double
            offset: double

        """
        return _gippy.GeoImage_open(*args, **kwargs)

    if _newclass:open = staticmethod(open)
    __swig_getmethods__["open"] = lambda x: open
    def filenames(self):
        """
        filenames(GeoImage self) -> svector

        Parameters:
            self: gip::GeoImage const *

        """
        return _gippy.GeoImage_filenames(self)

    def type(self):
        """
        type(GeoImage self) -> DataType

        Parameters:
            self: gip::GeoImage const *

        """
        return _gippy.GeoImage_type(self)

    def info(self, arg2=True, arg3=False):
        """
        info(GeoImage self, bool arg2=True, bool arg3=False) -> std::string

        Parameters:
            arg2: bool
            arg3: bool

        """
        return _gippy.GeoImage_info(self, arg2, arg3)

    def nbands(self):
        """
        nbands(GeoImage self) -> unsigned int

        Parameters:
            self: gip::GeoImage const *

        """
        return _gippy.GeoImage_nbands(self)

    def bandnames(self):
        """
        bandnames(GeoImage self) -> svector

        Parameters:
            self: gip::GeoImage const *

        """
        return _gippy.GeoImage_bandnames(self)

    def set_bandname(self, *args, **kwargs):
        """
        set_bandname(GeoImage self, std::string bandname, int bandnum) -> GeoImage

        Parameters:
            bandname: std::string
            bandnum: int

        """
        return _gippy.GeoImage_set_bandname(self, *args, **kwargs)

    def set_bandnames(self, *args, **kwargs):
        """
        set_bandnames(GeoImage self, svector names) -> GeoImage

        Parameters:
            names: std::vector< std::string,std::allocator< std::string > >

        """
        return _gippy.GeoImage_set_bandnames(self, *args, **kwargs)

    def band_exists(self, *args, **kwargs):
        """
        band_exists(GeoImage self, std::string bandname) -> bool

        Parameters:
            bandname: std::string

        """
        return _gippy.GeoImage_band_exists(self, *args, **kwargs)

    def bands_exist(self, *args, **kwargs):
        """
        bands_exist(GeoImage self, svector bnames) -> bool

        Parameters:
            bnames: std::vector< std::string,std::allocator< std::string > >

        """
        return _gippy.GeoImage_bands_exist(self, *args, **kwargs)

    def add_band(self, *args, **kwargs):
        """
        add_band(GeoImage self, GeoRaster band) -> GeoImage

        Parameters:
            band: gip::GeoRaster

        """
        return _gippy.GeoImage_add_band(self, *args, **kwargs)

    def add_bands(self, *args, **kwargs):
        """
        add_bands(GeoImage self, GeoImage img) -> GeoImage

        Parameters:
            img: gip::GeoImage

        """
        return _gippy.GeoImage_add_bands(self, *args, **kwargs)

    def select(self, *args):
        """
        select(GeoImage self, svector names) -> GeoImage

        Parameters:
            names: std::vector< std::string,std::allocator< std::string > >

        select(GeoImage self, ivector nums) -> GeoImage

        Parameters:
            nums: std::vector< int,std::allocator< int > >

        """
        return _gippy.GeoImage_select(self, *args)

    def set_gain(self, *args, **kwargs):
        """
        set_gain(GeoImage self, double gain) -> GeoImage

        Parameters:
            gain: double

        """
        return _gippy.GeoImage_set_gain(self, *args, **kwargs)

    def set_offset(self, *args, **kwargs):
        """
        set_offset(GeoImage self, double offset) -> GeoImage

        Parameters:
            offset: double

        """
        return _gippy.GeoImage_set_offset(self, *args, **kwargs)

    def set_nodata(self, *args, **kwargs):
        """
        set_nodata(GeoImage self, double val) -> GeoImage

        Parameters:
            val: double

        """
        return _gippy.GeoImage_set_nodata(self, *args, **kwargs)

    def autoscale(self, *args, **kwargs):
        """
        autoscale(GeoImage self, double const & minout, double const & maxout, double const & percent=0.0) -> GeoImage

        Parameters:
            minout: double const &
            maxout: double const &
            percent: double const &

        """
        return _gippy.GeoImage_autoscale(self, *args, **kwargs)

    def spectral_covariance(self):
        """
        spectral_covariance(GeoImage self) -> CImg< double >

        Parameters:
            self: gip::GeoImage const *

        """
        return _gippy.GeoImage_spectral_covariance(self)

    def spectral_statistics(self, *args, **kwargs):
        """
        spectral_statistics(GeoImage self, Chunk chunk=gip::Chunk()) -> CImg< double >

        Parameters:
            chunk: gip::Chunk

        """
        return _gippy.GeoImage_spectral_statistics(self, *args, **kwargs)

    def add_overviews(self, *args, **kwargs):
        """
        add_overviews(GeoImage self, ivector levels=std::vector< int >({2, 4, 8}), std::string resampler="NEAREST") -> GeoImage

        Parameters:
            levels: std::vector< int,std::allocator< int > >
            resampler: std::string

        """
        return _gippy.GeoImage_add_overviews(self, *args, **kwargs)

    def add_mask(self, *args, **kwargs):
        """
        add_mask(GeoImage self, GeoRaster band) -> GeoImage

        Parameters:
            band: gip::GeoRaster const &

        """
        return _gippy.GeoImage_add_mask(self, *args, **kwargs)

    def clear_masks(self):
        """
        clear_masks(GeoImage self) -> GeoImage

        Parameters:
            self: gip::GeoImage *

        """
        return _gippy.GeoImage_clear_masks(self)

    def nodata_mask(self, *args):
        """
        nodata_mask(GeoImage self, svector bands, Chunk chunk=gip::Chunk()) -> CImg< uint8_t >

        Parameters:
            bands: std::vector< std::string,std::allocator< std::string > >
            chunk: gip::Chunk

        nodata_mask(GeoImage self, Chunk chunk=gip::Chunk()) -> CImg< uint8_t >

        Parameters:
            chunk: gip::Chunk

        """
        return _gippy.GeoImage_nodata_mask(self, *args)

    def data_mask(self, *args):
        """
        data_mask(GeoImage self, svector bands, Chunk chunk=gip::Chunk()) -> CImg< unsigned char >

        Parameters:
            bands: std::vector< std::string,std::allocator< std::string > >
            chunk: gip::Chunk

        data_mask(GeoImage self, Chunk chunk=gip::Chunk()) -> CImg< unsigned char >

        Parameters:
            chunk: gip::Chunk

        """
        return _gippy.GeoImage_data_mask(self, *args)

    def saturation_mask(self, *args):
        """
        saturation_mask(GeoImage self, svector bands, float maxDC, Chunk chunk=gip::Chunk()) -> CImg< unsigned char >

        Parameters:
            bands: std::vector< std::string,std::allocator< std::string > >
            maxDC: float
            chunk: gip::Chunk

        saturation_mask(GeoImage self, float maxDC, Chunk chunk=gip::Chunk()) -> CImg< unsigned char >

        Parameters:
            maxDC: float
            chunk: gip::Chunk

        """
        return _gippy.GeoImage_saturation_mask(self, *args)

    def whiteness(self, *args, **kwargs):
        """
        whiteness(GeoImage self, Chunk chunk=gip::Chunk()) -> CImg< float >

        Parameters:
            chunk: gip::Chunk

        """
        return _gippy.GeoImage_whiteness(self, *args, **kwargs)

    def warp(self, *args, **kwargs):
        """
        warp(GeoImage self, std::string filename="", GeoFeature feature=GeoFeature(), bool crop=False, std::string proj="EPSG:4326", 
            float xres=1.0, float yres=1.0, int interpolation=0) -> GeoImage

        Parameters:
            filename: std::string
            feature: GeoFeature
            crop: bool
            proj: std::string
            xres: float
            yres: float
            interpolation: int

        """
        return _gippy.GeoImage_warp(self, *args, **kwargs)

    def warp_into(self, *args, **kwargs):
        """
        warp_into(GeoImage self, GeoImage arg2, GeoFeature arg3=GeoFeature(), int arg4=0, bool arg5=False) -> GeoImage

        Parameters:
            arg2: gip::GeoImage &
            arg3: GeoFeature
            arg4: int
            arg5: bool

        """
        return _gippy.GeoImage_warp_into(self, *args, **kwargs)

    def __getitem__(self, *args):
        """
        __getitem__(GeoImage self, std::string col) -> GeoRaster

        Parameters:
            col: std::string

        __getitem__(GeoImage self, int band) -> GeoRaster

        Parameters:
            band: int

        """
        return _gippy.GeoImage___getitem__(self, *args)

    def __setitem__(self, *args):
        """
        __setitem__(GeoImage self, int band, GeoRaster raster) -> GeoRaster

        Parameters:
            band: int
            raster: gip::GeoRaster const &

        __setitem__(GeoImage self, std::string col, GeoRaster raster) -> GeoRaster

        Parameters:
            col: std::string
            raster: gip::GeoRaster const &

        """
        return _gippy.GeoImage___setitem__(self, *args)

    def __len__(self):
        """
        __len__(GeoImage self) -> unsigned long

        Parameters:
            self: gip::GeoImage *

        """
        return _gippy.GeoImage___len__(self)

    def __deepcopy__(self, *args, **kwargs):
        """
        __deepcopy__(GeoImage self, GeoImage image) -> GeoImage

        Parameters:
            image: gip::GeoImage

        """
        return _gippy.GeoImage___deepcopy__(self, *args, **kwargs)

    def save(self, *args, **kwargs):
        """
        save(GeoImage self, std::string filename="", std::string dtype="", float nodata=NAN, std::string format="", 
            bool temp=False, bool overviews=False, gip::dictionary options=gip::dictionary()) -> GeoImage

        Parameters:
            filename: std::string
            dtype: std::string
            nodata: float
            format: std::string
            temp: bool
            overviews: bool
            options: gip::dictionary

        """
        return _gippy.GeoImage_save(self, *args, **kwargs)

    def read_random_pixels(self, *args, **kwargs):
        """
        read_random_pixels(GeoImage self, int num_pixels) -> PyObject *

        Parameters:
            num_pixels: int

        """
        return _gippy.GeoImage_read_random_pixels(self, *args, **kwargs)

    def extract_classes(self, *args, **kwargs):
        """
        extract_classes(GeoImage self, GeoRaster raster) -> PyObject *

        Parameters:
            raster: gip::GeoRaster

        """
        return _gippy.GeoImage_extract_classes(self, *args, **kwargs)

    def read(self, *args, **kwargs):
        """
        read(GeoImage self, Chunk chunk=gip::Chunk()) -> PyObject *

        Parameters:
            chunk: gip::Chunk

        """
        return _gippy.GeoImage_read(self, *args, **kwargs)

    def write(self, *args, **kwargs):
        """
        write(GeoImage self, PyObject * obj, Chunk chunk=gip::Chunk()) -> GeoImage

        Parameters:
            obj: PyObject *
            chunk: gip::Chunk

        """
        return _gippy.GeoImage_write(self, *args, **kwargs)

GeoImage_swigregister = _gippy.GeoImage_swigregister
GeoImage_swigregister(GeoImage)

def GeoImage_create(*args, **kwargs):
  """
    GeoImage_create(std::string filename="", unsigned int xsz=1, unsigned int ysz=1, unsigned int nb=1, 
        std::string proj="EPSG:4326", CImg< double > bbox=CImg< double >(4, 1, 1, 1, 0.0, 0.0, 1.0, 1.0), 
        std::string dtype="uint8", std::string format="", 
        bool temp=False, gip::dictionary options=gip::dictionary()) -> GeoImage

    Parameters:
        filename: std::string
        xsz: unsigned int
        ysz: unsigned int
        nb: unsigned int
        proj: std::string
        bbox: CImg< double >
        dtype: std::string
        format: std::string
        temp: bool
        options: gip::dictionary

    """
  return _gippy.GeoImage_create(*args, **kwargs)

def GeoImage_create_from(*args, **kwargs):
  """
    GeoImage_create_from(GeoImage geoimg, std::string filename="", unsigned int nb=0, std::string dtype="unknown", 
        std::string format="", bool temp=False, gip::dictionary options=gip::dictionary()) -> GeoImage

    Parameters:
        geoimg: gip::GeoImage
        filename: std::string
        nb: unsigned int
        dtype: std::string
        format: std::string
        temp: bool
        options: gip::dictionary

    """
  return _gippy.GeoImage_create_from(*args, **kwargs)

def GeoImage_open(*args, **kwargs):
  """
    GeoImage_open(svector filenames, bool update=True, float nodata=NAN, svector bandnames=std::vector< std::string >({}), 
        double gain=1.0, double offset=0.0) -> GeoImage

    Parameters:
        filenames: std::vector< std::string,std::allocator< std::string > >
        update: bool
        nodata: float
        bandnames: std::vector< std::string,std::allocator< std::string > >
        gain: double
        offset: double

    """
  return _gippy.GeoImage_open(*args, **kwargs)

class vector_GeoImage(_object):
    """Proxy of C++ std::vector<(gip::GeoImage)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, vector_GeoImage, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, vector_GeoImage, name)
    __repr__ = _swig_repr
    def iterator(self):
        """
        iterator(vector_GeoImage self) -> SwigPyIterator

        Parameters:
            self: std::vector< gip::GeoImage > *

        """
        return _gippy.vector_GeoImage_iterator(self)

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

        Parameters:
            self: std::vector< gip::GeoImage > const *

        """
        return _gippy.vector_GeoImage___nonzero__(self)

    def __bool__(self):
        """
        __bool__(vector_GeoImage self) -> bool

        Parameters:
            self: std::vector< gip::GeoImage > const *

        """
        return _gippy.vector_GeoImage___bool__(self)

    def __len__(self):
        """
        __len__(vector_GeoImage self) -> std::vector< gip::GeoImage >::size_type

        Parameters:
            self: std::vector< gip::GeoImage > const *

        """
        return _gippy.vector_GeoImage___len__(self)

    def pop(self):
        """
        pop(vector_GeoImage self) -> GeoImage

        Parameters:
            self: std::vector< gip::GeoImage > *

        """
        return _gippy.vector_GeoImage_pop(self)

    def __getslice__(self, *args, **kwargs):
        """
        __getslice__(vector_GeoImage self, std::vector< gip::GeoImage >::difference_type i, std::vector< gip::GeoImage >::difference_type j) -> vector_GeoImage

        Parameters:
            i: std::vector< gip::GeoImage >::difference_type
            j: std::vector< gip::GeoImage >::difference_type

        """
        return _gippy.vector_GeoImage___getslice__(self, *args, **kwargs)

    def __setslice__(self, *args, **kwargs):
        """
        __setslice__(vector_GeoImage self, std::vector< gip::GeoImage >::difference_type i, std::vector< gip::GeoImage >::difference_type j, 
            vector_GeoImage v=std::vector< gip::GeoImage,std::allocator< gip::GeoImage > >())

        Parameters:
            i: std::vector< gip::GeoImage >::difference_type
            j: std::vector< gip::GeoImage >::difference_type
            v: std::vector< gip::GeoImage,std::allocator< gip::GeoImage > > const &

        """
        return _gippy.vector_GeoImage___setslice__(self, *args, **kwargs)

    def __delslice__(self, *args, **kwargs):
        """
        __delslice__(vector_GeoImage self, std::vector< gip::GeoImage >::difference_type i, std::vector< gip::GeoImage >::difference_type j)

        Parameters:
            i: std::vector< gip::GeoImage >::difference_type
            j: std::vector< gip::GeoImage >::difference_type

        """
        return _gippy.vector_GeoImage___delslice__(self, *args, **kwargs)

    def __delitem__(self, *args):
        """
        __delitem__(vector_GeoImage self, std::vector< gip::GeoImage >::difference_type i)

        Parameters:
            i: std::vector< gip::GeoImage >::difference_type

        __delitem__(vector_GeoImage self, PySliceObject * slice)

        Parameters:
            slice: PySliceObject *

        """
        return _gippy.vector_GeoImage___delitem__(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(vector_GeoImage self, PySliceObject * slice) -> vector_GeoImage

        Parameters:
            slice: PySliceObject *

        __getitem__(vector_GeoImage self, std::vector< gip::GeoImage >::difference_type i) -> GeoImage

        Parameters:
            i: std::vector< gip::GeoImage >::difference_type

        """
        return _gippy.vector_GeoImage___getitem__(self, *args)

    def __setitem__(self, *args):
        """
        __setitem__(vector_GeoImage self, PySliceObject * slice, vector_GeoImage v)

        Parameters:
            slice: PySliceObject *
            v: std::vector< gip::GeoImage,std::allocator< gip::GeoImage > > const &

        __setitem__(vector_GeoImage self, PySliceObject * slice)

        Parameters:
            slice: PySliceObject *

        __setitem__(vector_GeoImage self, std::vector< gip::GeoImage >::difference_type i, GeoImage x)

        Parameters:
            i: std::vector< gip::GeoImage >::difference_type
            x: std::vector< gip::GeoImage >::value_type const &

        """
        return _gippy.vector_GeoImage___setitem__(self, *args)

    def append(self, *args, **kwargs):
        """
        append(vector_GeoImage self, GeoImage x)

        Parameters:
            x: std::vector< gip::GeoImage >::value_type const &

        """
        return _gippy.vector_GeoImage_append(self, *args, **kwargs)

    def empty(self):
        """
        empty(vector_GeoImage self) -> bool

        Parameters:
            self: std::vector< gip::GeoImage > const *

        """
        return _gippy.vector_GeoImage_empty(self)

    def size(self):
        """
        size(vector_GeoImage self) -> std::vector< gip::GeoImage >::size_type

        Parameters:
            self: std::vector< gip::GeoImage > const *

        """
        return _gippy.vector_GeoImage_size(self)

    def clear(self):
        """
        clear(vector_GeoImage self)

        Parameters:
            self: std::vector< gip::GeoImage > *

        """
        return _gippy.vector_GeoImage_clear(self)

    def swap(self, *args, **kwargs):
        """
        swap(vector_GeoImage self, vector_GeoImage v)

        Parameters:
            v: std::vector< gip::GeoImage > &

        """
        return _gippy.vector_GeoImage_swap(self, *args, **kwargs)

    def get_allocator(self):
        """
        get_allocator(vector_GeoImage self) -> std::vector< gip::GeoImage >::allocator_type

        Parameters:
            self: std::vector< gip::GeoImage > const *

        """
        return _gippy.vector_GeoImage_get_allocator(self)

    def begin(self):
        """
        begin(vector_GeoImage self) -> std::vector< gip::GeoImage >::iterator

        Parameters:
            self: std::vector< gip::GeoImage > *

        """
        return _gippy.vector_GeoImage_begin(self)

    def end(self):
        """
        end(vector_GeoImage self) -> std::vector< gip::GeoImage >::iterator

        Parameters:
            self: std::vector< gip::GeoImage > *

        """
        return _gippy.vector_GeoImage_end(self)

    def rbegin(self):
        """
        rbegin(vector_GeoImage self) -> std::vector< gip::GeoImage >::reverse_iterator

        Parameters:
            self: std::vector< gip::GeoImage > *

        """
        return _gippy.vector_GeoImage_rbegin(self)

    def rend(self):
        """
        rend(vector_GeoImage self) -> std::vector< gip::GeoImage >::reverse_iterator

        Parameters:
            self: std::vector< gip::GeoImage > *

        """
        return _gippy.vector_GeoImage_rend(self)

    def pop_back(self):
        """
        pop_back(vector_GeoImage self)

        Parameters:
            self: std::vector< gip::GeoImage > *

        """
        return _gippy.vector_GeoImage_pop_back(self)

    def erase(self, *args):
        """
        erase(vector_GeoImage self, std::vector< gip::GeoImage >::iterator pos) -> std::vector< gip::GeoImage >::iterator

        Parameters:
            pos: std::vector< gip::GeoImage >::iterator

        erase(vector_GeoImage self, std::vector< gip::GeoImage >::iterator first, std::vector< gip::GeoImage >::iterator last) -> std::vector< gip::GeoImage >::iterator

        Parameters:
            first: std::vector< gip::GeoImage >::iterator
            last: std::vector< gip::GeoImage >::iterator

        """
        return _gippy.vector_GeoImage_erase(self, *args)

    def __init__(self, *args): 
        """
        __init__(std::vector<(gip::GeoImage)> self) -> vector_GeoImage
        __init__(std::vector<(gip::GeoImage)> self, vector_GeoImage arg2) -> vector_GeoImage

        Parameters:
            arg2: std::vector< gip::GeoImage > const &

        __init__(std::vector<(gip::GeoImage)> self, std::vector< gip::GeoImage >::size_type size) -> vector_GeoImage

        Parameters:
            size: std::vector< gip::GeoImage >::size_type

        __init__(std::vector<(gip::GeoImage)> self, std::vector< gip::GeoImage >::size_type size, GeoImage value) -> vector_GeoImage

        Parameters:
            size: std::vector< gip::GeoImage >::size_type
            value: std::vector< gip::GeoImage >::value_type const &

        """
        this = _gippy.new_vector_GeoImage(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args, **kwargs):
        """
        push_back(vector_GeoImage self, GeoImage x)

        Parameters:
            x: std::vector< gip::GeoImage >::value_type const &

        """
        return _gippy.vector_GeoImage_push_back(self, *args, **kwargs)

    def front(self):
        """
        front(vector_GeoImage self) -> GeoImage

        Parameters:
            self: std::vector< gip::GeoImage > const *

        """
        return _gippy.vector_GeoImage_front(self)

    def back(self):
        """
        back(vector_GeoImage self) -> GeoImage

        Parameters:
            self: std::vector< gip::GeoImage > const *

        """
        return _gippy.vector_GeoImage_back(self)

    def assign(self, *args, **kwargs):
        """
        assign(vector_GeoImage self, std::vector< gip::GeoImage >::size_type n, GeoImage x)

        Parameters:
            n: std::vector< gip::GeoImage >::size_type
            x: std::vector< gip::GeoImage >::value_type const &

        """
        return _gippy.vector_GeoImage_assign(self, *args, **kwargs)

    def resize(self, *args):
        """
        resize(vector_GeoImage self, std::vector< gip::GeoImage >::size_type new_size)

        Parameters:
            new_size: std::vector< gip::GeoImage >::size_type

        resize(vector_GeoImage self, std::vector< gip::GeoImage >::size_type new_size, GeoImage x)

        Parameters:
            new_size: std::vector< gip::GeoImage >::size_type
            x: std::vector< gip::GeoImage >::value_type const &

        """
        return _gippy.vector_GeoImage_resize(self, *args)

    def insert(self, *args):
        """
        insert(vector_GeoImage self, std::vector< gip::GeoImage >::iterator pos, GeoImage x) -> std::vector< gip::GeoImage >::iterator

        Parameters:
            pos: std::vector< gip::GeoImage >::iterator
            x: std::vector< gip::GeoImage >::value_type const &

        insert(vector_GeoImage self, std::vector< gip::GeoImage >::iterator pos, std::vector< gip::GeoImage >::size_type n, 
            GeoImage x)

        Parameters:
            pos: std::vector< gip::GeoImage >::iterator
            n: std::vector< gip::GeoImage >::size_type
            x: std::vector< gip::GeoImage >::value_type const &

        """
        return _gippy.vector_GeoImage_insert(self, *args)

    def reserve(self, *args, **kwargs):
        """
        reserve(vector_GeoImage self, std::vector< gip::GeoImage >::size_type n)

        Parameters:
            n: std::vector< gip::GeoImage >::size_type

        """
        return _gippy.vector_GeoImage_reserve(self, *args, **kwargs)

    def capacity(self):
        """
        capacity(vector_GeoImage self) -> std::vector< gip::GeoImage >::size_type

        Parameters:
            self: std::vector< gip::GeoImage > const *

        """
        return _gippy.vector_GeoImage_capacity(self)

    __swig_destroy__ = _gippy.delete_vector_GeoImage
    __del__ = lambda self : None;
vector_GeoImage_swigregister = _gippy.vector_GeoImage_swigregister
vector_GeoImage_swigregister(vector_GeoImage)

class GeoVectorResource(_object):
    """Proxy of C++ gip::GeoVectorResource class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GeoVectorResource, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GeoVectorResource, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(gip::GeoVectorResource self) -> GeoVectorResource
        __init__(gip::GeoVectorResource self, std::string arg2, std::string layer="") -> GeoVectorResource

        Parameters:
            arg2: std::string
            layer: std::string

        __init__(gip::GeoVectorResource self, GeoVectorResource vector) -> GeoVectorResource

        Parameters:
            vector: gip::GeoVectorResource const &

        """
        this = _gippy.new_GeoVectorResource(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _gippy.delete_GeoVectorResource
    __del__ = lambda self : None;
    def filename(self):
        """
        filename(GeoVectorResource self) -> std::string

        Parameters:
            self: gip::GeoVectorResource const *

        """
        return _gippy.GeoVectorResource_filename(self)

    def basename(self):
        """
        basename(GeoVectorResource self) -> std::string

        Parameters:
            self: gip::GeoVectorResource const *

        """
        return _gippy.GeoVectorResource_basename(self)

    def layer_name(self):
        """
        layer_name(GeoVectorResource self) -> std::string

        Parameters:
            self: gip::GeoVectorResource const *

        """
        return _gippy.GeoVectorResource_layer_name(self)

    def srs(self):
        """
        srs(GeoVectorResource self) -> std::string

        Parameters:
            self: gip::GeoVectorResource const *

        """
        return _gippy.GeoVectorResource_srs(self)

    def extent(self):
        """
        extent(GeoVectorResource self) -> BoundingBox

        Parameters:
            self: gip::GeoVectorResource const *

        """
        return _gippy.GeoVectorResource_extent(self)

    def nfeatures(self):
        """
        nfeatures(GeoVectorResource self) -> unsigned long

        Parameters:
            self: gip::GeoVectorResource const *

        """
        return _gippy.GeoVectorResource_nfeatures(self)

    def primary_key(self):
        """
        primary_key(GeoVectorResource self) -> std::string

        Parameters:
            self: gip::GeoVectorResource const *

        """
        return _gippy.GeoVectorResource_primary_key(self)

    def attributes(self):
        """
        attributes(GeoVectorResource self) -> svector

        Parameters:
            self: gip::GeoVectorResource const *

        """
        return _gippy.GeoVectorResource_attributes(self)

    def __len__(self):
        """
        __len__(GeoVectorResource self) -> unsigned long

        Parameters:
            self: gip::GeoVectorResource *

        """
        return _gippy.GeoVectorResource___len__(self)

GeoVectorResource_swigregister = _gippy.GeoVectorResource_swigregister
GeoVectorResource_swigregister(GeoVectorResource)

class GeoFeature(GeoVectorResource):
    """Proxy of C++ gip::GeoFeature class"""
    __swig_setmethods__ = {}
    for _s in [GeoVectorResource]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, GeoFeature, name, value)
    __swig_getmethods__ = {}
    for _s in [GeoVectorResource]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, GeoFeature, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(gip::GeoFeature self) -> GeoFeature
        __init__(gip::GeoFeature self, std::string filename, std::string layer, long fid) -> GeoFeature

        Parameters:
            filename: std::string
            layer: std::string
            fid: long

        __init__(gip::GeoFeature self, GeoVectorResource vector, long fid) -> GeoFeature

        Parameters:
            vector: gip::GeoVectorResource const &
            fid: long

        __init__(gip::GeoFeature self, GeoVectorResource vector, OGRFeature * feature) -> GeoFeature

        Parameters:
            vector: gip::GeoVectorResource const &
            feature: OGRFeature *

        __init__(gip::GeoFeature self, GeoFeature feature) -> GeoFeature

        Parameters:
            feature: gip::GeoFeature const &

        """
        this = _gippy.new_GeoFeature(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _gippy.delete_GeoFeature
    __del__ = lambda self : None;
    def valid(self):
        """
        valid(GeoFeature self) -> bool

        Parameters:
            self: gip::GeoFeature const *

        """
        return _gippy.GeoFeature_valid(self)

    def value(self):
        """
        value(GeoFeature self) -> std::string

        Parameters:
            self: gip::GeoFeature const *

        """
        return _gippy.GeoFeature_value(self)

    def basename(self):
        """
        basename(GeoFeature self) -> std::string

        Parameters:
            self: gip::GeoFeature const *

        """
        return _gippy.GeoFeature_basename(self)

    def extent(self):
        """
        extent(GeoFeature self) -> BoundingBox

        Parameters:
            self: gip::GeoFeature const *

        """
        return _gippy.GeoFeature_extent(self)

    def geometry(self):
        """
        geometry(GeoFeature self) -> std::string

        Parameters:
            self: gip::GeoFeature const *

        """
        return _gippy.GeoFeature_geometry(self)

    def wkt_geometry(self):
        """
        wkt_geometry(GeoFeature self) -> std::string

        Parameters:
            self: gip::GeoFeature const *

        """
        return _gippy.GeoFeature_wkt_geometry(self)

    def json_geometry(self):
        """
        json_geometry(GeoFeature self) -> std::string

        Parameters:
            self: gip::GeoFeature const *

        """
        return _gippy.GeoFeature_json_geometry(self)

    def ogr_geometry(self, srs=None):
        """
        ogr_geometry(GeoFeature self, OGRSpatialReference * srs=None) -> OGRGeometry *

        Parameters:
            srs: OGRSpatialReference *

        """
        return _gippy.GeoFeature_ogr_geometry(self, srs)

    def fid(self):
        """
        fid(GeoFeature self) -> long

        Parameters:
            self: gip::GeoFeature const *

        """
        return _gippy.GeoFeature_fid(self)

    def __deepcopy__(self, *args, **kwargs):
        """
        __deepcopy__(GeoFeature self, GeoFeature feature) -> GeoFeature

        Parameters:
            feature: gip::GeoFeature

        """
        return _gippy.GeoFeature___deepcopy__(self, *args, **kwargs)

    def __getitem__(self, *args, **kwargs):
        """
        __getitem__(GeoFeature self, std::string att) -> std::string

        Parameters:
            att: std::string

        """
        return _gippy.GeoFeature___getitem__(self, *args, **kwargs)

GeoFeature_swigregister = _gippy.GeoFeature_swigregister
GeoFeature_swigregister(GeoFeature)

class vector_GeoFeature(_object):
    """Proxy of C++ std::vector<(gip::GeoFeature)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, vector_GeoFeature, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, vector_GeoFeature, name)
    __repr__ = _swig_repr
    def iterator(self):
        """
        iterator(vector_GeoFeature self) -> SwigPyIterator

        Parameters:
            self: std::vector< gip::GeoFeature > *

        """
        return _gippy.vector_GeoFeature_iterator(self)

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

        Parameters:
            self: std::vector< gip::GeoFeature > const *

        """
        return _gippy.vector_GeoFeature___nonzero__(self)

    def __bool__(self):
        """
        __bool__(vector_GeoFeature self) -> bool

        Parameters:
            self: std::vector< gip::GeoFeature > const *

        """
        return _gippy.vector_GeoFeature___bool__(self)

    def __len__(self):
        """
        __len__(vector_GeoFeature self) -> std::vector< gip::GeoFeature >::size_type

        Parameters:
            self: std::vector< gip::GeoFeature > const *

        """
        return _gippy.vector_GeoFeature___len__(self)

    def pop(self):
        """
        pop(vector_GeoFeature self) -> GeoFeature

        Parameters:
            self: std::vector< gip::GeoFeature > *

        """
        return _gippy.vector_GeoFeature_pop(self)

    def __getslice__(self, *args, **kwargs):
        """
        __getslice__(vector_GeoFeature self, std::vector< gip::GeoFeature >::difference_type i, std::vector< gip::GeoFeature >::difference_type j) -> vector_GeoFeature

        Parameters:
            i: std::vector< gip::GeoFeature >::difference_type
            j: std::vector< gip::GeoFeature >::difference_type

        """
        return _gippy.vector_GeoFeature___getslice__(self, *args, **kwargs)

    def __setslice__(self, *args, **kwargs):
        """
        __setslice__(vector_GeoFeature self, std::vector< gip::GeoFeature >::difference_type i, std::vector< gip::GeoFeature >::difference_type j, 
            vector_GeoFeature v=std::vector< gip::GeoFeature,std::allocator< gip::GeoFeature > >())

        Parameters:
            i: std::vector< gip::GeoFeature >::difference_type
            j: std::vector< gip::GeoFeature >::difference_type
            v: std::vector< gip::GeoFeature,std::allocator< gip::GeoFeature > > const &

        """
        return _gippy.vector_GeoFeature___setslice__(self, *args, **kwargs)

    def __delslice__(self, *args, **kwargs):
        """
        __delslice__(vector_GeoFeature self, std::vector< gip::GeoFeature >::difference_type i, std::vector< gip::GeoFeature >::difference_type j)

        Parameters:
            i: std::vector< gip::GeoFeature >::difference_type
            j: std::vector< gip::GeoFeature >::difference_type

        """
        return _gippy.vector_GeoFeature___delslice__(self, *args, **kwargs)

    def __delitem__(self, *args):
        """
        __delitem__(vector_GeoFeature self, std::vector< gip::GeoFeature >::difference_type i)

        Parameters:
            i: std::vector< gip::GeoFeature >::difference_type

        __delitem__(vector_GeoFeature self, PySliceObject * slice)

        Parameters:
            slice: PySliceObject *

        """
        return _gippy.vector_GeoFeature___delitem__(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(vector_GeoFeature self, PySliceObject * slice) -> vector_GeoFeature

        Parameters:
            slice: PySliceObject *

        __getitem__(vector_GeoFeature self, std::vector< gip::GeoFeature >::difference_type i) -> GeoFeature

        Parameters:
            i: std::vector< gip::GeoFeature >::difference_type

        """
        return _gippy.vector_GeoFeature___getitem__(self, *args)

    def __setitem__(self, *args):
        """
        __setitem__(vector_GeoFeature self, PySliceObject * slice, vector_GeoFeature v)

        Parameters:
            slice: PySliceObject *
            v: std::vector< gip::GeoFeature,std::allocator< gip::GeoFeature > > const &

        __setitem__(vector_GeoFeature self, PySliceObject * slice)

        Parameters:
            slice: PySliceObject *

        __setitem__(vector_GeoFeature self, std::vector< gip::GeoFeature >::difference_type i, GeoFeature x)

        Parameters:
            i: std::vector< gip::GeoFeature >::difference_type
            x: std::vector< gip::GeoFeature >::value_type const &

        """
        return _gippy.vector_GeoFeature___setitem__(self, *args)

    def append(self, *args, **kwargs):
        """
        append(vector_GeoFeature self, GeoFeature x)

        Parameters:
            x: std::vector< gip::GeoFeature >::value_type const &

        """
        return _gippy.vector_GeoFeature_append(self, *args, **kwargs)

    def empty(self):
        """
        empty(vector_GeoFeature self) -> bool

        Parameters:
            self: std::vector< gip::GeoFeature > const *

        """
        return _gippy.vector_GeoFeature_empty(self)

    def size(self):
        """
        size(vector_GeoFeature self) -> std::vector< gip::GeoFeature >::size_type

        Parameters:
            self: std::vector< gip::GeoFeature > const *

        """
        return _gippy.vector_GeoFeature_size(self)

    def clear(self):
        """
        clear(vector_GeoFeature self)

        Parameters:
            self: std::vector< gip::GeoFeature > *

        """
        return _gippy.vector_GeoFeature_clear(self)

    def swap(self, *args, **kwargs):
        """
        swap(vector_GeoFeature self, vector_GeoFeature v)

        Parameters:
            v: std::vector< gip::GeoFeature > &

        """
        return _gippy.vector_GeoFeature_swap(self, *args, **kwargs)

    def get_allocator(self):
        """
        get_allocator(vector_GeoFeature self) -> std::vector< gip::GeoFeature >::allocator_type

        Parameters:
            self: std::vector< gip::GeoFeature > const *

        """
        return _gippy.vector_GeoFeature_get_allocator(self)

    def begin(self):
        """
        begin(vector_GeoFeature self) -> std::vector< gip::GeoFeature >::iterator

        Parameters:
            self: std::vector< gip::GeoFeature > *

        """
        return _gippy.vector_GeoFeature_begin(self)

    def end(self):
        """
        end(vector_GeoFeature self) -> std::vector< gip::GeoFeature >::iterator

        Parameters:
            self: std::vector< gip::GeoFeature > *

        """
        return _gippy.vector_GeoFeature_end(self)

    def rbegin(self):
        """
        rbegin(vector_GeoFeature self) -> std::vector< gip::GeoFeature >::reverse_iterator

        Parameters:
            self: std::vector< gip::GeoFeature > *

        """
        return _gippy.vector_GeoFeature_rbegin(self)

    def rend(self):
        """
        rend(vector_GeoFeature self) -> std::vector< gip::GeoFeature >::reverse_iterator

        Parameters:
            self: std::vector< gip::GeoFeature > *

        """
        return _gippy.vector_GeoFeature_rend(self)

    def pop_back(self):
        """
        pop_back(vector_GeoFeature self)

        Parameters:
            self: std::vector< gip::GeoFeature > *

        """
        return _gippy.vector_GeoFeature_pop_back(self)

    def erase(self, *args):
        """
        erase(vector_GeoFeature self, std::vector< gip::GeoFeature >::iterator pos) -> std::vector< gip::GeoFeature >::iterator

        Parameters:
            pos: std::vector< gip::GeoFeature >::iterator

        erase(vector_GeoFeature self, std::vector< gip::GeoFeature >::iterator first, std::vector< gip::GeoFeature >::iterator last) -> std::vector< gip::GeoFeature >::iterator

        Parameters:
            first: std::vector< gip::GeoFeature >::iterator
            last: std::vector< gip::GeoFeature >::iterator

        """
        return _gippy.vector_GeoFeature_erase(self, *args)

    def __init__(self, *args): 
        """
        __init__(std::vector<(gip::GeoFeature)> self) -> vector_GeoFeature
        __init__(std::vector<(gip::GeoFeature)> self, vector_GeoFeature arg2) -> vector_GeoFeature

        Parameters:
            arg2: std::vector< gip::GeoFeature > const &

        __init__(std::vector<(gip::GeoFeature)> self, std::vector< gip::GeoFeature >::size_type size) -> vector_GeoFeature

        Parameters:
            size: std::vector< gip::GeoFeature >::size_type

        __init__(std::vector<(gip::GeoFeature)> self, std::vector< gip::GeoFeature >::size_type size, GeoFeature value) -> vector_GeoFeature

        Parameters:
            size: std::vector< gip::GeoFeature >::size_type
            value: std::vector< gip::GeoFeature >::value_type const &

        """
        this = _gippy.new_vector_GeoFeature(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args, **kwargs):
        """
        push_back(vector_GeoFeature self, GeoFeature x)

        Parameters:
            x: std::vector< gip::GeoFeature >::value_type const &

        """
        return _gippy.vector_GeoFeature_push_back(self, *args, **kwargs)

    def front(self):
        """
        front(vector_GeoFeature self) -> GeoFeature

        Parameters:
            self: std::vector< gip::GeoFeature > const *

        """
        return _gippy.vector_GeoFeature_front(self)

    def back(self):
        """
        back(vector_GeoFeature self) -> GeoFeature

        Parameters:
            self: std::vector< gip::GeoFeature > const *

        """
        return _gippy.vector_GeoFeature_back(self)

    def assign(self, *args, **kwargs):
        """
        assign(vector_GeoFeature self, std::vector< gip::GeoFeature >::size_type n, GeoFeature x)

        Parameters:
            n: std::vector< gip::GeoFeature >::size_type
            x: std::vector< gip::GeoFeature >::value_type const &

        """
        return _gippy.vector_GeoFeature_assign(self, *args, **kwargs)

    def resize(self, *args):
        """
        resize(vector_GeoFeature self, std::vector< gip::GeoFeature >::size_type new_size)

        Parameters:
            new_size: std::vector< gip::GeoFeature >::size_type

        resize(vector_GeoFeature self, std::vector< gip::GeoFeature >::size_type new_size, GeoFeature x)

        Parameters:
            new_size: std::vector< gip::GeoFeature >::size_type
            x: std::vector< gip::GeoFeature >::value_type const &

        """
        return _gippy.vector_GeoFeature_resize(self, *args)

    def insert(self, *args):
        """
        insert(vector_GeoFeature self, std::vector< gip::GeoFeature >::iterator pos, GeoFeature x) -> std::vector< gip::GeoFeature >::iterator

        Parameters:
            pos: std::vector< gip::GeoFeature >::iterator
            x: std::vector< gip::GeoFeature >::value_type const &

        insert(vector_GeoFeature self, std::vector< gip::GeoFeature >::iterator pos, std::vector< gip::GeoFeature >::size_type n, 
            GeoFeature x)

        Parameters:
            pos: std::vector< gip::GeoFeature >::iterator
            n: std::vector< gip::GeoFeature >::size_type
            x: std::vector< gip::GeoFeature >::value_type const &

        """
        return _gippy.vector_GeoFeature_insert(self, *args)

    def reserve(self, *args, **kwargs):
        """
        reserve(vector_GeoFeature self, std::vector< gip::GeoFeature >::size_type n)

        Parameters:
            n: std::vector< gip::GeoFeature >::size_type

        """
        return _gippy.vector_GeoFeature_reserve(self, *args, **kwargs)

    def capacity(self):
        """
        capacity(vector_GeoFeature self) -> std::vector< gip::GeoFeature >::size_type

        Parameters:
            self: std::vector< gip::GeoFeature > const *

        """
        return _gippy.vector_GeoFeature_capacity(self)

    __swig_destroy__ = _gippy.delete_vector_GeoFeature
    __del__ = lambda self : None;
vector_GeoFeature_swigregister = _gippy.vector_GeoFeature_swigregister
vector_GeoFeature_swigregister(vector_GeoFeature)

class GeoVector(GeoVectorResource):
    """Proxy of C++ gip::GeoVector class"""
    __swig_setmethods__ = {}
    for _s in [GeoVectorResource]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, GeoVector, name, value)
    __swig_getmethods__ = {}
    for _s in [GeoVectorResource]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, GeoVector, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(gip::GeoVector self) -> GeoVector
        __init__(gip::GeoVector self, std::string filename, std::string layer="") -> GeoVector

        Parameters:
            filename: std::string
            layer: std::string

        __init__(gip::GeoVector self, GeoVector vector) -> GeoVector

        Parameters:
            vector: gip::GeoVector const &

        """
        this = _gippy.new_GeoVector(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _gippy.delete_GeoVector
    __del__ = lambda self : None;
    def set_primary_key(self, key=""):
        """
        set_primary_key(GeoVector self, std::string key="")

        Parameters:
            key: std::string

        """
        return _gippy.GeoVector_set_primary_key(self, key)

    def values(self, *args, **kwargs):
        """
        values(GeoVector self, std::string attr) -> svector

        Parameters:
            attr: std::string

        """
        return _gippy.GeoVector_values(self, *args, **kwargs)

    def where(self, *args):
        """
        where(GeoVector self, std::string attr, std::string val) -> vector_GeoFeature

        Parameters:
            attr: std::string
            val: std::string

        where(GeoVector self, std::string sql) -> vector_GeoFeature

        Parameters:
            sql: std::string

        """
        return _gippy.GeoVector_where(self, *args)

    def intersections(self, *args, **kwargs):
        """
        intersections(GeoVector self, GeoFeature feat) -> std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > >

        Parameters:
            feat: gip::GeoFeature

        """
        return _gippy.GeoVector_intersections(self, *args, **kwargs)

    def __getitem__(self, *args):
        """
        __getitem__(GeoVector self, int index) -> GeoFeature

        Parameters:
            index: int

        __getitem__(GeoVector self, std::string val) -> GeoFeature

        Parameters:
            val: std::string

        """
        return _gippy.GeoVector___getitem__(self, *args)

    def __deepcopy__(self, *args, **kwargs):
        """
        __deepcopy__(GeoVector self, GeoVector vector) -> GeoVector

        Parameters:
            vector: gip::GeoVector

        """
        return _gippy.GeoVector___deepcopy__(self, *args, **kwargs)

GeoVector_swigregister = _gippy.GeoVector_swigregister
GeoVector_swigregister(GeoVector)

# This file is compatible with both classic and new-style classes.


