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


import collections

from sys import version_info as _version_info
if _version_info < (3, 7, 0):
    raise RuntimeError("Python 3.7 or later required")

from . import _ITKCommonPython


from . import _ITKCommonPython



from sys import version_info as _swig_python_version_info
# Import the low-level C/C++ module
if __package__ or "." in __name__:
    from . import _ITKCommonBasePython
else:
    import _ITKCommonBasePython

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

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


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


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


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


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


if _swig_python_version_info[0:2] >= (3, 3):
    import collections.abc
else:
    import collections

import itk.itkMatrixPython
import itk.itkVectorPython
import itk.vnl_vectorPython
import itk.stdcomplexPython
import itk.pyBasePython
import itk.vnl_matrixPython
import itk.vnl_vector_refPython
import itk.itkFixedArrayPython
import itk.itkCovariantVectorPython
import itk.vnl_matrix_fixedPython
import itk.itkPointPython
class listitkLightObject(collections.abc.MutableSequence if _swig_python_version_info >= (3, 3) else collections.MutableSequence):
    r"""Proxy of C++ std::list< itkLightObject_Pointer > class."""

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

    def iterator(self):
        r"""iterator(self) -> SwigPyIterator"""
        return _ITKCommonBasePython.listitkLightObject_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(self) -> bool"""
        return _ITKCommonBasePython.listitkLightObject___nonzero__(self)

    def __bool__(self):
        r"""__bool__(self) -> bool"""
        return _ITKCommonBasePython.listitkLightObject___bool__(self)

    def __len__(self):
        r"""__len__(self) -> std::list< itkLightObject_Pointer >::size_type"""
        return _ITKCommonBasePython.listitkLightObject___len__(self)

    def __getslice__(self, i, j):
        r"""
        __getslice__(self, i, j) -> listitkLightObject

        Parameters
        ----------
        i: std::list< itkLightObject_Pointer >::difference_type
        j: std::list< itkLightObject_Pointer >::difference_type

        """
        return _ITKCommonBasePython.listitkLightObject___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(self, i, j)

        Parameters
        ----------
        i: std::list< itkLightObject_Pointer >::difference_type
        j: std::list< itkLightObject_Pointer >::difference_type

        __setslice__(self, i, j, v)

        Parameters
        ----------
        i: std::list< itkLightObject_Pointer >::difference_type
        j: std::list< itkLightObject_Pointer >::difference_type
        v: std::list< itkLightObject_Pointer,std::allocator< itkLightObject_Pointer > > const &

        """
        return _ITKCommonBasePython.listitkLightObject___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""
        __delslice__(self, i, j)

        Parameters
        ----------
        i: std::list< itkLightObject_Pointer >::difference_type
        j: std::list< itkLightObject_Pointer >::difference_type

        """
        return _ITKCommonBasePython.listitkLightObject___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(self, i)

        Parameters
        ----------
        i: std::list< itkLightObject_Pointer >::difference_type

        __delitem__(self, slice)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        """
        return _ITKCommonBasePython.listitkLightObject___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(self, slice) -> listitkLightObject

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        __getitem__(self, i) -> std::list< itkLightObject_Pointer >::value_type const &

        Parameters
        ----------
        i: std::list< itkLightObject_Pointer >::difference_type

        """
        return _ITKCommonBasePython.listitkLightObject___getitem__(self, *args)

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

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *
        v: std::list< itkLightObject_Pointer,std::allocator< itkLightObject_Pointer > > const &

        __setitem__(self, slice)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        __setitem__(self, i, x)

        Parameters
        ----------
        i: std::list< itkLightObject_Pointer >::difference_type
        x: std::list< itkLightObject_Pointer >::value_type const &

        """
        return _ITKCommonBasePython.listitkLightObject___setitem__(self, *args)

    def pop(self):
        r"""pop(self) -> std::list< itkLightObject_Pointer >::value_type"""
        return _ITKCommonBasePython.listitkLightObject_pop(self)

    def append(self, x):
        r"""
        append(self, x)

        Parameters
        ----------
        x: std::list< itkLightObject_Pointer >::value_type const &

        """
        return _ITKCommonBasePython.listitkLightObject_append(self, x)

    def empty(self):
        r"""empty(self) -> bool"""
        return _ITKCommonBasePython.listitkLightObject_empty(self)

    def size(self):
        r"""size(self) -> std::list< itkLightObject_Pointer >::size_type"""
        return _ITKCommonBasePython.listitkLightObject_size(self)

    def swap(self, v):
        r"""
        swap(self, v)

        Parameters
        ----------
        v: std::list< itkLightObject_Pointer > &

        """
        return _ITKCommonBasePython.listitkLightObject_swap(self, v)

    def begin(self):
        r"""begin(self) -> std::list< itkLightObject_Pointer >::iterator"""
        return _ITKCommonBasePython.listitkLightObject_begin(self)

    def end(self):
        r"""end(self) -> std::list< itkLightObject_Pointer >::iterator"""
        return _ITKCommonBasePython.listitkLightObject_end(self)

    def rbegin(self):
        r"""rbegin(self) -> std::list< itkLightObject_Pointer >::reverse_iterator"""
        return _ITKCommonBasePython.listitkLightObject_rbegin(self)

    def rend(self):
        r"""rend(self) -> std::list< itkLightObject_Pointer >::reverse_iterator"""
        return _ITKCommonBasePython.listitkLightObject_rend(self)

    def clear(self):
        r"""clear(self)"""
        return _ITKCommonBasePython.listitkLightObject_clear(self)

    def get_allocator(self):
        r"""get_allocator(self) -> std::list< itkLightObject_Pointer >::allocator_type"""
        return _ITKCommonBasePython.listitkLightObject_get_allocator(self)

    def pop_back(self):
        r"""pop_back(self)"""
        return _ITKCommonBasePython.listitkLightObject_pop_back(self)

    def erase(self, *args):
        r"""
        erase(self, pos) -> std::list< itkLightObject_Pointer >::iterator

        Parameters
        ----------
        pos: std::list< itkLightObject_Pointer >::iterator

        erase(self, first, last) -> std::list< itkLightObject_Pointer >::iterator

        Parameters
        ----------
        first: std::list< itkLightObject_Pointer >::iterator
        last: std::list< itkLightObject_Pointer >::iterator

        """
        return _ITKCommonBasePython.listitkLightObject_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(self) -> listitkLightObject
        __init__(self, other) -> listitkLightObject

        Parameters
        ----------
        other: std::list< itkLightObject_Pointer > const &

        __init__(self, size) -> listitkLightObject

        Parameters
        ----------
        size: std::list< itkLightObject_Pointer >::size_type

        __init__(self, size, value) -> listitkLightObject

        Parameters
        ----------
        size: std::list< itkLightObject_Pointer >::size_type
        value: std::list< itkLightObject_Pointer >::value_type const &

        """
        _ITKCommonBasePython.listitkLightObject_swiginit(self, _ITKCommonBasePython.new_listitkLightObject(*args))

    def push_back(self, x):
        r"""
        push_back(self, x)

        Parameters
        ----------
        x: std::list< itkLightObject_Pointer >::value_type const &

        """
        return _ITKCommonBasePython.listitkLightObject_push_back(self, x)

    def front(self):
        r"""front(self) -> std::list< itkLightObject_Pointer >::value_type const &"""
        return _ITKCommonBasePython.listitkLightObject_front(self)

    def back(self):
        r"""back(self) -> std::list< itkLightObject_Pointer >::value_type const &"""
        return _ITKCommonBasePython.listitkLightObject_back(self)

    def assign(self, n, x):
        r"""
        assign(self, n, x)

        Parameters
        ----------
        n: std::list< itkLightObject_Pointer >::size_type
        x: std::list< itkLightObject_Pointer >::value_type const &

        """
        return _ITKCommonBasePython.listitkLightObject_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(self, new_size)

        Parameters
        ----------
        new_size: std::list< itkLightObject_Pointer >::size_type

        resize(self, new_size, x)

        Parameters
        ----------
        new_size: std::list< itkLightObject_Pointer >::size_type
        x: std::list< itkLightObject_Pointer >::value_type const &

        """
        return _ITKCommonBasePython.listitkLightObject_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(self, pos, x) -> std::list< itkLightObject_Pointer >::iterator

        Parameters
        ----------
        pos: std::list< itkLightObject_Pointer >::iterator
        x: std::list< itkLightObject_Pointer >::value_type const &

        insert(self, pos, n, x)

        Parameters
        ----------
        pos: std::list< itkLightObject_Pointer >::iterator
        n: std::list< itkLightObject_Pointer >::size_type
        x: std::list< itkLightObject_Pointer >::value_type const &

        """
        return _ITKCommonBasePython.listitkLightObject_insert(self, *args)

    def pop_front(self):
        r"""pop_front(self)"""
        return _ITKCommonBasePython.listitkLightObject_pop_front(self)

    def push_front(self, x):
        r"""
        push_front(self, x)

        Parameters
        ----------
        x: std::list< itkLightObject_Pointer >::value_type const &

        """
        return _ITKCommonBasePython.listitkLightObject_push_front(self, x)

    def reverse(self):
        r"""reverse(self)"""
        return _ITKCommonBasePython.listitkLightObject_reverse(self)
    __swig_destroy__ = _ITKCommonBasePython.delete_listitkLightObject

# Register listitkLightObject in _ITKCommonBasePython:
_ITKCommonBasePython.listitkLightObject_swigregister(listitkLightObject)
class vectoritkDataObject(collections.abc.MutableSequence if _swig_python_version_info >= (3, 3) else collections.MutableSequence):
    r"""Proxy of C++ std::vector< itkDataObject_Pointer > class."""

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

    def iterator(self):
        r"""iterator(self) -> SwigPyIterator"""
        return _ITKCommonBasePython.vectoritkDataObject_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(self) -> bool"""
        return _ITKCommonBasePython.vectoritkDataObject___nonzero__(self)

    def __bool__(self):
        r"""__bool__(self) -> bool"""
        return _ITKCommonBasePython.vectoritkDataObject___bool__(self)

    def __len__(self):
        r"""__len__(self) -> std::vector< itkDataObject_Pointer >::size_type"""
        return _ITKCommonBasePython.vectoritkDataObject___len__(self)

    def __getslice__(self, i, j):
        r"""
        __getslice__(self, i, j) -> vectoritkDataObject

        Parameters
        ----------
        i: std::vector< itkDataObject_Pointer >::difference_type
        j: std::vector< itkDataObject_Pointer >::difference_type

        """
        return _ITKCommonBasePython.vectoritkDataObject___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(self, i, j)

        Parameters
        ----------
        i: std::vector< itkDataObject_Pointer >::difference_type
        j: std::vector< itkDataObject_Pointer >::difference_type

        __setslice__(self, i, j, v)

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

        """
        return _ITKCommonBasePython.vectoritkDataObject___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""
        __delslice__(self, i, j)

        Parameters
        ----------
        i: std::vector< itkDataObject_Pointer >::difference_type
        j: std::vector< itkDataObject_Pointer >::difference_type

        """
        return _ITKCommonBasePython.vectoritkDataObject___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(self, i)

        Parameters
        ----------
        i: std::vector< itkDataObject_Pointer >::difference_type

        __delitem__(self, slice)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        """
        return _ITKCommonBasePython.vectoritkDataObject___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(self, slice) -> vectoritkDataObject

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        __getitem__(self, i) -> std::vector< itkDataObject_Pointer >::value_type const &

        Parameters
        ----------
        i: std::vector< itkDataObject_Pointer >::difference_type

        """
        return _ITKCommonBasePython.vectoritkDataObject___getitem__(self, *args)

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

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *
        v: std::vector< itkDataObject_Pointer,std::allocator< itkDataObject_Pointer > > const &

        __setitem__(self, slice)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        __setitem__(self, i, x)

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

        """
        return _ITKCommonBasePython.vectoritkDataObject___setitem__(self, *args)

    def pop(self):
        r"""pop(self) -> std::vector< itkDataObject_Pointer >::value_type"""
        return _ITKCommonBasePython.vectoritkDataObject_pop(self)

    def append(self, x):
        r"""
        append(self, x)

        Parameters
        ----------
        x: std::vector< itkDataObject_Pointer >::value_type const &

        """
        return _ITKCommonBasePython.vectoritkDataObject_append(self, x)

    def empty(self):
        r"""empty(self) -> bool"""
        return _ITKCommonBasePython.vectoritkDataObject_empty(self)

    def size(self):
        r"""size(self) -> std::vector< itkDataObject_Pointer >::size_type"""
        return _ITKCommonBasePython.vectoritkDataObject_size(self)

    def swap(self, v):
        r"""
        swap(self, v)

        Parameters
        ----------
        v: std::vector< itkDataObject_Pointer > &

        """
        return _ITKCommonBasePython.vectoritkDataObject_swap(self, v)

    def begin(self):
        r"""begin(self) -> std::vector< itkDataObject_Pointer >::iterator"""
        return _ITKCommonBasePython.vectoritkDataObject_begin(self)

    def end(self):
        r"""end(self) -> std::vector< itkDataObject_Pointer >::iterator"""
        return _ITKCommonBasePython.vectoritkDataObject_end(self)

    def rbegin(self):
        r"""rbegin(self) -> std::vector< itkDataObject_Pointer >::reverse_iterator"""
        return _ITKCommonBasePython.vectoritkDataObject_rbegin(self)

    def rend(self):
        r"""rend(self) -> std::vector< itkDataObject_Pointer >::reverse_iterator"""
        return _ITKCommonBasePython.vectoritkDataObject_rend(self)

    def clear(self):
        r"""clear(self)"""
        return _ITKCommonBasePython.vectoritkDataObject_clear(self)

    def get_allocator(self):
        r"""get_allocator(self) -> std::vector< itkDataObject_Pointer >::allocator_type"""
        return _ITKCommonBasePython.vectoritkDataObject_get_allocator(self)

    def pop_back(self):
        r"""pop_back(self)"""
        return _ITKCommonBasePython.vectoritkDataObject_pop_back(self)

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

        Parameters
        ----------
        pos: std::vector< itkDataObject_Pointer >::iterator

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

        Parameters
        ----------
        first: std::vector< itkDataObject_Pointer >::iterator
        last: std::vector< itkDataObject_Pointer >::iterator

        """
        return _ITKCommonBasePython.vectoritkDataObject_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(self) -> vectoritkDataObject
        __init__(self, other) -> vectoritkDataObject

        Parameters
        ----------
        other: std::vector< itkDataObject_Pointer > const &

        __init__(self, size) -> vectoritkDataObject

        Parameters
        ----------
        size: std::vector< itkDataObject_Pointer >::size_type

        __init__(self, size, value) -> vectoritkDataObject

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

        """
        _ITKCommonBasePython.vectoritkDataObject_swiginit(self, _ITKCommonBasePython.new_vectoritkDataObject(*args))

    def push_back(self, x):
        r"""
        push_back(self, x)

        Parameters
        ----------
        x: std::vector< itkDataObject_Pointer >::value_type const &

        """
        return _ITKCommonBasePython.vectoritkDataObject_push_back(self, x)

    def front(self):
        r"""front(self) -> std::vector< itkDataObject_Pointer >::value_type const &"""
        return _ITKCommonBasePython.vectoritkDataObject_front(self)

    def back(self):
        r"""back(self) -> std::vector< itkDataObject_Pointer >::value_type const &"""
        return _ITKCommonBasePython.vectoritkDataObject_back(self)

    def assign(self, n, x):
        r"""
        assign(self, n, x)

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

        """
        return _ITKCommonBasePython.vectoritkDataObject_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(self, new_size)

        Parameters
        ----------
        new_size: std::vector< itkDataObject_Pointer >::size_type

        resize(self, new_size, x)

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

        """
        return _ITKCommonBasePython.vectoritkDataObject_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(self, pos, x) -> std::vector< itkDataObject_Pointer >::iterator

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

        insert(self, pos, n, x)

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

        """
        return _ITKCommonBasePython.vectoritkDataObject_insert(self, *args)

    def reserve(self, n):
        r"""
        reserve(self, n)

        Parameters
        ----------
        n: std::vector< itkDataObject_Pointer >::size_type

        """
        return _ITKCommonBasePython.vectoritkDataObject_reserve(self, n)

    def capacity(self):
        r"""capacity(self) -> std::vector< itkDataObject_Pointer >::size_type"""
        return _ITKCommonBasePython.vectoritkDataObject_capacity(self)
    __swig_destroy__ = _ITKCommonBasePython.delete_vectoritkDataObject

# Register vectoritkDataObject in _ITKCommonBasePython:
_ITKCommonBasePython.vectoritkDataObject_swigregister(vectoritkDataObject)
class listitkObjectFactoryBase(object):
    r"""Proxy of C++ std::list< itkObjectFactoryBase * > class."""

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

    def iterator(self):
        r"""iterator(self) -> SwigPyIterator"""
        return _ITKCommonBasePython.listitkObjectFactoryBase_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(self) -> bool"""
        return _ITKCommonBasePython.listitkObjectFactoryBase___nonzero__(self)

    def __bool__(self):
        r"""__bool__(self) -> bool"""
        return _ITKCommonBasePython.listitkObjectFactoryBase___bool__(self)

    def __len__(self):
        r"""__len__(self) -> std::list< itkObjectFactoryBase * >::size_type"""
        return _ITKCommonBasePython.listitkObjectFactoryBase___len__(self)

    def __getslice__(self, i, j):
        r"""
        __getslice__(self, i, j) -> listitkObjectFactoryBase

        Parameters
        ----------
        i: std::list< itkObjectFactoryBase * >::difference_type
        j: std::list< itkObjectFactoryBase * >::difference_type

        """
        return _ITKCommonBasePython.listitkObjectFactoryBase___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(self, i, j)

        Parameters
        ----------
        i: std::list< itkObjectFactoryBase * >::difference_type
        j: std::list< itkObjectFactoryBase * >::difference_type

        __setslice__(self, i, j, v)

        Parameters
        ----------
        i: std::list< itkObjectFactoryBase * >::difference_type
        j: std::list< itkObjectFactoryBase * >::difference_type
        v: std::list< itkObjectFactoryBase *,std::allocator< itkObjectFactoryBase * > > const &

        """
        return _ITKCommonBasePython.listitkObjectFactoryBase___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""
        __delslice__(self, i, j)

        Parameters
        ----------
        i: std::list< itkObjectFactoryBase * >::difference_type
        j: std::list< itkObjectFactoryBase * >::difference_type

        """
        return _ITKCommonBasePython.listitkObjectFactoryBase___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(self, i)

        Parameters
        ----------
        i: std::list< itkObjectFactoryBase * >::difference_type

        __delitem__(self, slice)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        """
        return _ITKCommonBasePython.listitkObjectFactoryBase___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(self, slice) -> listitkObjectFactoryBase

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        __getitem__(self, i) -> itkObjectFactoryBase

        Parameters
        ----------
        i: std::list< itkObjectFactoryBase * >::difference_type

        """
        return _ITKCommonBasePython.listitkObjectFactoryBase___getitem__(self, *args)

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

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *
        v: std::list< itkObjectFactoryBase *,std::allocator< itkObjectFactoryBase * > > const &

        __setitem__(self, slice)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        __setitem__(self, i, x)

        Parameters
        ----------
        i: std::list< itkObjectFactoryBase * >::difference_type
        x: std::list< itkObjectFactoryBase * >::value_type

        """
        return _ITKCommonBasePython.listitkObjectFactoryBase___setitem__(self, *args)

    def pop(self):
        r"""pop(self) -> itkObjectFactoryBase"""
        return _ITKCommonBasePython.listitkObjectFactoryBase_pop(self)

    def append(self, x):
        r"""
        append(self, x)

        Parameters
        ----------
        x: std::list< itkObjectFactoryBase * >::value_type

        """
        return _ITKCommonBasePython.listitkObjectFactoryBase_append(self, x)

    def empty(self):
        r"""empty(self) -> bool"""
        return _ITKCommonBasePython.listitkObjectFactoryBase_empty(self)

    def size(self):
        r"""size(self) -> std::list< itkObjectFactoryBase * >::size_type"""
        return _ITKCommonBasePython.listitkObjectFactoryBase_size(self)

    def swap(self, v):
        r"""
        swap(self, v)

        Parameters
        ----------
        v: std::list< itkObjectFactoryBase * > &

        """
        return _ITKCommonBasePython.listitkObjectFactoryBase_swap(self, v)

    def begin(self):
        r"""begin(self) -> std::list< itkObjectFactoryBase * >::iterator"""
        return _ITKCommonBasePython.listitkObjectFactoryBase_begin(self)

    def end(self):
        r"""end(self) -> std::list< itkObjectFactoryBase * >::iterator"""
        return _ITKCommonBasePython.listitkObjectFactoryBase_end(self)

    def rbegin(self):
        r"""rbegin(self) -> std::list< itkObjectFactoryBase * >::reverse_iterator"""
        return _ITKCommonBasePython.listitkObjectFactoryBase_rbegin(self)

    def rend(self):
        r"""rend(self) -> std::list< itkObjectFactoryBase * >::reverse_iterator"""
        return _ITKCommonBasePython.listitkObjectFactoryBase_rend(self)

    def clear(self):
        r"""clear(self)"""
        return _ITKCommonBasePython.listitkObjectFactoryBase_clear(self)

    def get_allocator(self):
        r"""get_allocator(self) -> std::list< itkObjectFactoryBase * >::allocator_type"""
        return _ITKCommonBasePython.listitkObjectFactoryBase_get_allocator(self)

    def pop_back(self):
        r"""pop_back(self)"""
        return _ITKCommonBasePython.listitkObjectFactoryBase_pop_back(self)

    def erase(self, *args):
        r"""
        erase(self, pos) -> std::list< itkObjectFactoryBase * >::iterator

        Parameters
        ----------
        pos: std::list< itkObjectFactoryBase * >::iterator

        erase(self, first, last) -> std::list< itkObjectFactoryBase * >::iterator

        Parameters
        ----------
        first: std::list< itkObjectFactoryBase * >::iterator
        last: std::list< itkObjectFactoryBase * >::iterator

        """
        return _ITKCommonBasePython.listitkObjectFactoryBase_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(self) -> listitkObjectFactoryBase
        __init__(self, other) -> listitkObjectFactoryBase

        Parameters
        ----------
        other: std::list< itkObjectFactoryBase * > const &

        __init__(self, size) -> listitkObjectFactoryBase

        Parameters
        ----------
        size: std::list< itkObjectFactoryBase * >::size_type

        __init__(self, size, value) -> listitkObjectFactoryBase

        Parameters
        ----------
        size: std::list< itkObjectFactoryBase * >::size_type
        value: std::list< itkObjectFactoryBase * >::value_type

        """
        _ITKCommonBasePython.listitkObjectFactoryBase_swiginit(self, _ITKCommonBasePython.new_listitkObjectFactoryBase(*args))

    def push_back(self, x):
        r"""
        push_back(self, x)

        Parameters
        ----------
        x: std::list< itkObjectFactoryBase * >::value_type

        """
        return _ITKCommonBasePython.listitkObjectFactoryBase_push_back(self, x)

    def front(self):
        r"""front(self) -> itkObjectFactoryBase"""
        return _ITKCommonBasePython.listitkObjectFactoryBase_front(self)

    def back(self):
        r"""back(self) -> itkObjectFactoryBase"""
        return _ITKCommonBasePython.listitkObjectFactoryBase_back(self)

    def assign(self, n, x):
        r"""
        assign(self, n, x)

        Parameters
        ----------
        n: std::list< itkObjectFactoryBase * >::size_type
        x: std::list< itkObjectFactoryBase * >::value_type

        """
        return _ITKCommonBasePython.listitkObjectFactoryBase_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(self, new_size)

        Parameters
        ----------
        new_size: std::list< itkObjectFactoryBase * >::size_type

        resize(self, new_size, x)

        Parameters
        ----------
        new_size: std::list< itkObjectFactoryBase * >::size_type
        x: std::list< itkObjectFactoryBase * >::value_type

        """
        return _ITKCommonBasePython.listitkObjectFactoryBase_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(self, pos, x) -> std::list< itkObjectFactoryBase * >::iterator

        Parameters
        ----------
        pos: std::list< itkObjectFactoryBase * >::iterator
        x: std::list< itkObjectFactoryBase * >::value_type

        insert(self, pos, n, x)

        Parameters
        ----------
        pos: std::list< itkObjectFactoryBase * >::iterator
        n: std::list< itkObjectFactoryBase * >::size_type
        x: std::list< itkObjectFactoryBase * >::value_type

        """
        return _ITKCommonBasePython.listitkObjectFactoryBase_insert(self, *args)

    def pop_front(self):
        r"""pop_front(self)"""
        return _ITKCommonBasePython.listitkObjectFactoryBase_pop_front(self)

    def push_front(self, x):
        r"""
        push_front(self, x)

        Parameters
        ----------
        x: std::list< itkObjectFactoryBase * >::value_type

        """
        return _ITKCommonBasePython.listitkObjectFactoryBase_push_front(self, x)

    def remove(self, x):
        r"""
        remove(self, x)

        Parameters
        ----------
        x: std::list< itkObjectFactoryBase * >::value_type

        """
        return _ITKCommonBasePython.listitkObjectFactoryBase_remove(self, x)

    def unique(self):
        r"""unique(self)"""
        return _ITKCommonBasePython.listitkObjectFactoryBase_unique(self)

    def reverse(self):
        r"""reverse(self)"""
        return _ITKCommonBasePython.listitkObjectFactoryBase_reverse(self)

    def sort(self):
        r"""sort(self)"""
        return _ITKCommonBasePython.listitkObjectFactoryBase_sort(self)

    def merge(self, x):
        r"""
        merge(self, x)

        Parameters
        ----------
        x: std::list< itkObjectFactoryBase * > &

        """
        return _ITKCommonBasePython.listitkObjectFactoryBase_merge(self, x)
    __swig_destroy__ = _ITKCommonBasePython.delete_listitkObjectFactoryBase

