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





from sys import version_info as _swig_python_version_info
if _swig_python_version_info >= (2, 7, 0):
    def swig_import_helper():
        import importlib
        pkg = __name__.rpartition('.')[0]
        mname = '.'.join((pkg, '_Volume')).lstrip('.')
        try:
            return importlib.import_module(mname)
        except ImportError:
            return importlib.import_module('_Volume')
    _Volume = swig_import_helper()
    del swig_import_helper
elif _swig_python_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('_Volume', [dirname(__file__)])
        except ImportError:
            import _Volume
            return _Volume
        if fp is not None:
            try:
                _mod = imp.load_module('_Volume', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _Volume = swig_import_helper()
    del swig_import_helper
else:
    import _Volume
del _swig_python_version_info
try:
    _swig_property = property
except NameError:
    pass  # Python < 2.2 doesn't have 'property'.

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

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):
        if _newclass:
            object.__setattr__(self, name, value)
        else:
            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("'%s' object has no attribute '%s'" % (class_type.__name__, name))


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

try:
    _object = object
    _newclass = 1
except __builtin__.Exception:
    class _object:
        pass
    _newclass = 0

try:
    import weakref
    weakref_proxy = weakref.proxy
except __builtin__.Exception:
    weakref_proxy = lambda x: x


import VPLSwig.Core.Core
import VPLSwig.Image.Image
import VPLSwig.Core.Geometry
class CVolumeView(_object):
    """Proxy of C++ vpl::img::CVolumeView class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CVolumeView, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CVolumeView, name)
    __repr__ = _swig_repr
    CLASS_VOLUME_VIEW = _Volume.CVolumeView_CLASS_VOLUME_VIEW

    def __init__(self):
        """__init__(self) -> CVolumeView"""
        this = _Volume.new_CVolumeView()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _Volume.delete_CVolumeView
    __del__ = lambda self: None
CVolumeView_swigregister = _Volume.CVolumeView_swigregister
CVolumeView_swigregister(CVolumeView)

class swig_base_Volume8(_object):
    """Proxy of C++ vpl::img::CVolumeBase<(vpl::img::CVolume<(vpl::img::tPixel8,vpl::base::CPartedData)>)> class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, swig_base_Volume8, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, swig_base_Volume8, name)

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

    def getImpl(self, *args):
        """
        getImpl(self) -> CVolume8
        getImpl(self) -> CVolume8
        """
        return _Volume.swig_base_Volume8_getImpl(self, *args)


    def getSize(self, *args):
        """
        getSize(self) -> CSize3_int
        getSize(self) -> CSize3_int
        """
        return _Volume.swig_base_Volume8_getSize(self, *args)


    def getXSize(self):
        """getXSize(self) -> vpl::tSize"""
        return _Volume.swig_base_Volume8_getXSize(self)


    def getYSize(self):
        """getYSize(self) -> vpl::tSize"""
        return _Volume.swig_base_Volume8_getYSize(self)


    def getZSize(self):
        """getZSize(self) -> vpl::tSize"""
        return _Volume.swig_base_Volume8_getZSize(self)


    def width(self):
        """width(self) -> vpl::tSize"""
        return _Volume.swig_base_Volume8_width(self)


    def height(self):
        """height(self) -> vpl::tSize"""
        return _Volume.swig_base_Volume8_height(self)


    def depth(self):
        """depth(self) -> vpl::tSize"""
        return _Volume.swig_base_Volume8_depth(self)


    def getXOffset(self):
        """getXOffset(self) -> vpl::tSize"""
        return _Volume.swig_base_Volume8_getXOffset(self)


    def getYOffset(self):
        """getYOffset(self) -> vpl::tSize"""
        return _Volume.swig_base_Volume8_getYOffset(self)


    def getZOffset(self):
        """getZOffset(self) -> vpl::tSize"""
        return _Volume.swig_base_Volume8_getZOffset(self)


    def getMargin(self):
        """getMargin(self) -> vpl::tSize"""
        return _Volume.swig_base_Volume8_getMargin(self)


    def getIdx(self, x, y, z):
        """getIdx(self, x, y, z) -> vpl::tSize"""
        return _Volume.swig_base_Volume8_getIdx(self, x, y, z)


    def __call__(self, *args):
        """
        __call__(self, x, y, z) -> vpl::img::CVolumeBase< vpl::img::CVolume< unsigned __int8,vpl::base::CPartedData > >::tVoxel
        __call__(self, x, y, z) -> vpl::img::CVolumeBase< vpl::img::CVolume< unsigned __int8,vpl::base::CPartedData > >::tVoxel const
        __call__(self, i) -> vpl::img::CVolumeBase< vpl::img::CVolume< unsigned __int8,vpl::base::CPartedData > >::tVoxel
        __call__(self, i) -> vpl::img::CVolumeBase< vpl::img::CVolume< unsigned __int8,vpl::base::CPartedData > >::tVoxel const &
        """
        return _Volume.swig_base_Volume8___call__(self, *args)


    def at(self, *args):
        """
        at(self, x, y, z) -> vpl::img::CVolumeBase< vpl::img::CVolume< unsigned __int8,vpl::base::CPartedData > >::tVoxel
        at(self, x, y, z) -> vpl::img::CVolumeBase< vpl::img::CVolume< unsigned __int8,vpl::base::CPartedData > >::tVoxel const
        at(self, i) -> vpl::img::CVolumeBase< vpl::img::CVolume< unsigned __int8,vpl::base::CPartedData > >::tVoxel
        at(self, i) -> vpl::img::CVolumeBase< vpl::img::CVolume< unsigned __int8,vpl::base::CPartedData > >::tVoxel const &
        """
        return _Volume.swig_base_Volume8_at(self, *args)


    def set(self, *args):
        """
        set(self, x, y, z, Value) -> CVolume8
        set(self, i, Value) -> CVolume8
        """
        return _Volume.swig_base_Volume8_set(self, *args)

    __swig_destroy__ = _Volume.delete_swig_base_Volume8
    __del__ = lambda self: None
swig_base_Volume8_swigregister = _Volume.swig_base_Volume8_swigregister
swig_base_Volume8_swigregister(swig_base_Volume8)

class swig_base_Volume16(_object):
    """Proxy of C++ vpl::img::CVolumeBase<(vpl::img::CVolume<(vpl::img::tPixel16,vpl::base::CPartedData)>)> class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, swig_base_Volume16, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, swig_base_Volume16, name)

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

    def getImpl(self, *args):
        """
        getImpl(self) -> CVolume16
        getImpl(self) -> CVolume16
        """
        return _Volume.swig_base_Volume16_getImpl(self, *args)


    def getSize(self, *args):
        """
        getSize(self) -> CSize3_int
        getSize(self) -> CSize3_int
        """
        return _Volume.swig_base_Volume16_getSize(self, *args)


    def getXSize(self):
        """getXSize(self) -> vpl::tSize"""
        return _Volume.swig_base_Volume16_getXSize(self)


    def getYSize(self):
        """getYSize(self) -> vpl::tSize"""
        return _Volume.swig_base_Volume16_getYSize(self)


    def getZSize(self):
        """getZSize(self) -> vpl::tSize"""
        return _Volume.swig_base_Volume16_getZSize(self)


    def width(self):
        """width(self) -> vpl::tSize"""
        return _Volume.swig_base_Volume16_width(self)


    def height(self):
        """height(self) -> vpl::tSize"""
        return _Volume.swig_base_Volume16_height(self)


    def depth(self):
        """depth(self) -> vpl::tSize"""
        return _Volume.swig_base_Volume16_depth(self)


    def getXOffset(self):
        """getXOffset(self) -> vpl::tSize"""
        return _Volume.swig_base_Volume16_getXOffset(self)


    def getYOffset(self):
        """getYOffset(self) -> vpl::tSize"""
        return _Volume.swig_base_Volume16_getYOffset(self)


    def getZOffset(self):
        """getZOffset(self) -> vpl::tSize"""
        return _Volume.swig_base_Volume16_getZOffset(self)


    def getMargin(self):
        """getMargin(self) -> vpl::tSize"""
        return _Volume.swig_base_Volume16_getMargin(self)


    def getIdx(self, x, y, z):
        """getIdx(self, x, y, z) -> vpl::tSize"""
        return _Volume.swig_base_Volume16_getIdx(self, x, y, z)


    def __call__(self, *args):
        """
        __call__(self, x, y, z) -> vpl::img::CVolumeBase< vpl::img::CVolume< unsigned __int16,vpl::base::CPartedData > >::tVoxel
        __call__(self, x, y, z) -> vpl::img::CVolumeBase< vpl::img::CVolume< unsigned __int16,vpl::base::CPartedData > >::tVoxel const
        __call__(self, i) -> vpl::img::CVolumeBase< vpl::img::CVolume< unsigned __int16,vpl::base::CPartedData > >::tVoxel
        __call__(self, i) -> vpl::img::CVolumeBase< vpl::img::CVolume< unsigned __int16,vpl::base::CPartedData > >::tVoxel const &
        """
        return _Volume.swig_base_Volume16___call__(self, *args)


    def at(self, *args):
        """
        at(self, x, y, z) -> vpl::img::CVolumeBase< vpl::img::CVolume< unsigned __int16,vpl::base::CPartedData > >::tVoxel
        at(self, x, y, z) -> vpl::img::CVolumeBase< vpl::img::CVolume< unsigned __int16,vpl::base::CPartedData > >::tVoxel const
        at(self, i) -> vpl::img::CVolumeBase< vpl::img::CVolume< unsigned __int16,vpl::base::CPartedData > >::tVoxel
        at(self, i) -> vpl::img::CVolumeBase< vpl::img::CVolume< unsigned __int16,vpl::base::CPartedData > >::tVoxel const &
        """
        return _Volume.swig_base_Volume16_at(self, *args)


    def set(self, *args):
        """
        set(self, x, y, z, Value) -> CVolume16
        set(self, i, Value) -> CVolume16
        """
        return _Volume.swig_base_Volume16_set(self, *args)

    __swig_destroy__ = _Volume.delete_swig_base_Volume16
    __del__ = lambda self: None
swig_base_Volume16_swigregister = _Volume.swig_base_Volume16_swigregister
swig_base_Volume16_swigregister(swig_base_Volume16)

class swig_base_Volume32(_object):
    """Proxy of C++ vpl::img::CVolumeBase<(vpl::img::CVolume<(vpl::img::tPixel32,vpl::base::CPartedData)>)> class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, swig_base_Volume32, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, swig_base_Volume32, name)

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

    def getImpl(self, *args):
        """
        getImpl(self) -> CVolume32
        getImpl(self) -> CVolume32
        """
        return _Volume.swig_base_Volume32_getImpl(self, *args)


    def getSize(self, *args):
        """
        getSize(self) -> CSize3_int
        getSize(self) -> CSize3_int
        """
        return _Volume.swig_base_Volume32_getSize(self, *args)


    def getXSize(self):
        """getXSize(self) -> vpl::tSize"""
        return _Volume.swig_base_Volume32_getXSize(self)


    def getYSize(self):
        """getYSize(self) -> vpl::tSize"""
        return _Volume.swig_base_Volume32_getYSize(self)


    def getZSize(self):
        """getZSize(self) -> vpl::tSize"""
        return _Volume.swig_base_Volume32_getZSize(self)


    def width(self):
        """width(self) -> vpl::tSize"""
        return _Volume.swig_base_Volume32_width(self)


    def height(self):
        """height(self) -> vpl::tSize"""
        return _Volume.swig_base_Volume32_height(self)


    def depth(self):
        """depth(self) -> vpl::tSize"""
        return _Volume.swig_base_Volume32_depth(self)


    def getXOffset(self):
        """getXOffset(self) -> vpl::tSize"""
        return _Volume.swig_base_Volume32_getXOffset(self)


    def getYOffset(self):
        """getYOffset(self) -> vpl::tSize"""
        return _Volume.swig_base_Volume32_getYOffset(self)


    def getZOffset(self):
        """getZOffset(self) -> vpl::tSize"""
        return _Volume.swig_base_Volume32_getZOffset(self)


    def getMargin(self):
        """getMargin(self) -> vpl::tSize"""
        return _Volume.swig_base_Volume32_getMargin(self)


    def getIdx(self, x, y, z):
        """getIdx(self, x, y, z) -> vpl::tSize"""
        return _Volume.swig_base_Volume32_getIdx(self, x, y, z)


    def __call__(self, *args):
        """
        __call__(self, x, y, z) -> vpl::img::CVolumeBase< vpl::img::CVolume< unsigned __int32,vpl::base::CPartedData > >::tVoxel
        __call__(self, x, y, z) -> vpl::img::CVolumeBase< vpl::img::CVolume< unsigned __int32,vpl::base::CPartedData > >::tVoxel const
        __call__(self, i) -> vpl::img::CVolumeBase< vpl::img::CVolume< unsigned __int32,vpl::base::CPartedData > >::tVoxel
        __call__(self, i) -> vpl::img::CVolumeBase< vpl::img::CVolume< unsigned __int32,vpl::base::CPartedData > >::tVoxel const &
        """
        return _Volume.swig_base_Volume32___call__(self, *args)


    def at(self, *args):
        """
        at(self, x, y, z) -> vpl::img::CVolumeBase< vpl::img::CVolume< unsigned __int32,vpl::base::CPartedData > >::tVoxel
        at(self, x, y, z) -> vpl::img::CVolumeBase< vpl::img::CVolume< unsigned __int32,vpl::base::CPartedData > >::tVoxel const
        at(self, i) -> vpl::img::CVolumeBase< vpl::img::CVolume< unsigned __int32,vpl::base::CPartedData > >::tVoxel
        at(self, i) -> vpl::img::CVolumeBase< vpl::img::CVolume< unsigned __int32,vpl::base::CPartedData > >::tVoxel const &
        """
        return _Volume.swig_base_Volume32_at(self, *args)


    def set(self, *args):
        """
        set(self, x, y, z, Value) -> CVolume32
        set(self, i, Value) -> CVolume32
        """
        return _Volume.swig_base_Volume32_set(self, *args)

    __swig_destroy__ = _Volume.delete_swig_base_Volume32
    __del__ = lambda self: None
swig_base_Volume32_swigregister = _Volume.swig_base_Volume32_swigregister
swig_base_Volume32_swigregister(swig_base_Volume32)

class swig_base_FVolume(_object):
    """Proxy of C++ vpl::img::CVolumeBase<(vpl::img::CVolume<(vpl::img::tFloatPixel,vpl::base::CPartedData)>)> class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, swig_base_FVolume, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, swig_base_FVolume, name)

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

    def getImpl(self, *args):
        """
        getImpl(self) -> CFVolume
        getImpl(self) -> CFVolume
        """
        return _Volume.swig_base_FVolume_getImpl(self, *args)


    def getSize(self, *args):
        """
        getSize(self) -> CSize3_int
        getSize(self) -> CSize3_int
        """
        return _Volume.swig_base_FVolume_getSize(self, *args)


    def getXSize(self):
        """getXSize(self) -> vpl::tSize"""
        return _Volume.swig_base_FVolume_getXSize(self)


    def getYSize(self):
        """getYSize(self) -> vpl::tSize"""
        return _Volume.swig_base_FVolume_getYSize(self)


    def getZSize(self):
        """getZSize(self) -> vpl::tSize"""
        return _Volume.swig_base_FVolume_getZSize(self)


    def width(self):
        """width(self) -> vpl::tSize"""
        return _Volume.swig_base_FVolume_width(self)


    def height(self):
        """height(self) -> vpl::tSize"""
        return _Volume.swig_base_FVolume_height(self)


    def depth(self):
        """depth(self) -> vpl::tSize"""
        return _Volume.swig_base_FVolume_depth(self)


    def getXOffset(self):
        """getXOffset(self) -> vpl::tSize"""
        return _Volume.swig_base_FVolume_getXOffset(self)


    def getYOffset(self):
        """getYOffset(self) -> vpl::tSize"""
        return _Volume.swig_base_FVolume_getYOffset(self)


    def getZOffset(self):
        """getZOffset(self) -> vpl::tSize"""
        return _Volume.swig_base_FVolume_getZOffset(self)


    def getMargin(self):
        """getMargin(self) -> vpl::tSize"""
        return _Volume.swig_base_FVolume_getMargin(self)


    def getIdx(self, x, y, z):
        """getIdx(self, x, y, z) -> vpl::tSize"""
        return _Volume.swig_base_FVolume_getIdx(self, x, y, z)


    def __call__(self, *args):
        """
        __call__(self, x, y, z) -> vpl::img::CVolumeBase< vpl::img::CVolume< float,vpl::base::CPartedData > >::tVoxel
        __call__(self, x, y, z) -> vpl::img::CVolumeBase< vpl::img::CVolume< float,vpl::base::CPartedData > >::tVoxel const
        __call__(self, i) -> vpl::img::CVolumeBase< vpl::img::CVolume< float,vpl::base::CPartedData > >::tVoxel
        __call__(self, i) -> vpl::img::CVolumeBase< vpl::img::CVolume< float,vpl::base::CPartedData > >::tVoxel const &
        """
        return _Volume.swig_base_FVolume___call__(self, *args)


    def at(self, *args):
        """
        at(self, x, y, z) -> vpl::img::CVolumeBase< vpl::img::CVolume< float,vpl::base::CPartedData > >::tVoxel
        at(self, x, y, z) -> vpl::img::CVolumeBase< vpl::img::CVolume< float,vpl::base::CPartedData > >::tVoxel const
        at(self, i) -> vpl::img::CVolumeBase< vpl::img::CVolume< float,vpl::base::CPartedData > >::tVoxel
        at(self, i) -> vpl::img::CVolumeBase< vpl::img::CVolume< float,vpl::base::CPartedData > >::tVoxel const &
        """
        return _Volume.swig_base_FVolume_at(self, *args)


    def set(self, *args):
        """
        set(self, x, y, z, Value) -> CFVolume
        set(self, i, Value) -> CFVolume
        """
        return _Volume.swig_base_FVolume_set(self, *args)

    __swig_destroy__ = _Volume.delete_swig_base_FVolume
    __del__ = lambda self: None
swig_base_FVolume_swigregister = _Volume.swig_base_FVolume_swigregister
swig_base_FVolume_swigregister(swig_base_FVolume)

class swig_base_DVolume(_object):
    """Proxy of C++ vpl::img::CVolumeBase<(vpl::img::CVolume<(vpl::img::tDensityPixel,vpl::base::CPartedData)>)> class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, swig_base_DVolume, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, swig_base_DVolume, name)

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

    def getImpl(self, *args):
        """
        getImpl(self) -> CDVolume
        getImpl(self) -> CDVolume
        """
        return _Volume.swig_base_DVolume_getImpl(self, *args)


    def getSize(self, *args):
        """
        getSize(self) -> CSize3_int
        getSize(self) -> CSize3_int
        """
        return _Volume.swig_base_DVolume_getSize(self, *args)


    def getXSize(self):
        """getXSize(self) -> vpl::tSize"""
        return _Volume.swig_base_DVolume_getXSize(self)


    def getYSize(self):
        """getYSize(self) -> vpl::tSize"""
        return _Volume.swig_base_DVolume_getYSize(self)


    def getZSize(self):
        """getZSize(self) -> vpl::tSize"""
        return _Volume.swig_base_DVolume_getZSize(self)


    def width(self):
        """width(self) -> vpl::tSize"""
        return _Volume.swig_base_DVolume_width(self)


    def height(self):
        """height(self) -> vpl::tSize"""
        return _Volume.swig_base_DVolume_height(self)


    def depth(self):
        """depth(self) -> vpl::tSize"""
        return _Volume.swig_base_DVolume_depth(self)


    def getXOffset(self):
        """getXOffset(self) -> vpl::tSize"""
        return _Volume.swig_base_DVolume_getXOffset(self)


    def getYOffset(self):
        """getYOffset(self) -> vpl::tSize"""
        return _Volume.swig_base_DVolume_getYOffset(self)


    def getZOffset(self):
        """getZOffset(self) -> vpl::tSize"""
        return _Volume.swig_base_DVolume_getZOffset(self)


    def getMargin(self):
        """getMargin(self) -> vpl::tSize"""
        return _Volume.swig_base_DVolume_getMargin(self)


    def getIdx(self, x, y, z):
        """getIdx(self, x, y, z) -> vpl::tSize"""
        return _Volume.swig_base_DVolume_getIdx(self, x, y, z)


    def __call__(self, *args):
        """
        __call__(self, x, y, z) -> vpl::img::CVolumeBase< vpl::img::CVolume< __int16,vpl::base::CPartedData > >::tVoxel
        __call__(self, x, y, z) -> vpl::img::CVolumeBase< vpl::img::CVolume< __int16,vpl::base::CPartedData > >::tVoxel const
        __call__(self, i) -> vpl::img::CVolumeBase< vpl::img::CVolume< __int16,vpl::base::CPartedData > >::tVoxel
        __call__(self, i) -> vpl::img::CVolumeBase< vpl::img::CVolume< __int16,vpl::base::CPartedData > >::tVoxel const &
        """
        return _Volume.swig_base_DVolume___call__(self, *args)


    def at(self, *args):
        """
        at(self, x, y, z) -> vpl::img::CVolumeBase< vpl::img::CVolume< __int16,vpl::base::CPartedData > >::tVoxel
        at(self, x, y, z) -> vpl::img::CVolumeBase< vpl::img::CVolume< __int16,vpl::base::CPartedData > >::tVoxel const
        at(self, i) -> vpl::img::CVolumeBase< vpl::img::CVolume< __int16,vpl::base::CPartedData > >::tVoxel
        at(self, i) -> vpl::img::CVolumeBase< vpl::img::CVolume< __int16,vpl::base::CPartedData > >::tVoxel const &
        """
        return _Volume.swig_base_DVolume_at(self, *args)


    def set(self, *args):
        """
        set(self, x, y, z, Value) -> CDVolume
        set(self, i, Value) -> CDVolume
        """
        return _Volume.swig_base_DVolume_set(self, *args)

    __swig_destroy__ = _Volume.delete_swig_base_DVolume
    __del__ = lambda self: None
swig_base_DVolume_swigregister = _Volume.swig_base_DVolume_swigregister
swig_base_DVolume_swigregister(swig_base_DVolume)

class swig_base_RGBAVolume(_object):
    """Proxy of C++ vpl::img::CVolumeBase<(vpl::img::CVolume<(vpl::img::tRGBAPixel,vpl::base::CPartedData)>)> class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, swig_base_RGBAVolume, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, swig_base_RGBAVolume, name)

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

    def getImpl(self, *args):
        """
        getImpl(self) -> CRGBAVolume
        getImpl(self) -> CRGBAVolume
        """
        return _Volume.swig_base_RGBAVolume_getImpl(self, *args)


    def getSize(self, *args):
        """
        getSize(self) -> CSize3_int
        getSize(self) -> CSize3_int
        """
        return _Volume.swig_base_RGBAVolume_getSize(self, *args)


    def getXSize(self):
        """getXSize(self) -> vpl::tSize"""
        return _Volume.swig_base_RGBAVolume_getXSize(self)


    def getYSize(self):
        """getYSize(self) -> vpl::tSize"""
        return _Volume.swig_base_RGBAVolume_getYSize(self)


    def getZSize(self):
        """getZSize(self) -> vpl::tSize"""
        return _Volume.swig_base_RGBAVolume_getZSize(self)


    def width(self):
        """width(self) -> vpl::tSize"""
        return _Volume.swig_base_RGBAVolume_width(self)


    def height(self):
        """height(self) -> vpl::tSize"""
        return _Volume.swig_base_RGBAVolume_height(self)


    def depth(self):
        """depth(self) -> vpl::tSize"""
        return _Volume.swig_base_RGBAVolume_depth(self)


    def getXOffset(self):
        """getXOffset(self) -> vpl::tSize"""
        return _Volume.swig_base_RGBAVolume_getXOffset(self)


    def getYOffset(self):
        """getYOffset(self) -> vpl::tSize"""
        return _Volume.swig_base_RGBAVolume_getYOffset(self)


    def getZOffset(self):
        """getZOffset(self) -> vpl::tSize"""
        return _Volume.swig_base_RGBAVolume_getZOffset(self)


    def getMargin(self):
        """getMargin(self) -> vpl::tSize"""
        return _Volume.swig_base_RGBAVolume_getMargin(self)


    def getIdx(self, x, y, z):
        """getIdx(self, x, y, z) -> vpl::tSize"""
        return _Volume.swig_base_RGBAVolume_getIdx(self, x, y, z)


    def __call__(self, *args):
        """
        __call__(self, x, y, z) -> vpl::img::CVolumeBase< vpl::img::CVolume< vpl::img::CRGBPixel,vpl::base::CPartedData > >::tVoxel
        __call__(self, x, y, z) -> vpl::img::CVolumeBase< vpl::img::CVolume< vpl::img::CRGBPixel,vpl::base::CPartedData > >::tVoxel const
        __call__(self, i) -> vpl::img::CVolumeBase< vpl::img::CVolume< vpl::img::CRGBPixel,vpl::base::CPartedData > >::tVoxel
        __call__(self, i) -> vpl::img::CVolumeBase< vpl::img::CVolume< vpl::img::CRGBPixel,vpl::base::CPartedData > >::tVoxel const &
        """
        return _Volume.swig_base_RGBAVolume___call__(self, *args)


    def at(self, *args):
        """
        at(self, x, y, z) -> vpl::img::CVolumeBase< vpl::img::CVolume< vpl::img::CRGBPixel,vpl::base::CPartedData > >::tVoxel
        at(self, x, y, z) -> vpl::img::CVolumeBase< vpl::img::CVolume< vpl::img::CRGBPixel,vpl::base::CPartedData > >::tVoxel const
        at(self, i) -> vpl::img::CVolumeBase< vpl::img::CVolume< vpl::img::CRGBPixel,vpl::base::CPartedData > >::tVoxel
        at(self, i) -> vpl::img::CVolumeBase< vpl::img::CVolume< vpl::img::CRGBPixel,vpl::base::CPartedData > >::tVoxel const &
        """
        return _Volume.swig_base_RGBAVolume_at(self, *args)


    def set(self, *args):
        """
        set(self, x, y, z, Value) -> CRGBAVolume
        set(self, i, Value) -> CRGBAVolume
        """
        return _Volume.swig_base_RGBAVolume_set(self, *args)

    __swig_destroy__ = _Volume.delete_swig_base_RGBAVolume
    __del__ = lambda self: None
swig_base_RGBAVolume_swigregister = _Volume.swig_base_RGBAVolume_swigregister
swig_base_RGBAVolume_swigregister(swig_base_RGBAVolume)

class swig_base_ComplexVolume(_object):
    """Proxy of C++ vpl::img::CVolumeBase<(vpl::img::CVolume<(vpl::img::tComplexPixel,vpl::base::CPartedData)>)> class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, swig_base_ComplexVolume, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, swig_base_ComplexVolume, name)

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

    def getImpl(self, *args):
        """
        getImpl(self) -> CComplexVolume
        getImpl(self) -> CComplexVolume
        """
        return _Volume.swig_base_ComplexVolume_getImpl(self, *args)


    def getSize(self, *args):
        """
        getSize(self) -> CSize3_int
        getSize(self) -> CSize3_int
        """
        return _Volume.swig_base_ComplexVolume_getSize(self, *args)


    def getXSize(self):
        """getXSize(self) -> vpl::tSize"""
        return _Volume.swig_base_ComplexVolume_getXSize(self)


    def getYSize(self):
        """getYSize(self) -> vpl::tSize"""
        return _Volume.swig_base_ComplexVolume_getYSize(self)


    def getZSize(self):
        """getZSize(self) -> vpl::tSize"""
        return _Volume.swig_base_ComplexVolume_getZSize(self)


    def width(self):
        """width(self) -> vpl::tSize"""
        return _Volume.swig_base_ComplexVolume_width(self)


    def height(self):
        """height(self) -> vpl::tSize"""
        return _Volume.swig_base_ComplexVolume_height(self)


    def depth(self):
        """depth(self) -> vpl::tSize"""
        return _Volume.swig_base_ComplexVolume_depth(self)


    def getXOffset(self):
        """getXOffset(self) -> vpl::tSize"""
        return _Volume.swig_base_ComplexVolume_getXOffset(self)


    def getYOffset(self):
        """getYOffset(self) -> vpl::tSize"""
        return _Volume.swig_base_ComplexVolume_getYOffset(self)


    def getZOffset(self):
        """getZOffset(self) -> vpl::tSize"""
        return _Volume.swig_base_ComplexVolume_getZOffset(self)


    def getMargin(self):
        """getMargin(self) -> vpl::tSize"""
        return _Volume.swig_base_ComplexVolume_getMargin(self)


    def getIdx(self, x, y, z):
        """getIdx(self, x, y, z) -> vpl::tSize"""
        return _Volume.swig_base_ComplexVolume_getIdx(self, x, y, z)


    def __call__(self, *args):
        """
        __call__(self, x, y, z) -> vpl::img::CVolumeBase< vpl::img::CVolume< vpl::math::CComplex< float >,vpl::base::CPartedData > >::tVoxel
        __call__(self, x, y, z) -> vpl::img::CVolumeBase< vpl::img::CVolume< vpl::math::CComplex< float >,vpl::base::CPartedData > >::tVoxel const
        __call__(self, i) -> vpl::img::CVolumeBase< vpl::img::CVolume< vpl::math::CComplex< float >,vpl::base::CPartedData > >::tVoxel
        __call__(self, i) -> vpl::img::CVolumeBase< vpl::img::CVolume< vpl::math::CComplex< float >,vpl::base::CPartedData > >::tVoxel const &
        """
        return _Volume.swig_base_ComplexVolume___call__(self, *args)


    def at(self, *args):
        """
        at(self, x, y, z) -> vpl::img::CVolumeBase< vpl::img::CVolume< vpl::math::CComplex< float >,vpl::base::CPartedData > >::tVoxel
        at(self, x, y, z) -> vpl::img::CVolumeBase< vpl::img::CVolume< vpl::math::CComplex< float >,vpl::base::CPartedData > >::tVoxel const
        at(self, i) -> vpl::img::CVolumeBase< vpl::img::CVolume< vpl::math::CComplex< float >,vpl::base::CPartedData > >::tVoxel
        at(self, i) -> vpl::img::CVolumeBase< vpl::img::CVolume< vpl::math::CComplex< float >,vpl::base::CPartedData > >::tVoxel const &
        """
        return _Volume.swig_base_ComplexVolume_at(self, *args)


    def set(self, *args):
        """
        set(self, x, y, z, Value) -> CComplexVolume
        set(self, i, Value) -> CComplexVolume
        """
        return _Volume.swig_base_ComplexVolume_set(self, *args)

    __swig_destroy__ = _Volume.delete_swig_base_ComplexVolume
    __del__ = lambda self: None
swig_base_ComplexVolume_swigregister = _Volume.swig_base_ComplexVolume_swigregister
swig_base_ComplexVolume_swigregister(swig_base_ComplexVolume)