# Register listitkObjectFactoryBase in _ITKCommonBasePython:
_ITKCommonBasePython.listitkObjectFactoryBase_swigregister(listitkObjectFactoryBase)
class vectoritkMetaDataDictionary(object):
    r"""Proxy of C++ std::vector< itkMetaDataDictionary * > class."""

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

    def iterator(self):
        r"""iterator(self) -> SwigPyIterator"""
        return _ITKCommonBasePython.vectoritkMetaDataDictionary_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(self) -> bool"""
        return _ITKCommonBasePython.vectoritkMetaDataDictionary___nonzero__(self)

    def __bool__(self):
        r"""__bool__(self) -> bool"""
        return _ITKCommonBasePython.vectoritkMetaDataDictionary___bool__(self)

    def __len__(self):
        r"""__len__(self) -> std::vector< itkMetaDataDictionary * >::size_type"""
        return _ITKCommonBasePython.vectoritkMetaDataDictionary___len__(self)

    def __getslice__(self, i, j):
        r"""
        __getslice__(self, i, j) -> vectoritkMetaDataDictionary

        Parameters
        ----------
        i: std::vector< itkMetaDataDictionary * >::difference_type
        j: std::vector< itkMetaDataDictionary * >::difference_type

        """
        return _ITKCommonBasePython.vectoritkMetaDataDictionary___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(self, i, j)

        Parameters
        ----------
        i: std::vector< itkMetaDataDictionary * >::difference_type
        j: std::vector< itkMetaDataDictionary * >::difference_type

        __setslice__(self, i, j, v)

        Parameters
        ----------
        i: std::vector< itkMetaDataDictionary * >::difference_type
        j: std::vector< itkMetaDataDictionary * >::difference_type
        v: std::vector< itkMetaDataDictionary *,std::allocator< itkMetaDataDictionary * > > const &

        """
        return _ITKCommonBasePython.vectoritkMetaDataDictionary___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""
        __delslice__(self, i, j)

        Parameters
        ----------
        i: std::vector< itkMetaDataDictionary * >::difference_type
        j: std::vector< itkMetaDataDictionary * >::difference_type

        """
        return _ITKCommonBasePython.vectoritkMetaDataDictionary___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(self, i)

        Parameters
        ----------
        i: std::vector< itkMetaDataDictionary * >::difference_type

        __delitem__(self, slice)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        """
        return _ITKCommonBasePython.vectoritkMetaDataDictionary___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(self, slice) -> vectoritkMetaDataDictionary

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        __getitem__(self, i) -> itkMetaDataDictionary

        Parameters
        ----------
        i: std::vector< itkMetaDataDictionary * >::difference_type

        """
        return _ITKCommonBasePython.vectoritkMetaDataDictionary___getitem__(self, *args)

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

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *
        v: std::vector< itkMetaDataDictionary *,std::allocator< itkMetaDataDictionary * > > const &

        __setitem__(self, slice)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        __setitem__(self, i, x)

        Parameters
        ----------
        i: std::vector< itkMetaDataDictionary * >::difference_type
        x: std::vector< itkMetaDataDictionary * >::value_type

        """
        return _ITKCommonBasePython.vectoritkMetaDataDictionary___setitem__(self, *args)

    def pop(self):
        r"""pop(self) -> itkMetaDataDictionary"""
        return _ITKCommonBasePython.vectoritkMetaDataDictionary_pop(self)

    def append(self, x):
        r"""
        append(self, x)

        Parameters
        ----------
        x: std::vector< itkMetaDataDictionary * >::value_type

        """
        return _ITKCommonBasePython.vectoritkMetaDataDictionary_append(self, x)

    def empty(self):
        r"""empty(self) -> bool"""
        return _ITKCommonBasePython.vectoritkMetaDataDictionary_empty(self)

    def size(self):
        r"""size(self) -> std::vector< itkMetaDataDictionary * >::size_type"""
        return _ITKCommonBasePython.vectoritkMetaDataDictionary_size(self)

    def swap(self, v):
        r"""
        swap(self, v)

        Parameters
        ----------
        v: std::vector< itkMetaDataDictionary * > &

        """
        return _ITKCommonBasePython.vectoritkMetaDataDictionary_swap(self, v)

    def begin(self):
        r"""begin(self) -> std::vector< itkMetaDataDictionary * >::iterator"""
        return _ITKCommonBasePython.vectoritkMetaDataDictionary_begin(self)

    def end(self):
        r"""end(self) -> std::vector< itkMetaDataDictionary * >::iterator"""
        return _ITKCommonBasePython.vectoritkMetaDataDictionary_end(self)

    def rbegin(self):
        r"""rbegin(self) -> std::vector< itkMetaDataDictionary * >::reverse_iterator"""
        return _ITKCommonBasePython.vectoritkMetaDataDictionary_rbegin(self)

    def rend(self):
        r"""rend(self) -> std::vector< itkMetaDataDictionary * >::reverse_iterator"""
        return _ITKCommonBasePython.vectoritkMetaDataDictionary_rend(self)

    def clear(self):
        r"""clear(self)"""
        return _ITKCommonBasePython.vectoritkMetaDataDictionary_clear(self)

    def get_allocator(self):
        r"""get_allocator(self) -> std::vector< itkMetaDataDictionary * >::allocator_type"""
        return _ITKCommonBasePython.vectoritkMetaDataDictionary_get_allocator(self)

    def pop_back(self):
        r"""pop_back(self)"""
        return _ITKCommonBasePython.vectoritkMetaDataDictionary_pop_back(self)

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

        Parameters
        ----------
        pos: std::vector< itkMetaDataDictionary * >::iterator

        erase(self, first, last) -> std::vector< itkMetaDataDictionary * >::iterator

        Parameters
        ----------
        first: std::vector< itkMetaDataDictionary * >::iterator
        last: std::vector< itkMetaDataDictionary * >::iterator

        """
        return _ITKCommonBasePython.vectoritkMetaDataDictionary_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(self) -> vectoritkMetaDataDictionary
        __init__(self, other) -> vectoritkMetaDataDictionary

        Parameters
        ----------
        other: std::vector< itkMetaDataDictionary * > const &

        __init__(self, size) -> vectoritkMetaDataDictionary

        Parameters
        ----------
        size: std::vector< itkMetaDataDictionary * >::size_type

        __init__(self, size, value) -> vectoritkMetaDataDictionary

        Parameters
        ----------
        size: std::vector< itkMetaDataDictionary * >::size_type
        value: std::vector< itkMetaDataDictionary * >::value_type

        """
        _ITKCommonBasePython.vectoritkMetaDataDictionary_swiginit(self, _ITKCommonBasePython.new_vectoritkMetaDataDictionary(*args))

    def push_back(self, x):
        r"""
        push_back(self, x)

        Parameters
        ----------
        x: std::vector< itkMetaDataDictionary * >::value_type

        """
        return _ITKCommonBasePython.vectoritkMetaDataDictionary_push_back(self, x)

    def front(self):
        r"""front(self) -> itkMetaDataDictionary"""
        return _ITKCommonBasePython.vectoritkMetaDataDictionary_front(self)

    def back(self):
        r"""back(self) -> itkMetaDataDictionary"""
        return _ITKCommonBasePython.vectoritkMetaDataDictionary_back(self)

    def assign(self, n, x):
        r"""
        assign(self, n, x)

        Parameters
        ----------
        n: std::vector< itkMetaDataDictionary * >::size_type
        x: std::vector< itkMetaDataDictionary * >::value_type

        """
        return _ITKCommonBasePython.vectoritkMetaDataDictionary_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(self, new_size)

        Parameters
        ----------
        new_size: std::vector< itkMetaDataDictionary * >::size_type

        resize(self, new_size, x)

        Parameters
        ----------
        new_size: std::vector< itkMetaDataDictionary * >::size_type
        x: std::vector< itkMetaDataDictionary * >::value_type

        """
        return _ITKCommonBasePython.vectoritkMetaDataDictionary_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(self, pos, x) -> std::vector< itkMetaDataDictionary * >::iterator

        Parameters
        ----------
        pos: std::vector< itkMetaDataDictionary * >::iterator
        x: std::vector< itkMetaDataDictionary * >::value_type

        insert(self, pos, n, x)

        Parameters
        ----------
        pos: std::vector< itkMetaDataDictionary * >::iterator
        n: std::vector< itkMetaDataDictionary * >::size_type
        x: std::vector< itkMetaDataDictionary * >::value_type

        """
        return _ITKCommonBasePython.vectoritkMetaDataDictionary_insert(self, *args)

    def reserve(self, n):
        r"""
        reserve(self, n)

        Parameters
        ----------
        n: std::vector< itkMetaDataDictionary * >::size_type

        """
        return _ITKCommonBasePython.vectoritkMetaDataDictionary_reserve(self, n)

    def capacity(self):
        r"""capacity(self) -> std::vector< itkMetaDataDictionary * >::size_type"""
        return _ITKCommonBasePython.vectoritkMetaDataDictionary_capacity(self)
    __swig_destroy__ = _ITKCommonBasePython.delete_vectoritkMetaDataDictionary

# Register vectoritkMetaDataDictionary in _ITKCommonBasePython:
_ITKCommonBasePython.vectoritkMetaDataDictionary_swigregister(vectoritkMetaDataDictionary)
class itkBoolean(object):
    r"""Proxy of C++ itkBoolean class."""

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

    def __init__(self, *args):
        r"""
        __init__(self) -> itkBoolean
        __init__(self, v) -> itkBoolean

        Parameters
        ----------
        v: bool

        __init__(self, arg0) -> itkBoolean

        Parameters
        ----------
        arg0: itkBoolean const &

        """
        _ITKCommonBasePython.itkBoolean_swiginit(self, _ITKCommonBasePython.new_itkBoolean(*args))
    __swig_destroy__ = _ITKCommonBasePython.delete_itkBoolean

# Register itkBoolean in _ITKCommonBasePython:
_ITKCommonBasePython.itkBoolean_swigregister(itkBoolean)
class itkCommonEnums(object):
    r"""Proxy of C++ itkCommonEnums class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    IOPixel_UNKNOWNPIXELTYPE = _ITKCommonBasePython.itkCommonEnums_IOPixel_UNKNOWNPIXELTYPE
    
    IOPixel_SCALAR = _ITKCommonBasePython.itkCommonEnums_IOPixel_SCALAR
    
    IOPixel_RGB = _ITKCommonBasePython.itkCommonEnums_IOPixel_RGB
    
    IOPixel_RGBA = _ITKCommonBasePython.itkCommonEnums_IOPixel_RGBA
    
    IOPixel_OFFSET = _ITKCommonBasePython.itkCommonEnums_IOPixel_OFFSET
    
    IOPixel_VECTOR = _ITKCommonBasePython.itkCommonEnums_IOPixel_VECTOR
    
    IOPixel_POINT = _ITKCommonBasePython.itkCommonEnums_IOPixel_POINT
    
    IOPixel_COVARIANTVECTOR = _ITKCommonBasePython.itkCommonEnums_IOPixel_COVARIANTVECTOR
    
    IOPixel_SYMMETRICSECONDRANKTENSOR = _ITKCommonBasePython.itkCommonEnums_IOPixel_SYMMETRICSECONDRANKTENSOR
    
    IOPixel_DIFFUSIONTENSOR3D = _ITKCommonBasePython.itkCommonEnums_IOPixel_DIFFUSIONTENSOR3D
    
    IOPixel_COMPLEX = _ITKCommonBasePython.itkCommonEnums_IOPixel_COMPLEX
    
    IOPixel_FIXEDARRAY = _ITKCommonBasePython.itkCommonEnums_IOPixel_FIXEDARRAY
    
    IOPixel_ARRAY = _ITKCommonBasePython.itkCommonEnums_IOPixel_ARRAY
    
    IOPixel_MATRIX = _ITKCommonBasePython.itkCommonEnums_IOPixel_MATRIX
    
    IOPixel_VARIABLELENGTHVECTOR = _ITKCommonBasePython.itkCommonEnums_IOPixel_VARIABLELENGTHVECTOR
    
    IOPixel_VARIABLESIZEMATRIX = _ITKCommonBasePython.itkCommonEnums_IOPixel_VARIABLESIZEMATRIX
    
    IOComponent_UNKNOWNCOMPONENTTYPE = _ITKCommonBasePython.itkCommonEnums_IOComponent_UNKNOWNCOMPONENTTYPE
    
    IOComponent_UCHAR = _ITKCommonBasePython.itkCommonEnums_IOComponent_UCHAR
    
    IOComponent_CHAR = _ITKCommonBasePython.itkCommonEnums_IOComponent_CHAR
    
    IOComponent_USHORT = _ITKCommonBasePython.itkCommonEnums_IOComponent_USHORT
    
    IOComponent_SHORT = _ITKCommonBasePython.itkCommonEnums_IOComponent_SHORT
    
    IOComponent_UINT = _ITKCommonBasePython.itkCommonEnums_IOComponent_UINT
    
    IOComponent_INT = _ITKCommonBasePython.itkCommonEnums_IOComponent_INT
    
    IOComponent_ULONG = _ITKCommonBasePython.itkCommonEnums_IOComponent_ULONG
    
    IOComponent_LONG = _ITKCommonBasePython.itkCommonEnums_IOComponent_LONG
    
    IOComponent_LONGLONG = _ITKCommonBasePython.itkCommonEnums_IOComponent_LONGLONG
    
    IOComponent_ULONGLONG = _ITKCommonBasePython.itkCommonEnums_IOComponent_ULONGLONG
    
    IOComponent_FLOAT = _ITKCommonBasePython.itkCommonEnums_IOComponent_FLOAT
    
    IOComponent_DOUBLE = _ITKCommonBasePython.itkCommonEnums_IOComponent_DOUBLE
    
    IOComponent_LDOUBLE = _ITKCommonBasePython.itkCommonEnums_IOComponent_LDOUBLE
    
    IOFile_ASCII = _ITKCommonBasePython.itkCommonEnums_IOFile_ASCII
    
    IOFile_Binary = _ITKCommonBasePython.itkCommonEnums_IOFile_Binary
    
    IOFile_TypeNotApplicable = _ITKCommonBasePython.itkCommonEnums_IOFile_TypeNotApplicable
    
    IOFile_BINARY = _ITKCommonBasePython.itkCommonEnums_IOFile_BINARY
    
    IOFile_TYPENOTAPPLICABLE = _ITKCommonBasePython.itkCommonEnums_IOFile_TYPENOTAPPLICABLE
    
    IOFileMode_ReadMode = _ITKCommonBasePython.itkCommonEnums_IOFileMode_ReadMode
    
    IOFileMode_WriteMode = _ITKCommonBasePython.itkCommonEnums_IOFileMode_WriteMode
    
    IOByteOrder_BigEndian = _ITKCommonBasePython.itkCommonEnums_IOByteOrder_BigEndian
    
    IOByteOrder_LittleEndian = _ITKCommonBasePython.itkCommonEnums_IOByteOrder_LittleEndian
    
    IOByteOrder_OrderNotApplicable = _ITKCommonBasePython.itkCommonEnums_IOByteOrder_OrderNotApplicable
    
    CellGeometry_VERTEX_CELL = _ITKCommonBasePython.itkCommonEnums_CellGeometry_VERTEX_CELL
    
    CellGeometry_LINE_CELL = _ITKCommonBasePython.itkCommonEnums_CellGeometry_LINE_CELL
    
    CellGeometry_TRIANGLE_CELL = _ITKCommonBasePython.itkCommonEnums_CellGeometry_TRIANGLE_CELL
    
    CellGeometry_QUADRILATERAL_CELL = _ITKCommonBasePython.itkCommonEnums_CellGeometry_QUADRILATERAL_CELL
    
    CellGeometry_POLYGON_CELL = _ITKCommonBasePython.itkCommonEnums_CellGeometry_POLYGON_CELL
    
    CellGeometry_TETRAHEDRON_CELL = _ITKCommonBasePython.itkCommonEnums_CellGeometry_TETRAHEDRON_CELL
    
    CellGeometry_HEXAHEDRON_CELL = _ITKCommonBasePython.itkCommonEnums_CellGeometry_HEXAHEDRON_CELL
    
    CellGeometry_QUADRATIC_EDGE_CELL = _ITKCommonBasePython.itkCommonEnums_CellGeometry_QUADRATIC_EDGE_CELL
    
    CellGeometry_QUADRATIC_TRIANGLE_CELL = _ITKCommonBasePython.itkCommonEnums_CellGeometry_QUADRATIC_TRIANGLE_CELL
    
    CellGeometry_LAST_ITK_CELL = _ITKCommonBasePython.itkCommonEnums_CellGeometry_LAST_ITK_CELL
    
    CellGeometry_POLYLINE_CELL = _ITKCommonBasePython.itkCommonEnums_CellGeometry_POLYLINE_CELL
    
    CellGeometry_MAX_ITK_CELLS = _ITKCommonBasePython.itkCommonEnums_CellGeometry_MAX_ITK_CELLS
    

    def __init__(self, *args):
        r"""
        __init__(self) -> itkCommonEnums
        __init__(self, arg0) -> itkCommonEnums

        Parameters
        ----------
        arg0: itkCommonEnums const &

        """
        _ITKCommonBasePython.itkCommonEnums_swiginit(self, _ITKCommonBasePython.new_itkCommonEnums(*args))
    __swig_destroy__ = _ITKCommonBasePython.delete_itkCommonEnums

# Register itkCommonEnums in _ITKCommonBasePython:
_ITKCommonBasePython.itkCommonEnums_swigregister(itkCommonEnums)
class itkDataObjectConstIterator(object):
    r"""Proxy of C++ itkDataObjectConstIterator class."""

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

    def __init__(self, *args):
        r"""
        __init__(self) -> itkDataObjectConstIterator
        __init__(self, iter) -> itkDataObjectConstIterator

        Parameters
        ----------
        iter: itkDataObjectConstIterator const &

        """
        _ITKCommonBasePython.itkDataObjectConstIterator_swiginit(self, _ITKCommonBasePython.new_itkDataObjectConstIterator(*args))

    def GetDataObject(self):
        r"""GetDataObject(self) -> itkDataObject"""
        return _ITKCommonBasePython.itkDataObjectConstIterator_GetDataObject(self)

    def GetName(self):
        r"""GetName(self) -> std::string const &"""
        return _ITKCommonBasePython.itkDataObjectConstIterator_GetName(self)

    def __eq__(self, iter):
        r"""
        __eq__(self, iter) -> bool

        Parameters
        ----------
        iter: itkDataObjectConstIterator const &

        """
        return _ITKCommonBasePython.itkDataObjectConstIterator___eq__(self, iter)

    def __ne__(self, other):
        r"""
        __ne__(self, other) -> bool

        Parameters
        ----------
        other: itkDataObjectConstIterator const &

        """
        return _ITKCommonBasePython.itkDataObjectConstIterator___ne__(self, other)

    def GoToBegin(self):
        r"""GoToBegin(self)"""
        return _ITKCommonBasePython.itkDataObjectConstIterator_GoToBegin(self)

    def IsAtEnd(self):
        r"""IsAtEnd(self) -> bool"""
        return _ITKCommonBasePython.itkDataObjectConstIterator_IsAtEnd(self)
    __swig_destroy__ = _ITKCommonBasePython.delete_itkDataObjectConstIterator

# Register itkDataObjectConstIterator in _ITKCommonBasePython:
_ITKCommonBasePython.itkDataObjectConstIterator_swigregister(itkDataObjectConstIterator)
class itkDataObjectIterator(object):
    r"""Proxy of C++ itkDataObjectIterator class."""

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

    def __init__(self, *args):
        r"""
        __init__(self) -> itkDataObjectIterator
        __init__(self, iter) -> itkDataObjectIterator

        Parameters
        ----------
        iter: itkDataObjectIterator const &

        """
        _ITKCommonBasePython.itkDataObjectIterator_swiginit(self, _ITKCommonBasePython.new_itkDataObjectIterator(*args))

    def GetDataObject(self):
        r"""GetDataObject(self) -> itkDataObject"""
        return _ITKCommonBasePython.itkDataObjectIterator_GetDataObject(self)

    def GetName(self):
        r"""GetName(self) -> std::string const &"""
        return _ITKCommonBasePython.itkDataObjectIterator_GetName(self)

    def __eq__(self, iter):
        r"""
        __eq__(self, iter) -> bool

        Parameters
        ----------
        iter: itkDataObjectIterator const &

        """
        return _ITKCommonBasePython.itkDataObjectIterator___eq__(self, iter)

    def __ne__(self, other):
        r"""
        __ne__(self, other) -> bool

        Parameters
        ----------
        other: itkDataObjectIterator const &

        """
        return _ITKCommonBasePython.itkDataObjectIterator___ne__(self, other)

    def GoToBegin(self):
        r"""GoToBegin(self)"""
        return _ITKCommonBasePython.itkDataObjectIterator_GoToBegin(self)

    def IsAtEnd(self):
        r"""IsAtEnd(self) -> bool"""
        return _ITKCommonBasePython.itkDataObjectIterator_IsAtEnd(self)
    __swig_destroy__ = _ITKCommonBasePython.delete_itkDataObjectIterator

# Register itkDataObjectIterator in _ITKCommonBasePython:
_ITKCommonBasePython.itkDataObjectIterator_swigregister(itkDataObjectIterator)
class itkEventObject(object):
    r"""Proxy of C++ itkEventObject class."""

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

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

    def MakeObject(self):
        r"""MakeObject(self) -> itkEventObject"""
        return _ITKCommonBasePython.itkEventObject_MakeObject(self)

    def Print(self, os):
        r"""
        Print(self, os)

        Parameters
        ----------
        os: std::basic_ostream< char,std::char_traits< char > > &

        """
        return _ITKCommonBasePython.itkEventObject_Print(self, os)

    def GetEventName(self):
        r"""GetEventName(self) -> char const *"""
        return _ITKCommonBasePython.itkEventObject_GetEventName(self)

    def CheckEvent(self, arg0):
        r"""
        CheckEvent(self, arg0) -> bool

        Parameters
        ----------
        arg0: itkEventObject const *

        """
        return _ITKCommonBasePython.itkEventObject_CheckEvent(self, arg0)

# Register itkEventObject in _ITKCommonBasePython:
_ITKCommonBasePython.itkEventObject_swigregister(itkEventObject)

def itkIndent_New():
    return itkIndent.New()

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

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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkIndent"""
        return _ITKCommonBasePython.itkIndent___New_orig__()

    @staticmethod
    def GetNameOfClass():
        r"""GetNameOfClass() -> char const *"""
        return _ITKCommonBasePython.itkIndent_GetNameOfClass()

    def GetNextIndent(self):
        r"""GetNextIndent(self) -> itkIndent"""
        return _ITKCommonBasePython.itkIndent_GetNextIndent(self)
    __swig_destroy__ = _ITKCommonBasePython.delete_itkIndent

    def __init__(self, *args):
        r"""
        __init__(self, ind=0) -> itkIndent

        Parameters
        ----------
        ind: int

        __init__(self, arg0) -> itkIndent

        Parameters
        ----------
        arg0: itkIndent const &

        """
        _ITKCommonBasePython.itkIndent_swiginit(self, _ITKCommonBasePython.new_itkIndent(*args))

    def New(*args, **kargs):
        """New() -> itkIndent

        Create a new object of the class itkIndent and set the input and the parameters if some
        named or non-named arguments are passed to that method.

        New() tries to assign all the non named parameters to the input of the new objects - the
        first non named parameter in the first input, etc.

        The named parameters are used by calling the method with the same name prefixed by 'Set'.

        Ex:

          itkIndent.New(reader, threshold=10)

        is (most of the time) equivalent to:

          obj = itkIndent.New()
          obj.SetInput(0, reader.GetOutput())
          obj.SetThreshold(10)
        """
        obj = itkIndent.__New_orig__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkIndent in _ITKCommonBasePython:
_ITKCommonBasePython.itkIndent_swigregister(itkIndent)
class itkInputDataObjectConstIterator(itkDataObjectConstIterator):
    r"""Proxy of C++ itkInputDataObjectConstIterator class."""

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

    def GetInput(self):
        r"""GetInput(self) -> itkDataObject"""
        return _ITKCommonBasePython.itkInputDataObjectConstIterator_GetInput(self)

    def __init__(self, *args):
        r"""
        __init__(self, process) -> itkInputDataObjectConstIterator

        Parameters
        ----------
        process: itkProcessObject const *

        __init__(self, arg0) -> itkInputDataObjectConstIterator

        Parameters
        ----------
        arg0: itkInputDataObjectConstIterator const &

        """
        _ITKCommonBasePython.itkInputDataObjectConstIterator_swiginit(self, _ITKCommonBasePython.new_itkInputDataObjectConstIterator(*args))
    __swig_destroy__ = _ITKCommonBasePython.delete_itkInputDataObjectConstIterator

# Register itkInputDataObjectConstIterator in _ITKCommonBasePython:
_ITKCommonBasePython.itkInputDataObjectConstIterator_swigregister(itkInputDataObjectConstIterator)
class itkInputDataObjectIterator(itkDataObjectIterator):
    r"""Proxy of C++ itkInputDataObjectIterator class."""

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

    def GetInput(self):
        r"""GetInput(self) -> itkDataObject"""
        return _ITKCommonBasePython.itkInputDataObjectIterator_GetInput(self)

    def __init__(self, *args):
        r"""
        __init__(self, process) -> itkInputDataObjectIterator

        Parameters
        ----------
        process: itkProcessObject *

        __init__(self, arg0) -> itkInputDataObjectIterator

        Parameters
        ----------
        arg0: itkInputDataObjectIterator const &

        """
        _ITKCommonBasePython.itkInputDataObjectIterator_swiginit(self, _ITKCommonBasePython.new_itkInputDataObjectIterator(*args))
    __swig_destroy__ = _ITKCommonBasePython.delete_itkInputDataObjectIterator

# Register itkInputDataObjectIterator in _ITKCommonBasePython:
_ITKCommonBasePython.itkInputDataObjectIterator_swigregister(itkInputDataObjectIterator)
class itkIterationReporter(object):
    r"""Proxy of C++ itkIterationReporter class."""

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

    def CompletedStep(self):
        r"""CompletedStep(self)"""
        return _ITKCommonBasePython.itkIterationReporter_CompletedStep(self)

    def __init__(self, *args):
        r"""
        __init__(self, filter, threadId, stepsPerUpdate=100) -> itkIterationReporter

        Parameters
        ----------
        filter: itkProcessObject *
        threadId: unsigned int
        stepsPerUpdate: unsigned long

        __init__(self, arg0) -> itkIterationReporter

        Parameters
        ----------
        arg0: itkIterationReporter const &

        """
        _ITKCommonBasePython.itkIterationReporter_swiginit(self, _ITKCommonBasePython.new_itkIterationReporter(*args))

# Register itkIterationReporter in _ITKCommonBasePython:
_ITKCommonBasePython.itkIterationReporter_swigregister(itkIterationReporter)
class itkLightObject(object):
    r"""Proxy of C++ itkLightObject class."""

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

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

    @staticmethod
    def New():
        r"""New() -> itkLightObject_Pointer"""
        return _ITKCommonBasePython.itkLightObject_New()

    def CreateAnother(self):
        r"""CreateAnother(self) -> itkLightObject_Pointer"""
        return _ITKCommonBasePython.itkLightObject_CreateAnother(self)

    def Clone(self):
        r"""Clone(self) -> itkLightObject_Pointer"""
        return _ITKCommonBasePython.itkLightObject_Clone(self)

    def GetNameOfClass(self):
        r"""GetNameOfClass(self) -> char const *"""
        return _ITKCommonBasePython.itkLightObject_GetNameOfClass(self)

    def Print(self, os, indent=0):
        r"""
        Print(self, os, indent=0)

        Parameters
        ----------
        os: std::basic_ostream< char,std::char_traits< char > > &
        indent: itkIndent

        """
        return _ITKCommonBasePython.itkLightObject_Print(self, os, indent)

    @staticmethod
    def BreakOnError():
        r"""BreakOnError()"""
        return _ITKCommonBasePython.itkLightObject_BreakOnError()

    def GetReferenceCount(self):
        r"""GetReferenceCount(self) -> int"""
        return _ITKCommonBasePython.itkLightObject_GetReferenceCount(self)

    def __str__(self):
        r"""__str__(self) -> std::string"""
        return _ITKCommonBasePython.itkLightObject___str__(self)

    def __eq__(self, obj):
        r"""
        __eq__(self, obj) -> bool

        Parameters
        ----------
        obj: itkLightObject *

        """
        return _ITKCommonBasePython.itkLightObject___eq__(self, obj)

    def __hash__(self):
        r"""__hash__(self) -> size_t"""
        return _ITKCommonBasePython.itkLightObject___hash__(self)
    __swig_destroy__ = _ITKCommonBasePython.delete_itkLightObject

    @staticmethod
    def cast(obj):
        r"""
        cast(obj) -> itkLightObject

        Parameters
        ----------
        obj: itkLightObject *

        """
        return _ITKCommonBasePython.itkLightObject_cast(obj)

# Register itkLightObject in _ITKCommonBasePython:
_ITKCommonBasePython.itkLightObject_swigregister(itkLightObject)
class itkMeshEnums(object):
    r"""Proxy of C++ itkMeshEnums class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    MeshClassCellsAllocationMethod_CellsAllocationMethodUndefined = _ITKCommonBasePython.itkMeshEnums_MeshClassCellsAllocationMethod_CellsAllocationMethodUndefined
    
    MeshClassCellsAllocationMethod_CellsAllocatedAsStaticArray = _ITKCommonBasePython.itkMeshEnums_MeshClassCellsAllocationMethod_CellsAllocatedAsStaticArray
    
    MeshClassCellsAllocationMethod_CellsAllocatedAsADynamicArray = _ITKCommonBasePython.itkMeshEnums_MeshClassCellsAllocationMethod_CellsAllocatedAsADynamicArray
    
    MeshClassCellsAllocationMethod_CellsAllocatedDynamicallyCellByCell = _ITKCommonBasePython.itkMeshEnums_MeshClassCellsAllocationMethod_CellsAllocatedDynamicallyCellByCell
    

    def __init__(self, *args):
        r"""
        __init__(self) -> itkMeshEnums
        __init__(self, arg0) -> itkMeshEnums

        Parameters
        ----------
        arg0: itkMeshEnums const &

        """
        _ITKCommonBasePython.itkMeshEnums_swiginit(self, _ITKCommonBasePython.new_itkMeshEnums(*args))
    __swig_destroy__ = _ITKCommonBasePython.delete_itkMeshEnums

# Register itkMeshEnums in _ITKCommonBasePython:
_ITKCommonBasePython.itkMeshEnums_swigregister(itkMeshEnums)
class itkMetaDataDictionary(object):
    r"""Proxy of C++ itkMetaDataDictionary class."""

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

    def Print(self, os):
        r"""
        Print(self, os)

        Parameters
        ----------
        os: std::basic_ostream< char,std::char_traits< char > > &

        """
        return _ITKCommonBasePython.itkMetaDataDictionary_Print(self, os)

    def __init__(self, *args):
        r"""
        __init__(self) -> itkMetaDataDictionary
        __init__(self, arg0) -> itkMetaDataDictionary

        Parameters
        ----------
        arg0: itkMetaDataDictionary const &

        """
        _ITKCommonBasePython.itkMetaDataDictionary_swiginit(self, _ITKCommonBasePython.new_itkMetaDataDictionary(*args))
    __swig_destroy__ = _ITKCommonBasePython.delete_itkMetaDataDictionary

    def GetKeys(self):
        r"""GetKeys(self) -> vectorstring"""
        return _ITKCommonBasePython.itkMetaDataDictionary_GetKeys(self)

    def Get(self, arg0):
        r"""
        Get(self, arg0) -> itkMetaDataObjectBase

        Parameters
        ----------
        arg0: std::string const &

        """
        return _ITKCommonBasePython.itkMetaDataDictionary_Get(self, arg0)

    def Set(self, arg0, arg1):
        r"""
        Set(self, arg0, arg1)

        Parameters
        ----------
        arg0: std::string const &
        arg1: itkMetaDataObjectBase *

        """
        return _ITKCommonBasePython.itkMetaDataDictionary_Set(self, arg0, arg1)

    def HasKey(self, arg0):
        r"""
        HasKey(self, arg0) -> bool

        Parameters
        ----------
        arg0: std::string const &

        """
        return _ITKCommonBasePython.itkMetaDataDictionary_HasKey(self, arg0)

    def Erase(self, arg0):
        r"""
        Erase(self, arg0) -> bool

        Parameters
        ----------
        arg0: std::string const &

        """
        return _ITKCommonBasePython.itkMetaDataDictionary_Erase(self, arg0)

    def Clear(self):
        r"""Clear(self)"""
        return _ITKCommonBasePython.itkMetaDataDictionary_Clear(self)

    def Swap(self, other):
        r"""
        Swap(self, other)

        Parameters
        ----------
        other: itkMetaDataDictionary &

        """
        return _ITKCommonBasePython.itkMetaDataDictionary_Swap(self, other)

    def __str__(self):
        r"""__str__(self) -> std::string"""
        return _ITKCommonBasePython.itkMetaDataDictionary___str__(self)

    def __setitem__(self,key,item):
        import itk
        if isinstance(item, str):
            object = itk.MetaDataObject.S.New()
        elif isinstance(item, int):
            object = itk.MetaDataObject.SI.New()
        elif isinstance( item, float):
            object = itk.MetaDataObject.F.New()
        elif isinstance( item, bool):
            object = itk.MetaDataObject.B.New()
        else:
            object = None
        if object != None:
            object.SetMetaDataObjectValue(item)
            self.Set(key, object)
    def __getitem__(self,key):
        import itk
        obj = self.Get(key)
        return itk.down_cast(obj).GetMetaDataObjectValue()
    def __len__(self):
        return self.GetKeys().size()
    def __iter__(self):
        keys = self.GetKeys()
        for key in keys:
            yield self.Get(key)


# Register itkMetaDataDictionary in _ITKCommonBasePython:
_ITKCommonBasePython.itkMetaDataDictionary_swigregister(itkMetaDataDictionary)
class itkMetaDataObjectBase(itkLightObject):
    r"""Proxy of C++ itkMetaDataObjectBase class."""

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

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

    def GetMetaDataObjectTypeName(self):
        r"""GetMetaDataObjectTypeName(self) -> char const *"""
        return _ITKCommonBasePython.itkMetaDataObjectBase_GetMetaDataObjectTypeName(self)

    def GetMetaDataObjectTypeInfo(self):
        r"""GetMetaDataObjectTypeInfo(self) -> std::type_info const &"""
        return _ITKCommonBasePython.itkMetaDataObjectBase_GetMetaDataObjectTypeInfo(self)

    def Print(self, os):
        r"""
        Print(self, os)

        Parameters
        ----------
        os: std::basic_ostream< char,std::char_traits< char > > &

        """
        return _ITKCommonBasePython.itkMetaDataObjectBase_Print(self, os)
    __swig_destroy__ = _ITKCommonBasePython.delete_itkMetaDataObjectBase

    @staticmethod
    def cast(obj):
        r"""
        cast(obj) -> itkMetaDataObjectBase

        Parameters
        ----------
        obj: itkLightObject *

        """
        return _ITKCommonBasePython.itkMetaDataObjectBase_cast(obj)

# Register itkMetaDataObjectBase in _ITKCommonBasePython:
_ITKCommonBasePython.itkMetaDataObjectBase_swigregister(itkMetaDataObjectBase)
class itkMultiThreaderBaseEnums(object):
    r"""Proxy of C++ itkMultiThreaderBaseEnums class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    Threader_Platform = _ITKCommonBasePython.itkMultiThreaderBaseEnums_Threader_Platform
    
    Threader_First = _ITKCommonBasePython.itkMultiThreaderBaseEnums_Threader_First
    
    Threader_Pool = _ITKCommonBasePython.itkMultiThreaderBaseEnums_Threader_Pool
    
    Threader_TBB = _ITKCommonBasePython.itkMultiThreaderBaseEnums_Threader_TBB
    
    Threader_Last = _ITKCommonBasePython.itkMultiThreaderBaseEnums_Threader_Last
    
    Threader_Unknown = _ITKCommonBasePython.itkMultiThreaderBaseEnums_Threader_Unknown
    
    ThreadExitCode_SUCCESS = _ITKCommonBasePython.itkMultiThreaderBaseEnums_ThreadExitCode_SUCCESS
    
    ThreadExitCode_ITK_EXCEPTION = _ITKCommonBasePython.itkMultiThreaderBaseEnums_ThreadExitCode_ITK_EXCEPTION
    
    ThreadExitCode_ITK_PROCESS_ABORTED_EXCEPTION = _ITKCommonBasePython.itkMultiThreaderBaseEnums_ThreadExitCode_ITK_PROCESS_ABORTED_EXCEPTION
    
    ThreadExitCode_STD_EXCEPTION = _ITKCommonBasePython.itkMultiThreaderBaseEnums_ThreadExitCode_STD_EXCEPTION
    
    ThreadExitCode_UNKNOWN = _ITKCommonBasePython.itkMultiThreaderBaseEnums_ThreadExitCode_UNKNOWN
    

    def __init__(self, *args):
        r"""
        __init__(self) -> itkMultiThreaderBaseEnums
        __init__(self, arg0) -> itkMultiThreaderBaseEnums

        Parameters
        ----------
        arg0: itkMultiThreaderBaseEnums const &

        """
        _ITKCommonBasePython.itkMultiThreaderBaseEnums_swiginit(self, _ITKCommonBasePython.new_itkMultiThreaderBaseEnums(*args))
    __swig_destroy__ = _ITKCommonBasePython.delete_itkMultiThreaderBaseEnums

# Register itkMultiThreaderBaseEnums in _ITKCommonBasePython:
_ITKCommonBasePython.itkMultiThreaderBaseEnums_swigregister(itkMultiThreaderBaseEnums)
class itkNoEvent(itkEventObject):
    r"""Proxy of C++ itkNoEvent class."""

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

    def __init__(self, *args):
        r"""
        __init__(self) -> itkNoEvent
        __init__(self, s) -> itkNoEvent

        Parameters
        ----------
        s: itkNoEvent const &

        """
        _ITKCommonBasePython.itkNoEvent_swiginit(self, _ITKCommonBasePython.new_itkNoEvent(*args))
    __swig_destroy__ = _ITKCommonBasePython.delete_itkNoEvent

# Register itkNoEvent in _ITKCommonBasePython:
_ITKCommonBasePython.itkNoEvent_swigregister(itkNoEvent)

def itkObject_New():
    return itkObject.New()

class itkObject(itkLightObject):
    r"""Proxy of C++ itkObject class."""

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

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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkObject_Pointer"""
        return _ITKCommonBasePython.itkObject___New_orig__()

    def DebugOn(self):
        r"""DebugOn(self)"""
        return _ITKCommonBasePython.itkObject_DebugOn(self)

    def DebugOff(self):
        r"""DebugOff(self)"""
        return _ITKCommonBasePython.itkObject_DebugOff(self)

    def GetDebug(self):
        r"""GetDebug(self) -> bool"""
        return _ITKCommonBasePython.itkObject_GetDebug(self)

    def SetDebug(self, debugFlag):
        r"""
        SetDebug(self, debugFlag)

        Parameters
        ----------
        debugFlag: bool

        """
        return _ITKCommonBasePython.itkObject_SetDebug(self, debugFlag)

    def GetMTime(self):
        r"""GetMTime(self) -> unsigned long"""
        return _ITKCommonBasePython.itkObject_GetMTime(self)

    def GetTimeStamp(self):
        r"""GetTimeStamp(self) -> itkTimeStamp"""
        return _ITKCommonBasePython.itkObject_GetTimeStamp(self)

    def Modified(self):
        r"""Modified(self)"""
        return _ITKCommonBasePython.itkObject_Modified(self)

    @staticmethod
    def SetGlobalWarningDisplay(val):
        r"""
        SetGlobalWarningDisplay(val)

        Parameters
        ----------
        val: bool

        """
        return _ITKCommonBasePython.itkObject_SetGlobalWarningDisplay(val)

    @staticmethod
    def GetGlobalWarningDisplay():
        r"""GetGlobalWarningDisplay() -> bool"""
        return _ITKCommonBasePython.itkObject_GetGlobalWarningDisplay()

    @staticmethod
    def GlobalWarningDisplayOn():
        r"""GlobalWarningDisplayOn()"""
        return _ITKCommonBasePython.itkObject_GlobalWarningDisplayOn()

    @staticmethod
    def GlobalWarningDisplayOff():
        r"""GlobalWarningDisplayOff()"""
        return _ITKCommonBasePython.itkObject_GlobalWarningDisplayOff()

    def AddObserver(self, *args):
        r"""
        AddObserver(self, event, arg1) -> unsigned long

        Parameters
        ----------
        event: itkEventObject const &
        arg1: itkCommand *

        AddObserver(self, event, arg1) -> unsigned long

        Parameters
        ----------
        event: itkEventObject const &
        arg1: itkCommand *

        """

        import itk
        if len(args) == 3 and not issubclass(args[2].__class__, itk.Command) and callable(args[2]):
            args = list(args)
            pycommand = itk.PyCommand.New()
            pycommand.SetCommandCallable( args[2] )
            args[2] = pycommand
            args = tuple(args)
        elif len(args) == 2 and not issubclass(args[1].__class__, itk.Command) and callable(args[1]):
            args = list(args)
            pycommand = itk.PyCommand.New()
            pycommand.SetCommandCallable( args[1] )
            args[1] = pycommand
            args = tuple(args)


        return _ITKCommonBasePython.itkObject_AddObserver(self, *args)


    def GetCommand(self, tag):
        r"""
        GetCommand(self, tag) -> itkCommand

        Parameters
        ----------
        tag: unsigned long

        """
        return _ITKCommonBasePython.itkObject_GetCommand(self, tag)

    def InvokeEvent(self, *args):
        r"""
        InvokeEvent(self, arg0)

        Parameters
        ----------
        arg0: itkEventObject const &

        InvokeEvent(self, arg0)

        Parameters
        ----------
        arg0: itkEventObject const &

        """
        return _ITKCommonBasePython.itkObject_InvokeEvent(self, *args)

    def RemoveObserver(self, tag):
        r"""
        RemoveObserver(self, tag)

        Parameters
        ----------
        tag: unsigned long

        """
        return _ITKCommonBasePython.itkObject_RemoveObserver(self, tag)

    def RemoveAllObservers(self):
        r"""RemoveAllObservers(self)"""
        return _ITKCommonBasePython.itkObject_RemoveAllObservers(self)

    def HasObserver(self, event):
        r"""
        HasObserver(self, event) -> bool

        Parameters
        ----------
        event: itkEventObject const &

        """
        return _ITKCommonBasePython.itkObject_HasObserver(self, event)

    def GetMetaDataDictionary(self, *args):
        r"""
        GetMetaDataDictionary(self) -> itkMetaDataDictionary
        GetMetaDataDictionary(self) -> itkMetaDataDictionary
        """
        return _ITKCommonBasePython.itkObject_GetMetaDataDictionary(self, *args)

    def SetMetaDataDictionary(self, rhs):
        r"""
        SetMetaDataDictionary(self, rhs)

        Parameters
        ----------
        rhs: itkMetaDataDictionary const &

        """
        return _ITKCommonBasePython.itkObject_SetMetaDataDictionary(self, rhs)

    def SetObjectName(self, _arg):
        r"""
        SetObjectName(self, _arg)

        Parameters
        ----------
        _arg: std::string

        """
        return _ITKCommonBasePython.itkObject_SetObjectName(self, _arg)

    def GetObjectName(self):
        r"""GetObjectName(self) -> std::string const &"""
        return _ITKCommonBasePython.itkObject_GetObjectName(self)
    __swig_destroy__ = _ITKCommonBasePython.delete_itkObject

    @staticmethod
    def cast(obj):
        r"""
        cast(obj) -> itkObject

        Parameters
        ----------
        obj: itkLightObject *

        """
        return _ITKCommonBasePython.itkObject_cast(obj)

    def New(*args, **kargs):
        """New() -> itkObject

        Create a new object of the class itkObject and set the input and the parameters if some
        named or non-named arguments are passed to that method.

        New() tries to assign all the non named parameters to the input of the new objects - the
        first non named parameter in the first input, etc.

        The named parameters are used by calling the method with the same name prefixed by 'Set'.

        Ex:

          itkObject.New(reader, threshold=10)

        is (most of the time) equivalent to:

          obj = itkObject.New()
          obj.SetInput(0, reader.GetOutput())
          obj.SetThreshold(10)
        """
        obj = itkObject.__New_orig__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkObject in _ITKCommonBasePython:
_ITKCommonBasePython.itkObject_swigregister(itkObject)
class itkObjectEnums(object):
    r"""Proxy of C++ itkObjectEnums class."""

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

    def __init__(self, *args):
        r"""
        __init__(self) -> itkObjectEnums
        __init__(self, arg0) -> itkObjectEnums

        Parameters
        ----------
        arg0: itkObjectEnums const &

        """
        _ITKCommonBasePython.itkObjectEnums_swiginit(self, _ITKCommonBasePython.new_itkObjectEnums(*args))
    __swig_destroy__ = _ITKCommonBasePython.delete_itkObjectEnums

# Register itkObjectEnums in _ITKCommonBasePython:
_ITKCommonBasePython.itkObjectEnums_swigregister(itkObjectEnums)
class itkObjectFactoryBase(itkObject):
    r"""Proxy of C++ itkObjectFactoryBase class."""

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

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

    @staticmethod
    def CreateInstance(itkclassname):
        r"""
        CreateInstance(itkclassname) -> itkLightObject_Pointer

        Parameters
        ----------
        itkclassname: char const *

        """
        return _ITKCommonBasePython.itkObjectFactoryBase_CreateInstance(itkclassname)

    @staticmethod
    def CreateAllInstance(itkclassname):
        r"""
        CreateAllInstance(itkclassname) -> listitkLightObject

        Parameters
        ----------
        itkclassname: char const *

        """
        return _ITKCommonBasePython.itkObjectFactoryBase_CreateAllInstance(itkclassname)

    @staticmethod
    def ReHash():
        r"""ReHash()"""
        return _ITKCommonBasePython.itkObjectFactoryBase_ReHash()

    @staticmethod
    def RegisterFactoryInternal(arg0):
        r"""
        RegisterFactoryInternal(arg0)

        Parameters
        ----------
        arg0: itkObjectFactoryBase *

        """
        return _ITKCommonBasePython.itkObjectFactoryBase_RegisterFactoryInternal(arg0)

    @staticmethod
    def RegisterFactory(*args):
        r"""
        RegisterFactory(arg0, where=::itk::ObjectFactoryEnums::INSERT_AT_BACK, position=0) -> bool

        Parameters
        ----------
        arg0: itkObjectFactoryBase *
        where: enum itkObjectFactoryEnums::InsertionPosition
        position: unsigned long

        """
        return _ITKCommonBasePython.itkObjectFactoryBase_RegisterFactory(*args)

    @staticmethod
    def UnRegisterFactory(arg0):
        r"""
        UnRegisterFactory(arg0)

        Parameters
        ----------
        arg0: itkObjectFactoryBase *

        """
        return _ITKCommonBasePython.itkObjectFactoryBase_UnRegisterFactory(arg0)

    @staticmethod
    def UnRegisterAllFactories():
        r"""UnRegisterAllFactories()"""
        return _ITKCommonBasePython.itkObjectFactoryBase_UnRegisterAllFactories()

    @staticmethod
    def GetRegisteredFactories():
        r"""GetRegisteredFactories() -> listitkObjectFactoryBase"""
        return _ITKCommonBasePython.itkObjectFactoryBase_GetRegisteredFactories()

    def GetITKSourceVersion(self):
        r"""GetITKSourceVersion(self) -> char const *"""
        return _ITKCommonBasePython.itkObjectFactoryBase_GetITKSourceVersion(self)

    @staticmethod
    def SetStrictVersionChecking(arg0):
        r"""
        SetStrictVersionChecking(arg0)

        Parameters
        ----------
        arg0: bool

        """
        return _ITKCommonBasePython.itkObjectFactoryBase_SetStrictVersionChecking(arg0)

    @staticmethod
    def StrictVersionCheckingOn():
        r"""StrictVersionCheckingOn()"""
        return _ITKCommonBasePython.itkObjectFactoryBase_StrictVersionCheckingOn()

    @staticmethod
    def StrictVersionCheckingOff():
        r"""StrictVersionCheckingOff()"""
        return _ITKCommonBasePython.itkObjectFactoryBase_StrictVersionCheckingOff()

    @staticmethod
    def GetStrictVersionChecking():
        r"""GetStrictVersionChecking() -> bool"""
        return _ITKCommonBasePython.itkObjectFactoryBase_GetStrictVersionChecking()

    def GetDescription(self):
        r"""GetDescription(self) -> char const *"""
        return _ITKCommonBasePython.itkObjectFactoryBase_GetDescription(self)

    def GetClassOverrideNames(self):
        r"""GetClassOverrideNames(self) -> liststring"""
        return _ITKCommonBasePython.itkObjectFactoryBase_GetClassOverrideNames(self)

    def GetClassOverrideWithNames(self):
        r"""GetClassOverrideWithNames(self) -> liststring"""
        return _ITKCommonBasePython.itkObjectFactoryBase_GetClassOverrideWithNames(self)

    def GetClassOverrideDescriptions(self):
        r"""GetClassOverrideDescriptions(self) -> liststring"""
        return _ITKCommonBasePython.itkObjectFactoryBase_GetClassOverrideDescriptions(self)

    def GetEnableFlags(self):
        r"""GetEnableFlags(self) -> listB"""
        return _ITKCommonBasePython.itkObjectFactoryBase_GetEnableFlags(self)

    def SetEnableFlag(self, flag, className, subclassName):
        r"""
        SetEnableFlag(self, flag, className, subclassName)

        Parameters
        ----------
        flag: bool
        className: char const *
        subclassName: char const *

        """
        return _ITKCommonBasePython.itkObjectFactoryBase_SetEnableFlag(self, flag, className, subclassName)

    def GetEnableFlag(self, className, subclassName):
        r"""
        GetEnableFlag(self, className, subclassName) -> bool

        Parameters
        ----------
        className: char const *
        subclassName: char const *

        """
        return _ITKCommonBasePython.itkObjectFactoryBase_GetEnableFlag(self, className, subclassName)

    def Disable(self, className):
        r"""
        Disable(self, className)

        Parameters
        ----------
        className: char const *

        """
        return _ITKCommonBasePython.itkObjectFactoryBase_Disable(self, className)

    def GetLibraryPath(self):
        r"""GetLibraryPath(self) -> char const *"""
        return _ITKCommonBasePython.itkObjectFactoryBase_GetLibraryPath(self)

    @staticmethod
    def Initialize():
        r"""Initialize()"""
        return _ITKCommonBasePython.itkObjectFactoryBase_Initialize()
    __swig_destroy__ = _ITKCommonBasePython.delete_itkObjectFactoryBase

    @staticmethod
    def cast(obj):
        r"""
        cast(obj) -> itkObjectFactoryBase

        Parameters
        ----------
        obj: itkLightObject *

        """
        return _ITKCommonBasePython.itkObjectFactoryBase_cast(obj)

# Register itkObjectFactoryBase in _ITKCommonBasePython:
_ITKCommonBasePython.itkObjectFactoryBase_swigregister(itkObjectFactoryBase)
class itkObjectFactoryEnums(object):
    r"""Proxy of C++ itkObjectFactoryEnums class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    InsertionPosition_INSERT_AT_FRONT = _ITKCommonBasePython.itkObjectFactoryEnums_InsertionPosition_INSERT_AT_FRONT
    
    InsertionPosition_INSERT_AT_BACK = _ITKCommonBasePython.itkObjectFactoryEnums_InsertionPosition_INSERT_AT_BACK
    
    InsertionPosition_INSERT_AT_POSITION = _ITKCommonBasePython.itkObjectFactoryEnums_InsertionPosition_INSERT_AT_POSITION
    

    def __init__(self, *args):
        r"""
        __init__(self) -> itkObjectFactoryEnums
        __init__(self, arg0) -> itkObjectFactoryEnums

        Parameters
        ----------
        arg0: itkObjectFactoryEnums const &

        """
        _ITKCommonBasePython.itkObjectFactoryEnums_swiginit(self, _ITKCommonBasePython.new_itkObjectFactoryEnums(*args))
    __swig_destroy__ = _ITKCommonBasePython.delete_itkObjectFactoryEnums