class CVolume8(VPLSwig.Core.Core.CObject, swig_base_Volume8, VPLSwig.Image.Image.CSerializable):
    """Proxy of C++ vpl::img::CVolume<(vpl::img::tPixel8,vpl::base::CPartedData)> class."""

    __swig_setmethods__ = {}
    for _s in [VPLSwig.Core.Core.CObject, swig_base_Volume8, VPLSwig.Image.Image.CSerializable]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CVolume8, name, value)
    __swig_getmethods__ = {}
    for _s in [VPLSwig.Core.Core.CObject, swig_base_Volume8, VPLSwig.Image.Image.CSerializable]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CVolume8, name)
    __repr__ = _swig_repr
    CLASS_VOLUME = _Volume.CVolume8_CLASS_VOLUME
    ITERATOR_DECLARED = _Volume.CVolume8_ITERATOR_DECLARED

    def __init__(self, *args):
        """
        __init__(self) -> CVolume8
        __init__(self, XSize, YSize, ZSize, Margin=0) -> CVolume8
        __init__(self, XSize, YSize, ZSize) -> CVolume8
        __init__(self, Size, Margin=0) -> CVolume8
        __init__(self, Size) -> CVolume8
        __init__(self, Volume, x, y, z, XSize, YSize, ZSize) -> CVolume8
        __init__(self, Volume, x, y, z, XSize, YSize, ZSize, arg9) -> CVolume8
        __init__(self, Volume) -> CVolume8
        __init__(self, Volume, arg3) -> CVolume8
        __init__(self, Volume) -> CVolume8
        __init__(self, Volume, arg3) -> CVolume8
        """
        if self.__class__ == CVolume8:
            _self = None
        else:
            _self = self
        this = _Volume.new_CVolume8(_self, *args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _Volume.delete_CVolume8
    __del__ = lambda self: None

    def resize(self, *args):
        """
        resize(self, XSize, YSize, ZSize, Margin=0) -> CVolume8
        resize(self, XSize, YSize, ZSize) -> CVolume8
        resize(self, Size, Margin=0) -> CVolume8
        resize(self, Size) -> CVolume8
        """
        return _Volume.CVolume8_resize(self, *args)


    def copy(self, *args):
        """
        copy(self, Volume, Margin=-1) -> CVolume8
        copy(self, Volume) -> CVolume8
        copy(self, Volume, x, y, z, XSize, YSize, ZSize, Margin=-1) -> CVolume8
        copy(self, Volume, x, y, z, XSize, YSize, ZSize) -> CVolume8
        copy(self, Volume, Margin=-1) -> CVolume8
        copy(self, Volume) -> CVolume8
        """
        return _Volume.CVolume8_copy(self, *args)


    def makeRef(self, *args):
        """
        makeRef(self, Volume) -> CVolume8
        makeRef(self, Volume, x, y, z, XSize, YSize, ZSize) -> CVolume8
        makeRef(self, Volume) -> CVolume8
        """
        return _Volume.CVolume8_makeRef(self, *args)


    def getSize(self, *args):
        """
        getSize(self) -> CSize3_int
        getSize(self) -> CSize3_int
        """
        return _Volume.CVolume8_getSize(self, *args)


    def getXSize(self):
        """getXSize(self) -> vpl::tSize"""
        return _Volume.CVolume8_getXSize(self)


    def getYSize(self):
        """getYSize(self) -> vpl::tSize"""
        return _Volume.CVolume8_getYSize(self)


    def getZSize(self):
        """getZSize(self) -> vpl::tSize"""
        return _Volume.CVolume8_getZSize(self)


    def width(self):
        """width(self) -> vpl::tSize"""
        return _Volume.CVolume8_width(self)


    def height(self):
        """height(self) -> vpl::tSize"""
        return _Volume.CVolume8_height(self)


    def depth(self):
        """depth(self) -> vpl::tSize"""
        return _Volume.CVolume8_depth(self)


    def getXOffset(self):
        """getXOffset(self) -> vpl::tSize"""
        return _Volume.CVolume8_getXOffset(self)


    def getYOffset(self):
        """getYOffset(self) -> vpl::tSize"""
        return _Volume.CVolume8_getYOffset(self)


    def getZOffset(self):
        """getZOffset(self) -> vpl::tSize"""
        return _Volume.CVolume8_getZOffset(self)


    def getMargin(self):
        """getMargin(self) -> vpl::tSize"""
        return _Volume.CVolume8_getMargin(self)


    def getIdx(self, x, y, z):
        """getIdx(self, x, y, z) -> vpl::tSize"""
        return _Volume.CVolume8_getIdx(self, x, y, z)


    def __call__(self, *args):
        """
        __call__(self, x, y, z) -> unsigned __int8
        __call__(self, x, y, z) -> unsigned __int8 const
        __call__(self, i) -> unsigned __int8
        __call__(self, i) -> unsigned __int8 const &
        """
        return _Volume.CVolume8___call__(self, *args)


    def at(self, *args):
        """
        at(self, x, y, z) -> unsigned __int8 const
        at(self, i) -> unsigned __int8 const &
        """
        return _Volume.CVolume8_at(self, *args)


    def set(self, *args):
        """
        set(self, x, y, z, Value) -> CVolume8
        set(self, i, Value) -> CVolume8
        """
        return _Volume.CVolume8_set(self, *args)


    def getPtr(self, *args):
        """
        getPtr(self) -> unsigned __int8
        getPtr(self) -> unsigned __int8 const
        getPtr(self, x, y, z) -> unsigned __int8
        getPtr(self, x, y, z) -> unsigned __int8 const *
        """
        return _Volume.CVolume8_getPtr(self, *args)


    def getRowPtr(self, *args):
        """
        getRowPtr(self, y, z) -> unsigned __int8
        getRowPtr(self, y, z) -> unsigned __int8 const *
        """
        return _Volume.CVolume8_getRowPtr(self, *args)


    def rect(self, *args):
        """
        rect(self, Position, Size) -> vpl::img::CVolume< unsigned __int8,vpl::base::CPartedData >::tRect
        rect(self, Position, Size) -> vpl::img::CVolume< unsigned __int8,vpl::base::CPartedData >::tRect const
        rect(self, XRange, YRange, ZRange) -> vpl::img::CVolume< unsigned __int8,vpl::base::CPartedData >::tRect
        rect(self, XRange, YRange, ZRange) -> vpl::img::CVolume< unsigned __int8,vpl::base::CPartedData >::tRect const
        """
        return _Volume.CVolume8_rect(self, *args)


    def row(self, *args):
        """
        row(self, y, z) -> vpl::img::CVolume< unsigned __int8,vpl::base::CPartedData >::tRow
        row(self, y, z) -> vpl::img::CVolume< unsigned __int8,vpl::base::CPartedData >::tRow const
        """
        return _Volume.CVolume8_row(self, *args)


    def fill(self, c):
        """fill(self, c) -> CVolume8"""
        return _Volume.CVolume8_fill(self, c)


    def fillEntire(self, c):
        """fillEntire(self, c) -> CVolume8"""
        return _Volume.CVolume8_fillEntire(self, c)


    def fillMargin(self, c):
        """fillMargin(self, c) -> CVolume8"""
        return _Volume.CVolume8_fillMargin(self, c)


    def mirrorMargin(self):
        """mirrorMargin(self) -> CVolume8"""
        return _Volume.CVolume8_mirrorMargin(self)


    def replace(self, Value, NewValue):
        """replace(self, Value, NewValue) -> CVolume8"""
        return _Volume.CVolume8_replace(self, Value, NewValue)


    def abs(self):
        """abs(self) -> CVolume8"""
        return _Volume.CVolume8_abs(self)


    def limit(self, Lower, Upper):
        """limit(self, Lower, Upper) -> CVolume8"""
        return _Volume.CVolume8_limit(self, Lower, Upper)


    def cut(self, Lower, Upper):
        """cut(self, Lower, Upper) -> CVolume8"""
        return _Volume.CVolume8_cut(self, Lower, Upper)


    def subSample(self, Volume, l=2, m=2, n=2):
        """
        subSample(self, Volume, l=2, m=2, n=2) -> CVolume8
        subSample(self, Volume, l=2, m=2) -> CVolume8
        subSample(self, Volume, l=2) -> CVolume8
        subSample(self, Volume) -> CVolume8
        """
        return _Volume.CVolume8_subSample(self, Volume, l, m, n)


    def interpolate(self, Point):
        """interpolate(self, Point) -> unsigned __int8"""
        return _Volume.CVolume8_interpolate(self, Point)


    def color2Voxel(self, Color):
        """color2Voxel(self, Color) -> unsigned __int8"""
        return _Volume.CVolume8_color2Voxel(self, Color)


    def checkPosition(self, x, y, z):
        """checkPosition(self, x, y, z) -> bool"""
        return _Volume.CVolume8_checkPosition(self, x, y, z)


    def getPlaneXY(self, z, Plane):
        """getPlaneXY(self, z, Plane) -> bool"""
        return _Volume.CVolume8_getPlaneXY(self, z, Plane)


    def getPlaneXZ(self, y, Plane):
        """getPlaneXZ(self, y, Plane) -> bool"""
        return _Volume.CVolume8_getPlaneXZ(self, y, Plane)


    def getPlaneYZ(self, x, Plane):
        """getPlaneYZ(self, x, Plane) -> bool"""
        return _Volume.CVolume8_getPlaneYZ(self, x, Plane)


    def setPlaneXY(self, z, Plane):
        """setPlaneXY(self, z, Plane) -> bool"""
        return _Volume.CVolume8_setPlaneXY(self, z, Plane)


    def setPlaneXZ(self, y, Plane):
        """setPlaneXZ(self, y, Plane) -> bool"""
        return _Volume.CVolume8_setPlaneXZ(self, y, Plane)


    def setPlaneYZ(self, x, Plane):
        """setPlaneYZ(self, x, Plane) -> bool"""
        return _Volume.CVolume8_setPlaneYZ(self, x, Plane)


    def enableDummyMode(self, Enable):
        """enableDummyMode(self, Enable) -> CVolume8"""
        return _Volume.CVolume8_enableDummyMode(self, Enable)


    def isDummy(self):
        """isDummy(self) -> bool"""
        return _Volume.CVolume8_isDummy(self)

    def __disown__(self):
        self.this.disown()
        _Volume.disown_CVolume8(self)
        return weakref_proxy(self)
CVolume8_swigregister = _Volume.CVolume8_swigregister
CVolume8_swigregister(CVolume8)

class CVolume16(VPLSwig.Core.Core.CObject, swig_base_Volume16, VPLSwig.Image.Image.CSerializable):
    """Proxy of C++ vpl::img::CVolume<(vpl::img::tPixel16,vpl::base::CPartedData)> class."""

    __swig_setmethods__ = {}
    for _s in [VPLSwig.Core.Core.CObject, swig_base_Volume16, VPLSwig.Image.Image.CSerializable]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CVolume16, name, value)
    __swig_getmethods__ = {}
    for _s in [VPLSwig.Core.Core.CObject, swig_base_Volume16, VPLSwig.Image.Image.CSerializable]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CVolume16, name)
    __repr__ = _swig_repr
    CLASS_VOLUME = _Volume.CVolume16_CLASS_VOLUME
    ITERATOR_DECLARED = _Volume.CVolume16_ITERATOR_DECLARED

    def __init__(self, *args):
        """
        __init__(self) -> CVolume16
        __init__(self, XSize, YSize, ZSize, Margin=0) -> CVolume16
        __init__(self, XSize, YSize, ZSize) -> CVolume16
        __init__(self, Size, Margin=0) -> CVolume16
        __init__(self, Size) -> CVolume16
        __init__(self, Volume, x, y, z, XSize, YSize, ZSize) -> CVolume16
        __init__(self, Volume, x, y, z, XSize, YSize, ZSize, arg9) -> CVolume16
        __init__(self, Volume) -> CVolume16
        __init__(self, Volume, arg3) -> CVolume16
        __init__(self, Volume) -> CVolume16
        __init__(self, Volume, arg3) -> CVolume16
        """
        if self.__class__ == CVolume16:
            _self = None
        else:
            _self = self
        this = _Volume.new_CVolume16(_self, *args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _Volume.delete_CVolume16
    __del__ = lambda self: None

    def resize(self, *args):
        """
        resize(self, XSize, YSize, ZSize, Margin=0) -> CVolume16
        resize(self, XSize, YSize, ZSize) -> CVolume16
        resize(self, Size, Margin=0) -> CVolume16
        resize(self, Size) -> CVolume16
        """
        return _Volume.CVolume16_resize(self, *args)


    def copy(self, *args):
        """
        copy(self, Volume, Margin=-1) -> CVolume16
        copy(self, Volume) -> CVolume16
        copy(self, Volume, x, y, z, XSize, YSize, ZSize, Margin=-1) -> CVolume16
        copy(self, Volume, x, y, z, XSize, YSize, ZSize) -> CVolume16
        copy(self, Volume, Margin=-1) -> CVolume16
        copy(self, Volume) -> CVolume16
        """
        return _Volume.CVolume16_copy(self, *args)


    def makeRef(self, *args):
        """
        makeRef(self, Volume) -> CVolume16
        makeRef(self, Volume, x, y, z, XSize, YSize, ZSize) -> CVolume16
        makeRef(self, Volume) -> CVolume16
        """
        return _Volume.CVolume16_makeRef(self, *args)


    def getSize(self, *args):
        """
        getSize(self) -> CSize3_int
        getSize(self) -> CSize3_int
        """
        return _Volume.CVolume16_getSize(self, *args)


    def getXSize(self):
        """getXSize(self) -> vpl::tSize"""
        return _Volume.CVolume16_getXSize(self)


    def getYSize(self):
        """getYSize(self) -> vpl::tSize"""
        return _Volume.CVolume16_getYSize(self)


    def getZSize(self):
        """getZSize(self) -> vpl::tSize"""
        return _Volume.CVolume16_getZSize(self)


    def width(self):
        """width(self) -> vpl::tSize"""
        return _Volume.CVolume16_width(self)


    def height(self):
        """height(self) -> vpl::tSize"""
        return _Volume.CVolume16_height(self)


    def depth(self):
        """depth(self) -> vpl::tSize"""
        return _Volume.CVolume16_depth(self)


    def getXOffset(self):
        """getXOffset(self) -> vpl::tSize"""
        return _Volume.CVolume16_getXOffset(self)


    def getYOffset(self):
        """getYOffset(self) -> vpl::tSize"""
        return _Volume.CVolume16_getYOffset(self)


    def getZOffset(self):
        """getZOffset(self) -> vpl::tSize"""
        return _Volume.CVolume16_getZOffset(self)


    def getMargin(self):
        """getMargin(self) -> vpl::tSize"""
        return _Volume.CVolume16_getMargin(self)


    def getIdx(self, x, y, z):
        """getIdx(self, x, y, z) -> vpl::tSize"""
        return _Volume.CVolume16_getIdx(self, x, y, z)


    def __call__(self, *args):
        """
        __call__(self, x, y, z) -> unsigned __int16
        __call__(self, x, y, z) -> unsigned __int16 const
        __call__(self, i) -> unsigned __int16
        __call__(self, i) -> unsigned __int16 const &
        """
        return _Volume.CVolume16___call__(self, *args)


    def at(self, *args):
        """
        at(self, x, y, z) -> unsigned __int16 const
        at(self, i) -> unsigned __int16 const &
        """
        return _Volume.CVolume16_at(self, *args)


    def set(self, *args):
        """
        set(self, x, y, z, Value) -> CVolume16
        set(self, i, Value) -> CVolume16
        """
        return _Volume.CVolume16_set(self, *args)


    def getPtr(self, *args):
        """
        getPtr(self) -> unsigned __int16
        getPtr(self) -> unsigned __int16 const
        getPtr(self, x, y, z) -> unsigned __int16
        getPtr(self, x, y, z) -> unsigned __int16 const *
        """
        return _Volume.CVolume16_getPtr(self, *args)


    def getRowPtr(self, *args):
        """
        getRowPtr(self, y, z) -> unsigned __int16
        getRowPtr(self, y, z) -> unsigned __int16 const *
        """
        return _Volume.CVolume16_getRowPtr(self, *args)


    def rect(self, *args):
        """
        rect(self, Position, Size) -> vpl::img::CVolume< unsigned __int16,vpl::base::CPartedData >::tRect
        rect(self, Position, Size) -> vpl::img::CVolume< unsigned __int16,vpl::base::CPartedData >::tRect const
        rect(self, XRange, YRange, ZRange) -> vpl::img::CVolume< unsigned __int16,vpl::base::CPartedData >::tRect
        rect(self, XRange, YRange, ZRange) -> vpl::img::CVolume< unsigned __int16,vpl::base::CPartedData >::tRect const
        """
        return _Volume.CVolume16_rect(self, *args)


    def row(self, *args):
        """
        row(self, y, z) -> vpl::img::CVolume< unsigned __int16,vpl::base::CPartedData >::tRow
        row(self, y, z) -> vpl::img::CVolume< unsigned __int16,vpl::base::CPartedData >::tRow const
        """
        return _Volume.CVolume16_row(self, *args)


    def fill(self, c):
        """fill(self, c) -> CVolume16"""
        return _Volume.CVolume16_fill(self, c)


    def fillEntire(self, c):
        """fillEntire(self, c) -> CVolume16"""
        return _Volume.CVolume16_fillEntire(self, c)


    def fillMargin(self, c):
        """fillMargin(self, c) -> CVolume16"""
        return _Volume.CVolume16_fillMargin(self, c)


    def mirrorMargin(self):
        """mirrorMargin(self) -> CVolume16"""
        return _Volume.CVolume16_mirrorMargin(self)


    def replace(self, Value, NewValue):
        """replace(self, Value, NewValue) -> CVolume16"""
        return _Volume.CVolume16_replace(self, Value, NewValue)


    def abs(self):
        """abs(self) -> CVolume16"""
        return _Volume.CVolume16_abs(self)


    def limit(self, Lower, Upper):
        """limit(self, Lower, Upper) -> CVolume16"""
        return _Volume.CVolume16_limit(self, Lower, Upper)


    def cut(self, Lower, Upper):
        """cut(self, Lower, Upper) -> CVolume16"""
        return _Volume.CVolume16_cut(self, Lower, Upper)


    def subSample(self, Volume, l=2, m=2, n=2):
        """
        subSample(self, Volume, l=2, m=2, n=2) -> CVolume16
        subSample(self, Volume, l=2, m=2) -> CVolume16
        subSample(self, Volume, l=2) -> CVolume16
        subSample(self, Volume) -> CVolume16
        """
        return _Volume.CVolume16_subSample(self, Volume, l, m, n)


    def interpolate(self, Point):
        """interpolate(self, Point) -> unsigned __int16"""
        return _Volume.CVolume16_interpolate(self, Point)


    def color2Voxel(self, Color):
        """color2Voxel(self, Color) -> unsigned __int16"""
        return _Volume.CVolume16_color2Voxel(self, Color)


    def checkPosition(self, x, y, z):
        """checkPosition(self, x, y, z) -> bool"""
        return _Volume.CVolume16_checkPosition(self, x, y, z)


    def getPlaneXY(self, z, Plane):
        """getPlaneXY(self, z, Plane) -> bool"""
        return _Volume.CVolume16_getPlaneXY(self, z, Plane)


    def getPlaneXZ(self, y, Plane):
        """getPlaneXZ(self, y, Plane) -> bool"""
        return _Volume.CVolume16_getPlaneXZ(self, y, Plane)


    def getPlaneYZ(self, x, Plane):
        """getPlaneYZ(self, x, Plane) -> bool"""
        return _Volume.CVolume16_getPlaneYZ(self, x, Plane)


    def setPlaneXY(self, z, Plane):
        """setPlaneXY(self, z, Plane) -> bool"""
        return _Volume.CVolume16_setPlaneXY(self, z, Plane)


    def setPlaneXZ(self, y, Plane):
        """setPlaneXZ(self, y, Plane) -> bool"""
        return _Volume.CVolume16_setPlaneXZ(self, y, Plane)


    def setPlaneYZ(self, x, Plane):
        """setPlaneYZ(self, x, Plane) -> bool"""
        return _Volume.CVolume16_setPlaneYZ(self, x, Plane)


    def enableDummyMode(self, Enable):
        """enableDummyMode(self, Enable) -> CVolume16"""
        return _Volume.CVolume16_enableDummyMode(self, Enable)


    def isDummy(self):
        """isDummy(self) -> bool"""
        return _Volume.CVolume16_isDummy(self)

    def __disown__(self):
        self.this.disown()
        _Volume.disown_CVolume16(self)
        return weakref_proxy(self)
CVolume16_swigregister = _Volume.CVolume16_swigregister
CVolume16_swigregister(CVolume16)

class CVolume32(VPLSwig.Core.Core.CObject, swig_base_Volume32, VPLSwig.Image.Image.CSerializable):
    """Proxy of C++ vpl::img::CVolume<(vpl::img::tPixel32,vpl::base::CPartedData)> class."""

    __swig_setmethods__ = {}
    for _s in [VPLSwig.Core.Core.CObject, swig_base_Volume32, VPLSwig.Image.Image.CSerializable]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CVolume32, name, value)
    __swig_getmethods__ = {}
    for _s in [VPLSwig.Core.Core.CObject, swig_base_Volume32, VPLSwig.Image.Image.CSerializable]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CVolume32, name)
    __repr__ = _swig_repr
    CLASS_VOLUME = _Volume.CVolume32_CLASS_VOLUME
    ITERATOR_DECLARED = _Volume.CVolume32_ITERATOR_DECLARED

    def __init__(self, *args):
        """
        __init__(self) -> CVolume32
        __init__(self, XSize, YSize, ZSize, Margin=0) -> CVolume32
        __init__(self, XSize, YSize, ZSize) -> CVolume32
        __init__(self, Size, Margin=0) -> CVolume32
        __init__(self, Size) -> CVolume32
        __init__(self, Volume, x, y, z, XSize, YSize, ZSize) -> CVolume32
        __init__(self, Volume, x, y, z, XSize, YSize, ZSize, arg9) -> CVolume32
        __init__(self, Volume) -> CVolume32
        __init__(self, Volume, arg3) -> CVolume32
        __init__(self, Volume) -> CVolume32
        __init__(self, Volume, arg3) -> CVolume32
        """
        if self.__class__ == CVolume32:
            _self = None
        else:
            _self = self
        this = _Volume.new_CVolume32(_self, *args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _Volume.delete_CVolume32
    __del__ = lambda self: None

    def resize(self, *args):
        """
        resize(self, XSize, YSize, ZSize, Margin=0) -> CVolume32
        resize(self, XSize, YSize, ZSize) -> CVolume32
        resize(self, Size, Margin=0) -> CVolume32
        resize(self, Size) -> CVolume32
        """
        return _Volume.CVolume32_resize(self, *args)


    def copy(self, *args):
        """
        copy(self, Volume, Margin=-1) -> CVolume32
        copy(self, Volume) -> CVolume32
        copy(self, Volume, x, y, z, XSize, YSize, ZSize, Margin=-1) -> CVolume32
        copy(self, Volume, x, y, z, XSize, YSize, ZSize) -> CVolume32
        copy(self, Volume, Margin=-1) -> CVolume32
        copy(self, Volume) -> CVolume32
        """
        return _Volume.CVolume32_copy(self, *args)


    def makeRef(self, *args):
        """
        makeRef(self, Volume) -> CVolume32
        makeRef(self, Volume, x, y, z, XSize, YSize, ZSize) -> CVolume32
        makeRef(self, Volume) -> CVolume32
        """
        return _Volume.CVolume32_makeRef(self, *args)


    def getSize(self, *args):
        """
        getSize(self) -> CSize3_int
        getSize(self) -> CSize3_int
        """
        return _Volume.CVolume32_getSize(self, *args)


    def getXSize(self):
        """getXSize(self) -> vpl::tSize"""
        return _Volume.CVolume32_getXSize(self)


    def getYSize(self):
        """getYSize(self) -> vpl::tSize"""
        return _Volume.CVolume32_getYSize(self)


    def getZSize(self):
        """getZSize(self) -> vpl::tSize"""
        return _Volume.CVolume32_getZSize(self)


    def width(self):
        """width(self) -> vpl::tSize"""
        return _Volume.CVolume32_width(self)


    def height(self):
        """height(self) -> vpl::tSize"""
        return _Volume.CVolume32_height(self)


    def depth(self):
        """depth(self) -> vpl::tSize"""
        return _Volume.CVolume32_depth(self)


    def getXOffset(self):
        """getXOffset(self) -> vpl::tSize"""
        return _Volume.CVolume32_getXOffset(self)


    def getYOffset(self):
        """getYOffset(self) -> vpl::tSize"""
        return _Volume.CVolume32_getYOffset(self)


    def getZOffset(self):
        """getZOffset(self) -> vpl::tSize"""
        return _Volume.CVolume32_getZOffset(self)


    def getMargin(self):
        """getMargin(self) -> vpl::tSize"""
        return _Volume.CVolume32_getMargin(self)


    def getIdx(self, x, y, z):
        """getIdx(self, x, y, z) -> vpl::tSize"""
        return _Volume.CVolume32_getIdx(self, x, y, z)


    def __call__(self, *args):
        """
        __call__(self, x, y, z) -> unsigned __int32
        __call__(self, x, y, z) -> unsigned __int32 const
        __call__(self, i) -> unsigned __int32
        __call__(self, i) -> unsigned __int32 const &
        """
        return _Volume.CVolume32___call__(self, *args)


    def at(self, *args):
        """
        at(self, x, y, z) -> unsigned __int32 const
        at(self, i) -> unsigned __int32 const &
        """
        return _Volume.CVolume32_at(self, *args)


    def set(self, *args):
        """
        set(self, x, y, z, Value) -> CVolume32
        set(self, i, Value) -> CVolume32
        """
        return _Volume.CVolume32_set(self, *args)


    def getPtr(self, *args):
        """
        getPtr(self) -> unsigned __int32
        getPtr(self) -> unsigned __int32 const
        getPtr(self, x, y, z) -> unsigned __int32
        getPtr(self, x, y, z) -> unsigned __int32 const *
        """
        return _Volume.CVolume32_getPtr(self, *args)


    def getRowPtr(self, *args):
        """
        getRowPtr(self, y, z) -> unsigned __int32
        getRowPtr(self, y, z) -> unsigned __int32 const *
        """
        return _Volume.CVolume32_getRowPtr(self, *args)


    def rect(self, *args):
        """
        rect(self, Position, Size) -> vpl::img::CVolume< unsigned __int32,vpl::base::CPartedData >::tRect
        rect(self, Position, Size) -> vpl::img::CVolume< unsigned __int32,vpl::base::CPartedData >::tRect const
        rect(self, XRange, YRange, ZRange) -> vpl::img::CVolume< unsigned __int32,vpl::base::CPartedData >::tRect
        rect(self, XRange, YRange, ZRange) -> vpl::img::CVolume< unsigned __int32,vpl::base::CPartedData >::tRect const
        """
        return _Volume.CVolume32_rect(self, *args)


    def row(self, *args):
        """
        row(self, y, z) -> vpl::img::CVolume< unsigned __int32,vpl::base::CPartedData >::tRow
        row(self, y, z) -> vpl::img::CVolume< unsigned __int32,vpl::base::CPartedData >::tRow const
        """
        return _Volume.CVolume32_row(self, *args)


    def fill(self, c):
        """fill(self, c) -> CVolume32"""
        return _Volume.CVolume32_fill(self, c)


    def fillEntire(self, c):
        """fillEntire(self, c) -> CVolume32"""
        return _Volume.CVolume32_fillEntire(self, c)


    def fillMargin(self, c):
        """fillMargin(self, c) -> CVolume32"""
        return _Volume.CVolume32_fillMargin(self, c)


    def mirrorMargin(self):
        """mirrorMargin(self) -> CVolume32"""
        return _Volume.CVolume32_mirrorMargin(self)


    def replace(self, Value, NewValue):
        """replace(self, Value, NewValue) -> CVolume32"""
        return _Volume.CVolume32_replace(self, Value, NewValue)


    def abs(self):
        """abs(self) -> CVolume32"""
        return _Volume.CVolume32_abs(self)


    def limit(self, Lower, Upper):
        """limit(self, Lower, Upper) -> CVolume32"""
        return _Volume.CVolume32_limit(self, Lower, Upper)


    def cut(self, Lower, Upper):
        """cut(self, Lower, Upper) -> CVolume32"""
        return _Volume.CVolume32_cut(self, Lower, Upper)


    def subSample(self, Volume, l=2, m=2, n=2):
        """
        subSample(self, Volume, l=2, m=2, n=2) -> CVolume32
        subSample(self, Volume, l=2, m=2) -> CVolume32
        subSample(self, Volume, l=2) -> CVolume32
        subSample(self, Volume) -> CVolume32
        """
        return _Volume.CVolume32_subSample(self, Volume, l, m, n)


    def interpolate(self, Point):
        """interpolate(self, Point) -> unsigned __int32"""
        return _Volume.CVolume32_interpolate(self, Point)


    def color2Voxel(self, Color):
        """color2Voxel(self, Color) -> unsigned __int32"""
        return _Volume.CVolume32_color2Voxel(self, Color)


    def checkPosition(self, x, y, z):
        """checkPosition(self, x, y, z) -> bool"""
        return _Volume.CVolume32_checkPosition(self, x, y, z)


    def getPlaneXY(self, z, Plane):
        """getPlaneXY(self, z, Plane) -> bool"""
        return _Volume.CVolume32_getPlaneXY(self, z, Plane)


    def getPlaneXZ(self, y, Plane):
        """getPlaneXZ(self, y, Plane) -> bool"""
        return _Volume.CVolume32_getPlaneXZ(self, y, Plane)


    def getPlaneYZ(self, x, Plane):
        """getPlaneYZ(self, x, Plane) -> bool"""
        return _Volume.CVolume32_getPlaneYZ(self, x, Plane)


    def setPlaneXY(self, z, Plane):
        """setPlaneXY(self, z, Plane) -> bool"""
        return _Volume.CVolume32_setPlaneXY(self, z, Plane)


    def setPlaneXZ(self, y, Plane):
        """setPlaneXZ(self, y, Plane) -> bool"""
        return _Volume.CVolume32_setPlaneXZ(self, y, Plane)


    def setPlaneYZ(self, x, Plane):
        """setPlaneYZ(self, x, Plane) -> bool"""
        return _Volume.CVolume32_setPlaneYZ(self, x, Plane)


    def enableDummyMode(self, Enable):
        """enableDummyMode(self, Enable) -> CVolume32"""
        return _Volume.CVolume32_enableDummyMode(self, Enable)


    def isDummy(self):
        """isDummy(self) -> bool"""
        return _Volume.CVolume32_isDummy(self)

    def __disown__(self):
        self.this.disown()
        _Volume.disown_CVolume32(self)
        return weakref_proxy(self)
CVolume32_swigregister = _Volume.CVolume32_swigregister
CVolume32_swigregister(CVolume32)

class CFVolume(VPLSwig.Core.Core.CObject, swig_base_FVolume, VPLSwig.Image.Image.CSerializable):
    """Proxy of C++ vpl::img::CVolume<(vpl::img::tFloatPixel,vpl::base::CPartedData)> class."""

    __swig_setmethods__ = {}
    for _s in [VPLSwig.Core.Core.CObject, swig_base_FVolume, VPLSwig.Image.Image.CSerializable]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CFVolume, name, value)
    __swig_getmethods__ = {}
    for _s in [VPLSwig.Core.Core.CObject, swig_base_FVolume, VPLSwig.Image.Image.CSerializable]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CFVolume, name)
    __repr__ = _swig_repr
    CLASS_VOLUME = _Volume.CFVolume_CLASS_VOLUME
    ITERATOR_DECLARED = _Volume.CFVolume_ITERATOR_DECLARED

    def __init__(self, *args):
        """
        __init__(self) -> CFVolume
        __init__(self, XSize, YSize, ZSize, Margin=0) -> CFVolume
        __init__(self, XSize, YSize, ZSize) -> CFVolume
        __init__(self, Size, Margin=0) -> CFVolume
        __init__(self, Size) -> CFVolume
        __init__(self, Volume, x, y, z, XSize, YSize, ZSize) -> CFVolume
        __init__(self, Volume, x, y, z, XSize, YSize, ZSize, arg9) -> CFVolume
        __init__(self, Volume) -> CFVolume
        __init__(self, Volume, arg3) -> CFVolume
        __init__(self, Volume) -> CFVolume
        __init__(self, Volume, arg3) -> CFVolume
        """
        if self.__class__ == CFVolume:
            _self = None
        else:
            _self = self
        this = _Volume.new_CFVolume(_self, *args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _Volume.delete_CFVolume
    __del__ = lambda self: None

    def resize(self, *args):
        """
        resize(self, XSize, YSize, ZSize, Margin=0) -> CFVolume
        resize(self, XSize, YSize, ZSize) -> CFVolume
        resize(self, Size, Margin=0) -> CFVolume
        resize(self, Size) -> CFVolume
        """
        return _Volume.CFVolume_resize(self, *args)


    def copy(self, *args):
        """
        copy(self, Volume, Margin=-1) -> CFVolume
        copy(self, Volume) -> CFVolume
        copy(self, Volume, x, y, z, XSize, YSize, ZSize, Margin=-1) -> CFVolume
        copy(self, Volume, x, y, z, XSize, YSize, ZSize) -> CFVolume
        copy(self, Volume, Margin=-1) -> CFVolume
        copy(self, Volume) -> CFVolume
        """
        return _Volume.CFVolume_copy(self, *args)


    def makeRef(self, *args):
        """
        makeRef(self, Volume) -> CFVolume
        makeRef(self, Volume, x, y, z, XSize, YSize, ZSize) -> CFVolume
        makeRef(self, Volume) -> CFVolume
        """
        return _Volume.CFVolume_makeRef(self, *args)


    def getSize(self, *args):
        """
        getSize(self) -> CSize3_int
        getSize(self) -> CSize3_int
        """
        return _Volume.CFVolume_getSize(self, *args)


    def getXSize(self):
        """getXSize(self) -> vpl::tSize"""
        return _Volume.CFVolume_getXSize(self)


    def getYSize(self):
        """getYSize(self) -> vpl::tSize"""
        return _Volume.CFVolume_getYSize(self)


    def getZSize(self):
        """getZSize(self) -> vpl::tSize"""
        return _Volume.CFVolume_getZSize(self)


    def width(self):
        """width(self) -> vpl::tSize"""
        return _Volume.CFVolume_width(self)


    def height(self):
        """height(self) -> vpl::tSize"""
        return _Volume.CFVolume_height(self)


    def depth(self):
        """depth(self) -> vpl::tSize"""
        return _Volume.CFVolume_depth(self)


    def getXOffset(self):
        """getXOffset(self) -> vpl::tSize"""
        return _Volume.CFVolume_getXOffset(self)


    def getYOffset(self):
        """getYOffset(self) -> vpl::tSize"""
        return _Volume.CFVolume_getYOffset(self)


    def getZOffset(self):
        """getZOffset(self) -> vpl::tSize"""
        return _Volume.CFVolume_getZOffset(self)


    def getMargin(self):
        """getMargin(self) -> vpl::tSize"""
        return _Volume.CFVolume_getMargin(self)


    def getIdx(self, x, y, z):
        """getIdx(self, x, y, z) -> vpl::tSize"""
        return _Volume.CFVolume_getIdx(self, x, y, z)


    def __call__(self, *args):
        """
        __call__(self, x, y, z) -> float
        __call__(self, x, y, z) -> float const
        __call__(self, i) -> float
        __call__(self, i) -> float const &
        """
        return _Volume.CFVolume___call__(self, *args)


    def at(self, *args):
        """
        at(self, x, y, z) -> float const
        at(self, i) -> float const &
        """
        return _Volume.CFVolume_at(self, *args)


    def set(self, *args):
        """
        set(self, x, y, z, Value) -> CFVolume
        set(self, i, Value) -> CFVolume
        """
        return _Volume.CFVolume_set(self, *args)


    def getPtr(self, *args):
        """
        getPtr(self) -> float
        getPtr(self) -> float const
        getPtr(self, x, y, z) -> float
        getPtr(self, x, y, z) -> float const *
        """
        return _Volume.CFVolume_getPtr(self, *args)


    def getRowPtr(self, *args):
        """
        getRowPtr(self, y, z) -> float
        getRowPtr(self, y, z) -> float const *
        """
        return _Volume.CFVolume_getRowPtr(self, *args)


    def rect(self, *args):
        """
        rect(self, Position, Size) -> vpl::img::CVolume< float,vpl::base::CPartedData >::tRect
        rect(self, Position, Size) -> vpl::img::CVolume< float,vpl::base::CPartedData >::tRect const
        rect(self, XRange, YRange, ZRange) -> vpl::img::CVolume< float,vpl::base::CPartedData >::tRect
        rect(self, XRange, YRange, ZRange) -> vpl::img::CVolume< float,vpl::base::CPartedData >::tRect const
        """
        return _Volume.CFVolume_rect(self, *args)


    def row(self, *args):
        """
        row(self, y, z) -> vpl::img::CVolume< float,vpl::base::CPartedData >::tRow
        row(self, y, z) -> vpl::img::CVolume< float,vpl::base::CPartedData >::tRow const
        """
        return _Volume.CFVolume_row(self, *args)


    def fill(self, c):
        """fill(self, c) -> CFVolume"""
        return _Volume.CFVolume_fill(self, c)


    def fillEntire(self, c):
        """fillEntire(self, c) -> CFVolume"""
        return _Volume.CFVolume_fillEntire(self, c)


    def fillMargin(self, c):
        """fillMargin(self, c) -> CFVolume"""
        return _Volume.CFVolume_fillMargin(self, c)


    def mirrorMargin(self):
        """mirrorMargin(self) -> CFVolume"""
        return _Volume.CFVolume_mirrorMargin(self)


    def replace(self, Value, NewValue):
        """replace(self, Value, NewValue) -> CFVolume"""
        return _Volume.CFVolume_replace(self, Value, NewValue)


    def abs(self):
        """abs(self) -> CFVolume"""
        return _Volume.CFVolume_abs(self)


    def limit(self, Lower, Upper):
        """limit(self, Lower, Upper) -> CFVolume"""
        return _Volume.CFVolume_limit(self, Lower, Upper)


    def cut(self, Lower, Upper):
        """cut(self, Lower, Upper) -> CFVolume"""
        return _Volume.CFVolume_cut(self, Lower, Upper)


    def subSample(self, Volume, l=2, m=2, n=2):
        """
        subSample(self, Volume, l=2, m=2, n=2) -> CFVolume
        subSample(self, Volume, l=2, m=2) -> CFVolume
        subSample(self, Volume, l=2) -> CFVolume
        subSample(self, Volume) -> CFVolume
        """
        return _Volume.CFVolume_subSample(self, Volume, l, m, n)


    def interpolate(self, Point):
        """interpolate(self, Point) -> float"""
        return _Volume.CFVolume_interpolate(self, Point)


    def color2Voxel(self, Color):
        """color2Voxel(self, Color) -> float"""
        return _Volume.CFVolume_color2Voxel(self, Color)


    def checkPosition(self, x, y, z):
        """checkPosition(self, x, y, z) -> bool"""
        return _Volume.CFVolume_checkPosition(self, x, y, z)


    def getPlaneXY(self, z, Plane):
        """getPlaneXY(self, z, Plane) -> bool"""
        return _Volume.CFVolume_getPlaneXY(self, z, Plane)


    def getPlaneXZ(self, y, Plane):
        """getPlaneXZ(self, y, Plane) -> bool"""
        return _Volume.CFVolume_getPlaneXZ(self, y, Plane)


    def getPlaneYZ(self, x, Plane):
        """getPlaneYZ(self, x, Plane) -> bool"""
        return _Volume.CFVolume_getPlaneYZ(self, x, Plane)


    def setPlaneXY(self, z, Plane):
        """setPlaneXY(self, z, Plane) -> bool"""
        return _Volume.CFVolume_setPlaneXY(self, z, Plane)


    def setPlaneXZ(self, y, Plane):
        """setPlaneXZ(self, y, Plane) -> bool"""
        return _Volume.CFVolume_setPlaneXZ(self, y, Plane)


    def setPlaneYZ(self, x, Plane):
        """setPlaneYZ(self, x, Plane) -> bool"""
        return _Volume.CFVolume_setPlaneYZ(self, x, Plane)


    def enableDummyMode(self, Enable):
        """enableDummyMode(self, Enable) -> CFVolume"""
        return _Volume.CFVolume_enableDummyMode(self, Enable)


    def isDummy(self):
        """isDummy(self) -> bool"""
        return _Volume.CFVolume_isDummy(self)

    def __disown__(self):
        self.this.disown()
        _Volume.disown_CFVolume(self)
        return weakref_proxy(self)
CFVolume_swigregister = _Volume.CFVolume_swigregister
CFVolume_swigregister(CFVolume)

class CDVolume(VPLSwig.Core.Core.CObject, swig_base_DVolume, VPLSwig.Image.Image.CSerializable):
    """Proxy of C++ vpl::img::CVolume<(vpl::img::tDensityPixel,vpl::base::CPartedData)> class."""

    __swig_setmethods__ = {}
    for _s in [VPLSwig.Core.Core.CObject, swig_base_DVolume, VPLSwig.Image.Image.CSerializable]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CDVolume, name, value)
    __swig_getmethods__ = {}
    for _s in [VPLSwig.Core.Core.CObject, swig_base_DVolume, VPLSwig.Image.Image.CSerializable]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CDVolume, name)
    __repr__ = _swig_repr
    CLASS_VOLUME = _Volume.CDVolume_CLASS_VOLUME
    ITERATOR_DECLARED = _Volume.CDVolume_ITERATOR_DECLARED

    def __init__(self, *args):
        """
        __init__(self) -> CDVolume
        __init__(self, XSize, YSize, ZSize, Margin=0) -> CDVolume
        __init__(self, XSize, YSize, ZSize) -> CDVolume
        __init__(self, Size, Margin=0) -> CDVolume
        __init__(self, Size) -> CDVolume
        __init__(self, Volume, x, y, z, XSize, YSize, ZSize) -> CDVolume
        __init__(self, Volume, x, y, z, XSize, YSize, ZSize, arg9) -> CDVolume
        __init__(self, Volume) -> CDVolume
        __init__(self, Volume, arg3) -> CDVolume
        __init__(self, Volume) -> CDVolume
        __init__(self, Volume, arg3) -> CDVolume
        """
        if self.__class__ == CDVolume:
            _self = None
        else:
            _self = self
        this = _Volume.new_CDVolume(_self, *args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _Volume.delete_CDVolume
    __del__ = lambda self: None

    def resize(self, *args):
        """
        resize(self, XSize, YSize, ZSize, Margin=0) -> CDVolume
        resize(self, XSize, YSize, ZSize) -> CDVolume
        resize(self, Size, Margin=0) -> CDVolume
        resize(self, Size) -> CDVolume
        """
        return _Volume.CDVolume_resize(self, *args)


    def copy(self, *args):
        """
        copy(self, Volume, Margin=-1) -> CDVolume
        copy(self, Volume) -> CDVolume
        copy(self, Volume, x, y, z, XSize, YSize, ZSize, Margin=-1) -> CDVolume
        copy(self, Volume, x, y, z, XSize, YSize, ZSize) -> CDVolume
        copy(self, Volume, Margin=-1) -> CDVolume
        copy(self, Volume) -> CDVolume
        """
        return _Volume.CDVolume_copy(self, *args)


    def makeRef(self, *args):
        """
        makeRef(self, Volume) -> CDVolume
        makeRef(self, Volume, x, y, z, XSize, YSize, ZSize) -> CDVolume
        makeRef(self, Volume) -> CDVolume
        """
        return _Volume.CDVolume_makeRef(self, *args)


    def getSize(self, *args):
        """
        getSize(self) -> CSize3_int
        getSize(self) -> CSize3_int
        """
        return _Volume.CDVolume_getSize(self, *args)


    def getXSize(self):
        """getXSize(self) -> vpl::tSize"""
        return _Volume.CDVolume_getXSize(self)


    def getYSize(self):
        """getYSize(self) -> vpl::tSize"""
        return _Volume.CDVolume_getYSize(self)


    def getZSize(self):
        """getZSize(self) -> vpl::tSize"""
        return _Volume.CDVolume_getZSize(self)


    def width(self):
        """width(self) -> vpl::tSize"""
        return _Volume.CDVolume_width(self)


    def height(self):
        """height(self) -> vpl::tSize"""
        return _Volume.CDVolume_height(self)


    def depth(self):
        """depth(self) -> vpl::tSize"""
        return _Volume.CDVolume_depth(self)


    def getXOffset(self):
        """getXOffset(self) -> vpl::tSize"""
        return _Volume.CDVolume_getXOffset(self)


    def getYOffset(self):
        """getYOffset(self) -> vpl::tSize"""
        return _Volume.CDVolume_getYOffset(self)


    def getZOffset(self):
        """getZOffset(self) -> vpl::tSize"""
        return _Volume.CDVolume_getZOffset(self)


    def getMargin(self):
        """getMargin(self) -> vpl::tSize"""
        return _Volume.CDVolume_getMargin(self)


    def getIdx(self, x, y, z):
        """getIdx(self, x, y, z) -> vpl::tSize"""
        return _Volume.CDVolume_getIdx(self, x, y, z)


    def __call__(self, *args):
        """
        __call__(self, x, y, z) -> __int16
        __call__(self, x, y, z) -> __int16 const
        __call__(self, i) -> __int16
        __call__(self, i) -> __int16 const &
        """
        return _Volume.CDVolume___call__(self, *args)


    def at(self, *args):
        """
        at(self, x, y, z) -> __int16 const
        at(self, i) -> __int16 const &
        """
        return _Volume.CDVolume_at(self, *args)


    def set(self, *args):
        """
        set(self, x, y, z, Value) -> CDVolume
        set(self, i, Value) -> CDVolume
        """
        return _Volume.CDVolume_set(self, *args)


    def getPtr(self, *args):
        """
        getPtr(self) -> __int16
        getPtr(self) -> __int16 const
        getPtr(self, x, y, z) -> __int16
        getPtr(self, x, y, z) -> __int16 const *
        """
        return _Volume.CDVolume_getPtr(self, *args)


    def getRowPtr(self, *args):
        """
        getRowPtr(self, y, z) -> __int16
        getRowPtr(self, y, z) -> __int16 const *
        """
        return _Volume.CDVolume_getRowPtr(self, *args)


    def rect(self, *args):
        """
        rect(self, Position, Size) -> vpl::img::CVolume< __int16,vpl::base::CPartedData >::tRect
        rect(self, Position, Size) -> vpl::img::CVolume< __int16,vpl::base::CPartedData >::tRect const
        rect(self, XRange, YRange, ZRange) -> vpl::img::CVolume< __int16,vpl::base::CPartedData >::tRect
        rect(self, XRange, YRange, ZRange) -> vpl::img::CVolume< __int16,vpl::base::CPartedData >::tRect const
        """
        return _Volume.CDVolume_rect(self, *args)


    def row(self, *args):
        """
        row(self, y, z) -> vpl::img::CVolume< __int16,vpl::base::CPartedData >::tRow
        row(self, y, z) -> vpl::img::CVolume< __int16,vpl::base::CPartedData >::tRow const
        """
        return _Volume.CDVolume_row(self, *args)


    def fill(self, c):
        """fill(self, c) -> CDVolume"""
        return _Volume.CDVolume_fill(self, c)


    def fillEntire(self, c):
        """fillEntire(self, c) -> CDVolume"""
        return _Volume.CDVolume_fillEntire(self, c)


    def fillMargin(self, c):
        """fillMargin(self, c) -> CDVolume"""
        return _Volume.CDVolume_fillMargin(self, c)


    def mirrorMargin(self):
        """mirrorMargin(self) -> CDVolume"""
        return _Volume.CDVolume_mirrorMargin(self)


    def replace(self, Value, NewValue):
        """replace(self, Value, NewValue) -> CDVolume"""
        return _Volume.CDVolume_replace(self, Value, NewValue)


    def abs(self):
        """abs(self) -> CDVolume"""
        return _Volume.CDVolume_abs(self)


    def limit(self, Lower, Upper):
        """limit(self, Lower, Upper) -> CDVolume"""
        return _Volume.CDVolume_limit(self, Lower, Upper)


    def cut(self, Lower, Upper):
        """cut(self, Lower, Upper) -> CDVolume"""
        return _Volume.CDVolume_cut(self, Lower, Upper)


    def subSample(self, Volume, l=2, m=2, n=2):
        """
        subSample(self, Volume, l=2, m=2, n=2) -> CDVolume
        subSample(self, Volume, l=2, m=2) -> CDVolume
        subSample(self, Volume, l=2) -> CDVolume
        subSample(self, Volume) -> CDVolume
        """
        return _Volume.CDVolume_subSample(self, Volume, l, m, n)


    def interpolate(self, Point):
        """interpolate(self, Point) -> __int16"""
        return _Volume.CDVolume_interpolate(self, Point)


    def color2Voxel(self, Color):
        """color2Voxel(self, Color) -> __int16"""
        return _Volume.CDVolume_color2Voxel(self, Color)


    def checkPosition(self, x, y, z):
        """checkPosition(self, x, y, z) -> bool"""
        return _Volume.CDVolume_checkPosition(self, x, y, z)


    def getPlaneXY(self, z, Plane):
        """getPlaneXY(self, z, Plane) -> bool"""
        return _Volume.CDVolume_getPlaneXY(self, z, Plane)


    def getPlaneXZ(self, y, Plane):
        """getPlaneXZ(self, y, Plane) -> bool"""
        return _Volume.CDVolume_getPlaneXZ(self, y, Plane)


    def getPlaneYZ(self, x, Plane):
        """getPlaneYZ(self, x, Plane) -> bool"""
        return _Volume.CDVolume_getPlaneYZ(self, x, Plane)


    def setPlaneXY(self, z, Plane):
        """setPlaneXY(self, z, Plane) -> bool"""
        return _Volume.CDVolume_setPlaneXY(self, z, Plane)


    def setPlaneXZ(self, y, Plane):
        """setPlaneXZ(self, y, Plane) -> bool"""
        return _Volume.CDVolume_setPlaneXZ(self, y, Plane)


    def setPlaneYZ(self, x, Plane):
        """setPlaneYZ(self, x, Plane) -> bool"""
        return _Volume.CDVolume_setPlaneYZ(self, x, Plane)


    def enableDummyMode(self, Enable):
        """enableDummyMode(self, Enable) -> CDVolume"""
        return _Volume.CDVolume_enableDummyMode(self, Enable)


    def isDummy(self):
        """isDummy(self) -> bool"""
        return _Volume.CDVolume_isDummy(self)

    def __disown__(self):
        self.this.disown()
        _Volume.disown_CDVolume(self)
        return weakref_proxy(self)
CDVolume_swigregister = _Volume.CDVolume_swigregister
CDVolume_swigregister(CDVolume)

class CRGBAVolume(VPLSwig.Core.Core.CObject, swig_base_RGBAVolume, VPLSwig.Image.Image.CSerializable):
    """Proxy of C++ vpl::img::CVolume<(vpl::img::tRGBAPixel,vpl::base::CPartedData)> class."""

    __swig_setmethods__ = {}
    for _s in [VPLSwig.Core.Core.CObject, swig_base_RGBAVolume, VPLSwig.Image.Image.CSerializable]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CRGBAVolume, name, value)
    __swig_getmethods__ = {}
    for _s in [VPLSwig.Core.Core.CObject, swig_base_RGBAVolume, VPLSwig.Image.Image.CSerializable]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CRGBAVolume, name)
    __repr__ = _swig_repr
    CLASS_VOLUME = _Volume.CRGBAVolume_CLASS_VOLUME
    ITERATOR_DECLARED = _Volume.CRGBAVolume_ITERATOR_DECLARED

    def __init__(self, *args):
        """
        __init__(self) -> CRGBAVolume
        __init__(self, XSize, YSize, ZSize, Margin=0) -> CRGBAVolume
        __init__(self, XSize, YSize, ZSize) -> CRGBAVolume
        __init__(self, Size, Margin=0) -> CRGBAVolume
        __init__(self, Size) -> CRGBAVolume
        __init__(self, Volume, x, y, z, XSize, YSize, ZSize) -> CRGBAVolume
        __init__(self, Volume, x, y, z, XSize, YSize, ZSize, arg9) -> CRGBAVolume
        __init__(self, Volume) -> CRGBAVolume
        __init__(self, Volume, arg3) -> CRGBAVolume
        __init__(self, Volume) -> CRGBAVolume
        __init__(self, Volume, arg3) -> CRGBAVolume
        """
        if self.__class__ == CRGBAVolume:
            _self = None
        else:
            _self = self
        this = _Volume.new_CRGBAVolume(_self, *args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _Volume.delete_CRGBAVolume
    __del__ = lambda self: None

    def resize(self, *args):
        """
        resize(self, XSize, YSize, ZSize, Margin=0) -> CRGBAVolume
        resize(self, XSize, YSize, ZSize) -> CRGBAVolume
        resize(self, Size, Margin=0) -> CRGBAVolume
        resize(self, Size) -> CRGBAVolume
        """
        return _Volume.CRGBAVolume_resize(self, *args)


    def copy(self, *args):
        """
        copy(self, Volume, Margin=-1) -> CRGBAVolume
        copy(self, Volume) -> CRGBAVolume
        copy(self, Volume, x, y, z, XSize, YSize, ZSize, Margin=-1) -> CRGBAVolume
        copy(self, Volume, x, y, z, XSize, YSize, ZSize) -> CRGBAVolume
        copy(self, Volume, Margin=-1) -> CRGBAVolume
        copy(self, Volume) -> CRGBAVolume
        """
        return _Volume.CRGBAVolume_copy(self, *args)


    def makeRef(self, *args):
        """
        makeRef(self, Volume) -> CRGBAVolume
        makeRef(self, Volume, x, y, z, XSize, YSize, ZSize) -> CRGBAVolume
        makeRef(self, Volume) -> CRGBAVolume
        """
        return _Volume.CRGBAVolume_makeRef(self, *args)


    def getSize(self, *args):
        """
        getSize(self) -> CSize3_int
        getSize(self) -> CSize3_int
        """
        return _Volume.CRGBAVolume_getSize(self, *args)


    def getXSize(self):
        """getXSize(self) -> vpl::tSize"""
        return _Volume.CRGBAVolume_getXSize(self)


    def getYSize(self):
        """getYSize(self) -> vpl::tSize"""
        return _Volume.CRGBAVolume_getYSize(self)


    def getZSize(self):
        """getZSize(self) -> vpl::tSize"""
        return _Volume.CRGBAVolume_getZSize(self)


    def width(self):
        """width(self) -> vpl::tSize"""
        return _Volume.CRGBAVolume_width(self)


    def height(self):
        """height(self) -> vpl::tSize"""
        return _Volume.CRGBAVolume_height(self)


    def depth(self):
        """depth(self) -> vpl::tSize"""
        return _Volume.CRGBAVolume_depth(self)


    def getXOffset(self):
        """getXOffset(self) -> vpl::tSize"""
        return _Volume.CRGBAVolume_getXOffset(self)


    def getYOffset(self):
        """getYOffset(self) -> vpl::tSize"""
        return _Volume.CRGBAVolume_getYOffset(self)


    def getZOffset(self):
        """getZOffset(self) -> vpl::tSize"""
        return _Volume.CRGBAVolume_getZOffset(self)


    def getMargin(self):
        """getMargin(self) -> vpl::tSize"""
        return _Volume.CRGBAVolume_getMargin(self)


    def getIdx(self, x, y, z):
        """getIdx(self, x, y, z) -> vpl::tSize"""
        return _Volume.CRGBAVolume_getIdx(self, x, y, z)


    def __call__(self, *args):
        """
        __call__(self, x, y, z) -> CRGBPixel
        __call__(self, x, y, z) -> CRGBPixel
        __call__(self, i) -> CRGBPixel
        __call__(self, i) -> CRGBPixel
        """
        return _Volume.CRGBAVolume___call__(self, *args)


    def at(self, *args):
        """
        at(self, x, y, z) -> CRGBPixel
        at(self, i) -> CRGBPixel
        """
        return _Volume.CRGBAVolume_at(self, *args)


    def set(self, *args):
        """
        set(self, x, y, z, Value) -> CRGBAVolume
        set(self, i, Value) -> CRGBAVolume
        """
        return _Volume.CRGBAVolume_set(self, *args)


    def getPtr(self, *args):
        """
        getPtr(self) -> CRGBPixel
        getPtr(self) -> CRGBPixel
        getPtr(self, x, y, z) -> CRGBPixel
        getPtr(self, x, y, z) -> CRGBPixel
        """
        return _Volume.CRGBAVolume_getPtr(self, *args)


    def getRowPtr(self, *args):
        """
        getRowPtr(self, y, z) -> CRGBPixel
        getRowPtr(self, y, z) -> CRGBPixel
        """
        return _Volume.CRGBAVolume_getRowPtr(self, *args)


    def rect(self, *args):
        """
        rect(self, Position, Size) -> vpl::img::CVolume< vpl::img::CRGBPixel,vpl::base::CPartedData >::tRect
        rect(self, Position, Size) -> vpl::img::CVolume< vpl::img::CRGBPixel,vpl::base::CPartedData >::tRect const
        rect(self, XRange, YRange, ZRange) -> vpl::img::CVolume< vpl::img::CRGBPixel,vpl::base::CPartedData >::tRect
        rect(self, XRange, YRange, ZRange) -> vpl::img::CVolume< vpl::img::CRGBPixel,vpl::base::CPartedData >::tRect const
        """
        return _Volume.CRGBAVolume_rect(self, *args)


    def row(self, *args):
        """
        row(self, y, z) -> vpl::img::CVolume< vpl::img::CRGBPixel,vpl::base::CPartedData >::tRow
        row(self, y, z) -> vpl::img::CVolume< vpl::img::CRGBPixel,vpl::base::CPartedData >::tRow const
        """
        return _Volume.CRGBAVolume_row(self, *args)


    def fill(self, c):
        """fill(self, c) -> CRGBAVolume"""
        return _Volume.CRGBAVolume_fill(self, c)


    def fillEntire(self, c):
        """fillEntire(self, c) -> CRGBAVolume"""
        return _Volume.CRGBAVolume_fillEntire(self, c)


    def fillMargin(self, c):
        """fillMargin(self, c) -> CRGBAVolume"""
        return _Volume.CRGBAVolume_fillMargin(self, c)


    def mirrorMargin(self):
        """mirrorMargin(self) -> CRGBAVolume"""
        return _Volume.CRGBAVolume_mirrorMargin(self)


    def replace(self, Value, NewValue):
        """replace(self, Value, NewValue) -> CRGBAVolume"""
        return _Volume.CRGBAVolume_replace(self, Value, NewValue)


    def abs(self):
        """abs(self) -> CRGBAVolume"""
        return _Volume.CRGBAVolume_abs(self)


    def limit(self, Lower, Upper):
        """limit(self, Lower, Upper) -> CRGBAVolume"""
        return _Volume.CRGBAVolume_limit(self, Lower, Upper)


    def cut(self, Lower, Upper):
        """cut(self, Lower, Upper) -> CRGBAVolume"""
        return _Volume.CRGBAVolume_cut(self, Lower, Upper)


    def subSample(self, Volume, l=2, m=2, n=2):
        """
        subSample(self, Volume, l=2, m=2, n=2) -> CRGBAVolume
        subSample(self, Volume, l=2, m=2) -> CRGBAVolume
        subSample(self, Volume, l=2) -> CRGBAVolume
        subSample(self, Volume) -> CRGBAVolume
        """
        return _Volume.CRGBAVolume_subSample(self, Volume, l, m, n)


    def interpolate(self, Point):
        """interpolate(self, Point) -> CRGBPixel"""
        return _Volume.CRGBAVolume_interpolate(self, Point)


    def color2Voxel(self, Color):
        """color2Voxel(self, Color) -> CRGBPixel"""
        return _Volume.CRGBAVolume_color2Voxel(self, Color)


    def checkPosition(self, x, y, z):
        """checkPosition(self, x, y, z) -> bool"""
        return _Volume.CRGBAVolume_checkPosition(self, x, y, z)


    def getPlaneXY(self, z, Plane):
        """getPlaneXY(self, z, Plane) -> bool"""
        return _Volume.CRGBAVolume_getPlaneXY(self, z, Plane)


    def getPlaneXZ(self, y, Plane):
        """getPlaneXZ(self, y, Plane) -> bool"""
        return _Volume.CRGBAVolume_getPlaneXZ(self, y, Plane)


    def getPlaneYZ(self, x, Plane):
        """getPlaneYZ(self, x, Plane) -> bool"""
        return _Volume.CRGBAVolume_getPlaneYZ(self, x, Plane)


    def setPlaneXY(self, z, Plane):
        """setPlaneXY(self, z, Plane) -> bool"""
        return _Volume.CRGBAVolume_setPlaneXY(self, z, Plane)


    def setPlaneXZ(self, y, Plane):
        """setPlaneXZ(self, y, Plane) -> bool"""
        return _Volume.CRGBAVolume_setPlaneXZ(self, y, Plane)


    def setPlaneYZ(self, x, Plane):
        """setPlaneYZ(self, x, Plane) -> bool"""
        return _Volume.CRGBAVolume_setPlaneYZ(self, x, Plane)


    def enableDummyMode(self, Enable):
        """enableDummyMode(self, Enable) -> CRGBAVolume"""
        return _Volume.CRGBAVolume_enableDummyMode(self, Enable)


    def isDummy(self):
        """isDummy(self) -> bool"""
        return _Volume.CRGBAVolume_isDummy(self)

    def __disown__(self):
        self.this.disown()
        _Volume.disown_CRGBAVolume(self)
        return weakref_proxy(self)
CRGBAVolume_swigregister = _Volume.CRGBAVolume_swigregister
CRGBAVolume_swigregister(CRGBAVolume)

class CComplexVolume(VPLSwig.Core.Core.CObject, swig_base_ComplexVolume, VPLSwig.Image.Image.CSerializable):
    """Proxy of C++ vpl::img::CVolume<(vpl::img::tComplexPixel,vpl::base::CPartedData)> class."""

    __swig_setmethods__ = {}
    for _s in [VPLSwig.Core.Core.CObject, swig_base_ComplexVolume, VPLSwig.Image.Image.CSerializable]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CComplexVolume, name, value)
    __swig_getmethods__ = {}
    for _s in [VPLSwig.Core.Core.CObject, swig_base_ComplexVolume, VPLSwig.Image.Image.CSerializable]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CComplexVolume, name)
    __repr__ = _swig_repr
    CLASS_VOLUME = _Volume.CComplexVolume_CLASS_VOLUME
    ITERATOR_DECLARED = _Volume.CComplexVolume_ITERATOR_DECLARED

    def __init__(self, *args):
        """
        __init__(self) -> CComplexVolume
        __init__(self, XSize, YSize, ZSize, Margin=0) -> CComplexVolume
        __init__(self, XSize, YSize, ZSize) -> CComplexVolume
        __init__(self, Size, Margin=0) -> CComplexVolume
        __init__(self, Size) -> CComplexVolume
        __init__(self, Volume, x, y, z, XSize, YSize, ZSize) -> CComplexVolume
        __init__(self, Volume, x, y, z, XSize, YSize, ZSize, arg9) -> CComplexVolume
        __init__(self, Volume) -> CComplexVolume
        __init__(self, Volume, arg3) -> CComplexVolume
        __init__(self, Volume) -> CComplexVolume
        __init__(self, Volume, arg3) -> CComplexVolume
        """
        if self.__class__ == CComplexVolume:
            _self = None
        else:
            _self = self
        this = _Volume.new_CComplexVolume(_self, *args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _Volume.delete_CComplexVolume
    __del__ = lambda self: None

    def resize(self, *args):
        """
        resize(self, XSize, YSize, ZSize, Margin=0) -> CComplexVolume
        resize(self, XSize, YSize, ZSize) -> CComplexVolume
        resize(self, Size, Margin=0) -> CComplexVolume
        resize(self, Size) -> CComplexVolume
        """
        return _Volume.CComplexVolume_resize(self, *args)


    def copy(self, *args):
        """
        copy(self, Volume, Margin=-1) -> CComplexVolume
        copy(self, Volume) -> CComplexVolume
        copy(self, Volume, x, y, z, XSize, YSize, ZSize, Margin=-1) -> CComplexVolume
        copy(self, Volume, x, y, z, XSize, YSize, ZSize) -> CComplexVolume
        copy(self, Volume, Margin=-1) -> CComplexVolume
        copy(self, Volume) -> CComplexVolume
        """
        return _Volume.CComplexVolume_copy(self, *args)


    def makeRef(self, *args):
        """
        makeRef(self, Volume) -> CComplexVolume
        makeRef(self, Volume, x, y, z, XSize, YSize, ZSize) -> CComplexVolume
        makeRef(self, Volume) -> CComplexVolume
        """
        return _Volume.CComplexVolume_makeRef(self, *args)


    def getSize(self, *args):
        """
        getSize(self) -> CSize3_int
        getSize(self) -> CSize3_int
        """
        return _Volume.CComplexVolume_getSize(self, *args)


    def getXSize(self):
        """getXSize(self) -> vpl::tSize"""
        return _Volume.CComplexVolume_getXSize(self)


    def getYSize(self):
        """getYSize(self) -> vpl::tSize"""
        return _Volume.CComplexVolume_getYSize(self)


    def getZSize(self):
        """getZSize(self) -> vpl::tSize"""
        return _Volume.CComplexVolume_getZSize(self)


    def width(self):
        """width(self) -> vpl::tSize"""
        return _Volume.CComplexVolume_width(self)


    def height(self):
        """height(self) -> vpl::tSize"""
        return _Volume.CComplexVolume_height(self)


    def depth(self):
        """depth(self) -> vpl::tSize"""
        return _Volume.CComplexVolume_depth(self)


    def getXOffset(self):
        """getXOffset(self) -> vpl::tSize"""
        return _Volume.CComplexVolume_getXOffset(self)


    def getYOffset(self):
        """getYOffset(self) -> vpl::tSize"""
        return _Volume.CComplexVolume_getYOffset(self)


    def getZOffset(self):
        """getZOffset(self) -> vpl::tSize"""
        return _Volume.CComplexVolume_getZOffset(self)


    def getMargin(self):
        """getMargin(self) -> vpl::tSize"""
        return _Volume.CComplexVolume_getMargin(self)


    def getIdx(self, x, y, z):
        """getIdx(self, x, y, z) -> vpl::tSize"""
        return _Volume.CComplexVolume_getIdx(self, x, y, z)


    def __call__(self, *args):
        """
        __call__(self, x, y, z) -> vpl::math::CComplex< float >
        __call__(self, x, y, z) -> vpl::math::CComplex< float > const
        __call__(self, i) -> vpl::math::CComplex< float >
        __call__(self, i) -> vpl::math::CComplex< float > const &
        """
        return _Volume.CComplexVolume___call__(self, *args)


    def at(self, *args):
        """
        at(self, x, y, z) -> vpl::math::CComplex< float > const
        at(self, i) -> vpl::math::CComplex< float > const &
        """
        return _Volume.CComplexVolume_at(self, *args)


    def set(self, *args):
        """
        set(self, x, y, z, Value) -> CComplexVolume
        set(self, i, Value) -> CComplexVolume
        """
        return _Volume.CComplexVolume_set(self, *args)


    def getPtr(self, *args):
        """
        getPtr(self) -> vpl::math::CComplex< float >
        getPtr(self) -> vpl::math::CComplex< float > const
        getPtr(self, x, y, z) -> vpl::math::CComplex< float >
        getPtr(self, x, y, z) -> vpl::math::CComplex< float > const *
        """
        return _Volume.CComplexVolume_getPtr(self, *args)


    def getRowPtr(self, *args):
        """
        getRowPtr(self, y, z) -> vpl::math::CComplex< float >
        getRowPtr(self, y, z) -> vpl::math::CComplex< float > const *
        """
        return _Volume.CComplexVolume_getRowPtr(self, *args)


    def rect(self, *args):
        """
        rect(self, Position, Size) -> vpl::img::CVolume< vpl::math::CComplex< float >,vpl::base::CPartedData >::tRect
        rect(self, Position, Size) -> vpl::img::CVolume< vpl::math::CComplex< float >,vpl::base::CPartedData >::tRect const
        rect(self, XRange, YRange, ZRange) -> vpl::img::CVolume< vpl::math::CComplex< float >,vpl::base::CPartedData >::tRect
        rect(self, XRange, YRange, ZRange) -> vpl::img::CVolume< vpl::math::CComplex< float >,vpl::base::CPartedData >::tRect const
        """
        return _Volume.CComplexVolume_rect(self, *args)


    def row(self, *args):
        """
        row(self, y, z) -> vpl::img::CVolume< vpl::math::CComplex< float >,vpl::base::CPartedData >::tRow
        row(self, y, z) -> vpl::img::CVolume< vpl::math::CComplex< float >,vpl::base::CPartedData >::tRow const
        """
        return _Volume.CComplexVolume_row(self, *args)


    def fill(self, c):
        """fill(self, c) -> CComplexVolume"""
        return _Volume.CComplexVolume_fill(self, c)


    def fillEntire(self, c):
        """fillEntire(self, c) -> CComplexVolume"""
        return _Volume.CComplexVolume_fillEntire(self, c)


    def fillMargin(self, c):
        """fillMargin(self, c) -> CComplexVolume"""
        return _Volume.CComplexVolume_fillMargin(self, c)


    def mirrorMargin(self):
        """mirrorMargin(self) -> CComplexVolume"""
        return _Volume.CComplexVolume_mirrorMargin(self)


    def replace(self, Value, NewValue):
        """replace(self, Value, NewValue) -> CComplexVolume"""
        return _Volume.CComplexVolume_replace(self, Value, NewValue)


    def abs(self):
        """abs(self) -> CComplexVolume"""
        return _Volume.CComplexVolume_abs(self)


    def limit(self, Lower, Upper):
        """limit(self, Lower, Upper) -> CComplexVolume"""
        return _Volume.CComplexVolume_limit(self, Lower, Upper)


    def cut(self, Lower, Upper):
        """cut(self, Lower, Upper) -> CComplexVolume"""
        return _Volume.CComplexVolume_cut(self, Lower, Upper)


    def subSample(self, Volume, l=2, m=2, n=2):
        """
        subSample(self, Volume, l=2, m=2, n=2) -> CComplexVolume
        subSample(self, Volume, l=2, m=2) -> CComplexVolume
        subSample(self, Volume, l=2) -> CComplexVolume
        subSample(self, Volume) -> CComplexVolume
        """
        return _Volume.CComplexVolume_subSample(self, Volume, l, m, n)


    def interpolate(self, Point):
        """interpolate(self, Point) -> vpl::math::CComplex< float >"""
        return _Volume.CComplexVolume_interpolate(self, Point)


    def color2Voxel(self, Color):
        """color2Voxel(self, Color) -> vpl::math::CComplex< float >"""
        return _Volume.CComplexVolume_color2Voxel(self, Color)


    def checkPosition(self, x, y, z):
        """checkPosition(self, x, y, z) -> bool"""
        return _Volume.CComplexVolume_checkPosition(self, x, y, z)


    def getPlaneXY(self, z, Plane):
        """getPlaneXY(self, z, Plane) -> bool"""
        return _Volume.CComplexVolume_getPlaneXY(self, z, Plane)


    def getPlaneXZ(self, y, Plane):
        """getPlaneXZ(self, y, Plane) -> bool"""
        return _Volume.CComplexVolume_getPlaneXZ(self, y, Plane)


    def getPlaneYZ(self, x, Plane):
        """getPlaneYZ(self, x, Plane) -> bool"""
        return _Volume.CComplexVolume_getPlaneYZ(self, x, Plane)


    def setPlaneXY(self, z, Plane):
        """setPlaneXY(self, z, Plane) -> bool"""
        return _Volume.CComplexVolume_setPlaneXY(self, z, Plane)


    def setPlaneXZ(self, y, Plane):
        """setPlaneXZ(self, y, Plane) -> bool"""
        return _Volume.CComplexVolume_setPlaneXZ(self, y, Plane)


    def setPlaneYZ(self, x, Plane):
        """setPlaneYZ(self, x, Plane) -> bool"""
        return _Volume.CComplexVolume_setPlaneYZ(self, x, Plane)


    def enableDummyMode(self, Enable):
        """enableDummyMode(self, Enable) -> CComplexVolume"""
        return _Volume.CComplexVolume_enableDummyMode(self, Enable)


    def isDummy(self):
        """isDummy(self) -> bool"""
        return _Volume.CComplexVolume_isDummy(self)

    def __disown__(self):
        self.this.disown()
        _Volume.disown_CComplexVolume(self)
        return weakref_proxy(self)
CComplexVolume_swigregister = _Volume.CComplexVolume_swigregister
CComplexVolume_swigregister(CComplexVolume)

class CDensityVolume(CDVolume):
    """Proxy of C++ vpl::img::CDensityVolume class."""

    __swig_setmethods__ = {}
    for _s in [CDVolume]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CDensityVolume, name, value)
    __swig_getmethods__ = {}
    for _s in [CDVolume]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CDensityVolume, name)
    __repr__ = _swig_repr

    def getName():
        """getName() -> char const *"""
        return _Volume.CDensityVolume_getName()

    getName = staticmethod(getName)

    def getCompression():
        """getCompression() -> int"""
        return _Volume.CDensityVolume_getCompression()

    getCompression = staticmethod(getCompression)
    DEFAULT_MARGIN = _Volume.CDensityVolume_DEFAULT_MARGIN

    def __init__(self, *args):
        """
        __init__(self) -> CDensityVolume
        __init__(self, XSize, YSize, ZSize, Margin) -> CDensityVolume
        __init__(self, XSize, YSize, ZSize) -> CDensityVolume
        __init__(self, Volume) -> CDensityVolume
        __init__(self, Volume, arg3) -> CDensityVolume
        __init__(self, Volume) -> CDensityVolume
        __init__(self, Volume, arg3) -> CDensityVolume
        """
        if self.__class__ == CDensityVolume:
            _self = None
        else:
            _self = self
        this = _Volume.new_CDensityVolume(_self, *args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _Volume.delete_CDensityVolume
    __del__ = lambda self: None

    def resize(self, *args):
        """
        resize(self, XSize, YSize, ZSize, Margin) -> CDensityVolume
        resize(self, XSize, YSize, ZSize) -> CDensityVolume
        resize(self, Size, Margin) -> CDensityVolume
        resize(self, Size) -> CDensityVolume
        """
        return _Volume.CDensityVolume_resize(self, *args)


    def copy(self, *args):
        """
        copy(self, Volume, Margin=-1) -> CDensityVolume
        copy(self, Volume) -> CDensityVolume
        copy(self, Volume, Margin=-1) -> CDensityVolume
        copy(self, Volume) -> CDensityVolume
        """
        return _Volume.CDensityVolume_copy(self, *args)


    def makeRef(self, *args):
        """
        makeRef(self, Volume) -> CDensityVolume
        makeRef(self, Volume) -> CDensityVolume
        """
        return _Volume.CDensityVolume_makeRef(self, *args)


    def copyProps(self, Volume):
        """copyProps(self, Volume) -> CDensityVolume"""
        return _Volume.CDensityVolume_copyProps(self, Volume)


    def getDX(self):
        """getDX(self) -> double"""
        return _Volume.CDensityVolume_getDX(self)


    def getDY(self):
        """getDY(self) -> double"""
        return _Volume.CDensityVolume_getDY(self)


    def getDZ(self):
        """getDZ(self) -> double"""
        return _Volume.CDensityVolume_getDZ(self)


    def setDX(self, dValue):
        """setDX(self, dValue) -> CDensityVolume"""
        return _Volume.CDensityVolume_setDX(self, dValue)


    def setDY(self, dValue):
        """setDY(self, dValue) -> CDensityVolume"""
        return _Volume.CDensityVolume_setDY(self, dValue)


    def setDZ(self, dValue):
        """setDZ(self, dValue) -> CDensityVolume"""
        return _Volume.CDensityVolume_setDZ(self, dValue)


    def setVoxel(self, dDX, dDY, dDZ):
        """setVoxel(self, dDX, dDY, dDZ) -> CDensityVolume"""
        return _Volume.CDensityVolume_setVoxel(self, dDX, dDY, dDZ)


    def makeVolume(self, *args):
        """
        makeVolume(self, Slices, BorderValue) -> bool
        makeVolume(self, Slices) -> bool
        """
        return _Volume.CDensityVolume_makeVolume(self, *args)


    def getSliceXY(self, *args):
        """
        getSliceXY(self, z, Plane) -> bool
        getSliceXY(self, dZ, Plane) -> bool
        """
        return _Volume.CDensityVolume_getSliceXY(self, *args)


    def getSliceXZ(self, *args):
        """
        getSliceXZ(self, y, Plane) -> bool
        getSliceXZ(self, dY, Plane) -> bool
        """
        return _Volume.CDensityVolume_getSliceXZ(self, *args)


    def getSliceYZ(self, *args):
        """
        getSliceYZ(self, x, Plane) -> bool
        getSliceYZ(self, dX, Plane) -> bool
        """
        return _Volume.CDensityVolume_getSliceYZ(self, *args)


    def getSlice(self, dPosition, Plane):
        """getSlice(self, dPosition, Plane) -> bool"""
        return _Volume.CDensityVolume_getSlice(self, dPosition, Plane)


    def initSlice(self, Slice, eOrientation):
        """initSlice(self, Slice, eOrientation)"""
        return _Volume.CDensityVolume_initSlice(self, Slice, eOrientation)

    def __disown__(self):
        self.this.disown()
        _Volume.disown_CDensityVolume(self)
        return weakref_proxy(self)
CDensityVolume_swigregister = _Volume.CDensityVolume_swigregister
CDensityVolume_swigregister(CDensityVolume)

def CDensityVolume_getName():
    """CDensityVolume_getName() -> char const *"""
    return _Volume.CDensityVolume_getName()

def CDensityVolume_getCompression():
    """CDensityVolume_getCompression() -> int"""
    return _Volume.CDensityVolume_getCompression()

class sp_densityVolume(_object):
    """Proxy of C++ vpl::base::CSharedPtr<(vpl::img::CDensityVolume)> class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, sp_densityVolume, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, sp_densityVolume, name)
    __repr__ = _swig_repr
    TEMPLATE_PARAMETER_IS_NOT_OBJECT = _Volume.sp_densityVolume_TEMPLATE_PARAMETER_IS_NOT_OBJECT

    def __init__(self, *args):
        """
        __init__(self) -> sp_densityVolume
        __init__(self, p) -> sp_densityVolume
        __init__(self, p) -> sp_densityVolume
        """
        this = _Volume.new_sp_densityVolume(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _Volume.delete_sp_densityVolume
    __del__ = lambda self: None

    def __deref__(self):
        """__deref__(self) -> CDensityVolume"""
        return _Volume.sp_densityVolume___deref__(self)


    def __ref__(self):
        """__ref__(self) -> CDensityVolume"""
        return _Volume.sp_densityVolume___ref__(self)


    def get(self, *args):
        """
        get(self) -> CDensityVolume
        get(self) -> CDensityVolume
        """
        return _Volume.sp_densityVolume_get(self, *args)


    def release(self):
        """release(self) -> CDensityVolume"""
        return _Volume.sp_densityVolume_release(self)


    def getName(self):
        """getName(self) -> char const *"""
        return _Volume.sp_densityVolume_getName(self)


    def getCompression(self):
        """getCompression(self) -> int"""
        return _Volume.sp_densityVolume_getCompression(self)


    def resize(self, *args):
        """
        resize(self, XSize, YSize, ZSize, Margin) -> CDensityVolume
        resize(self, XSize, YSize, ZSize) -> CDensityVolume
        resize(self, Size, Margin) -> CDensityVolume
        resize(self, Size) -> CDensityVolume
        """
        return _Volume.sp_densityVolume_resize(self, *args)


    def copy(self, *args):
        """
        copy(self, Volume, Margin=-1) -> CDensityVolume
        copy(self, Volume) -> CDensityVolume
        copy(self, Volume, Margin=-1) -> CDensityVolume
        copy(self, Volume) -> CDensityVolume
        """
        return _Volume.sp_densityVolume_copy(self, *args)


    def makeRef(self, *args):
        """
        makeRef(self, Volume) -> CDensityVolume
        makeRef(self, Volume) -> CDensityVolume
        """
        return _Volume.sp_densityVolume_makeRef(self, *args)


    def copyProps(self, Volume):
        """copyProps(self, Volume) -> CDensityVolume"""
        return _Volume.sp_densityVolume_copyProps(self, Volume)


    def getDX(self):
        """getDX(self) -> double"""
        return _Volume.sp_densityVolume_getDX(self)


    def getDY(self):
        """getDY(self) -> double"""
        return _Volume.sp_densityVolume_getDY(self)


    def getDZ(self):
        """getDZ(self) -> double"""
        return _Volume.sp_densityVolume_getDZ(self)


    def setDX(self, dValue):
        """setDX(self, dValue) -> CDensityVolume"""
        return _Volume.sp_densityVolume_setDX(self, dValue)


    def setDY(self, dValue):
        """setDY(self, dValue) -> CDensityVolume"""
        return _Volume.sp_densityVolume_setDY(self, dValue)


    def setDZ(self, dValue):
        """setDZ(self, dValue) -> CDensityVolume"""
        return _Volume.sp_densityVolume_setDZ(self, dValue)


    def setVoxel(self, dDX, dDY, dDZ):
        """setVoxel(self, dDX, dDY, dDZ) -> CDensityVolume"""
        return _Volume.sp_densityVolume_setVoxel(self, dDX, dDY, dDZ)


    def makeVolume(self, *args):
        """
        makeVolume(self, Slices, BorderValue) -> bool
        makeVolume(self, Slices) -> bool
        """
        return _Volume.sp_densityVolume_makeVolume(self, *args)


    def getSliceXY(self, *args):
        """
        getSliceXY(self, z, Plane) -> bool
        getSliceXY(self, dZ, Plane) -> bool
        """
        return _Volume.sp_densityVolume_getSliceXY(self, *args)


    def getSliceXZ(self, *args):
        """
        getSliceXZ(self, y, Plane) -> bool
        getSliceXZ(self, dY, Plane) -> bool
        """
        return _Volume.sp_densityVolume_getSliceXZ(self, *args)


    def getSliceYZ(self, *args):
        """
        getSliceYZ(self, x, Plane) -> bool
        getSliceYZ(self, dX, Plane) -> bool
        """
        return _Volume.sp_densityVolume_getSliceYZ(self, *args)


    def getSlice(self, dPosition, Plane):
        """getSlice(self, dPosition, Plane) -> bool"""
        return _Volume.sp_densityVolume_getSlice(self, dPosition, Plane)


    def initSlice(self, Slice, eOrientation):
        """initSlice(self, Slice, eOrientation)"""
        return _Volume.sp_densityVolume_initSlice(self, Slice, eOrientation)


    def getSize(self, *args):
        """
        getSize(self) -> CSize3_int
        getSize(self) -> CSize3_int
        """
        return _Volume.sp_densityVolume_getSize(self, *args)


    def getXSize(self):
        """getXSize(self) -> vpl::tSize"""
        return _Volume.sp_densityVolume_getXSize(self)


    def getYSize(self):
        """getYSize(self) -> vpl::tSize"""
        return _Volume.sp_densityVolume_getYSize(self)


    def getZSize(self):
        """getZSize(self) -> vpl::tSize"""
        return _Volume.sp_densityVolume_getZSize(self)


    def width(self):
        """width(self) -> vpl::tSize"""
        return _Volume.sp_densityVolume_width(self)


    def height(self):
        """height(self) -> vpl::tSize"""
        return _Volume.sp_densityVolume_height(self)


    def depth(self):
        """depth(self) -> vpl::tSize"""
        return _Volume.sp_densityVolume_depth(self)


    def getXOffset(self):
        """getXOffset(self) -> vpl::tSize"""
        return _Volume.sp_densityVolume_getXOffset(self)


    def getYOffset(self):
        """getYOffset(self) -> vpl::tSize"""
        return _Volume.sp_densityVolume_getYOffset(self)


    def getZOffset(self):
        """getZOffset(self) -> vpl::tSize"""
        return _Volume.sp_densityVolume_getZOffset(self)


    def getMargin(self):
        """getMargin(self) -> vpl::tSize"""
        return _Volume.sp_densityVolume_getMargin(self)


    def __call__(self, *args):
        """
        __call__(self, x, y, z) -> __int16
        __call__(self, x, y, z) -> __int16 const
        __call__(self, i) -> __int16
        __call__(self, i) -> __int16 const &
        """
        return _Volume.sp_densityVolume___call__(self, *args)


    def at(self, *args):
        """
        at(self, x, y, z) -> __int16 const
        at(self, i) -> __int16 const &
        """
        return _Volume.sp_densityVolume_at(self, *args)


    def set(self, *args):
        """
        set(self, x, y, z, Value) -> CDVolume
        set(self, i, Value) -> CDVolume
        """
        return _Volume.sp_densityVolume_set(self, *args)


    def getIdx(self, x, y, z):
        """getIdx(self, x, y, z) -> vpl::tSize"""
        return _Volume.sp_densityVolume_getIdx(self, x, y, z)


    def getPtr(self, *args):
        """
        getPtr(self) -> __int16
        getPtr(self) -> __int16 const
        getPtr(self, x, y, z) -> __int16
        getPtr(self, x, y, z) -> __int16 const *
        """
        return _Volume.sp_densityVolume_getPtr(self, *args)


    def getRowPtr(self, *args):
        """
        getRowPtr(self, y, z) -> __int16
        getRowPtr(self, y, z) -> __int16 const *
        """
        return _Volume.sp_densityVolume_getRowPtr(self, *args)


    def rect(self, *args):
        """
        rect(self, Position, Size) -> vpl::img::CVolume< __int16,vpl::base::CPartedData >::tRect
        rect(self, Position, Size) -> vpl::img::CVolume< __int16,vpl::base::CPartedData >::tRect const
        rect(self, XRange, YRange, ZRange) -> vpl::img::CVolume< __int16,vpl::base::CPartedData >::tRect
        rect(self, XRange, YRange, ZRange) -> vpl::img::CVolume< __int16,vpl::base::CPartedData >::tRect const
        """
        return _Volume.sp_densityVolume_rect(self, *args)


    def row(self, *args):
        """
        row(self, y, z) -> vpl::img::CVolume< __int16,vpl::base::CPartedData >::tRow
        row(self, y, z) -> vpl::img::CVolume< __int16,vpl::base::CPartedData >::tRow const
        """
        return _Volume.sp_densityVolume_row(self, *args)


    def fill(self, c):
        """fill(self, c) -> CDVolume"""
        return _Volume.sp_densityVolume_fill(self, c)


    def fillEntire(self, c):
        """fillEntire(self, c) -> CDVolume"""
        return _Volume.sp_densityVolume_fillEntire(self, c)


    def fillMargin(self, c):
        """fillMargin(self, c) -> CDVolume"""
        return _Volume.sp_densityVolume_fillMargin(self, c)


    def mirrorMargin(self):
        """mirrorMargin(self) -> CDVolume"""
        return _Volume.sp_densityVolume_mirrorMargin(self)


    def replace(self, Value, NewValue):
        """replace(self, Value, NewValue) -> CDVolume"""
        return _Volume.sp_densityVolume_replace(self, Value, NewValue)


    def abs(self):
        """abs(self) -> CDVolume"""
        return _Volume.sp_densityVolume_abs(self)


    def limit(self, Lower, Upper):
        """limit(self, Lower, Upper) -> CDVolume"""
        return _Volume.sp_densityVolume_limit(self, Lower, Upper)


    def cut(self, Lower, Upper):
        """cut(self, Lower, Upper) -> CDVolume"""
        return _Volume.sp_densityVolume_cut(self, Lower, Upper)


    def subSample(self, Volume, l=2, m=2, n=2):
        """
        subSample(self, Volume, l=2, m=2, n=2) -> CDVolume
        subSample(self, Volume, l=2, m=2) -> CDVolume
        subSample(self, Volume, l=2) -> CDVolume
        subSample(self, Volume) -> CDVolume
        """
        return _Volume.sp_densityVolume_subSample(self, Volume, l, m, n)


    def interpolate(self, Point):
        """interpolate(self, Point) -> __int16"""
        return _Volume.sp_densityVolume_interpolate(self, Point)


    def color2Voxel(self, Color):
        """color2Voxel(self, Color) -> __int16"""
        return _Volume.sp_densityVolume_color2Voxel(self, Color)


    def checkPosition(self, x, y, z):
        """checkPosition(self, x, y, z) -> bool"""
        return _Volume.sp_densityVolume_checkPosition(self, x, y, z)


    def getPlaneXY(self, z, Plane):
        """getPlaneXY(self, z, Plane) -> bool"""
        return _Volume.sp_densityVolume_getPlaneXY(self, z, Plane)


    def getPlaneXZ(self, y, Plane):
        """getPlaneXZ(self, y, Plane) -> bool"""
        return _Volume.sp_densityVolume_getPlaneXZ(self, y, Plane)


    def getPlaneYZ(self, x, Plane):
        """getPlaneYZ(self, x, Plane) -> bool"""
        return _Volume.sp_densityVolume_getPlaneYZ(self, x, Plane)


    def setPlaneXY(self, z, Plane):
        """setPlaneXY(self, z, Plane) -> bool"""
        return _Volume.sp_densityVolume_setPlaneXY(self, z, Plane)


    def setPlaneXZ(self, y, Plane):
        """setPlaneXZ(self, y, Plane) -> bool"""
        return _Volume.sp_densityVolume_setPlaneXZ(self, y, Plane)


    def setPlaneYZ(self, x, Plane):
        """setPlaneYZ(self, x, Plane) -> bool"""
        return _Volume.sp_densityVolume_setPlaneYZ(self, x, Plane)


    def enableDummyMode(self, Enable):
        """enableDummyMode(self, Enable) -> CDVolume"""
        return _Volume.sp_densityVolume_enableDummyMode(self, Enable)


    def isDummy(self):
        """isDummy(self) -> bool"""
        return _Volume.sp_densityVolume_isDummy(self)


    def getReferencesCount(self):
        """getReferencesCount(self) -> int"""
        return _Volume.sp_densityVolume_getReferencesCount(self)


    def isOnHeap(self):
        """isOnHeap(self) -> bool"""
        return _Volume.sp_densityVolume_isOnHeap(self)


    def getImpl(self, *args):
        """
        getImpl(self) -> CDVolume
        getImpl(self) -> CDVolume
        """
        return _Volume.sp_densityVolume_getImpl(self, *args)


    def getBlockSize(self):
        """getBlockSize(self) -> int"""
        return _Volume.sp_densityVolume_getBlockSize(self)

sp_densityVolume_swigregister = _Volume.sp_densityVolume_swigregister
sp_densityVolume_swigregister(sp_densityVolume)

# This file is compatible with both classic and new-style classes.



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





from sys import version_info as _swig_python_version_info
if _swig_python_version_info >= (2, 7, 0):
    def swig_import_helper():
        import importlib
        pkg = __name__.rpartition('.')[0]
        mname = '.'.join((pkg, '_Volume')).lstrip('.')
        try:
            return importlib.import_module(mname)
        except ImportError:
            return importlib.import_module('_Volume')
    _Volume = swig_import_helper()
    del swig_import_helper
elif _swig_python_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('_Volume', [dirname(__file__)])
        except ImportError:
            import _Volume
            return _Volume
        if fp is not None:
            try:
                _mod = imp.load_module('_Volume', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _Volume = swig_import_helper()
    del swig_import_helper
else:
    import _Volume
del _swig_python_version_info
try:
    _swig_property = property
except NameError:
    pass  # Python < 2.2 doesn't have 'property'.

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

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):
        if _newclass:
            object.__setattr__(self, name, value)
        else:
            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("'%s' object has no attribute '%s'" % (class_type.__name__, name))


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

try:
    _object = object
    _newclass = 1
except __builtin__.Exception:
    class _object:
        pass
    _newclass = 0

try:
    import weakref
    weakref_proxy = weakref.proxy
except __builtin__.Exception:
    weakref_proxy = lambda x: x


import VPLSwig.Core.Core
import VPLSwig.Image.Image
import VPLSwig.Core.Geometry
class CVolumeView(_object):
    """Proxy of C++ vpl::img::CVolumeView class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CVolumeView, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CVolumeView, name)
    __repr__ = _swig_repr
    CLASS_VOLUME_VIEW = _Volume.CVolumeView_CLASS_VOLUME_VIEW

    def __init__(self):
        """__init__(self) -> CVolumeView"""
        this = _Volume.new_CVolumeView()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _Volume.delete_CVolumeView
    __del__ = lambda self: None