# Register itkObjectFactoryEnums in _ITKCommonBasePython:
_ITKCommonBasePython.itkObjectFactoryEnums_swigregister(itkObjectFactoryEnums)
class itkOctreeEnums(object):
    r"""Proxy of C++ itkOctreeEnums class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    Octree_UNKNOWN_PLANE = _ITKCommonBasePython.itkOctreeEnums_Octree_UNKNOWN_PLANE
    
    Octree_SAGITAL_PLANE = _ITKCommonBasePython.itkOctreeEnums_Octree_SAGITAL_PLANE
    
    Octree_CORONAL_PLANE = _ITKCommonBasePython.itkOctreeEnums_Octree_CORONAL_PLANE
    
    Octree_TRANSVERSE_PLANE = _ITKCommonBasePython.itkOctreeEnums_Octree_TRANSVERSE_PLANE
    
    LeafIdentifier_ZERO = _ITKCommonBasePython.itkOctreeEnums_LeafIdentifier_ZERO
    
    LeafIdentifier_ONE = _ITKCommonBasePython.itkOctreeEnums_LeafIdentifier_ONE
    
    LeafIdentifier_TWO = _ITKCommonBasePython.itkOctreeEnums_LeafIdentifier_TWO
    
    LeafIdentifier_THREE = _ITKCommonBasePython.itkOctreeEnums_LeafIdentifier_THREE
    
    LeafIdentifier_FOUR = _ITKCommonBasePython.itkOctreeEnums_LeafIdentifier_FOUR
    
    LeafIdentifier_FIVE = _ITKCommonBasePython.itkOctreeEnums_LeafIdentifier_FIVE
    
    LeafIdentifier_SIX = _ITKCommonBasePython.itkOctreeEnums_LeafIdentifier_SIX
    
    LeafIdentifier_SEVEN = _ITKCommonBasePython.itkOctreeEnums_LeafIdentifier_SEVEN
    

    def __init__(self, *args):
        r"""
        __init__(self) -> itkOctreeEnums
        __init__(self, arg0) -> itkOctreeEnums

        Parameters
        ----------
        arg0: itkOctreeEnums const &

        """
        _ITKCommonBasePython.itkOctreeEnums_swiginit(self, _ITKCommonBasePython.new_itkOctreeEnums(*args))
    __swig_destroy__ = _ITKCommonBasePython.delete_itkOctreeEnums

# Register itkOctreeEnums in _ITKCommonBasePython:
_ITKCommonBasePython.itkOctreeEnums_swigregister(itkOctreeEnums)
class itkOutputDataObjectConstIterator(itkDataObjectConstIterator):
    r"""Proxy of C++ itkOutputDataObjectConstIterator class."""

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

    def GetOutput(self):
        r"""GetOutput(self) -> itkDataObject"""
        return _ITKCommonBasePython.itkOutputDataObjectConstIterator_GetOutput(self)

    def __init__(self, *args):
        r"""
        __init__(self, process) -> itkOutputDataObjectConstIterator

        Parameters
        ----------
        process: itkProcessObject const *

        __init__(self, arg0) -> itkOutputDataObjectConstIterator

        Parameters
        ----------
        arg0: itkOutputDataObjectConstIterator const &

        """
        _ITKCommonBasePython.itkOutputDataObjectConstIterator_swiginit(self, _ITKCommonBasePython.new_itkOutputDataObjectConstIterator(*args))
    __swig_destroy__ = _ITKCommonBasePython.delete_itkOutputDataObjectConstIterator

# Register itkOutputDataObjectConstIterator in _ITKCommonBasePython:
_ITKCommonBasePython.itkOutputDataObjectConstIterator_swigregister(itkOutputDataObjectConstIterator)
class itkOutputDataObjectIterator(itkDataObjectIterator):
    r"""Proxy of C++ itkOutputDataObjectIterator class."""

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

    def GetOutput(self):
        r"""GetOutput(self) -> itkDataObject"""
        return _ITKCommonBasePython.itkOutputDataObjectIterator_GetOutput(self)

    def __init__(self, *args):
        r"""
        __init__(self, process) -> itkOutputDataObjectIterator

        Parameters
        ----------
        process: itkProcessObject *

        __init__(self, arg0) -> itkOutputDataObjectIterator

        Parameters
        ----------
        arg0: itkOutputDataObjectIterator const &

        """
        _ITKCommonBasePython.itkOutputDataObjectIterator_swiginit(self, _ITKCommonBasePython.new_itkOutputDataObjectIterator(*args))
    __swig_destroy__ = _ITKCommonBasePython.delete_itkOutputDataObjectIterator

# Register itkOutputDataObjectIterator in _ITKCommonBasePython:
_ITKCommonBasePython.itkOutputDataObjectIterator_swigregister(itkOutputDataObjectIterator)

def itkOutputWindow_New():
    return itkOutputWindow.New()

class itkOutputWindow(itkObject):
    r"""Proxy of C++ itkOutputWindow class."""

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

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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkOutputWindow_Pointer"""
        return _ITKCommonBasePython.itkOutputWindow___New_orig__()

    @staticmethod
    def GetInstance():
        r"""GetInstance() -> itkOutputWindow_Pointer"""
        return _ITKCommonBasePython.itkOutputWindow_GetInstance()

    @staticmethod
    def SetInstance(instance):
        r"""
        SetInstance(instance)

        Parameters
        ----------
        instance: itkOutputWindow *

        """
        return _ITKCommonBasePython.itkOutputWindow_SetInstance(instance)

    def DisplayText(self, arg0):
        r"""
        DisplayText(self, arg0)

        Parameters
        ----------
        arg0: char const *

        """
        return _ITKCommonBasePython.itkOutputWindow_DisplayText(self, arg0)

    def DisplayErrorText(self, t):
        r"""
        DisplayErrorText(self, t)

        Parameters
        ----------
        t: char const *

        """
        return _ITKCommonBasePython.itkOutputWindow_DisplayErrorText(self, t)

    def DisplayWarningText(self, t):
        r"""
        DisplayWarningText(self, t)

        Parameters
        ----------
        t: char const *

        """
        return _ITKCommonBasePython.itkOutputWindow_DisplayWarningText(self, t)

    def DisplayGenericOutputText(self, t):
        r"""
        DisplayGenericOutputText(self, t)

        Parameters
        ----------
        t: char const *

        """
        return _ITKCommonBasePython.itkOutputWindow_DisplayGenericOutputText(self, t)

    def DisplayDebugText(self, t):
        r"""
        DisplayDebugText(self, t)

        Parameters
        ----------
        t: char const *

        """
        return _ITKCommonBasePython.itkOutputWindow_DisplayDebugText(self, t)

    def SetPromptUser(self, _arg):
        r"""
        SetPromptUser(self, _arg)

        Parameters
        ----------
        _arg: bool

        """
        return _ITKCommonBasePython.itkOutputWindow_SetPromptUser(self, _arg)

    def GetPromptUser(self):
        r"""GetPromptUser(self) -> bool"""
        return _ITKCommonBasePython.itkOutputWindow_GetPromptUser(self)

    def PromptUserOn(self):
        r"""PromptUserOn(self)"""
        return _ITKCommonBasePython.itkOutputWindow_PromptUserOn(self)

    def PromptUserOff(self):
        r"""PromptUserOff(self)"""
        return _ITKCommonBasePython.itkOutputWindow_PromptUserOff(self)
    __swig_destroy__ = _ITKCommonBasePython.delete_itkOutputWindow

    @staticmethod
    def cast(obj):
        r"""
        cast(obj) -> itkOutputWindow

        Parameters
        ----------
        obj: itkLightObject *

        """
        return _ITKCommonBasePython.itkOutputWindow_cast(obj)

    def New(*args, **kargs):
        """New() -> itkOutputWindow

        Create a new object of the class itkOutputWindow and set the input and the parameters if some
        named or non-named arguments are passed to that method.

        New() tries to assign all the non named parameters to the input of the new objects - the
        first non named parameter in the first input, etc.

        The named parameters are used by calling the method with the same name prefixed by 'Set'.

        Ex:

          itkOutputWindow.New(reader, threshold=10)

        is (most of the time) equivalent to:

          obj = itkOutputWindow.New()
          obj.SetInput(0, reader.GetOutput())
          obj.SetThreshold(10)
        """
        obj = itkOutputWindow.__New_orig__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkOutputWindow in _ITKCommonBasePython:
_ITKCommonBasePython.itkOutputWindow_swigregister(itkOutputWindow)
class itkProcessObject(itkObject):
    r"""Proxy of C++ itkProcessObject class."""

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

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

    def GetInputNames(self):
        r"""GetInputNames(self) -> vectorstring"""
        return _ITKCommonBasePython.itkProcessObject_GetInputNames(self)

    def GetRequiredInputNames(self):
        r"""GetRequiredInputNames(self) -> vectorstring"""
        return _ITKCommonBasePython.itkProcessObject_GetRequiredInputNames(self)

    def GetInputs(self):
        r"""GetInputs(self) -> vectoritkDataObject"""
        return _ITKCommonBasePython.itkProcessObject_GetInputs(self)

    def HasInput(self, key):
        r"""
        HasInput(self, key) -> bool

        Parameters
        ----------
        key: std::string const &

        """
        return _ITKCommonBasePython.itkProcessObject_HasInput(self, key)

    def GetNumberOfInputs(self):
        r"""GetNumberOfInputs(self) -> unsigned long"""
        return _ITKCommonBasePython.itkProcessObject_GetNumberOfInputs(self)

    def GetNumberOfOutputs(self):
        r"""GetNumberOfOutputs(self) -> unsigned long"""
        return _ITKCommonBasePython.itkProcessObject_GetNumberOfOutputs(self)

    def GetOutputNames(self):
        r"""GetOutputNames(self) -> vectorstring"""
        return _ITKCommonBasePython.itkProcessObject_GetOutputNames(self)

    def GetOutputs(self):
        r"""GetOutputs(self) -> vectoritkDataObject"""
        return _ITKCommonBasePython.itkProcessObject_GetOutputs(self)

    def HasOutput(self, key):
        r"""
        HasOutput(self, key) -> bool

        Parameters
        ----------
        key: std::string const &

        """
        return _ITKCommonBasePython.itkProcessObject_HasOutput(self, key)

    def GetIndexedInputs(self):
        r"""GetIndexedInputs(self) -> vectoritkDataObject"""
        return _ITKCommonBasePython.itkProcessObject_GetIndexedInputs(self)

    def GetNumberOfIndexedInputs(self):
        r"""GetNumberOfIndexedInputs(self) -> unsigned long"""
        return _ITKCommonBasePython.itkProcessObject_GetNumberOfIndexedInputs(self)

    def GetNumberOfValidRequiredInputs(self):
        r"""GetNumberOfValidRequiredInputs(self) -> unsigned long"""
        return _ITKCommonBasePython.itkProcessObject_GetNumberOfValidRequiredInputs(self)

    def GetIndexedOutputs(self):
        r"""GetIndexedOutputs(self) -> vectoritkDataObject"""
        return _ITKCommonBasePython.itkProcessObject_GetIndexedOutputs(self)

    def GetNumberOfIndexedOutputs(self):
        r"""GetNumberOfIndexedOutputs(self) -> unsigned long"""
        return _ITKCommonBasePython.itkProcessObject_GetNumberOfIndexedOutputs(self)

    def SetAbortGenerateData(self, _arg):
        r"""
        SetAbortGenerateData(self, _arg)

        Parameters
        ----------
        _arg: bool

        """
        return _ITKCommonBasePython.itkProcessObject_SetAbortGenerateData(self, _arg)

    def GetAbortGenerateData(self):
        r"""GetAbortGenerateData(self) -> bool const &"""
        return _ITKCommonBasePython.itkProcessObject_GetAbortGenerateData(self)

    def AbortGenerateDataOn(self):
        r"""AbortGenerateDataOn(self)"""
        return _ITKCommonBasePython.itkProcessObject_AbortGenerateDataOn(self)

    def AbortGenerateDataOff(self):
        r"""AbortGenerateDataOff(self)"""
        return _ITKCommonBasePython.itkProcessObject_AbortGenerateDataOff(self)

    def GetProgress(self):
        r"""GetProgress(self) -> float"""
        return _ITKCommonBasePython.itkProcessObject_GetProgress(self)

    def UpdateProgress(self, progress):
        r"""
        UpdateProgress(self, progress)

        Parameters
        ----------
        progress: float

        """
        return _ITKCommonBasePython.itkProcessObject_UpdateProgress(self, progress)

    def IncrementProgress(self, increment):
        r"""
        IncrementProgress(self, increment)

        Parameters
        ----------
        increment: float

        """
        return _ITKCommonBasePython.itkProcessObject_IncrementProgress(self, increment)

    def Update(self):
        r"""Update(self)"""
        return _ITKCommonBasePython.itkProcessObject_Update(self)

    def UpdateLargestPossibleRegion(self):
        r"""UpdateLargestPossibleRegion(self)"""
        return _ITKCommonBasePython.itkProcessObject_UpdateLargestPossibleRegion(self)

    def UpdateOutputInformation(self):
        r"""UpdateOutputInformation(self)"""
        return _ITKCommonBasePython.itkProcessObject_UpdateOutputInformation(self)

    def PropagateRequestedRegion(self, output):
        r"""
        PropagateRequestedRegion(self, output)

        Parameters
        ----------
        output: itkDataObject *

        """
        return _ITKCommonBasePython.itkProcessObject_PropagateRequestedRegion(self, output)

    def UpdateOutputData(self, output):
        r"""
        UpdateOutputData(self, output)

        Parameters
        ----------
        output: itkDataObject *

        """
        return _ITKCommonBasePython.itkProcessObject_UpdateOutputData(self, output)

    def EnlargeOutputRequestedRegion(self, arg0):
        r"""
        EnlargeOutputRequestedRegion(self, arg0)

        Parameters
        ----------
        arg0: itkDataObject *

        """
        return _ITKCommonBasePython.itkProcessObject_EnlargeOutputRequestedRegion(self, arg0)

    def ResetPipeline(self):
        r"""ResetPipeline(self)"""
        return _ITKCommonBasePython.itkProcessObject_ResetPipeline(self)

    def MakeOutput(self, *args):
        r"""
        MakeOutput(self, idx) -> itkDataObject_Pointer

        Parameters
        ----------
        idx: unsigned long

        MakeOutput(self, arg0) -> itkDataObject_Pointer

        Parameters
        ----------
        arg0: std::string const &

        """
        return _ITKCommonBasePython.itkProcessObject_MakeOutput(self, *args)

    def SetReleaseDataFlag(self, val):
        r"""
        SetReleaseDataFlag(self, val)

        Parameters
        ----------
        val: bool

        """
        return _ITKCommonBasePython.itkProcessObject_SetReleaseDataFlag(self, val)

    def GetReleaseDataFlag(self):
        r"""GetReleaseDataFlag(self) -> bool"""
        return _ITKCommonBasePython.itkProcessObject_GetReleaseDataFlag(self)

    def ReleaseDataFlagOn(self):
        r"""ReleaseDataFlagOn(self)"""
        return _ITKCommonBasePython.itkProcessObject_ReleaseDataFlagOn(self)

    def ReleaseDataFlagOff(self):
        r"""ReleaseDataFlagOff(self)"""
        return _ITKCommonBasePython.itkProcessObject_ReleaseDataFlagOff(self)

    def SetReleaseDataBeforeUpdateFlag(self, _arg):
        r"""
        SetReleaseDataBeforeUpdateFlag(self, _arg)

        Parameters
        ----------
        _arg: bool

        """
        return _ITKCommonBasePython.itkProcessObject_SetReleaseDataBeforeUpdateFlag(self, _arg)

    def GetReleaseDataBeforeUpdateFlag(self):
        r"""GetReleaseDataBeforeUpdateFlag(self) -> bool const &"""
        return _ITKCommonBasePython.itkProcessObject_GetReleaseDataBeforeUpdateFlag(self)

    def ReleaseDataBeforeUpdateFlagOn(self):
        r"""ReleaseDataBeforeUpdateFlagOn(self)"""
        return _ITKCommonBasePython.itkProcessObject_ReleaseDataBeforeUpdateFlagOn(self)

    def ReleaseDataBeforeUpdateFlagOff(self):
        r"""ReleaseDataBeforeUpdateFlagOff(self)"""
        return _ITKCommonBasePython.itkProcessObject_ReleaseDataBeforeUpdateFlagOff(self)

    def SetNumberOfWorkUnits(self, _arg):
        r"""
        SetNumberOfWorkUnits(self, _arg)

        Parameters
        ----------
        _arg: unsigned int

        """
        return _ITKCommonBasePython.itkProcessObject_SetNumberOfWorkUnits(self, _arg)

    def GetNumberOfWorkUnits(self):
        r"""GetNumberOfWorkUnits(self) -> unsigned int const &"""
        return _ITKCommonBasePython.itkProcessObject_GetNumberOfWorkUnits(self)

    def GetMultiThreader(self):
        r"""GetMultiThreader(self) -> itkMultiThreaderBase"""
        return _ITKCommonBasePython.itkProcessObject_GetMultiThreader(self)

    def SetMultiThreader(self, threader):
        r"""
        SetMultiThreader(self, threader)

        Parameters
        ----------
        threader: itkMultiThreaderBase *

        """
        return _ITKCommonBasePython.itkProcessObject_SetMultiThreader(self, threader)

    def PrepareOutputs(self):
        r"""PrepareOutputs(self)"""
        return _ITKCommonBasePython.itkProcessObject_PrepareOutputs(self)
    __swig_destroy__ = _ITKCommonBasePython.delete_itkProcessObject

    @staticmethod
    def cast(obj):
        r"""
        cast(obj) -> itkProcessObject

        Parameters
        ----------
        obj: itkLightObject *

        """
        return _ITKCommonBasePython.itkProcessObject_cast(obj)

    def __len__(self):
        """Returns the number of outputs of that object.
        """
        return self.GetNumberOfIndexedOutputs()

    def __getitem__(self, item):
        """Returns the outputs of that object.

        The outputs are casted to their real type.
        Several outputs may be returned by using the slice notation.
        """
        import itk
        if isinstance(item, slice):
            indices = item.indices(len(self))
            return [itk.down_cast(self.GetOutput(i)) for i in range(*indices)]
        else:
            return itk.down_cast(self.GetOutput(item))

    def __call__(self, *args, **kargs):
        """Deprecated procedural interface function.

        Use snake case function instead. This function is now
        merely a wrapper around the snake case function.

        Create a process object, update with the inputs and
        attributes, and return the result.

        The syntax is the same as the one used in New().
        UpdateLargestPossibleRegion() is ran once the input are changed, and
        the current output, or tuple of outputs, if there is more than
        one, is returned. Something like 'filter(input_image, threshold=10)[0]' would
        return the first up-to-date output of a filter with multiple
        outputs.
        """
        from itk.support import helpers
        import warnings

        name = self.GetNameOfClass()
        snake = helpers.camel_to_snake_case(name)

        warnings.warn("WrapITK warning: itk.%s() is deprecated for procedural"
        " interface. Use snake case function itk.%s() instead."
        % (name, snake), DeprecationWarning)

        filt = self.New(*args, **kargs)
        return filt.__internal_call__()


    def __internal_call__(self):
        """Create a process object, update with the inputs and
        attributes, and return the result.

        The syntax is the same as the one used in New().
        UpdateLargestPossibleRegion() is ran once the input are changed, and
        the current output, or tuple of outputs, if there is more than
        one, is returned. Something like 'filter(input_image, threshold=10)[0]' would
        return the first up-to-date output of a filter with multiple
        outputs.
        """
        self.UpdateLargestPossibleRegion()
        try:
            import itk
            if self.GetNumberOfIndexedOutputs() == 0:
                result = None
            elif self.GetNumberOfIndexedOutputs() == 1:
                result = itk.down_cast(self.GetOutput())
            else:
                result = tuple([itk.down_cast(self.GetOutput(idx)) for idx in range(self.GetNumberOfIndexedOutputs())])
            return result
        except AttributeError as e:
#In theory, filters should declare that they don't return any output
    # and therefore the `GetOutput()` method should not be called. However,
    # there is no garranty that this is always the case.
            print("This filter cannot be called functionally. Use Object call instead.")


# Register itkProcessObject in _ITKCommonBasePython:
_ITKCommonBasePython.itkProcessObject_swigregister(itkProcessObject)
class itkProgressReporter(object):
    r"""Proxy of C++ itkProgressReporter class."""

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

    def __init__(self, filter, threadId, numberOfPixels, numberOfUpdates=100, initialProgress=0., progressWeight=1.):
        r"""
        __init__(self, filter, threadId, numberOfPixels, numberOfUpdates=100, initialProgress=0., progressWeight=1.) -> itkProgressReporter

        Parameters
        ----------
        filter: itkProcessObject *
        threadId: unsigned int
        numberOfPixels: unsigned long
        numberOfUpdates: unsigned long
        initialProgress: float
        progressWeight: float

        """
        _ITKCommonBasePython.itkProgressReporter_swiginit(self, _ITKCommonBasePython.new_itkProgressReporter(filter, threadId, numberOfPixels, numberOfUpdates, initialProgress, progressWeight))
    __swig_destroy__ = _ITKCommonBasePython.delete_itkProgressReporter

    def CheckAbortGenerateData(self):
        r"""CheckAbortGenerateData(self)"""
        return _ITKCommonBasePython.itkProgressReporter_CheckAbortGenerateData(self)

    def CompletedPixel(self):
        r"""CompletedPixel(self)"""
        return _ITKCommonBasePython.itkProgressReporter_CompletedPixel(self)

# Register itkProgressReporter in _ITKCommonBasePython:
_ITKCommonBasePython.itkProgressReporter_swigregister(itkProgressReporter)
class itkRandomVariateGeneratorBase(itkObject):
    r"""Proxy of C++ itkRandomVariateGeneratorBase class."""

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

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

    def GetVariate(self):
        r"""GetVariate(self) -> double"""
        return _ITKCommonBasePython.itkRandomVariateGeneratorBase_GetVariate(self)
    __swig_destroy__ = _ITKCommonBasePython.delete_itkRandomVariateGeneratorBase

    @staticmethod
    def cast(obj):
        r"""
        cast(obj) -> itkRandomVariateGeneratorBase

        Parameters
        ----------
        obj: itkLightObject *

        """
        return _ITKCommonBasePython.itkRandomVariateGeneratorBase_cast(obj)

# Register itkRandomVariateGeneratorBase in _ITKCommonBasePython:
_ITKCommonBasePython.itkRandomVariateGeneratorBase_swigregister(itkRandomVariateGeneratorBase)

def itkRealTimeClock_New():
    return itkRealTimeClock.New()

class itkRealTimeClock(itkObject):
    r"""Proxy of C++ itkRealTimeClock class."""

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

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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkRealTimeClock_Pointer"""
        return _ITKCommonBasePython.itkRealTimeClock___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkRealTimeClock_Pointer"""
        return _ITKCommonBasePython.itkRealTimeClock_Clone(self)

    def GetTimeInSeconds(self):
        r"""GetTimeInSeconds(self) -> double"""
        return _ITKCommonBasePython.itkRealTimeClock_GetTimeInSeconds(self)

    def GetFrequency(self):
        r"""GetFrequency(self) -> double"""
        return _ITKCommonBasePython.itkRealTimeClock_GetFrequency(self)

    def GetRealTimeStamp(self):
        r"""GetRealTimeStamp(self) -> itkRealTimeStamp"""
        return _ITKCommonBasePython.itkRealTimeClock_GetRealTimeStamp(self)
    __swig_destroy__ = _ITKCommonBasePython.delete_itkRealTimeClock

    @staticmethod
    def cast(obj):
        r"""
        cast(obj) -> itkRealTimeClock

        Parameters
        ----------
        obj: itkLightObject *

        """
        return _ITKCommonBasePython.itkRealTimeClock_cast(obj)

    def New(*args, **kargs):
        """New() -> itkRealTimeClock

        Create a new object of the class itkRealTimeClock and set the input and the parameters if some
        named or non-named arguments are passed to that method.

        New() tries to assign all the non named parameters to the input of the new objects - the
        first non named parameter in the first input, etc.

        The named parameters are used by calling the method with the same name prefixed by 'Set'.

        Ex:

          itkRealTimeClock.New(reader, threshold=10)

        is (most of the time) equivalent to:

          obj = itkRealTimeClock.New()
          obj.SetInput(0, reader.GetOutput())
          obj.SetThreshold(10)
        """
        obj = itkRealTimeClock.__New_orig__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkRealTimeClock in _ITKCommonBasePython:
_ITKCommonBasePython.itkRealTimeClock_swigregister(itkRealTimeClock)
class itkRealTimeInterval(object):
    r"""Proxy of C++ itkRealTimeInterval class."""

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

    def GetTimeInMicroSeconds(self):
        r"""GetTimeInMicroSeconds(self) -> double"""
        return _ITKCommonBasePython.itkRealTimeInterval_GetTimeInMicroSeconds(self)

    def GetTimeInMilliSeconds(self):
        r"""GetTimeInMilliSeconds(self) -> double"""
        return _ITKCommonBasePython.itkRealTimeInterval_GetTimeInMilliSeconds(self)

    def GetTimeInSeconds(self):
        r"""GetTimeInSeconds(self) -> double"""
        return _ITKCommonBasePython.itkRealTimeInterval_GetTimeInSeconds(self)

    def GetTimeInMinutes(self):
        r"""GetTimeInMinutes(self) -> double"""
        return _ITKCommonBasePython.itkRealTimeInterval_GetTimeInMinutes(self)

    def GetTimeInHours(self):
        r"""GetTimeInHours(self) -> double"""
        return _ITKCommonBasePython.itkRealTimeInterval_GetTimeInHours(self)

    def GetTimeInDays(self):
        r"""GetTimeInDays(self) -> double"""
        return _ITKCommonBasePython.itkRealTimeInterval_GetTimeInDays(self)

    def __sub__(self, arg0):
        r"""
        __sub__(self, arg0) -> itkRealTimeInterval

        Parameters
        ----------
        arg0: itkRealTimeInterval const &

        """
        return _ITKCommonBasePython.itkRealTimeInterval___sub__(self, arg0)

    def __add__(self, arg0):
        r"""
        __add__(self, arg0) -> itkRealTimeInterval

        Parameters
        ----------
        arg0: itkRealTimeInterval const &

        """
        return _ITKCommonBasePython.itkRealTimeInterval___add__(self, arg0)

    def __isub__(self, arg0):
        r"""
        __isub__(self, arg0) -> itkRealTimeInterval

        Parameters
        ----------
        arg0: itkRealTimeInterval const &

        """
        return _ITKCommonBasePython.itkRealTimeInterval___isub__(self, arg0)

    def __iadd__(self, arg0):
        r"""
        __iadd__(self, arg0) -> itkRealTimeInterval

        Parameters
        ----------
        arg0: itkRealTimeInterval const &

        """
        return _ITKCommonBasePython.itkRealTimeInterval___iadd__(self, arg0)

    def __gt__(self, arg0):
        r"""
        __gt__(self, arg0) -> bool

        Parameters
        ----------
        arg0: itkRealTimeInterval const &

        """
        return _ITKCommonBasePython.itkRealTimeInterval___gt__(self, arg0)

    def __lt__(self, arg0):
        r"""
        __lt__(self, arg0) -> bool

        Parameters
        ----------
        arg0: itkRealTimeInterval const &

        """
        return _ITKCommonBasePython.itkRealTimeInterval___lt__(self, arg0)

    def __eq__(self, arg0):
        r"""
        __eq__(self, arg0) -> bool

        Parameters
        ----------
        arg0: itkRealTimeInterval const &

        """
        return _ITKCommonBasePython.itkRealTimeInterval___eq__(self, arg0)

    def __ne__(self, other):
        r"""
        __ne__(self, other) -> bool

        Parameters
        ----------
        other: itkRealTimeInterval const &

        """
        return _ITKCommonBasePython.itkRealTimeInterval___ne__(self, other)

    def __le__(self, arg0):
        r"""
        __le__(self, arg0) -> bool

        Parameters
        ----------
        arg0: itkRealTimeInterval const &

        """
        return _ITKCommonBasePython.itkRealTimeInterval___le__(self, arg0)

    def __ge__(self, arg0):
        r"""
        __ge__(self, arg0) -> bool

        Parameters
        ----------
        arg0: itkRealTimeInterval const &

        """
        return _ITKCommonBasePython.itkRealTimeInterval___ge__(self, arg0)

    def Set(self, arg0, arg1):
        r"""
        Set(self, arg0, arg1)

        Parameters
        ----------
        arg0: long long
        arg1: long long

        """
        return _ITKCommonBasePython.itkRealTimeInterval_Set(self, arg0, arg1)

    def __init__(self, *args):
        r"""
        __init__(self) -> itkRealTimeInterval
        __init__(self, arg0, arg1) -> itkRealTimeInterval

        Parameters
        ----------
        arg0: long long
        arg1: long long

        __init__(self, arg0) -> itkRealTimeInterval

        Parameters
        ----------
        arg0: itkRealTimeInterval const &

        """
        _ITKCommonBasePython.itkRealTimeInterval_swiginit(self, _ITKCommonBasePython.new_itkRealTimeInterval(*args))

# Register itkRealTimeInterval in _ITKCommonBasePython:
_ITKCommonBasePython.itkRealTimeInterval_swigregister(itkRealTimeInterval)
class itkRealTimeStamp(object):
    r"""Proxy of C++ itkRealTimeStamp class."""

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

    def __init__(self, *args):
        r"""
        __init__(self, arg0) -> itkRealTimeStamp

        Parameters
        ----------
        arg0: itkRealTimeStamp const &

        __init__(self) -> itkRealTimeStamp
        """
        _ITKCommonBasePython.itkRealTimeStamp_swiginit(self, _ITKCommonBasePython.new_itkRealTimeStamp(*args))
    __swig_destroy__ = _ITKCommonBasePython.delete_itkRealTimeStamp

    def GetTimeInMicroSeconds(self):
        r"""GetTimeInMicroSeconds(self) -> double"""
        return _ITKCommonBasePython.itkRealTimeStamp_GetTimeInMicroSeconds(self)

    def GetTimeInMilliSeconds(self):
        r"""GetTimeInMilliSeconds(self) -> double"""
        return _ITKCommonBasePython.itkRealTimeStamp_GetTimeInMilliSeconds(self)

    def GetTimeInSeconds(self):
        r"""GetTimeInSeconds(self) -> double"""
        return _ITKCommonBasePython.itkRealTimeStamp_GetTimeInSeconds(self)

    def GetTimeInMinutes(self):
        r"""GetTimeInMinutes(self) -> double"""
        return _ITKCommonBasePython.itkRealTimeStamp_GetTimeInMinutes(self)

    def GetTimeInHours(self):
        r"""GetTimeInHours(self) -> double"""
        return _ITKCommonBasePython.itkRealTimeStamp_GetTimeInHours(self)

    def GetTimeInDays(self):
        r"""GetTimeInDays(self) -> double"""
        return _ITKCommonBasePython.itkRealTimeStamp_GetTimeInDays(self)

    def __add__(self, arg0):
        r"""
        __add__(self, arg0) -> itkRealTimeStamp

        Parameters
        ----------
        arg0: itkRealTimeInterval const &

        """
        return _ITKCommonBasePython.itkRealTimeStamp___add__(self, arg0)

    def __sub__(self, *args):
        r"""
        __sub__(self, arg0) -> itkRealTimeInterval

        Parameters
        ----------
        arg0: itkRealTimeStamp const &

        __sub__(self, arg0) -> itkRealTimeStamp

        Parameters
        ----------
        arg0: itkRealTimeInterval const &

        """
        return _ITKCommonBasePython.itkRealTimeStamp___sub__(self, *args)

    def __iadd__(self, arg0):
        r"""
        __iadd__(self, arg0) -> itkRealTimeStamp

        Parameters
        ----------
        arg0: itkRealTimeInterval const &

        """
        return _ITKCommonBasePython.itkRealTimeStamp___iadd__(self, arg0)

    def __isub__(self, arg0):
        r"""
        __isub__(self, arg0) -> itkRealTimeStamp

        Parameters
        ----------
        arg0: itkRealTimeInterval const &

        """
        return _ITKCommonBasePython.itkRealTimeStamp___isub__(self, arg0)

    def __gt__(self, arg0):
        r"""
        __gt__(self, arg0) -> bool

        Parameters
        ----------
        arg0: itkRealTimeStamp const &

        """
        return _ITKCommonBasePython.itkRealTimeStamp___gt__(self, arg0)

    def __lt__(self, arg0):
        r"""
        __lt__(self, arg0) -> bool

        Parameters
        ----------
        arg0: itkRealTimeStamp const &

        """
        return _ITKCommonBasePython.itkRealTimeStamp___lt__(self, arg0)

    def __eq__(self, arg0):
        r"""
        __eq__(self, arg0) -> bool

        Parameters
        ----------
        arg0: itkRealTimeStamp const &

        """
        return _ITKCommonBasePython.itkRealTimeStamp___eq__(self, arg0)

    def __ne__(self, other):
        r"""
        __ne__(self, other) -> bool

        Parameters
        ----------
        other: itkRealTimeStamp const &

        """
        return _ITKCommonBasePython.itkRealTimeStamp___ne__(self, other)

    def __le__(self, arg0):
        r"""
        __le__(self, arg0) -> bool

        Parameters
        ----------
        arg0: itkRealTimeStamp const &

        """
        return _ITKCommonBasePython.itkRealTimeStamp___le__(self, arg0)

    def __ge__(self, arg0):
        r"""
        __ge__(self, arg0) -> bool

        Parameters
        ----------
        arg0: itkRealTimeStamp const &

        """
        return _ITKCommonBasePython.itkRealTimeStamp___ge__(self, arg0)

# Register itkRealTimeStamp in _ITKCommonBasePython:
_ITKCommonBasePython.itkRealTimeStamp_swigregister(itkRealTimeStamp)
class itkRegion(object):
    r"""Proxy of C++ itkRegion class."""

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

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

    def GetNameOfClass(self):
        r"""GetNameOfClass(self) -> char const *"""
        return _ITKCommonBasePython.itkRegion_GetNameOfClass(self)

    def GetRegionType(self):
        r"""GetRegionType(self) -> itkObjectEnums::RegionEnum"""
        return _ITKCommonBasePython.itkRegion_GetRegionType(self)

    def Print(self, os, indent=0):
        r"""
        Print(self, os, indent=0)

        Parameters
        ----------
        os: std::basic_ostream< char,std::char_traits< char > > &
        indent: itkIndent

        """
        return _ITKCommonBasePython.itkRegion_Print(self, os, indent)
    __swig_destroy__ = _ITKCommonBasePython.delete_itkRegion

# Register itkRegion in _ITKCommonBasePython:
_ITKCommonBasePython.itkRegion_swigregister(itkRegion)
class itkResourceProbeDD(object):
    r"""Proxy of C++ itkResourceProbeDD class."""

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

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

    def GetType(self):
        r"""GetType(self) -> std::string"""
        return _ITKCommonBasePython.itkResourceProbeDD_GetType(self)

    def GetUnit(self):
        r"""GetUnit(self) -> std::string"""
        return _ITKCommonBasePython.itkResourceProbeDD_GetUnit(self)

    def Start(self):
        r"""Start(self)"""
        return _ITKCommonBasePython.itkResourceProbeDD_Start(self)

    def Stop(self):
        r"""Stop(self)"""
        return _ITKCommonBasePython.itkResourceProbeDD_Stop(self)

    def GetNumberOfStarts(self):
        r"""GetNumberOfStarts(self) -> unsigned long"""
        return _ITKCommonBasePython.itkResourceProbeDD_GetNumberOfStarts(self)

    def GetNumberOfStops(self):
        r"""GetNumberOfStops(self) -> unsigned long"""
        return _ITKCommonBasePython.itkResourceProbeDD_GetNumberOfStops(self)

    def GetNumberOfIteration(self):
        r"""GetNumberOfIteration(self) -> unsigned long"""
        return _ITKCommonBasePython.itkResourceProbeDD_GetNumberOfIteration(self)

    def GetInstantValue(self):
        r"""GetInstantValue(self) -> double"""
        return _ITKCommonBasePython.itkResourceProbeDD_GetInstantValue(self)

    def GetTotal(self):
        r"""GetTotal(self) -> double"""
        return _ITKCommonBasePython.itkResourceProbeDD_GetTotal(self)

    def GetMean(self):
        r"""GetMean(self) -> double"""
        return _ITKCommonBasePython.itkResourceProbeDD_GetMean(self)

    def Reset(self):
        r"""Reset(self)"""
        return _ITKCommonBasePython.itkResourceProbeDD_Reset(self)

    def GetMinimum(self):
        r"""GetMinimum(self) -> double"""
        return _ITKCommonBasePython.itkResourceProbeDD_GetMinimum(self)

    def GetMaximum(self):
        r"""GetMaximum(self) -> double"""
        return _ITKCommonBasePython.itkResourceProbeDD_GetMaximum(self)

    def GetStandardDeviation(self):
        r"""GetStandardDeviation(self) -> double"""
        return _ITKCommonBasePython.itkResourceProbeDD_GetStandardDeviation(self)

    def GetStandardError(self):
        r"""GetStandardError(self) -> double"""
        return _ITKCommonBasePython.itkResourceProbeDD_GetStandardError(self)

    def SetNameOfProbe(self, nameOfProbe):
        r"""
        SetNameOfProbe(self, nameOfProbe)

        Parameters
        ----------
        nameOfProbe: char const *

        """
        return _ITKCommonBasePython.itkResourceProbeDD_SetNameOfProbe(self, nameOfProbe)

    def GetNameOfProbe(self):
        r"""GetNameOfProbe(self) -> std::string"""
        return _ITKCommonBasePython.itkResourceProbeDD_GetNameOfProbe(self)

    def PrintSystemInformation(self, *args):
        r"""
        PrintSystemInformation(self, os=cout)

        Parameters
        ----------
        os: std::basic_ostream< char,std::char_traits< char > > &

        """
        return _ITKCommonBasePython.itkResourceProbeDD_PrintSystemInformation(self, *args)

    def Report(self, *args):
        r"""
        Report(self, os=cout, printSystemInfo=True, printReportHead=True, useTabs=False)

        Parameters
        ----------
        os: std::basic_ostream< char,std::char_traits< char > > &
        printSystemInfo: bool
        printReportHead: bool
        useTabs: bool

        """
        return _ITKCommonBasePython.itkResourceProbeDD_Report(self, *args)

    def ExpandedReport(self, *args):
        r"""
        ExpandedReport(self, os=cout, printSystemInfo=True, printReportHead=True, useTabs=False)

        Parameters
        ----------
        os: std::basic_ostream< char,std::char_traits< char > > &
        printSystemInfo: bool
        printReportHead: bool
        useTabs: bool

        """
        return _ITKCommonBasePython.itkResourceProbeDD_ExpandedReport(self, *args)

    def JSONReport(self, *args):
        r"""
        JSONReport(self, os=cout)

        Parameters
        ----------
        os: std::basic_ostream< char,std::char_traits< char > > &

        """
        return _ITKCommonBasePython.itkResourceProbeDD_JSONReport(self, *args)

    def PrintJSONSystemInformation(self, *args):
        r"""
        PrintJSONSystemInformation(self, os=cout)

        Parameters
        ----------
        os: std::basic_ostream< char,std::char_traits< char > > &

        """
        return _ITKCommonBasePython.itkResourceProbeDD_PrintJSONSystemInformation(self, *args)

# Register itkResourceProbeDD in _ITKCommonBasePython:
_ITKCommonBasePython.itkResourceProbeDD_swigregister(itkResourceProbeDD)
class itkSimpleFilterWatcher(object):
    r"""Proxy of C++ itkSimpleFilterWatcher class."""

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

    def __init__(self, *args):
        r"""
        __init__(self, o, comment="") -> itkSimpleFilterWatcher

        Parameters
        ----------
        o: itkProcessObject *
        comment: char const *

        __init__(self, arg0) -> itkSimpleFilterWatcher

        Parameters
        ----------
        arg0: itkSimpleFilterWatcher const &

        __init__(self) -> itkSimpleFilterWatcher
        """
        _ITKCommonBasePython.itkSimpleFilterWatcher_swiginit(self, _ITKCommonBasePython.new_itkSimpleFilterWatcher(*args))
    __swig_destroy__ = _ITKCommonBasePython.delete_itkSimpleFilterWatcher

    def GetNameOfClass(self):
        r"""GetNameOfClass(self) -> char const *"""
        return _ITKCommonBasePython.itkSimpleFilterWatcher_GetNameOfClass(self)

    def QuietOn(self):
        r"""QuietOn(self)"""
        return _ITKCommonBasePython.itkSimpleFilterWatcher_QuietOn(self)

    def QuietOff(self):
        r"""QuietOff(self)"""
        return _ITKCommonBasePython.itkSimpleFilterWatcher_QuietOff(self)

    def TestAbortOn(self):
        r"""TestAbortOn(self)"""
        return _ITKCommonBasePython.itkSimpleFilterWatcher_TestAbortOn(self)

    def TestAbortOff(self):
        r"""TestAbortOff(self)"""
        return _ITKCommonBasePython.itkSimpleFilterWatcher_TestAbortOff(self)

    def GetProcess(self):
        r"""GetProcess(self) -> itkProcessObject"""
        return _ITKCommonBasePython.itkSimpleFilterWatcher_GetProcess(self)

    def SetSteps(self, val):
        r"""
        SetSteps(self, val)

        Parameters
        ----------
        val: int

        """
        return _ITKCommonBasePython.itkSimpleFilterWatcher_SetSteps(self, val)

    def GetSteps(self):
        r"""GetSteps(self) -> int"""
        return _ITKCommonBasePython.itkSimpleFilterWatcher_GetSteps(self)

    def SetIterations(self, val):
        r"""
        SetIterations(self, val)

        Parameters
        ----------
        val: int

        """
        return _ITKCommonBasePython.itkSimpleFilterWatcher_SetIterations(self, val)

    def GetIterations(self):
        r"""GetIterations(self) -> int"""
        return _ITKCommonBasePython.itkSimpleFilterWatcher_GetIterations(self)

    def SetQuiet(self, val):
        r"""
        SetQuiet(self, val)

        Parameters
        ----------
        val: bool

        """
        return _ITKCommonBasePython.itkSimpleFilterWatcher_SetQuiet(self, val)

    def GetQuiet(self):
        r"""GetQuiet(self) -> bool"""
        return _ITKCommonBasePython.itkSimpleFilterWatcher_GetQuiet(self)

    def GetComment(self):
        r"""GetComment(self) -> std::string"""
        return _ITKCommonBasePython.itkSimpleFilterWatcher_GetComment(self)

    def GetTimeProbe(self):
        r"""GetTimeProbe(self) -> itkTimeProbe"""
        return _ITKCommonBasePython.itkSimpleFilterWatcher_GetTimeProbe(self)

# Register itkSimpleFilterWatcher in _ITKCommonBasePython:
_ITKCommonBasePython.itkSimpleFilterWatcher_swigregister(itkSimpleFilterWatcher)
class itkSpatialOrientationAdapter(object):
    r"""Proxy of C++ itkSpatialOrientationAdapter class."""

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

    def FromDirectionCosines(self, Dir):
        r"""
        FromDirectionCosines(self, Dir) -> itkSpatialOrientationEnums::ValidCoordinateOrientations

        Parameters
        ----------
        Dir: itkMatrixD33 const &

        """
        return _ITKCommonBasePython.itkSpatialOrientationAdapter_FromDirectionCosines(self, Dir)

    def ToDirectionCosines(self, Or):
        r"""
        ToDirectionCosines(self, Or) -> itkMatrixD33

        Parameters
        ----------
        Or: itkSpatialOrientationEnums::ValidCoordinateOrientations const &

        """
        return _ITKCommonBasePython.itkSpatialOrientationAdapter_ToDirectionCosines(self, Or)

    def __init__(self, *args):
        r"""
        __init__(self) -> itkSpatialOrientationAdapter
        __init__(self, arg0) -> itkSpatialOrientationAdapter

        Parameters
        ----------
        arg0: itkSpatialOrientationAdapter const &

        """
        _ITKCommonBasePython.itkSpatialOrientationAdapter_swiginit(self, _ITKCommonBasePython.new_itkSpatialOrientationAdapter(*args))
    __swig_destroy__ = _ITKCommonBasePython.delete_itkSpatialOrientationAdapter