CVolumeView_swigregister = _Volume.CVolumeView_swigregister
CVolumeView_swigregister(CVolumeView)

class swig_base_Volume8(_object):
    """Proxy of C++ vpl::img::CVolumeBase<(vpl::img::CVolume<(vpl::img::tPixel8,vpl::base::CPartedData)>)> class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, swig_base_Volume8, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, swig_base_Volume8, name)

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

    def getImpl(self, *args):
        """
        getImpl(self) -> CVolume8
        getImpl(self) -> CVolume8
        """
        return _Volume.swig_base_Volume8_getImpl(self, *args)


    def getSize(self, *args):
        """
        getSize(self) -> CSize3_int
        getSize(self) -> CSize3_int
        """
        return _Volume.swig_base_Volume8_getSize(self, *args)


    def getXSize(self):
        """getXSize(self) -> vpl::tSize"""
        return _Volume.swig_base_Volume8_getXSize(self)


    def getYSize(self):
        """getYSize(self) -> vpl::tSize"""
        return _Volume.swig_base_Volume8_getYSize(self)


    def getZSize(self):
        """getZSize(self) -> vpl::tSize"""
        return _Volume.swig_base_Volume8_getZSize(self)


    def width(self):
        """width(self) -> vpl::tSize"""
        return _Volume.swig_base_Volume8_width(self)


    def height(self):
        """height(self) -> vpl::tSize"""
        return _Volume.swig_base_Volume8_height(self)


    def depth(self):
        """depth(self) -> vpl::tSize"""
        return _Volume.swig_base_Volume8_depth(self)


    def getXOffset(self):
        """getXOffset(self) -> vpl::tSize"""
        return _Volume.swig_base_Volume8_getXOffset(self)


    def getYOffset(self):
        """getYOffset(self) -> vpl::tSize"""
        return _Volume.swig_base_Volume8_getYOffset(self)


    def getZOffset(self):
        """getZOffset(self) -> vpl::tSize"""
        return _Volume.swig_base_Volume8_getZOffset(self)


    def getMargin(self):
        """getMargin(self) -> vpl::tSize"""
        return _Volume.swig_base_Volume8_getMargin(self)


    def getIdx(self, x, y, z):
        """getIdx(self, x, y, z) -> vpl::tSize"""
        return _Volume.swig_base_Volume8_getIdx(self, x, y, z)


    def __call__(self, *args):
        """
        __call__(self, x, y, z) -> vpl::img::CVolumeBase< vpl::img::CVolume< unsigned __int8,vpl::base::CPartedData > >::tVoxel
        __call__(self, x, y, z) -> vpl::img::CVolumeBase< vpl::img::CVolume< unsigned __int8,vpl::base::CPartedData > >::tVoxel const
        __call__(self, i) -> vpl::img::CVolumeBase< vpl::img::CVolume< unsigned __int8,vpl::base::CPartedData > >::tVoxel
        __call__(self, i) -> vpl::img::CVolumeBase< vpl::img::CVolume< unsigned __int8,vpl::base::CPartedData > >::tVoxel const &
        """
        return _Volume.swig_base_Volume8___call__(self, *args)


    def at(self, *args):
        """
        at(self, x, y, z) -> vpl::img::CVolumeBase< vpl::img::CVolume< unsigned __int8,vpl::base::CPartedData > >::tVoxel
        at(self, x, y, z) -> vpl::img::CVolumeBase< vpl::img::CVolume< unsigned __int8,vpl::base::CPartedData > >::tVoxel const
        at(self, i) -> vpl::img::CVolumeBase< vpl::img::CVolume< unsigned __int8,vpl::base::CPartedData > >::tVoxel
        at(self, i) -> vpl::img::CVolumeBase< vpl::img::CVolume< unsigned __int8,vpl::base::CPartedData > >::tVoxel const &
        """
        return _Volume.swig_base_Volume8_at(self, *args)


    def set(self, *args):
        """
        set(self, x, y, z, Value) -> CVolume8
        set(self, i, Value) -> CVolume8
        """
        return _Volume.swig_base_Volume8_set(self, *args)

    __swig_destroy__ = _Volume.delete_swig_base_Volume8
    __del__ = lambda self: None
swig_base_Volume8_swigregister = _Volume.swig_base_Volume8_swigregister
swig_base_Volume8_swigregister(swig_base_Volume8)

class swig_base_Volume16(_object):
    """Proxy of C++ vpl::img::CVolumeBase<(vpl::img::CVolume<(vpl::img::tPixel16,vpl::base::CPartedData)>)> class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, swig_base_Volume16, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, swig_base_Volume16, name)

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

    def getImpl(self, *args):
        """
        getImpl(self) -> CVolume16
        getImpl(self) -> CVolume16
        """
        return _Volume.swig_base_Volume16_getImpl(self, *args)


    def getSize(self, *args):
        """
        getSize(self) -> CSize3_int
        getSize(self) -> CSize3_int
        """
        return _Volume.swig_base_Volume16_getSize(self, *args)


    def getXSize(self):
        """getXSize(self) -> vpl::tSize"""
        return _Volume.swig_base_Volume16_getXSize(self)


    def getYSize(self):
        """getYSize(self) -> vpl::tSize"""
        return _Volume.swig_base_Volume16_getYSize(self)


    def getZSize(self):
        """getZSize(self) -> vpl::tSize"""
        return _Volume.swig_base_Volume16_getZSize(self)


    def width(self):
        """width(self) -> vpl::tSize"""
        return _Volume.swig_base_Volume16_width(self)


    def height(self):
        """height(self) -> vpl::tSize"""
        return _Volume.swig_base_Volume16_height(self)


    def depth(self):
        """depth(self) -> vpl::tSize"""
        return _Volume.swig_base_Volume16_depth(self)


    def getXOffset(self):
        """getXOffset(self) -> vpl::tSize"""
        return _Volume.swig_base_Volume16_getXOffset(self)


    def getYOffset(self):
        """getYOffset(self) -> vpl::tSize"""
        return _Volume.swig_base_Volume16_getYOffset(self)


    def getZOffset(self):
        """getZOffset(self) -> vpl::tSize"""
        return _Volume.swig_base_Volume16_getZOffset(self)


    def getMargin(self):
        """getMargin(self) -> vpl::tSize"""
        return _Volume.swig_base_Volume16_getMargin(self)


    def getIdx(self, x, y, z):
        """getIdx(self, x, y, z) -> vpl::tSize"""
        return _Volume.swig_base_Volume16_getIdx(self, x, y, z)


    def __call__(self, *args):
        """
        __call__(self, x, y, z) -> vpl::img::CVolumeBase< vpl::img::CVolume< unsigned __int16,vpl::base::CPartedData > >::tVoxel
        __call__(self, x, y, z) -> vpl::img::CVolumeBase< vpl::img::CVolume< unsigned __int16,vpl::base::CPartedData > >::tVoxel const
        __call__(self, i) -> vpl::img::CVolumeBase< vpl::img::CVolume< unsigned __int16,vpl::base::CPartedData > >::tVoxel
        __call__(self, i) -> vpl::img::CVolumeBase< vpl::img::CVolume< unsigned __int16,vpl::base::CPartedData > >::tVoxel const &
        """
        return _Volume.swig_base_Volume16___call__(self, *args)


    def at(self, *args):
        """
        at(self, x, y, z) -> vpl::img::CVolumeBase< vpl::img::CVolume< unsigned __int16,vpl::base::CPartedData > >::tVoxel
        at(self, x, y, z) -> vpl::img::CVolumeBase< vpl::img::CVolume< unsigned __int16,vpl::base::CPartedData > >::tVoxel const
        at(self, i) -> vpl::img::CVolumeBase< vpl::img::CVolume< unsigned __int16,vpl::base::CPartedData > >::tVoxel
        at(self, i) -> vpl::img::CVolumeBase< vpl::img::CVolume< unsigned __int16,vpl::base::CPartedData > >::tVoxel const &
        """
        return _Volume.swig_base_Volume16_at(self, *args)


    def set(self, *args):
        """
        set(self, x, y, z, Value) -> CVolume16
        set(self, i, Value) -> CVolume16
        """
        return _Volume.swig_base_Volume16_set(self, *args)

    __swig_destroy__ = _Volume.delete_swig_base_Volume16
    __del__ = lambda self: None