# Register itkSpatialOrientationAdapter in _ITKCommonBasePython:
_ITKCommonBasePython.itkSpatialOrientationAdapter_swigregister(itkSpatialOrientationAdapter)
class itkSpatialOrientationEnums(object):
    r"""Proxy of C++ itkSpatialOrientationEnums class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    CoordinateTerms_ITK_COORDINATE_UNKNOWN = _ITKCommonBasePython.itkSpatialOrientationEnums_CoordinateTerms_ITK_COORDINATE_UNKNOWN
    
    CoordinateTerms_ITK_COORDINATE_Right = _ITKCommonBasePython.itkSpatialOrientationEnums_CoordinateTerms_ITK_COORDINATE_Right
    
    CoordinateTerms_ITK_COORDINATE_Left = _ITKCommonBasePython.itkSpatialOrientationEnums_CoordinateTerms_ITK_COORDINATE_Left
    
    CoordinateTerms_ITK_COORDINATE_Posterior = _ITKCommonBasePython.itkSpatialOrientationEnums_CoordinateTerms_ITK_COORDINATE_Posterior
    
    CoordinateTerms_ITK_COORDINATE_Anterior = _ITKCommonBasePython.itkSpatialOrientationEnums_CoordinateTerms_ITK_COORDINATE_Anterior
    
    CoordinateTerms_ITK_COORDINATE_Inferior = _ITKCommonBasePython.itkSpatialOrientationEnums_CoordinateTerms_ITK_COORDINATE_Inferior
    
    CoordinateTerms_ITK_COORDINATE_Superior = _ITKCommonBasePython.itkSpatialOrientationEnums_CoordinateTerms_ITK_COORDINATE_Superior
    
    CoordinateMajornessTerms_ITK_COORDINATE_PrimaryMinor = _ITKCommonBasePython.itkSpatialOrientationEnums_CoordinateMajornessTerms_ITK_COORDINATE_PrimaryMinor
    
    CoordinateMajornessTerms_ITK_COORDINATE_SecondaryMinor = _ITKCommonBasePython.itkSpatialOrientationEnums_CoordinateMajornessTerms_ITK_COORDINATE_SecondaryMinor
    
    CoordinateMajornessTerms_ITK_COORDINATE_TertiaryMinor = _ITKCommonBasePython.itkSpatialOrientationEnums_CoordinateMajornessTerms_ITK_COORDINATE_TertiaryMinor
    
    ValidCoordinateOrientations_ITK_COORDINATE_ORIENTATION_INVALID = _ITKCommonBasePython.itkSpatialOrientationEnums_ValidCoordinateOrientations_ITK_COORDINATE_ORIENTATION_INVALID
    
    ValidCoordinateOrientations_ITK_COORDINATE_ORIENTATION_RIP = _ITKCommonBasePython.itkSpatialOrientationEnums_ValidCoordinateOrientations_ITK_COORDINATE_ORIENTATION_RIP
    
    ValidCoordinateOrientations_ITK_COORDINATE_ORIENTATION_LIP = _ITKCommonBasePython.itkSpatialOrientationEnums_ValidCoordinateOrientations_ITK_COORDINATE_ORIENTATION_LIP
    
    ValidCoordinateOrientations_ITK_COORDINATE_ORIENTATION_RSP = _ITKCommonBasePython.itkSpatialOrientationEnums_ValidCoordinateOrientations_ITK_COORDINATE_ORIENTATION_RSP
    
    ValidCoordinateOrientations_ITK_COORDINATE_ORIENTATION_LSP = _ITKCommonBasePython.itkSpatialOrientationEnums_ValidCoordinateOrientations_ITK_COORDINATE_ORIENTATION_LSP
    
    ValidCoordinateOrientations_ITK_COORDINATE_ORIENTATION_RIA = _ITKCommonBasePython.itkSpatialOrientationEnums_ValidCoordinateOrientations_ITK_COORDINATE_ORIENTATION_RIA
    
    ValidCoordinateOrientations_ITK_COORDINATE_ORIENTATION_LIA = _ITKCommonBasePython.itkSpatialOrientationEnums_ValidCoordinateOrientations_ITK_COORDINATE_ORIENTATION_LIA
    
    ValidCoordinateOrientations_ITK_COORDINATE_ORIENTATION_RSA = _ITKCommonBasePython.itkSpatialOrientationEnums_ValidCoordinateOrientations_ITK_COORDINATE_ORIENTATION_RSA
    
    ValidCoordinateOrientations_ITK_COORDINATE_ORIENTATION_LSA = _ITKCommonBasePython.itkSpatialOrientationEnums_ValidCoordinateOrientations_ITK_COORDINATE_ORIENTATION_LSA
    
    ValidCoordinateOrientations_ITK_COORDINATE_ORIENTATION_IRP = _ITKCommonBasePython.itkSpatialOrientationEnums_ValidCoordinateOrientations_ITK_COORDINATE_ORIENTATION_IRP
    
    ValidCoordinateOrientations_ITK_COORDINATE_ORIENTATION_ILP = _ITKCommonBasePython.itkSpatialOrientationEnums_ValidCoordinateOrientations_ITK_COORDINATE_ORIENTATION_ILP
    
    ValidCoordinateOrientations_ITK_COORDINATE_ORIENTATION_SRP = _ITKCommonBasePython.itkSpatialOrientationEnums_ValidCoordinateOrientations_ITK_COORDINATE_ORIENTATION_SRP
    
    ValidCoordinateOrientations_ITK_COORDINATE_ORIENTATION_SLP = _ITKCommonBasePython.itkSpatialOrientationEnums_ValidCoordinateOrientations_ITK_COORDINATE_ORIENTATION_SLP
    
    ValidCoordinateOrientations_ITK_COORDINATE_ORIENTATION_IRA = _ITKCommonBasePython.itkSpatialOrientationEnums_ValidCoordinateOrientations_ITK_COORDINATE_ORIENTATION_IRA
    
    ValidCoordinateOrientations_ITK_COORDINATE_ORIENTATION_ILA = _ITKCommonBasePython.itkSpatialOrientationEnums_ValidCoordinateOrientations_ITK_COORDINATE_ORIENTATION_ILA
    
    ValidCoordinateOrientations_ITK_COORDINATE_ORIENTATION_SRA = _ITKCommonBasePython.itkSpatialOrientationEnums_ValidCoordinateOrientations_ITK_COORDINATE_ORIENTATION_SRA
    
    ValidCoordinateOrientations_ITK_COORDINATE_ORIENTATION_SLA = _ITKCommonBasePython.itkSpatialOrientationEnums_ValidCoordinateOrientations_ITK_COORDINATE_ORIENTATION_SLA
    
    ValidCoordinateOrientations_ITK_COORDINATE_ORIENTATION_RPI = _ITKCommonBasePython.itkSpatialOrientationEnums_ValidCoordinateOrientations_ITK_COORDINATE_ORIENTATION_RPI
    
    ValidCoordinateOrientations_ITK_COORDINATE_ORIENTATION_LPI = _ITKCommonBasePython.itkSpatialOrientationEnums_ValidCoordinateOrientations_ITK_COORDINATE_ORIENTATION_LPI
    
    ValidCoordinateOrientations_ITK_COORDINATE_ORIENTATION_RAI = _ITKCommonBasePython.itkSpatialOrientationEnums_ValidCoordinateOrientations_ITK_COORDINATE_ORIENTATION_RAI
    
    ValidCoordinateOrientations_ITK_COORDINATE_ORIENTATION_LAI = _ITKCommonBasePython.itkSpatialOrientationEnums_ValidCoordinateOrientations_ITK_COORDINATE_ORIENTATION_LAI
    
    ValidCoordinateOrientations_ITK_COORDINATE_ORIENTATION_RPS = _ITKCommonBasePython.itkSpatialOrientationEnums_ValidCoordinateOrientations_ITK_COORDINATE_ORIENTATION_RPS
    
    ValidCoordinateOrientations_ITK_COORDINATE_ORIENTATION_LPS = _ITKCommonBasePython.itkSpatialOrientationEnums_ValidCoordinateOrientations_ITK_COORDINATE_ORIENTATION_LPS
    
    ValidCoordinateOrientations_ITK_COORDINATE_ORIENTATION_RAS = _ITKCommonBasePython.itkSpatialOrientationEnums_ValidCoordinateOrientations_ITK_COORDINATE_ORIENTATION_RAS
    
    ValidCoordinateOrientations_ITK_COORDINATE_ORIENTATION_LAS = _ITKCommonBasePython.itkSpatialOrientationEnums_ValidCoordinateOrientations_ITK_COORDINATE_ORIENTATION_LAS
    
    ValidCoordinateOrientations_ITK_COORDINATE_ORIENTATION_PRI = _ITKCommonBasePython.itkSpatialOrientationEnums_ValidCoordinateOrientations_ITK_COORDINATE_ORIENTATION_PRI
    
    ValidCoordinateOrientations_ITK_COORDINATE_ORIENTATION_PLI = _ITKCommonBasePython.itkSpatialOrientationEnums_ValidCoordinateOrientations_ITK_COORDINATE_ORIENTATION_PLI
    
    ValidCoordinateOrientations_ITK_COORDINATE_ORIENTATION_ARI = _ITKCommonBasePython.itkSpatialOrientationEnums_ValidCoordinateOrientations_ITK_COORDINATE_ORIENTATION_ARI
    
    ValidCoordinateOrientations_ITK_COORDINATE_ORIENTATION_ALI = _ITKCommonBasePython.itkSpatialOrientationEnums_ValidCoordinateOrientations_ITK_COORDINATE_ORIENTATION_ALI
    
    ValidCoordinateOrientations_ITK_COORDINATE_ORIENTATION_PRS = _ITKCommonBasePython.itkSpatialOrientationEnums_ValidCoordinateOrientations_ITK_COORDINATE_ORIENTATION_PRS
    
    ValidCoordinateOrientations_ITK_COORDINATE_ORIENTATION_PLS = _ITKCommonBasePython.itkSpatialOrientationEnums_ValidCoordinateOrientations_ITK_COORDINATE_ORIENTATION_PLS
    
    ValidCoordinateOrientations_ITK_COORDINATE_ORIENTATION_ARS = _ITKCommonBasePython.itkSpatialOrientationEnums_ValidCoordinateOrientations_ITK_COORDINATE_ORIENTATION_ARS
    
    ValidCoordinateOrientations_ITK_COORDINATE_ORIENTATION_ALS = _ITKCommonBasePython.itkSpatialOrientationEnums_ValidCoordinateOrientations_ITK_COORDINATE_ORIENTATION_ALS
    
    ValidCoordinateOrientations_ITK_COORDINATE_ORIENTATION_IPR = _ITKCommonBasePython.itkSpatialOrientationEnums_ValidCoordinateOrientations_ITK_COORDINATE_ORIENTATION_IPR
    
    ValidCoordinateOrientations_ITK_COORDINATE_ORIENTATION_SPR = _ITKCommonBasePython.itkSpatialOrientationEnums_ValidCoordinateOrientations_ITK_COORDINATE_ORIENTATION_SPR
    
    ValidCoordinateOrientations_ITK_COORDINATE_ORIENTATION_IAR = _ITKCommonBasePython.itkSpatialOrientationEnums_ValidCoordinateOrientations_ITK_COORDINATE_ORIENTATION_IAR
    
    ValidCoordinateOrientations_ITK_COORDINATE_ORIENTATION_SAR = _ITKCommonBasePython.itkSpatialOrientationEnums_ValidCoordinateOrientations_ITK_COORDINATE_ORIENTATION_SAR
    
    ValidCoordinateOrientations_ITK_COORDINATE_ORIENTATION_IPL = _ITKCommonBasePython.itkSpatialOrientationEnums_ValidCoordinateOrientations_ITK_COORDINATE_ORIENTATION_IPL
    
    ValidCoordinateOrientations_ITK_COORDINATE_ORIENTATION_SPL = _ITKCommonBasePython.itkSpatialOrientationEnums_ValidCoordinateOrientations_ITK_COORDINATE_ORIENTATION_SPL
    
    ValidCoordinateOrientations_ITK_COORDINATE_ORIENTATION_IAL = _ITKCommonBasePython.itkSpatialOrientationEnums_ValidCoordinateOrientations_ITK_COORDINATE_ORIENTATION_IAL
    
    ValidCoordinateOrientations_ITK_COORDINATE_ORIENTATION_SAL = _ITKCommonBasePython.itkSpatialOrientationEnums_ValidCoordinateOrientations_ITK_COORDINATE_ORIENTATION_SAL
    
    ValidCoordinateOrientations_ITK_COORDINATE_ORIENTATION_PIR = _ITKCommonBasePython.itkSpatialOrientationEnums_ValidCoordinateOrientations_ITK_COORDINATE_ORIENTATION_PIR
    
    ValidCoordinateOrientations_ITK_COORDINATE_ORIENTATION_PSR = _ITKCommonBasePython.itkSpatialOrientationEnums_ValidCoordinateOrientations_ITK_COORDINATE_ORIENTATION_PSR
    
    ValidCoordinateOrientations_ITK_COORDINATE_ORIENTATION_AIR = _ITKCommonBasePython.itkSpatialOrientationEnums_ValidCoordinateOrientations_ITK_COORDINATE_ORIENTATION_AIR
    
    ValidCoordinateOrientations_ITK_COORDINATE_ORIENTATION_ASR = _ITKCommonBasePython.itkSpatialOrientationEnums_ValidCoordinateOrientations_ITK_COORDINATE_ORIENTATION_ASR
    
    ValidCoordinateOrientations_ITK_COORDINATE_ORIENTATION_PIL = _ITKCommonBasePython.itkSpatialOrientationEnums_ValidCoordinateOrientations_ITK_COORDINATE_ORIENTATION_PIL
    
    ValidCoordinateOrientations_ITK_COORDINATE_ORIENTATION_PSL = _ITKCommonBasePython.itkSpatialOrientationEnums_ValidCoordinateOrientations_ITK_COORDINATE_ORIENTATION_PSL
    
    ValidCoordinateOrientations_ITK_COORDINATE_ORIENTATION_AIL = _ITKCommonBasePython.itkSpatialOrientationEnums_ValidCoordinateOrientations_ITK_COORDINATE_ORIENTATION_AIL
    
    ValidCoordinateOrientations_ITK_COORDINATE_ORIENTATION_ASL = _ITKCommonBasePython.itkSpatialOrientationEnums_ValidCoordinateOrientations_ITK_COORDINATE_ORIENTATION_ASL
    

    def __init__(self, *args):
        r"""
        __init__(self) -> itkSpatialOrientationEnums
        __init__(self, arg0) -> itkSpatialOrientationEnums

        Parameters
        ----------
        arg0: itkSpatialOrientationEnums const &

        """
        _ITKCommonBasePython.itkSpatialOrientationEnums_swiginit(self, _ITKCommonBasePython.new_itkSpatialOrientationEnums(*args))
    __swig_destroy__ = _ITKCommonBasePython.delete_itkSpatialOrientationEnums

# Register itkSpatialOrientationEnums in _ITKCommonBasePython:
_ITKCommonBasePython.itkSpatialOrientationEnums_swigregister(itkSpatialOrientationEnums)
class itkStoppingCriterionBase(itkObject):
    r"""Proxy of C++ itkStoppingCriterionBase class."""

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

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

    def IsSatisfied(self):
        r"""IsSatisfied(self) -> bool"""
        return _ITKCommonBasePython.itkStoppingCriterionBase_IsSatisfied(self)

    def GetDescription(self):
        r"""GetDescription(self) -> std::string"""
        return _ITKCommonBasePython.itkStoppingCriterionBase_GetDescription(self)

# Register itkStoppingCriterionBase in _ITKCommonBasePython:
_ITKCommonBasePython.itkStoppingCriterionBase_swigregister(itkStoppingCriterionBase)
class itkStreamingProcessObject(itkProcessObject):
    r"""Proxy of C++ itkStreamingProcessObject class."""

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

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

    def GenerateData(self):
        r"""GenerateData(self)"""
        return _ITKCommonBasePython.itkStreamingProcessObject_GenerateData(self)

    def GetCurrentRequestNumber(self):
        r"""GetCurrentRequestNumber(self) -> int"""
        return _ITKCommonBasePython.itkStreamingProcessObject_GetCurrentRequestNumber(self)
    __swig_destroy__ = _ITKCommonBasePython.delete_itkStreamingProcessObject

    @staticmethod
    def cast(obj):
        r"""
        cast(obj) -> itkStreamingProcessObject

        Parameters
        ----------
        obj: itkLightObject *

        """
        return _ITKCommonBasePython.itkStreamingProcessObject_cast(obj)

# Register itkStreamingProcessObject in _ITKCommonBasePython:
_ITKCommonBasePython.itkStreamingProcessObject_swigregister(itkStreamingProcessObject)

def itkThreadPool_New():
    return itkThreadPool.New()

class itkThreadPool(itkObject):
    r"""Proxy of C++ itkThreadPool class."""

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

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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkThreadPool_Pointer"""
        return _ITKCommonBasePython.itkThreadPool___New_orig__()

    @staticmethod
    def GetInstance():
        r"""GetInstance() -> itkThreadPool_Pointer"""
        return _ITKCommonBasePython.itkThreadPool_GetInstance()

    def AddThreads(self, count):
        r"""
        AddThreads(self, count)

        Parameters
        ----------
        count: unsigned int

        """
        return _ITKCommonBasePython.itkThreadPool_AddThreads(self, count)

    def GetMaximumNumberOfThreads(self):
        r"""GetMaximumNumberOfThreads(self) -> unsigned int"""
        return _ITKCommonBasePython.itkThreadPool_GetMaximumNumberOfThreads(self)

    def GetNumberOfCurrentlyIdleThreads(self):
        r"""GetNumberOfCurrentlyIdleThreads(self) -> int"""
        return _ITKCommonBasePython.itkThreadPool_GetNumberOfCurrentlyIdleThreads(self)

    @staticmethod
    def GetDoNotWaitForThreads():
        r"""GetDoNotWaitForThreads() -> bool"""
        return _ITKCommonBasePython.itkThreadPool_GetDoNotWaitForThreads()

    @staticmethod
    def SetDoNotWaitForThreads(doNotWaitForThreads):
        r"""
        SetDoNotWaitForThreads(doNotWaitForThreads)

        Parameters
        ----------
        doNotWaitForThreads: bool

        """
        return _ITKCommonBasePython.itkThreadPool_SetDoNotWaitForThreads(doNotWaitForThreads)
    __swig_destroy__ = _ITKCommonBasePython.delete_itkThreadPool

    @staticmethod
    def cast(obj):
        r"""
        cast(obj) -> itkThreadPool

        Parameters
        ----------
        obj: itkLightObject *

        """
        return _ITKCommonBasePython.itkThreadPool_cast(obj)

    def New(*args, **kargs):
        """New() -> itkThreadPool

        Create a new object of the class itkThreadPool and set the input and the parameters if some
        named or non-named arguments are passed to that method.

        New() tries to assign all the non named parameters to the input of the new objects - the
        first non named parameter in the first input, etc.

        The named parameters are used by calling the method with the same name prefixed by 'Set'.

        Ex:

          itkThreadPool.New(reader, threshold=10)

        is (most of the time) equivalent to:

          obj = itkThreadPool.New()
          obj.SetInput(0, reader.GetOutput())
          obj.SetThreshold(10)
        """
        obj = itkThreadPool.__New_orig__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkThreadPool in _ITKCommonBasePython:
_ITKCommonBasePython.itkThreadPool_swigregister(itkThreadPool)
class itkTimeProbe(itkResourceProbeDD):
    r"""Proxy of C++ itkTimeProbe class."""

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

    def Print(self, os, indent):
        r"""
        Print(self, os, indent)

        Parameters
        ----------
        os: std::basic_ostream< char,std::char_traits< char > > &
        indent: itkIndent

        """
        return _ITKCommonBasePython.itkTimeProbe_Print(self, os, indent)

    def GetRealTimeClock(self):
        r"""GetRealTimeClock(self) -> itkRealTimeClock"""
        return _ITKCommonBasePython.itkTimeProbe_GetRealTimeClock(self)

    def __init__(self, *args):
        r"""
        __init__(self) -> itkTimeProbe
        __init__(self, arg0) -> itkTimeProbe

        Parameters
        ----------
        arg0: itkTimeProbe const &

        """
        _ITKCommonBasePython.itkTimeProbe_swiginit(self, _ITKCommonBasePython.new_itkTimeProbe(*args))

# Register itkTimeProbe in _ITKCommonBasePython:
_ITKCommonBasePython.itkTimeProbe_swigregister(itkTimeProbe)

def itkTimeStamp_New():
    return itkTimeStamp.New()

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

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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkTimeStamp"""
        return _ITKCommonBasePython.itkTimeStamp___New_orig__()

    @staticmethod
    def GetNameOfClass():
        r"""GetNameOfClass() -> char const *"""
        return _ITKCommonBasePython.itkTimeStamp_GetNameOfClass()

    def Modified(self):
        r"""Modified(self)"""
        return _ITKCommonBasePython.itkTimeStamp_Modified(self)

    def GetMTime(self):
        r"""GetMTime(self) -> unsigned long"""
        return _ITKCommonBasePython.itkTimeStamp_GetMTime(self)

    def __gt__(self, ts):
        r"""
        __gt__(self, ts) -> bool

        Parameters
        ----------
        ts: itkTimeStamp &

        """
        return _ITKCommonBasePython.itkTimeStamp___gt__(self, ts)

    def __lt__(self, ts):
        r"""
        __lt__(self, ts) -> bool

        Parameters
        ----------
        ts: itkTimeStamp &

        """
        return _ITKCommonBasePython.itkTimeStamp___lt__(self, ts)
    __swig_destroy__ = _ITKCommonBasePython.delete_itkTimeStamp

    def __init__(self, *args):
        r"""
        __init__(self) -> itkTimeStamp
        __init__(self, arg0) -> itkTimeStamp

        Parameters
        ----------
        arg0: itkTimeStamp const &

        """
        _ITKCommonBasePython.itkTimeStamp_swiginit(self, _ITKCommonBasePython.new_itkTimeStamp(*args))

    def New(*args, **kargs):
        """New() -> itkTimeStamp

        Create a new object of the class itkTimeStamp and set the input and the parameters if some
        named or non-named arguments are passed to that method.

        New() tries to assign all the non named parameters to the input of the new objects - the
        first non named parameter in the first input, etc.

        The named parameters are used by calling the method with the same name prefixed by 'Set'.

        Ex:

          itkTimeStamp.New(reader, threshold=10)

        is (most of the time) equivalent to:

          obj = itkTimeStamp.New()
          obj.SetInput(0, reader.GetOutput())
          obj.SetThreshold(10)
        """
        obj = itkTimeStamp.__New_orig__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkTimeStamp in _ITKCommonBasePython:
_ITKCommonBasePython.itkTimeStamp_swigregister(itkTimeStamp)

def itkVersion_New():
    return itkVersion.New()

class itkVersion(itkObject):
    r"""Proxy of C++ itkVersion class."""

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

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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkVersion_Pointer"""
        return _ITKCommonBasePython.itkVersion___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkVersion_Pointer"""
        return _ITKCommonBasePython.itkVersion_Clone(self)

    @staticmethod
    def GetITKVersion():
        r"""GetITKVersion() -> char const *"""
        return _ITKCommonBasePython.itkVersion_GetITKVersion()

    @staticmethod
    def GetITKMajorVersion():
        r"""GetITKMajorVersion() -> int"""
        return _ITKCommonBasePython.itkVersion_GetITKMajorVersion()

    @staticmethod
    def GetITKMinorVersion():
        r"""GetITKMinorVersion() -> int"""
        return _ITKCommonBasePython.itkVersion_GetITKMinorVersion()

    @staticmethod
    def GetITKBuildVersion():
        r"""GetITKBuildVersion() -> int"""
        return _ITKCommonBasePython.itkVersion_GetITKBuildVersion()

    @staticmethod
    def GetITKSourceVersion():
        r"""GetITKSourceVersion() -> char const *"""
        return _ITKCommonBasePython.itkVersion_GetITKSourceVersion()
    __swig_destroy__ = _ITKCommonBasePython.delete_itkVersion

    @staticmethod
    def cast(obj):
        r"""
        cast(obj) -> itkVersion

        Parameters
        ----------
        obj: itkLightObject *

        """
        return _ITKCommonBasePython.itkVersion_cast(obj)

    def New(*args, **kargs):
        """New() -> itkVersion

        Create a new object of the class itkVersion and set the input and the parameters if some
        named or non-named arguments are passed to that method.

        New() tries to assign all the non named parameters to the input of the new objects - the
        first non named parameter in the first input, etc.

        The named parameters are used by calling the method with the same name prefixed by 'Set'.

        Ex:

          itkVersion.New(reader, threshold=10)

        is (most of the time) equivalent to:

          obj = itkVersion.New()
          obj.SetInput(0, reader.GetOutput())
          obj.SetThreshold(10)
        """
        obj = itkVersion.__New_orig__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkVersion in _ITKCommonBasePython:
_ITKCommonBasePython.itkVersion_swigregister(itkVersion)
class itkXMLFilterWatcher(itkSimpleFilterWatcher):
    r"""Proxy of C++ itkXMLFilterWatcher class."""

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

    def __init__(self, *args):
        r"""
        __init__(self, o, comment="") -> itkXMLFilterWatcher

        Parameters
        ----------
        o: itkProcessObject *
        comment: char const *

        __init__(self, arg0) -> itkXMLFilterWatcher

        Parameters
        ----------
        arg0: itkXMLFilterWatcher const &

        """
        _ITKCommonBasePython.itkXMLFilterWatcher_swiginit(self, _ITKCommonBasePython.new_itkXMLFilterWatcher(*args))
    __swig_destroy__ = _ITKCommonBasePython.delete_itkXMLFilterWatcher

# Register itkXMLFilterWatcher in _ITKCommonBasePython:
_ITKCommonBasePython.itkXMLFilterWatcher_swigregister(itkXMLFilterWatcher)
class itkAnyEvent(itkEventObject):
    r"""Proxy of C++ itkAnyEvent class."""

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

    def __init__(self, *args):
        r"""
        __init__(self) -> itkAnyEvent
        __init__(self, s) -> itkAnyEvent

        Parameters
        ----------
        s: itkAnyEvent const &

        """
        _ITKCommonBasePython.itkAnyEvent_swiginit(self, _ITKCommonBasePython.new_itkAnyEvent(*args))
    __swig_destroy__ = _ITKCommonBasePython.delete_itkAnyEvent

# Register itkAnyEvent in _ITKCommonBasePython:
_ITKCommonBasePython.itkAnyEvent_swigregister(itkAnyEvent)
class itkCommand(itkObject):
    r"""Proxy of C++ itkCommand class."""

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

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

    def Execute(self, *args):
        r"""
        Execute(self, caller, event)

        Parameters
        ----------
        caller: itkObject *
        event: itkEventObject const &

        Execute(self, caller, event)

        Parameters
        ----------
        caller: itkObject const *
        event: itkEventObject const &

        """
        return _ITKCommonBasePython.itkCommand_Execute(self, *args)
    __swig_destroy__ = _ITKCommonBasePython.delete_itkCommand

    @staticmethod
    def cast(obj):
        r"""
        cast(obj) -> itkCommand

        Parameters
        ----------
        obj: itkLightObject *

        """
        return _ITKCommonBasePython.itkCommand_cast(obj)

# Register itkCommand in _ITKCommonBasePython:
_ITKCommonBasePython.itkCommand_swigregister(itkCommand)

def itkDataObject_New():
    return itkDataObject.New()

class itkDataObject(itkObject):
    r"""Proxy of C++ itkDataObject class."""

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

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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkDataObject_Pointer"""
        return _ITKCommonBasePython.itkDataObject___New_orig__()

    def DisconnectPipeline(self):
        r"""DisconnectPipeline(self)"""
        return _ITKCommonBasePython.itkDataObject_DisconnectPipeline(self)

    def GetSource(self):
        r"""GetSource(self) -> itkProcessObject_Pointer"""
        return _ITKCommonBasePython.itkDataObject_GetSource(self)

    def GetSourceOutputName(self):
        r"""GetSourceOutputName(self) -> std::string const &"""
        return _ITKCommonBasePython.itkDataObject_GetSourceOutputName(self)

    def GetSourceOutputIndex(self):
        r"""GetSourceOutputIndex(self) -> unsigned long"""
        return _ITKCommonBasePython.itkDataObject_GetSourceOutputIndex(self)

    def UpdateSource(self):
        r"""UpdateSource(self)"""
        return _ITKCommonBasePython.itkDataObject_UpdateSource(self)

    def Initialize(self):
        r"""Initialize(self)"""
        return _ITKCommonBasePython.itkDataObject_Initialize(self)

    def SetReleaseDataFlag(self, flag):
        r"""
        SetReleaseDataFlag(self, flag)

        Parameters
        ----------
        flag: bool

        """
        return _ITKCommonBasePython.itkDataObject_SetReleaseDataFlag(self, flag)

    def GetReleaseDataFlag(self):
        r"""GetReleaseDataFlag(self) -> bool const &"""
        return _ITKCommonBasePython.itkDataObject_GetReleaseDataFlag(self)

    def ReleaseDataFlagOn(self):
        r"""ReleaseDataFlagOn(self)"""
        return _ITKCommonBasePython.itkDataObject_ReleaseDataFlagOn(self)

    def ReleaseDataFlagOff(self):
        r"""ReleaseDataFlagOff(self)"""
        return _ITKCommonBasePython.itkDataObject_ReleaseDataFlagOff(self)

    @staticmethod
    def SetGlobalReleaseDataFlag(val):
        r"""
        SetGlobalReleaseDataFlag(val)

        Parameters
        ----------
        val: bool

        """
        return _ITKCommonBasePython.itkDataObject_SetGlobalReleaseDataFlag(val)

    @staticmethod
    def GetGlobalReleaseDataFlag():
        r"""GetGlobalReleaseDataFlag() -> bool"""
        return _ITKCommonBasePython.itkDataObject_GetGlobalReleaseDataFlag()

    @staticmethod
    def GlobalReleaseDataFlagOn():
        r"""GlobalReleaseDataFlagOn()"""
        return _ITKCommonBasePython.itkDataObject_GlobalReleaseDataFlagOn()

    @staticmethod
    def GlobalReleaseDataFlagOff():
        r"""GlobalReleaseDataFlagOff()"""
        return _ITKCommonBasePython.itkDataObject_GlobalReleaseDataFlagOff()

    def ReleaseData(self):
        r"""ReleaseData(self)"""
        return _ITKCommonBasePython.itkDataObject_ReleaseData(self)

    def ShouldIReleaseData(self):
        r"""ShouldIReleaseData(self) -> bool"""
        return _ITKCommonBasePython.itkDataObject_ShouldIReleaseData(self)

    def GetDataReleased(self):
        r"""GetDataReleased(self) -> bool"""
        return _ITKCommonBasePython.itkDataObject_GetDataReleased(self)

    def Update(self):
        r"""Update(self)"""
        return _ITKCommonBasePython.itkDataObject_Update(self)

    def UpdateOutputInformation(self):
        r"""UpdateOutputInformation(self)"""
        return _ITKCommonBasePython.itkDataObject_UpdateOutputInformation(self)

    def PropagateRequestedRegion(self):
        r"""PropagateRequestedRegion(self)"""
        return _ITKCommonBasePython.itkDataObject_PropagateRequestedRegion(self)

    def UpdateOutputData(self):
        r"""UpdateOutputData(self)"""
        return _ITKCommonBasePython.itkDataObject_UpdateOutputData(self)

    def ResetPipeline(self):
        r"""ResetPipeline(self)"""
        return _ITKCommonBasePython.itkDataObject_ResetPipeline(self)

    def SetPipelineMTime(self, time):
        r"""
        SetPipelineMTime(self, time)

        Parameters
        ----------
        time: unsigned long

        """
        return _ITKCommonBasePython.itkDataObject_SetPipelineMTime(self, time)

    def GetPipelineMTime(self):
        r"""GetPipelineMTime(self) -> unsigned long const &"""
        return _ITKCommonBasePython.itkDataObject_GetPipelineMTime(self)

    def GetUpdateMTime(self):
        r"""GetUpdateMTime(self) -> unsigned long"""
        return _ITKCommonBasePython.itkDataObject_GetUpdateMTime(self)

    def SetRealTimeStamp(self, _arg):
        r"""
        SetRealTimeStamp(self, _arg)

        Parameters
        ----------
        _arg: itkRealTimeStamp

        """
        return _ITKCommonBasePython.itkDataObject_SetRealTimeStamp(self, _arg)

    def GetRealTimeStamp(self):
        r"""GetRealTimeStamp(self) -> itkRealTimeStamp"""
        return _ITKCommonBasePython.itkDataObject_GetRealTimeStamp(self)

    def PrepareForNewData(self):
        r"""PrepareForNewData(self)"""
        return _ITKCommonBasePython.itkDataObject_PrepareForNewData(self)

    def DataHasBeenGenerated(self):
        r"""DataHasBeenGenerated(self)"""
        return _ITKCommonBasePython.itkDataObject_DataHasBeenGenerated(self)

    def SetRequestedRegionToLargestPossibleRegion(self):
        r"""SetRequestedRegionToLargestPossibleRegion(self)"""
        return _ITKCommonBasePython.itkDataObject_SetRequestedRegionToLargestPossibleRegion(self)

    def RequestedRegionIsOutsideOfTheBufferedRegion(self):
        r"""RequestedRegionIsOutsideOfTheBufferedRegion(self) -> bool"""
        return _ITKCommonBasePython.itkDataObject_RequestedRegionIsOutsideOfTheBufferedRegion(self)

    def VerifyRequestedRegion(self):
        r"""VerifyRequestedRegion(self) -> bool"""
        return _ITKCommonBasePython.itkDataObject_VerifyRequestedRegion(self)

    def CopyInformation(self, arg0):
        r"""
        CopyInformation(self, arg0)

        Parameters
        ----------
        arg0: itkDataObject const *

        """
        return _ITKCommonBasePython.itkDataObject_CopyInformation(self, arg0)

    def SetRequestedRegion(self, arg0):
        r"""
        SetRequestedRegion(self, arg0)

        Parameters
        ----------
        arg0: itkDataObject const *

        """
        return _ITKCommonBasePython.itkDataObject_SetRequestedRegion(self, arg0)

    def Graft(self, arg0):
        r"""
        Graft(self, arg0)

        Parameters
        ----------
        arg0: itkDataObject const *

        """
        return _ITKCommonBasePython.itkDataObject_Graft(self, arg0)
    __swig_destroy__ = _ITKCommonBasePython.delete_itkDataObject

    @staticmethod
    def cast(obj):
        r"""
        cast(obj) -> itkDataObject

        Parameters
        ----------
        obj: itkLightObject *

        """
        return _ITKCommonBasePython.itkDataObject_cast(obj)

    def New(*args, **kargs):
        """New() -> itkDataObject

        Create a new object of the class itkDataObject and set the input and the parameters if some
        named or non-named arguments are passed to that method.

        New() tries to assign all the non named parameters to the input of the new objects - the
        first non named parameter in the first input, etc.

        The named parameters are used by calling the method with the same name prefixed by 'Set'.

        Ex:

          itkDataObject.New(reader, threshold=10)

        is (most of the time) equivalent to:

          obj = itkDataObject.New()
          obj.SetInput(0, reader.GetOutput())
          obj.SetThreshold(10)
        """
        obj = itkDataObject.__New_orig__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkDataObject in _ITKCommonBasePython:
_ITKCommonBasePython.itkDataObject_swigregister(itkDataObject)
class itkDeleteEvent(itkAnyEvent):
    r"""Proxy of C++ itkDeleteEvent class."""

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

    def __init__(self, *args):
        r"""
        __init__(self) -> itkDeleteEvent
        __init__(self, s) -> itkDeleteEvent

        Parameters
        ----------
        s: itkDeleteEvent const &

        """
        _ITKCommonBasePython.itkDeleteEvent_swiginit(self, _ITKCommonBasePython.new_itkDeleteEvent(*args))
    __swig_destroy__ = _ITKCommonBasePython.delete_itkDeleteEvent

# Register itkDeleteEvent in _ITKCommonBasePython:
_ITKCommonBasePython.itkDeleteEvent_swigregister(itkDeleteEvent)

def itkDirectory_New():
    return itkDirectory.New()

class itkDirectory(itkObject):
    r"""Proxy of C++ itkDirectory class."""

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

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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkDirectory_Pointer"""
        return _ITKCommonBasePython.itkDirectory___New_orig__()

    def Load(self, dir):
        r"""
        Load(self, dir) -> bool

        Parameters
        ----------
        dir: char const *

        """
        return _ITKCommonBasePython.itkDirectory_Load(self, dir)

    def GetNumberOfFiles(self):
        r"""GetNumberOfFiles(self) -> unsigned long"""
        return _ITKCommonBasePython.itkDirectory_GetNumberOfFiles(self)

    def GetFile(self, index):
        r"""
        GetFile(self, index) -> char const *

        Parameters
        ----------
        index: unsigned int

        """
        return _ITKCommonBasePython.itkDirectory_GetFile(self, index)
    __swig_destroy__ = _ITKCommonBasePython.delete_itkDirectory

    @staticmethod
    def cast(obj):
        r"""
        cast(obj) -> itkDirectory

        Parameters
        ----------
        obj: itkLightObject *

        """
        return _ITKCommonBasePython.itkDirectory_cast(obj)

    def New(*args, **kargs):
        """New() -> itkDirectory

        Create a new object of the class itkDirectory and set the input and the parameters if some
        named or non-named arguments are passed to that method.

        New() tries to assign all the non named parameters to the input of the new objects - the
        first non named parameter in the first input, etc.

        The named parameters are used by calling the method with the same name prefixed by 'Set'.

        Ex:

          itkDirectory.New(reader, threshold=10)

        is (most of the time) equivalent to:

          obj = itkDirectory.New()
          obj.SetInput(0, reader.GetOutput())
          obj.SetThreshold(10)
        """
        obj = itkDirectory.__New_orig__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkDirectory in _ITKCommonBasePython:
_ITKCommonBasePython.itkDirectory_swigregister(itkDirectory)

def itkDynamicLoader_New():
    return itkDynamicLoader.New()

class itkDynamicLoader(itkObject):
    r"""Proxy of C++ itkDynamicLoader class."""

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

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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkDynamicLoader_Pointer"""
        return _ITKCommonBasePython.itkDynamicLoader___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkDynamicLoader_Pointer"""
        return _ITKCommonBasePython.itkDynamicLoader_Clone(self)

    @staticmethod
    def OpenLibrary(arg0):
        r"""
        OpenLibrary(arg0) -> void *

        Parameters
        ----------
        arg0: char const *

        """
        return _ITKCommonBasePython.itkDynamicLoader_OpenLibrary(arg0)

    @staticmethod
    def CloseLibrary(arg0):
        r"""
        CloseLibrary(arg0) -> int

        Parameters
        ----------
        arg0: void *

        """
        return _ITKCommonBasePython.itkDynamicLoader_CloseLibrary(arg0)

    @staticmethod
    def GetSymbolAddress(arg0, arg1):
        r"""
        GetSymbolAddress(arg0, arg1) -> void *

        Parameters
        ----------
        arg0: void *
        arg1: char const *

        """
        return _ITKCommonBasePython.itkDynamicLoader_GetSymbolAddress(arg0, arg1)

    @staticmethod
    def LibPrefix():
        r"""LibPrefix() -> char const *"""
        return _ITKCommonBasePython.itkDynamicLoader_LibPrefix()

    @staticmethod
    def LibExtension():
        r"""LibExtension() -> char const *"""
        return _ITKCommonBasePython.itkDynamicLoader_LibExtension()

    @staticmethod
    def LastError():
        r"""LastError() -> char const *"""
        return _ITKCommonBasePython.itkDynamicLoader_LastError()
    __swig_destroy__ = _ITKCommonBasePython.delete_itkDynamicLoader

    @staticmethod
    def cast(obj):
        r"""
        cast(obj) -> itkDynamicLoader

        Parameters
        ----------
        obj: itkLightObject *

        """
        return _ITKCommonBasePython.itkDynamicLoader_cast(obj)

    def New(*args, **kargs):
        """New() -> itkDynamicLoader

        Create a new object of the class itkDynamicLoader and set the input and the parameters if some
        named or non-named arguments are passed to that method.

        New() tries to assign all the non named parameters to the input of the new objects - the
        first non named parameter in the first input, etc.

        The named parameters are used by calling the method with the same name prefixed by 'Set'.

        Ex:

          itkDynamicLoader.New(reader, threshold=10)

        is (most of the time) equivalent to:

          obj = itkDynamicLoader.New()
          obj.SetInput(0, reader.GetOutput())
          obj.SetThreshold(10)
        """
        obj = itkDynamicLoader.__New_orig__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkDynamicLoader in _ITKCommonBasePython:
_ITKCommonBasePython.itkDynamicLoader_swigregister(itkDynamicLoader)
class itkEndEvent(itkAnyEvent):
    r"""Proxy of C++ itkEndEvent class."""

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

    def __init__(self, *args):
        r"""
        __init__(self) -> itkEndEvent
        __init__(self, s) -> itkEndEvent

        Parameters
        ----------
        s: itkEndEvent const &

        """
        _ITKCommonBasePython.itkEndEvent_swiginit(self, _ITKCommonBasePython.new_itkEndEvent(*args))
    __swig_destroy__ = _ITKCommonBasePython.delete_itkEndEvent

# Register itkEndEvent in _ITKCommonBasePython:
_ITKCommonBasePython.itkEndEvent_swigregister(itkEndEvent)
class itkExitEvent(itkAnyEvent):
    r"""Proxy of C++ itkExitEvent class."""

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

    def __init__(self, *args):
        r"""
        __init__(self) -> itkExitEvent
        __init__(self, s) -> itkExitEvent

        Parameters
        ----------
        s: itkExitEvent const &

        """
        _ITKCommonBasePython.itkExitEvent_swiginit(self, _ITKCommonBasePython.new_itkExitEvent(*args))
    __swig_destroy__ = _ITKCommonBasePython.delete_itkExitEvent

# Register itkExitEvent in _ITKCommonBasePython:
_ITKCommonBasePython.itkExitEvent_swigregister(itkExitEvent)
class itkImageIORegion(itkRegion):
    r"""Proxy of C++ itkImageIORegion class."""

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

    def GetImageDimension(self):
        r"""GetImageDimension(self) -> unsigned int"""
        return _ITKCommonBasePython.itkImageIORegion_GetImageDimension(self)

    def GetRegionDimension(self):
        r"""GetRegionDimension(self) -> unsigned int"""
        return _ITKCommonBasePython.itkImageIORegion_GetRegionDimension(self)
    __swig_destroy__ = _ITKCommonBasePython.delete_itkImageIORegion

    def __init__(self, *args):
        r"""
        __init__(self, dimension) -> itkImageIORegion

        Parameters
        ----------
        dimension: unsigned int

        __init__(self) -> itkImageIORegion
        __init__(self, arg0) -> itkImageIORegion

        Parameters
        ----------
        arg0: itkImageIORegion const &

        """
        _ITKCommonBasePython.itkImageIORegion_swiginit(self, _ITKCommonBasePython.new_itkImageIORegion(*args))

    def GetModifiableIndex(self):
        r"""GetModifiableIndex(self) -> vectorSL"""
        return _ITKCommonBasePython.itkImageIORegion_GetModifiableIndex(self)

    def GetModifiableSize(self):
        r"""GetModifiableSize(self) -> vectorUL"""
        return _ITKCommonBasePython.itkImageIORegion_GetModifiableSize(self)

    def GetSize(self, *args):
        r"""
        GetSize(self) -> vectorUL
        GetSize(self, i) -> unsigned long

        Parameters
        ----------
        i: unsigned long

        """
        return _ITKCommonBasePython.itkImageIORegion_GetSize(self, *args)

    def GetIndex(self, *args):
        r"""
        GetIndex(self) -> vectorSL
        GetIndex(self, i) -> long

        Parameters
        ----------
        i: unsigned long

        """
        return _ITKCommonBasePython.itkImageIORegion_GetIndex(self, *args)

    def SetSize(self, *args):
        r"""
        SetSize(self, size)

        Parameters
        ----------
        size: std::vector< unsigned long,std::allocator< unsigned long > > const &

        SetSize(self, i, size)

        Parameters
        ----------
        i: unsigned long const
        size: unsigned long

        """
        return _ITKCommonBasePython.itkImageIORegion_SetSize(self, *args)

    def SetIndex(self, *args):
        r"""
        SetIndex(self, index)

        Parameters
        ----------
        index: std::vector< long,std::allocator< long > > const &

        SetIndex(self, i, idx)

        Parameters
        ----------
        i: unsigned long const
        idx: long

        """
        return _ITKCommonBasePython.itkImageIORegion_SetIndex(self, *args)

    def __eq__(self, region):
        r"""
        __eq__(self, region) -> bool

        Parameters
        ----------
        region: itkImageIORegion const &

        """
        return _ITKCommonBasePython.itkImageIORegion___eq__(self, region)

    def __ne__(self, other):
        r"""
        __ne__(self, other) -> bool

        Parameters
        ----------
        other: itkImageIORegion const &

        """
        return _ITKCommonBasePython.itkImageIORegion___ne__(self, other)

    def IsInside(self, *args):
        r"""
        IsInside(self, index) -> bool

        Parameters
        ----------
        index: std::vector< long,std::allocator< long > > const &

        IsInside(self, region) -> bool

        Parameters
        ----------
        region: itkImageIORegion const &

        """
        return _ITKCommonBasePython.itkImageIORegion_IsInside(self, *args)

    def GetNumberOfPixels(self):
        r"""GetNumberOfPixels(self) -> unsigned long"""
        return _ITKCommonBasePython.itkImageIORegion_GetNumberOfPixels(self)

# Register itkImageIORegion in _ITKCommonBasePython:
_ITKCommonBasePython.itkImageIORegion_swigregister(itkImageIORegion)
class itkImageRegionSplitterBase(itkObject):
    r"""Proxy of C++ itkImageRegionSplitterBase class."""

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

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

    def GetNumberOfSplits(self, region, requestedNumber):
        r"""
        GetNumberOfSplits(self, region, requestedNumber) -> unsigned int

        Parameters
        ----------
        region: itkImageIORegion const &
        requestedNumber: unsigned int

        """
        return _ITKCommonBasePython.itkImageRegionSplitterBase_GetNumberOfSplits(self, region, requestedNumber)

    def GetSplit(self, i, numberOfPieces, region):
        r"""
        GetSplit(self, i, numberOfPieces, region) -> unsigned int

        Parameters
        ----------
        i: unsigned int
        numberOfPieces: unsigned int
        region: itkImageIORegion &

        """
        return _ITKCommonBasePython.itkImageRegionSplitterBase_GetSplit(self, i, numberOfPieces, region)
    __swig_destroy__ = _ITKCommonBasePython.delete_itkImageRegionSplitterBase

    @staticmethod
    def cast(obj):
        r"""
        cast(obj) -> itkImageRegionSplitterBase

        Parameters
        ----------
        obj: itkLightObject *

        """
        return _ITKCommonBasePython.itkImageRegionSplitterBase_cast(obj)

# Register itkImageRegionSplitterBase in _ITKCommonBasePython:
_ITKCommonBasePython.itkImageRegionSplitterBase_swigregister(itkImageRegionSplitterBase)

def itkImageRegionSplitterDirection_New():
    return itkImageRegionSplitterDirection.New()

class itkImageRegionSplitterDirection(itkImageRegionSplitterBase):
    r"""Proxy of C++ itkImageRegionSplitterDirection class."""

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

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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkImageRegionSplitterDirection_Pointer"""
        return _ITKCommonBasePython.itkImageRegionSplitterDirection___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkImageRegionSplitterDirection_Pointer"""
        return _ITKCommonBasePython.itkImageRegionSplitterDirection_Clone(self)

    def GetDirection(self):
        r"""GetDirection(self) -> unsigned int"""
        return _ITKCommonBasePython.itkImageRegionSplitterDirection_GetDirection(self)

    def SetDirection(self, _arg):
        r"""
        SetDirection(self, _arg)

        Parameters
        ----------
        _arg: unsigned int

        """
        return _ITKCommonBasePython.itkImageRegionSplitterDirection_SetDirection(self, _arg)
    __swig_destroy__ = _ITKCommonBasePython.delete_itkImageRegionSplitterDirection

    @staticmethod
    def cast(obj):
        r"""
        cast(obj) -> itkImageRegionSplitterDirection

        Parameters
        ----------
        obj: itkLightObject *

        """
        return _ITKCommonBasePython.itkImageRegionSplitterDirection_cast(obj)

    def New(*args, **kargs):
        """New() -> itkImageRegionSplitterDirection

        Create a new object of the class itkImageRegionSplitterDirection and set the input and the parameters if some
        named or non-named arguments are passed to that method.

        New() tries to assign all the non named parameters to the input of the new objects - the
        first non named parameter in the first input, etc.

        The named parameters are used by calling the method with the same name prefixed by 'Set'.

        Ex:

          itkImageRegionSplitterDirection.New(reader, threshold=10)

        is (most of the time) equivalent to:

          obj = itkImageRegionSplitterDirection.New()
          obj.SetInput(0, reader.GetOutput())
          obj.SetThreshold(10)
        """
        obj = itkImageRegionSplitterDirection.__New_orig__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkImageRegionSplitterDirection in _ITKCommonBasePython:
_ITKCommonBasePython.itkImageRegionSplitterDirection_swigregister(itkImageRegionSplitterDirection)
class itkInitializeEvent(itkAnyEvent):
    r"""Proxy of C++ itkInitializeEvent class."""

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

    def __init__(self, *args):
        r"""
        __init__(self) -> itkInitializeEvent
        __init__(self, s) -> itkInitializeEvent

        Parameters
        ----------
        s: itkInitializeEvent const &

        """
        _ITKCommonBasePython.itkInitializeEvent_swiginit(self, _ITKCommonBasePython.new_itkInitializeEvent(*args))
    __swig_destroy__ = _ITKCommonBasePython.delete_itkInitializeEvent

# Register itkInitializeEvent in _ITKCommonBasePython:
_ITKCommonBasePython.itkInitializeEvent_swigregister(itkInitializeEvent)
class itkIterationEvent(itkAnyEvent):
    r"""Proxy of C++ itkIterationEvent class."""

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

    def __init__(self, *args):
        r"""
        __init__(self) -> itkIterationEvent
        __init__(self, s) -> itkIterationEvent

        Parameters
        ----------
        s: itkIterationEvent const &

        """
        _ITKCommonBasePython.itkIterationEvent_swiginit(self, _ITKCommonBasePython.new_itkIterationEvent(*args))
    __swig_destroy__ = _ITKCommonBasePython.delete_itkIterationEvent

# Register itkIterationEvent in _ITKCommonBasePython:
_ITKCommonBasePython.itkIterationEvent_swigregister(itkIterationEvent)

def itkLightProcessObject_New():
    return itkLightProcessObject.New()

class itkLightProcessObject(itkObject):
    r"""Proxy of C++ itkLightProcessObject class."""

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

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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkLightProcessObject_Pointer"""
        return _ITKCommonBasePython.itkLightProcessObject___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkLightProcessObject_Pointer"""
        return _ITKCommonBasePython.itkLightProcessObject_Clone(self)

    def SetAbortGenerateData(self, _arg):
        r"""
        SetAbortGenerateData(self, _arg)

        Parameters
        ----------
        _arg: bool

        """
        return _ITKCommonBasePython.itkLightProcessObject_SetAbortGenerateData(self, _arg)

    def GetAbortGenerateData(self):
        r"""GetAbortGenerateData(self) -> bool const &"""
        return _ITKCommonBasePython.itkLightProcessObject_GetAbortGenerateData(self)

    def AbortGenerateDataOn(self):
        r"""AbortGenerateDataOn(self)"""
        return _ITKCommonBasePython.itkLightProcessObject_AbortGenerateDataOn(self)

    def AbortGenerateDataOff(self):
        r"""AbortGenerateDataOff(self)"""
        return _ITKCommonBasePython.itkLightProcessObject_AbortGenerateDataOff(self)

    def SetProgress(self, _arg):
        r"""
        SetProgress(self, _arg)

        Parameters
        ----------
        _arg: float

        """
        return _ITKCommonBasePython.itkLightProcessObject_SetProgress(self, _arg)

    def GetProgress(self):
        r"""GetProgress(self) -> float const &"""
        return _ITKCommonBasePython.itkLightProcessObject_GetProgress(self)

    def UpdateProgress(self, amount):
        r"""
        UpdateProgress(self, amount)

        Parameters
        ----------
        amount: float

        """
        return _ITKCommonBasePython.itkLightProcessObject_UpdateProgress(self, amount)

    def UpdateOutputData(self):
        r"""UpdateOutputData(self)"""
        return _ITKCommonBasePython.itkLightProcessObject_UpdateOutputData(self)
    __swig_destroy__ = _ITKCommonBasePython.delete_itkLightProcessObject

    @staticmethod
    def cast(obj):
        r"""
        cast(obj) -> itkLightProcessObject

        Parameters
        ----------
        obj: itkLightObject *

        """
        return _ITKCommonBasePython.itkLightProcessObject_cast(obj)

    def New(*args, **kargs):
        """New() -> itkLightProcessObject

        Create a new object of the class itkLightProcessObject and set the input and the parameters if some
        named or non-named arguments are passed to that method.

        New() tries to assign all the non named parameters to the input of the new objects - the
        first non named parameter in the first input, etc.

        The named parameters are used by calling the method with the same name prefixed by 'Set'.

        Ex:

          itkLightProcessObject.New(reader, threshold=10)

        is (most of the time) equivalent to:

          obj = itkLightProcessObject.New()
          obj.SetInput(0, reader.GetOutput())
          obj.SetThreshold(10)
        """
        obj = itkLightProcessObject.__New_orig__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkLightProcessObject in _ITKCommonBasePython:
_ITKCommonBasePython.itkLightProcessObject_swigregister(itkLightProcessObject)

def itkMersenneTwisterRandomVariateGenerator_New():
    return itkMersenneTwisterRandomVariateGenerator.New()

class itkMersenneTwisterRandomVariateGenerator(itkRandomVariateGeneratorBase):
    r"""Proxy of C++ itkMersenneTwisterRandomVariateGenerator class."""

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

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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkMersenneTwisterRandomVariateGenerator_Pointer"""
        return _ITKCommonBasePython.itkMersenneTwisterRandomVariateGenerator___New_orig__()

    @staticmethod
    def GetInstance():
        r"""GetInstance() -> itkMersenneTwisterRandomVariateGenerator_Pointer"""
        return _ITKCommonBasePython.itkMersenneTwisterRandomVariateGenerator_GetInstance()

    @staticmethod
    def ResetNextSeed():
        r"""ResetNextSeed()"""
        return _ITKCommonBasePython.itkMersenneTwisterRandomVariateGenerator_ResetNextSeed()

    def Initialize(self, *args):
        r"""
        Initialize(self, seed)

        Parameters
        ----------
        seed: unsigned int const

        Initialize(self)
        """
        return _ITKCommonBasePython.itkMersenneTwisterRandomVariateGenerator_Initialize(self, *args)

    def GetVariateWithClosedRange(self, *args):
        r"""
        GetVariateWithClosedRange(self) -> double
        GetVariateWithClosedRange(self, n) -> double

        Parameters
        ----------
        n: double const

        """
        return _ITKCommonBasePython.itkMersenneTwisterRandomVariateGenerator_GetVariateWithClosedRange(self, *args)

    def GetVariateWithOpenUpperRange(self, *args):
        r"""
        GetVariateWithOpenUpperRange(self) -> double
        GetVariateWithOpenUpperRange(self, n) -> double

        Parameters
        ----------
        n: double const

        """
        return _ITKCommonBasePython.itkMersenneTwisterRandomVariateGenerator_GetVariateWithOpenUpperRange(self, *args)

    def GetVariateWithOpenRange(self, *args):
        r"""
        GetVariateWithOpenRange(self) -> double
        GetVariateWithOpenRange(self, n) -> double

        Parameters
        ----------
        n: double const

        """
        return _ITKCommonBasePython.itkMersenneTwisterRandomVariateGenerator_GetVariateWithOpenRange(self, *args)

    def GetIntegerVariate(self, *args):
        r"""
        GetIntegerVariate(self) -> unsigned int
        GetIntegerVariate(self, n) -> unsigned int

        Parameters
        ----------
        n: unsigned int const &

        """
        return _ITKCommonBasePython.itkMersenneTwisterRandomVariateGenerator_GetIntegerVariate(self, *args)

    def Get53BitVariate(self):
        r"""Get53BitVariate(self) -> double"""
        return _ITKCommonBasePython.itkMersenneTwisterRandomVariateGenerator_Get53BitVariate(self)

    def GetNormalVariate(self, mean=0., variance=1.):
        r"""
        GetNormalVariate(self, mean=0., variance=1.) -> double

        Parameters
        ----------
        mean: double const
        variance: double const

        """
        return _ITKCommonBasePython.itkMersenneTwisterRandomVariateGenerator_GetNormalVariate(self, mean, variance)

    def GetUniformVariate(self, a, b):
        r"""
        GetUniformVariate(self, a, b) -> double

        Parameters
        ----------
        a: double const
        b: double const

        """
        return _ITKCommonBasePython.itkMersenneTwisterRandomVariateGenerator_GetUniformVariate(self, a, b)

    def __call__(self):
        r"""__call__(self) -> double"""
        return _ITKCommonBasePython.itkMersenneTwisterRandomVariateGenerator___call__(self)

    def SetSeed(self, *args):
        r"""
        SetSeed(self, oneSeed)

        Parameters
        ----------
        oneSeed: unsigned int const

        SetSeed(self)
        """
        return _ITKCommonBasePython.itkMersenneTwisterRandomVariateGenerator_SetSeed(self, *args)

    def GetSeed(self):
        r"""GetSeed(self) -> unsigned int"""
        return _ITKCommonBasePython.itkMersenneTwisterRandomVariateGenerator_GetSeed(self)

    @staticmethod
    def GetNextSeed():
        r"""GetNextSeed() -> unsigned int"""
        return _ITKCommonBasePython.itkMersenneTwisterRandomVariateGenerator_GetNextSeed()
    __swig_destroy__ = _ITKCommonBasePython.delete_itkMersenneTwisterRandomVariateGenerator

    @staticmethod
    def cast(obj):
        r"""
        cast(obj) -> itkMersenneTwisterRandomVariateGenerator

        Parameters
        ----------
        obj: itkLightObject *

        """
        return _ITKCommonBasePython.itkMersenneTwisterRandomVariateGenerator_cast(obj)

    def New(*args, **kargs):
        """New() -> itkMersenneTwisterRandomVariateGenerator

        Create a new object of the class itkMersenneTwisterRandomVariateGenerator and set the input and the parameters if some
        named or non-named arguments are passed to that method.

        New() tries to assign all the non named parameters to the input of the new objects - the
        first non named parameter in the first input, etc.

        The named parameters are used by calling the method with the same name prefixed by 'Set'.

        Ex:

          itkMersenneTwisterRandomVariateGenerator.New(reader, threshold=10)

        is (most of the time) equivalent to:

          obj = itkMersenneTwisterRandomVariateGenerator.New()
          obj.SetInput(0, reader.GetOutput())
          obj.SetThreshold(10)
        """
        obj = itkMersenneTwisterRandomVariateGenerator.__New_orig__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkMersenneTwisterRandomVariateGenerator in _ITKCommonBasePython:
_ITKCommonBasePython.itkMersenneTwisterRandomVariateGenerator_swigregister(itkMersenneTwisterRandomVariateGenerator)
class itkMeshRegion(itkRegion):
    r"""Proxy of C++ itkMeshRegion class."""

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

    def GetNumberOfRegions(self):
        r"""GetNumberOfRegions(self) -> unsigned long"""
        return _ITKCommonBasePython.itkMeshRegion_GetNumberOfRegions(self)

    def SetNumberOfRegions(self, num):
        r"""
        SetNumberOfRegions(self, num)

        Parameters
        ----------
        num: unsigned long

        """
        return _ITKCommonBasePython.itkMeshRegion_SetNumberOfRegions(self, num)

    def GetRegion(self):
        r"""GetRegion(self) -> unsigned long"""
        return _ITKCommonBasePython.itkMeshRegion_GetRegion(self)

    def SetRegion(self, region):
        r"""
        SetRegion(self, region)

        Parameters
        ----------
        region: unsigned long

        """
        return _ITKCommonBasePython.itkMeshRegion_SetRegion(self, region)

    def __init__(self, *args):
        r"""
        __init__(self) -> itkMeshRegion
        __init__(self, arg0) -> itkMeshRegion

        Parameters
        ----------
        arg0: itkMeshRegion const &

        """
        _ITKCommonBasePython.itkMeshRegion_swiginit(self, _ITKCommonBasePython.new_itkMeshRegion(*args))

# Register itkMeshRegion in _ITKCommonBasePython:
_ITKCommonBasePython.itkMeshRegion_swigregister(itkMeshRegion)
class itkModifiedEvent(itkAnyEvent):
    r"""Proxy of C++ itkModifiedEvent class."""

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

    def __init__(self, *args):
        r"""
        __init__(self) -> itkModifiedEvent
        __init__(self, s) -> itkModifiedEvent

        Parameters
        ----------
        s: itkModifiedEvent const &

        """
        _ITKCommonBasePython.itkModifiedEvent_swiginit(self, _ITKCommonBasePython.new_itkModifiedEvent(*args))
    __swig_destroy__ = _ITKCommonBasePython.delete_itkModifiedEvent

# Register itkModifiedEvent in _ITKCommonBasePython:
_ITKCommonBasePython.itkModifiedEvent_swigregister(itkModifiedEvent)
class itkMultiResolutionIterationEvent(itkIterationEvent):
    r"""Proxy of C++ itkMultiResolutionIterationEvent class."""

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

    def __init__(self, *args):
        r"""
        __init__(self) -> itkMultiResolutionIterationEvent
        __init__(self, s) -> itkMultiResolutionIterationEvent

        Parameters
        ----------
        s: itkMultiResolutionIterationEvent const &

        """
        _ITKCommonBasePython.itkMultiResolutionIterationEvent_swiginit(self, _ITKCommonBasePython.new_itkMultiResolutionIterationEvent(*args))
    __swig_destroy__ = _ITKCommonBasePython.delete_itkMultiResolutionIterationEvent

# Register itkMultiResolutionIterationEvent in _ITKCommonBasePython:
_ITKCommonBasePython.itkMultiResolutionIterationEvent_swigregister(itkMultiResolutionIterationEvent)

def itkMultiThreaderBase_New():
    return itkMultiThreaderBase.New()

class itkMultiThreaderBase(itkObject):
    r"""Proxy of C++ itkMultiThreaderBase class."""

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

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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkMultiThreaderBase_Pointer"""
        return _ITKCommonBasePython.itkMultiThreaderBase___New_orig__()

    def SetMaximumNumberOfThreads(self, numberOfThreads):
        r"""
        SetMaximumNumberOfThreads(self, numberOfThreads)

        Parameters
        ----------
        numberOfThreads: unsigned int

        """
        return _ITKCommonBasePython.itkMultiThreaderBase_SetMaximumNumberOfThreads(self, numberOfThreads)

    def GetMaximumNumberOfThreads(self):
        r"""GetMaximumNumberOfThreads(self) -> unsigned int"""
        return _ITKCommonBasePython.itkMultiThreaderBase_GetMaximumNumberOfThreads(self)

    def SetNumberOfWorkUnits(self, numberOfWorkUnits):
        r"""
        SetNumberOfWorkUnits(self, numberOfWorkUnits)

        Parameters
        ----------
        numberOfWorkUnits: unsigned int

        """
        return _ITKCommonBasePython.itkMultiThreaderBase_SetNumberOfWorkUnits(self, numberOfWorkUnits)

    def GetNumberOfWorkUnits(self):
        r"""GetNumberOfWorkUnits(self) -> unsigned int"""
        return _ITKCommonBasePython.itkMultiThreaderBase_GetNumberOfWorkUnits(self)

    def SetUpdateProgress(self, updates):
        r"""
        SetUpdateProgress(self, updates)

        Parameters
        ----------
        updates: bool

        """
        return _ITKCommonBasePython.itkMultiThreaderBase_SetUpdateProgress(self, updates)

    def GetUpdateProgress(self):
        r"""GetUpdateProgress(self) -> bool"""
        return _ITKCommonBasePython.itkMultiThreaderBase_GetUpdateProgress(self)

    @staticmethod
    def SetGlobalMaximumNumberOfThreads(val):
        r"""
        SetGlobalMaximumNumberOfThreads(val)

        Parameters
        ----------
        val: unsigned int

        """
        return _ITKCommonBasePython.itkMultiThreaderBase_SetGlobalMaximumNumberOfThreads(val)

    @staticmethod
    def GetGlobalMaximumNumberOfThreads():
        r"""GetGlobalMaximumNumberOfThreads() -> unsigned int"""
        return _ITKCommonBasePython.itkMultiThreaderBase_GetGlobalMaximumNumberOfThreads()

    @staticmethod
    def ThreaderTypeFromString(threaderString):
        r"""
        ThreaderTypeFromString(threaderString) -> itkMultiThreaderBaseEnums::Threader

        Parameters
        ----------
        threaderString: std::string

        """
        return _ITKCommonBasePython.itkMultiThreaderBase_ThreaderTypeFromString(threaderString)

    @staticmethod
    def ThreaderTypeToString(threader):
        r"""
        ThreaderTypeToString(threader) -> std::string

        Parameters
        ----------
        threader: enum itkMultiThreaderBaseEnums::Threader

        """
        return _ITKCommonBasePython.itkMultiThreaderBase_ThreaderTypeToString(threader)

    @staticmethod
    def SetGlobalDefaultThreader(threaderType):
        r"""
        SetGlobalDefaultThreader(threaderType)

        Parameters
        ----------
        threaderType: enum itkMultiThreaderBaseEnums::Threader

        """
        return _ITKCommonBasePython.itkMultiThreaderBase_SetGlobalDefaultThreader(threaderType)

    @staticmethod
    def GetGlobalDefaultThreader():
        r"""GetGlobalDefaultThreader() -> itkMultiThreaderBaseEnums::Threader"""
        return _ITKCommonBasePython.itkMultiThreaderBase_GetGlobalDefaultThreader()

    @staticmethod
    def SetGlobalDefaultNumberOfThreads(val):
        r"""
        SetGlobalDefaultNumberOfThreads(val)

        Parameters
        ----------
        val: unsigned int

        """
        return _ITKCommonBasePython.itkMultiThreaderBase_SetGlobalDefaultNumberOfThreads(val)

    @staticmethod
    def GetGlobalDefaultNumberOfThreads():
        r"""GetGlobalDefaultNumberOfThreads() -> unsigned int"""
        return _ITKCommonBasePython.itkMultiThreaderBase_GetGlobalDefaultNumberOfThreads()

    def SingleMethodExecute(self):
        r"""SingleMethodExecute(self)"""
        return _ITKCommonBasePython.itkMultiThreaderBase_SingleMethodExecute(self)
    __swig_destroy__ = _ITKCommonBasePython.delete_itkMultiThreaderBase

    @staticmethod
    def cast(obj):
        r"""
        cast(obj) -> itkMultiThreaderBase

        Parameters
        ----------
        obj: itkLightObject *

        """
        return _ITKCommonBasePython.itkMultiThreaderBase_cast(obj)

    def New(*args, **kargs):
        """New() -> itkMultiThreaderBase

        Create a new object of the class itkMultiThreaderBase and set the input and the parameters if some
        named or non-named arguments are passed to that method.

        New() tries to assign all the non named parameters to the input of the new objects - the
        first non named parameter in the first input, etc.

        The named parameters are used by calling the method with the same name prefixed by 'Set'.

        Ex:

          itkMultiThreaderBase.New(reader, threshold=10)

        is (most of the time) equivalent to:

          obj = itkMultiThreaderBase.New()
          obj.SetInput(0, reader.GetOutput())
          obj.SetThreshold(10)
        """
        obj = itkMultiThreaderBase.__New_orig__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkMultiThreaderBase in _ITKCommonBasePython:
_ITKCommonBasePython.itkMultiThreaderBase_swigregister(itkMultiThreaderBase)
class itkPickEvent(itkAnyEvent):
    r"""Proxy of C++ itkPickEvent class."""

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

    def __init__(self, *args):
        r"""
        __init__(self) -> itkPickEvent
        __init__(self, s) -> itkPickEvent

        Parameters
        ----------
        s: itkPickEvent const &

        """
        _ITKCommonBasePython.itkPickEvent_swiginit(self, _ITKCommonBasePython.new_itkPickEvent(*args))
    __swig_destroy__ = _ITKCommonBasePython.delete_itkPickEvent

# Register itkPickEvent in _ITKCommonBasePython:
_ITKCommonBasePython.itkPickEvent_swigregister(itkPickEvent)

def itkPlatformMultiThreader_New():
    return itkPlatformMultiThreader.New()

class itkPlatformMultiThreader(itkMultiThreaderBase):
    r"""Proxy of C++ itkPlatformMultiThreader class."""

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

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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkPlatformMultiThreader_Pointer"""
        return _ITKCommonBasePython.itkPlatformMultiThreader___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkPlatformMultiThreader_Pointer"""
        return _ITKCommonBasePython.itkPlatformMultiThreader_Clone(self)
    __swig_destroy__ = _ITKCommonBasePython.delete_itkPlatformMultiThreader

    @staticmethod
    def cast(obj):
        r"""
        cast(obj) -> itkPlatformMultiThreader

        Parameters
        ----------
        obj: itkLightObject *

        """
        return _ITKCommonBasePython.itkPlatformMultiThreader_cast(obj)

    def New(*args, **kargs):
        """New() -> itkPlatformMultiThreader

        Create a new object of the class itkPlatformMultiThreader and set the input and the parameters if some
        named or non-named arguments are passed to that method.

        New() tries to assign all the non named parameters to the input of the new objects - the
        first non named parameter in the first input, etc.

        The named parameters are used by calling the method with the same name prefixed by 'Set'.

        Ex:

          itkPlatformMultiThreader.New(reader, threshold=10)

        is (most of the time) equivalent to:

          obj = itkPlatformMultiThreader.New()
          obj.SetInput(0, reader.GetOutput())
          obj.SetThreshold(10)
        """
        obj = itkPlatformMultiThreader.__New_orig__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkPlatformMultiThreader in _ITKCommonBasePython:
_ITKCommonBasePython.itkPlatformMultiThreader_swigregister(itkPlatformMultiThreader)

def itkPoolMultiThreader_New():
    return itkPoolMultiThreader.New()

class itkPoolMultiThreader(itkMultiThreaderBase):
    r"""Proxy of C++ itkPoolMultiThreader class."""

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

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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkPoolMultiThreader_Pointer"""
        return _ITKCommonBasePython.itkPoolMultiThreader___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkPoolMultiThreader_Pointer"""
        return _ITKCommonBasePython.itkPoolMultiThreader_Clone(self)
    __swig_destroy__ = _ITKCommonBasePython.delete_itkPoolMultiThreader

    @staticmethod
    def cast(obj):
        r"""
        cast(obj) -> itkPoolMultiThreader

        Parameters
        ----------
        obj: itkLightObject *

        """
        return _ITKCommonBasePython.itkPoolMultiThreader_cast(obj)

    def New(*args, **kargs):
        """New() -> itkPoolMultiThreader

        Create a new object of the class itkPoolMultiThreader and set the input and the parameters if some
        named or non-named arguments are passed to that method.

        New() tries to assign all the non named parameters to the input of the new objects - the
        first non named parameter in the first input, etc.

        The named parameters are used by calling the method with the same name prefixed by 'Set'.

        Ex:

          itkPoolMultiThreader.New(reader, threshold=10)

        is (most of the time) equivalent to:

          obj = itkPoolMultiThreader.New()
          obj.SetInput(0, reader.GetOutput())
          obj.SetThreshold(10)
        """
        obj = itkPoolMultiThreader.__New_orig__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkPoolMultiThreader in _ITKCommonBasePython:
_ITKCommonBasePython.itkPoolMultiThreader_swigregister(itkPoolMultiThreader)
class itkProgressEvent(itkAnyEvent):
    r"""Proxy of C++ itkProgressEvent class."""

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

    def __init__(self, *args):
        r"""
        __init__(self) -> itkProgressEvent
        __init__(self, s) -> itkProgressEvent

        Parameters
        ----------
        s: itkProgressEvent const &

        """
        _ITKCommonBasePython.itkProgressEvent_swiginit(self, _ITKCommonBasePython.new_itkProgressEvent(*args))
    __swig_destroy__ = _ITKCommonBasePython.delete_itkProgressEvent

# Register itkProgressEvent in _ITKCommonBasePython:
_ITKCommonBasePython.itkProgressEvent_swigregister(itkProgressEvent)
class itkStartEvent(itkAnyEvent):
    r"""Proxy of C++ itkStartEvent class."""

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

    def __init__(self, *args):
        r"""
        __init__(self) -> itkStartEvent
        __init__(self, s) -> itkStartEvent

        Parameters
        ----------
        s: itkStartEvent const &

        """
        _ITKCommonBasePython.itkStartEvent_swiginit(self, _ITKCommonBasePython.new_itkStartEvent(*args))
    __swig_destroy__ = _ITKCommonBasePython.delete_itkStartEvent

# Register itkStartEvent in _ITKCommonBasePython:
_ITKCommonBasePython.itkStartEvent_swigregister(itkStartEvent)
class itkStartPickEvent(itkPickEvent):
    r"""Proxy of C++ itkStartPickEvent class."""

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

    def __init__(self, *args):
        r"""
        __init__(self) -> itkStartPickEvent
        __init__(self, s) -> itkStartPickEvent

        Parameters
        ----------
        s: itkStartPickEvent const &

        """
        _ITKCommonBasePython.itkStartPickEvent_swiginit(self, _ITKCommonBasePython.new_itkStartPickEvent(*args))
    __swig_destroy__ = _ITKCommonBasePython.delete_itkStartPickEvent

# Register itkStartPickEvent in _ITKCommonBasePython:
_ITKCommonBasePython.itkStartPickEvent_swigregister(itkStartPickEvent)
class itkUserEvent(itkAnyEvent):
    r"""Proxy of C++ itkUserEvent class."""

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

    def __init__(self, *args):
        r"""
        __init__(self) -> itkUserEvent
        __init__(self, s) -> itkUserEvent

        Parameters
        ----------
        s: itkUserEvent const &

        """
        _ITKCommonBasePython.itkUserEvent_swiginit(self, _ITKCommonBasePython.new_itkUserEvent(*args))
    __swig_destroy__ = _ITKCommonBasePython.delete_itkUserEvent

# Register itkUserEvent in _ITKCommonBasePython:
_ITKCommonBasePython.itkUserEvent_swigregister(itkUserEvent)
class itkAbortCheckEvent(itkPickEvent):
    r"""Proxy of C++ itkAbortCheckEvent class."""

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

    def __init__(self, *args):
        r"""
        __init__(self) -> itkAbortCheckEvent
        __init__(self, s) -> itkAbortCheckEvent

        Parameters
        ----------
        s: itkAbortCheckEvent const &

        """
        _ITKCommonBasePython.itkAbortCheckEvent_swiginit(self, _ITKCommonBasePython.new_itkAbortCheckEvent(*args))
    __swig_destroy__ = _ITKCommonBasePython.delete_itkAbortCheckEvent

# Register itkAbortCheckEvent in _ITKCommonBasePython:
_ITKCommonBasePython.itkAbortCheckEvent_swigregister(itkAbortCheckEvent)
class itkAbortEvent(itkAnyEvent):
    r"""Proxy of C++ itkAbortEvent class."""

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

    def __init__(self, *args):
        r"""
        __init__(self) -> itkAbortEvent
        __init__(self, s) -> itkAbortEvent

        Parameters
        ----------
        s: itkAbortEvent const &

        """
        _ITKCommonBasePython.itkAbortEvent_swiginit(self, _ITKCommonBasePython.new_itkAbortEvent(*args))
    __swig_destroy__ = _ITKCommonBasePython.delete_itkAbortEvent

# Register itkAbortEvent in _ITKCommonBasePython:
_ITKCommonBasePython.itkAbortEvent_swigregister(itkAbortEvent)
class itkEndPickEvent(itkPickEvent):
    r"""Proxy of C++ itkEndPickEvent class."""

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

    def __init__(self, *args):
        r"""
        __init__(self) -> itkEndPickEvent
        __init__(self, s) -> itkEndPickEvent

        Parameters
        ----------
        s: itkEndPickEvent const &

        """
        _ITKCommonBasePython.itkEndPickEvent_swiginit(self, _ITKCommonBasePython.new_itkEndPickEvent(*args))
    __swig_destroy__ = _ITKCommonBasePython.delete_itkEndPickEvent

# Register itkEndPickEvent in _ITKCommonBasePython:
_ITKCommonBasePython.itkEndPickEvent_swigregister(itkEndPickEvent)
class itkFunctionAndGradientEvaluationIterationEvent(itkIterationEvent):
    r"""Proxy of C++ itkFunctionAndGradientEvaluationIterationEvent class."""

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

    def __init__(self, *args):
        r"""
        __init__(self) -> itkFunctionAndGradientEvaluationIterationEvent
        __init__(self, s) -> itkFunctionAndGradientEvaluationIterationEvent

        Parameters
        ----------
        s: itkFunctionAndGradientEvaluationIterationEvent const &

        """
        _ITKCommonBasePython.itkFunctionAndGradientEvaluationIterationEvent_swiginit(self, _ITKCommonBasePython.new_itkFunctionAndGradientEvaluationIterationEvent(*args))
    __swig_destroy__ = _ITKCommonBasePython.delete_itkFunctionAndGradientEvaluationIterationEvent

# Register itkFunctionAndGradientEvaluationIterationEvent in _ITKCommonBasePython:
_ITKCommonBasePython.itkFunctionAndGradientEvaluationIterationEvent_swigregister(itkFunctionAndGradientEvaluationIterationEvent)
class itkFunctionEvaluationIterationEvent(itkIterationEvent):
    r"""Proxy of C++ itkFunctionEvaluationIterationEvent class."""

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

    def __init__(self, *args):
        r"""
        __init__(self) -> itkFunctionEvaluationIterationEvent
        __init__(self, s) -> itkFunctionEvaluationIterationEvent

        Parameters
        ----------
        s: itkFunctionEvaluationIterationEvent const &

        """
        _ITKCommonBasePython.itkFunctionEvaluationIterationEvent_swiginit(self, _ITKCommonBasePython.new_itkFunctionEvaluationIterationEvent(*args))
    __swig_destroy__ = _ITKCommonBasePython.delete_itkFunctionEvaluationIterationEvent

# Register itkFunctionEvaluationIterationEvent in _ITKCommonBasePython:
_ITKCommonBasePython.itkFunctionEvaluationIterationEvent_swigregister(itkFunctionEvaluationIterationEvent)
class itkGradientEvaluationIterationEvent(itkIterationEvent):
    r"""Proxy of C++ itkGradientEvaluationIterationEvent class."""

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

    def __init__(self, *args):
        r"""
        __init__(self) -> itkGradientEvaluationIterationEvent
        __init__(self, s) -> itkGradientEvaluationIterationEvent

        Parameters
        ----------
        s: itkGradientEvaluationIterationEvent const &

        """
        _ITKCommonBasePython.itkGradientEvaluationIterationEvent_swiginit(self, _ITKCommonBasePython.new_itkGradientEvaluationIterationEvent(*args))
    __swig_destroy__ = _ITKCommonBasePython.delete_itkGradientEvaluationIterationEvent

# Register itkGradientEvaluationIterationEvent in _ITKCommonBasePython:
_ITKCommonBasePython.itkGradientEvaluationIterationEvent_swigregister(itkGradientEvaluationIterationEvent)