swig_base_Volume16_swigregister = _Volume.swig_base_Volume16_swigregister
swig_base_Volume16_swigregister(swig_base_Volume16)

class swig_base_Volume32(_object):
    """Proxy of C++ vpl::img::CVolumeBase<(vpl::img::CVolume<(vpl::img::tPixel32,vpl::base::CPartedData)>)> class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, swig_base_Volume32, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, swig_base_Volume32, name)

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

    def getImpl(self, *args):
        """
        getImpl(self) -> CVolume32
        getImpl(self) -> CVolume32
        """
        return _Volume.swig_base_Volume32_getImpl(self, *args)


    def getSize(self, *args):
        """
        getSize(self) -> CSize3_int
        getSize(self) -> CSize3_int
        """
        return _Volume.swig_base_Volume32_getSize(self, *args)


    def getXSize(self):
        """getXSize(self) -> vpl::tSize"""
        return _Volume.swig_base_Volume32_getXSize(self)


    def getYSize(self):
        """getYSize(self) -> vpl::tSize"""
        return _Volume.swig_base_Volume32_getYSize(self)


    def getZSize(self):
        """getZSize(self) -> vpl::tSize"""
        return _Volume.swig_base_Volume32_getZSize(self)


    def width(self):
        """width(self) -> vpl::tSize"""
        return _Volume.swig_base_Volume32_width(self)


    def height(self):
        """height(self) -> vpl::tSize"""
        return _Volume.swig_base_Volume32_height(self)


    def depth(self):
        """depth(self) -> vpl::tSize"""
        return _Volume.swig_base_Volume32_depth(self)


    def getXOffset(self):
        """getXOffset(self) -> vpl::tSize"""
        return _Volume.swig_base_Volume32_getXOffset(self)


    def getYOffset(self):
        """getYOffset(self) -> vpl::tSize"""
        return _Volume.swig_base_Volume32_getYOffset(self)


    def getZOffset(self):
        """getZOffset(self) -> vpl::tSize"""
        return _Volume.swig_base_Volume32_getZOffset(self)


    def getMargin(self):
        """getMargin(self) -> vpl::tSize"""
        return _Volume.swig_base_Volume32_getMargin(self)


    def getIdx(self, x, y, z):
        """getIdx(self, x, y, z) -> vpl::tSize"""
        return _Volume.swig_base_Volume32_getIdx(self, x, y, z)


    def __call__(self, *args):
        """
        __call__(self, x, y, z) -> vpl::img::CVolumeBase< vpl::img::CVolume< unsigned __int32,vpl::base::CPartedData > >::tVoxel
        __call__(self, x, y, z) -> vpl::img::CVolumeBase< vpl::img::CVolume< unsigned __int32,vpl::base::CPartedData > >::tVoxel const
        __call__(self, i) -> vpl::img::CVolumeBase< vpl::img::CVolume< unsigned __int32,vpl::base::CPartedData > >::tVoxel
        __call__(self, i) -> vpl::img::CVolumeBase< vpl::img::CVolume< unsigned __int32,vpl::base::CPartedData > >::tVoxel const &
        """
        return _Volume.swig_base_Volume32___call__(self, *args)


    def at(self, *args):
        """
        at(self, x, y, z) -> vpl::img::CVolumeBase< vpl::img::CVolume< unsigned __int32,vpl::base::CPartedData > >::tVoxel
        at(self, x, y, z) -> vpl::img::CVolumeBase< vpl::img::CVolume< unsigned __int32,vpl::base::CPartedData > >::tVoxel const
        at(self, i) -> vpl::img::CVolumeBase< vpl::img::CVolume< unsigned __int32,vpl::base::CPartedData > >::tVoxel
        at(self, i) -> vpl::img::CVolumeBase< vpl::img::CVolume< unsigned __int32,vpl::base::CPartedData > >::tVoxel const &
        """
        return _Volume.swig_base_Volume32_at(self, *args)


    def set(self, *args):
        """
        set(self, x, y, z, Value) -> CVolume32
        set(self, i, Value) -> CVolume32
        """
        return _Volume.swig_base_Volume32_set(self, *args)

    __swig_destroy__ = _Volume.delete_swig_base_Volume32
    __del__ = lambda self: None
swig_base_Volume32_swigregister = _Volume.swig_base_Volume32_swigregister
swig_base_Volume32_swigregister(swig_base_Volume32)

class swig_base_FVolume(_object):
    """Proxy of C++ vpl::img::CVolumeBase<(vpl::img::CVolume<(vpl::img::tFloatPixel,vpl::base::CPartedData)>)> class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, swig_base_FVolume, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, swig_base_FVolume, name)

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

    def getImpl(self, *args):
        """
        getImpl(self) -> CFVolume
        getImpl(self) -> CFVolume
        """
        return _Volume.swig_base_FVolume_getImpl(self, *args)


    def getSize(self, *args):
        """
        getSize(self) -> CSize3_int
        getSize(self) -> CSize3_int
        """
        return _Volume.swig_base_FVolume_getSize(self, *args)


    def getXSize(self):
        """getXSize(self) -> vpl::tSize"""
        return _Volume.swig_base_FVolume_getXSize(self)


    def getYSize(self):
        """getYSize(self) -> vpl::tSize"""
        return _Volume.swig_base_FVolume_getYSize(self)


    def getZSize(self):
        """getZSize(self) -> vpl::tSize"""
        return _Volume.swig_base_FVolume_getZSize(self)


    def width(self):
        """width(self) -> vpl::tSize"""
        return _Volume.swig_base_FVolume_width(self)


    def height(self):
        """height(self) -> vpl::tSize"""
        return _Volume.swig_base_FVolume_height(self)


    def depth(self):
        """depth(self) -> vpl::tSize"""
        return _Volume.swig_base_FVolume_depth(self)


    def getXOffset(self):
        """getXOffset(self) -> vpl::tSize"""
        return _Volume.swig_base_FVolume_getXOffset(self)


    def getYOffset(self):
        """getYOffset(self) -> vpl::tSize"""
        return _Volume.swig_base_FVolume_getYOffset(self)


    def getZOffset(self):
        """getZOffset(self) -> vpl::tSize"""
        return _Volume.swig_base_FVolume_getZOffset(self)


    def getMargin(self):
        """getMargin(self) -> vpl::tSize"""
        return _Volume.swig_base_FVolume_getMargin(self)


    def getIdx(self, x, y, z):
        """getIdx(self, x, y, z) -> vpl::tSize"""
        return _Volume.swig_base_FVolume_getIdx(self, x, y, z)


    def __call__(self, *args):
        """
        __call__(self, x, y, z) -> vpl::img::CVolumeBase< vpl::img::CVolume< float,vpl::base::CPartedData > >::tVoxel
        __call__(self, x, y, z) -> vpl::img::CVolumeBase< vpl::img::CVolume< float,vpl::base::CPartedData > >::tVoxel const
        __call__(self, i) -> vpl::img::CVolumeBase< vpl::img::CVolume< float,vpl::base::CPartedData > >::tVoxel
        __call__(self, i) -> vpl::img::CVolumeBase< vpl::img::CVolume< float,vpl::base::CPartedData > >::tVoxel const &
        """
        return _Volume.swig_base_FVolume___call__(self, *args)


    def at(self, *args):
        """
        at(self, x, y, z) -> vpl::img::CVolumeBase< vpl::img::CVolume< float,vpl::base::CPartedData > >::tVoxel
        at(self, x, y, z) -> vpl::img::CVolumeBase< vpl::img::CVolume< float,vpl::base::CPartedData > >::tVoxel const
        at(self, i) -> vpl::img::CVolumeBase< vpl::img::CVolume< float,vpl::base::CPartedData > >::tVoxel
        at(self, i) -> vpl::img::CVolumeBase< vpl::img::CVolume< float,vpl::base::CPartedData > >::tVoxel const &
        """
        return _Volume.swig_base_FVolume_at(self, *args)


    def set(self, *args):
        """
        set(self, x, y, z, Value) -> CFVolume
        set(self, i, Value) -> CFVolume
        """
        return _Volume.swig_base_FVolume_set(self, *args)

    __swig_destroy__ = _Volume.delete_swig_base_FVolume
    __del__ = lambda self: None
swig_base_FVolume_swigregister = _Volume.swig_base_FVolume_swigregister
swig_base_FVolume_swigregister(swig_base_FVolume)

class swig_base_DVolume(_object):
    """Proxy of C++ vpl::img::CVolumeBase<(vpl::img::CVolume<(vpl::img::tDensityPixel,vpl::base::CPartedData)>)> class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, swig_base_DVolume, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, swig_base_DVolume, name)

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

    def getImpl(self, *args):
        """
        getImpl(self) -> CDVolume
        getImpl(self) -> CDVolume
        """
        return _Volume.swig_base_DVolume_getImpl(self, *args)


    def getSize(self, *args):
        """
        getSize(self) -> CSize3_int
        getSize(self) -> CSize3_int
        """
        return _Volume.swig_base_DVolume_getSize(self, *args)


    def getXSize(self):
        """getXSize(self) -> vpl::tSize"""
        return _Volume.swig_base_DVolume_getXSize(self)


    def getYSize(self):
        """getYSize(self) -> vpl::tSize"""
        return _Volume.swig_base_DVolume_getYSize(self)


    def getZSize(self):
        """getZSize(self) -> vpl::tSize"""
        return _Volume.swig_base_DVolume_getZSize(self)


    def width(self):
        """width(self) -> vpl::tSize"""
        return _Volume.swig_base_DVolume_width(self)


    def height(self):
        """height(self) -> vpl::tSize"""
        return _Volume.swig_base_DVolume_height(self)


    def depth(self):
        """depth(self) -> vpl::tSize"""
        return _Volume.swig_base_DVolume_depth(self)


    def getXOffset(self):
        """getXOffset(self) -> vpl::tSize"""
        return _Volume.swig_base_DVolume_getXOffset(self)


    def getYOffset(self):
        """getYOffset(self) -> vpl::tSize"""
        return _Volume.swig_base_DVolume_getYOffset(self)


    def getZOffset(self):
        """getZOffset(self) -> vpl::tSize"""
        return _Volume.swig_base_DVolume_getZOffset(self)


    def getMargin(self):
        """getMargin(self) -> vpl::tSize"""
        return _Volume.swig_base_DVolume_getMargin(self)


    def getIdx(self, x, y, z):
        """getIdx(self, x, y, z) -> vpl::tSize"""
        return _Volume.swig_base_DVolume_getIdx(self, x, y, z)


    def __call__(self, *args):
        """
        __call__(self, x, y, z) -> vpl::img::CVolumeBase< vpl::img::CVolume< __int16,vpl::base::CPartedData > >::tVoxel
        __call__(self, x, y, z) -> vpl::img::CVolumeBase< vpl::img::CVolume< __int16,vpl::base::CPartedData > >::tVoxel const
        __call__(self, i) -> vpl::img::CVolumeBase< vpl::img::CVolume< __int16,vpl::base::CPartedData > >::tVoxel
        __call__(self, i) -> vpl::img::CVolumeBase< vpl::img::CVolume< __int16,vpl::base::CPartedData > >::tVoxel const &
        """
        return _Volume.swig_base_DVolume___call__(self, *args)


    def at(self, *args):
        """
        at(self, x, y, z) -> vpl::img::CVolumeBase< vpl::img::CVolume< __int16,vpl::base::CPartedData > >::tVoxel
        at(self, x, y, z) -> vpl::img::CVolumeBase< vpl::img::CVolume< __int16,vpl::base::CPartedData > >::tVoxel const
        at(self, i) -> vpl::img::CVolumeBase< vpl::img::CVolume< __int16,vpl::base::CPartedData > >::tVoxel
        at(self, i) -> vpl::img::CVolumeBase< vpl::img::CVolume< __int16,vpl::base::CPartedData > >::tVoxel const &
        """
        return _Volume.swig_base_DVolume_at(self, *args)


    def set(self, *args):
        """
        set(self, x, y, z, Value) -> CDVolume
        set(self, i, Value) -> CDVolume
        """
        return _Volume.swig_base_DVolume_set(self, *args)

    __swig_destroy__ = _Volume.delete_swig_base_DVolume
    __del__ = lambda self: None
swig_base_DVolume_swigregister = _Volume.swig_base_DVolume_swigregister
swig_base_DVolume_swigregister(swig_base_DVolume)

class swig_base_RGBAVolume(_object):
    """Proxy of C++ vpl::img::CVolumeBase<(vpl::img::CVolume<(vpl::img::tRGBAPixel,vpl::base::CPartedData)>)> class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, swig_base_RGBAVolume, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, swig_base_RGBAVolume, name)

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

    def getImpl(self, *args):
        """
        getImpl(self) -> CRGBAVolume
        getImpl(self) -> CRGBAVolume
        """
        return _Volume.swig_base_RGBAVolume_getImpl(self, *args)


    def getSize(self, *args):
        """
        getSize(self) -> CSize3_int
        getSize(self) -> CSize3_int
        """
        return _Volume.swig_base_RGBAVolume_getSize(self, *args)


    def getXSize(self):
        """getXSize(self) -> vpl::tSize"""
        return _Volume.swig_base_RGBAVolume_getXSize(self)


    def getYSize(self):
        """getYSize(self) -> vpl::tSize"""
        return _Volume.swig_base_RGBAVolume_getYSize(self)


    def getZSize(self):
        """getZSize(self) -> vpl::tSize"""
        return _Volume.swig_base_RGBAVolume_getZSize(self)


    def width(self):
        """width(self) -> vpl::tSize"""
        return _Volume.swig_base_RGBAVolume_width(self)


    def height(self):
        """height(self) -> vpl::tSize"""
        return _Volume.swig_base_RGBAVolume_height(self)


    def depth(self):
        """depth(self) -> vpl::tSize"""
        return _Volume.swig_base_RGBAVolume_depth(self)


    def getXOffset(self):
        """getXOffset(self) -> vpl::tSize"""
        return _Volume.swig_base_RGBAVolume_getXOffset(self)


    def getYOffset(self):
        """getYOffset(self) -> vpl::tSize"""
        return _Volume.swig_base_RGBAVolume_getYOffset(self)


    def getZOffset(self):
        """getZOffset(self) -> vpl::tSize"""
        return _Volume.swig_base_RGBAVolume_getZOffset(self)


    def getMargin(self):
        """getMargin(self) -> vpl::tSize"""
        return _Volume.swig_base_RGBAVolume_getMargin(self)


    def getIdx(self, x, y, z):
        """getIdx(self, x, y, z) -> vpl::tSize"""
        return _Volume.swig_base_RGBAVolume_getIdx(self, x, y, z)


    def __call__(self, *args):
        """
        __call__(self, x, y, z) -> vpl::img::CVolumeBase< vpl::img::CVolume< vpl::img::CRGBPixel,vpl::base::CPartedData > >::tVoxel
        __call__(self, x, y, z) -> vpl::img::CVolumeBase< vpl::img::CVolume< vpl::img::CRGBPixel,vpl::base::CPartedData > >::tVoxel const
        __call__(self, i) -> vpl::img::CVolumeBase< vpl::img::CVolume< vpl::img::CRGBPixel,vpl::base::CPartedData > >::tVoxel
        __call__(self, i) -> vpl::img::CVolumeBase< vpl::img::CVolume< vpl::img::CRGBPixel,vpl::base::CPartedData > >::tVoxel const &
        """
        return _Volume.swig_base_RGBAVolume___call__(self, *args)


    def at(self, *args):
        """
        at(self, x, y, z) -> vpl::img::CVolumeBase< vpl::img::CVolume< vpl::img::CRGBPixel,vpl::base::CPartedData > >::tVoxel
        at(self, x, y, z) -> vpl::img::CVolumeBase< vpl::img::CVolume< vpl::img::CRGBPixel,vpl::base::CPartedData > >::tVoxel const
        at(self, i) -> vpl::img::CVolumeBase< vpl::img::CVolume< vpl::img::CRGBPixel,vpl::base::CPartedData > >::tVoxel
        at(self, i) -> vpl::img::CVolumeBase< vpl::img::CVolume< vpl::img::CRGBPixel,vpl::base::CPartedData > >::tVoxel const &
        """
        return _Volume.swig_base_RGBAVolume_at(self, *args)


    def set(self, *args):
        """
        set(self, x, y, z, Value) -> CRGBAVolume
        set(self, i, Value) -> CRGBAVolume
        """
        return _Volume.swig_base_RGBAVolume_set(self, *args)

    __swig_destroy__ = _Volume.delete_swig_base_RGBAVolume
    __del__ = lambda self: None
swig_base_RGBAVolume_swigregister = _Volume.swig_base_RGBAVolume_swigregister
swig_base_RGBAVolume_swigregister(swig_base_RGBAVolume)

class swig_base_ComplexVolume(_object):
    """Proxy of C++ vpl::img::CVolumeBase<(vpl::img::CVolume<(vpl::img::tComplexPixel,vpl::base::CPartedData)>)> class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, swig_base_ComplexVolume, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, swig_base_ComplexVolume, name)

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

    def getImpl(self, *args):
        """
        getImpl(self) -> CComplexVolume
        getImpl(self) -> CComplexVolume
        """
        return _Volume.swig_base_ComplexVolume_getImpl(self, *args)


    def getSize(self, *args):
        """
        getSize(self) -> CSize3_int
        getSize(self) -> CSize3_int
        """
        return _Volume.swig_base_ComplexVolume_getSize(self, *args)


    def getXSize(self):
        """getXSize(self) -> vpl::tSize"""
        return _Volume.swig_base_ComplexVolume_getXSize(self)


    def getYSize(self):
        """getYSize(self) -> vpl::tSize"""
        return _Volume.swig_base_ComplexVolume_getYSize(self)


    def getZSize(self):
        """getZSize(self) -> vpl::tSize"""
        return _Volume.swig_base_ComplexVolume_getZSize(self)


    def width(self):
        """width(self) -> vpl::tSize"""
        return _Volume.swig_base_ComplexVolume_width(self)


    def height(self):
        """height(self) -> vpl::tSize"""
        return _Volume.swig_base_ComplexVolume_height(self)


    def depth(self):
        """depth(self) -> vpl::tSize"""
        return _Volume.swig_base_ComplexVolume_depth(self)


    def getXOffset(self):
        """getXOffset(self) -> vpl::tSize"""
        return _Volume.swig_base_ComplexVolume_getXOffset(self)


    def getYOffset(self):
        """getYOffset(self) -> vpl::tSize"""
        return _Volume.swig_base_ComplexVolume_getYOffset(self)


    def getZOffset(self):
        """getZOffset(self) -> vpl::tSize"""
        return _Volume.swig_base_ComplexVolume_getZOffset(self)


    def getMargin(self):
        """getMargin(self) -> vpl::tSize"""
        return _Volume.swig_base_ComplexVolume_getMargin(self)


    def getIdx(self, x, y, z):
        """getIdx(self, x, y, z) -> vpl::tSize"""
        return _Volume.swig_base_ComplexVolume_getIdx(self, x, y, z)


    def __call__(self, *args):
        """
        __call__(self, x, y, z) -> vpl::img::CVolumeBase< vpl::img::CVolume< vpl::math::CComplex< float >,vpl::base::CPartedData > >::tVoxel
        __call__(self, x, y, z) -> vpl::img::CVolumeBase< vpl::img::CVolume< vpl::math::CComplex< float >,vpl::base::CPartedData > >::tVoxel const
        __call__(self, i) -> vpl::img::CVolumeBase< vpl::img::CVolume< vpl::math::CComplex< float >,vpl::base::CPartedData > >::tVoxel
        __call__(self, i) -> vpl::img::CVolumeBase< vpl::img::CVolume< vpl::math::CComplex< float >,vpl::base::CPartedData > >::tVoxel const &
        """
        return _Volume.swig_base_ComplexVolume___call__(self, *args)


    def at(self, *args):
        """
        at(self, x, y, z) -> vpl::img::CVolumeBase< vpl::img::CVolume< vpl::math::CComplex< float >,vpl::base::CPartedData > >::tVoxel
        at(self, x, y, z) -> vpl::img::CVolumeBase< vpl::img::CVolume< vpl::math::CComplex< float >,vpl::base::CPartedData > >::tVoxel const
        at(self, i) -> vpl::img::CVolumeBase< vpl::img::CVolume< vpl::math::CComplex< float >,vpl::base::CPartedData > >::tVoxel
        at(self, i) -> vpl::img::CVolumeBase< vpl::img::CVolume< vpl::math::CComplex< float >,vpl::base::CPartedData > >::tVoxel const &
        """
        return _Volume.swig_base_ComplexVolume_at(self, *args)


    def set(self, *args):
        """
        set(self, x, y, z, Value) -> CComplexVolume
        set(self, i, Value) -> CComplexVolume
        """
        return _Volume.swig_base_ComplexVolume_set(self, *args)

    __swig_destroy__ = _Volume.delete_swig_base_ComplexVolume
    __del__ = lambda self: None
swig_base_ComplexVolume_swigregister = _Volume.swig_base_ComplexVolume_swigregister
swig_base_ComplexVolume_swigregister(swig_base_ComplexVolume)

class CVolume8(VPLSwig.Core.Core.CObject, swig_base_Volume8, VPLSwig.Image.Image.CSerializable):
    """Proxy of C++ vpl::img::CVolume<(vpl::img::tPixel8,vpl::base::CPartedData)> class."""

    __swig_setmethods__ = {}
    for _s in [VPLSwig.Core.Core.CObject, swig_base_Volume8, VPLSwig.Image.Image.CSerializable]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CVolume8, name, value)
    __swig_getmethods__ = {}
    for _s in [VPLSwig.Core.Core.CObject, swig_base_Volume8, VPLSwig.Image.Image.CSerializable]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CVolume8, name)
    __repr__ = _swig_repr
    CLASS_VOLUME = _Volume.CVolume8_CLASS_VOLUME
    ITERATOR_DECLARED = _Volume.CVolume8_ITERATOR_DECLARED

    def __init__(self, *args):
        """
        __init__(self) -> CVolume8
        __init__(self, XSize, YSize, ZSize, Margin=0) -> CVolume8
        __init__(self, XSize, YSize, ZSize) -> CVolume8
        __init__(self, Size, Margin=0) -> CVolume8
        __init__(self, Size) -> CVolume8
        __init__(self, Volume, x, y, z, XSize, YSize, ZSize) -> CVolume8
        __init__(self, Volume, x, y, z, XSize, YSize, ZSize, arg9) -> CVolume8
        __init__(self, Volume) -> CVolume8
        __init__(self, Volume, arg3) -> CVolume8
        __init__(self, Volume) -> CVolume8
        __init__(self, Volume, arg3) -> CVolume8
        """
        if self.__class__ == CVolume8:
            _self = None
        else:
            _self = self
        this = _Volume.new_CVolume8(_self, *args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _Volume.delete_CVolume8
    __del__ = lambda self: None

    def resize(self, *args):
        """
        resize(self, XSize, YSize, ZSize, Margin=0) -> CVolume8
        resize(self, XSize, YSize, ZSize) -> CVolume8
        resize(self, Size, Margin=0) -> CVolume8
        resize(self, Size) -> CVolume8
        """
        return _Volume.CVolume8_resize(self, *args)


    def copy(self, *args):
        """
        copy(self, Volume, Margin=-1) -> CVolume8
        copy(self, Volume) -> CVolume8
        copy(self, Volume, x, y, z, XSize, YSize, ZSize, Margin=-1) -> CVolume8
        copy(self, Volume, x, y, z, XSize, YSize, ZSize) -> CVolume8
        copy(self, Volume, Margin=-1) -> CVolume8
        copy(self, Volume) -> CVolume8
        """
        return _Volume.CVolume8_copy(self, *args)


    def makeRef(self, *args):
        """
        makeRef(self, Volume) -> CVolume8
        makeRef(self, Volume, x, y, z, XSize, YSize, ZSize) -> CVolume8
        makeRef(self, Volume) -> CVolume8
        """
        return _Volume.CVolume8_makeRef(self, *args)


    def getSize(self, *args):
        """
        getSize(self) -> CSize3_int
        getSize(self) -> CSize3_int
        """
        return _Volume.CVolume8_getSize(self, *args)


    def getXSize(self):
        """getXSize(self) -> vpl::tSize"""
        return _Volume.CVolume8_getXSize(self)


    def getYSize(self):
        """getYSize(self) -> vpl::tSize"""
        return _Volume.CVolume8_getYSize(self)


    def getZSize(self):
        """getZSize(self) -> vpl::tSize"""
        return _Volume.CVolume8_getZSize(self)


    def width(self):
        """width(self) -> vpl::tSize"""
        return _Volume.CVolume8_width(self)


    def height(self):
        """height(self) -> vpl::tSize"""
        return _Volume.CVolume8_height(self)


    def depth(self):
        """depth(self) -> vpl::tSize"""
        return _Volume.CVolume8_depth(self)


    def getXOffset(self):
        """getXOffset(self) -> vpl::tSize"""
        return _Volume.CVolume8_getXOffset(self)


    def getYOffset(self):
        """getYOffset(self) -> vpl::tSize"""
        return _Volume.CVolume8_getYOffset(self)


    def getZOffset(self):
        """getZOffset(self) -> vpl::tSize"""
        return _Volume.CVolume8_getZOffset(self)


    def getMargin(self):
        """getMargin(self) -> vpl::tSize"""
        return _Volume.CVolume8_getMargin(self)


    def getIdx(self, x, y, z):
        """getIdx(self, x, y, z) -> vpl::tSize"""
        return _Volume.CVolume8_getIdx(self, x, y, z)


    def __call__(self, *args):
        """
        __call__(self, x, y, z) -> unsigned __int8
        __call__(self, x, y, z) -> unsigned __int8 const
        __call__(self, i) -> unsigned __int8
        __call__(self, i) -> unsigned __int8 const &
        """
        return _Volume.CVolume8___call__(self, *args)


    def at(self, *args):
        """
        at(self, x, y, z) -> unsigned __int8 const
        at(self, i) -> unsigned __int8 const &
        """
        return _Volume.CVolume8_at(self, *args)


    def set(self, *args):
        """
        set(self, x, y, z, Value) -> CVolume8
        set(self, i, Value) -> CVolume8
        """
        return _Volume.CVolume8_set(self, *args)


    def getPtr(self, *args):
        """
        getPtr(self) -> unsigned __int8
        getPtr(self) -> unsigned __int8 const
        getPtr(self, x, y, z) -> unsigned __int8
        getPtr(self, x, y, z) -> unsigned __int8 const *
        """
        return _Volume.CVolume8_getPtr(self, *args)


    def getRowPtr(self, *args):
        """
        getRowPtr(self, y, z) -> unsigned __int8
        getRowPtr(self, y, z) -> unsigned __int8 const *
        """
        return _Volume.CVolume8_getRowPtr(self, *args)


    def rect(self, *args):
        """
        rect(self, Position, Size) -> vpl::img::CVolume< unsigned __int8,vpl::base::CPartedData >::tRect
        rect(self, Position, Size) -> vpl::img::CVolume< unsigned __int8,vpl::base::CPartedData >::tRect const
        rect(self, XRange, YRange, ZRange) -> vpl::img::CVolume< unsigned __int8,vpl::base::CPartedData >::tRect
        rect(self, XRange, YRange, ZRange) -> vpl::img::CVolume< unsigned __int8,vpl::base::CPartedData >::tRect const
        """
        return _Volume.CVolume8_rect(self, *args)


    def row(self, *args):
        """
        row(self, y, z) -> vpl::img::CVolume< unsigned __int8,vpl::base::CPartedData >::tRow
        row(self, y, z) -> vpl::img::CVolume< unsigned __int8,vpl::base::CPartedData >::tRow const
        """
        return _Volume.CVolume8_row(self, *args)


    def fill(self, c):
        """fill(self, c) -> CVolume8"""
        return _Volume.CVolume8_fill(self, c)


    def fillEntire(self, c):
        """fillEntire(self, c) -> CVolume8"""
        return _Volume.CVolume8_fillEntire(self, c)


    def fillMargin(self, c):
        """fillMargin(self, c) -> CVolume8"""
        return _Volume.CVolume8_fillMargin(self, c)


    def mirrorMargin(self):
        """mirrorMargin(self) -> CVolume8"""
        return _Volume.CVolume8_mirrorMargin(self)


    def replace(self, Value, NewValue):
        """replace(self, Value, NewValue) -> CVolume8"""
        return _Volume.CVolume8_replace(self, Value, NewValue)


    def abs(self):
        """abs(self) -> CVolume8"""
        return _Volume.CVolume8_abs(self)


    def limit(self, Lower, Upper):
        """limit(self, Lower, Upper) -> CVolume8"""
        return _Volume.CVolume8_limit(self, Lower, Upper)


    def cut(self, Lower, Upper):
        """cut(self, Lower, Upper) -> CVolume8"""
        return _Volume.CVolume8_cut(self, Lower, Upper)


    def subSample(self, Volume, l=2, m=2, n=2):
        """
        subSample(self, Volume, l=2, m=2, n=2) -> CVolume8
        subSample(self, Volume, l=2, m=2) -> CVolume8
        subSample(self, Volume, l=2) -> CVolume8
        subSample(self, Volume) -> CVolume8
        """
        return _Volume.CVolume8_subSample(self, Volume, l, m, n)


    def interpolate(self, Point):
        """interpolate(self, Point) -> unsigned __int8"""
        return _Volume.CVolume8_interpolate(self, Point)


    def color2Voxel(self, Color):
        """color2Voxel(self, Color) -> unsigned __int8"""
        return _Volume.CVolume8_color2Voxel(self, Color)


    def checkPosition(self, x, y, z):
        """checkPosition(self, x, y, z) -> bool"""
        return _Volume.CVolume8_checkPosition(self, x, y, z)


    def getPlaneXY(self, z, Plane):
        """getPlaneXY(self, z, Plane) -> bool"""
        return _Volume.CVolume8_getPlaneXY(self, z, Plane)


    def getPlaneXZ(self, y, Plane):
        """getPlaneXZ(self, y, Plane) -> bool"""
        return _Volume.CVolume8_getPlaneXZ(self, y, Plane)


    def getPlaneYZ(self, x, Plane):
        """getPlaneYZ(self, x, Plane) -> bool"""
        return _Volume.CVolume8_getPlaneYZ(self, x, Plane)


    def setPlaneXY(self, z, Plane):
        """setPlaneXY(self, z, Plane) -> bool"""
        return _Volume.CVolume8_setPlaneXY(self, z, Plane)


    def setPlaneXZ(self, y, Plane):
        """setPlaneXZ(self, y, Plane) -> bool"""
        return _Volume.CVolume8_setPlaneXZ(self, y, Plane)


    def setPlaneYZ(self, x, Plane):
        """setPlaneYZ(self, x, Plane) -> bool"""
        return _Volume.CVolume8_setPlaneYZ(self, x, Plane)


    def enableDummyMode(self, Enable):
        """enableDummyMode(self, Enable) -> CVolume8"""
        return _Volume.CVolume8_enableDummyMode(self, Enable)


    def isDummy(self):
        """isDummy(self) -> bool"""
        return _Volume.CVolume8_isDummy(self)

    def __disown__(self):
        self.this.disown()
        _Volume.disown_CVolume8(self)
        return weakref_proxy(self)
CVolume8_swigregister = _Volume.CVolume8_swigregister
CVolume8_swigregister(CVolume8)

class CVolume16(VPLSwig.Core.Core.CObject, swig_base_Volume16, VPLSwig.Image.Image.CSerializable):
    """Proxy of C++ vpl::img::CVolume<(vpl::img::tPixel16,vpl::base::CPartedData)> class."""

    __swig_setmethods__ = {}
    for _s in [VPLSwig.Core.Core.CObject, swig_base_Volume16, VPLSwig.Image.Image.CSerializable]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CVolume16, name, value)
    __swig_getmethods__ = {}
    for _s in [VPLSwig.Core.Core.CObject, swig_base_Volume16, VPLSwig.Image.Image.CSerializable]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CVolume16, name)
    __repr__ = _swig_repr
    CLASS_VOLUME = _Volume.CVolume16_CLASS_VOLUME
    ITERATOR_DECLARED = _Volume.CVolume16_ITERATOR_DECLARED

    def __init__(self, *args):
        """
        __init__(self) -> CVolume16
        __init__(self, XSize, YSize, ZSize, Margin=0) -> CVolume16
        __init__(self, XSize, YSize, ZSize) -> CVolume16
        __init__(self, Size, Margin=0) -> CVolume16
        __init__(self, Size) -> CVolume16
        __init__(self, Volume, x, y, z, XSize, YSize, ZSize) -> CVolume16
        __init__(self, Volume, x, y, z, XSize, YSize, ZSize, arg9) -> CVolume16
        __init__(self, Volume) -> CVolume16
        __init__(self, Volume, arg3) -> CVolume16
        __init__(self, Volume) -> CVolume16
        __init__(self, Volume, arg3) -> CVolume16
        """
        if self.__class__ == CVolume16:
            _self = None
        else:
            _self = self
        this = _Volume.new_CVolume16(_self, *args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _Volume.delete_CVolume16
    __del__ = lambda self: None

    def resize(self, *args):
        """
        resize(self, XSize, YSize, ZSize, Margin=0) -> CVolume16
        resize(self, XSize, YSize, ZSize) -> CVolume16
        resize(self, Size, Margin=0) -> CVolume16
        resize(self, Size) -> CVolume16
        """
        return _Volume.CVolume16_resize(self, *args)


    def copy(self, *args):
        """
        copy(self, Volume, Margin=-1) -> CVolume16
        copy(self, Volume) -> CVolume16
        copy(self, Volume, x, y, z, XSize, YSize, ZSize, Margin=-1) -> CVolume16
        copy(self, Volume, x, y, z, XSize, YSize, ZSize) -> CVolume16
        copy(self, Volume, Margin=-1) -> CVolume16
        copy(self, Volume) -> CVolume16
        """
        return _Volume.CVolume16_copy(self, *args)


    def makeRef(self, *args):
        """
        makeRef(self, Volume) -> CVolume16
        makeRef(self, Volume, x, y, z, XSize, YSize, ZSize) -> CVolume16
        makeRef(self, Volume) -> CVolume16
        """
        return _Volume.CVolume16_makeRef(self, *args)


    def getSize(self, *args):
        """
        getSize(self) -> CSize3_int
        getSize(self) -> CSize3_int
        """
        return _Volume.CVolume16_getSize(self, *args)


    def getXSize(self):
        """getXSize(self) -> vpl::tSize"""
        return _Volume.CVolume16_getXSize(self)


    def getYSize(self):
        """getYSize(self) -> vpl::tSize"""
        return _Volume.CVolume16_getYSize(self)


    def getZSize(self):
        """getZSize(self) -> vpl::tSize"""
        return _Volume.CVolume16_getZSize(self)


    def width(self):
        """width(self) -> vpl::tSize"""
        return _Volume.CVolume16_width(self)


    def height(self):
        """height(self) -> vpl::tSize"""
        return _Volume.CVolume16_height(self)


    def depth(self):
        """depth(self) -> vpl::tSize"""
        return _Volume.CVolume16_depth(self)


    def getXOffset(self):
        """getXOffset(self) -> vpl::tSize"""
        return _Volume.CVolume16_getXOffset(self)


    def getYOffset(self):
        """getYOffset(self) -> vpl::tSize"""
        return _Volume.CVolume16_getYOffset(self)


    def getZOffset(self):
        """getZOffset(self) -> vpl::tSize"""
        return _Volume.CVolume16_getZOffset(self)


    def getMargin(self):
        """getMargin(self) -> vpl::tSize"""
        return _Volume.CVolume16_getMargin(self)


    def getIdx(self, x, y, z):
        """getIdx(self, x, y, z) -> vpl::tSize"""
        return _Volume.CVolume16_getIdx(self, x, y, z)


    def __call__(self, *args):
        """
        __call__(self, x, y, z) -> unsigned __int16
        __call__(self, x, y, z) -> unsigned __int16 const
        __call__(self, i) -> unsigned __int16
        __call__(self, i) -> unsigned __int16 const &
        """
        return _Volume.CVolume16___call__(self, *args)


    def at(self, *args):
        """
        at(self, x, y, z) -> unsigned __int16 const
        at(self, i) -> unsigned __int16 const &
        """
        return _Volume.CVolume16_at(self, *args)


    def set(self, *args):
        """
        set(self, x, y, z, Value) -> CVolume16
        set(self, i, Value) -> CVolume16
        """
        return _Volume.CVolume16_set(self, *args)


    def getPtr(self, *args):
        """
        getPtr(self) -> unsigned __int16
        getPtr(self) -> unsigned __int16 const
        getPtr(self, x, y, z) -> unsigned __int16
        getPtr(self, x, y, z) -> unsigned __int16 const *
        """
        return _Volume.CVolume16_getPtr(self, *args)


    def getRowPtr(self, *args):
        """
        getRowPtr(self, y, z) -> unsigned __int16
        getRowPtr(self, y, z) -> unsigned __int16 const *
        """
        return _Volume.CVolume16_getRowPtr(self, *args)


    def rect(self, *args):
        """
        rect(self, Position, Size) -> vpl::img::CVolume< unsigned __int16,vpl::base::CPartedData >::tRect
        rect(self, Position, Size) -> vpl::img::CVolume< unsigned __int16,vpl::base::CPartedData >::tRect const
        rect(self, XRange, YRange, ZRange) -> vpl::img::CVolume< unsigned __int16,vpl::base::CPartedData >::tRect
        rect(self, XRange, YRange, ZRange) -> vpl::img::CVolume< unsigned __int16,vpl::base::CPartedData >::tRect const
        """
        return _Volume.CVolume16_rect(self, *args)


    def row(self, *args):
        """
        row(self, y, z) -> vpl::img::CVolume< unsigned __int16,vpl::base::CPartedData >::tRow
        row(self, y, z) -> vpl::img::CVolume< unsigned __int16,vpl::base::CPartedData >::tRow const
        """
        return _Volume.CVolume16_row(self, *args)


    def fill(self, c):
        """fill(self, c) -> CVolume16"""
        return _Volume.CVolume16_fill(self, c)


    def fillEntire(self, c):
        """fillEntire(self, c) -> CVolume16"""
        return _Volume.CVolume16_fillEntire(self, c)


    def fillMargin(self, c):
        """fillMargin(self, c) -> CVolume16"""
        return _Volume.CVolume16_fillMargin(self, c)


    def mirrorMargin(self):
        """mirrorMargin(self) -> CVolume16"""
        return _Volume.CVolume16_mirrorMargin(self)


    def replace(self, Value, NewValue):
        """replace(self, Value, NewValue) -> CVolume16"""
        return _Volume.CVolume16_replace(self, Value, NewValue)


    def abs(self):
        """abs(self) -> CVolume16"""
        return _Volume.CVolume16_abs(self)


    def limit(self, Lower, Upper):
        """limit(self, Lower, Upper) -> CVolume16"""
        return _Volume.CVolume16_limit(self, Lower, Upper)


    def cut(self, Lower, Upper):
        """cut(self, Lower, Upper) -> CVolume16"""
        return _Volume.CVolume16_cut(self, Lower, Upper)


    def subSample(self, Volume, l=2, m=2, n=2):
        """
        subSample(self, Volume, l=2, m=2, n=2) -> CVolume16
        subSample(self, Volume, l=2, m=2) -> CVolume16
        subSample(self, Volume, l=2) -> CVolume16
        subSample(self, Volume) -> CVolume16
        """
        return _Volume.CVolume16_subSample(self, Volume, l, m, n)


    def interpolate(self, Point):
        """interpolate(self, Point) -> unsigned __int16"""
        return _Volume.CVolume16_interpolate(self, Point)


    def color2Voxel(self, Color):
        """color2Voxel(self, Color) -> unsigned __int16"""
        return _Volume.CVolume16_color2Voxel(self, Color)


    def checkPosition(self, x, y, z):
        """checkPosition(self, x, y, z) -> bool"""
        return _Volume.CVolume16_checkPosition(self, x, y, z)


    def getPlaneXY(self, z, Plane):
        """getPlaneXY(self, z, Plane) -> bool"""
        return _Volume.CVolume16_getPlaneXY(self, z, Plane)


    def getPlaneXZ(self, y, Plane):
        """getPlaneXZ(self, y, Plane) -> bool"""
        return _Volume.CVolume16_getPlaneXZ(self, y, Plane)


    def getPlaneYZ(self, x, Plane):
        """getPlaneYZ(self, x, Plane) -> bool"""
        return _Volume.CVolume16_getPlaneYZ(self, x, Plane)


    def setPlaneXY(self, z, Plane):
        """setPlaneXY(self, z, Plane) -> bool"""
        return _Volume.CVolume16_setPlaneXY(self, z, Plane)


    def setPlaneXZ(self, y, Plane):
        """setPlaneXZ(self, y, Plane) -> bool"""
        return _Volume.CVolume16_setPlaneXZ(self, y, Plane)


    def setPlaneYZ(self, x, Plane):
        """setPlaneYZ(self, x, Plane) -> bool"""
        return _Volume.CVolume16_setPlaneYZ(self, x, Plane)


    def enableDummyMode(self, Enable):
        """enableDummyMode(self, Enable) -> CVolume16"""
        return _Volume.CVolume16_enableDummyMode(self, Enable)


    def isDummy(self):
        """isDummy(self) -> bool"""
        return _Volume.CVolume16_isDummy(self)

    def __disown__(self):
        self.this.disown()
        _Volume.disown_CVolume16(self)
        return weakref_proxy(self)
CVolume16_swigregister = _Volume.CVolume16_swigregister
CVolume16_swigregister(CVolume16)

class CVolume32(VPLSwig.Core.Core.CObject, swig_base_Volume32, VPLSwig.Image.Image.CSerializable):
    """Proxy of C++ vpl::img::CVolume<(vpl::img::tPixel32,vpl::base::CPartedData)> class."""

    __swig_setmethods__ = {}
    for _s in [VPLSwig.Core.Core.CObject, swig_base_Volume32, VPLSwig.Image.Image.CSerializable]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CVolume32, name, value)
    __swig_getmethods__ = {}
    for _s in [VPLSwig.Core.Core.CObject, swig_base_Volume32, VPLSwig.Image.Image.CSerializable]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CVolume32, name)
    __repr__ = _swig_repr
    CLASS_VOLUME = _Volume.CVolume32_CLASS_VOLUME
    ITERATOR_DECLARED = _Volume.CVolume32_ITERATOR_DECLARED

    def __init__(self, *args):
        """
        __init__(self) -> CVolume32
        __init__(self, XSize, YSize, ZSize, Margin=0) -> CVolume32
        __init__(self, XSize, YSize, ZSize) -> CVolume32
        __init__(self, Size, Margin=0) -> CVolume32
        __init__(self, Size) -> CVolume32
        __init__(self, Volume, x, y, z, XSize, YSize, ZSize) -> CVolume32
        __init__(self, Volume, x, y, z, XSize, YSize, ZSize, arg9) -> CVolume32
        __init__(self, Volume) -> CVolume32
        __init__(self, Volume, arg3) -> CVolume32
        __init__(self, Volume) -> CVolume32
        __init__(self, Volume, arg3) -> CVolume32
        """
        if self.__class__ == CVolume32:
            _self = None
        else:
            _self = self
        this = _Volume.new_CVolume32(_self, *args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _Volume.delete_CVolume32
    __del__ = lambda self: None

    def resize(self, *args):
        """
        resize(self, XSize, YSize, ZSize, Margin=0) -> CVolume32
        resize(self, XSize, YSize, ZSize) -> CVolume32
        resize(self, Size, Margin=0) -> CVolume32
        resize(self, Size) -> CVolume32
        """
        return _Volume.CVolume32_resize(self, *args)


    def copy(self, *args):
        """
        copy(self, Volume, Margin=-1) -> CVolume32
        copy(self, Volume) -> CVolume32
        copy(self, Volume, x, y, z, XSize, YSize, ZSize, Margin=-1) -> CVolume32
        copy(self, Volume, x, y, z, XSize, YSize, ZSize) -> CVolume32
        copy(self, Volume, Margin=-1) -> CVolume32
        copy(self, Volume) -> CVolume32
        """
        return _Volume.CVolume32_copy(self, *args)


    def makeRef(self, *args):
        """
        makeRef(self, Volume) -> CVolume32
        makeRef(self, Volume, x, y, z, XSize, YSize, ZSize) -> CVolume32
        makeRef(self, Volume) -> CVolume32
        """
        return _Volume.CVolume32_makeRef(self, *args)


    def getSize(self, *args):
        """
        getSize(self) -> CSize3_int
        getSize(self) -> CSize3_int
        """
        return _Volume.CVolume32_getSize(self, *args)


    def getXSize(self):
        """getXSize(self) -> vpl::tSize"""
        return _Volume.CVolume32_getXSize(self)


    def getYSize(self):
        """getYSize(self) -> vpl::tSize"""
        return _Volume.CVolume32_getYSize(self)


    def getZSize(self):
        """getZSize(self) -> vpl::tSize"""
        return _Volume.CVolume32_getZSize(self)


    def width(self):
        """width(self) -> vpl::tSize"""
        return _Volume.CVolume32_width(self)


    def height(self):
        """height(self) -> vpl::tSize"""
        return _Volume.CVolume32_height(self)


    def depth(self):
        """depth(self) -> vpl::tSize"""
        return _Volume.CVolume32_depth(self)


    def getXOffset(self):
        """getXOffset(self) -> vpl::tSize"""
        return _Volume.CVolume32_getXOffset(self)


    def getYOffset(self):
        """getYOffset(self) -> vpl::tSize"""
        return _Volume.CVolume32_getYOffset(self)


    def getZOffset(self):
        """getZOffset(self) -> vpl::tSize"""
        return _Volume.CVolume32_getZOffset(self)


    def getMargin(self):
        """getMargin(self) -> vpl::tSize"""
        return _Volume.CVolume32_getMargin(self)


    def getIdx(self, x, y, z):
        """getIdx(self, x, y, z) -> vpl::tSize"""
        return _Volume.CVolume32_getIdx(self, x, y, z)


    def __call__(self, *args):
        """
        __call__(self, x, y, z) -> unsigned __int32
        __call__(self, x, y, z) -> unsigned __int32 const
        __call__(self, i) -> unsigned __int32
        __call__(self, i) -> unsigned __int32 const &
        """
        return _Volume.CVolume32___call__(self, *args)


    def at(self, *args):
        """
        at(self, x, y, z) -> unsigned __int32 const
        at(self, i) -> unsigned __int32 const &
        """
        return _Volume.CVolume32_at(self, *args)


    def set(self, *args):
        """
        set(self, x, y, z, Value) -> CVolume32
        set(self, i, Value) -> CVolume32
        """
        return _Volume.CVolume32_set(self, *args)


    def getPtr(self, *args):
        """
        getPtr(self) -> unsigned __int32
        getPtr(self) -> unsigned __int32 const
        getPtr(self, x, y, z) -> unsigned __int32
        getPtr(self, x, y, z) -> unsigned __int32 const *
        """
        return _Volume.CVolume32_getPtr(self, *args)


    def getRowPtr(self, *args):
        """
        getRowPtr(self, y, z) -> unsigned __int32
        getRowPtr(self, y, z) -> unsigned __int32 const *
        """
        return _Volume.CVolume32_getRowPtr(self, *args)


    def rect(self, *args):
        """
        rect(self, Position, Size) -> vpl::img::CVolume< unsigned __int32,vpl::base::CPartedData >::tRect
        rect(self, Position, Size) -> vpl::img::CVolume< unsigned __int32,vpl::base::CPartedData >::tRect const
        rect(self, XRange, YRange, ZRange) -> vpl::img::CVolume< unsigned __int32,vpl::base::CPartedData >::tRect
        rect(self, XRange, YRange, ZRange) -> vpl::img::CVolume< unsigned __int32,vpl::base::CPartedData >::tRect const
        """
        return _Volume.CVolume32_rect(self, *args)


    def row(self, *args):
        """
        row(self, y, z) -> vpl::img::CVolume< unsigned __int32,vpl::base::CPartedData >::tRow
        row(self, y, z) -> vpl::img::CVolume< unsigned __int32,vpl::base::CPartedData >::tRow const
        """
        return _Volume.CVolume32_row(self, *args)


    def fill(self, c):
        """fill(self, c) -> CVolume32"""
        return _Volume.CVolume32_fill(self, c)


    def fillEntire(self, c):
        """fillEntire(self, c) -> CVolume32"""
        return _Volume.CVolume32_fillEntire(self, c)


    def fillMargin(self, c):
        """fillMargin(self, c) -> CVolume32"""
        return _Volume.CVolume32_fillMargin(self, c)


    def mirrorMargin(self):
        """mirrorMargin(self) -> CVolume32"""
        return _Volume.CVolume32_mirrorMargin(self)


    def replace(self, Value, NewValue):
        """replace(self, Value, NewValue) -> CVolume32"""
        return _Volume.CVolume32_replace(self, Value, NewValue)


    def abs(self):
        """abs(self) -> CVolume32"""
        return _Volume.CVolume32_abs(self)


    def limit(self, Lower, Upper):
        """limit(self, Lower, Upper) -> CVolume32"""
        return _Volume.CVolume32_limit(self, Lower, Upper)


    def cut(self, Lower, Upper):
        """cut(self, Lower, Upper) -> CVolume32"""
        return _Volume.CVolume32_cut(self, Lower, Upper)


    def subSample(self, Volume, l=2, m=2, n=2):
        """
        subSample(self, Volume, l=2, m=2, n=2) -> CVolume32
        subSample(self, Volume, l=2, m=2) -> CVolume32
        subSample(self, Volume, l=2) -> CVolume32
        subSample(self, Volume) -> CVolume32
        """
        return _Volume.CVolume32_subSample(self, Volume, l, m, n)


    def interpolate(self, Point):
        """interpolate(self, Point) -> unsigned __int32"""
        return _Volume.CVolume32_interpolate(self, Point)


    def color2Voxel(self, Color):
        """color2Voxel(self, Color) -> unsigned __int32"""
        return _Volume.CVolume32_color2Voxel(self, Color)


    def checkPosition(self, x, y, z):
        """checkPosition(self, x, y, z) -> bool"""
        return _Volume.CVolume32_checkPosition(self, x, y, z)


    def getPlaneXY(self, z, Plane):
        """getPlaneXY(self, z, Plane) -> bool"""
        return _Volume.CVolume32_getPlaneXY(self, z, Plane)


    def getPlaneXZ(self, y, Plane):
        """getPlaneXZ(self, y, Plane) -> bool"""
        return _Volume.CVolume32_getPlaneXZ(self, y, Plane)


    def getPlaneYZ(self, x, Plane):
        """getPlaneYZ(self, x, Plane) -> bool"""
        return _Volume.CVolume32_getPlaneYZ(self, x, Plane)


    def setPlaneXY(self, z, Plane):
        """setPlaneXY(self, z, Plane) -> bool"""
        return _Volume.CVolume32_setPlaneXY(self, z, Plane)


    def setPlaneXZ(self, y, Plane):
        """setPlaneXZ(self, y, Plane) -> bool"""
        return _Volume.CVolume32_setPlaneXZ(self, y, Plane)


    def setPlaneYZ(self, x, Plane):
        """setPlaneYZ(self, x, Plane) -> bool"""
        return _Volume.CVolume32_setPlaneYZ(self, x, Plane)


    def enableDummyMode(self, Enable):
        """enableDummyMode(self, Enable) -> CVolume32"""
        return _Volume.CVolume32_enableDummyMode(self, Enable)


    def isDummy(self):
        """isDummy(self) -> bool"""
        return _Volume.CVolume32_isDummy(self)

    def __disown__(self):
        self.this.disown()
        _Volume.disown_CVolume32(self)
        return weakref_proxy(self)
CVolume32_swigregister = _Volume.CVolume32_swigregister
CVolume32_swigregister(CVolume32)

class CFVolume(VPLSwig.Core.Core.CObject, swig_base_FVolume, VPLSwig.Image.Image.CSerializable):
    """Proxy of C++ vpl::img::CVolume<(vpl::img::tFloatPixel,vpl::base::CPartedData)> class."""

    __swig_setmethods__ = {}
    for _s in [VPLSwig.Core.Core.CObject, swig_base_FVolume, VPLSwig.Image.Image.CSerializable]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CFVolume, name, value)
    __swig_getmethods__ = {}
    for _s in [VPLSwig.Core.Core.CObject, swig_base_FVolume, VPLSwig.Image.Image.CSerializable]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CFVolume, name)
    __repr__ = _swig_repr
    CLASS_VOLUME = _Volume.CFVolume_CLASS_VOLUME
    ITERATOR_DECLARED = _Volume.CFVolume_ITERATOR_DECLARED

    def __init__(self, *args):
        """
        __init__(self) -> CFVolume
        __init__(self, XSize, YSize, ZSize, Margin=0) -> CFVolume
        __init__(self, XSize, YSize, ZSize) -> CFVolume
        __init__(self, Size, Margin=0) -> CFVolume
        __init__(self, Size) -> CFVolume
        __init__(self, Volume, x, y, z, XSize, YSize, ZSize) -> CFVolume
        __init__(self, Volume, x, y, z, XSize, YSize, ZSize, arg9) -> CFVolume
        __init__(self, Volume) -> CFVolume
        __init__(self, Volume, arg3) -> CFVolume
        __init__(self, Volume) -> CFVolume
        __init__(self, Volume, arg3) -> CFVolume
        """
        if self.__class__ == CFVolume:
            _self = None
        else:
            _self = self
        this = _Volume.new_CFVolume(_self, *args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _Volume.delete_CFVolume
    __del__ = lambda self: None

    def resize(self, *args):
        """
        resize(self, XSize, YSize, ZSize, Margin=0) -> CFVolume
        resize(self, XSize, YSize, ZSize) -> CFVolume
        resize(self, Size, Margin=0) -> CFVolume
        resize(self, Size) -> CFVolume
        """
        return _Volume.CFVolume_resize(self, *args)


    def copy(self, *args):
        """
        copy(self, Volume, Margin=-1) -> CFVolume
        copy(self, Volume) -> CFVolume
        copy(self, Volume, x, y, z, XSize, YSize, ZSize, Margin=-1) -> CFVolume
        copy(self, Volume, x, y, z, XSize, YSize, ZSize) -> CFVolume
        copy(self, Volume, Margin=-1) -> CFVolume
        copy(self, Volume) -> CFVolume
        """
        return _Volume.CFVolume_copy(self, *args)


    def makeRef(self, *args):
        """
        makeRef(self, Volume) -> CFVolume
        makeRef(self, Volume, x, y, z, XSize, YSize, ZSize) -> CFVolume
        makeRef(self, Volume) -> CFVolume
        """
        return _Volume.CFVolume_makeRef(self, *args)


    def getSize(self, *args):
        """
        getSize(self) -> CSize3_int
        getSize(self) -> CSize3_int
        """
        return _Volume.CFVolume_getSize(self, *args)


    def getXSize(self):
        """getXSize(self) -> vpl::tSize"""
        return _Volume.CFVolume_getXSize(self)


    def getYSize(self):
        """getYSize(self) -> vpl::tSize"""
        return _Volume.CFVolume_getYSize(self)


    def getZSize(self):
        """getZSize(self) -> vpl::tSize"""
        return _Volume.CFVolume_getZSize(self)


    def width(self):
        """width(self) -> vpl::tSize"""
        return _Volume.CFVolume_width(self)


    def height(self):
        """height(self) -> vpl::tSize"""
        return _Volume.CFVolume_height(self)


    def depth(self):
        """depth(self) -> vpl::tSize"""
        return _Volume.CFVolume_depth(self)


    def getXOffset(self):
        """getXOffset(self) -> vpl::tSize"""
        return _Volume.CFVolume_getXOffset(self)


    def getYOffset(self):
        """getYOffset(self) -> vpl::tSize"""
        return _Volume.CFVolume_getYOffset(self)


    def getZOffset(self):
        """getZOffset(self) -> vpl::tSize"""
        return _Volume.CFVolume_getZOffset(self)


    def getMargin(self):
        """getMargin(self) -> vpl::tSize"""
        return _Volume.CFVolume_getMargin(self)


    def getIdx(self, x, y, z):
        """getIdx(self, x, y, z) -> vpl::tSize"""
        return _Volume.CFVolume_getIdx(self, x, y, z)


    def __call__(self, *args):
        """
        __call__(self, x, y, z) -> float
        __call__(self, x, y, z) -> float const
        __call__(self, i) -> float
        __call__(self, i) -> float const &
        """
        return _Volume.CFVolume___call__(self, *args)


    def at(self, *args):
        """
        at(self, x, y, z) -> float const
        at(self, i) -> float const &
        """
        return _Volume.CFVolume_at(self, *args)


    def set(self, *args):
        """
        set(self, x, y, z, Value) -> CFVolume
        set(self, i, Value) -> CFVolume
        """
        return _Volume.CFVolume_set(self, *args)


    def getPtr(self, *args):
        """
        getPtr(self) -> float
        getPtr(self) -> float const
        getPtr(self, x, y, z) -> float
        getPtr(self, x, y, z) -> float const *
        """
        return _Volume.CFVolume_getPtr(self, *args)


    def getRowPtr(self, *args):
        """
        getRowPtr(self, y, z) -> float
        getRowPtr(self, y, z) -> float const *
        """
        return _Volume.CFVolume_getRowPtr(self, *args)


    def rect(self, *args):
        """
        rect(self, Position, Size) -> vpl::img::CVolume< float,vpl::base::CPartedData >::tRect
        rect(self, Position, Size) -> vpl::img::CVolume< float,vpl::base::CPartedData >::tRect const
        rect(self, XRange, YRange, ZRange) -> vpl::img::CVolume< float,vpl::base::CPartedData >::tRect
        rect(self, XRange, YRange, ZRange) -> vpl::img::CVolume< float,vpl::base::CPartedData >::tRect const
        """
        return _Volume.CFVolume_rect(self, *args)


    def row(self, *args):
        """
        row(self, y, z) -> vpl::img::CVolume< float,vpl::base::CPartedData >::tRow
        row(self, y, z) -> vpl::img::CVolume< float,vpl::base::CPartedData >::tRow const
        """
        return _Volume.CFVolume_row(self, *args)


    def fill(self, c):
        """fill(self, c) -> CFVolume"""
        return _Volume.CFVolume_fill(self, c)


    def fillEntire(self, c):
        """fillEntire(self, c) -> CFVolume"""
        return _Volume.CFVolume_fillEntire(self, c)


    def fillMargin(self, c):
        """fillMargin(self, c) -> CFVolume"""
        return _Volume.CFVolume_fillMargin(self, c)


    def mirrorMargin(self):
        """mirrorMargin(self) -> CFVolume"""
        return _Volume.CFVolume_mirrorMargin(self)


    def replace(self, Value, NewValue):
        """replace(self, Value, NewValue) -> CFVolume"""
        return _Volume.CFVolume_replace(self, Value, NewValue)


    def abs(self):
        """abs(self) -> CFVolume"""
        return _Volume.CFVolume_abs(self)


    def limit(self, Lower, Upper):
        """limit(self, Lower, Upper) -> CFVolume"""
        return _Volume.CFVolume_limit(self, Lower, Upper)


    def cut(self, Lower, Upper):
        """cut(self, Lower, Upper) -> CFVolume"""
        return _Volume.CFVolume_cut(self, Lower, Upper)


    def subSample(self, Volume, l=2, m=2, n=2):
        """
        subSample(self, Volume, l=2, m=2, n=2) -> CFVolume
        subSample(self, Volume, l=2, m=2) -> CFVolume
        subSample(self, Volume, l=2) -> CFVolume
        subSample(self, Volume) -> CFVolume
        """
        return _Volume.CFVolume_subSample(self, Volume, l, m, n)


    def interpolate(self, Point):
        """interpolate(self, Point) -> float"""
        return _Volume.CFVolume_interpolate(self, Point)


    def color2Voxel(self, Color):
        """color2Voxel(self, Color) -> float"""
        return _Volume.CFVolume_color2Voxel(self, Color)


    def checkPosition(self, x, y, z):
        """checkPosition(self, x, y, z) -> bool"""
        return _Volume.CFVolume_checkPosition(self, x, y, z)


    def getPlaneXY(self, z, Plane):
        """getPlaneXY(self, z, Plane) -> bool"""
        return _Volume.CFVolume_getPlaneXY(self, z, Plane)


    def getPlaneXZ(self, y, Plane):
        """getPlaneXZ(self, y, Plane) -> bool"""
        return _Volume.CFVolume_getPlaneXZ(self, y, Plane)


    def getPlaneYZ(self, x, Plane):
        """getPlaneYZ(self, x, Plane) -> bool"""
        return _Volume.CFVolume_getPlaneYZ(self, x, Plane)


    def setPlaneXY(self, z, Plane):
        """setPlaneXY(self, z, Plane) -> bool"""
        return _Volume.CFVolume_setPlaneXY(self, z, Plane)


    def setPlaneXZ(self, y, Plane):
        """setPlaneXZ(self, y, Plane) -> bool"""
        return _Volume.CFVolume_setPlaneXZ(self, y, Plane)


    def setPlaneYZ(self, x, Plane):
        """setPlaneYZ(self, x, Plane) -> bool"""
        return _Volume.CFVolume_setPlaneYZ(self, x, Plane)


    def enableDummyMode(self, Enable):
        """enableDummyMode(self, Enable) -> CFVolume"""
        return _Volume.CFVolume_enableDummyMode(self, Enable)


    def isDummy(self):
        """isDummy(self) -> bool"""
        return _Volume.CFVolume_isDummy(self)

    def __disown__(self):
        self.this.disown()
        _Volume.disown_CFVolume(self)
        return weakref_proxy(self)
CFVolume_swigregister = _Volume.CFVolume_swigregister
CFVolume_swigregister(CFVolume)

class CDVolume(VPLSwig.Core.Core.CObject, swig_base_DVolume, VPLSwig.Image.Image.CSerializable):
    """Proxy of C++ vpl::img::CVolume<(vpl::img::tDensityPixel,vpl::base::CPartedData)> class."""

    __swig_setmethods__ = {}
    for _s in [VPLSwig.Core.Core.CObject, swig_base_DVolume, VPLSwig.Image.Image.CSerializable]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CDVolume, name, value)
    __swig_getmethods__ = {}
    for _s in [VPLSwig.Core.Core.CObject, swig_base_DVolume, VPLSwig.Image.Image.CSerializable]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CDVolume, name)
    __repr__ = _swig_repr
    CLASS_VOLUME = _Volume.CDVolume_CLASS_VOLUME
    ITERATOR_DECLARED = _Volume.CDVolume_ITERATOR_DECLARED

    def __init__(self, *args):
        """
        __init__(self) -> CDVolume
        __init__(self, XSize, YSize, ZSize, Margin=0) -> CDVolume
        __init__(self, XSize, YSize, ZSize) -> CDVolume
        __init__(self, Size, Margin=0) -> CDVolume
        __init__(self, Size) -> CDVolume
        __init__(self, Volume, x, y, z, XSize, YSize, ZSize) -> CDVolume
        __init__(self, Volume, x, y, z, XSize, YSize, ZSize, arg9) -> CDVolume
        __init__(self, Volume) -> CDVolume
        __init__(self, Volume, arg3) -> CDVolume
        __init__(self, Volume) -> CDVolume
        __init__(self, Volume, arg3) -> CDVolume
        """
        if self.__class__ == CDVolume:
            _self = None
        else:
            _self = self
        this = _Volume.new_CDVolume(_self, *args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _Volume.delete_CDVolume
    __del__ = lambda self: None

    def resize(self, *args):
        """
        resize(self, XSize, YSize, ZSize, Margin=0) -> CDVolume
        resize(self, XSize, YSize, ZSize) -> CDVolume
        resize(self, Size, Margin=0) -> CDVolume
        resize(self, Size) -> CDVolume
        """
        return _Volume.CDVolume_resize(self, *args)


    def copy(self, *args):
        """
        copy(self, Volume, Margin=-1) -> CDVolume
        copy(self, Volume) -> CDVolume
        copy(self, Volume, x, y, z, XSize, YSize, ZSize, Margin=-1) -> CDVolume
        copy(self, Volume, x, y, z, XSize, YSize, ZSize) -> CDVolume
        copy(self, Volume, Margin=-1) -> CDVolume
        copy(self, Volume) -> CDVolume
        """
        return _Volume.CDVolume_copy(self, *args)


    def makeRef(self, *args):
        """
        makeRef(self, Volume) -> CDVolume
        makeRef(self, Volume, x, y, z, XSize, YSize, ZSize) -> CDVolume
        makeRef(self, Volume) -> CDVolume
        """
        return _Volume.CDVolume_makeRef(self, *args)


    def getSize(self, *args):
        """
        getSize(self) -> CSize3_int
        getSize(self) -> CSize3_int
        """
        return _Volume.CDVolume_getSize(self, *args)


    def getXSize(self):
        """getXSize(self) -> vpl::tSize"""
        return _Volume.CDVolume_getXSize(self)


    def getYSize(self):
        """getYSize(self) -> vpl::tSize"""
        return _Volume.CDVolume_getYSize(self)


    def getZSize(self):
        """getZSize(self) -> vpl::tSize"""
        return _Volume.CDVolume_getZSize(self)


    def width(self):
        """width(self) -> vpl::tSize"""
        return _Volume.CDVolume_width(self)


    def height(self):
        """height(self) -> vpl::tSize"""
        return _Volume.CDVolume_height(self)


    def depth(self):
        """depth(self) -> vpl::tSize"""
        return _Volume.CDVolume_depth(self)


    def getXOffset(self):
        """getXOffset(self) -> vpl::tSize"""
        return _Volume.CDVolume_getXOffset(self)


    def getYOffset(self):
        """getYOffset(self) -> vpl::tSize"""
        return _Volume.CDVolume_getYOffset(self)


    def getZOffset(self):
        """getZOffset(self) -> vpl::tSize"""
        return _Volume.CDVolume_getZOffset(self)


    def getMargin(self):
        """getMargin(self) -> vpl::tSize"""
        return _Volume.CDVolume_getMargin(self)


    def getIdx(self, x, y, z):
        """getIdx(self, x, y, z) -> vpl::tSize"""
        return _Volume.CDVolume_getIdx(self, x, y, z)


    def __call__(self, *args):
        """
        __call__(self, x, y, z) -> __int16
        __call__(self, x, y, z) -> __int16 const
        __call__(self, i) -> __int16
        __call__(self, i) -> __int16 const &
        """
        return _Volume.CDVolume___call__(self, *args)


    def at(self, *args):
        """
        at(self, x, y, z) -> __int16 const
        at(self, i) -> __int16 const &
        """
        return _Volume.CDVolume_at(self, *args)


    def set(self, *args):
        """
        set(self, x, y, z, Value) -> CDVolume
        set(self, i, Value) -> CDVolume
        """
        return _Volume.CDVolume_set(self, *args)


    def getPtr(self, *args):
        """
        getPtr(self) -> __int16
        getPtr(self) -> __int16 const
        getPtr(self, x, y, z) -> __int16
        getPtr(self, x, y, z) -> __int16 const *
        """
        return _Volume.CDVolume_getPtr(self, *args)


    def getRowPtr(self, *args):
        """
        getRowPtr(self, y, z) -> __int16
        getRowPtr(self, y, z) -> __int16 const *
        """
        return _Volume.CDVolume_getRowPtr(self, *args)


    def rect(self, *args):
        """
        rect(self, Position, Size) -> vpl::img::CVolume< __int16,vpl::base::CPartedData >::tRect
        rect(self, Position, Size) -> vpl::img::CVolume< __int16,vpl::base::CPartedData >::tRect const
        rect(self, XRange, YRange, ZRange) -> vpl::img::CVolume< __int16,vpl::base::CPartedData >::tRect
        rect(self, XRange, YRange, ZRange) -> vpl::img::CVolume< __int16,vpl::base::CPartedData >::tRect const
        """
        return _Volume.CDVolume_rect(self, *args)


    def row(self, *args):
        """
        row(self, y, z) -> vpl::img::CVolume< __int16,vpl::base::CPartedData >::tRow
        row(self, y, z) -> vpl::img::CVolume< __int16,vpl::base::CPartedData >::tRow const
        """
        return _Volume.CDVolume_row(self, *args)


    def fill(self, c):
        """fill(self, c) -> CDVolume"""
        return _Volume.CDVolume_fill(self, c)


    def fillEntire(self, c):
        """fillEntire(self, c) -> CDVolume"""
        return _Volume.CDVolume_fillEntire(self, c)


    def fillMargin(self, c):
        """fillMargin(self, c) -> CDVolume"""
        return _Volume.CDVolume_fillMargin(self, c)


    def mirrorMargin(self):
        """mirrorMargin(self) -> CDVolume"""
        return _Volume.CDVolume_mirrorMargin(self)


    def replace(self, Value, NewValue):
        """replace(self, Value, NewValue) -> CDVolume"""
        return _Volume.CDVolume_replace(self, Value, NewValue)


    def abs(self):
        """abs(self) -> CDVolume"""
        return _Volume.CDVolume_abs(self)


    def limit(self, Lower, Upper):
        """limit(self, Lower, Upper) -> CDVolume"""
        return _Volume.CDVolume_limit(self, Lower, Upper)


    def cut(self, Lower, Upper):
        """cut(self, Lower, Upper) -> CDVolume"""
        return _Volume.CDVolume_cut(self, Lower, Upper)


    def subSample(self, Volume, l=2, m=2, n=2):
        """
        subSample(self, Volume, l=2, m=2, n=2) -> CDVolume
        subSample(self, Volume, l=2, m=2) -> CDVolume
        subSample(self, Volume, l=2) -> CDVolume
        subSample(self, Volume) -> CDVolume
        """
        return _Volume.CDVolume_subSample(self, Volume, l, m, n)


    def interpolate(self, Point):
        """interpolate(self, Point) -> __int16"""
        return _Volume.CDVolume_interpolate(self, Point)


    def color2Voxel(self, Color):
        """color2Voxel(self, Color) -> __int16"""
        return _Volume.CDVolume_color2Voxel(self, Color)


    def checkPosition(self, x, y, z):
        """checkPosition(self, x, y, z) -> bool"""
        return _Volume.CDVolume_checkPosition(self, x, y, z)


    def getPlaneXY(self, z, Plane):
        """getPlaneXY(self, z, Plane) -> bool"""
        return _Volume.CDVolume_getPlaneXY(self, z, Plane)


    def getPlaneXZ(self, y, Plane):
        """getPlaneXZ(self, y, Plane) -> bool"""
        return _Volume.CDVolume_getPlaneXZ(self, y, Plane)


    def getPlaneYZ(self, x, Plane):
        """getPlaneYZ(self, x, Plane) -> bool"""
        return _Volume.CDVolume_getPlaneYZ(self, x, Plane)


    def setPlaneXY(self, z, Plane):
        """setPlaneXY(self, z, Plane) -> bool"""
        return _Volume.CDVolume_setPlaneXY(self, z, Plane)


    def setPlaneXZ(self, y, Plane):
        """setPlaneXZ(self, y, Plane) -> bool"""
        return _Volume.CDVolume_setPlaneXZ(self, y, Plane)


    def setPlaneYZ(self, x, Plane):
        """setPlaneYZ(self, x, Plane) -> bool"""
        return _Volume.CDVolume_setPlaneYZ(self, x, Plane)


    def enableDummyMode(self, Enable):
        """enableDummyMode(self, Enable) -> CDVolume"""
        return _Volume.CDVolume_enableDummyMode(self, Enable)


    def isDummy(self):
        """isDummy(self) -> bool"""
        return _Volume.CDVolume_isDummy(self)

    def __disown__(self):
        self.this.disown()
        _Volume.disown_CDVolume(self)
        return weakref_proxy(self)
CDVolume_swigregister = _Volume.CDVolume_swigregister
CDVolume_swigregister(CDVolume)

class CRGBAVolume(VPLSwig.Core.Core.CObject, swig_base_RGBAVolume, VPLSwig.Image.Image.CSerializable):
    """Proxy of C++ vpl::img::CVolume<(vpl::img::tRGBAPixel,vpl::base::CPartedData)> class."""

    __swig_setmethods__ = {}
    for _s in [VPLSwig.Core.Core.CObject, swig_base_RGBAVolume, VPLSwig.Image.Image.CSerializable]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CRGBAVolume, name, value)
    __swig_getmethods__ = {}
    for _s in [VPLSwig.Core.Core.CObject, swig_base_RGBAVolume, VPLSwig.Image.Image.CSerializable]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CRGBAVolume, name)
    __repr__ = _swig_repr
    CLASS_VOLUME = _Volume.CRGBAVolume_CLASS_VOLUME
    ITERATOR_DECLARED = _Volume.CRGBAVolume_ITERATOR_DECLARED

    def __init__(self, *args):
        """
        __init__(self) -> CRGBAVolume
        __init__(self, XSize, YSize, ZSize, Margin=0) -> CRGBAVolume
        __init__(self, XSize, YSize, ZSize) -> CRGBAVolume
        __init__(self, Size, Margin=0) -> CRGBAVolume
        __init__(self, Size) -> CRGBAVolume
        __init__(self, Volume, x, y, z, XSize, YSize, ZSize) -> CRGBAVolume
        __init__(self, Volume, x, y, z, XSize, YSize, ZSize, arg9) -> CRGBAVolume
        __init__(self, Volume) -> CRGBAVolume
        __init__(self, Volume, arg3) -> CRGBAVolume
        __init__(self, Volume) -> CRGBAVolume
        __init__(self, Volume, arg3) -> CRGBAVolume
        """
        if self.__class__ == CRGBAVolume:
            _self = None
        else:
            _self = self
        this = _Volume.new_CRGBAVolume(_self, *args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _Volume.delete_CRGBAVolume
    __del__ = lambda self: None

    def resize(self, *args):
        """
        resize(self, XSize, YSize, ZSize, Margin=0) -> CRGBAVolume
        resize(self, XSize, YSize, ZSize) -> CRGBAVolume
        resize(self, Size, Margin=0) -> CRGBAVolume
        resize(self, Size) -> CRGBAVolume
        """
        return _Volume.CRGBAVolume_resize(self, *args)


    def copy(self, *args):
        """
        copy(self, Volume, Margin=-1) -> CRGBAVolume
        copy(self, Volume) -> CRGBAVolume
        copy(self, Volume, x, y, z, XSize, YSize, ZSize, Margin=-1) -> CRGBAVolume
        copy(self, Volume, x, y, z, XSize, YSize, ZSize) -> CRGBAVolume
        copy(self, Volume, Margin=-1) -> CRGBAVolume
        copy(self, Volume) -> CRGBAVolume
        """
        return _Volume.CRGBAVolume_copy(self, *args)


    def makeRef(self, *args):
        """
        makeRef(self, Volume) -> CRGBAVolume
        makeRef(self, Volume, x, y, z, XSize, YSize, ZSize) -> CRGBAVolume
        makeRef(self, Volume) -> CRGBAVolume
        """
        return _Volume.CRGBAVolume_makeRef(self, *args)


    def getSize(self, *args):
        """
        getSize(self) -> CSize3_int
        getSize(self) -> CSize3_int
        """
        return _Volume.CRGBAVolume_getSize(self, *args)


    def getXSize(self):
        """getXSize(self) -> vpl::tSize"""
        return _Volume.CRGBAVolume_getXSize(self)


    def getYSize(self):
        """getYSize(self) -> vpl::tSize"""
        return _Volume.CRGBAVolume_getYSize(self)


    def getZSize(self):
        """getZSize(self) -> vpl::tSize"""
        return _Volume.CRGBAVolume_getZSize(self)


    def width(self):
        """width(self) -> vpl::tSize"""
        return _Volume.CRGBAVolume_width(self)


    def height(self):
        """height(self) -> vpl::tSize"""
        return _Volume.CRGBAVolume_height(self)


    def depth(self):
        """depth(self) -> vpl::tSize"""
        return _Volume.CRGBAVolume_depth(self)


    def getXOffset(self):
        """getXOffset(self) -> vpl::tSize"""
        return _Volume.CRGBAVolume_getXOffset(self)


    def getYOffset(self):
        """getYOffset(self) -> vpl::tSize"""
        return _Volume.CRGBAVolume_getYOffset(self)


    def getZOffset(self):
        """getZOffset(self) -> vpl::tSize"""
        return _Volume.CRGBAVolume_getZOffset(self)


    def getMargin(self):
        """getMargin(self) -> vpl::tSize"""
        return _Volume.CRGBAVolume_getMargin(self)


    def getIdx(self, x, y, z):
        """getIdx(self, x, y, z) -> vpl::tSize"""
        return _Volume.CRGBAVolume_getIdx(self, x, y, z)


    def __call__(self, *args):
        """
        __call__(self, x, y, z) -> CRGBPixel
        __call__(self, x, y, z) -> CRGBPixel
        __call__(self, i) -> CRGBPixel
        __call__(self, i) -> CRGBPixel
        """
        return _Volume.CRGBAVolume___call__(self, *args)


    def at(self, *args):
        """
        at(self, x, y, z) -> CRGBPixel
        at(self, i) -> CRGBPixel
        """
        return _Volume.CRGBAVolume_at(self, *args)


    def set(self, *args):
        """
        set(self, x, y, z, Value) -> CRGBAVolume
        set(self, i, Value) -> CRGBAVolume
        """
        return _Volume.CRGBAVolume_set(self, *args)


    def getPtr(self, *args):
        """
        getPtr(self) -> CRGBPixel
        getPtr(self) -> CRGBPixel
        getPtr(self, x, y, z) -> CRGBPixel
        getPtr(self, x, y, z) -> CRGBPixel
        """
        return _Volume.CRGBAVolume_getPtr(self, *args)


    def getRowPtr(self, *args):
        """
        getRowPtr(self, y, z) -> CRGBPixel
        getRowPtr(self, y, z) -> CRGBPixel
        """
        return _Volume.CRGBAVolume_getRowPtr(self, *args)


    def rect(self, *args):
        """
        rect(self, Position, Size) -> vpl::img::CVolume< vpl::img::CRGBPixel,vpl::base::CPartedData >::tRect
        rect(self, Position, Size) -> vpl::img::CVolume< vpl::img::CRGBPixel,vpl::base::CPartedData >::tRect const
        rect(self, XRange, YRange, ZRange) -> vpl::img::CVolume< vpl::img::CRGBPixel,vpl::base::CPartedData >::tRect
        rect(self, XRange, YRange, ZRange) -> vpl::img::CVolume< vpl::img::CRGBPixel,vpl::base::CPartedData >::tRect const
        """
        return _Volume.CRGBAVolume_rect(self, *args)


    def row(self, *args):
        """
        row(self, y, z) -> vpl::img::CVolume< vpl::img::CRGBPixel,vpl::base::CPartedData >::tRow
        row(self, y, z) -> vpl::img::CVolume< vpl::img::CRGBPixel,vpl::base::CPartedData >::tRow const
        """
        return _Volume.CRGBAVolume_row(self, *args)


    def fill(self, c):
        """fill(self, c) -> CRGBAVolume"""
        return _Volume.CRGBAVolume_fill(self, c)


    def fillEntire(self, c):
        """fillEntire(self, c) -> CRGBAVolume"""
        return _Volume.CRGBAVolume_fillEntire(self, c)


    def fillMargin(self, c):
        """fillMargin(self, c) -> CRGBAVolume"""
        return _Volume.CRGBAVolume_fillMargin(self, c)


    def mirrorMargin(self):
        """mirrorMargin(self) -> CRGBAVolume"""
        return _Volume.CRGBAVolume_mirrorMargin(self)


    def replace(self, Value, NewValue):
        """replace(self, Value, NewValue) -> CRGBAVolume"""
        return _Volume.CRGBAVolume_replace(self, Value, NewValue)


    def abs(self):
        """abs(self) -> CRGBAVolume"""
        return _Volume.CRGBAVolume_abs(self)


    def limit(self, Lower, Upper):
        """limit(self, Lower, Upper) -> CRGBAVolume"""
        return _Volume.CRGBAVolume_limit(self, Lower, Upper)


    def cut(self, Lower, Upper):
        """cut(self, Lower, Upper) -> CRGBAVolume"""
        return _Volume.CRGBAVolume_cut(self, Lower, Upper)


    def subSample(self, Volume, l=2, m=2, n=2):
        """
        subSample(self, Volume, l=2, m=2, n=2) -> CRGBAVolume
        subSample(self, Volume, l=2, m=2) -> CRGBAVolume
        subSample(self, Volume, l=2) -> CRGBAVolume
        subSample(self, Volume) -> CRGBAVolume
        """
        return _Volume.CRGBAVolume_subSample(self, Volume, l, m, n)


    def interpolate(self, Point):
        """interpolate(self, Point) -> CRGBPixel"""
        return _Volume.CRGBAVolume_interpolate(self, Point)


    def color2Voxel(self, Color):
        """color2Voxel(self, Color) -> CRGBPixel"""
        return _Volume.CRGBAVolume_color2Voxel(self, Color)


    def checkPosition(self, x, y, z):
        """checkPosition(self, x, y, z) -> bool"""
        return _Volume.CRGBAVolume_checkPosition(self, x, y, z)


    def getPlaneXY(self, z, Plane):
        """getPlaneXY(self, z, Plane) -> bool"""
        return _Volume.CRGBAVolume_getPlaneXY(self, z, Plane)


    def getPlaneXZ(self, y, Plane):
        """getPlaneXZ(self, y, Plane) -> bool"""
        return _Volume.CRGBAVolume_getPlaneXZ(self, y, Plane)


    def getPlaneYZ(self, x, Plane):
        """getPlaneYZ(self, x, Plane) -> bool"""
        return _Volume.CRGBAVolume_getPlaneYZ(self, x, Plane)


    def setPlaneXY(self, z, Plane):
        """setPlaneXY(self, z, Plane) -> bool"""
        return _Volume.CRGBAVolume_setPlaneXY(self, z, Plane)


    def setPlaneXZ(self, y, Plane):
        """setPlaneXZ(self, y, Plane) -> bool"""
        return _Volume.CRGBAVolume_setPlaneXZ(self, y, Plane)


    def setPlaneYZ(self, x, Plane):
        """setPlaneYZ(self, x, Plane) -> bool"""
        return _Volume.CRGBAVolume_setPlaneYZ(self, x, Plane)


    def enableDummyMode(self, Enable):
        """enableDummyMode(self, Enable) -> CRGBAVolume"""
        return _Volume.CRGBAVolume_enableDummyMode(self, Enable)


    def isDummy(self):
        """isDummy(self) -> bool"""
        return _Volume.CRGBAVolume_isDummy(self)

    def __disown__(self):
        self.this.disown()
        _Volume.disown_CRGBAVolume(self)
        return weakref_proxy(self)
CRGBAVolume_swigregister = _Volume.CRGBAVolume_swigregister
CRGBAVolume_swigregister(CRGBAVolume)

class CComplexVolume(VPLSwig.Core.Core.CObject, swig_base_ComplexVolume, VPLSwig.Image.Image.CSerializable):
    """Proxy of C++ vpl::img::CVolume<(vpl::img::tComplexPixel,vpl::base::CPartedData)> class."""

    __swig_setmethods__ = {}
    for _s in [VPLSwig.Core.Core.CObject, swig_base_ComplexVolume, VPLSwig.Image.Image.CSerializable]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CComplexVolume, name, value)
    __swig_getmethods__ = {}
    for _s in [VPLSwig.Core.Core.CObject, swig_base_ComplexVolume, VPLSwig.Image.Image.CSerializable]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CComplexVolume, name)
    __repr__ = _swig_repr
    CLASS_VOLUME = _Volume.CComplexVolume_CLASS_VOLUME
    ITERATOR_DECLARED = _Volume.CComplexVolume_ITERATOR_DECLARED

    def __init__(self, *args):
        """
        __init__(self) -> CComplexVolume
        __init__(self, XSize, YSize, ZSize, Margin=0) -> CComplexVolume
        __init__(self, XSize, YSize, ZSize) -> CComplexVolume
        __init__(self, Size, Margin=0) -> CComplexVolume
        __init__(self, Size) -> CComplexVolume
        __init__(self, Volume, x, y, z, XSize, YSize, ZSize) -> CComplexVolume
        __init__(self, Volume, x, y, z, XSize, YSize, ZSize, arg9) -> CComplexVolume
        __init__(self, Volume) -> CComplexVolume
        __init__(self, Volume, arg3) -> CComplexVolume
        __init__(self, Volume) -> CComplexVolume
        __init__(self, Volume, arg3) -> CComplexVolume
        """
        if self.__class__ == CComplexVolume:
            _self = None
        else:
            _self = self
        this = _Volume.new_CComplexVolume(_self, *args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _Volume.delete_CComplexVolume
    __del__ = lambda self: None

    def resize(self, *args):
        """
        resize(self, XSize, YSize, ZSize, Margin=0) -> CComplexVolume
        resize(self, XSize, YSize, ZSize) -> CComplexVolume
        resize(self, Size, Margin=0) -> CComplexVolume
        resize(self, Size) -> CComplexVolume
        """
        return _Volume.CComplexVolume_resize(self, *args)


    def copy(self, *args):
        """
        copy(self, Volume, Margin=-1) -> CComplexVolume
        copy(self, Volume) -> CComplexVolume
        copy(self, Volume, x, y, z, XSize, YSize, ZSize, Margin=-1) -> CComplexVolume
        copy(self, Volume, x, y, z, XSize, YSize, ZSize) -> CComplexVolume
        copy(self, Volume, Margin=-1) -> CComplexVolume
        copy(self, Volume) -> CComplexVolume
        """
        return _Volume.CComplexVolume_copy(self, *args)


    def makeRef(self, *args):
        """
        makeRef(self, Volume) -> CComplexVolume
        makeRef(self, Volume, x, y, z, XSize, YSize, ZSize) -> CComplexVolume
        makeRef(self, Volume) -> CComplexVolume
        """
        return _Volume.CComplexVolume_makeRef(self, *args)


    def getSize(self, *args):
        """
        getSize(self) -> CSize3_int
        getSize(self) -> CSize3_int
        """
        return _Volume.CComplexVolume_getSize(self, *args)


    def getXSize(self):
        """getXSize(self) -> vpl::tSize"""
        return _Volume.CComplexVolume_getXSize(self)


    def getYSize(self):
        """getYSize(self) -> vpl::tSize"""
        return _Volume.CComplexVolume_getYSize(self)


    def getZSize(self):
        """getZSize(self) -> vpl::tSize"""
        return _Volume.CComplexVolume_getZSize(self)


    def width(self):
        """width(self) -> vpl::tSize"""
        return _Volume.CComplexVolume_width(self)


    def height(self):
        """height(self) -> vpl::tSize"""
        return _Volume.CComplexVolume_height(self)


    def depth(self):
        """depth(self) -> vpl::tSize"""
        return _Volume.CComplexVolume_depth(self)


    def getXOffset(self):
        """getXOffset(self) -> vpl::tSize"""
        return _Volume.CComplexVolume_getXOffset(self)


    def getYOffset(self):
        """getYOffset(self) -> vpl::tSize"""
        return _Volume.CComplexVolume_getYOffset(self)


    def getZOffset(self):
        """getZOffset(self) -> vpl::tSize"""
        return _Volume.CComplexVolume_getZOffset(self)


    def getMargin(self):
        """getMargin(self) -> vpl::tSize"""
        return _Volume.CComplexVolume_getMargin(self)


    def getIdx(self, x, y, z):
        """getIdx(self, x, y, z) -> vpl::tSize"""
        return _Volume.CComplexVolume_getIdx(self, x, y, z)


    def __call__(self, *args):
        """
        __call__(self, x, y, z) -> vpl::math::CComplex< float >
        __call__(self, x, y, z) -> vpl::math::CComplex< float > const
        __call__(self, i) -> vpl::math::CComplex< float >
        __call__(self, i) -> vpl::math::CComplex< float > const &
        """
        return _Volume.CComplexVolume___call__(self, *args)


    def at(self, *args):
        """
        at(self, x, y, z) -> vpl::math::CComplex< float > const
        at(self, i) -> vpl::math::CComplex< float > const &
        """
        return _Volume.CComplexVolume_at(self, *args)


    def set(self, *args):
        """
        set(self, x, y, z, Value) -> CComplexVolume
        set(self, i, Value) -> CComplexVolume
        """
        return _Volume.CComplexVolume_set(self, *args)


    def getPtr(self, *args):
        """
        getPtr(self) -> vpl::math::CComplex< float >
        getPtr(self) -> vpl::math::CComplex< float > const
        getPtr(self, x, y, z) -> vpl::math::CComplex< float >
        getPtr(self, x, y, z) -> vpl::math::CComplex< float > const *
        """
        return _Volume.CComplexVolume_getPtr(self, *args)


    def getRowPtr(self, *args):
        """
        getRowPtr(self, y, z) -> vpl::math::CComplex< float >
        getRowPtr(self, y, z) -> vpl::math::CComplex< float > const *
        """
        return _Volume.CComplexVolume_getRowPtr(self, *args)


    def rect(self, *args):
        """
        rect(self, Position, Size) -> vpl::img::CVolume< vpl::math::CComplex< float >,vpl::base::CPartedData >::tRect
        rect(self, Position, Size) -> vpl::img::CVolume< vpl::math::CComplex< float >,vpl::base::CPartedData >::tRect const
        rect(self, XRange, YRange, ZRange) -> vpl::img::CVolume< vpl::math::CComplex< float >,vpl::base::CPartedData >::tRect
        rect(self, XRange, YRange, ZRange) -> vpl::img::CVolume< vpl::math::CComplex< float >,vpl::base::CPartedData >::tRect const
        """
        return _Volume.CComplexVolume_rect(self, *args)


    def row(self, *args):
        """
        row(self, y, z) -> vpl::img::CVolume< vpl::math::CComplex< float >,vpl::base::CPartedData >::tRow
        row(self, y, z) -> vpl::img::CVolume< vpl::math::CComplex< float >,vpl::base::CPartedData >::tRow const
        """
        return _Volume.CComplexVolume_row(self, *args)


    def fill(self, c):
        """fill(self, c) -> CComplexVolume"""
        return _Volume.CComplexVolume_fill(self, c)


    def fillEntire(self, c):
        """fillEntire(self, c) -> CComplexVolume"""
        return _Volume.CComplexVolume_fillEntire(self, c)


    def fillMargin(self, c):
        """fillMargin(self, c) -> CComplexVolume"""
        return _Volume.CComplexVolume_fillMargin(self, c)


    def mirrorMargin(self):
        """mirrorMargin(self) -> CComplexVolume"""
        return _Volume.CComplexVolume_mirrorMargin(self)


    def replace(self, Value, NewValue):
        """replace(self, Value, NewValue) -> CComplexVolume"""
        return _Volume.CComplexVolume_replace(self, Value, NewValue)


    def abs(self):
        """abs(self) -> CComplexVolume"""
        return _Volume.CComplexVolume_abs(self)


    def limit(self, Lower, Upper):
        """limit(self, Lower, Upper) -> CComplexVolume"""
        return _Volume.CComplexVolume_limit(self, Lower, Upper)


    def cut(self, Lower, Upper):
        """cut(self, Lower, Upper) -> CComplexVolume"""
        return _Volume.CComplexVolume_cut(self, Lower, Upper)


    def subSample(self, Volume, l=2, m=2, n=2):
        """
        subSample(self, Volume, l=2, m=2, n=2) -> CComplexVolume
        subSample(self, Volume, l=2, m=2) -> CComplexVolume
        subSample(self, Volume, l=2) -> CComplexVolume
        subSample(self, Volume) -> CComplexVolume
        """
        return _Volume.CComplexVolume_subSample(self, Volume, l, m, n)


    def interpolate(self, Point):
        """interpolate(self, Point) -> vpl::math::CComplex< float >"""
        return _Volume.CComplexVolume_interpolate(self, Point)


    def color2Voxel(self, Color):
        """color2Voxel(self, Color) -> vpl::math::CComplex< float >"""
        return _Volume.CComplexVolume_color2Voxel(self, Color)


    def checkPosition(self, x, y, z):
        """checkPosition(self, x, y, z) -> bool"""
        return _Volume.CComplexVolume_checkPosition(self, x, y, z)


    def getPlaneXY(self, z, Plane):
        """getPlaneXY(self, z, Plane) -> bool"""
        return _Volume.CComplexVolume_getPlaneXY(self, z, Plane)


    def getPlaneXZ(self, y, Plane):
        """getPlaneXZ(self, y, Plane) -> bool"""
        return _Volume.CComplexVolume_getPlaneXZ(self, y, Plane)


    def getPlaneYZ(self, x, Plane):
        """getPlaneYZ(self, x, Plane) -> bool"""
        return _Volume.CComplexVolume_getPlaneYZ(self, x, Plane)


    def setPlaneXY(self, z, Plane):
        """setPlaneXY(self, z, Plane) -> bool"""
        return _Volume.CComplexVolume_setPlaneXY(self, z, Plane)


    def setPlaneXZ(self, y, Plane):
        """setPlaneXZ(self, y, Plane) -> bool"""
        return _Volume.CComplexVolume_setPlaneXZ(self, y, Plane)


    def setPlaneYZ(self, x, Plane):
        """setPlaneYZ(self, x, Plane) -> bool"""
        return _Volume.CComplexVolume_setPlaneYZ(self, x, Plane)


    def enableDummyMode(self, Enable):
        """enableDummyMode(self, Enable) -> CComplexVolume"""
        return _Volume.CComplexVolume_enableDummyMode(self, Enable)


    def isDummy(self):
        """isDummy(self) -> bool"""
        return _Volume.CComplexVolume_isDummy(self)

    def __disown__(self):
        self.this.disown()
        _Volume.disown_CComplexVolume(self)
        return weakref_proxy(self)
CComplexVolume_swigregister = _Volume.CComplexVolume_swigregister
CComplexVolume_swigregister(CComplexVolume)

class CDensityVolume(CDVolume):
    """Proxy of C++ vpl::img::CDensityVolume class."""

    __swig_setmethods__ = {}
    for _s in [CDVolume]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CDensityVolume, name, value)
    __swig_getmethods__ = {}
    for _s in [CDVolume]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CDensityVolume, name)
    __repr__ = _swig_repr

    def getName():
        """getName() -> char const *"""
        return _Volume.CDensityVolume_getName()

    getName = staticmethod(getName)

    def getCompression():
        """getCompression() -> int"""
        return _Volume.CDensityVolume_getCompression()

    getCompression = staticmethod(getCompression)
    DEFAULT_MARGIN = _Volume.CDensityVolume_DEFAULT_MARGIN

    def __init__(self, *args):
        """
        __init__(self) -> CDensityVolume
        __init__(self, XSize, YSize, ZSize, Margin) -> CDensityVolume
        __init__(self, XSize, YSize, ZSize) -> CDensityVolume
        __init__(self, Volume) -> CDensityVolume
        __init__(self, Volume, arg3) -> CDensityVolume
        __init__(self, Volume) -> CDensityVolume
        __init__(self, Volume, arg3) -> CDensityVolume
        """
        if self.__class__ == CDensityVolume:
            _self = None
        else:
            _self = self
        this = _Volume.new_CDensityVolume(_self, *args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _Volume.delete_CDensityVolume
    __del__ = lambda self: None

    def resize(self, *args):
        """
        resize(self, XSize, YSize, ZSize, Margin) -> CDensityVolume
        resize(self, XSize, YSize, ZSize) -> CDensityVolume
        resize(self, Size, Margin) -> CDensityVolume
        resize(self, Size) -> CDensityVolume
        """
        return _Volume.CDensityVolume_resize(self, *args)


    def copy(self, *args):
        """
        copy(self, Volume, Margin=-1) -> CDensityVolume
        copy(self, Volume) -> CDensityVolume
        copy(self, Volume, Margin=-1) -> CDensityVolume
        copy(self, Volume) -> CDensityVolume
        """
        return _Volume.CDensityVolume_copy(self, *args)


    def makeRef(self, *args):
        """
        makeRef(self, Volume) -> CDensityVolume
        makeRef(self, Volume) -> CDensityVolume
        """
        return _Volume.CDensityVolume_makeRef(self, *args)


    def copyProps(self, Volume):
        """copyProps(self, Volume) -> CDensityVolume"""
        return _Volume.CDensityVolume_copyProps(self, Volume)


    def getDX(self):
        """getDX(self) -> double"""
        return _Volume.CDensityVolume_getDX(self)


    def getDY(self):
        """getDY(self) -> double"""
        return _Volume.CDensityVolume_getDY(self)


    def getDZ(self):
        """getDZ(self) -> double"""
        return _Volume.CDensityVolume_getDZ(self)


    def setDX(self, dValue):
        """setDX(self, dValue) -> CDensityVolume"""
        return _Volume.CDensityVolume_setDX(self, dValue)


    def setDY(self, dValue):
        """setDY(self, dValue) -> CDensityVolume"""
        return _Volume.CDensityVolume_setDY(self, dValue)


    def setDZ(self, dValue):
        """setDZ(self, dValue) -> CDensityVolume"""
        return _Volume.CDensityVolume_setDZ(self, dValue)


    def setVoxel(self, dDX, dDY, dDZ):
        """setVoxel(self, dDX, dDY, dDZ) -> CDensityVolume"""
        return _Volume.CDensityVolume_setVoxel(self, dDX, dDY, dDZ)


    def makeVolume(self, *args):
        """
        makeVolume(self, Slices, BorderValue) -> bool
        makeVolume(self, Slices) -> bool
        """
        return _Volume.CDensityVolume_makeVolume(self, *args)


    def getSliceXY(self, *args):
        """
        getSliceXY(self, z, Plane) -> bool
        getSliceXY(self, dZ, Plane) -> bool
        """
        return _Volume.CDensityVolume_getSliceXY(self, *args)


    def getSliceXZ(self, *args):
        """
        getSliceXZ(self, y, Plane) -> bool
        getSliceXZ(self, dY, Plane) -> bool
        """
        return _Volume.CDensityVolume_getSliceXZ(self, *args)


    def getSliceYZ(self, *args):
        """
        getSliceYZ(self, x, Plane) -> bool
        getSliceYZ(self, dX, Plane) -> bool
        """
        return _Volume.CDensityVolume_getSliceYZ(self, *args)


    def getSlice(self, dPosition, Plane):
        """getSlice(self, dPosition, Plane) -> bool"""
        return _Volume.CDensityVolume_getSlice(self, dPosition, Plane)


    def initSlice(self, Slice, eOrientation):
        """initSlice(self, Slice, eOrientation)"""
        return _Volume.CDensityVolume_initSlice(self, Slice, eOrientation)

    def __disown__(self):
        self.this.disown()
        _Volume.disown_CDensityVolume(self)
        return weakref_proxy(self)
CDensityVolume_swigregister = _Volume.CDensityVolume_swigregister
CDensityVolume_swigregister(CDensityVolume)

def CDensityVolume_getName():
    """CDensityVolume_getName() -> char const *"""
    return _Volume.CDensityVolume_getName()

def CDensityVolume_getCompression():
    """CDensityVolume_getCompression() -> int"""
    return _Volume.CDensityVolume_getCompression()

class sp_densityVolume(_object):
    """Proxy of C++ vpl::base::CSharedPtr<(vpl::img::CDensityVolume)> class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, sp_densityVolume, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, sp_densityVolume, name)
    __repr__ = _swig_repr
    TEMPLATE_PARAMETER_IS_NOT_OBJECT = _Volume.sp_densityVolume_TEMPLATE_PARAMETER_IS_NOT_OBJECT

    def __init__(self, *args):
        """
        __init__(self) -> sp_densityVolume
        __init__(self, p) -> sp_densityVolume
        __init__(self, p) -> sp_densityVolume
        """
        this = _Volume.new_sp_densityVolume(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _Volume.delete_sp_densityVolume
    __del__ = lambda self: None

    def __deref__(self):
        """__deref__(self) -> CDensityVolume"""
        return _Volume.sp_densityVolume___deref__(self)


    def __ref__(self):
        """__ref__(self) -> CDensityVolume"""
        return _Volume.sp_densityVolume___ref__(self)


    def get(self, *args):
        """
        get(self) -> CDensityVolume
        get(self) -> CDensityVolume
        """
        return _Volume.sp_densityVolume_get(self, *args)


    def release(self):
        """release(self) -> CDensityVolume"""
        return _Volume.sp_densityVolume_release(self)


    def getName(self):
        """getName(self) -> char const *"""
        return _Volume.sp_densityVolume_getName(self)


    def getCompression(self):
        """getCompression(self) -> int"""
        return _Volume.sp_densityVolume_getCompression(self)


    def resize(self, *args):
        """
        resize(self, XSize, YSize, ZSize, Margin) -> CDensityVolume
        resize(self, XSize, YSize, ZSize) -> CDensityVolume
        resize(self, Size, Margin) -> CDensityVolume
        resize(self, Size) -> CDensityVolume
        """
        return _Volume.sp_densityVolume_resize(self, *args)


    def copy(self, *args):
        """
        copy(self, Volume, Margin=-1) -> CDensityVolume
        copy(self, Volume) -> CDensityVolume
        copy(self, Volume, Margin=-1) -> CDensityVolume
        copy(self, Volume) -> CDensityVolume
        """
        return _Volume.sp_densityVolume_copy(self, *args)


    def makeRef(self, *args):
        """
        makeRef(self, Volume) -> CDensityVolume
        makeRef(self, Volume) -> CDensityVolume
        """
        return _Volume.sp_densityVolume_makeRef(self, *args)


    def copyProps(self, Volume):
        """copyProps(self, Volume) -> CDensityVolume"""
        return _Volume.sp_densityVolume_copyProps(self, Volume)


    def getDX(self):
        """getDX(self) -> double"""
        return _Volume.sp_densityVolume_getDX(self)


    def getDY(self):
        """getDY(self) -> double"""
        return _Volume.sp_densityVolume_getDY(self)


    def getDZ(self):
        """getDZ(self) -> double"""
        return _Volume.sp_densityVolume_getDZ(self)


    def setDX(self, dValue):
        """setDX(self, dValue) -> CDensityVolume"""
        return _Volume.sp_densityVolume_setDX(self, dValue)


    def setDY(self, dValue):
        """setDY(self, dValue) -> CDensityVolume"""
        return _Volume.sp_densityVolume_setDY(self, dValue)


    def setDZ(self, dValue):
        """setDZ(self, dValue) -> CDensityVolume"""
        return _Volume.sp_densityVolume_setDZ(self, dValue)


    def setVoxel(self, dDX, dDY, dDZ):
        """setVoxel(self, dDX, dDY, dDZ) -> CDensityVolume"""
        return _Volume.sp_densityVolume_setVoxel(self, dDX, dDY, dDZ)


    def makeVolume(self, *args):
        """
        makeVolume(self, Slices, BorderValue) -> bool
        makeVolume(self, Slices) -> bool
        """
        return _Volume.sp_densityVolume_makeVolume(self, *args)


    def getSliceXY(self, *args):
        """
        getSliceXY(self, z, Plane) -> bool
        getSliceXY(self, dZ, Plane) -> bool
        """
        return _Volume.sp_densityVolume_getSliceXY(self, *args)


    def getSliceXZ(self, *args):
        """
        getSliceXZ(self, y, Plane) -> bool
        getSliceXZ(self, dY, Plane) -> bool
        """
        return _Volume.sp_densityVolume_getSliceXZ(self, *args)


    def getSliceYZ(self, *args):
        """
        getSliceYZ(self, x, Plane) -> bool
        getSliceYZ(self, dX, Plane) -> bool
        """
        return _Volume.sp_densityVolume_getSliceYZ(self, *args)


    def getSlice(self, dPosition, Plane):
        """getSlice(self, dPosition, Plane) -> bool"""
        return _Volume.sp_densityVolume_getSlice(self, dPosition, Plane)


    def initSlice(self, Slice, eOrientation):
        """initSlice(self, Slice, eOrientation)"""
        return _Volume.sp_densityVolume_initSlice(self, Slice, eOrientation)


    def getSize(self, *args):
        """
        getSize(self) -> CSize3_int
        getSize(self) -> CSize3_int
        """
        return _Volume.sp_densityVolume_getSize(self, *args)


    def getXSize(self):
        """getXSize(self) -> vpl::tSize"""
        return _Volume.sp_densityVolume_getXSize(self)


    def getYSize(self):
        """getYSize(self) -> vpl::tSize"""
        return _Volume.sp_densityVolume_getYSize(self)


    def getZSize(self):
        """getZSize(self) -> vpl::tSize"""
        return _Volume.sp_densityVolume_getZSize(self)


    def width(self):
        """width(self) -> vpl::tSize"""
        return _Volume.sp_densityVolume_width(self)


    def height(self):
        """height(self) -> vpl::tSize"""
        return _Volume.sp_densityVolume_height(self)


    def depth(self):
        """depth(self) -> vpl::tSize"""
        return _Volume.sp_densityVolume_depth(self)


    def getXOffset(self):
        """getXOffset(self) -> vpl::tSize"""
        return _Volume.sp_densityVolume_getXOffset(self)


    def getYOffset(self):
        """getYOffset(self) -> vpl::tSize"""
        return _Volume.sp_densityVolume_getYOffset(self)


    def getZOffset(self):
        """getZOffset(self) -> vpl::tSize"""
        return _Volume.sp_densityVolume_getZOffset(self)


    def getMargin(self):
        """getMargin(self) -> vpl::tSize"""
        return _Volume.sp_densityVolume_getMargin(self)


    def __call__(self, *args):
        """
        __call__(self, x, y, z) -> __int16
        __call__(self, x, y, z) -> __int16 const
        __call__(self, i) -> __int16
        __call__(self, i) -> __int16 const &
        """
        return _Volume.sp_densityVolume___call__(self, *args)


    def at(self, *args):
        """
        at(self, x, y, z) -> __int16 const
        at(self, i) -> __int16 const &
        """
        return _Volume.sp_densityVolume_at(self, *args)


    def set(self, *args):
        """
        set(self, x, y, z, Value) -> CDVolume
        set(self, i, Value) -> CDVolume
        """
        return _Volume.sp_densityVolume_set(self, *args)


    def getIdx(self, x, y, z):
        """getIdx(self, x, y, z) -> vpl::tSize"""
        return _Volume.sp_densityVolume_getIdx(self, x, y, z)


    def getPtr(self, *args):
        """
        getPtr(self) -> __int16
        getPtr(self) -> __int16 const
        getPtr(self, x, y, z) -> __int16
        getPtr(self, x, y, z) -> __int16 const *
        """
        return _Volume.sp_densityVolume_getPtr(self, *args)


    def getRowPtr(self, *args):
        """
        getRowPtr(self, y, z) -> __int16
        getRowPtr(self, y, z) -> __int16 const *
        """
        return _Volume.sp_densityVolume_getRowPtr(self, *args)


    def rect(self, *args):
        """
        rect(self, Position, Size) -> vpl::img::CVolume< __int16,vpl::base::CPartedData >::tRect
        rect(self, Position, Size) -> vpl::img::CVolume< __int16,vpl::base::CPartedData >::tRect const
        rect(self, XRange, YRange, ZRange) -> vpl::img::CVolume< __int16,vpl::base::CPartedData >::tRect
        rect(self, XRange, YRange, ZRange) -> vpl::img::CVolume< __int16,vpl::base::CPartedData >::tRect const
        """
        return _Volume.sp_densityVolume_rect(self, *args)


    def row(self, *args):
        """
        row(self, y, z) -> vpl::img::CVolume< __int16,vpl::base::CPartedData >::tRow
        row(self, y, z) -> vpl::img::CVolume< __int16,vpl::base::CPartedData >::tRow const
        """
        return _Volume.sp_densityVolume_row(self, *args)


    def fill(self, c):
        """fill(self, c) -> CDVolume"""
        return _Volume.sp_densityVolume_fill(self, c)


    def fillEntire(self, c):
        """fillEntire(self, c) -> CDVolume"""
        return _Volume.sp_densityVolume_fillEntire(self, c)


    def fillMargin(self, c):
        """fillMargin(self, c) -> CDVolume"""
        return _Volume.sp_densityVolume_fillMargin(self, c)


    def mirrorMargin(self):
        """mirrorMargin(self) -> CDVolume"""
        return _Volume.sp_densityVolume_mirrorMargin(self)


    def replace(self, Value, NewValue):
        """replace(self, Value, NewValue) -> CDVolume"""
        return _Volume.sp_densityVolume_replace(self, Value, NewValue)


    def abs(self):
        """abs(self) -> CDVolume"""
        return _Volume.sp_densityVolume_abs(self)


    def limit(self, Lower, Upper):
        """limit(self, Lower, Upper) -> CDVolume"""
        return _Volume.sp_densityVolume_limit(self, Lower, Upper)


    def cut(self, Lower, Upper):
        """cut(self, Lower, Upper) -> CDVolume"""
        return _Volume.sp_densityVolume_cut(self, Lower, Upper)


    def subSample(self, Volume, l=2, m=2, n=2):
        """
        subSample(self, Volume, l=2, m=2, n=2) -> CDVolume
        subSample(self, Volume, l=2, m=2) -> CDVolume
        subSample(self, Volume, l=2) -> CDVolume
        subSample(self, Volume) -> CDVolume
        """
        return _Volume.sp_densityVolume_subSample(self, Volume, l, m, n)


    def interpolate(self, Point):
        """interpolate(self, Point) -> __int16"""
        return _Volume.sp_densityVolume_interpolate(self, Point)


    def color2Voxel(self, Color):
        """color2Voxel(self, Color) -> __int16"""
        return _Volume.sp_densityVolume_color2Voxel(self, Color)


    def checkPosition(self, x, y, z):
        """checkPosition(self, x, y, z) -> bool"""
        return _Volume.sp_densityVolume_checkPosition(self, x, y, z)


    def getPlaneXY(self, z, Plane):
        """getPlaneXY(self, z, Plane) -> bool"""
        return _Volume.sp_densityVolume_getPlaneXY(self, z, Plane)


    def getPlaneXZ(self, y, Plane):
        """getPlaneXZ(self, y, Plane) -> bool"""
        return _Volume.sp_densityVolume_getPlaneXZ(self, y, Plane)


    def getPlaneYZ(self, x, Plane):
        """getPlaneYZ(self, x, Plane) -> bool"""
        return _Volume.sp_densityVolume_getPlaneYZ(self, x, Plane)


    def setPlaneXY(self, z, Plane):
        """setPlaneXY(self, z, Plane) -> bool"""
        return _Volume.sp_densityVolume_setPlaneXY(self, z, Plane)


    def setPlaneXZ(self, y, Plane):
        """setPlaneXZ(self, y, Plane) -> bool"""
        return _Volume.sp_densityVolume_setPlaneXZ(self, y, Plane)


    def setPlaneYZ(self, x, Plane):
        """setPlaneYZ(self, x, Plane) -> bool"""
        return _Volume.sp_densityVolume_setPlaneYZ(self, x, Plane)


    def enableDummyMode(self, Enable):
        """enableDummyMode(self, Enable) -> CDVolume"""
        return _Volume.sp_densityVolume_enableDummyMode(self, Enable)


    def isDummy(self):
        """isDummy(self) -> bool"""
        return _Volume.sp_densityVolume_isDummy(self)


    def getReferencesCount(self):
        """getReferencesCount(self) -> int"""
        return _Volume.sp_densityVolume_getReferencesCount(self)


    def isOnHeap(self):
        """isOnHeap(self) -> bool"""
        return _Volume.sp_densityVolume_isOnHeap(self)


    def getImpl(self, *args):
        """
        getImpl(self) -> CDVolume
        getImpl(self) -> CDVolume
        """
        return _Volume.sp_densityVolume_getImpl(self, *args)


    def getBlockSize(self):
        """getBlockSize(self) -> int"""
        return _Volume.sp_densityVolume_getBlockSize(self)

sp_densityVolume_swigregister = _Volume.sp_densityVolume_swigregister
sp_densityVolume_swigregister(sp_densityVolume)

# This file is compatible with both classic and new-style classes.



# This file was automatically generated by SWIG (http://www.swig.org). # Version 3.0.10 # # Do not make changes to this file unless you know what you are doing--modify # the SWIG interface file instead. # Python < 2.2 doesn't have 'property'. Proxy of C++ vpl::img::CVolumeView class. __init__(self) -> CVolumeView Proxy of C++ vpl::img::CVolumeBase<(vpl::img::CVolume<(vpl::img::tPixel8,vpl::base::CPartedData)>)> class. getImpl(self) -> CVolume8         getImpl(self) -> CVolume8 getSize(self) -> CSize3_int         getSize(self) -> CSize3_int getXSize(self) -> vpl::tSize getYSize(self) -> vpl::tSize getZSize(self) -> vpl::tSize width(self) -> vpl::tSize height(self) -> vpl::tSize depth(self) -> vpl::tSize getXOffset(self) -> vpl::tSize getYOffset(self) -> vpl::tSize getZOffset(self) -> vpl::tSize getMargin(self) -> vpl::tSize getIdx(self, x, y, z) -> vpl::tSize __call__(self, x, y, z) -> vpl::img::CVolumeBase< vpl::img::CVolume< unsigned __int8,vpl::base::CPartedData > >::tVoxel         __call__(self, x, y, z) -> vpl::img::CVolumeBase< vpl::img::CVolume< unsigned __int8,vpl::base::CPartedData > >::tVoxel const         __call__(self, i) -> vpl::img::CVolumeBase< vpl::img::CVolume< unsigned __int8,vpl::base::CPartedData > >::tVoxel         __call__(self, i) -> vpl::img::CVolumeBase< vpl::img::CVolume< unsigned __int8,vpl::base::CPartedData > >::tVoxel const & at(self, x, y, z) -> vpl::img::CVolumeBase< vpl::img::CVolume< unsigned __int8,vpl::base::CPartedData > >::tVoxel         at(self, x, y, z) -> vpl::img::CVolumeBase< vpl::img::CVolume< unsigned __int8,vpl::base::CPartedData > >::tVoxel const         at(self, i) -> vpl::img::CVolumeBase< vpl::img::CVolume< unsigned __int8,vpl::base::CPartedData > >::tVoxel         at(self, i) -> vpl::img::CVolumeBase< vpl::img::CVolume< unsigned __int8,vpl::base::CPartedData > >::tVoxel const & set(self, x, y, z, Value) -> CVolume8         set(self, i, Value) -> CVolume8 Proxy of C++ vpl::img::CVolumeBase<(vpl::img::CVolume<(vpl::img::tPixel16,vpl::base::CPartedData)>)> class. getImpl(self) -> CVolume16         getImpl(self) -> CVolume16 getSize(self) -> CSize3_int         getSize(self) -> CSize3_int getXSize(self) -> vpl::tSize getYSize(self) -> vpl::tSize getZSize(self) -> vpl::tSize width(self) -> vpl::tSize height(self) -> vpl::tSize depth(self) -> vpl::tSize getXOffset(self) -> vpl::tSize getYOffset(self) -> vpl::tSize getZOffset(self) -> vpl::tSize getMargin(self) -> vpl::tSize getIdx(self, x, y, z) -> vpl::tSize __call__(self, x, y, z) -> vpl::img::CVolumeBase< vpl::img::CVolume< unsigned __int16,vpl::base::CPartedData > >::tVoxel         __call__(self, x, y, z) -> vpl::img::CVolumeBase< vpl::img::CVolume< unsigned __int16,vpl::base::CPartedData > >::tVoxel const         __call__(self, i) -> vpl::img::CVolumeBase< vpl::img::CVolume< unsigned __int16,vpl::base::CPartedData > >::tVoxel         __call__(self, i) -> vpl::img::CVolumeBase< vpl::img::CVolume< unsigned __int16,vpl::base::CPartedData > >::tVoxel const & at(self, x, y, z) -> vpl::img::CVolumeBase< vpl::img::CVolume< unsigned __int16,vpl::base::CPartedData > >::tVoxel         at(self, x, y, z) -> vpl::img::CVolumeBase< vpl::img::CVolume< unsigned __int16,vpl::base::CPartedData > >::tVoxel const         at(self, i) -> vpl::img::CVolumeBase< vpl::img::CVolume< unsigned __int16,vpl::base::CPartedData > >::tVoxel         at(self, i) -> vpl::img::CVolumeBase< vpl::img::CVolume< unsigned __int16,vpl::base::CPartedData > >::tVoxel const & set(self, x, y, z, Value) -> CVolume16         set(self, i, Value) -> CVolume16 Proxy of C++ vpl::img::CVolumeBase<(vpl::img::CVolume<(vpl::img::tPixel32,vpl::base::CPartedData)>)> class. getImpl(self) -> CVolume32         getImpl(self) -> CVolume32 getSize(self) -> CSize3_int         getSize(self) -> CSize3_int getXSize(self) -> vpl::tSize getYSize(self) -> vpl::tSize getZSize(self) -> vpl::tSize width(self) -> vpl::tSize height(self) -> vpl::tSize depth(self) -> vpl::tSize getXOffset(self) -> vpl::tSize getYOffset(self) -> vpl::tSize getZOffset(self) -> vpl::tSize getMargin(self) -> vpl::tSize getIdx(self, x, y, z) -> vpl::tSize __call__(self, x, y, z) -> vpl::img::CVolumeBase< vpl::img::CVolume< unsigned __int32,vpl::base::CPartedData > >::tVoxel         __call__(self, x, y, z) -> vpl::img::CVolumeBase< vpl::img::CVolume< unsigned __int32,vpl::base::CPartedData > >::tVoxel const         __call__(self, i) -> vpl::img::CVolumeBase< vpl::img::CVolume< unsigned __int32,vpl::base::CPartedData > >::tVoxel         __call__(self, i) -> vpl::img::CVolumeBase< vpl::img::CVolume< unsigned __int32,vpl::base::CPartedData > >::tVoxel const & at(self, x, y, z) -> vpl::img::CVolumeBase< vpl::img::CVolume< unsigned __int32,vpl::base::CPartedData > >::tVoxel         at(self, x, y, z) -> vpl::img::CVolumeBase< vpl::img::CVolume< unsigned __int32,vpl::base::CPartedData > >::tVoxel const         at(self, i) -> vpl::img::CVolumeBase< vpl::img::CVolume< unsigned __int32,vpl::base::CPartedData > >::tVoxel         at(self, i) -> vpl::img::CVolumeBase< vpl::img::CVolume< unsigned __int32,vpl::base::CPartedData > >::tVoxel const & set(self, x, y, z, Value) -> CVolume32         set(self, i, Value) -> CVolume32 Proxy of C++ vpl::img::CVolumeBase<(vpl::img::CVolume<(vpl::img::tFloatPixel,vpl::base::CPartedData)>)> class. getImpl(self) -> CFVolume         getImpl(self) -> CFVolume getSize(self) -> CSize3_int         getSize(self) -> CSize3_int getXSize(self) -> vpl::tSize getYSize(self) -> vpl::tSize getZSize(self) -> vpl::tSize width(self) -> vpl::tSize height(self) -> vpl::tSize depth(self) -> vpl::tSize getXOffset(self) -> vpl::tSize getYOffset(self) -> vpl::tSize getZOffset(self) -> vpl::tSize getMargin(self) -> vpl::tSize getIdx(self, x, y, z) -> vpl::tSize __call__(self, x, y, z) -> vpl::img::CVolumeBase< vpl::img::CVolume< float,vpl::base::CPartedData > >::tVoxel         __call__(self, x, y, z) -> vpl::img::CVolumeBase< vpl::img::CVolume< float,vpl::base::CPartedData > >::tVoxel const         __call__(self, i) -> vpl::img::CVolumeBase< vpl::img::CVolume< float,vpl::base::CPartedData > >::tVoxel         __call__(self, i) -> vpl::img::CVolumeBase< vpl::img::CVolume< float,vpl::base::CPartedData > >::tVoxel const & at(self, x, y, z) -> vpl::img::CVolumeBase< vpl::img::CVolume< float,vpl::base::CPartedData > >::tVoxel         at(self, x, y, z) -> vpl::img::CVolumeBase< vpl::img::CVolume< float,vpl::base::CPartedData > >::tVoxel const         at(self, i) -> vpl::img::CVolumeBase< vpl::img::CVolume< float,vpl::base::CPartedData > >::tVoxel         at(self, i) -> vpl::img::CVolumeBase< vpl::img::CVolume< float,vpl::base::CPartedData > >::tVoxel const & set(self, x, y, z, Value) -> CFVolume         set(self, i, Value) -> CFVolume Proxy of C++ vpl::img::CVolumeBase<(vpl::img::CVolume<(vpl::img::tDensityPixel,vpl::base::CPartedData)>)> class. getImpl(self) -> CDVolume         getImpl(self) -> CDVolume getSize(self) -> CSize3_int         getSize(self) -> CSize3_int getXSize(self) -> vpl::tSize getYSize(self) -> vpl::tSize getZSize(self) -> vpl::tSize width(self) -> vpl::tSize height(self) -> vpl::tSize depth(self) -> vpl::tSize getXOffset(self) -> vpl::tSize getYOffset(self) -> vpl::tSize getZOffset(self) -> vpl::tSize getMargin(self) -> vpl::tSize getIdx(self, x, y, z) -> vpl::tSize __call__(self, x, y, z) -> vpl::img::CVolumeBase< vpl::img::CVolume< __int16,vpl::base::CPartedData > >::tVoxel         __call__(self, x, y, z) -> vpl::img::CVolumeBase< vpl::img::CVolume< __int16,vpl::base::CPartedData > >::tVoxel const         __call__(self, i) -> vpl::img::CVolumeBase< vpl::img::CVolume< __int16,vpl::base::CPartedData > >::tVoxel         __call__(self, i) -> vpl::img::CVolumeBase< vpl::img::CVolume< __int16,vpl::base::CPartedData > >::tVoxel const & at(self, x, y, z) -> vpl::img::CVolumeBase< vpl::img::CVolume< __int16,vpl::base::CPartedData > >::tVoxel         at(self, x, y, z) -> vpl::img::CVolumeBase< vpl::img::CVolume< __int16,vpl::base::CPartedData > >::tVoxel const         at(self, i) -> vpl::img::CVolumeBase< vpl::img::CVolume< __int16,vpl::base::CPartedData > >::tVoxel         at(self, i) -> vpl::img::CVolumeBase< vpl::img::CVolume< __int16,vpl::base::CPartedData > >::tVoxel const & set(self, x, y, z, Value) -> CDVolume         set(self, i, Value) -> CDVolume Proxy of C++ vpl::img::CVolumeBase<(vpl::img::CVolume<(vpl::img::tRGBAPixel,vpl::base::CPartedData)>)> class. getImpl(self) -> CRGBAVolume         getImpl(self) -> CRGBAVolume getSize(self) -> CSize3_int         getSize(self) -> CSize3_int getXSize(self) -> vpl::tSize getYSize(self) -> vpl::tSize getZSize(self) -> vpl::tSize width(self) -> vpl::tSize height(self) -> vpl::tSize depth(self) -> vpl::tSize getXOffset(self) -> vpl::tSize getYOffset(self) -> vpl::tSize getZOffset(self) -> vpl::tSize getMargin(self) -> vpl::tSize getIdx(self, x, y, z) -> vpl::tSize __call__(self, x, y, z) -> vpl::img::CVolumeBase< vpl::img::CVolume< vpl::img::CRGBPixel,vpl::base::CPartedData > >::tVoxel         __call__(self, x, y, z) -> vpl::img::CVolumeBase< vpl::img::CVolume< vpl::img::CRGBPixel,vpl::base::CPartedData > >::tVoxel const         __call__(self, i) -> vpl::img::CVolumeBase< vpl::img::CVolume< vpl::img::CRGBPixel,vpl::base::CPartedData > >::tVoxel         __call__(self, i) -> vpl::img::CVolumeBase< vpl::img::CVolume< vpl::img::CRGBPixel,vpl::base::CPartedData > >::tVoxel const & at(self, x, y, z) -> vpl::img::CVolumeBase< vpl::img::CVolume< vpl::img::CRGBPixel,vpl::base::CPartedData > >::tVoxel         at(self, x, y, z) -> vpl::img::CVolumeBase< vpl::img::CVolume< vpl::img::CRGBPixel,vpl::base::CPartedData > >::tVoxel const         at(self, i) -> vpl::img::CVolumeBase< vpl::img::CVolume< vpl::img::CRGBPixel,vpl::base::CPartedData > >::tVoxel         at(self, i) -> vpl::img::CVolumeBase< vpl::img::CVolume< vpl::img::CRGBPixel,vpl::base::CPartedData > >::tVoxel const & set(self, x, y, z, Value) -> CRGBAVolume         set(self, i, Value) -> CRGBAVolume Proxy of C++ vpl::img::CVolumeBase<(vpl::img::CVolume<(vpl::img::tComplexPixel,vpl::base::CPartedData)>)> class. getImpl(self) -> CComplexVolume         getImpl(self) -> CComplexVolume getSize(self) -> CSize3_int         getSize(self) -> CSize3_int getXSize(self) -> vpl::tSize getYSize(self) -> vpl::tSize getZSize(self) -> vpl::tSize width(self) -> vpl::tSize height(self) -> vpl::tSize depth(self) -> vpl::tSize getXOffset(self) -> vpl::tSize getYOffset(self) -> vpl::tSize getZOffset(self) -> vpl::tSize getMargin(self) -> vpl::tSize getIdx(self, x, y, z) -> vpl::tSize __call__(self, x, y, z) -> vpl::img::CVolumeBase< vpl::img::CVolume< vpl::math::CComplex< float >,vpl::base::CPartedData > >::tVoxel         __call__(self, x, y, z) -> vpl::img::CVolumeBase< vpl::img::CVolume< vpl::math::CComplex< float >,vpl::base::CPartedData > >::tVoxel const         __call__(self, i) -> vpl::img::CVolumeBase< vpl::img::CVolume< vpl::math::CComplex< float >,vpl::base::CPartedData > >::tVoxel         __call__(self, i) -> vpl::img::CVolumeBase< vpl::img::CVolume< vpl::math::CComplex< float >,vpl::base::CPartedData > >::tVoxel const & at(self, x, y, z) -> vpl::img::CVolumeBase< vpl::img::CVolume< vpl::math::CComplex< float >,vpl::base::CPartedData > >::tVoxel         at(self, x, y, z) -> vpl::img::CVolumeBase< vpl::img::CVolume< vpl::math::CComplex< float >,vpl::base::CPartedData > >::tVoxel const         at(self, i) -> vpl::img::CVolumeBase< vpl::img::CVolume< vpl::math::CComplex< float >,vpl::base::CPartedData > >::tVoxel         at(self, i) -> vpl::img::CVolumeBase< vpl::img::CVolume< vpl::math::CComplex< float >,vpl::base::CPartedData > >::tVoxel const & set(self, x, y, z, Value) -> CComplexVolume         set(self, i, Value) -> CComplexVolume Proxy of C++ vpl::img::CVolume<(vpl::img::tPixel8,vpl::base::CPartedData)> class. __init__(self) -> CVolume8         __init__(self, XSize, YSize, ZSize, Margin=0) -> CVolume8         __init__(self, XSize, YSize, ZSize) -> CVolume8         __init__(self, Size, Margin=0) -> CVolume8         __init__(self, Size) -> CVolume8         __init__(self, Volume, x, y, z, XSize, YSize, ZSize) -> CVolume8         __init__(self, Volume, x, y, z, XSize, YSize, ZSize, arg9) -> CVolume8         __init__(self, Volume) -> CVolume8         __init__(self, Volume, arg3) -> CVolume8         __init__(self, Volume) -> CVolume8         __init__(self, Volume, arg3) -> CVolume8 resize(self, XSize, YSize, ZSize, Margin=0) -> CVolume8         resize(self, XSize, YSize, ZSize) -> CVolume8         resize(self, Size, Margin=0) -> CVolume8         resize(self, Size) -> CVolume8 copy(self, Volume, Margin=-1) -> CVolume8         copy(self, Volume) -> CVolume8         copy(self, Volume, x, y, z, XSize, YSize, ZSize, Margin=-1) -> CVolume8         copy(self, Volume, x, y, z, XSize, YSize, ZSize) -> CVolume8         copy(self, Volume, Margin=-1) -> CVolume8         copy(self, Volume) -> CVolume8 makeRef(self, Volume) -> CVolume8         makeRef(self, Volume, x, y, z, XSize, YSize, ZSize) -> CVolume8         makeRef(self, Volume) -> CVolume8 getSize(self) -> CSize3_int         getSize(self) -> CSize3_int getXSize(self) -> vpl::tSize getYSize(self) -> vpl::tSize getZSize(self) -> vpl::tSize width(self) -> vpl::tSize height(self) -> vpl::tSize depth(self) -> vpl::tSize getXOffset(self) -> vpl::tSize getYOffset(self) -> vpl::tSize getZOffset(self) -> vpl::tSize getMargin(self) -> vpl::tSize getIdx(self, x, y, z) -> vpl::tSize __call__(self, x, y, z) -> unsigned __int8         __call__(self, x, y, z) -> unsigned __int8 const         __call__(self, i) -> unsigned __int8         __call__(self, i) -> unsigned __int8 const & at(self, x, y, z) -> unsigned __int8 const         at(self, i) -> unsigned __int8 const & set(self, x, y, z, Value) -> CVolume8         set(self, i, Value) -> CVolume8 getPtr(self) -> unsigned __int8         getPtr(self) -> unsigned __int8 const         getPtr(self, x, y, z) -> unsigned __int8         getPtr(self, x, y, z) -> unsigned __int8 const * getRowPtr(self, y, z) -> unsigned __int8         getRowPtr(self, y, z) -> unsigned __int8 const * rect(self, Position, Size) -> vpl::img::CVolume< unsigned __int8,vpl::base::CPartedData >::tRect         rect(self, Position, Size) -> vpl::img::CVolume< unsigned __int8,vpl::base::CPartedData >::tRect const         rect(self, XRange, YRange, ZRange) -> vpl::img::CVolume< unsigned __int8,vpl::base::CPartedData >::tRect         rect(self, XRange, YRange, ZRange) -> vpl::img::CVolume< unsigned __int8,vpl::base::CPartedData >::tRect const row(self, y, z) -> vpl::img::CVolume< unsigned __int8,vpl::base::CPartedData >::tRow         row(self, y, z) -> vpl::img::CVolume< unsigned __int8,vpl::base::CPartedData >::tRow const fill(self, c) -> CVolume8 fillEntire(self, c) -> CVolume8 fillMargin(self, c) -> CVolume8 mirrorMargin(self) -> CVolume8 replace(self, Value, NewValue) -> CVolume8 abs(self) -> CVolume8 limit(self, Lower, Upper) -> CVolume8 cut(self, Lower, Upper) -> CVolume8 subSample(self, Volume, l=2, m=2, n=2) -> CVolume8         subSample(self, Volume, l=2, m=2) -> CVolume8         subSample(self, Volume, l=2) -> CVolume8         subSample(self, Volume) -> CVolume8 interpolate(self, Point) -> unsigned __int8 color2Voxel(self, Color) -> unsigned __int8 checkPosition(self, x, y, z) -> bool getPlaneXY(self, z, Plane) -> bool getPlaneXZ(self, y, Plane) -> bool getPlaneYZ(self, x, Plane) -> bool setPlaneXY(self, z, Plane) -> bool setPlaneXZ(self, y, Plane) -> bool setPlaneYZ(self, x, Plane) -> bool enableDummyMode(self, Enable) -> CVolume8 isDummy(self) -> bool Proxy of C++ vpl::img::CVolume<(vpl::img::tPixel16,vpl::base::CPartedData)> class. __init__(self) -> CVolume16         __init__(self, XSize, YSize, ZSize, Margin=0) -> CVolume16         __init__(self, XSize, YSize, ZSize) -> CVolume16         __init__(self, Size, Margin=0) -> CVolume16         __init__(self, Size) -> CVolume16         __init__(self, Volume, x, y, z, XSize, YSize, ZSize) -> CVolume16         __init__(self, Volume, x, y, z, XSize, YSize, ZSize, arg9) -> CVolume16         __init__(self, Volume) -> CVolume16         __init__(self, Volume, arg3) -> CVolume16         __init__(self, Volume) -> CVolume16         __init__(self, Volume, arg3) -> CVolume16 resize(self, XSize, YSize, ZSize, Margin=0) -> CVolume16         resize(self, XSize, YSize, ZSize) -> CVolume16         resize(self, Size, Margin=0) -> CVolume16         resize(self, Size) -> CVolume16 copy(self, Volume, Margin=-1) -> CVolume16         copy(self, Volume) -> CVolume16         copy(self, Volume, x, y, z, XSize, YSize, ZSize, Margin=-1) -> CVolume16         copy(self, Volume, x, y, z, XSize, YSize, ZSize) -> CVolume16         copy(self, Volume, Margin=-1) -> CVolume16         copy(self, Volume) -> CVolume16 makeRef(self, Volume) -> CVolume16         makeRef(self, Volume, x, y, z, XSize, YSize, ZSize) -> CVolume16         makeRef(self, Volume) -> CVolume16 getSize(self) -> CSize3_int         getSize(self) -> CSize3_int getXSize(self) -> vpl::tSize getYSize(self) -> vpl::tSize getZSize(self) -> vpl::tSize width(self) -> vpl::tSize height(self) -> vpl::tSize depth(self) -> vpl::tSize getXOffset(self) -> vpl::tSize getYOffset(self) -> vpl::tSize getZOffset(self) -> vpl::tSize getMargin(self) -> vpl::tSize getIdx(self, x, y, z) -> vpl::tSize __call__(self, x, y, z) -> unsigned __int16         __call__(self, x, y, z) -> unsigned __int16 const         __call__(self, i) -> unsigned __int16         __call__(self, i) -> unsigned __int16 const & at(self, x, y, z) -> unsigned __int16 const         at(self, i) -> unsigned __int16 const & set(self, x, y, z, Value) -> CVolume16         set(self, i, Value) -> CVolume16 getPtr(self) -> unsigned __int16         getPtr(self) -> unsigned __int16 const         getPtr(self, x, y, z) -> unsigned __int16         getPtr(self, x, y, z) -> unsigned __int16 const * getRowPtr(self, y, z) -> unsigned __int16         getRowPtr(self, y, z) -> unsigned __int16 const * rect(self, Position, Size) -> vpl::img::CVolume< unsigned __int16,vpl::base::CPartedData >::tRect         rect(self, Position, Size) -> vpl::img::CVolume< unsigned __int16,vpl::base::CPartedData >::tRect const         rect(self, XRange, YRange, ZRange) -> vpl::img::CVolume< unsigned __int16,vpl::base::CPartedData >::tRect         rect(self, XRange, YRange, ZRange) -> vpl::img::CVolume< unsigned __int16,vpl::base::CPartedData >::tRect const row(self, y, z) -> vpl::img::CVolume< unsigned __int16,vpl::base::CPartedData >::tRow         row(self, y, z) -> vpl::img::CVolume< unsigned __int16,vpl::base::CPartedData >::tRow const fill(self, c) -> CVolume16 fillEntire(self, c) -> CVolume16 fillMargin(self, c) -> CVolume16 mirrorMargin(self) -> CVolume16 replace(self, Value, NewValue) -> CVolume16 abs(self) -> CVolume16 limit(self, Lower, Upper) -> CVolume16 cut(self, Lower, Upper) -> CVolume16 subSample(self, Volume, l=2, m=2, n=2) -> CVolume16         subSample(self, Volume, l=2, m=2) -> CVolume16         subSample(self, Volume, l=2) -> CVolume16         subSample(self, Volume) -> CVolume16 interpolate(self, Point) -> unsigned __int16 color2Voxel(self, Color) -> unsigned __int16 checkPosition(self, x, y, z) -> bool getPlaneXY(self, z, Plane) -> bool getPlaneXZ(self, y, Plane) -> bool getPlaneYZ(self, x, Plane) -> bool setPlaneXY(self, z, Plane) -> bool setPlaneXZ(self, y, Plane) -> bool setPlaneYZ(self, x, Plane) -> bool enableDummyMode(self, Enable) -> CVolume16 isDummy(self) -> bool Proxy of C++ vpl::img::CVolume<(vpl::img::tPixel32,vpl::base::CPartedData)> class. __init__(self) -> CVolume32         __init__(self, XSize, YSize, ZSize, Margin=0) -> CVolume32         __init__(self, XSize, YSize, ZSize) -> CVolume32         __init__(self, Size, Margin=0) -> CVolume32         __init__(self, Size) -> CVolume32         __init__(self, Volume, x, y, z, XSize, YSize, ZSize) -> CVolume32         __init__(self, Volume, x, y, z, XSize, YSize, ZSize, arg9) -> CVolume32         __init__(self, Volume) -> CVolume32         __init__(self, Volume, arg3) -> CVolume32         __init__(self, Volume) -> CVolume32         __init__(self, Volume, arg3) -> CVolume32 resize(self, XSize, YSize, ZSize, Margin=0) -> CVolume32         resize(self, XSize, YSize, ZSize) -> CVolume32         resize(self, Size, Margin=0) -> CVolume32         resize(self, Size) -> CVolume32 copy(self, Volume, Margin=-1) -> CVolume32         copy(self, Volume) -> CVolume32         copy(self, Volume, x, y, z, XSize, YSize, ZSize, Margin=-1) -> CVolume32         copy(self, Volume, x, y, z, XSize, YSize, ZSize) -> CVolume32         copy(self, Volume, Margin=-1) -> CVolume32         copy(self, Volume) -> CVolume32 makeRef(self, Volume) -> CVolume32         makeRef(self, Volume, x, y, z, XSize, YSize, ZSize) -> CVolume32         makeRef(self, Volume) -> CVolume32 getSize(self) -> CSize3_int         getSize(self) -> CSize3_int getXSize(self) -> vpl::tSize getYSize(self) -> vpl::tSize getZSize(self) -> vpl::tSize width(self) -> vpl::tSize height(self) -> vpl::tSize depth(self) -> vpl::tSize getXOffset(self) -> vpl::tSize getYOffset(self) -> vpl::tSize getZOffset(self) -> vpl::tSize getMargin(self) -> vpl::tSize getIdx(self, x, y, z) -> vpl::tSize __call__(self, x, y, z) -> unsigned __int32         __call__(self, x, y, z) -> unsigned __int32 const         __call__(self, i) -> unsigned __int32         __call__(self, i) -> unsigned __int32 const & at(self, x, y, z) -> unsigned __int32 const         at(self, i) -> unsigned __int32 const & set(self, x, y, z, Value) -> CVolume32         set(self, i, Value) -> CVolume32 getPtr(self) -> unsigned __int32         getPtr(self) -> unsigned __int32 const         getPtr(self, x, y, z) -> unsigned __int32         getPtr(self, x, y, z) -> unsigned __int32 const * getRowPtr(self, y, z) -> unsigned __int32         getRowPtr(self, y, z) -> unsigned __int32 const * rect(self, Position, Size) -> vpl::img::CVolume< unsigned __int32,vpl::base::CPartedData >::tRect         rect(self, Position, Size) -> vpl::img::CVolume< unsigned __int32,vpl::base::CPartedData >::tRect const         rect(self, XRange, YRange, ZRange) -> vpl::img::CVolume< unsigned __int32,vpl::base::CPartedData >::tRect         rect(self, XRange, YRange, ZRange) -> vpl::img::CVolume< unsigned __int32,vpl::base::CPartedData >::tRect const row(self, y, z) -> vpl::img::CVolume< unsigned __int32,vpl::base::CPartedData >::tRow         row(self, y, z) -> vpl::img::CVolume< unsigned __int32,vpl::base::CPartedData >::tRow const fill(self, c) -> CVolume32 fillEntire(self, c) -> CVolume32 fillMargin(self, c) -> CVolume32 mirrorMargin(self) -> CVolume32 replace(self, Value, NewValue) -> CVolume32 abs(self) -> CVolume32 limit(self, Lower, Upper) -> CVolume32 cut(self, Lower, Upper) -> CVolume32 subSample(self, Volume, l=2, m=2, n=2) -> CVolume32         subSample(self, Volume, l=2, m=2) -> CVolume32         subSample(self, Volume, l=2) -> CVolume32         subSample(self, Volume) -> CVolume32 interpolate(self, Point) -> unsigned __int32 color2Voxel(self, Color) -> unsigned __int32 checkPosition(self, x, y, z) -> bool getPlaneXY(self, z, Plane) -> bool getPlaneXZ(self, y, Plane) -> bool getPlaneYZ(self, x, Plane) -> bool setPlaneXY(self, z, Plane) -> bool setPlaneXZ(self, y, Plane) -> bool setPlaneYZ(self, x, Plane) -> bool enableDummyMode(self, Enable) -> CVolume32 isDummy(self) -> bool Proxy of C++ vpl::img::CVolume<(vpl::img::tFloatPixel,vpl::base::CPartedData)> class. __init__(self) -> CFVolume         __init__(self, XSize, YSize, ZSize, Margin=0) -> CFVolume         __init__(self, XSize, YSize, ZSize) -> CFVolume         __init__(self, Size, Margin=0) -> CFVolume         __init__(self, Size) -> CFVolume         __init__(self, Volume, x, y, z, XSize, YSize, ZSize) -> CFVolume         __init__(self, Volume, x, y, z, XSize, YSize, ZSize, arg9) -> CFVolume         __init__(self, Volume) -> CFVolume         __init__(self, Volume, arg3) -> CFVolume         __init__(self, Volume) -> CFVolume         __init__(self, Volume, arg3) -> CFVolume resize(self, XSize, YSize, ZSize, Margin=0) -> CFVolume         resize(self, XSize, YSize, ZSize) -> CFVolume         resize(self, Size, Margin=0) -> CFVolume         resize(self, Size) -> CFVolume copy(self, Volume, Margin=-1) -> CFVolume         copy(self, Volume) -> CFVolume         copy(self, Volume, x, y, z, XSize, YSize, ZSize, Margin=-1) -> CFVolume         copy(self, Volume, x, y, z, XSize, YSize, ZSize) -> CFVolume         copy(self, Volume, Margin=-1) -> CFVolume         copy(self, Volume) -> CFVolume makeRef(self, Volume) -> CFVolume         makeRef(self, Volume, x, y, z, XSize, YSize, ZSize) -> CFVolume         makeRef(self, Volume) -> CFVolume getSize(self) -> CSize3_int         getSize(self) -> CSize3_int getXSize(self) -> vpl::tSize getYSize(self) -> vpl::tSize getZSize(self) -> vpl::tSize width(self) -> vpl::tSize height(self) -> vpl::tSize depth(self) -> vpl::tSize getXOffset(self) -> vpl::tSize getYOffset(self) -> vpl::tSize getZOffset(self) -> vpl::tSize getMargin(self) -> vpl::tSize getIdx(self, x, y, z) -> vpl::tSize __call__(self, x, y, z) -> float         __call__(self, x, y, z) -> float const         __call__(self, i) -> float         __call__(self, i) -> float const & at(self, x, y, z) -> float const         at(self, i) -> float const & set(self, x, y, z, Value) -> CFVolume         set(self, i, Value) -> CFVolume getPtr(self) -> float         getPtr(self) -> float const         getPtr(self, x, y, z) -> float         getPtr(self, x, y, z) -> float const * getRowPtr(self, y, z) -> float         getRowPtr(self, y, z) -> float const * rect(self, Position, Size) -> vpl::img::CVolume< float,vpl::base::CPartedData >::tRect         rect(self, Position, Size) -> vpl::img::CVolume< float,vpl::base::CPartedData >::tRect const         rect(self, XRange, YRange, ZRange) -> vpl::img::CVolume< float,vpl::base::CPartedData >::tRect         rect(self, XRange, YRange, ZRange) -> vpl::img::CVolume< float,vpl::base::CPartedData >::tRect const row(self, y, z) -> vpl::img::CVolume< float,vpl::base::CPartedData >::tRow         row(self, y, z) -> vpl::img::CVolume< float,vpl::base::CPartedData >::tRow const fill(self, c) -> CFVolume fillEntire(self, c) -> CFVolume fillMargin(self, c) -> CFVolume mirrorMargin(self) -> CFVolume replace(self, Value, NewValue) -> CFVolume abs(self) -> CFVolume limit(self, Lower, Upper) -> CFVolume cut(self, Lower, Upper) -> CFVolume subSample(self, Volume, l=2, m=2, n=2) -> CFVolume         subSample(self, Volume, l=2, m=2) -> CFVolume         subSample(self, Volume, l=2) -> CFVolume         subSample(self, Volume) -> CFVolume interpolate(self, Point) -> float color2Voxel(self, Color) -> float checkPosition(self, x, y, z) -> bool getPlaneXY(self, z, Plane) -> bool getPlaneXZ(self, y, Plane) -> bool getPlaneYZ(self, x, Plane) -> bool setPlaneXY(self, z, Plane) -> bool setPlaneXZ(self, y, Plane) -> bool setPlaneYZ(self, x, Plane) -> bool enableDummyMode(self, Enable) -> CFVolume isDummy(self) -> bool Proxy of C++ vpl::img::CVolume<(vpl::img::tDensityPixel,vpl::base::CPartedData)> class. __init__(self) -> CDVolume         __init__(self, XSize, YSize, ZSize, Margin=0) -> CDVolume         __init__(self, XSize, YSize, ZSize) -> CDVolume         __init__(self, Size, Margin=0) -> CDVolume         __init__(self, Size) -> CDVolume         __init__(self, Volume, x, y, z, XSize, YSize, ZSize) -> CDVolume         __init__(self, Volume, x, y, z, XSize, YSize, ZSize, arg9) -> CDVolume         __init__(self, Volume) -> CDVolume         __init__(self, Volume, arg3) -> CDVolume         __init__(self, Volume) -> CDVolume         __init__(self, Volume, arg3) -> CDVolume resize(self, XSize, YSize, ZSize, Margin=0) -> CDVolume         resize(self, XSize, YSize, ZSize) -> CDVolume         resize(self, Size, Margin=0) -> CDVolume         resize(self, Size) -> CDVolume copy(self, Volume, Margin=-1) -> CDVolume         copy(self, Volume) -> CDVolume         copy(self, Volume, x, y, z, XSize, YSize, ZSize, Margin=-1) -> CDVolume         copy(self, Volume, x, y, z, XSize, YSize, ZSize) -> CDVolume         copy(self, Volume, Margin=-1) -> CDVolume         copy(self, Volume) -> CDVolume makeRef(self, Volume) -> CDVolume         makeRef(self, Volume, x, y, z, XSize, YSize, ZSize) -> CDVolume         makeRef(self, Volume) -> CDVolume getSize(self) -> CSize3_int         getSize(self) -> CSize3_int getXSize(self) -> vpl::tSize getYSize(self) -> vpl::tSize getZSize(self) -> vpl::tSize width(self) -> vpl::tSize height(self) -> vpl::tSize depth(self) -> vpl::tSize getXOffset(self) -> vpl::tSize getYOffset(self) -> vpl::tSize getZOffset(self) -> vpl::tSize getMargin(self) -> vpl::tSize getIdx(self, x, y, z) -> vpl::tSize __call__(self, x, y, z) -> __int16         __call__(self, x, y, z) -> __int16 const         __call__(self, i) -> __int16         __call__(self, i) -> __int16 const & at(self, x, y, z) -> __int16 const         at(self, i) -> __int16 const & set(self, x, y, z, Value) -> CDVolume         set(self, i, Value) -> CDVolume getPtr(self) -> __int16         getPtr(self) -> __int16 const         getPtr(self, x, y, z) -> __int16         getPtr(self, x, y, z) -> __int16 const * getRowPtr(self, y, z) -> __int16         getRowPtr(self, y, z) -> __int16 const * rect(self, Position, Size) -> vpl::img::CVolume< __int16,vpl::base::CPartedData >::tRect         rect(self, Position, Size) -> vpl::img::CVolume< __int16,vpl::base::CPartedData >::tRect const         rect(self, XRange, YRange, ZRange) -> vpl::img::CVolume< __int16,vpl::base::CPartedData >::tRect         rect(self, XRange, YRange, ZRange) -> vpl::img::CVolume< __int16,vpl::base::CPartedData >::tRect const row(self, y, z) -> vpl::img::CVolume< __int16,vpl::base::CPartedData >::tRow         row(self, y, z) -> vpl::img::CVolume< __int16,vpl::base::CPartedData >::tRow const fill(self, c) -> CDVolume fillEntire(self, c) -> CDVolume fillMargin(self, c) -> CDVolume mirrorMargin(self) -> CDVolume replace(self, Value, NewValue) -> CDVolume abs(self) -> CDVolume limit(self, Lower, Upper) -> CDVolume cut(self, Lower, Upper) -> CDVolume subSample(self, Volume, l=2, m=2, n=2) -> CDVolume         subSample(self, Volume, l=2, m=2) -> CDVolume         subSample(self, Volume, l=2) -> CDVolume         subSample(self, Volume) -> CDVolume interpolate(self, Point) -> __int16 color2Voxel(self, Color) -> __int16 checkPosition(self, x, y, z) -> bool getPlaneXY(self, z, Plane) -> bool getPlaneXZ(self, y, Plane) -> bool getPlaneYZ(self, x, Plane) -> bool setPlaneXY(self, z, Plane) -> bool setPlaneXZ(self, y, Plane) -> bool setPlaneYZ(self, x, Plane) -> bool enableDummyMode(self, Enable) -> CDVolume isDummy(self) -> bool Proxy of C++ vpl::img::CVolume<(vpl::img::tRGBAPixel,vpl::base::CPartedData)> class. __init__(self) -> CRGBAVolume         __init__(self, XSize, YSize, ZSize, Margin=0) -> CRGBAVolume         __init__(self, XSize, YSize, ZSize) -> CRGBAVolume         __init__(self, Size, Margin=0) -> CRGBAVolume         __init__(self, Size) -> CRGBAVolume         __init__(self, Volume, x, y, z, XSize, YSize, ZSize) -> CRGBAVolume         __init__(self, Volume, x, y, z, XSize, YSize, ZSize, arg9) -> CRGBAVolume         __init__(self, Volume) -> CRGBAVolume         __init__(self, Volume, arg3) -> CRGBAVolume         __init__(self, Volume) -> CRGBAVolume         __init__(self, Volume, arg3) -> CRGBAVolume resize(self, XSize, YSize, ZSize, Margin=0) -> CRGBAVolume         resize(self, XSize, YSize, ZSize) -> CRGBAVolume         resize(self, Size, Margin=0) -> CRGBAVolume         resize(self, Size) -> CRGBAVolume copy(self, Volume, Margin=-1) -> CRGBAVolume         copy(self, Volume) -> CRGBAVolume         copy(self, Volume, x, y, z, XSize, YSize, ZSize, Margin=-1) -> CRGBAVolume         copy(self, Volume, x, y, z, XSize, YSize, ZSize) -> CRGBAVolume         copy(self, Volume, Margin=-1) -> CRGBAVolume         copy(self, Volume) -> CRGBAVolume makeRef(self, Volume) -> CRGBAVolume         makeRef(self, Volume, x, y, z, XSize, YSize, ZSize) -> CRGBAVolume         makeRef(self, Volume) -> CRGBAVolume getSize(self) -> CSize3_int         getSize(self) -> CSize3_int getXSize(self) -> vpl::tSize getYSize(self) -> vpl::tSize getZSize(self) -> vpl::tSize width(self) -> vpl::tSize height(self) -> vpl::tSize depth(self) -> vpl::tSize getXOffset(self) -> vpl::tSize getYOffset(self) -> vpl::tSize getZOffset(self) -> vpl::tSize getMargin(self) -> vpl::tSize getIdx(self, x, y, z) -> vpl::tSize __call__(self, x, y, z) -> CRGBPixel         __call__(self, x, y, z) -> CRGBPixel         __call__(self, i) -> CRGBPixel         __call__(self, i) -> CRGBPixel at(self, x, y, z) -> CRGBPixel         at(self, i) -> CRGBPixel set(self, x, y, z, Value) -> CRGBAVolume         set(self, i, Value) -> CRGBAVolume getPtr(self) -> CRGBPixel         getPtr(self) -> CRGBPixel         getPtr(self, x, y, z) -> CRGBPixel         getPtr(self, x, y, z) -> CRGBPixel getRowPtr(self, y, z) -> CRGBPixel         getRowPtr(self, y, z) -> CRGBPixel rect(self, Position, Size) -> vpl::img::CVolume< vpl::img::CRGBPixel,vpl::base::CPartedData >::tRect         rect(self, Position, Size) -> vpl::img::CVolume< vpl::img::CRGBPixel,vpl::base::CPartedData >::tRect const         rect(self, XRange, YRange, ZRange) -> vpl::img::CVolume< vpl::img::CRGBPixel,vpl::base::CPartedData >::tRect         rect(self, XRange, YRange, ZRange) -> vpl::img::CVolume< vpl::img::CRGBPixel,vpl::base::CPartedData >::tRect const row(self, y, z) -> vpl::img::CVolume< vpl::img::CRGBPixel,vpl::base::CPartedData >::tRow         row(self, y, z) -> vpl::img::CVolume< vpl::img::CRGBPixel,vpl::base::CPartedData >::tRow const fill(self, c) -> CRGBAVolume fillEntire(self, c) -> CRGBAVolume fillMargin(self, c) -> CRGBAVolume mirrorMargin(self) -> CRGBAVolume replace(self, Value, NewValue) -> CRGBAVolume abs(self) -> CRGBAVolume limit(self, Lower, Upper) -> CRGBAVolume cut(self, Lower, Upper) -> CRGBAVolume subSample(self, Volume, l=2, m=2, n=2) -> CRGBAVolume         subSample(self, Volume, l=2, m=2) -> CRGBAVolume         subSample(self, Volume, l=2) -> CRGBAVolume         subSample(self, Volume) -> CRGBAVolume interpolate(self, Point) -> CRGBPixel color2Voxel(self, Color) -> CRGBPixel checkPosition(self, x, y, z) -> bool getPlaneXY(self, z, Plane) -> bool getPlaneXZ(self, y, Plane) -> bool getPlaneYZ(self, x, Plane) -> bool setPlaneXY(self, z, Plane) -> bool setPlaneXZ(self, y, Plane) -> bool setPlaneYZ(self, x, Plane) -> bool enableDummyMode(self, Enable) -> CRGBAVolume isDummy(self) -> bool Proxy of C++ vpl::img::CVolume<(vpl::img::tComplexPixel,vpl::base::CPartedData)> class. __init__(self) -> CComplexVolume         __init__(self, XSize, YSize, ZSize, Margin=0) -> CComplexVolume         __init__(self, XSize, YSize, ZSize) -> CComplexVolume         __init__(self, Size, Margin=0) -> CComplexVolume         __init__(self, Size) -> CComplexVolume         __init__(self, Volume, x, y, z, XSize, YSize, ZSize) -> CComplexVolume         __init__(self, Volume, x, y, z, XSize, YSize, ZSize, arg9) -> CComplexVolume         __init__(self, Volume) -> CComplexVolume         __init__(self, Volume, arg3) -> CComplexVolume         __init__(self, Volume) -> CComplexVolume         __init__(self, Volume, arg3) -> CComplexVolume resize(self, XSize, YSize, ZSize, Margin=0) -> CComplexVolume         resize(self, XSize, YSize, ZSize) -> CComplexVolume         resize(self, Size, Margin=0) -> CComplexVolume         resize(self, Size) -> CComplexVolume copy(self, Volume, Margin=-1) -> CComplexVolume         copy(self, Volume) -> CComplexVolume         copy(self, Volume, x, y, z, XSize, YSize, ZSize, Margin=-1) -> CComplexVolume         copy(self, Volume, x, y, z, XSize, YSize, ZSize) -> CComplexVolume         copy(self, Volume, Margin=-1) -> CComplexVolume         copy(self, Volume) -> CComplexVolume makeRef(self, Volume) -> CComplexVolume         makeRef(self, Volume, x, y, z, XSize, YSize, ZSize) -> CComplexVolume         makeRef(self, Volume) -> CComplexVolume getSize(self) -> CSize3_int         getSize(self) -> CSize3_int getXSize(self) -> vpl::tSize getYSize(self) -> vpl::tSize getZSize(self) -> vpl::tSize width(self) -> vpl::tSize height(self) -> vpl::tSize depth(self) -> vpl::tSize getXOffset(self) -> vpl::tSize getYOffset(self) -> vpl::tSize getZOffset(self) -> vpl::tSize getMargin(self) -> vpl::tSize getIdx(self, x, y, z) -> vpl::tSize __call__(self, x, y, z) -> vpl::math::CComplex< float >         __call__(self, x, y, z) -> vpl::math::CComplex< float > const         __call__(self, i) -> vpl::math::CComplex< float >         __call__(self, i) -> vpl::math::CComplex< float > const & at(self, x, y, z) -> vpl::math::CComplex< float > const         at(self, i) -> vpl::math::CComplex< float > const & set(self, x, y, z, Value) -> CComplexVolume         set(self, i, Value) -> CComplexVolume getPtr(self) -> vpl::math::CComplex< float >         getPtr(self) -> vpl::math::CComplex< float > const         getPtr(self, x, y, z) -> vpl::math::CComplex< float >         getPtr(self, x, y, z) -> vpl::math::CComplex< float > const * getRowPtr(self, y, z) -> vpl::math::CComplex< float >         getRowPtr(self, y, z) -> vpl::math::CComplex< float > const * rect(self, Position, Size) -> vpl::img::CVolume< vpl::math::CComplex< float >,vpl::base::CPartedData >::tRect         rect(self, Position, Size) -> vpl::img::CVolume< vpl::math::CComplex< float >,vpl::base::CPartedData >::tRect const         rect(self, XRange, YRange, ZRange) -> vpl::img::CVolume< vpl::math::CComplex< float >,vpl::base::CPartedData >::tRect         rect(self, XRange, YRange, ZRange) -> vpl::img::CVolume< vpl::math::CComplex< float >,vpl::base::CPartedData >::tRect const row(self, y, z) -> vpl::img::CVolume< vpl::math::CComplex< float >,vpl::base::CPartedData >::tRow         row(self, y, z) -> vpl::img::CVolume< vpl::math::CComplex< float >,vpl::base::CPartedData >::tRow const fill(self, c) -> CComplexVolume fillEntire(self, c) -> CComplexVolume fillMargin(self, c) -> CComplexVolume mirrorMargin(self) -> CComplexVolume replace(self, Value, NewValue) -> CComplexVolume abs(self) -> CComplexVolume limit(self, Lower, Upper) -> CComplexVolume cut(self, Lower, Upper) -> CComplexVolume subSample(self, Volume, l=2, m=2, n=2) -> CComplexVolume         subSample(self, Volume, l=2, m=2) -> CComplexVolume         subSample(self, Volume, l=2) -> CComplexVolume         subSample(self, Volume) -> CComplexVolume interpolate(self, Point) -> vpl::math::CComplex< float > color2Voxel(self, Color) -> vpl::math::CComplex< float > checkPosition(self, x, y, z) -> bool getPlaneXY(self, z, Plane) -> bool getPlaneXZ(self, y, Plane) -> bool getPlaneYZ(self, x, Plane) -> bool setPlaneXY(self, z, Plane) -> bool setPlaneXZ(self, y, Plane) -> bool setPlaneYZ(self, x, Plane) -> bool enableDummyMode(self, Enable) -> CComplexVolume isDummy(self) -> bool Proxy of C++ vpl::img::CDensityVolume class. getName() -> char const * getCompression() -> int __init__(self) -> CDensityVolume         __init__(self, XSize, YSize, ZSize, Margin) -> CDensityVolume         __init__(self, XSize, YSize, ZSize) -> CDensityVolume         __init__(self, Volume) -> CDensityVolume         __init__(self, Volume, arg3) -> CDensityVolume         __init__(self, Volume) -> CDensityVolume         __init__(self, Volume, arg3) -> CDensityVolume resize(self, XSize, YSize, ZSize, Margin) -> CDensityVolume         resize(self, XSize, YSize, ZSize) -> CDensityVolume         resize(self, Size, Margin) -> CDensityVolume         resize(self, Size) -> CDensityVolume copy(self, Volume, Margin=-1) -> CDensityVolume         copy(self, Volume) -> CDensityVolume         copy(self, Volume, Margin=-1) -> CDensityVolume         copy(self, Volume) -> CDensityVolume makeRef(self, Volume) -> CDensityVolume         makeRef(self, Volume) -> CDensityVolume copyProps(self, Volume) -> CDensityVolume getDX(self) -> double getDY(self) -> double getDZ(self) -> double setDX(self, dValue) -> CDensityVolume setDY(self, dValue) -> CDensityVolume setDZ(self, dValue) -> CDensityVolume setVoxel(self, dDX, dDY, dDZ) -> CDensityVolume makeVolume(self, Slices, BorderValue) -> bool         makeVolume(self, Slices) -> bool getSliceXY(self, z, Plane) -> bool         getSliceXY(self, dZ, Plane) -> bool getSliceXZ(self, y, Plane) -> bool         getSliceXZ(self, dY, Plane) -> bool getSliceYZ(self, x, Plane) -> bool         getSliceYZ(self, dX, Plane) -> bool getSlice(self, dPosition, Plane) -> bool initSlice(self, Slice, eOrientation) CDensityVolume_getName() -> char const * CDensityVolume_getCompression() -> int Proxy of C++ vpl::base::CSharedPtr<(vpl::img::CDensityVolume)> class. __init__(self) -> sp_densityVolume         __init__(self, p) -> sp_densityVolume         __init__(self, p) -> sp_densityVolume __deref__(self) -> CDensityVolume __ref__(self) -> CDensityVolume get(self) -> CDensityVolume         get(self) -> CDensityVolume release(self) -> CDensityVolume getName(self) -> char const * getCompression(self) -> int resize(self, XSize, YSize, ZSize, Margin) -> CDensityVolume         resize(self, XSize, YSize, ZSize) -> CDensityVolume         resize(self, Size, Margin) -> CDensityVolume         resize(self, Size) -> CDensityVolume copy(self, Volume, Margin=-1) -> CDensityVolume         copy(self, Volume) -> CDensityVolume         copy(self, Volume, Margin=-1) -> CDensityVolume         copy(self, Volume) -> CDensityVolume makeRef(self, Volume) -> CDensityVolume         makeRef(self, Volume) -> CDensityVolume copyProps(self, Volume) -> CDensityVolume getDX(self) -> double getDY(self) -> double getDZ(self) -> double setDX(self, dValue) -> CDensityVolume setDY(self, dValue) -> CDensityVolume setDZ(self, dValue) -> CDensityVolume setVoxel(self, dDX, dDY, dDZ) -> CDensityVolume makeVolume(self, Slices, BorderValue) -> bool         makeVolume(self, Slices) -> bool getSliceXY(self, z, Plane) -> bool         getSliceXY(self, dZ, Plane) -> bool getSliceXZ(self, y, Plane) -> bool         getSliceXZ(self, dY, Plane) -> bool getSliceYZ(self, x, Plane) -> bool         getSliceYZ(self, dX, Plane) -> bool getSlice(self, dPosition, Plane) -> bool initSlice(self, Slice, eOrientation) getSize(self) -> CSize3_int         getSize(self) -> CSize3_int getXSize(self) -> vpl::tSize getYSize(self) -> vpl::tSize getZSize(self) -> vpl::tSize width(self) -> vpl::tSize height(self) -> vpl::tSize depth(self) -> vpl::tSize getXOffset(self) -> vpl::tSize getYOffset(self) -> vpl::tSize getZOffset(self) -> vpl::tSize getMargin(self) -> vpl::tSize __call__(self, x, y, z) -> __int16         __call__(self, x, y, z) -> __int16 const         __call__(self, i) -> __int16         __call__(self, i) -> __int16 const & at(self, x, y, z) -> __int16 const         at(self, i) -> __int16 const & set(self, x, y, z, Value) -> CDVolume         set(self, i, Value) -> CDVolume getIdx(self, x, y, z) -> vpl::tSize getPtr(self) -> __int16         getPtr(self) -> __int16 const         getPtr(self, x, y, z) -> __int16         getPtr(self, x, y, z) -> __int16 const * getRowPtr(self, y, z) -> __int16         getRowPtr(self, y, z) -> __int16 const * rect(self, Position, Size) -> vpl::img::CVolume< __int16,vpl::base::CPartedData >::tRect         rect(self, Position, Size) -> vpl::img::CVolume< __int16,vpl::base::CPartedData >::tRect const         rect(self, XRange, YRange, ZRange) -> vpl::img::CVolume< __int16,vpl::base::CPartedData >::tRect         rect(self, XRange, YRange, ZRange) -> vpl::img::CVolume< __int16,vpl::base::CPartedData >::tRect const row(self, y, z) -> vpl::img::CVolume< __int16,vpl::base::CPartedData >::tRow         row(self, y, z) -> vpl::img::CVolume< __int16,vpl::base::CPartedData >::tRow const fill(self, c) -> CDVolume fillEntire(self, c) -> CDVolume fillMargin(self, c) -> CDVolume mirrorMargin(self) -> CDVolume replace(self, Value, NewValue) -> CDVolume abs(self) -> CDVolume limit(self, Lower, Upper) -> CDVolume cut(self, Lower, Upper) -> CDVolume subSample(self, Volume, l=2, m=2, n=2) -> CDVolume         subSample(self, Volume, l=2, m=2) -> CDVolume         subSample(self, Volume, l=2) -> CDVolume         subSample(self, Volume) -> CDVolume interpolate(self, Point) -> __int16 color2Voxel(self, Color) -> __int16 checkPosition(self, x, y, z) -> bool getPlaneXY(self, z, Plane) -> bool getPlaneXZ(self, y, Plane) -> bool getPlaneYZ(self, x, Plane) -> bool setPlaneXY(self, z, Plane) -> bool setPlaneXZ(self, y, Plane) -> bool setPlaneYZ(self, x, Plane) -> bool enableDummyMode(self, Enable) -> CDVolume isDummy(self) -> bool getReferencesCount(self) -> int isOnHeap(self) -> bool getImpl(self) -> CDVolume         getImpl(self) -> CDVolume getBlockSize(self) -> int # This file is compatible with both classic and new-style classes.