# This file was automatically generated by SWIG (https://www.swig.org).
# Version 4.4.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 getattr(globals().get("__spec__"), "parent", None) or __package__ or "." in __name__:
    from . import _itkImageBoundaryConditionPython
else:
    import _itkImageBoundaryConditionPython

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.itkIndexPython
import itk.itkSizePython
import itk.pyBasePython
import itk.itkOffsetPython
import itk.ITKCommonBasePython
import itk.itkMatrixPython
import itk.itkCovariantVectorPython
import itk.vnl_vector_refPython
import itk.vnl_vectorPython
import itk.stdcomplexPython
import itk.vnl_matrixPython
import itk.itkFixedArrayPython
import itk.itkVectorPython
import itk.vnl_matrix_fixedPython
import itk.itkPointPython
import itk.itkImagePython
import itk.itkSymmetricSecondRankTensorPython
import itk.itkRGBAPixelPython
import itk.itkImageRegionPython
import itk.itkRGBPixelPython
class itkImageBoundaryConditionICF2(object):
    r"""Proxy of C++ itkImageBoundaryConditionICF2 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 _itkImageBoundaryConditionPython.itkImageBoundaryConditionICF2_GetNameOfClass(self)

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

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

        """
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionICF2_Print(self, os, i)

    def __call__(self, *args):
        r"""
        __call__(self, point_index, boundary_offset, data) -> stdcomplexF

        Parameters
        ----------
        point_index: itkOffset2 const &
        boundary_offset: itkOffset2 const &
        data: itk::Neighborhood< std::complex< float > * > const *

        __call__(self, point_index, boundary_offset, data, neighborhoodAccessorFunctor) -> stdcomplexF

        Parameters
        ----------
        point_index: itkOffset2 const &
        boundary_offset: itkOffset2 const &
        data: itk::Neighborhood< std::complex< float > * > const *
        neighborhoodAccessorFunctor: itk::NeighborhoodAccessorFunctor< itk::Image< std::complex< float > > > const &

        """
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionICF2___call__(self, *args)
    __swig_destroy__ = _itkImageBoundaryConditionPython.delete_itkImageBoundaryConditionICF2

    def RequiresCompleteNeighborhood(self):
        r"""RequiresCompleteNeighborhood(self) -> bool"""
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionICF2_RequiresCompleteNeighborhood(self)

    def GetInputRequestedRegion(self, inputLargestPossibleRegion, outputRequestedRegion):
        r"""
        GetInputRequestedRegion(self, inputLargestPossibleRegion, outputRequestedRegion) -> itkImageRegion2

        Parameters
        ----------
        inputLargestPossibleRegion: itkImageRegion2 const &
        outputRequestedRegion: itkImageRegion2 const &

        """
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionICF2_GetInputRequestedRegion(self, inputLargestPossibleRegion, outputRequestedRegion)

    def GetPixel(self, index, image):
        r"""
        GetPixel(self, index, image) -> stdcomplexF

        Parameters
        ----------
        index: itkIndex2 const &
        image: itkImageCF2 const *

        """
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionICF2_GetPixel(self, index, image)

# Register itkImageBoundaryConditionICF2 in _itkImageBoundaryConditionPython:
_itkImageBoundaryConditionPython.itkImageBoundaryConditionICF2_swigregister(itkImageBoundaryConditionICF2)
class itkImageBoundaryConditionICF3(object):
    r"""Proxy of C++ itkImageBoundaryConditionICF3 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 _itkImageBoundaryConditionPython.itkImageBoundaryConditionICF3_GetNameOfClass(self)

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

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

        """
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionICF3_Print(self, os, i)

    def __call__(self, *args):
        r"""
        __call__(self, point_index, boundary_offset, data) -> stdcomplexF

        Parameters
        ----------
        point_index: itkOffset3 const &
        boundary_offset: itkOffset3 const &
        data: itk::Neighborhood< std::complex< float > *,3 > const *

        __call__(self, point_index, boundary_offset, data, neighborhoodAccessorFunctor) -> stdcomplexF

        Parameters
        ----------
        point_index: itkOffset3 const &
        boundary_offset: itkOffset3 const &
        data: itk::Neighborhood< std::complex< float > *,3 > const *
        neighborhoodAccessorFunctor: itk::NeighborhoodAccessorFunctor< itk::Image< std::complex< float >,3 > > const &

        """
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionICF3___call__(self, *args)
    __swig_destroy__ = _itkImageBoundaryConditionPython.delete_itkImageBoundaryConditionICF3

    def RequiresCompleteNeighborhood(self):
        r"""RequiresCompleteNeighborhood(self) -> bool"""
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionICF3_RequiresCompleteNeighborhood(self)

    def GetInputRequestedRegion(self, inputLargestPossibleRegion, outputRequestedRegion):
        r"""
        GetInputRequestedRegion(self, inputLargestPossibleRegion, outputRequestedRegion) -> itkImageRegion3

        Parameters
        ----------
        inputLargestPossibleRegion: itkImageRegion3 const &
        outputRequestedRegion: itkImageRegion3 const &

        """
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionICF3_GetInputRequestedRegion(self, inputLargestPossibleRegion, outputRequestedRegion)

    def GetPixel(self, index, image):
        r"""
        GetPixel(self, index, image) -> stdcomplexF

        Parameters
        ----------
        index: itkIndex3 const &
        image: itkImageCF3 const *

        """
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionICF3_GetPixel(self, index, image)

# Register itkImageBoundaryConditionICF3 in _itkImageBoundaryConditionPython:
_itkImageBoundaryConditionPython.itkImageBoundaryConditionICF3_swigregister(itkImageBoundaryConditionICF3)
class itkImageBoundaryConditionICVF22(object):
    r"""Proxy of C++ itkImageBoundaryConditionICVF22 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 _itkImageBoundaryConditionPython.itkImageBoundaryConditionICVF22_GetNameOfClass(self)

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

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

        """
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionICVF22_Print(self, os, i)

    def __call__(self, *args):
        r"""
        __call__(self, point_index, boundary_offset, data) -> itkCovariantVectorF2

        Parameters
        ----------
        point_index: itkOffset2 const &
        boundary_offset: itkOffset2 const &
        data: itk::Neighborhood< itk::CovariantVector< float,2 > * > const *

        __call__(self, point_index, boundary_offset, data, neighborhoodAccessorFunctor) -> itkCovariantVectorF2

        Parameters
        ----------
        point_index: itkOffset2 const &
        boundary_offset: itkOffset2 const &
        data: itk::Neighborhood< itk::CovariantVector< float,2 > * > const *
        neighborhoodAccessorFunctor: itk::NeighborhoodAccessorFunctor< itk::Image< itk::CovariantVector< float,2 > > > const &

        """
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionICVF22___call__(self, *args)
    __swig_destroy__ = _itkImageBoundaryConditionPython.delete_itkImageBoundaryConditionICVF22

    def RequiresCompleteNeighborhood(self):
        r"""RequiresCompleteNeighborhood(self) -> bool"""
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionICVF22_RequiresCompleteNeighborhood(self)

    def GetInputRequestedRegion(self, inputLargestPossibleRegion, outputRequestedRegion):
        r"""
        GetInputRequestedRegion(self, inputLargestPossibleRegion, outputRequestedRegion) -> itkImageRegion2

        Parameters
        ----------
        inputLargestPossibleRegion: itkImageRegion2 const &
        outputRequestedRegion: itkImageRegion2 const &

        """
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionICVF22_GetInputRequestedRegion(self, inputLargestPossibleRegion, outputRequestedRegion)

    def GetPixel(self, index, image):
        r"""
        GetPixel(self, index, image) -> itkCovariantVectorF2

        Parameters
        ----------
        index: itkIndex2 const &
        image: itkImageCVF22 const *

        """
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionICVF22_GetPixel(self, index, image)

# Register itkImageBoundaryConditionICVF22 in _itkImageBoundaryConditionPython:
_itkImageBoundaryConditionPython.itkImageBoundaryConditionICVF22_swigregister(itkImageBoundaryConditionICVF22)
class itkImageBoundaryConditionICVF23(object):
    r"""Proxy of C++ itkImageBoundaryConditionICVF23 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 _itkImageBoundaryConditionPython.itkImageBoundaryConditionICVF23_GetNameOfClass(self)

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

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

        """
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionICVF23_Print(self, os, i)

    def __call__(self, *args):
        r"""
        __call__(self, point_index, boundary_offset, data) -> itkCovariantVectorF2

        Parameters
        ----------
        point_index: itkOffset3 const &
        boundary_offset: itkOffset3 const &
        data: itk::Neighborhood< itk::CovariantVector< float,2 > *,3 > const *

        __call__(self, point_index, boundary_offset, data, neighborhoodAccessorFunctor) -> itkCovariantVectorF2

        Parameters
        ----------
        point_index: itkOffset3 const &
        boundary_offset: itkOffset3 const &
        data: itk::Neighborhood< itk::CovariantVector< float,2 > *,3 > const *
        neighborhoodAccessorFunctor: itk::NeighborhoodAccessorFunctor< itk::Image< itk::CovariantVector< float,2 >,3 > > const &

        """
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionICVF23___call__(self, *args)
    __swig_destroy__ = _itkImageBoundaryConditionPython.delete_itkImageBoundaryConditionICVF23

    def RequiresCompleteNeighborhood(self):
        r"""RequiresCompleteNeighborhood(self) -> bool"""
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionICVF23_RequiresCompleteNeighborhood(self)

    def GetInputRequestedRegion(self, inputLargestPossibleRegion, outputRequestedRegion):
        r"""
        GetInputRequestedRegion(self, inputLargestPossibleRegion, outputRequestedRegion) -> itkImageRegion3

        Parameters
        ----------
        inputLargestPossibleRegion: itkImageRegion3 const &
        outputRequestedRegion: itkImageRegion3 const &

        """
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionICVF23_GetInputRequestedRegion(self, inputLargestPossibleRegion, outputRequestedRegion)

    def GetPixel(self, index, image):
        r"""
        GetPixel(self, index, image) -> itkCovariantVectorF2

        Parameters
        ----------
        index: itkIndex3 const &
        image: itkImageCVF23 const *

        """
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionICVF23_GetPixel(self, index, image)

# Register itkImageBoundaryConditionICVF23 in _itkImageBoundaryConditionPython:
_itkImageBoundaryConditionPython.itkImageBoundaryConditionICVF23_swigregister(itkImageBoundaryConditionICVF23)
class itkImageBoundaryConditionICVF32(object):
    r"""Proxy of C++ itkImageBoundaryConditionICVF32 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 _itkImageBoundaryConditionPython.itkImageBoundaryConditionICVF32_GetNameOfClass(self)

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

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

        """
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionICVF32_Print(self, os, i)

    def __call__(self, *args):
        r"""
        __call__(self, point_index, boundary_offset, data) -> itkCovariantVectorF3

        Parameters
        ----------
        point_index: itkOffset2 const &
        boundary_offset: itkOffset2 const &
        data: itk::Neighborhood< itk::CovariantVector< float > * > const *

        __call__(self, point_index, boundary_offset, data, neighborhoodAccessorFunctor) -> itkCovariantVectorF3

        Parameters
        ----------
        point_index: itkOffset2 const &
        boundary_offset: itkOffset2 const &
        data: itk::Neighborhood< itk::CovariantVector< float > * > const *
        neighborhoodAccessorFunctor: itk::NeighborhoodAccessorFunctor< itk::Image< itk::CovariantVector< float > > > const &

        """
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionICVF32___call__(self, *args)
    __swig_destroy__ = _itkImageBoundaryConditionPython.delete_itkImageBoundaryConditionICVF32

    def RequiresCompleteNeighborhood(self):
        r"""RequiresCompleteNeighborhood(self) -> bool"""
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionICVF32_RequiresCompleteNeighborhood(self)

    def GetInputRequestedRegion(self, inputLargestPossibleRegion, outputRequestedRegion):
        r"""
        GetInputRequestedRegion(self, inputLargestPossibleRegion, outputRequestedRegion) -> itkImageRegion2

        Parameters
        ----------
        inputLargestPossibleRegion: itkImageRegion2 const &
        outputRequestedRegion: itkImageRegion2 const &

        """
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionICVF32_GetInputRequestedRegion(self, inputLargestPossibleRegion, outputRequestedRegion)

    def GetPixel(self, index, image):
        r"""
        GetPixel(self, index, image) -> itkCovariantVectorF3

        Parameters
        ----------
        index: itkIndex2 const &
        image: itkImageCVF32 const *

        """
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionICVF32_GetPixel(self, index, image)

# Register itkImageBoundaryConditionICVF32 in _itkImageBoundaryConditionPython:
_itkImageBoundaryConditionPython.itkImageBoundaryConditionICVF32_swigregister(itkImageBoundaryConditionICVF32)
class itkImageBoundaryConditionICVF33(object):
    r"""Proxy of C++ itkImageBoundaryConditionICVF33 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 _itkImageBoundaryConditionPython.itkImageBoundaryConditionICVF33_GetNameOfClass(self)

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

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

        """
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionICVF33_Print(self, os, i)

    def __call__(self, *args):
        r"""
        __call__(self, point_index, boundary_offset, data) -> itkCovariantVectorF3

        Parameters
        ----------
        point_index: itkOffset3 const &
        boundary_offset: itkOffset3 const &
        data: itk::Neighborhood< itk::CovariantVector< float > *,3 > const *

        __call__(self, point_index, boundary_offset, data, neighborhoodAccessorFunctor) -> itkCovariantVectorF3

        Parameters
        ----------
        point_index: itkOffset3 const &
        boundary_offset: itkOffset3 const &
        data: itk::Neighborhood< itk::CovariantVector< float > *,3 > const *
        neighborhoodAccessorFunctor: itk::NeighborhoodAccessorFunctor< itk::Image< itk::CovariantVector< float >,3 > > const &

        """
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionICVF33___call__(self, *args)
    __swig_destroy__ = _itkImageBoundaryConditionPython.delete_itkImageBoundaryConditionICVF33

    def RequiresCompleteNeighborhood(self):
        r"""RequiresCompleteNeighborhood(self) -> bool"""
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionICVF33_RequiresCompleteNeighborhood(self)

    def GetInputRequestedRegion(self, inputLargestPossibleRegion, outputRequestedRegion):
        r"""
        GetInputRequestedRegion(self, inputLargestPossibleRegion, outputRequestedRegion) -> itkImageRegion3

        Parameters
        ----------
        inputLargestPossibleRegion: itkImageRegion3 const &
        outputRequestedRegion: itkImageRegion3 const &

        """
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionICVF33_GetInputRequestedRegion(self, inputLargestPossibleRegion, outputRequestedRegion)

    def GetPixel(self, index, image):
        r"""
        GetPixel(self, index, image) -> itkCovariantVectorF3

        Parameters
        ----------
        index: itkIndex3 const &
        image: itkImageCVF33 const *

        """
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionICVF33_GetPixel(self, index, image)

# Register itkImageBoundaryConditionICVF33 in _itkImageBoundaryConditionPython:
_itkImageBoundaryConditionPython.itkImageBoundaryConditionICVF33_swigregister(itkImageBoundaryConditionICVF33)
class itkImageBoundaryConditionICVF42(object):
    r"""Proxy of C++ itkImageBoundaryConditionICVF42 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 _itkImageBoundaryConditionPython.itkImageBoundaryConditionICVF42_GetNameOfClass(self)

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

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

        """
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionICVF42_Print(self, os, i)

    def __call__(self, *args):
        r"""
        __call__(self, point_index, boundary_offset, data) -> itkCovariantVectorF4

        Parameters
        ----------
        point_index: itkOffset2 const &
        boundary_offset: itkOffset2 const &
        data: itk::Neighborhood< itk::CovariantVector< float,4 > * > const *

        __call__(self, point_index, boundary_offset, data, neighborhoodAccessorFunctor) -> itkCovariantVectorF4

        Parameters
        ----------
        point_index: itkOffset2 const &
        boundary_offset: itkOffset2 const &
        data: itk::Neighborhood< itk::CovariantVector< float,4 > * > const *
        neighborhoodAccessorFunctor: itk::NeighborhoodAccessorFunctor< itk::Image< itk::CovariantVector< float,4 > > > const &

        """
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionICVF42___call__(self, *args)
    __swig_destroy__ = _itkImageBoundaryConditionPython.delete_itkImageBoundaryConditionICVF42

    def RequiresCompleteNeighborhood(self):
        r"""RequiresCompleteNeighborhood(self) -> bool"""
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionICVF42_RequiresCompleteNeighborhood(self)

    def GetInputRequestedRegion(self, inputLargestPossibleRegion, outputRequestedRegion):
        r"""
        GetInputRequestedRegion(self, inputLargestPossibleRegion, outputRequestedRegion) -> itkImageRegion2

        Parameters
        ----------
        inputLargestPossibleRegion: itkImageRegion2 const &
        outputRequestedRegion: itkImageRegion2 const &

        """
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionICVF42_GetInputRequestedRegion(self, inputLargestPossibleRegion, outputRequestedRegion)

    def GetPixel(self, index, image):
        r"""
        GetPixel(self, index, image) -> itkCovariantVectorF4

        Parameters
        ----------
        index: itkIndex2 const &
        image: itkImageCVF42 const *

        """
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionICVF42_GetPixel(self, index, image)

# Register itkImageBoundaryConditionICVF42 in _itkImageBoundaryConditionPython:
_itkImageBoundaryConditionPython.itkImageBoundaryConditionICVF42_swigregister(itkImageBoundaryConditionICVF42)
class itkImageBoundaryConditionICVF43(object):
    r"""Proxy of C++ itkImageBoundaryConditionICVF43 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 _itkImageBoundaryConditionPython.itkImageBoundaryConditionICVF43_GetNameOfClass(self)

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

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

        """
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionICVF43_Print(self, os, i)

    def __call__(self, *args):
        r"""
        __call__(self, point_index, boundary_offset, data) -> itkCovariantVectorF4

        Parameters
        ----------
        point_index: itkOffset3 const &
        boundary_offset: itkOffset3 const &
        data: itk::Neighborhood< itk::CovariantVector< float,4 > *,3 > const *

        __call__(self, point_index, boundary_offset, data, neighborhoodAccessorFunctor) -> itkCovariantVectorF4

        Parameters
        ----------
        point_index: itkOffset3 const &
        boundary_offset: itkOffset3 const &
        data: itk::Neighborhood< itk::CovariantVector< float,4 > *,3 > const *
        neighborhoodAccessorFunctor: itk::NeighborhoodAccessorFunctor< itk::Image< itk::CovariantVector< float,4 >,3 > > const &

        """
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionICVF43___call__(self, *args)
    __swig_destroy__ = _itkImageBoundaryConditionPython.delete_itkImageBoundaryConditionICVF43

    def RequiresCompleteNeighborhood(self):
        r"""RequiresCompleteNeighborhood(self) -> bool"""
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionICVF43_RequiresCompleteNeighborhood(self)

    def GetInputRequestedRegion(self, inputLargestPossibleRegion, outputRequestedRegion):
        r"""
        GetInputRequestedRegion(self, inputLargestPossibleRegion, outputRequestedRegion) -> itkImageRegion3

        Parameters
        ----------
        inputLargestPossibleRegion: itkImageRegion3 const &
        outputRequestedRegion: itkImageRegion3 const &

        """
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionICVF43_GetInputRequestedRegion(self, inputLargestPossibleRegion, outputRequestedRegion)

    def GetPixel(self, index, image):
        r"""
        GetPixel(self, index, image) -> itkCovariantVectorF4

        Parameters
        ----------
        index: itkIndex3 const &
        image: itkImageCVF43 const *

        """
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionICVF43_GetPixel(self, index, image)

# Register itkImageBoundaryConditionICVF43 in _itkImageBoundaryConditionPython:
_itkImageBoundaryConditionPython.itkImageBoundaryConditionICVF43_swigregister(itkImageBoundaryConditionICVF43)
class itkImageBoundaryConditionIF2(object):
    r"""Proxy of C++ itkImageBoundaryConditionIF2 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 _itkImageBoundaryConditionPython.itkImageBoundaryConditionIF2_GetNameOfClass(self)

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

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

        """
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionIF2_Print(self, os, i)

    def __call__(self, *args):
        r"""
        __call__(self, point_index, boundary_offset, data) -> float

        Parameters
        ----------
        point_index: itkOffset2 const &
        boundary_offset: itkOffset2 const &
        data: itk::Neighborhood< float * > const *

        __call__(self, point_index, boundary_offset, data, neighborhoodAccessorFunctor) -> float

        Parameters
        ----------
        point_index: itkOffset2 const &
        boundary_offset: itkOffset2 const &
        data: itk::Neighborhood< float * > const *
        neighborhoodAccessorFunctor: itk::NeighborhoodAccessorFunctor< itk::Image< float > > const &

        """
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionIF2___call__(self, *args)
    __swig_destroy__ = _itkImageBoundaryConditionPython.delete_itkImageBoundaryConditionIF2

    def RequiresCompleteNeighborhood(self):
        r"""RequiresCompleteNeighborhood(self) -> bool"""
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionIF2_RequiresCompleteNeighborhood(self)

    def GetInputRequestedRegion(self, inputLargestPossibleRegion, outputRequestedRegion):
        r"""
        GetInputRequestedRegion(self, inputLargestPossibleRegion, outputRequestedRegion) -> itkImageRegion2

        Parameters
        ----------
        inputLargestPossibleRegion: itkImageRegion2 const &
        outputRequestedRegion: itkImageRegion2 const &

        """
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionIF2_GetInputRequestedRegion(self, inputLargestPossibleRegion, outputRequestedRegion)

    def GetPixel(self, index, image):
        r"""
        GetPixel(self, index, image) -> float

        Parameters
        ----------
        index: itkIndex2 const &
        image: itkImageF2 const *

        """
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionIF2_GetPixel(self, index, image)

# Register itkImageBoundaryConditionIF2 in _itkImageBoundaryConditionPython:
_itkImageBoundaryConditionPython.itkImageBoundaryConditionIF2_swigregister(itkImageBoundaryConditionIF2)
class itkImageBoundaryConditionIF3(object):
    r"""Proxy of C++ itkImageBoundaryConditionIF3 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 _itkImageBoundaryConditionPython.itkImageBoundaryConditionIF3_GetNameOfClass(self)

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

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

        """
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionIF3_Print(self, os, i)

    def __call__(self, *args):
        r"""
        __call__(self, point_index, boundary_offset, data) -> float

        Parameters
        ----------
        point_index: itkOffset3 const &
        boundary_offset: itkOffset3 const &
        data: itk::Neighborhood< float *,3 > const *

        __call__(self, point_index, boundary_offset, data, neighborhoodAccessorFunctor) -> float

        Parameters
        ----------
        point_index: itkOffset3 const &
        boundary_offset: itkOffset3 const &
        data: itk::Neighborhood< float *,3 > const *
        neighborhoodAccessorFunctor: itk::NeighborhoodAccessorFunctor< itk::Image< float,3 > > const &

        """
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionIF3___call__(self, *args)
    __swig_destroy__ = _itkImageBoundaryConditionPython.delete_itkImageBoundaryConditionIF3

    def RequiresCompleteNeighborhood(self):
        r"""RequiresCompleteNeighborhood(self) -> bool"""
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionIF3_RequiresCompleteNeighborhood(self)

    def GetInputRequestedRegion(self, inputLargestPossibleRegion, outputRequestedRegion):
        r"""
        GetInputRequestedRegion(self, inputLargestPossibleRegion, outputRequestedRegion) -> itkImageRegion3

        Parameters
        ----------
        inputLargestPossibleRegion: itkImageRegion3 const &
        outputRequestedRegion: itkImageRegion3 const &

        """
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionIF3_GetInputRequestedRegion(self, inputLargestPossibleRegion, outputRequestedRegion)

    def GetPixel(self, index, image):
        r"""
        GetPixel(self, index, image) -> float

        Parameters
        ----------
        index: itkIndex3 const &
        image: itkImageF3 const *

        """
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionIF3_GetPixel(self, index, image)

# Register itkImageBoundaryConditionIF3 in _itkImageBoundaryConditionPython:
_itkImageBoundaryConditionPython.itkImageBoundaryConditionIF3_swigregister(itkImageBoundaryConditionIF3)
class itkImageBoundaryConditionIRGBAUC2(object):
    r"""Proxy of C++ itkImageBoundaryConditionIRGBAUC2 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 _itkImageBoundaryConditionPython.itkImageBoundaryConditionIRGBAUC2_GetNameOfClass(self)

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

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

        """
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionIRGBAUC2_Print(self, os, i)

    def __call__(self, *args):
        r"""
        __call__(self, point_index, boundary_offset, data) -> itkRGBAPixelUC

        Parameters
        ----------
        point_index: itkOffset2 const &
        boundary_offset: itkOffset2 const &
        data: itk::Neighborhood< itk::RGBAPixel< unsigned char > * > const *

        __call__(self, point_index, boundary_offset, data, neighborhoodAccessorFunctor) -> itkRGBAPixelUC

        Parameters
        ----------
        point_index: itkOffset2 const &
        boundary_offset: itkOffset2 const &
        data: itk::Neighborhood< itk::RGBAPixel< unsigned char > * > const *
        neighborhoodAccessorFunctor: itk::NeighborhoodAccessorFunctor< itk::Image< itk::RGBAPixel< unsigned char > > > const &

        """
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionIRGBAUC2___call__(self, *args)
    __swig_destroy__ = _itkImageBoundaryConditionPython.delete_itkImageBoundaryConditionIRGBAUC2

    def RequiresCompleteNeighborhood(self):
        r"""RequiresCompleteNeighborhood(self) -> bool"""
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionIRGBAUC2_RequiresCompleteNeighborhood(self)

    def GetInputRequestedRegion(self, inputLargestPossibleRegion, outputRequestedRegion):
        r"""
        GetInputRequestedRegion(self, inputLargestPossibleRegion, outputRequestedRegion) -> itkImageRegion2

        Parameters
        ----------
        inputLargestPossibleRegion: itkImageRegion2 const &
        outputRequestedRegion: itkImageRegion2 const &

        """
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionIRGBAUC2_GetInputRequestedRegion(self, inputLargestPossibleRegion, outputRequestedRegion)

    def GetPixel(self, index, image):
        r"""
        GetPixel(self, index, image) -> itkRGBAPixelUC

        Parameters
        ----------
        index: itkIndex2 const &
        image: itkImageRGBAUC2 const *

        """
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionIRGBAUC2_GetPixel(self, index, image)

# Register itkImageBoundaryConditionIRGBAUC2 in _itkImageBoundaryConditionPython:
_itkImageBoundaryConditionPython.itkImageBoundaryConditionIRGBAUC2_swigregister(itkImageBoundaryConditionIRGBAUC2)
class itkImageBoundaryConditionIRGBAUC3(object):
    r"""Proxy of C++ itkImageBoundaryConditionIRGBAUC3 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 _itkImageBoundaryConditionPython.itkImageBoundaryConditionIRGBAUC3_GetNameOfClass(self)

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

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

        """
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionIRGBAUC3_Print(self, os, i)

    def __call__(self, *args):
        r"""
        __call__(self, point_index, boundary_offset, data) -> itkRGBAPixelUC

        Parameters
        ----------
        point_index: itkOffset3 const &
        boundary_offset: itkOffset3 const &
        data: itk::Neighborhood< itk::RGBAPixel< unsigned char > *,3 > const *

        __call__(self, point_index, boundary_offset, data, neighborhoodAccessorFunctor) -> itkRGBAPixelUC

        Parameters
        ----------
        point_index: itkOffset3 const &
        boundary_offset: itkOffset3 const &
        data: itk::Neighborhood< itk::RGBAPixel< unsigned char > *,3 > const *
        neighborhoodAccessorFunctor: itk::NeighborhoodAccessorFunctor< itk::Image< itk::RGBAPixel< unsigned char >,3 > > const &

        """
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionIRGBAUC3___call__(self, *args)
    __swig_destroy__ = _itkImageBoundaryConditionPython.delete_itkImageBoundaryConditionIRGBAUC3

    def RequiresCompleteNeighborhood(self):
        r"""RequiresCompleteNeighborhood(self) -> bool"""
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionIRGBAUC3_RequiresCompleteNeighborhood(self)

    def GetInputRequestedRegion(self, inputLargestPossibleRegion, outputRequestedRegion):
        r"""
        GetInputRequestedRegion(self, inputLargestPossibleRegion, outputRequestedRegion) -> itkImageRegion3

        Parameters
        ----------
        inputLargestPossibleRegion: itkImageRegion3 const &
        outputRequestedRegion: itkImageRegion3 const &

        """
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionIRGBAUC3_GetInputRequestedRegion(self, inputLargestPossibleRegion, outputRequestedRegion)

    def GetPixel(self, index, image):
        r"""
        GetPixel(self, index, image) -> itkRGBAPixelUC

        Parameters
        ----------
        index: itkIndex3 const &
        image: itkImageRGBAUC3 const *

        """
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionIRGBAUC3_GetPixel(self, index, image)

# Register itkImageBoundaryConditionIRGBAUC3 in _itkImageBoundaryConditionPython:
_itkImageBoundaryConditionPython.itkImageBoundaryConditionIRGBAUC3_swigregister(itkImageBoundaryConditionIRGBAUC3)
class itkImageBoundaryConditionIRGBUC2(object):
    r"""Proxy of C++ itkImageBoundaryConditionIRGBUC2 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 _itkImageBoundaryConditionPython.itkImageBoundaryConditionIRGBUC2_GetNameOfClass(self)

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

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

        """
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionIRGBUC2_Print(self, os, i)

    def __call__(self, *args):
        r"""
        __call__(self, point_index, boundary_offset, data) -> itkRGBPixelUC

        Parameters
        ----------
        point_index: itkOffset2 const &
        boundary_offset: itkOffset2 const &
        data: itk::Neighborhood< itk::RGBPixel< unsigned char > * > const *

        __call__(self, point_index, boundary_offset, data, neighborhoodAccessorFunctor) -> itkRGBPixelUC

        Parameters
        ----------
        point_index: itkOffset2 const &
        boundary_offset: itkOffset2 const &
        data: itk::Neighborhood< itk::RGBPixel< unsigned char > * > const *
        neighborhoodAccessorFunctor: itk::NeighborhoodAccessorFunctor< itk::Image< itk::RGBPixel< unsigned char > > > const &

        """
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionIRGBUC2___call__(self, *args)
    __swig_destroy__ = _itkImageBoundaryConditionPython.delete_itkImageBoundaryConditionIRGBUC2

    def RequiresCompleteNeighborhood(self):
        r"""RequiresCompleteNeighborhood(self) -> bool"""
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionIRGBUC2_RequiresCompleteNeighborhood(self)

    def GetInputRequestedRegion(self, inputLargestPossibleRegion, outputRequestedRegion):
        r"""
        GetInputRequestedRegion(self, inputLargestPossibleRegion, outputRequestedRegion) -> itkImageRegion2

        Parameters
        ----------
        inputLargestPossibleRegion: itkImageRegion2 const &
        outputRequestedRegion: itkImageRegion2 const &

        """
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionIRGBUC2_GetInputRequestedRegion(self, inputLargestPossibleRegion, outputRequestedRegion)

    def GetPixel(self, index, image):
        r"""
        GetPixel(self, index, image) -> itkRGBPixelUC

        Parameters
        ----------
        index: itkIndex2 const &
        image: itkImageRGBUC2 const *

        """
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionIRGBUC2_GetPixel(self, index, image)

# Register itkImageBoundaryConditionIRGBUC2 in _itkImageBoundaryConditionPython:
_itkImageBoundaryConditionPython.itkImageBoundaryConditionIRGBUC2_swigregister(itkImageBoundaryConditionIRGBUC2)
class itkImageBoundaryConditionIRGBUC3(object):
    r"""Proxy of C++ itkImageBoundaryConditionIRGBUC3 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 _itkImageBoundaryConditionPython.itkImageBoundaryConditionIRGBUC3_GetNameOfClass(self)

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

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

        """
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionIRGBUC3_Print(self, os, i)

    def __call__(self, *args):
        r"""
        __call__(self, point_index, boundary_offset, data) -> itkRGBPixelUC

        Parameters
        ----------
        point_index: itkOffset3 const &
        boundary_offset: itkOffset3 const &
        data: itk::Neighborhood< itk::RGBPixel< unsigned char > *,3 > const *

        __call__(self, point_index, boundary_offset, data, neighborhoodAccessorFunctor) -> itkRGBPixelUC

        Parameters
        ----------
        point_index: itkOffset3 const &
        boundary_offset: itkOffset3 const &
        data: itk::Neighborhood< itk::RGBPixel< unsigned char > *,3 > const *
        neighborhoodAccessorFunctor: itk::NeighborhoodAccessorFunctor< itk::Image< itk::RGBPixel< unsigned char >,3 > > const &

        """
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionIRGBUC3___call__(self, *args)
    __swig_destroy__ = _itkImageBoundaryConditionPython.delete_itkImageBoundaryConditionIRGBUC3

    def RequiresCompleteNeighborhood(self):
        r"""RequiresCompleteNeighborhood(self) -> bool"""
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionIRGBUC3_RequiresCompleteNeighborhood(self)

    def GetInputRequestedRegion(self, inputLargestPossibleRegion, outputRequestedRegion):
        r"""
        GetInputRequestedRegion(self, inputLargestPossibleRegion, outputRequestedRegion) -> itkImageRegion3

        Parameters
        ----------
        inputLargestPossibleRegion: itkImageRegion3 const &
        outputRequestedRegion: itkImageRegion3 const &

        """
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionIRGBUC3_GetInputRequestedRegion(self, inputLargestPossibleRegion, outputRequestedRegion)

    def GetPixel(self, index, image):
        r"""
        GetPixel(self, index, image) -> itkRGBPixelUC

        Parameters
        ----------
        index: itkIndex3 const &
        image: itkImageRGBUC3 const *

        """
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionIRGBUC3_GetPixel(self, index, image)

# Register itkImageBoundaryConditionIRGBUC3 in _itkImageBoundaryConditionPython:
_itkImageBoundaryConditionPython.itkImageBoundaryConditionIRGBUC3_swigregister(itkImageBoundaryConditionIRGBUC3)
class itkImageBoundaryConditionISS2(object):
    r"""Proxy of C++ itkImageBoundaryConditionISS2 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 _itkImageBoundaryConditionPython.itkImageBoundaryConditionISS2_GetNameOfClass(self)

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

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

        """
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionISS2_Print(self, os, i)

    def __call__(self, *args):
        r"""
        __call__(self, point_index, boundary_offset, data) -> short

        Parameters
        ----------
        point_index: itkOffset2 const &
        boundary_offset: itkOffset2 const &
        data: itk::Neighborhood< short * > const *

        __call__(self, point_index, boundary_offset, data, neighborhoodAccessorFunctor) -> short

        Parameters
        ----------
        point_index: itkOffset2 const &
        boundary_offset: itkOffset2 const &
        data: itk::Neighborhood< short * > const *
        neighborhoodAccessorFunctor: itk::NeighborhoodAccessorFunctor< itk::Image< short > > const &

        """
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionISS2___call__(self, *args)
    __swig_destroy__ = _itkImageBoundaryConditionPython.delete_itkImageBoundaryConditionISS2

    def RequiresCompleteNeighborhood(self):
        r"""RequiresCompleteNeighborhood(self) -> bool"""
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionISS2_RequiresCompleteNeighborhood(self)

    def GetInputRequestedRegion(self, inputLargestPossibleRegion, outputRequestedRegion):
        r"""
        GetInputRequestedRegion(self, inputLargestPossibleRegion, outputRequestedRegion) -> itkImageRegion2

        Parameters
        ----------
        inputLargestPossibleRegion: itkImageRegion2 const &
        outputRequestedRegion: itkImageRegion2 const &

        """
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionISS2_GetInputRequestedRegion(self, inputLargestPossibleRegion, outputRequestedRegion)

    def GetPixel(self, index, image):
        r"""
        GetPixel(self, index, image) -> short

        Parameters
        ----------
        index: itkIndex2 const &
        image: itkImageSS2 const *

        """
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionISS2_GetPixel(self, index, image)

# Register itkImageBoundaryConditionISS2 in _itkImageBoundaryConditionPython:
_itkImageBoundaryConditionPython.itkImageBoundaryConditionISS2_swigregister(itkImageBoundaryConditionISS2)
class itkImageBoundaryConditionISS3(object):
    r"""Proxy of C++ itkImageBoundaryConditionISS3 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 _itkImageBoundaryConditionPython.itkImageBoundaryConditionISS3_GetNameOfClass(self)

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

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

        """
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionISS3_Print(self, os, i)

    def __call__(self, *args):
        r"""
        __call__(self, point_index, boundary_offset, data) -> short

        Parameters
        ----------
        point_index: itkOffset3 const &
        boundary_offset: itkOffset3 const &
        data: itk::Neighborhood< short *,3 > const *

        __call__(self, point_index, boundary_offset, data, neighborhoodAccessorFunctor) -> short

        Parameters
        ----------
        point_index: itkOffset3 const &
        boundary_offset: itkOffset3 const &
        data: itk::Neighborhood< short *,3 > const *
        neighborhoodAccessorFunctor: itk::NeighborhoodAccessorFunctor< itk::Image< short,3 > > const &

        """
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionISS3___call__(self, *args)
    __swig_destroy__ = _itkImageBoundaryConditionPython.delete_itkImageBoundaryConditionISS3

    def RequiresCompleteNeighborhood(self):
        r"""RequiresCompleteNeighborhood(self) -> bool"""
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionISS3_RequiresCompleteNeighborhood(self)

    def GetInputRequestedRegion(self, inputLargestPossibleRegion, outputRequestedRegion):
        r"""
        GetInputRequestedRegion(self, inputLargestPossibleRegion, outputRequestedRegion) -> itkImageRegion3

        Parameters
        ----------
        inputLargestPossibleRegion: itkImageRegion3 const &
        outputRequestedRegion: itkImageRegion3 const &

        """
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionISS3_GetInputRequestedRegion(self, inputLargestPossibleRegion, outputRequestedRegion)

    def GetPixel(self, index, image):
        r"""
        GetPixel(self, index, image) -> short

        Parameters
        ----------
        index: itkIndex3 const &
        image: itkImageSS3 const *

        """
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionISS3_GetPixel(self, index, image)

# Register itkImageBoundaryConditionISS3 in _itkImageBoundaryConditionPython:
_itkImageBoundaryConditionPython.itkImageBoundaryConditionISS3_swigregister(itkImageBoundaryConditionISS3)
class itkImageBoundaryConditionIUC2(object):
    r"""Proxy of C++ itkImageBoundaryConditionIUC2 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 _itkImageBoundaryConditionPython.itkImageBoundaryConditionIUC2_GetNameOfClass(self)

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

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

        """
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionIUC2_Print(self, os, i)

    def __call__(self, *args):
        r"""
        __call__(self, point_index, boundary_offset, data) -> unsigned char

        Parameters
        ----------
        point_index: itkOffset2 const &
        boundary_offset: itkOffset2 const &
        data: itk::Neighborhood< unsigned char * > const *

        __call__(self, point_index, boundary_offset, data, neighborhoodAccessorFunctor) -> unsigned char

        Parameters
        ----------
        point_index: itkOffset2 const &
        boundary_offset: itkOffset2 const &
        data: itk::Neighborhood< unsigned char * > const *
        neighborhoodAccessorFunctor: itk::NeighborhoodAccessorFunctor< itk::Image< unsigned char > > const &

        """
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionIUC2___call__(self, *args)
    __swig_destroy__ = _itkImageBoundaryConditionPython.delete_itkImageBoundaryConditionIUC2

    def RequiresCompleteNeighborhood(self):
        r"""RequiresCompleteNeighborhood(self) -> bool"""
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionIUC2_RequiresCompleteNeighborhood(self)

    def GetInputRequestedRegion(self, inputLargestPossibleRegion, outputRequestedRegion):
        r"""
        GetInputRequestedRegion(self, inputLargestPossibleRegion, outputRequestedRegion) -> itkImageRegion2

        Parameters
        ----------
        inputLargestPossibleRegion: itkImageRegion2 const &
        outputRequestedRegion: itkImageRegion2 const &

        """
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionIUC2_GetInputRequestedRegion(self, inputLargestPossibleRegion, outputRequestedRegion)

    def GetPixel(self, index, image):
        r"""
        GetPixel(self, index, image) -> unsigned char

        Parameters
        ----------
        index: itkIndex2 const &
        image: itkImageUC2 const *

        """
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionIUC2_GetPixel(self, index, image)

# Register itkImageBoundaryConditionIUC2 in _itkImageBoundaryConditionPython:
_itkImageBoundaryConditionPython.itkImageBoundaryConditionIUC2_swigregister(itkImageBoundaryConditionIUC2)
class itkImageBoundaryConditionIUC3(object):
    r"""Proxy of C++ itkImageBoundaryConditionIUC3 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 _itkImageBoundaryConditionPython.itkImageBoundaryConditionIUC3_GetNameOfClass(self)

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

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

        """
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionIUC3_Print(self, os, i)

    def __call__(self, *args):
        r"""
        __call__(self, point_index, boundary_offset, data) -> unsigned char

        Parameters
        ----------
        point_index: itkOffset3 const &
        boundary_offset: itkOffset3 const &
        data: itk::Neighborhood< unsigned char *,3 > const *

        __call__(self, point_index, boundary_offset, data, neighborhoodAccessorFunctor) -> unsigned char

        Parameters
        ----------
        point_index: itkOffset3 const &
        boundary_offset: itkOffset3 const &
        data: itk::Neighborhood< unsigned char *,3 > const *
        neighborhoodAccessorFunctor: itk::NeighborhoodAccessorFunctor< itk::Image< unsigned char,3 > > const &

        """
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionIUC3___call__(self, *args)
    __swig_destroy__ = _itkImageBoundaryConditionPython.delete_itkImageBoundaryConditionIUC3

    def RequiresCompleteNeighborhood(self):
        r"""RequiresCompleteNeighborhood(self) -> bool"""
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionIUC3_RequiresCompleteNeighborhood(self)

    def GetInputRequestedRegion(self, inputLargestPossibleRegion, outputRequestedRegion):
        r"""
        GetInputRequestedRegion(self, inputLargestPossibleRegion, outputRequestedRegion) -> itkImageRegion3

        Parameters
        ----------
        inputLargestPossibleRegion: itkImageRegion3 const &
        outputRequestedRegion: itkImageRegion3 const &

        """
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionIUC3_GetInputRequestedRegion(self, inputLargestPossibleRegion, outputRequestedRegion)

    def GetPixel(self, index, image):
        r"""
        GetPixel(self, index, image) -> unsigned char

        Parameters
        ----------
        index: itkIndex3 const &
        image: itkImageUC3 const *

        """
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionIUC3_GetPixel(self, index, image)

# Register itkImageBoundaryConditionIUC3 in _itkImageBoundaryConditionPython:
_itkImageBoundaryConditionPython.itkImageBoundaryConditionIUC3_swigregister(itkImageBoundaryConditionIUC3)
class itkImageBoundaryConditionIVF22(object):
    r"""Proxy of C++ itkImageBoundaryConditionIVF22 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 _itkImageBoundaryConditionPython.itkImageBoundaryConditionIVF22_GetNameOfClass(self)

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

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

        """
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionIVF22_Print(self, os, i)

    def __call__(self, *args):
        r"""
        __call__(self, point_index, boundary_offset, data) -> itkVectorF2

        Parameters
        ----------
        point_index: itkOffset2 const &
        boundary_offset: itkOffset2 const &
        data: itk::Neighborhood< itk::Vector< float,2 > * > const *

        __call__(self, point_index, boundary_offset, data, neighborhoodAccessorFunctor) -> itkVectorF2

        Parameters
        ----------
        point_index: itkOffset2 const &
        boundary_offset: itkOffset2 const &
        data: itk::Neighborhood< itk::Vector< float,2 > * > const *
        neighborhoodAccessorFunctor: itk::NeighborhoodAccessorFunctor< itk::Image< itk::Vector< float,2 > > > const &

        """
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionIVF22___call__(self, *args)
    __swig_destroy__ = _itkImageBoundaryConditionPython.delete_itkImageBoundaryConditionIVF22

    def RequiresCompleteNeighborhood(self):
        r"""RequiresCompleteNeighborhood(self) -> bool"""
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionIVF22_RequiresCompleteNeighborhood(self)

    def GetInputRequestedRegion(self, inputLargestPossibleRegion, outputRequestedRegion):
        r"""
        GetInputRequestedRegion(self, inputLargestPossibleRegion, outputRequestedRegion) -> itkImageRegion2

        Parameters
        ----------
        inputLargestPossibleRegion: itkImageRegion2 const &
        outputRequestedRegion: itkImageRegion2 const &

        """
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionIVF22_GetInputRequestedRegion(self, inputLargestPossibleRegion, outputRequestedRegion)

    def GetPixel(self, index, image):
        r"""
        GetPixel(self, index, image) -> itkVectorF2

        Parameters
        ----------
        index: itkIndex2 const &
        image: itkImageVF22 const *

        """
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionIVF22_GetPixel(self, index, image)

# Register itkImageBoundaryConditionIVF22 in _itkImageBoundaryConditionPython:
_itkImageBoundaryConditionPython.itkImageBoundaryConditionIVF22_swigregister(itkImageBoundaryConditionIVF22)
class itkImageBoundaryConditionIVF23(object):
    r"""Proxy of C++ itkImageBoundaryConditionIVF23 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 _itkImageBoundaryConditionPython.itkImageBoundaryConditionIVF23_GetNameOfClass(self)

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

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

        """
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionIVF23_Print(self, os, i)

    def __call__(self, *args):
        r"""
        __call__(self, point_index, boundary_offset, data) -> itkVectorF2

        Parameters
        ----------
        point_index: itkOffset3 const &
        boundary_offset: itkOffset3 const &
        data: itk::Neighborhood< itk::Vector< float,2 > *,3 > const *

        __call__(self, point_index, boundary_offset, data, neighborhoodAccessorFunctor) -> itkVectorF2

        Parameters
        ----------
        point_index: itkOffset3 const &
        boundary_offset: itkOffset3 const &
        data: itk::Neighborhood< itk::Vector< float,2 > *,3 > const *
        neighborhoodAccessorFunctor: itk::NeighborhoodAccessorFunctor< itk::Image< itk::Vector< float,2 >,3 > > const &

        """
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionIVF23___call__(self, *args)
    __swig_destroy__ = _itkImageBoundaryConditionPython.delete_itkImageBoundaryConditionIVF23

    def RequiresCompleteNeighborhood(self):
        r"""RequiresCompleteNeighborhood(self) -> bool"""
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionIVF23_RequiresCompleteNeighborhood(self)

    def GetInputRequestedRegion(self, inputLargestPossibleRegion, outputRequestedRegion):
        r"""
        GetInputRequestedRegion(self, inputLargestPossibleRegion, outputRequestedRegion) -> itkImageRegion3

        Parameters
        ----------
        inputLargestPossibleRegion: itkImageRegion3 const &
        outputRequestedRegion: itkImageRegion3 const &

        """
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionIVF23_GetInputRequestedRegion(self, inputLargestPossibleRegion, outputRequestedRegion)

    def GetPixel(self, index, image):
        r"""
        GetPixel(self, index, image) -> itkVectorF2

        Parameters
        ----------
        index: itkIndex3 const &
        image: itkImageVF23 const *

        """
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionIVF23_GetPixel(self, index, image)

# Register itkImageBoundaryConditionIVF23 in _itkImageBoundaryConditionPython:
_itkImageBoundaryConditionPython.itkImageBoundaryConditionIVF23_swigregister(itkImageBoundaryConditionIVF23)
class itkImageBoundaryConditionIVF32(object):
    r"""Proxy of C++ itkImageBoundaryConditionIVF32 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 _itkImageBoundaryConditionPython.itkImageBoundaryConditionIVF32_GetNameOfClass(self)

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

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

        """
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionIVF32_Print(self, os, i)

    def __call__(self, *args):
        r"""
        __call__(self, point_index, boundary_offset, data) -> itkVectorF3

        Parameters
        ----------
        point_index: itkOffset2 const &
        boundary_offset: itkOffset2 const &
        data: itk::Neighborhood< itk::Vector< float > * > const *

        __call__(self, point_index, boundary_offset, data, neighborhoodAccessorFunctor) -> itkVectorF3

        Parameters
        ----------
        point_index: itkOffset2 const &
        boundary_offset: itkOffset2 const &
        data: itk::Neighborhood< itk::Vector< float > * > const *
        neighborhoodAccessorFunctor: itk::NeighborhoodAccessorFunctor< itk::Image< itk::Vector< float > > > const &

        """
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionIVF32___call__(self, *args)
    __swig_destroy__ = _itkImageBoundaryConditionPython.delete_itkImageBoundaryConditionIVF32

    def RequiresCompleteNeighborhood(self):
        r"""RequiresCompleteNeighborhood(self) -> bool"""
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionIVF32_RequiresCompleteNeighborhood(self)

    def GetInputRequestedRegion(self, inputLargestPossibleRegion, outputRequestedRegion):
        r"""
        GetInputRequestedRegion(self, inputLargestPossibleRegion, outputRequestedRegion) -> itkImageRegion2

        Parameters
        ----------
        inputLargestPossibleRegion: itkImageRegion2 const &
        outputRequestedRegion: itkImageRegion2 const &

        """
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionIVF32_GetInputRequestedRegion(self, inputLargestPossibleRegion, outputRequestedRegion)

    def GetPixel(self, index, image):
        r"""
        GetPixel(self, index, image) -> itkVectorF3

        Parameters
        ----------
        index: itkIndex2 const &
        image: itkImageVF32 const *

        """
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionIVF32_GetPixel(self, index, image)

# Register itkImageBoundaryConditionIVF32 in _itkImageBoundaryConditionPython:
_itkImageBoundaryConditionPython.itkImageBoundaryConditionIVF32_swigregister(itkImageBoundaryConditionIVF32)
class itkImageBoundaryConditionIVF33(object):
    r"""Proxy of C++ itkImageBoundaryConditionIVF33 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 _itkImageBoundaryConditionPython.itkImageBoundaryConditionIVF33_GetNameOfClass(self)

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

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

        """
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionIVF33_Print(self, os, i)

    def __call__(self, *args):
        r"""
        __call__(self, point_index, boundary_offset, data) -> itkVectorF3

        Parameters
        ----------
        point_index: itkOffset3 const &
        boundary_offset: itkOffset3 const &
        data: itk::Neighborhood< itk::Vector< float > *,3 > const *

        __call__(self, point_index, boundary_offset, data, neighborhoodAccessorFunctor) -> itkVectorF3

        Parameters
        ----------
        point_index: itkOffset3 const &
        boundary_offset: itkOffset3 const &
        data: itk::Neighborhood< itk::Vector< float > *,3 > const *
        neighborhoodAccessorFunctor: itk::NeighborhoodAccessorFunctor< itk::Image< itk::Vector< float >,3 > > const &

        """
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionIVF33___call__(self, *args)
    __swig_destroy__ = _itkImageBoundaryConditionPython.delete_itkImageBoundaryConditionIVF33

    def RequiresCompleteNeighborhood(self):
        r"""RequiresCompleteNeighborhood(self) -> bool"""
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionIVF33_RequiresCompleteNeighborhood(self)

    def GetInputRequestedRegion(self, inputLargestPossibleRegion, outputRequestedRegion):
        r"""
        GetInputRequestedRegion(self, inputLargestPossibleRegion, outputRequestedRegion) -> itkImageRegion3

        Parameters
        ----------
        inputLargestPossibleRegion: itkImageRegion3 const &
        outputRequestedRegion: itkImageRegion3 const &

        """
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionIVF33_GetInputRequestedRegion(self, inputLargestPossibleRegion, outputRequestedRegion)

    def GetPixel(self, index, image):
        r"""
        GetPixel(self, index, image) -> itkVectorF3

        Parameters
        ----------
        index: itkIndex3 const &
        image: itkImageVF33 const *

        """
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionIVF33_GetPixel(self, index, image)

# Register itkImageBoundaryConditionIVF33 in _itkImageBoundaryConditionPython:
_itkImageBoundaryConditionPython.itkImageBoundaryConditionIVF33_swigregister(itkImageBoundaryConditionIVF33)
class itkImageBoundaryConditionIVF42(object):
    r"""Proxy of C++ itkImageBoundaryConditionIVF42 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 _itkImageBoundaryConditionPython.itkImageBoundaryConditionIVF42_GetNameOfClass(self)

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

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

        """
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionIVF42_Print(self, os, i)

    def __call__(self, *args):
        r"""
        __call__(self, point_index, boundary_offset, data) -> itkVectorF4

        Parameters
        ----------
        point_index: itkOffset2 const &
        boundary_offset: itkOffset2 const &
        data: itk::Neighborhood< itk::Vector< float,4 > * > const *

        __call__(self, point_index, boundary_offset, data, neighborhoodAccessorFunctor) -> itkVectorF4

        Parameters
        ----------
        point_index: itkOffset2 const &
        boundary_offset: itkOffset2 const &
        data: itk::Neighborhood< itk::Vector< float,4 > * > const *
        neighborhoodAccessorFunctor: itk::NeighborhoodAccessorFunctor< itk::Image< itk::Vector< float,4 > > > const &

        """
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionIVF42___call__(self, *args)
    __swig_destroy__ = _itkImageBoundaryConditionPython.delete_itkImageBoundaryConditionIVF42

    def RequiresCompleteNeighborhood(self):
        r"""RequiresCompleteNeighborhood(self) -> bool"""
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionIVF42_RequiresCompleteNeighborhood(self)

    def GetInputRequestedRegion(self, inputLargestPossibleRegion, outputRequestedRegion):
        r"""
        GetInputRequestedRegion(self, inputLargestPossibleRegion, outputRequestedRegion) -> itkImageRegion2

        Parameters
        ----------
        inputLargestPossibleRegion: itkImageRegion2 const &
        outputRequestedRegion: itkImageRegion2 const &

        """
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionIVF42_GetInputRequestedRegion(self, inputLargestPossibleRegion, outputRequestedRegion)

    def GetPixel(self, index, image):
        r"""
        GetPixel(self, index, image) -> itkVectorF4

        Parameters
        ----------
        index: itkIndex2 const &
        image: itkImageVF42 const *

        """
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionIVF42_GetPixel(self, index, image)

# Register itkImageBoundaryConditionIVF42 in _itkImageBoundaryConditionPython:
_itkImageBoundaryConditionPython.itkImageBoundaryConditionIVF42_swigregister(itkImageBoundaryConditionIVF42)
class itkImageBoundaryConditionIVF43(object):
    r"""Proxy of C++ itkImageBoundaryConditionIVF43 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 _itkImageBoundaryConditionPython.itkImageBoundaryConditionIVF43_GetNameOfClass(self)

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

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

        """
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionIVF43_Print(self, os, i)

    def __call__(self, *args):
        r"""
        __call__(self, point_index, boundary_offset, data) -> itkVectorF4

        Parameters
        ----------
        point_index: itkOffset3 const &
        boundary_offset: itkOffset3 const &
        data: itk::Neighborhood< itk::Vector< float,4 > *,3 > const *

        __call__(self, point_index, boundary_offset, data, neighborhoodAccessorFunctor) -> itkVectorF4

        Parameters
        ----------
        point_index: itkOffset3 const &
        boundary_offset: itkOffset3 const &
        data: itk::Neighborhood< itk::Vector< float,4 > *,3 > const *
        neighborhoodAccessorFunctor: itk::NeighborhoodAccessorFunctor< itk::Image< itk::Vector< float,4 >,3 > > const &

        """
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionIVF43___call__(self, *args)
    __swig_destroy__ = _itkImageBoundaryConditionPython.delete_itkImageBoundaryConditionIVF43

    def RequiresCompleteNeighborhood(self):
        r"""RequiresCompleteNeighborhood(self) -> bool"""
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionIVF43_RequiresCompleteNeighborhood(self)

    def GetInputRequestedRegion(self, inputLargestPossibleRegion, outputRequestedRegion):
        r"""
        GetInputRequestedRegion(self, inputLargestPossibleRegion, outputRequestedRegion) -> itkImageRegion3

        Parameters
        ----------
        inputLargestPossibleRegion: itkImageRegion3 const &
        outputRequestedRegion: itkImageRegion3 const &

        """
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionIVF43_GetInputRequestedRegion(self, inputLargestPossibleRegion, outputRequestedRegion)

    def GetPixel(self, index, image):
        r"""
        GetPixel(self, index, image) -> itkVectorF4

        Parameters
        ----------
        index: itkIndex3 const &
        image: itkImageVF43 const *

        """
        return _itkImageBoundaryConditionPython.itkImageBoundaryConditionIVF43_GetPixel(self, index, image)

# Register itkImageBoundaryConditionIVF43 in _itkImageBoundaryConditionPython:
_itkImageBoundaryConditionPython.itkImageBoundaryConditionIVF43_swigregister(itkImageBoundaryConditionIVF43)
class itkPeriodicBoundaryConditionICF2(itkImageBoundaryConditionICF2):
    r"""Proxy of C++ itkPeriodicBoundaryConditionICF2 class."""

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

    def __call__(self, *args):
        r"""
        __call__(self, point_index, boundary_offset, data) -> stdcomplexF

        Parameters
        ----------
        point_index: itkOffset2 const &
        boundary_offset: itkOffset2 const &
        data: itk::Neighborhood< std::complex< float > * > const *

        __call__(self, point_index, boundary_offset, data, neighborhoodAccessorFunctor) -> stdcomplexF

        Parameters
        ----------
        point_index: itkOffset2 const &
        boundary_offset: itkOffset2 const &
        data: itk::Neighborhood< std::complex< float > * > const *
        neighborhoodAccessorFunctor: itk::NeighborhoodAccessorFunctor< itk::Image< std::complex< float > > > const &

        """
        return _itkImageBoundaryConditionPython.itkPeriodicBoundaryConditionICF2___call__(self, *args)

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

        Parameters
        ----------
        arg0: itkPeriodicBoundaryConditionICF2 const &

        """
        _itkImageBoundaryConditionPython.itkPeriodicBoundaryConditionICF2_swiginit(self, _itkImageBoundaryConditionPython.new_itkPeriodicBoundaryConditionICF2(*args))
    __swig_destroy__ = _itkImageBoundaryConditionPython.delete_itkPeriodicBoundaryConditionICF2

# Register itkPeriodicBoundaryConditionICF2 in _itkImageBoundaryConditionPython:
_itkImageBoundaryConditionPython.itkPeriodicBoundaryConditionICF2_swigregister(itkPeriodicBoundaryConditionICF2)
class itkPeriodicBoundaryConditionICF3(itkImageBoundaryConditionICF3):
    r"""Proxy of C++ itkPeriodicBoundaryConditionICF3 class."""

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

    def __call__(self, *args):
        r"""
        __call__(self, point_index, boundary_offset, data) -> stdcomplexF

        Parameters
        ----------
        point_index: itkOffset3 const &
        boundary_offset: itkOffset3 const &
        data: itk::Neighborhood< std::complex< float > *,3 > const *

        __call__(self, point_index, boundary_offset, data, neighborhoodAccessorFunctor) -> stdcomplexF

        Parameters
        ----------
        point_index: itkOffset3 const &
        boundary_offset: itkOffset3 const &
        data: itk::Neighborhood< std::complex< float > *,3 > const *
        neighborhoodAccessorFunctor: itk::NeighborhoodAccessorFunctor< itk::Image< std::complex< float >,3 > > const &

        """
        return _itkImageBoundaryConditionPython.itkPeriodicBoundaryConditionICF3___call__(self, *args)

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

        Parameters
        ----------
        arg0: itkPeriodicBoundaryConditionICF3 const &

        """
        _itkImageBoundaryConditionPython.itkPeriodicBoundaryConditionICF3_swiginit(self, _itkImageBoundaryConditionPython.new_itkPeriodicBoundaryConditionICF3(*args))
    __swig_destroy__ = _itkImageBoundaryConditionPython.delete_itkPeriodicBoundaryConditionICF3

# Register itkPeriodicBoundaryConditionICF3 in _itkImageBoundaryConditionPython:
_itkImageBoundaryConditionPython.itkPeriodicBoundaryConditionICF3_swigregister(itkPeriodicBoundaryConditionICF3)
class itkPeriodicBoundaryConditionICVF22(itkImageBoundaryConditionICVF22):
    r"""Proxy of C++ itkPeriodicBoundaryConditionICVF22 class."""

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

    def __call__(self, *args):
        r"""
        __call__(self, point_index, boundary_offset, data) -> itkCovariantVectorF2

        Parameters
        ----------
        point_index: itkOffset2 const &
        boundary_offset: itkOffset2 const &
        data: itk::Neighborhood< itk::CovariantVector< float,2 > * > const *

        __call__(self, point_index, boundary_offset, data, neighborhoodAccessorFunctor) -> itkCovariantVectorF2

        Parameters
        ----------
        point_index: itkOffset2 const &
        boundary_offset: itkOffset2 const &
        data: itk::Neighborhood< itk::CovariantVector< float,2 > * > const *
        neighborhoodAccessorFunctor: itk::NeighborhoodAccessorFunctor< itk::Image< itk::CovariantVector< float,2 > > > const &

        """
        return _itkImageBoundaryConditionPython.itkPeriodicBoundaryConditionICVF22___call__(self, *args)

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

        Parameters
        ----------
        arg0: itkPeriodicBoundaryConditionICVF22 const &

        """
        _itkImageBoundaryConditionPython.itkPeriodicBoundaryConditionICVF22_swiginit(self, _itkImageBoundaryConditionPython.new_itkPeriodicBoundaryConditionICVF22(*args))
    __swig_destroy__ = _itkImageBoundaryConditionPython.delete_itkPeriodicBoundaryConditionICVF22

# Register itkPeriodicBoundaryConditionICVF22 in _itkImageBoundaryConditionPython:
_itkImageBoundaryConditionPython.itkPeriodicBoundaryConditionICVF22_swigregister(itkPeriodicBoundaryConditionICVF22)
class itkPeriodicBoundaryConditionICVF23(itkImageBoundaryConditionICVF23):
    r"""Proxy of C++ itkPeriodicBoundaryConditionICVF23 class."""

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

    def __call__(self, *args):
        r"""
        __call__(self, point_index, boundary_offset, data) -> itkCovariantVectorF2

        Parameters
        ----------
        point_index: itkOffset3 const &
        boundary_offset: itkOffset3 const &
        data: itk::Neighborhood< itk::CovariantVector< float,2 > *,3 > const *

        __call__(self, point_index, boundary_offset, data, neighborhoodAccessorFunctor) -> itkCovariantVectorF2

        Parameters
        ----------
        point_index: itkOffset3 const &
        boundary_offset: itkOffset3 const &
        data: itk::Neighborhood< itk::CovariantVector< float,2 > *,3 > const *
        neighborhoodAccessorFunctor: itk::NeighborhoodAccessorFunctor< itk::Image< itk::CovariantVector< float,2 >,3 > > const &

        """
        return _itkImageBoundaryConditionPython.itkPeriodicBoundaryConditionICVF23___call__(self, *args)

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

        Parameters
        ----------
        arg0: itkPeriodicBoundaryConditionICVF23 const &

        """
        _itkImageBoundaryConditionPython.itkPeriodicBoundaryConditionICVF23_swiginit(self, _itkImageBoundaryConditionPython.new_itkPeriodicBoundaryConditionICVF23(*args))
    __swig_destroy__ = _itkImageBoundaryConditionPython.delete_itkPeriodicBoundaryConditionICVF23

# Register itkPeriodicBoundaryConditionICVF23 in _itkImageBoundaryConditionPython:
_itkImageBoundaryConditionPython.itkPeriodicBoundaryConditionICVF23_swigregister(itkPeriodicBoundaryConditionICVF23)
class itkPeriodicBoundaryConditionICVF32(itkImageBoundaryConditionICVF32):
    r"""Proxy of C++ itkPeriodicBoundaryConditionICVF32 class."""

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

    def __call__(self, *args):
        r"""
        __call__(self, point_index, boundary_offset, data) -> itkCovariantVectorF3

        Parameters
        ----------
        point_index: itkOffset2 const &
        boundary_offset: itkOffset2 const &
        data: itk::Neighborhood< itk::CovariantVector< float > * > const *

        __call__(self, point_index, boundary_offset, data, neighborhoodAccessorFunctor) -> itkCovariantVectorF3

        Parameters
        ----------
        point_index: itkOffset2 const &
        boundary_offset: itkOffset2 const &
        data: itk::Neighborhood< itk::CovariantVector< float > * > const *
        neighborhoodAccessorFunctor: itk::NeighborhoodAccessorFunctor< itk::Image< itk::CovariantVector< float > > > const &

        """
        return _itkImageBoundaryConditionPython.itkPeriodicBoundaryConditionICVF32___call__(self, *args)

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

        Parameters
        ----------
        arg0: itkPeriodicBoundaryConditionICVF32 const &

        """
        _itkImageBoundaryConditionPython.itkPeriodicBoundaryConditionICVF32_swiginit(self, _itkImageBoundaryConditionPython.new_itkPeriodicBoundaryConditionICVF32(*args))
    __swig_destroy__ = _itkImageBoundaryConditionPython.delete_itkPeriodicBoundaryConditionICVF32

# Register itkPeriodicBoundaryConditionICVF32 in _itkImageBoundaryConditionPython:
_itkImageBoundaryConditionPython.itkPeriodicBoundaryConditionICVF32_swigregister(itkPeriodicBoundaryConditionICVF32)
class itkPeriodicBoundaryConditionICVF33(itkImageBoundaryConditionICVF33):
    r"""Proxy of C++ itkPeriodicBoundaryConditionICVF33 class."""

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

    def __call__(self, *args):
        r"""
        __call__(self, point_index, boundary_offset, data) -> itkCovariantVectorF3

        Parameters
        ----------
        point_index: itkOffset3 const &
        boundary_offset: itkOffset3 const &
        data: itk::Neighborhood< itk::CovariantVector< float > *,3 > const *

        __call__(self, point_index, boundary_offset, data, neighborhoodAccessorFunctor) -> itkCovariantVectorF3

        Parameters
        ----------
        point_index: itkOffset3 const &
        boundary_offset: itkOffset3 const &
        data: itk::Neighborhood< itk::CovariantVector< float > *,3 > const *
        neighborhoodAccessorFunctor: itk::NeighborhoodAccessorFunctor< itk::Image< itk::CovariantVector< float >,3 > > const &

        """
        return _itkImageBoundaryConditionPython.itkPeriodicBoundaryConditionICVF33___call__(self, *args)

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

        Parameters
        ----------
        arg0: itkPeriodicBoundaryConditionICVF33 const &

        """
        _itkImageBoundaryConditionPython.itkPeriodicBoundaryConditionICVF33_swiginit(self, _itkImageBoundaryConditionPython.new_itkPeriodicBoundaryConditionICVF33(*args))
    __swig_destroy__ = _itkImageBoundaryConditionPython.delete_itkPeriodicBoundaryConditionICVF33

# Register itkPeriodicBoundaryConditionICVF33 in _itkImageBoundaryConditionPython:
_itkImageBoundaryConditionPython.itkPeriodicBoundaryConditionICVF33_swigregister(itkPeriodicBoundaryConditionICVF33)
class itkPeriodicBoundaryConditionICVF42(itkImageBoundaryConditionICVF42):
    r"""Proxy of C++ itkPeriodicBoundaryConditionICVF42 class."""

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

    def __call__(self, *args):
        r"""
        __call__(self, point_index, boundary_offset, data) -> itkCovariantVectorF4

        Parameters
        ----------
        point_index: itkOffset2 const &
        boundary_offset: itkOffset2 const &
        data: itk::Neighborhood< itk::CovariantVector< float,4 > * > const *

        __call__(self, point_index, boundary_offset, data, neighborhoodAccessorFunctor) -> itkCovariantVectorF4

        Parameters
        ----------
        point_index: itkOffset2 const &
        boundary_offset: itkOffset2 const &
        data: itk::Neighborhood< itk::CovariantVector< float,4 > * > const *
        neighborhoodAccessorFunctor: itk::NeighborhoodAccessorFunctor< itk::Image< itk::CovariantVector< float,4 > > > const &

        """
        return _itkImageBoundaryConditionPython.itkPeriodicBoundaryConditionICVF42___call__(self, *args)

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

        Parameters
        ----------
        arg0: itkPeriodicBoundaryConditionICVF42 const &

        """
        _itkImageBoundaryConditionPython.itkPeriodicBoundaryConditionICVF42_swiginit(self, _itkImageBoundaryConditionPython.new_itkPeriodicBoundaryConditionICVF42(*args))
    __swig_destroy__ = _itkImageBoundaryConditionPython.delete_itkPeriodicBoundaryConditionICVF42

# Register itkPeriodicBoundaryConditionICVF42 in _itkImageBoundaryConditionPython:
_itkImageBoundaryConditionPython.itkPeriodicBoundaryConditionICVF42_swigregister(itkPeriodicBoundaryConditionICVF42)
class itkPeriodicBoundaryConditionICVF43(itkImageBoundaryConditionICVF43):
    r"""Proxy of C++ itkPeriodicBoundaryConditionICVF43 class."""

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

    def __call__(self, *args):
        r"""
        __call__(self, point_index, boundary_offset, data) -> itkCovariantVectorF4

        Parameters
        ----------
        point_index: itkOffset3 const &
        boundary_offset: itkOffset3 const &
        data: itk::Neighborhood< itk::CovariantVector< float,4 > *,3 > const *

        __call__(self, point_index, boundary_offset, data, neighborhoodAccessorFunctor) -> itkCovariantVectorF4

        Parameters
        ----------
        point_index: itkOffset3 const &
        boundary_offset: itkOffset3 const &
        data: itk::Neighborhood< itk::CovariantVector< float,4 > *,3 > const *
        neighborhoodAccessorFunctor: itk::NeighborhoodAccessorFunctor< itk::Image< itk::CovariantVector< float,4 >,3 > > const &

        """
        return _itkImageBoundaryConditionPython.itkPeriodicBoundaryConditionICVF43___call__(self, *args)

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

        Parameters
        ----------
        arg0: itkPeriodicBoundaryConditionICVF43 const &

        """
        _itkImageBoundaryConditionPython.itkPeriodicBoundaryConditionICVF43_swiginit(self, _itkImageBoundaryConditionPython.new_itkPeriodicBoundaryConditionICVF43(*args))
    __swig_destroy__ = _itkImageBoundaryConditionPython.delete_itkPeriodicBoundaryConditionICVF43

# Register itkPeriodicBoundaryConditionICVF43 in _itkImageBoundaryConditionPython:
_itkImageBoundaryConditionPython.itkPeriodicBoundaryConditionICVF43_swigregister(itkPeriodicBoundaryConditionICVF43)
class itkPeriodicBoundaryConditionIF2(itkImageBoundaryConditionIF2):
    r"""Proxy of C++ itkPeriodicBoundaryConditionIF2 class."""

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

    def __call__(self, *args):
        r"""
        __call__(self, point_index, boundary_offset, data) -> float

        Parameters
        ----------
        point_index: itkOffset2 const &
        boundary_offset: itkOffset2 const &
        data: itk::Neighborhood< float * > const *

        __call__(self, point_index, boundary_offset, data, neighborhoodAccessorFunctor) -> float

        Parameters
        ----------
        point_index: itkOffset2 const &
        boundary_offset: itkOffset2 const &
        data: itk::Neighborhood< float * > const *
        neighborhoodAccessorFunctor: itk::NeighborhoodAccessorFunctor< itk::Image< float > > const &

        """
        return _itkImageBoundaryConditionPython.itkPeriodicBoundaryConditionIF2___call__(self, *args)

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

        Parameters
        ----------
        arg0: itkPeriodicBoundaryConditionIF2 const &

        """
        _itkImageBoundaryConditionPython.itkPeriodicBoundaryConditionIF2_swiginit(self, _itkImageBoundaryConditionPython.new_itkPeriodicBoundaryConditionIF2(*args))
    __swig_destroy__ = _itkImageBoundaryConditionPython.delete_itkPeriodicBoundaryConditionIF2

# Register itkPeriodicBoundaryConditionIF2 in _itkImageBoundaryConditionPython:
_itkImageBoundaryConditionPython.itkPeriodicBoundaryConditionIF2_swigregister(itkPeriodicBoundaryConditionIF2)
class itkPeriodicBoundaryConditionIF3(itkImageBoundaryConditionIF3):
    r"""Proxy of C++ itkPeriodicBoundaryConditionIF3 class."""

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

    def __call__(self, *args):
        r"""
        __call__(self, point_index, boundary_offset, data) -> float

        Parameters
        ----------
        point_index: itkOffset3 const &
        boundary_offset: itkOffset3 const &
        data: itk::Neighborhood< float *,3 > const *

        __call__(self, point_index, boundary_offset, data, neighborhoodAccessorFunctor) -> float

        Parameters
        ----------
        point_index: itkOffset3 const &
        boundary_offset: itkOffset3 const &
        data: itk::Neighborhood< float *,3 > const *
        neighborhoodAccessorFunctor: itk::NeighborhoodAccessorFunctor< itk::Image< float,3 > > const &

        """
        return _itkImageBoundaryConditionPython.itkPeriodicBoundaryConditionIF3___call__(self, *args)

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

        Parameters
        ----------
        arg0: itkPeriodicBoundaryConditionIF3 const &

        """
        _itkImageBoundaryConditionPython.itkPeriodicBoundaryConditionIF3_swiginit(self, _itkImageBoundaryConditionPython.new_itkPeriodicBoundaryConditionIF3(*args))
    __swig_destroy__ = _itkImageBoundaryConditionPython.delete_itkPeriodicBoundaryConditionIF3

# Register itkPeriodicBoundaryConditionIF3 in _itkImageBoundaryConditionPython:
_itkImageBoundaryConditionPython.itkPeriodicBoundaryConditionIF3_swigregister(itkPeriodicBoundaryConditionIF3)
class itkPeriodicBoundaryConditionIRGBAUC2(itkImageBoundaryConditionIRGBAUC2):
    r"""Proxy of C++ itkPeriodicBoundaryConditionIRGBAUC2 class."""

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

    def __call__(self, *args):
        r"""
        __call__(self, point_index, boundary_offset, data) -> itkRGBAPixelUC

        Parameters
        ----------
        point_index: itkOffset2 const &
        boundary_offset: itkOffset2 const &
        data: itk::Neighborhood< itk::RGBAPixel< unsigned char > * > const *

        __call__(self, point_index, boundary_offset, data, neighborhoodAccessorFunctor) -> itkRGBAPixelUC

        Parameters
        ----------
        point_index: itkOffset2 const &
        boundary_offset: itkOffset2 const &
        data: itk::Neighborhood< itk::RGBAPixel< unsigned char > * > const *
        neighborhoodAccessorFunctor: itk::NeighborhoodAccessorFunctor< itk::Image< itk::RGBAPixel< unsigned char > > > const &

        """
        return _itkImageBoundaryConditionPython.itkPeriodicBoundaryConditionIRGBAUC2___call__(self, *args)

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

        Parameters
        ----------
        arg0: itkPeriodicBoundaryConditionIRGBAUC2 const &

        """
        _itkImageBoundaryConditionPython.itkPeriodicBoundaryConditionIRGBAUC2_swiginit(self, _itkImageBoundaryConditionPython.new_itkPeriodicBoundaryConditionIRGBAUC2(*args))
    __swig_destroy__ = _itkImageBoundaryConditionPython.delete_itkPeriodicBoundaryConditionIRGBAUC2

# Register itkPeriodicBoundaryConditionIRGBAUC2 in _itkImageBoundaryConditionPython:
_itkImageBoundaryConditionPython.itkPeriodicBoundaryConditionIRGBAUC2_swigregister(itkPeriodicBoundaryConditionIRGBAUC2)
class itkPeriodicBoundaryConditionIRGBAUC3(itkImageBoundaryConditionIRGBAUC3):
    r"""Proxy of C++ itkPeriodicBoundaryConditionIRGBAUC3 class."""

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

    def __call__(self, *args):
        r"""
        __call__(self, point_index, boundary_offset, data) -> itkRGBAPixelUC

        Parameters
        ----------
        point_index: itkOffset3 const &
        boundary_offset: itkOffset3 const &
        data: itk::Neighborhood< itk::RGBAPixel< unsigned char > *,3 > const *

        __call__(self, point_index, boundary_offset, data, neighborhoodAccessorFunctor) -> itkRGBAPixelUC

        Parameters
        ----------
        point_index: itkOffset3 const &
        boundary_offset: itkOffset3 const &
        data: itk::Neighborhood< itk::RGBAPixel< unsigned char > *,3 > const *
        neighborhoodAccessorFunctor: itk::NeighborhoodAccessorFunctor< itk::Image< itk::RGBAPixel< unsigned char >,3 > > const &

        """
        return _itkImageBoundaryConditionPython.itkPeriodicBoundaryConditionIRGBAUC3___call__(self, *args)

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

        Parameters
        ----------
        arg0: itkPeriodicBoundaryConditionIRGBAUC3 const &

        """
        _itkImageBoundaryConditionPython.itkPeriodicBoundaryConditionIRGBAUC3_swiginit(self, _itkImageBoundaryConditionPython.new_itkPeriodicBoundaryConditionIRGBAUC3(*args))
    __swig_destroy__ = _itkImageBoundaryConditionPython.delete_itkPeriodicBoundaryConditionIRGBAUC3

# Register itkPeriodicBoundaryConditionIRGBAUC3 in _itkImageBoundaryConditionPython:
_itkImageBoundaryConditionPython.itkPeriodicBoundaryConditionIRGBAUC3_swigregister(itkPeriodicBoundaryConditionIRGBAUC3)
class itkPeriodicBoundaryConditionIRGBUC2(itkImageBoundaryConditionIRGBUC2):
    r"""Proxy of C++ itkPeriodicBoundaryConditionIRGBUC2 class."""

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

    def __call__(self, *args):
        r"""
        __call__(self, point_index, boundary_offset, data) -> itkRGBPixelUC

        Parameters
        ----------
        point_index: itkOffset2 const &
        boundary_offset: itkOffset2 const &
        data: itk::Neighborhood< itk::RGBPixel< unsigned char > * > const *

        __call__(self, point_index, boundary_offset, data, neighborhoodAccessorFunctor) -> itkRGBPixelUC

        Parameters
        ----------
        point_index: itkOffset2 const &
        boundary_offset: itkOffset2 const &
        data: itk::Neighborhood< itk::RGBPixel< unsigned char > * > const *
        neighborhoodAccessorFunctor: itk::NeighborhoodAccessorFunctor< itk::Image< itk::RGBPixel< unsigned char > > > const &

        """
        return _itkImageBoundaryConditionPython.itkPeriodicBoundaryConditionIRGBUC2___call__(self, *args)

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

        Parameters
        ----------
        arg0: itkPeriodicBoundaryConditionIRGBUC2 const &

        """
        _itkImageBoundaryConditionPython.itkPeriodicBoundaryConditionIRGBUC2_swiginit(self, _itkImageBoundaryConditionPython.new_itkPeriodicBoundaryConditionIRGBUC2(*args))
    __swig_destroy__ = _itkImageBoundaryConditionPython.delete_itkPeriodicBoundaryConditionIRGBUC2

# Register itkPeriodicBoundaryConditionIRGBUC2 in _itkImageBoundaryConditionPython:
_itkImageBoundaryConditionPython.itkPeriodicBoundaryConditionIRGBUC2_swigregister(itkPeriodicBoundaryConditionIRGBUC2)
class itkPeriodicBoundaryConditionIRGBUC3(itkImageBoundaryConditionIRGBUC3):
    r"""Proxy of C++ itkPeriodicBoundaryConditionIRGBUC3 class."""

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

    def __call__(self, *args):
        r"""
        __call__(self, point_index, boundary_offset, data) -> itkRGBPixelUC

        Parameters
        ----------
        point_index: itkOffset3 const &
        boundary_offset: itkOffset3 const &
        data: itk::Neighborhood< itk::RGBPixel< unsigned char > *,3 > const *

        __call__(self, point_index, boundary_offset, data, neighborhoodAccessorFunctor) -> itkRGBPixelUC

        Parameters
        ----------
        point_index: itkOffset3 const &
        boundary_offset: itkOffset3 const &
        data: itk::Neighborhood< itk::RGBPixel< unsigned char > *,3 > const *
        neighborhoodAccessorFunctor: itk::NeighborhoodAccessorFunctor< itk::Image< itk::RGBPixel< unsigned char >,3 > > const &

        """
        return _itkImageBoundaryConditionPython.itkPeriodicBoundaryConditionIRGBUC3___call__(self, *args)

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

        Parameters
        ----------
        arg0: itkPeriodicBoundaryConditionIRGBUC3 const &

        """
        _itkImageBoundaryConditionPython.itkPeriodicBoundaryConditionIRGBUC3_swiginit(self, _itkImageBoundaryConditionPython.new_itkPeriodicBoundaryConditionIRGBUC3(*args))
    __swig_destroy__ = _itkImageBoundaryConditionPython.delete_itkPeriodicBoundaryConditionIRGBUC3

# Register itkPeriodicBoundaryConditionIRGBUC3 in _itkImageBoundaryConditionPython:
_itkImageBoundaryConditionPython.itkPeriodicBoundaryConditionIRGBUC3_swigregister(itkPeriodicBoundaryConditionIRGBUC3)
class itkPeriodicBoundaryConditionISS2(itkImageBoundaryConditionISS2):
    r"""Proxy of C++ itkPeriodicBoundaryConditionISS2 class."""

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

    def __call__(self, *args):
        r"""
        __call__(self, point_index, boundary_offset, data) -> short

        Parameters
        ----------
        point_index: itkOffset2 const &
        boundary_offset: itkOffset2 const &
        data: itk::Neighborhood< short * > const *

        __call__(self, point_index, boundary_offset, data, neighborhoodAccessorFunctor) -> short

        Parameters
        ----------
        point_index: itkOffset2 const &
        boundary_offset: itkOffset2 const &
        data: itk::Neighborhood< short * > const *
        neighborhoodAccessorFunctor: itk::NeighborhoodAccessorFunctor< itk::Image< short > > const &

        """
        return _itkImageBoundaryConditionPython.itkPeriodicBoundaryConditionISS2___call__(self, *args)

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

        Parameters
        ----------
        arg0: itkPeriodicBoundaryConditionISS2 const &

        """
        _itkImageBoundaryConditionPython.itkPeriodicBoundaryConditionISS2_swiginit(self, _itkImageBoundaryConditionPython.new_itkPeriodicBoundaryConditionISS2(*args))
    __swig_destroy__ = _itkImageBoundaryConditionPython.delete_itkPeriodicBoundaryConditionISS2

# Register itkPeriodicBoundaryConditionISS2 in _itkImageBoundaryConditionPython:
_itkImageBoundaryConditionPython.itkPeriodicBoundaryConditionISS2_swigregister(itkPeriodicBoundaryConditionISS2)
class itkPeriodicBoundaryConditionISS3(itkImageBoundaryConditionISS3):
    r"""Proxy of C++ itkPeriodicBoundaryConditionISS3 class."""

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

    def __call__(self, *args):
        r"""
        __call__(self, point_index, boundary_offset, data) -> short

        Parameters
        ----------
        point_index: itkOffset3 const &
        boundary_offset: itkOffset3 const &
        data: itk::Neighborhood< short *,3 > const *

        __call__(self, point_index, boundary_offset, data, neighborhoodAccessorFunctor) -> short

        Parameters
        ----------
        point_index: itkOffset3 const &
        boundary_offset: itkOffset3 const &
        data: itk::Neighborhood< short *,3 > const *
        neighborhoodAccessorFunctor: itk::NeighborhoodAccessorFunctor< itk::Image< short,3 > > const &

        """
        return _itkImageBoundaryConditionPython.itkPeriodicBoundaryConditionISS3___call__(self, *args)

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

        Parameters
        ----------
        arg0: itkPeriodicBoundaryConditionISS3 const &

        """
        _itkImageBoundaryConditionPython.itkPeriodicBoundaryConditionISS3_swiginit(self, _itkImageBoundaryConditionPython.new_itkPeriodicBoundaryConditionISS3(*args))
    __swig_destroy__ = _itkImageBoundaryConditionPython.delete_itkPeriodicBoundaryConditionISS3

# Register itkPeriodicBoundaryConditionISS3 in _itkImageBoundaryConditionPython:
_itkImageBoundaryConditionPython.itkPeriodicBoundaryConditionISS3_swigregister(itkPeriodicBoundaryConditionISS3)
class itkPeriodicBoundaryConditionIUC2(itkImageBoundaryConditionIUC2):
    r"""Proxy of C++ itkPeriodicBoundaryConditionIUC2 class."""

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

    def __call__(self, *args):
        r"""
        __call__(self, point_index, boundary_offset, data) -> unsigned char

        Parameters
        ----------
        point_index: itkOffset2 const &
        boundary_offset: itkOffset2 const &
        data: itk::Neighborhood< unsigned char * > const *

        __call__(self, point_index, boundary_offset, data, neighborhoodAccessorFunctor) -> unsigned char

        Parameters
        ----------
        point_index: itkOffset2 const &
        boundary_offset: itkOffset2 const &
        data: itk::Neighborhood< unsigned char * > const *
        neighborhoodAccessorFunctor: itk::NeighborhoodAccessorFunctor< itk::Image< unsigned char > > const &

        """
        return _itkImageBoundaryConditionPython.itkPeriodicBoundaryConditionIUC2___call__(self, *args)

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

        Parameters
        ----------
        arg0: itkPeriodicBoundaryConditionIUC2 const &

        """
        _itkImageBoundaryConditionPython.itkPeriodicBoundaryConditionIUC2_swiginit(self, _itkImageBoundaryConditionPython.new_itkPeriodicBoundaryConditionIUC2(*args))
    __swig_destroy__ = _itkImageBoundaryConditionPython.delete_itkPeriodicBoundaryConditionIUC2

# Register itkPeriodicBoundaryConditionIUC2 in _itkImageBoundaryConditionPython:
_itkImageBoundaryConditionPython.itkPeriodicBoundaryConditionIUC2_swigregister(itkPeriodicBoundaryConditionIUC2)
class itkPeriodicBoundaryConditionIUC3(itkImageBoundaryConditionIUC3):
    r"""Proxy of C++ itkPeriodicBoundaryConditionIUC3 class."""

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

    def __call__(self, *args):
        r"""
        __call__(self, point_index, boundary_offset, data) -> unsigned char

        Parameters
        ----------
        point_index: itkOffset3 const &
        boundary_offset: itkOffset3 const &
        data: itk::Neighborhood< unsigned char *,3 > const *

        __call__(self, point_index, boundary_offset, data, neighborhoodAccessorFunctor) -> unsigned char

        Parameters
        ----------
        point_index: itkOffset3 const &
        boundary_offset: itkOffset3 const &
        data: itk::Neighborhood< unsigned char *,3 > const *
        neighborhoodAccessorFunctor: itk::NeighborhoodAccessorFunctor< itk::Image< unsigned char,3 > > const &

        """
        return _itkImageBoundaryConditionPython.itkPeriodicBoundaryConditionIUC3___call__(self, *args)

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

        Parameters
        ----------
        arg0: itkPeriodicBoundaryConditionIUC3 const &

        """
        _itkImageBoundaryConditionPython.itkPeriodicBoundaryConditionIUC3_swiginit(self, _itkImageBoundaryConditionPython.new_itkPeriodicBoundaryConditionIUC3(*args))
    __swig_destroy__ = _itkImageBoundaryConditionPython.delete_itkPeriodicBoundaryConditionIUC3

# Register itkPeriodicBoundaryConditionIUC3 in _itkImageBoundaryConditionPython:
_itkImageBoundaryConditionPython.itkPeriodicBoundaryConditionIUC3_swigregister(itkPeriodicBoundaryConditionIUC3)
class itkPeriodicBoundaryConditionIVF22(itkImageBoundaryConditionIVF22):
    r"""Proxy of C++ itkPeriodicBoundaryConditionIVF22 class."""

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

    def __call__(self, *args):
        r"""
        __call__(self, point_index, boundary_offset, data) -> itkVectorF2

        Parameters
        ----------
        point_index: itkOffset2 const &
        boundary_offset: itkOffset2 const &
        data: itk::Neighborhood< itk::Vector< float,2 > * > const *

        __call__(self, point_index, boundary_offset, data, neighborhoodAccessorFunctor) -> itkVectorF2

        Parameters
        ----------
        point_index: itkOffset2 const &
        boundary_offset: itkOffset2 const &
        data: itk::Neighborhood< itk::Vector< float,2 > * > const *
        neighborhoodAccessorFunctor: itk::NeighborhoodAccessorFunctor< itk::Image< itk::Vector< float,2 > > > const &

        """
        return _itkImageBoundaryConditionPython.itkPeriodicBoundaryConditionIVF22___call__(self, *args)

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

        Parameters
        ----------
        arg0: itkPeriodicBoundaryConditionIVF22 const &

        """
        _itkImageBoundaryConditionPython.itkPeriodicBoundaryConditionIVF22_swiginit(self, _itkImageBoundaryConditionPython.new_itkPeriodicBoundaryConditionIVF22(*args))
    __swig_destroy__ = _itkImageBoundaryConditionPython.delete_itkPeriodicBoundaryConditionIVF22

# Register itkPeriodicBoundaryConditionIVF22 in _itkImageBoundaryConditionPython:
_itkImageBoundaryConditionPython.itkPeriodicBoundaryConditionIVF22_swigregister(itkPeriodicBoundaryConditionIVF22)
class itkPeriodicBoundaryConditionIVF23(itkImageBoundaryConditionIVF23):
    r"""Proxy of C++ itkPeriodicBoundaryConditionIVF23 class."""

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

    def __call__(self, *args):
        r"""
        __call__(self, point_index, boundary_offset, data) -> itkVectorF2

        Parameters
        ----------
        point_index: itkOffset3 const &
        boundary_offset: itkOffset3 const &
        data: itk::Neighborhood< itk::Vector< float,2 > *,3 > const *

        __call__(self, point_index, boundary_offset, data, neighborhoodAccessorFunctor) -> itkVectorF2

        Parameters
        ----------
        point_index: itkOffset3 const &
        boundary_offset: itkOffset3 const &
        data: itk::Neighborhood< itk::Vector< float,2 > *,3 > const *
        neighborhoodAccessorFunctor: itk::NeighborhoodAccessorFunctor< itk::Image< itk::Vector< float,2 >,3 > > const &

        """
        return _itkImageBoundaryConditionPython.itkPeriodicBoundaryConditionIVF23___call__(self, *args)

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

        Parameters
        ----------
        arg0: itkPeriodicBoundaryConditionIVF23 const &

        """
        _itkImageBoundaryConditionPython.itkPeriodicBoundaryConditionIVF23_swiginit(self, _itkImageBoundaryConditionPython.new_itkPeriodicBoundaryConditionIVF23(*args))
    __swig_destroy__ = _itkImageBoundaryConditionPython.delete_itkPeriodicBoundaryConditionIVF23

# Register itkPeriodicBoundaryConditionIVF23 in _itkImageBoundaryConditionPython:
_itkImageBoundaryConditionPython.itkPeriodicBoundaryConditionIVF23_swigregister(itkPeriodicBoundaryConditionIVF23)
class itkPeriodicBoundaryConditionIVF32(itkImageBoundaryConditionIVF32):
    r"""Proxy of C++ itkPeriodicBoundaryConditionIVF32 class."""

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

    def __call__(self, *args):
        r"""
        __call__(self, point_index, boundary_offset, data) -> itkVectorF3

        Parameters
        ----------
        point_index: itkOffset2 const &
        boundary_offset: itkOffset2 const &
        data: itk::Neighborhood< itk::Vector< float > * > const *

        __call__(self, point_index, boundary_offset, data, neighborhoodAccessorFunctor) -> itkVectorF3

        Parameters
        ----------
        point_index: itkOffset2 const &
        boundary_offset: itkOffset2 const &
        data: itk::Neighborhood< itk::Vector< float > * > const *
        neighborhoodAccessorFunctor: itk::NeighborhoodAccessorFunctor< itk::Image< itk::Vector< float > > > const &

        """
        return _itkImageBoundaryConditionPython.itkPeriodicBoundaryConditionIVF32___call__(self, *args)

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

        Parameters
        ----------
        arg0: itkPeriodicBoundaryConditionIVF32 const &

        """
        _itkImageBoundaryConditionPython.itkPeriodicBoundaryConditionIVF32_swiginit(self, _itkImageBoundaryConditionPython.new_itkPeriodicBoundaryConditionIVF32(*args))
    __swig_destroy__ = _itkImageBoundaryConditionPython.delete_itkPeriodicBoundaryConditionIVF32

# Register itkPeriodicBoundaryConditionIVF32 in _itkImageBoundaryConditionPython:
_itkImageBoundaryConditionPython.itkPeriodicBoundaryConditionIVF32_swigregister(itkPeriodicBoundaryConditionIVF32)
class itkPeriodicBoundaryConditionIVF33(itkImageBoundaryConditionIVF33):
    r"""Proxy of C++ itkPeriodicBoundaryConditionIVF33 class."""

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

    def __call__(self, *args):
        r"""
        __call__(self, point_index, boundary_offset, data) -> itkVectorF3

        Parameters
        ----------
        point_index: itkOffset3 const &
        boundary_offset: itkOffset3 const &
        data: itk::Neighborhood< itk::Vector< float > *,3 > const *

        __call__(self, point_index, boundary_offset, data, neighborhoodAccessorFunctor) -> itkVectorF3

        Parameters
        ----------
        point_index: itkOffset3 const &
        boundary_offset: itkOffset3 const &
        data: itk::Neighborhood< itk::Vector< float > *,3 > const *
        neighborhoodAccessorFunctor: itk::NeighborhoodAccessorFunctor< itk::Image< itk::Vector< float >,3 > > const &

        """
        return _itkImageBoundaryConditionPython.itkPeriodicBoundaryConditionIVF33___call__(self, *args)

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

        Parameters
        ----------
        arg0: itkPeriodicBoundaryConditionIVF33 const &

        """
        _itkImageBoundaryConditionPython.itkPeriodicBoundaryConditionIVF33_swiginit(self, _itkImageBoundaryConditionPython.new_itkPeriodicBoundaryConditionIVF33(*args))
    __swig_destroy__ = _itkImageBoundaryConditionPython.delete_itkPeriodicBoundaryConditionIVF33

# Register itkPeriodicBoundaryConditionIVF33 in _itkImageBoundaryConditionPython:
_itkImageBoundaryConditionPython.itkPeriodicBoundaryConditionIVF33_swigregister(itkPeriodicBoundaryConditionIVF33)
class itkPeriodicBoundaryConditionIVF42(itkImageBoundaryConditionIVF42):
    r"""Proxy of C++ itkPeriodicBoundaryConditionIVF42 class."""

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

    def __call__(self, *args):
        r"""
        __call__(self, point_index, boundary_offset, data) -> itkVectorF4

        Parameters
        ----------
        point_index: itkOffset2 const &
        boundary_offset: itkOffset2 const &
        data: itk::Neighborhood< itk::Vector< float,4 > * > const *

        __call__(self, point_index, boundary_offset, data, neighborhoodAccessorFunctor) -> itkVectorF4

        Parameters
        ----------
        point_index: itkOffset2 const &
        boundary_offset: itkOffset2 const &
        data: itk::Neighborhood< itk::Vector< float,4 > * > const *
        neighborhoodAccessorFunctor: itk::NeighborhoodAccessorFunctor< itk::Image< itk::Vector< float,4 > > > const &

        """
        return _itkImageBoundaryConditionPython.itkPeriodicBoundaryConditionIVF42___call__(self, *args)

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

        Parameters
        ----------
        arg0: itkPeriodicBoundaryConditionIVF42 const &

        """
        _itkImageBoundaryConditionPython.itkPeriodicBoundaryConditionIVF42_swiginit(self, _itkImageBoundaryConditionPython.new_itkPeriodicBoundaryConditionIVF42(*args))
    __swig_destroy__ = _itkImageBoundaryConditionPython.delete_itkPeriodicBoundaryConditionIVF42

# Register itkPeriodicBoundaryConditionIVF42 in _itkImageBoundaryConditionPython:
_itkImageBoundaryConditionPython.itkPeriodicBoundaryConditionIVF42_swigregister(itkPeriodicBoundaryConditionIVF42)
class itkPeriodicBoundaryConditionIVF43(itkImageBoundaryConditionIVF43):
    r"""Proxy of C++ itkPeriodicBoundaryConditionIVF43 class."""

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

    def __call__(self, *args):
        r"""
        __call__(self, point_index, boundary_offset, data) -> itkVectorF4

        Parameters
        ----------
        point_index: itkOffset3 const &
        boundary_offset: itkOffset3 const &
        data: itk::Neighborhood< itk::Vector< float,4 > *,3 > const *

        __call__(self, point_index, boundary_offset, data, neighborhoodAccessorFunctor) -> itkVectorF4

        Parameters
        ----------
        point_index: itkOffset3 const &
        boundary_offset: itkOffset3 const &
        data: itk::Neighborhood< itk::Vector< float,4 > *,3 > const *
        neighborhoodAccessorFunctor: itk::NeighborhoodAccessorFunctor< itk::Image< itk::Vector< float,4 >,3 > > const &

        """
        return _itkImageBoundaryConditionPython.itkPeriodicBoundaryConditionIVF43___call__(self, *args)

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

        Parameters
        ----------
        arg0: itkPeriodicBoundaryConditionIVF43 const &

        """
        _itkImageBoundaryConditionPython.itkPeriodicBoundaryConditionIVF43_swiginit(self, _itkImageBoundaryConditionPython.new_itkPeriodicBoundaryConditionIVF43(*args))
    __swig_destroy__ = _itkImageBoundaryConditionPython.delete_itkPeriodicBoundaryConditionIVF43

# Register itkPeriodicBoundaryConditionIVF43 in _itkImageBoundaryConditionPython:
_itkImageBoundaryConditionPython.itkPeriodicBoundaryConditionIVF43_swigregister(itkPeriodicBoundaryConditionIVF43)
class itkZeroFluxNeumannBoundaryConditionICF2(itkImageBoundaryConditionICF2):
    r"""Proxy of C++ itkZeroFluxNeumannBoundaryConditionICF2 class."""

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

    def __call__(self, *args):
        r"""
        __call__(self, point_index, boundary_offset, data) -> stdcomplexF

        Parameters
        ----------
        point_index: itkOffset2 const &
        boundary_offset: itkOffset2 const &
        data: itk::Neighborhood< std::complex< float > * > const *

        __call__(self, point_index, boundary_offset, data, neighborhoodAccessorFunctor) -> stdcomplexF

        Parameters
        ----------
        point_index: itkOffset2 const &
        boundary_offset: itkOffset2 const &
        data: itk::Neighborhood< std::complex< float > * > const *
        neighborhoodAccessorFunctor: itk::NeighborhoodAccessorFunctor< itk::Image< std::complex< float > > > const &

        """
        return _itkImageBoundaryConditionPython.itkZeroFluxNeumannBoundaryConditionICF2___call__(self, *args)

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

        Parameters
        ----------
        arg0: itkZeroFluxNeumannBoundaryConditionICF2 const &

        """
        _itkImageBoundaryConditionPython.itkZeroFluxNeumannBoundaryConditionICF2_swiginit(self, _itkImageBoundaryConditionPython.new_itkZeroFluxNeumannBoundaryConditionICF2(*args))
    __swig_destroy__ = _itkImageBoundaryConditionPython.delete_itkZeroFluxNeumannBoundaryConditionICF2

# Register itkZeroFluxNeumannBoundaryConditionICF2 in _itkImageBoundaryConditionPython:
_itkImageBoundaryConditionPython.itkZeroFluxNeumannBoundaryConditionICF2_swigregister(itkZeroFluxNeumannBoundaryConditionICF2)
class itkZeroFluxNeumannBoundaryConditionICF3(itkImageBoundaryConditionICF3):
    r"""Proxy of C++ itkZeroFluxNeumannBoundaryConditionICF3 class."""

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

    def __call__(self, *args):
        r"""
        __call__(self, point_index, boundary_offset, data) -> stdcomplexF

        Parameters
        ----------
        point_index: itkOffset3 const &
        boundary_offset: itkOffset3 const &
        data: itk::Neighborhood< std::complex< float > *,3 > const *

        __call__(self, point_index, boundary_offset, data, neighborhoodAccessorFunctor) -> stdcomplexF

        Parameters
        ----------
        point_index: itkOffset3 const &
        boundary_offset: itkOffset3 const &
        data: itk::Neighborhood< std::complex< float > *,3 > const *
        neighborhoodAccessorFunctor: itk::NeighborhoodAccessorFunctor< itk::Image< std::complex< float >,3 > > const &

        """
        return _itkImageBoundaryConditionPython.itkZeroFluxNeumannBoundaryConditionICF3___call__(self, *args)

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

        Parameters
        ----------
        arg0: itkZeroFluxNeumannBoundaryConditionICF3 const &

        """
        _itkImageBoundaryConditionPython.itkZeroFluxNeumannBoundaryConditionICF3_swiginit(self, _itkImageBoundaryConditionPython.new_itkZeroFluxNeumannBoundaryConditionICF3(*args))
    __swig_destroy__ = _itkImageBoundaryConditionPython.delete_itkZeroFluxNeumannBoundaryConditionICF3

# Register itkZeroFluxNeumannBoundaryConditionICF3 in _itkImageBoundaryConditionPython:
_itkImageBoundaryConditionPython.itkZeroFluxNeumannBoundaryConditionICF3_swigregister(itkZeroFluxNeumannBoundaryConditionICF3)
class itkZeroFluxNeumannBoundaryConditionICVF22(itkImageBoundaryConditionICVF22):
    r"""Proxy of C++ itkZeroFluxNeumannBoundaryConditionICVF22 class."""

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

    def __call__(self, *args):
        r"""
        __call__(self, point_index, boundary_offset, data) -> itkCovariantVectorF2

        Parameters
        ----------
        point_index: itkOffset2 const &
        boundary_offset: itkOffset2 const &
        data: itk::Neighborhood< itk::CovariantVector< float,2 > * > const *

        __call__(self, point_index, boundary_offset, data, neighborhoodAccessorFunctor) -> itkCovariantVectorF2

        Parameters
        ----------
        point_index: itkOffset2 const &
        boundary_offset: itkOffset2 const &
        data: itk::Neighborhood< itk::CovariantVector< float,2 > * > const *
        neighborhoodAccessorFunctor: itk::NeighborhoodAccessorFunctor< itk::Image< itk::CovariantVector< float,2 > > > const &

        """
        return _itkImageBoundaryConditionPython.itkZeroFluxNeumannBoundaryConditionICVF22___call__(self, *args)

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

        Parameters
        ----------
        arg0: itkZeroFluxNeumannBoundaryConditionICVF22 const &

        """
        _itkImageBoundaryConditionPython.itkZeroFluxNeumannBoundaryConditionICVF22_swiginit(self, _itkImageBoundaryConditionPython.new_itkZeroFluxNeumannBoundaryConditionICVF22(*args))
    __swig_destroy__ = _itkImageBoundaryConditionPython.delete_itkZeroFluxNeumannBoundaryConditionICVF22

# Register itkZeroFluxNeumannBoundaryConditionICVF22 in _itkImageBoundaryConditionPython:
_itkImageBoundaryConditionPython.itkZeroFluxNeumannBoundaryConditionICVF22_swigregister(itkZeroFluxNeumannBoundaryConditionICVF22)
class itkZeroFluxNeumannBoundaryConditionICVF23(itkImageBoundaryConditionICVF23):
    r"""Proxy of C++ itkZeroFluxNeumannBoundaryConditionICVF23 class."""

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

    def __call__(self, *args):
        r"""
        __call__(self, point_index, boundary_offset, data) -> itkCovariantVectorF2

        Parameters
        ----------
        point_index: itkOffset3 const &
        boundary_offset: itkOffset3 const &
        data: itk::Neighborhood< itk::CovariantVector< float,2 > *,3 > const *

        __call__(self, point_index, boundary_offset, data, neighborhoodAccessorFunctor) -> itkCovariantVectorF2

        Parameters
        ----------
        point_index: itkOffset3 const &
        boundary_offset: itkOffset3 const &
        data: itk::Neighborhood< itk::CovariantVector< float,2 > *,3 > const *
        neighborhoodAccessorFunctor: itk::NeighborhoodAccessorFunctor< itk::Image< itk::CovariantVector< float,2 >,3 > > const &

        """
        return _itkImageBoundaryConditionPython.itkZeroFluxNeumannBoundaryConditionICVF23___call__(self, *args)

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

        Parameters
        ----------
        arg0: itkZeroFluxNeumannBoundaryConditionICVF23 const &

        """
        _itkImageBoundaryConditionPython.itkZeroFluxNeumannBoundaryConditionICVF23_swiginit(self, _itkImageBoundaryConditionPython.new_itkZeroFluxNeumannBoundaryConditionICVF23(*args))
    __swig_destroy__ = _itkImageBoundaryConditionPython.delete_itkZeroFluxNeumannBoundaryConditionICVF23

# Register itkZeroFluxNeumannBoundaryConditionICVF23 in _itkImageBoundaryConditionPython:
_itkImageBoundaryConditionPython.itkZeroFluxNeumannBoundaryConditionICVF23_swigregister(itkZeroFluxNeumannBoundaryConditionICVF23)
class itkZeroFluxNeumannBoundaryConditionICVF32(itkImageBoundaryConditionICVF32):
    r"""Proxy of C++ itkZeroFluxNeumannBoundaryConditionICVF32 class."""

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

    def __call__(self, *args):
        r"""
        __call__(self, point_index, boundary_offset, data) -> itkCovariantVectorF3

        Parameters
        ----------
        point_index: itkOffset2 const &
        boundary_offset: itkOffset2 const &
        data: itk::Neighborhood< itk::CovariantVector< float > * > const *

        __call__(self, point_index, boundary_offset, data, neighborhoodAccessorFunctor) -> itkCovariantVectorF3

        Parameters
        ----------
        point_index: itkOffset2 const &
        boundary_offset: itkOffset2 const &
        data: itk::Neighborhood< itk::CovariantVector< float > * > const *
        neighborhoodAccessorFunctor: itk::NeighborhoodAccessorFunctor< itk::Image< itk::CovariantVector< float > > > const &

        """
        return _itkImageBoundaryConditionPython.itkZeroFluxNeumannBoundaryConditionICVF32___call__(self, *args)

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

        Parameters
        ----------
        arg0: itkZeroFluxNeumannBoundaryConditionICVF32 const &

        """
        _itkImageBoundaryConditionPython.itkZeroFluxNeumannBoundaryConditionICVF32_swiginit(self, _itkImageBoundaryConditionPython.new_itkZeroFluxNeumannBoundaryConditionICVF32(*args))
    __swig_destroy__ = _itkImageBoundaryConditionPython.delete_itkZeroFluxNeumannBoundaryConditionICVF32

# Register itkZeroFluxNeumannBoundaryConditionICVF32 in _itkImageBoundaryConditionPython:
_itkImageBoundaryConditionPython.itkZeroFluxNeumannBoundaryConditionICVF32_swigregister(itkZeroFluxNeumannBoundaryConditionICVF32)
class itkZeroFluxNeumannBoundaryConditionICVF33(itkImageBoundaryConditionICVF33):
    r"""Proxy of C++ itkZeroFluxNeumannBoundaryConditionICVF33 class."""

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

    def __call__(self, *args):
        r"""
        __call__(self, point_index, boundary_offset, data) -> itkCovariantVectorF3

        Parameters
        ----------
        point_index: itkOffset3 const &
        boundary_offset: itkOffset3 const &
        data: itk::Neighborhood< itk::CovariantVector< float > *,3 > const *

        __call__(self, point_index, boundary_offset, data, neighborhoodAccessorFunctor) -> itkCovariantVectorF3

        Parameters
        ----------
        point_index: itkOffset3 const &
        boundary_offset: itkOffset3 const &
        data: itk::Neighborhood< itk::CovariantVector< float > *,3 > const *
        neighborhoodAccessorFunctor: itk::NeighborhoodAccessorFunctor< itk::Image< itk::CovariantVector< float >,3 > > const &

        """
        return _itkImageBoundaryConditionPython.itkZeroFluxNeumannBoundaryConditionICVF33___call__(self, *args)

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

        Parameters
        ----------
        arg0: itkZeroFluxNeumannBoundaryConditionICVF33 const &

        """
        _itkImageBoundaryConditionPython.itkZeroFluxNeumannBoundaryConditionICVF33_swiginit(self, _itkImageBoundaryConditionPython.new_itkZeroFluxNeumannBoundaryConditionICVF33(*args))
    __swig_destroy__ = _itkImageBoundaryConditionPython.delete_itkZeroFluxNeumannBoundaryConditionICVF33

# Register itkZeroFluxNeumannBoundaryConditionICVF33 in _itkImageBoundaryConditionPython:
_itkImageBoundaryConditionPython.itkZeroFluxNeumannBoundaryConditionICVF33_swigregister(itkZeroFluxNeumannBoundaryConditionICVF33)
class itkZeroFluxNeumannBoundaryConditionICVF42(itkImageBoundaryConditionICVF42):
    r"""Proxy of C++ itkZeroFluxNeumannBoundaryConditionICVF42 class."""

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

    def __call__(self, *args):
        r"""
        __call__(self, point_index, boundary_offset, data) -> itkCovariantVectorF4

        Parameters
        ----------
        point_index: itkOffset2 const &
        boundary_offset: itkOffset2 const &
        data: itk::Neighborhood< itk::CovariantVector< float,4 > * > const *

        __call__(self, point_index, boundary_offset, data, neighborhoodAccessorFunctor) -> itkCovariantVectorF4

        Parameters
        ----------
        point_index: itkOffset2 const &
        boundary_offset: itkOffset2 const &
        data: itk::Neighborhood< itk::CovariantVector< float,4 > * > const *
        neighborhoodAccessorFunctor: itk::NeighborhoodAccessorFunctor< itk::Image< itk::CovariantVector< float,4 > > > const &

        """
        return _itkImageBoundaryConditionPython.itkZeroFluxNeumannBoundaryConditionICVF42___call__(self, *args)

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

        Parameters
        ----------
        arg0: itkZeroFluxNeumannBoundaryConditionICVF42 const &

        """
        _itkImageBoundaryConditionPython.itkZeroFluxNeumannBoundaryConditionICVF42_swiginit(self, _itkImageBoundaryConditionPython.new_itkZeroFluxNeumannBoundaryConditionICVF42(*args))
    __swig_destroy__ = _itkImageBoundaryConditionPython.delete_itkZeroFluxNeumannBoundaryConditionICVF42

# Register itkZeroFluxNeumannBoundaryConditionICVF42 in _itkImageBoundaryConditionPython:
_itkImageBoundaryConditionPython.itkZeroFluxNeumannBoundaryConditionICVF42_swigregister(itkZeroFluxNeumannBoundaryConditionICVF42)
class itkZeroFluxNeumannBoundaryConditionICVF43(itkImageBoundaryConditionICVF43):
    r"""Proxy of C++ itkZeroFluxNeumannBoundaryConditionICVF43 class."""

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

    def __call__(self, *args):
        r"""
        __call__(self, point_index, boundary_offset, data) -> itkCovariantVectorF4

        Parameters
        ----------
        point_index: itkOffset3 const &
        boundary_offset: itkOffset3 const &
        data: itk::Neighborhood< itk::CovariantVector< float,4 > *,3 > const *

        __call__(self, point_index, boundary_offset, data, neighborhoodAccessorFunctor) -> itkCovariantVectorF4

        Parameters
        ----------
        point_index: itkOffset3 const &
        boundary_offset: itkOffset3 const &
        data: itk::Neighborhood< itk::CovariantVector< float,4 > *,3 > const *
        neighborhoodAccessorFunctor: itk::NeighborhoodAccessorFunctor< itk::Image< itk::CovariantVector< float,4 >,3 > > const &

        """
        return _itkImageBoundaryConditionPython.itkZeroFluxNeumannBoundaryConditionICVF43___call__(self, *args)

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

        Parameters
        ----------
        arg0: itkZeroFluxNeumannBoundaryConditionICVF43 const &

        """
        _itkImageBoundaryConditionPython.itkZeroFluxNeumannBoundaryConditionICVF43_swiginit(self, _itkImageBoundaryConditionPython.new_itkZeroFluxNeumannBoundaryConditionICVF43(*args))
    __swig_destroy__ = _itkImageBoundaryConditionPython.delete_itkZeroFluxNeumannBoundaryConditionICVF43

# Register itkZeroFluxNeumannBoundaryConditionICVF43 in _itkImageBoundaryConditionPython:
_itkImageBoundaryConditionPython.itkZeroFluxNeumannBoundaryConditionICVF43_swigregister(itkZeroFluxNeumannBoundaryConditionICVF43)
class itkZeroFluxNeumannBoundaryConditionIF2(itkImageBoundaryConditionIF2):
    r"""Proxy of C++ itkZeroFluxNeumannBoundaryConditionIF2 class."""

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

    def __call__(self, *args):
        r"""
        __call__(self, point_index, boundary_offset, data) -> float

        Parameters
        ----------
        point_index: itkOffset2 const &
        boundary_offset: itkOffset2 const &
        data: itk::Neighborhood< float * > const *

        __call__(self, point_index, boundary_offset, data, neighborhoodAccessorFunctor) -> float

        Parameters
        ----------
        point_index: itkOffset2 const &
        boundary_offset: itkOffset2 const &
        data: itk::Neighborhood< float * > const *
        neighborhoodAccessorFunctor: itk::NeighborhoodAccessorFunctor< itk::Image< float > > const &

        """
        return _itkImageBoundaryConditionPython.itkZeroFluxNeumannBoundaryConditionIF2___call__(self, *args)

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

        Parameters
        ----------
        arg0: itkZeroFluxNeumannBoundaryConditionIF2 const &

        """
        _itkImageBoundaryConditionPython.itkZeroFluxNeumannBoundaryConditionIF2_swiginit(self, _itkImageBoundaryConditionPython.new_itkZeroFluxNeumannBoundaryConditionIF2(*args))
    __swig_destroy__ = _itkImageBoundaryConditionPython.delete_itkZeroFluxNeumannBoundaryConditionIF2

# Register itkZeroFluxNeumannBoundaryConditionIF2 in _itkImageBoundaryConditionPython:
_itkImageBoundaryConditionPython.itkZeroFluxNeumannBoundaryConditionIF2_swigregister(itkZeroFluxNeumannBoundaryConditionIF2)
class itkZeroFluxNeumannBoundaryConditionIF3(itkImageBoundaryConditionIF3):
    r"""Proxy of C++ itkZeroFluxNeumannBoundaryConditionIF3 class."""

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

    def __call__(self, *args):
        r"""
        __call__(self, point_index, boundary_offset, data) -> float

        Parameters
        ----------
        point_index: itkOffset3 const &
        boundary_offset: itkOffset3 const &
        data: itk::Neighborhood< float *,3 > const *

        __call__(self, point_index, boundary_offset, data, neighborhoodAccessorFunctor) -> float

        Parameters
        ----------
        point_index: itkOffset3 const &
        boundary_offset: itkOffset3 const &
        data: itk::Neighborhood< float *,3 > const *
        neighborhoodAccessorFunctor: itk::NeighborhoodAccessorFunctor< itk::Image< float,3 > > const &

        """
        return _itkImageBoundaryConditionPython.itkZeroFluxNeumannBoundaryConditionIF3___call__(self, *args)

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

        Parameters
        ----------
        arg0: itkZeroFluxNeumannBoundaryConditionIF3 const &

        """
        _itkImageBoundaryConditionPython.itkZeroFluxNeumannBoundaryConditionIF3_swiginit(self, _itkImageBoundaryConditionPython.new_itkZeroFluxNeumannBoundaryConditionIF3(*args))
    __swig_destroy__ = _itkImageBoundaryConditionPython.delete_itkZeroFluxNeumannBoundaryConditionIF3

# Register itkZeroFluxNeumannBoundaryConditionIF3 in _itkImageBoundaryConditionPython:
_itkImageBoundaryConditionPython.itkZeroFluxNeumannBoundaryConditionIF3_swigregister(itkZeroFluxNeumannBoundaryConditionIF3)
class itkZeroFluxNeumannBoundaryConditionIRGBAUC2(itkImageBoundaryConditionIRGBAUC2):
    r"""Proxy of C++ itkZeroFluxNeumannBoundaryConditionIRGBAUC2 class."""

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

    def __call__(self, *args):
        r"""
        __call__(self, point_index, boundary_offset, data) -> itkRGBAPixelUC

        Parameters
        ----------
        point_index: itkOffset2 const &
        boundary_offset: itkOffset2 const &
        data: itk::Neighborhood< itk::RGBAPixel< unsigned char > * > const *

        __call__(self, point_index, boundary_offset, data, neighborhoodAccessorFunctor) -> itkRGBAPixelUC

        Parameters
        ----------
        point_index: itkOffset2 const &
        boundary_offset: itkOffset2 const &
        data: itk::Neighborhood< itk::RGBAPixel< unsigned char > * > const *
        neighborhoodAccessorFunctor: itk::NeighborhoodAccessorFunctor< itk::Image< itk::RGBAPixel< unsigned char > > > const &

        """
        return _itkImageBoundaryConditionPython.itkZeroFluxNeumannBoundaryConditionIRGBAUC2___call__(self, *args)

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

        Parameters
        ----------
        arg0: itkZeroFluxNeumannBoundaryConditionIRGBAUC2 const &

        """
        _itkImageBoundaryConditionPython.itkZeroFluxNeumannBoundaryConditionIRGBAUC2_swiginit(self, _itkImageBoundaryConditionPython.new_itkZeroFluxNeumannBoundaryConditionIRGBAUC2(*args))
    __swig_destroy__ = _itkImageBoundaryConditionPython.delete_itkZeroFluxNeumannBoundaryConditionIRGBAUC2

# Register itkZeroFluxNeumannBoundaryConditionIRGBAUC2 in _itkImageBoundaryConditionPython:
_itkImageBoundaryConditionPython.itkZeroFluxNeumannBoundaryConditionIRGBAUC2_swigregister(itkZeroFluxNeumannBoundaryConditionIRGBAUC2)
class itkZeroFluxNeumannBoundaryConditionIRGBAUC3(itkImageBoundaryConditionIRGBAUC3):
    r"""Proxy of C++ itkZeroFluxNeumannBoundaryConditionIRGBAUC3 class."""

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

    def __call__(self, *args):
        r"""
        __call__(self, point_index, boundary_offset, data) -> itkRGBAPixelUC

        Parameters
        ----------
        point_index: itkOffset3 const &
        boundary_offset: itkOffset3 const &
        data: itk::Neighborhood< itk::RGBAPixel< unsigned char > *,3 > const *

        __call__(self, point_index, boundary_offset, data, neighborhoodAccessorFunctor) -> itkRGBAPixelUC

        Parameters
        ----------
        point_index: itkOffset3 const &
        boundary_offset: itkOffset3 const &
        data: itk::Neighborhood< itk::RGBAPixel< unsigned char > *,3 > const *
        neighborhoodAccessorFunctor: itk::NeighborhoodAccessorFunctor< itk::Image< itk::RGBAPixel< unsigned char >,3 > > const &

        """
        return _itkImageBoundaryConditionPython.itkZeroFluxNeumannBoundaryConditionIRGBAUC3___call__(self, *args)

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

        Parameters
        ----------
        arg0: itkZeroFluxNeumannBoundaryConditionIRGBAUC3 const &

        """
        _itkImageBoundaryConditionPython.itkZeroFluxNeumannBoundaryConditionIRGBAUC3_swiginit(self, _itkImageBoundaryConditionPython.new_itkZeroFluxNeumannBoundaryConditionIRGBAUC3(*args))
    __swig_destroy__ = _itkImageBoundaryConditionPython.delete_itkZeroFluxNeumannBoundaryConditionIRGBAUC3

# Register itkZeroFluxNeumannBoundaryConditionIRGBAUC3 in _itkImageBoundaryConditionPython:
_itkImageBoundaryConditionPython.itkZeroFluxNeumannBoundaryConditionIRGBAUC3_swigregister(itkZeroFluxNeumannBoundaryConditionIRGBAUC3)
class itkZeroFluxNeumannBoundaryConditionIRGBUC2(itkImageBoundaryConditionIRGBUC2):
    r"""Proxy of C++ itkZeroFluxNeumannBoundaryConditionIRGBUC2 class."""

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

    def __call__(self, *args):
        r"""
        __call__(self, point_index, boundary_offset, data) -> itkRGBPixelUC

        Parameters
        ----------
        point_index: itkOffset2 const &
        boundary_offset: itkOffset2 const &
        data: itk::Neighborhood< itk::RGBPixel< unsigned char > * > const *

        __call__(self, point_index, boundary_offset, data, neighborhoodAccessorFunctor) -> itkRGBPixelUC

        Parameters
        ----------
        point_index: itkOffset2 const &
        boundary_offset: itkOffset2 const &
        data: itk::Neighborhood< itk::RGBPixel< unsigned char > * > const *
        neighborhoodAccessorFunctor: itk::NeighborhoodAccessorFunctor< itk::Image< itk::RGBPixel< unsigned char > > > const &

        """
        return _itkImageBoundaryConditionPython.itkZeroFluxNeumannBoundaryConditionIRGBUC2___call__(self, *args)

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

        Parameters
        ----------
        arg0: itkZeroFluxNeumannBoundaryConditionIRGBUC2 const &

        """
        _itkImageBoundaryConditionPython.itkZeroFluxNeumannBoundaryConditionIRGBUC2_swiginit(self, _itkImageBoundaryConditionPython.new_itkZeroFluxNeumannBoundaryConditionIRGBUC2(*args))
    __swig_destroy__ = _itkImageBoundaryConditionPython.delete_itkZeroFluxNeumannBoundaryConditionIRGBUC2

# Register itkZeroFluxNeumannBoundaryConditionIRGBUC2 in _itkImageBoundaryConditionPython:
_itkImageBoundaryConditionPython.itkZeroFluxNeumannBoundaryConditionIRGBUC2_swigregister(itkZeroFluxNeumannBoundaryConditionIRGBUC2)
class itkZeroFluxNeumannBoundaryConditionIRGBUC3(itkImageBoundaryConditionIRGBUC3):
    r"""Proxy of C++ itkZeroFluxNeumannBoundaryConditionIRGBUC3 class."""

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

    def __call__(self, *args):
        r"""
        __call__(self, point_index, boundary_offset, data) -> itkRGBPixelUC

        Parameters
        ----------
        point_index: itkOffset3 const &
        boundary_offset: itkOffset3 const &
        data: itk::Neighborhood< itk::RGBPixel< unsigned char > *,3 > const *

        __call__(self, point_index, boundary_offset, data, neighborhoodAccessorFunctor) -> itkRGBPixelUC

        Parameters
        ----------
        point_index: itkOffset3 const &
        boundary_offset: itkOffset3 const &
        data: itk::Neighborhood< itk::RGBPixel< unsigned char > *,3 > const *
        neighborhoodAccessorFunctor: itk::NeighborhoodAccessorFunctor< itk::Image< itk::RGBPixel< unsigned char >,3 > > const &

        """
        return _itkImageBoundaryConditionPython.itkZeroFluxNeumannBoundaryConditionIRGBUC3___call__(self, *args)

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

        Parameters
        ----------
        arg0: itkZeroFluxNeumannBoundaryConditionIRGBUC3 const &

        """
        _itkImageBoundaryConditionPython.itkZeroFluxNeumannBoundaryConditionIRGBUC3_swiginit(self, _itkImageBoundaryConditionPython.new_itkZeroFluxNeumannBoundaryConditionIRGBUC3(*args))
    __swig_destroy__ = _itkImageBoundaryConditionPython.delete_itkZeroFluxNeumannBoundaryConditionIRGBUC3

# Register itkZeroFluxNeumannBoundaryConditionIRGBUC3 in _itkImageBoundaryConditionPython:
_itkImageBoundaryConditionPython.itkZeroFluxNeumannBoundaryConditionIRGBUC3_swigregister(itkZeroFluxNeumannBoundaryConditionIRGBUC3)
class itkZeroFluxNeumannBoundaryConditionISS2(itkImageBoundaryConditionISS2):
    r"""Proxy of C++ itkZeroFluxNeumannBoundaryConditionISS2 class."""

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

    def __call__(self, *args):
        r"""
        __call__(self, point_index, boundary_offset, data) -> short

        Parameters
        ----------
        point_index: itkOffset2 const &
        boundary_offset: itkOffset2 const &
        data: itk::Neighborhood< short * > const *

        __call__(self, point_index, boundary_offset, data, neighborhoodAccessorFunctor) -> short

        Parameters
        ----------
        point_index: itkOffset2 const &
        boundary_offset: itkOffset2 const &
        data: itk::Neighborhood< short * > const *
        neighborhoodAccessorFunctor: itk::NeighborhoodAccessorFunctor< itk::Image< short > > const &

        """
        return _itkImageBoundaryConditionPython.itkZeroFluxNeumannBoundaryConditionISS2___call__(self, *args)

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

        Parameters
        ----------
        arg0: itkZeroFluxNeumannBoundaryConditionISS2 const &

        """
        _itkImageBoundaryConditionPython.itkZeroFluxNeumannBoundaryConditionISS2_swiginit(self, _itkImageBoundaryConditionPython.new_itkZeroFluxNeumannBoundaryConditionISS2(*args))
    __swig_destroy__ = _itkImageBoundaryConditionPython.delete_itkZeroFluxNeumannBoundaryConditionISS2

# Register itkZeroFluxNeumannBoundaryConditionISS2 in _itkImageBoundaryConditionPython:
_itkImageBoundaryConditionPython.itkZeroFluxNeumannBoundaryConditionISS2_swigregister(itkZeroFluxNeumannBoundaryConditionISS2)
class itkZeroFluxNeumannBoundaryConditionISS3(itkImageBoundaryConditionISS3):
    r"""Proxy of C++ itkZeroFluxNeumannBoundaryConditionISS3 class."""

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

    def __call__(self, *args):
        r"""
        __call__(self, point_index, boundary_offset, data) -> short

        Parameters
        ----------
        point_index: itkOffset3 const &
        boundary_offset: itkOffset3 const &
        data: itk::Neighborhood< short *,3 > const *

        __call__(self, point_index, boundary_offset, data, neighborhoodAccessorFunctor) -> short

        Parameters
        ----------
        point_index: itkOffset3 const &
        boundary_offset: itkOffset3 const &
        data: itk::Neighborhood< short *,3 > const *
        neighborhoodAccessorFunctor: itk::NeighborhoodAccessorFunctor< itk::Image< short,3 > > const &

        """
        return _itkImageBoundaryConditionPython.itkZeroFluxNeumannBoundaryConditionISS3___call__(self, *args)

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

        Parameters
        ----------
        arg0: itkZeroFluxNeumannBoundaryConditionISS3 const &

        """
        _itkImageBoundaryConditionPython.itkZeroFluxNeumannBoundaryConditionISS3_swiginit(self, _itkImageBoundaryConditionPython.new_itkZeroFluxNeumannBoundaryConditionISS3(*args))
    __swig_destroy__ = _itkImageBoundaryConditionPython.delete_itkZeroFluxNeumannBoundaryConditionISS3

# Register itkZeroFluxNeumannBoundaryConditionISS3 in _itkImageBoundaryConditionPython:
_itkImageBoundaryConditionPython.itkZeroFluxNeumannBoundaryConditionISS3_swigregister(itkZeroFluxNeumannBoundaryConditionISS3)
class itkZeroFluxNeumannBoundaryConditionIUC2(itkImageBoundaryConditionIUC2):
    r"""Proxy of C++ itkZeroFluxNeumannBoundaryConditionIUC2 class."""

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

    def __call__(self, *args):
        r"""
        __call__(self, point_index, boundary_offset, data) -> unsigned char

        Parameters
        ----------
        point_index: itkOffset2 const &
        boundary_offset: itkOffset2 const &
        data: itk::Neighborhood< unsigned char * > const *

        __call__(self, point_index, boundary_offset, data, neighborhoodAccessorFunctor) -> unsigned char

        Parameters
        ----------
        point_index: itkOffset2 const &
        boundary_offset: itkOffset2 const &
        data: itk::Neighborhood< unsigned char * > const *
        neighborhoodAccessorFunctor: itk::NeighborhoodAccessorFunctor< itk::Image< unsigned char > > const &

        """
        return _itkImageBoundaryConditionPython.itkZeroFluxNeumannBoundaryConditionIUC2___call__(self, *args)

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

        Parameters
        ----------
        arg0: itkZeroFluxNeumannBoundaryConditionIUC2 const &

        """
        _itkImageBoundaryConditionPython.itkZeroFluxNeumannBoundaryConditionIUC2_swiginit(self, _itkImageBoundaryConditionPython.new_itkZeroFluxNeumannBoundaryConditionIUC2(*args))
    __swig_destroy__ = _itkImageBoundaryConditionPython.delete_itkZeroFluxNeumannBoundaryConditionIUC2

# Register itkZeroFluxNeumannBoundaryConditionIUC2 in _itkImageBoundaryConditionPython:
_itkImageBoundaryConditionPython.itkZeroFluxNeumannBoundaryConditionIUC2_swigregister(itkZeroFluxNeumannBoundaryConditionIUC2)
class itkZeroFluxNeumannBoundaryConditionIUC3(itkImageBoundaryConditionIUC3):
    r"""Proxy of C++ itkZeroFluxNeumannBoundaryConditionIUC3 class."""

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

    def __call__(self, *args):
        r"""
        __call__(self, point_index, boundary_offset, data) -> unsigned char

        Parameters
        ----------
        point_index: itkOffset3 const &
        boundary_offset: itkOffset3 const &
        data: itk::Neighborhood< unsigned char *,3 > const *

        __call__(self, point_index, boundary_offset, data, neighborhoodAccessorFunctor) -> unsigned char

        Parameters
        ----------
        point_index: itkOffset3 const &
        boundary_offset: itkOffset3 const &
        data: itk::Neighborhood< unsigned char *,3 > const *
        neighborhoodAccessorFunctor: itk::NeighborhoodAccessorFunctor< itk::Image< unsigned char,3 > > const &

        """
        return _itkImageBoundaryConditionPython.itkZeroFluxNeumannBoundaryConditionIUC3___call__(self, *args)

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

        Parameters
        ----------
        arg0: itkZeroFluxNeumannBoundaryConditionIUC3 const &

        """
        _itkImageBoundaryConditionPython.itkZeroFluxNeumannBoundaryConditionIUC3_swiginit(self, _itkImageBoundaryConditionPython.new_itkZeroFluxNeumannBoundaryConditionIUC3(*args))
    __swig_destroy__ = _itkImageBoundaryConditionPython.delete_itkZeroFluxNeumannBoundaryConditionIUC3

# Register itkZeroFluxNeumannBoundaryConditionIUC3 in _itkImageBoundaryConditionPython:
_itkImageBoundaryConditionPython.itkZeroFluxNeumannBoundaryConditionIUC3_swigregister(itkZeroFluxNeumannBoundaryConditionIUC3)
class itkZeroFluxNeumannBoundaryConditionIVF22(itkImageBoundaryConditionIVF22):
    r"""Proxy of C++ itkZeroFluxNeumannBoundaryConditionIVF22 class."""

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

    def __call__(self, *args):
        r"""
        __call__(self, point_index, boundary_offset, data) -> itkVectorF2

        Parameters
        ----------
        point_index: itkOffset2 const &
        boundary_offset: itkOffset2 const &
        data: itk::Neighborhood< itk::Vector< float,2 > * > const *

        __call__(self, point_index, boundary_offset, data, neighborhoodAccessorFunctor) -> itkVectorF2

        Parameters
        ----------
        point_index: itkOffset2 const &
        boundary_offset: itkOffset2 const &
        data: itk::Neighborhood< itk::Vector< float,2 > * > const *
        neighborhoodAccessorFunctor: itk::NeighborhoodAccessorFunctor< itk::Image< itk::Vector< float,2 > > > const &

        """
        return _itkImageBoundaryConditionPython.itkZeroFluxNeumannBoundaryConditionIVF22___call__(self, *args)

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

        Parameters
        ----------
        arg0: itkZeroFluxNeumannBoundaryConditionIVF22 const &

        """
        _itkImageBoundaryConditionPython.itkZeroFluxNeumannBoundaryConditionIVF22_swiginit(self, _itkImageBoundaryConditionPython.new_itkZeroFluxNeumannBoundaryConditionIVF22(*args))
    __swig_destroy__ = _itkImageBoundaryConditionPython.delete_itkZeroFluxNeumannBoundaryConditionIVF22

# Register itkZeroFluxNeumannBoundaryConditionIVF22 in _itkImageBoundaryConditionPython:
_itkImageBoundaryConditionPython.itkZeroFluxNeumannBoundaryConditionIVF22_swigregister(itkZeroFluxNeumannBoundaryConditionIVF22)
class itkZeroFluxNeumannBoundaryConditionIVF23(itkImageBoundaryConditionIVF23):
    r"""Proxy of C++ itkZeroFluxNeumannBoundaryConditionIVF23 class."""

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

    def __call__(self, *args):
        r"""
        __call__(self, point_index, boundary_offset, data) -> itkVectorF2

        Parameters
        ----------
        point_index: itkOffset3 const &
        boundary_offset: itkOffset3 const &
        data: itk::Neighborhood< itk::Vector< float,2 > *,3 > const *

        __call__(self, point_index, boundary_offset, data, neighborhoodAccessorFunctor) -> itkVectorF2

        Parameters
        ----------
        point_index: itkOffset3 const &
        boundary_offset: itkOffset3 const &
        data: itk::Neighborhood< itk::Vector< float,2 > *,3 > const *
        neighborhoodAccessorFunctor: itk::NeighborhoodAccessorFunctor< itk::Image< itk::Vector< float,2 >,3 > > const &

        """
        return _itkImageBoundaryConditionPython.itkZeroFluxNeumannBoundaryConditionIVF23___call__(self, *args)

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

        Parameters
        ----------
        arg0: itkZeroFluxNeumannBoundaryConditionIVF23 const &

        """
        _itkImageBoundaryConditionPython.itkZeroFluxNeumannBoundaryConditionIVF23_swiginit(self, _itkImageBoundaryConditionPython.new_itkZeroFluxNeumannBoundaryConditionIVF23(*args))
    __swig_destroy__ = _itkImageBoundaryConditionPython.delete_itkZeroFluxNeumannBoundaryConditionIVF23

# Register itkZeroFluxNeumannBoundaryConditionIVF23 in _itkImageBoundaryConditionPython:
_itkImageBoundaryConditionPython.itkZeroFluxNeumannBoundaryConditionIVF23_swigregister(itkZeroFluxNeumannBoundaryConditionIVF23)
class itkZeroFluxNeumannBoundaryConditionIVF32(itkImageBoundaryConditionIVF32):
    r"""Proxy of C++ itkZeroFluxNeumannBoundaryConditionIVF32 class."""

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

    def __call__(self, *args):
        r"""
        __call__(self, point_index, boundary_offset, data) -> itkVectorF3

        Parameters
        ----------
        point_index: itkOffset2 const &
        boundary_offset: itkOffset2 const &
        data: itk::Neighborhood< itk::Vector< float > * > const *

        __call__(self, point_index, boundary_offset, data, neighborhoodAccessorFunctor) -> itkVectorF3

        Parameters
        ----------
        point_index: itkOffset2 const &
        boundary_offset: itkOffset2 const &
        data: itk::Neighborhood< itk::Vector< float > * > const *
        neighborhoodAccessorFunctor: itk::NeighborhoodAccessorFunctor< itk::Image< itk::Vector< float > > > const &

        """
        return _itkImageBoundaryConditionPython.itkZeroFluxNeumannBoundaryConditionIVF32___call__(self, *args)

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

        Parameters
        ----------
        arg0: itkZeroFluxNeumannBoundaryConditionIVF32 const &

        """
        _itkImageBoundaryConditionPython.itkZeroFluxNeumannBoundaryConditionIVF32_swiginit(self, _itkImageBoundaryConditionPython.new_itkZeroFluxNeumannBoundaryConditionIVF32(*args))
    __swig_destroy__ = _itkImageBoundaryConditionPython.delete_itkZeroFluxNeumannBoundaryConditionIVF32

# Register itkZeroFluxNeumannBoundaryConditionIVF32 in _itkImageBoundaryConditionPython:
_itkImageBoundaryConditionPython.itkZeroFluxNeumannBoundaryConditionIVF32_swigregister(itkZeroFluxNeumannBoundaryConditionIVF32)
class itkZeroFluxNeumannBoundaryConditionIVF33(itkImageBoundaryConditionIVF33):
    r"""Proxy of C++ itkZeroFluxNeumannBoundaryConditionIVF33 class."""

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

    def __call__(self, *args):
        r"""
        __call__(self, point_index, boundary_offset, data) -> itkVectorF3

        Parameters
        ----------
        point_index: itkOffset3 const &
        boundary_offset: itkOffset3 const &
        data: itk::Neighborhood< itk::Vector< float > *,3 > const *

        __call__(self, point_index, boundary_offset, data, neighborhoodAccessorFunctor) -> itkVectorF3

        Parameters
        ----------
        point_index: itkOffset3 const &
        boundary_offset: itkOffset3 const &
        data: itk::Neighborhood< itk::Vector< float > *,3 > const *
        neighborhoodAccessorFunctor: itk::NeighborhoodAccessorFunctor< itk::Image< itk::Vector< float >,3 > > const &

        """
        return _itkImageBoundaryConditionPython.itkZeroFluxNeumannBoundaryConditionIVF33___call__(self, *args)

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

        Parameters
        ----------
        arg0: itkZeroFluxNeumannBoundaryConditionIVF33 const &

        """
        _itkImageBoundaryConditionPython.itkZeroFluxNeumannBoundaryConditionIVF33_swiginit(self, _itkImageBoundaryConditionPython.new_itkZeroFluxNeumannBoundaryConditionIVF33(*args))
    __swig_destroy__ = _itkImageBoundaryConditionPython.delete_itkZeroFluxNeumannBoundaryConditionIVF33

# Register itkZeroFluxNeumannBoundaryConditionIVF33 in _itkImageBoundaryConditionPython:
_itkImageBoundaryConditionPython.itkZeroFluxNeumannBoundaryConditionIVF33_swigregister(itkZeroFluxNeumannBoundaryConditionIVF33)
class itkZeroFluxNeumannBoundaryConditionIVF42(itkImageBoundaryConditionIVF42):
    r"""Proxy of C++ itkZeroFluxNeumannBoundaryConditionIVF42 class."""

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

    def __call__(self, *args):
        r"""
        __call__(self, point_index, boundary_offset, data) -> itkVectorF4

        Parameters
        ----------
        point_index: itkOffset2 const &
        boundary_offset: itkOffset2 const &
        data: itk::Neighborhood< itk::Vector< float,4 > * > const *

        __call__(self, point_index, boundary_offset, data, neighborhoodAccessorFunctor) -> itkVectorF4

        Parameters
        ----------
        point_index: itkOffset2 const &
        boundary_offset: itkOffset2 const &
        data: itk::Neighborhood< itk::Vector< float,4 > * > const *
        neighborhoodAccessorFunctor: itk::NeighborhoodAccessorFunctor< itk::Image< itk::Vector< float,4 > > > const &

        """
        return _itkImageBoundaryConditionPython.itkZeroFluxNeumannBoundaryConditionIVF42___call__(self, *args)

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

        Parameters
        ----------
        arg0: itkZeroFluxNeumannBoundaryConditionIVF42 const &

        """
        _itkImageBoundaryConditionPython.itkZeroFluxNeumannBoundaryConditionIVF42_swiginit(self, _itkImageBoundaryConditionPython.new_itkZeroFluxNeumannBoundaryConditionIVF42(*args))
    __swig_destroy__ = _itkImageBoundaryConditionPython.delete_itkZeroFluxNeumannBoundaryConditionIVF42

# Register itkZeroFluxNeumannBoundaryConditionIVF42 in _itkImageBoundaryConditionPython:
_itkImageBoundaryConditionPython.itkZeroFluxNeumannBoundaryConditionIVF42_swigregister(itkZeroFluxNeumannBoundaryConditionIVF42)
class itkZeroFluxNeumannBoundaryConditionIVF43(itkImageBoundaryConditionIVF43):
    r"""Proxy of C++ itkZeroFluxNeumannBoundaryConditionIVF43 class."""

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

    def __call__(self, *args):
        r"""
        __call__(self, point_index, boundary_offset, data) -> itkVectorF4

        Parameters
        ----------
        point_index: itkOffset3 const &
        boundary_offset: itkOffset3 const &
        data: itk::Neighborhood< itk::Vector< float,4 > *,3 > const *

        __call__(self, point_index, boundary_offset, data, neighborhoodAccessorFunctor) -> itkVectorF4

        Parameters
        ----------
        point_index: itkOffset3 const &
        boundary_offset: itkOffset3 const &
        data: itk::Neighborhood< itk::Vector< float,4 > *,3 > const *
        neighborhoodAccessorFunctor: itk::NeighborhoodAccessorFunctor< itk::Image< itk::Vector< float,4 >,3 > > const &

        """
        return _itkImageBoundaryConditionPython.itkZeroFluxNeumannBoundaryConditionIVF43___call__(self, *args)

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

        Parameters
        ----------
        arg0: itkZeroFluxNeumannBoundaryConditionIVF43 const &

        """
        _itkImageBoundaryConditionPython.itkZeroFluxNeumannBoundaryConditionIVF43_swiginit(self, _itkImageBoundaryConditionPython.new_itkZeroFluxNeumannBoundaryConditionIVF43(*args))
    __swig_destroy__ = _itkImageBoundaryConditionPython.delete_itkZeroFluxNeumannBoundaryConditionIVF43

# Register itkZeroFluxNeumannBoundaryConditionIVF43 in _itkImageBoundaryConditionPython:
_itkImageBoundaryConditionPython.itkZeroFluxNeumannBoundaryConditionIVF43_swigregister(itkZeroFluxNeumannBoundaryConditionIVF43)
class itkConstantBoundaryConditionICF2(itkImageBoundaryConditionICF2):
    r"""Proxy of C++ itkConstantBoundaryConditionICF2 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, i=0):
        r"""
        Print(self, os, i=0)

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

        """
        return _itkImageBoundaryConditionPython.itkConstantBoundaryConditionICF2_Print(self, os, i)

    def __call__(self, *args):
        r"""
        __call__(self, arg0, arg1, arg2) -> stdcomplexF

        Parameters
        ----------
        arg0: itkOffset2 const &
        arg1: itkOffset2 const &
        arg2: itk::Neighborhood< std::complex< float > * > const *

        __call__(self, arg0, arg1, arg2, arg3) -> stdcomplexF

        Parameters
        ----------
        arg0: itkOffset2 const &
        arg1: itkOffset2 const &
        arg2: itk::Neighborhood< std::complex< float > * > const *
        arg3: itk::NeighborhoodAccessorFunctor< itk::Image< std::complex< float > > > const &

        """
        return _itkImageBoundaryConditionPython.itkConstantBoundaryConditionICF2___call__(self, *args)

    def SetConstant(self, c):
        r"""
        SetConstant(self, c)

        Parameters
        ----------
        c: stdcomplexF const &

        """
        return _itkImageBoundaryConditionPython.itkConstantBoundaryConditionICF2_SetConstant(self, c)

    def GetConstant(self):
        r"""GetConstant(self) -> stdcomplexF"""
        return _itkImageBoundaryConditionPython.itkConstantBoundaryConditionICF2_GetConstant(self)

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

        Parameters
        ----------
        arg0: itkConstantBoundaryConditionICF2 const &

        """
        _itkImageBoundaryConditionPython.itkConstantBoundaryConditionICF2_swiginit(self, _itkImageBoundaryConditionPython.new_itkConstantBoundaryConditionICF2(*args))
    __swig_destroy__ = _itkImageBoundaryConditionPython.delete_itkConstantBoundaryConditionICF2

# Register itkConstantBoundaryConditionICF2 in _itkImageBoundaryConditionPython:
_itkImageBoundaryConditionPython.itkConstantBoundaryConditionICF2_swigregister(itkConstantBoundaryConditionICF2)
class itkConstantBoundaryConditionICF3(itkImageBoundaryConditionICF3):
    r"""Proxy of C++ itkConstantBoundaryConditionICF3 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, i=0):
        r"""
        Print(self, os, i=0)

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

        """
        return _itkImageBoundaryConditionPython.itkConstantBoundaryConditionICF3_Print(self, os, i)

    def __call__(self, *args):
        r"""
        __call__(self, arg0, arg1, arg2) -> stdcomplexF

        Parameters
        ----------
        arg0: itkOffset3 const &
        arg1: itkOffset3 const &
        arg2: itk::Neighborhood< std::complex< float > *,3 > const *

        __call__(self, arg0, arg1, arg2, arg3) -> stdcomplexF

        Parameters
        ----------
        arg0: itkOffset3 const &
        arg1: itkOffset3 const &
        arg2: itk::Neighborhood< std::complex< float > *,3 > const *
        arg3: itk::NeighborhoodAccessorFunctor< itk::Image< std::complex< float >,3 > > const &

        """
        return _itkImageBoundaryConditionPython.itkConstantBoundaryConditionICF3___call__(self, *args)

    def SetConstant(self, c):
        r"""
        SetConstant(self, c)

        Parameters
        ----------
        c: stdcomplexF const &

        """
        return _itkImageBoundaryConditionPython.itkConstantBoundaryConditionICF3_SetConstant(self, c)

    def GetConstant(self):
        r"""GetConstant(self) -> stdcomplexF"""
        return _itkImageBoundaryConditionPython.itkConstantBoundaryConditionICF3_GetConstant(self)

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

        Parameters
        ----------
        arg0: itkConstantBoundaryConditionICF3 const &

        """
        _itkImageBoundaryConditionPython.itkConstantBoundaryConditionICF3_swiginit(self, _itkImageBoundaryConditionPython.new_itkConstantBoundaryConditionICF3(*args))
    __swig_destroy__ = _itkImageBoundaryConditionPython.delete_itkConstantBoundaryConditionICF3

# Register itkConstantBoundaryConditionICF3 in _itkImageBoundaryConditionPython:
_itkImageBoundaryConditionPython.itkConstantBoundaryConditionICF3_swigregister(itkConstantBoundaryConditionICF3)
class itkConstantBoundaryConditionICVF22(itkImageBoundaryConditionICVF22):
    r"""Proxy of C++ itkConstantBoundaryConditionICVF22 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, i=0):
        r"""
        Print(self, os, i=0)

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

        """
        return _itkImageBoundaryConditionPython.itkConstantBoundaryConditionICVF22_Print(self, os, i)

    def __call__(self, *args):
        r"""
        __call__(self, arg0, arg1, arg2) -> itkCovariantVectorF2

        Parameters
        ----------
        arg0: itkOffset2 const &
        arg1: itkOffset2 const &
        arg2: itk::Neighborhood< itk::CovariantVector< float,2 > * > const *

        __call__(self, arg0, arg1, arg2, arg3) -> itkCovariantVectorF2

        Parameters
        ----------
        arg0: itkOffset2 const &
        arg1: itkOffset2 const &
        arg2: itk::Neighborhood< itk::CovariantVector< float,2 > * > const *
        arg3: itk::NeighborhoodAccessorFunctor< itk::Image< itk::CovariantVector< float,2 > > > const &

        """
        return _itkImageBoundaryConditionPython.itkConstantBoundaryConditionICVF22___call__(self, *args)

    def SetConstant(self, c):
        r"""
        SetConstant(self, c)

        Parameters
        ----------
        c: itkCovariantVectorF2 const &

        """
        return _itkImageBoundaryConditionPython.itkConstantBoundaryConditionICVF22_SetConstant(self, c)

    def GetConstant(self):
        r"""GetConstant(self) -> itkCovariantVectorF2"""
        return _itkImageBoundaryConditionPython.itkConstantBoundaryConditionICVF22_GetConstant(self)

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

        Parameters
        ----------
        arg0: itkConstantBoundaryConditionICVF22 const &

        """
        _itkImageBoundaryConditionPython.itkConstantBoundaryConditionICVF22_swiginit(self, _itkImageBoundaryConditionPython.new_itkConstantBoundaryConditionICVF22(*args))
    __swig_destroy__ = _itkImageBoundaryConditionPython.delete_itkConstantBoundaryConditionICVF22

# Register itkConstantBoundaryConditionICVF22 in _itkImageBoundaryConditionPython:
_itkImageBoundaryConditionPython.itkConstantBoundaryConditionICVF22_swigregister(itkConstantBoundaryConditionICVF22)
class itkConstantBoundaryConditionICVF23(itkImageBoundaryConditionICVF23):
    r"""Proxy of C++ itkConstantBoundaryConditionICVF23 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, i=0):
        r"""
        Print(self, os, i=0)

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

        """
        return _itkImageBoundaryConditionPython.itkConstantBoundaryConditionICVF23_Print(self, os, i)

    def __call__(self, *args):
        r"""
        __call__(self, arg0, arg1, arg2) -> itkCovariantVectorF2

        Parameters
        ----------
        arg0: itkOffset3 const &
        arg1: itkOffset3 const &
        arg2: itk::Neighborhood< itk::CovariantVector< float,2 > *,3 > const *

        __call__(self, arg0, arg1, arg2, arg3) -> itkCovariantVectorF2

        Parameters
        ----------
        arg0: itkOffset3 const &
        arg1: itkOffset3 const &
        arg2: itk::Neighborhood< itk::CovariantVector< float,2 > *,3 > const *
        arg3: itk::NeighborhoodAccessorFunctor< itk::Image< itk::CovariantVector< float,2 >,3 > > const &

        """
        return _itkImageBoundaryConditionPython.itkConstantBoundaryConditionICVF23___call__(self, *args)

    def SetConstant(self, c):
        r"""
        SetConstant(self, c)

        Parameters
        ----------
        c: itkCovariantVectorF2 const &

        """
        return _itkImageBoundaryConditionPython.itkConstantBoundaryConditionICVF23_SetConstant(self, c)

    def GetConstant(self):
        r"""GetConstant(self) -> itkCovariantVectorF2"""
        return _itkImageBoundaryConditionPython.itkConstantBoundaryConditionICVF23_GetConstant(self)

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

        Parameters
        ----------
        arg0: itkConstantBoundaryConditionICVF23 const &

        """
        _itkImageBoundaryConditionPython.itkConstantBoundaryConditionICVF23_swiginit(self, _itkImageBoundaryConditionPython.new_itkConstantBoundaryConditionICVF23(*args))
    __swig_destroy__ = _itkImageBoundaryConditionPython.delete_itkConstantBoundaryConditionICVF23

# Register itkConstantBoundaryConditionICVF23 in _itkImageBoundaryConditionPython:
_itkImageBoundaryConditionPython.itkConstantBoundaryConditionICVF23_swigregister(itkConstantBoundaryConditionICVF23)
class itkConstantBoundaryConditionICVF32(itkImageBoundaryConditionICVF32):
    r"""Proxy of C++ itkConstantBoundaryConditionICVF32 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, i=0):
        r"""
        Print(self, os, i=0)

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

        """
        return _itkImageBoundaryConditionPython.itkConstantBoundaryConditionICVF32_Print(self, os, i)

    def __call__(self, *args):
        r"""
        __call__(self, arg0, arg1, arg2) -> itkCovariantVectorF3

        Parameters
        ----------
        arg0: itkOffset2 const &
        arg1: itkOffset2 const &
        arg2: itk::Neighborhood< itk::CovariantVector< float > * > const *

        __call__(self, arg0, arg1, arg2, arg3) -> itkCovariantVectorF3

        Parameters
        ----------
        arg0: itkOffset2 const &
        arg1: itkOffset2 const &
        arg2: itk::Neighborhood< itk::CovariantVector< float > * > const *
        arg3: itk::NeighborhoodAccessorFunctor< itk::Image< itk::CovariantVector< float > > > const &

        """
        return _itkImageBoundaryConditionPython.itkConstantBoundaryConditionICVF32___call__(self, *args)

    def SetConstant(self, c):
        r"""
        SetConstant(self, c)

        Parameters
        ----------
        c: itkCovariantVectorF3 const &

        """
        return _itkImageBoundaryConditionPython.itkConstantBoundaryConditionICVF32_SetConstant(self, c)

    def GetConstant(self):
        r"""GetConstant(self) -> itkCovariantVectorF3"""
        return _itkImageBoundaryConditionPython.itkConstantBoundaryConditionICVF32_GetConstant(self)

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

        Parameters
        ----------
        arg0: itkConstantBoundaryConditionICVF32 const &

        """
        _itkImageBoundaryConditionPython.itkConstantBoundaryConditionICVF32_swiginit(self, _itkImageBoundaryConditionPython.new_itkConstantBoundaryConditionICVF32(*args))
    __swig_destroy__ = _itkImageBoundaryConditionPython.delete_itkConstantBoundaryConditionICVF32

# Register itkConstantBoundaryConditionICVF32 in _itkImageBoundaryConditionPython:
_itkImageBoundaryConditionPython.itkConstantBoundaryConditionICVF32_swigregister(itkConstantBoundaryConditionICVF32)
class itkConstantBoundaryConditionICVF33(itkImageBoundaryConditionICVF33):
    r"""Proxy of C++ itkConstantBoundaryConditionICVF33 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, i=0):
        r"""
        Print(self, os, i=0)

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

        """
        return _itkImageBoundaryConditionPython.itkConstantBoundaryConditionICVF33_Print(self, os, i)

    def __call__(self, *args):
        r"""
        __call__(self, arg0, arg1, arg2) -> itkCovariantVectorF3

        Parameters
        ----------
        arg0: itkOffset3 const &
        arg1: itkOffset3 const &
        arg2: itk::Neighborhood< itk::CovariantVector< float > *,3 > const *

        __call__(self, arg0, arg1, arg2, arg3) -> itkCovariantVectorF3

        Parameters
        ----------
        arg0: itkOffset3 const &
        arg1: itkOffset3 const &
        arg2: itk::Neighborhood< itk::CovariantVector< float > *,3 > const *
        arg3: itk::NeighborhoodAccessorFunctor< itk::Image< itk::CovariantVector< float >,3 > > const &

        """
        return _itkImageBoundaryConditionPython.itkConstantBoundaryConditionICVF33___call__(self, *args)

    def SetConstant(self, c):
        r"""
        SetConstant(self, c)

        Parameters
        ----------
        c: itkCovariantVectorF3 const &

        """
        return _itkImageBoundaryConditionPython.itkConstantBoundaryConditionICVF33_SetConstant(self, c)

    def GetConstant(self):
        r"""GetConstant(self) -> itkCovariantVectorF3"""
        return _itkImageBoundaryConditionPython.itkConstantBoundaryConditionICVF33_GetConstant(self)

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

        Parameters
        ----------
        arg0: itkConstantBoundaryConditionICVF33 const &

        """
        _itkImageBoundaryConditionPython.itkConstantBoundaryConditionICVF33_swiginit(self, _itkImageBoundaryConditionPython.new_itkConstantBoundaryConditionICVF33(*args))
    __swig_destroy__ = _itkImageBoundaryConditionPython.delete_itkConstantBoundaryConditionICVF33

# Register itkConstantBoundaryConditionICVF33 in _itkImageBoundaryConditionPython:
_itkImageBoundaryConditionPython.itkConstantBoundaryConditionICVF33_swigregister(itkConstantBoundaryConditionICVF33)
class itkConstantBoundaryConditionICVF42(itkImageBoundaryConditionICVF42):
    r"""Proxy of C++ itkConstantBoundaryConditionICVF42 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, i=0):
        r"""
        Print(self, os, i=0)

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

        """
        return _itkImageBoundaryConditionPython.itkConstantBoundaryConditionICVF42_Print(self, os, i)

    def __call__(self, *args):
        r"""
        __call__(self, arg0, arg1, arg2) -> itkCovariantVectorF4

        Parameters
        ----------
        arg0: itkOffset2 const &
        arg1: itkOffset2 const &
        arg2: itk::Neighborhood< itk::CovariantVector< float,4 > * > const *

        __call__(self, arg0, arg1, arg2, arg3) -> itkCovariantVectorF4

        Parameters
        ----------
        arg0: itkOffset2 const &
        arg1: itkOffset2 const &
        arg2: itk::Neighborhood< itk::CovariantVector< float,4 > * > const *
        arg3: itk::NeighborhoodAccessorFunctor< itk::Image< itk::CovariantVector< float,4 > > > const &

        """
        return _itkImageBoundaryConditionPython.itkConstantBoundaryConditionICVF42___call__(self, *args)

    def SetConstant(self, c):
        r"""
        SetConstant(self, c)

        Parameters
        ----------
        c: itkCovariantVectorF4 const &

        """
        return _itkImageBoundaryConditionPython.itkConstantBoundaryConditionICVF42_SetConstant(self, c)

    def GetConstant(self):
        r"""GetConstant(self) -> itkCovariantVectorF4"""
        return _itkImageBoundaryConditionPython.itkConstantBoundaryConditionICVF42_GetConstant(self)

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

        Parameters
        ----------
        arg0: itkConstantBoundaryConditionICVF42 const &

        """
        _itkImageBoundaryConditionPython.itkConstantBoundaryConditionICVF42_swiginit(self, _itkImageBoundaryConditionPython.new_itkConstantBoundaryConditionICVF42(*args))
    __swig_destroy__ = _itkImageBoundaryConditionPython.delete_itkConstantBoundaryConditionICVF42

# Register itkConstantBoundaryConditionICVF42 in _itkImageBoundaryConditionPython:
_itkImageBoundaryConditionPython.itkConstantBoundaryConditionICVF42_swigregister(itkConstantBoundaryConditionICVF42)
class itkConstantBoundaryConditionICVF43(itkImageBoundaryConditionICVF43):
    r"""Proxy of C++ itkConstantBoundaryConditionICVF43 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, i=0):
        r"""
        Print(self, os, i=0)

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

        """
        return _itkImageBoundaryConditionPython.itkConstantBoundaryConditionICVF43_Print(self, os, i)

    def __call__(self, *args):
        r"""
        __call__(self, arg0, arg1, arg2) -> itkCovariantVectorF4

        Parameters
        ----------
        arg0: itkOffset3 const &
        arg1: itkOffset3 const &
        arg2: itk::Neighborhood< itk::CovariantVector< float,4 > *,3 > const *

        __call__(self, arg0, arg1, arg2, arg3) -> itkCovariantVectorF4

        Parameters
        ----------
        arg0: itkOffset3 const &
        arg1: itkOffset3 const &
        arg2: itk::Neighborhood< itk::CovariantVector< float,4 > *,3 > const *
        arg3: itk::NeighborhoodAccessorFunctor< itk::Image< itk::CovariantVector< float,4 >,3 > > const &

        """
        return _itkImageBoundaryConditionPython.itkConstantBoundaryConditionICVF43___call__(self, *args)

    def SetConstant(self, c):
        r"""
        SetConstant(self, c)

        Parameters
        ----------
        c: itkCovariantVectorF4 const &

        """
        return _itkImageBoundaryConditionPython.itkConstantBoundaryConditionICVF43_SetConstant(self, c)

    def GetConstant(self):
        r"""GetConstant(self) -> itkCovariantVectorF4"""
        return _itkImageBoundaryConditionPython.itkConstantBoundaryConditionICVF43_GetConstant(self)

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

        Parameters
        ----------
        arg0: itkConstantBoundaryConditionICVF43 const &

        """
        _itkImageBoundaryConditionPython.itkConstantBoundaryConditionICVF43_swiginit(self, _itkImageBoundaryConditionPython.new_itkConstantBoundaryConditionICVF43(*args))
    __swig_destroy__ = _itkImageBoundaryConditionPython.delete_itkConstantBoundaryConditionICVF43

# Register itkConstantBoundaryConditionICVF43 in _itkImageBoundaryConditionPython:
_itkImageBoundaryConditionPython.itkConstantBoundaryConditionICVF43_swigregister(itkConstantBoundaryConditionICVF43)
class itkConstantBoundaryConditionIF2(itkImageBoundaryConditionIF2):
    r"""Proxy of C++ itkConstantBoundaryConditionIF2 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, i=0):
        r"""
        Print(self, os, i=0)

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

        """
        return _itkImageBoundaryConditionPython.itkConstantBoundaryConditionIF2_Print(self, os, i)

    def __call__(self, *args):
        r"""
        __call__(self, arg0, arg1, arg2) -> float

        Parameters
        ----------
        arg0: itkOffset2 const &
        arg1: itkOffset2 const &
        arg2: itk::Neighborhood< float * > const *

        __call__(self, arg0, arg1, arg2, arg3) -> float

        Parameters
        ----------
        arg0: itkOffset2 const &
        arg1: itkOffset2 const &
        arg2: itk::Neighborhood< float * > const *
        arg3: itk::NeighborhoodAccessorFunctor< itk::Image< float > > const &

        """
        return _itkImageBoundaryConditionPython.itkConstantBoundaryConditionIF2___call__(self, *args)

    def SetConstant(self, c):
        r"""
        SetConstant(self, c)

        Parameters
        ----------
        c: float const &

        """
        return _itkImageBoundaryConditionPython.itkConstantBoundaryConditionIF2_SetConstant(self, c)

    def GetConstant(self):
        r"""GetConstant(self) -> float const &"""
        return _itkImageBoundaryConditionPython.itkConstantBoundaryConditionIF2_GetConstant(self)

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

        Parameters
        ----------
        arg0: itkConstantBoundaryConditionIF2 const &

        """
        _itkImageBoundaryConditionPython.itkConstantBoundaryConditionIF2_swiginit(self, _itkImageBoundaryConditionPython.new_itkConstantBoundaryConditionIF2(*args))
    __swig_destroy__ = _itkImageBoundaryConditionPython.delete_itkConstantBoundaryConditionIF2

# Register itkConstantBoundaryConditionIF2 in _itkImageBoundaryConditionPython:
_itkImageBoundaryConditionPython.itkConstantBoundaryConditionIF2_swigregister(itkConstantBoundaryConditionIF2)
class itkConstantBoundaryConditionIF3(itkImageBoundaryConditionIF3):
    r"""Proxy of C++ itkConstantBoundaryConditionIF3 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, i=0):
        r"""
        Print(self, os, i=0)

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

        """
        return _itkImageBoundaryConditionPython.itkConstantBoundaryConditionIF3_Print(self, os, i)

    def __call__(self, *args):
        r"""
        __call__(self, arg0, arg1, arg2) -> float

        Parameters
        ----------
        arg0: itkOffset3 const &
        arg1: itkOffset3 const &
        arg2: itk::Neighborhood< float *,3 > const *

        __call__(self, arg0, arg1, arg2, arg3) -> float

        Parameters
        ----------
        arg0: itkOffset3 const &
        arg1: itkOffset3 const &
        arg2: itk::Neighborhood< float *,3 > const *
        arg3: itk::NeighborhoodAccessorFunctor< itk::Image< float,3 > > const &

        """
        return _itkImageBoundaryConditionPython.itkConstantBoundaryConditionIF3___call__(self, *args)

    def SetConstant(self, c):
        r"""
        SetConstant(self, c)

        Parameters
        ----------
        c: float const &

        """
        return _itkImageBoundaryConditionPython.itkConstantBoundaryConditionIF3_SetConstant(self, c)

    def GetConstant(self):
        r"""GetConstant(self) -> float const &"""
        return _itkImageBoundaryConditionPython.itkConstantBoundaryConditionIF3_GetConstant(self)

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

        Parameters
        ----------
        arg0: itkConstantBoundaryConditionIF3 const &

        """
        _itkImageBoundaryConditionPython.itkConstantBoundaryConditionIF3_swiginit(self, _itkImageBoundaryConditionPython.new_itkConstantBoundaryConditionIF3(*args))
    __swig_destroy__ = _itkImageBoundaryConditionPython.delete_itkConstantBoundaryConditionIF3

# Register itkConstantBoundaryConditionIF3 in _itkImageBoundaryConditionPython:
_itkImageBoundaryConditionPython.itkConstantBoundaryConditionIF3_swigregister(itkConstantBoundaryConditionIF3)
class itkConstantBoundaryConditionIRGBAUC2(itkImageBoundaryConditionIRGBAUC2):
    r"""Proxy of C++ itkConstantBoundaryConditionIRGBAUC2 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, i=0):
        r"""
        Print(self, os, i=0)

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

        """
        return _itkImageBoundaryConditionPython.itkConstantBoundaryConditionIRGBAUC2_Print(self, os, i)

    def __call__(self, *args):
        r"""
        __call__(self, arg0, arg1, arg2) -> itkRGBAPixelUC

        Parameters
        ----------
        arg0: itkOffset2 const &
        arg1: itkOffset2 const &
        arg2: itk::Neighborhood< itk::RGBAPixel< unsigned char > * > const *

        __call__(self, arg0, arg1, arg2, arg3) -> itkRGBAPixelUC

        Parameters
        ----------
        arg0: itkOffset2 const &
        arg1: itkOffset2 const &
        arg2: itk::Neighborhood< itk::RGBAPixel< unsigned char > * > const *
        arg3: itk::NeighborhoodAccessorFunctor< itk::Image< itk::RGBAPixel< unsigned char > > > const &

        """
        return _itkImageBoundaryConditionPython.itkConstantBoundaryConditionIRGBAUC2___call__(self, *args)

    def SetConstant(self, c):
        r"""
        SetConstant(self, c)

        Parameters
        ----------
        c: itkRGBAPixelUC const &

        """
        return _itkImageBoundaryConditionPython.itkConstantBoundaryConditionIRGBAUC2_SetConstant(self, c)

    def GetConstant(self):
        r"""GetConstant(self) -> itkRGBAPixelUC"""
        return _itkImageBoundaryConditionPython.itkConstantBoundaryConditionIRGBAUC2_GetConstant(self)

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

        Parameters
        ----------
        arg0: itkConstantBoundaryConditionIRGBAUC2 const &

        """
        _itkImageBoundaryConditionPython.itkConstantBoundaryConditionIRGBAUC2_swiginit(self, _itkImageBoundaryConditionPython.new_itkConstantBoundaryConditionIRGBAUC2(*args))
    __swig_destroy__ = _itkImageBoundaryConditionPython.delete_itkConstantBoundaryConditionIRGBAUC2

# Register itkConstantBoundaryConditionIRGBAUC2 in _itkImageBoundaryConditionPython:
_itkImageBoundaryConditionPython.itkConstantBoundaryConditionIRGBAUC2_swigregister(itkConstantBoundaryConditionIRGBAUC2)
class itkConstantBoundaryConditionIRGBAUC3(itkImageBoundaryConditionIRGBAUC3):
    r"""Proxy of C++ itkConstantBoundaryConditionIRGBAUC3 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, i=0):
        r"""
        Print(self, os, i=0)

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

        """
        return _itkImageBoundaryConditionPython.itkConstantBoundaryConditionIRGBAUC3_Print(self, os, i)

    def __call__(self, *args):
        r"""
        __call__(self, arg0, arg1, arg2) -> itkRGBAPixelUC

        Parameters
        ----------
        arg0: itkOffset3 const &
        arg1: itkOffset3 const &
        arg2: itk::Neighborhood< itk::RGBAPixel< unsigned char > *,3 > const *

        __call__(self, arg0, arg1, arg2, arg3) -> itkRGBAPixelUC

        Parameters
        ----------
        arg0: itkOffset3 const &
        arg1: itkOffset3 const &
        arg2: itk::Neighborhood< itk::RGBAPixel< unsigned char > *,3 > const *
        arg3: itk::NeighborhoodAccessorFunctor< itk::Image< itk::RGBAPixel< unsigned char >,3 > > const &

        """
        return _itkImageBoundaryConditionPython.itkConstantBoundaryConditionIRGBAUC3___call__(self, *args)

    def SetConstant(self, c):
        r"""
        SetConstant(self, c)

        Parameters
        ----------
        c: itkRGBAPixelUC const &

        """
        return _itkImageBoundaryConditionPython.itkConstantBoundaryConditionIRGBAUC3_SetConstant(self, c)

    def GetConstant(self):
        r"""GetConstant(self) -> itkRGBAPixelUC"""
        return _itkImageBoundaryConditionPython.itkConstantBoundaryConditionIRGBAUC3_GetConstant(self)

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

        Parameters
        ----------
        arg0: itkConstantBoundaryConditionIRGBAUC3 const &

        """
        _itkImageBoundaryConditionPython.itkConstantBoundaryConditionIRGBAUC3_swiginit(self, _itkImageBoundaryConditionPython.new_itkConstantBoundaryConditionIRGBAUC3(*args))
    __swig_destroy__ = _itkImageBoundaryConditionPython.delete_itkConstantBoundaryConditionIRGBAUC3

# Register itkConstantBoundaryConditionIRGBAUC3 in _itkImageBoundaryConditionPython:
_itkImageBoundaryConditionPython.itkConstantBoundaryConditionIRGBAUC3_swigregister(itkConstantBoundaryConditionIRGBAUC3)
class itkConstantBoundaryConditionIRGBUC2(itkImageBoundaryConditionIRGBUC2):
    r"""Proxy of C++ itkConstantBoundaryConditionIRGBUC2 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, i=0):
        r"""
        Print(self, os, i=0)

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

        """
        return _itkImageBoundaryConditionPython.itkConstantBoundaryConditionIRGBUC2_Print(self, os, i)

    def __call__(self, *args):
        r"""
        __call__(self, arg0, arg1, arg2) -> itkRGBPixelUC

        Parameters
        ----------
        arg0: itkOffset2 const &
        arg1: itkOffset2 const &
        arg2: itk::Neighborhood< itk::RGBPixel< unsigned char > * > const *

        __call__(self, arg0, arg1, arg2, arg3) -> itkRGBPixelUC

        Parameters
        ----------
        arg0: itkOffset2 const &
        arg1: itkOffset2 const &
        arg2: itk::Neighborhood< itk::RGBPixel< unsigned char > * > const *
        arg3: itk::NeighborhoodAccessorFunctor< itk::Image< itk::RGBPixel< unsigned char > > > const &

        """
        return _itkImageBoundaryConditionPython.itkConstantBoundaryConditionIRGBUC2___call__(self, *args)

    def SetConstant(self, c):
        r"""
        SetConstant(self, c)

        Parameters
        ----------
        c: itkRGBPixelUC const &

        """
        return _itkImageBoundaryConditionPython.itkConstantBoundaryConditionIRGBUC2_SetConstant(self, c)

    def GetConstant(self):
        r"""GetConstant(self) -> itkRGBPixelUC"""
        return _itkImageBoundaryConditionPython.itkConstantBoundaryConditionIRGBUC2_GetConstant(self)

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

        Parameters
        ----------
        arg0: itkConstantBoundaryConditionIRGBUC2 const &

        """
        _itkImageBoundaryConditionPython.itkConstantBoundaryConditionIRGBUC2_swiginit(self, _itkImageBoundaryConditionPython.new_itkConstantBoundaryConditionIRGBUC2(*args))
    __swig_destroy__ = _itkImageBoundaryConditionPython.delete_itkConstantBoundaryConditionIRGBUC2

# Register itkConstantBoundaryConditionIRGBUC2 in _itkImageBoundaryConditionPython:
_itkImageBoundaryConditionPython.itkConstantBoundaryConditionIRGBUC2_swigregister(itkConstantBoundaryConditionIRGBUC2)
class itkConstantBoundaryConditionIRGBUC3(itkImageBoundaryConditionIRGBUC3):
    r"""Proxy of C++ itkConstantBoundaryConditionIRGBUC3 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, i=0):
        r"""
        Print(self, os, i=0)

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

        """
        return _itkImageBoundaryConditionPython.itkConstantBoundaryConditionIRGBUC3_Print(self, os, i)

    def __call__(self, *args):
        r"""
        __call__(self, arg0, arg1, arg2) -> itkRGBPixelUC

        Parameters
        ----------
        arg0: itkOffset3 const &
        arg1: itkOffset3 const &
        arg2: itk::Neighborhood< itk::RGBPixel< unsigned char > *,3 > const *

        __call__(self, arg0, arg1, arg2, arg3) -> itkRGBPixelUC

        Parameters
        ----------
        arg0: itkOffset3 const &
        arg1: itkOffset3 const &
        arg2: itk::Neighborhood< itk::RGBPixel< unsigned char > *,3 > const *
        arg3: itk::NeighborhoodAccessorFunctor< itk::Image< itk::RGBPixel< unsigned char >,3 > > const &

        """
        return _itkImageBoundaryConditionPython.itkConstantBoundaryConditionIRGBUC3___call__(self, *args)

    def SetConstant(self, c):
        r"""
        SetConstant(self, c)

        Parameters
        ----------
        c: itkRGBPixelUC const &

        """
        return _itkImageBoundaryConditionPython.itkConstantBoundaryConditionIRGBUC3_SetConstant(self, c)

    def GetConstant(self):
        r"""GetConstant(self) -> itkRGBPixelUC"""
        return _itkImageBoundaryConditionPython.itkConstantBoundaryConditionIRGBUC3_GetConstant(self)

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

        Parameters
        ----------
        arg0: itkConstantBoundaryConditionIRGBUC3 const &

        """
        _itkImageBoundaryConditionPython.itkConstantBoundaryConditionIRGBUC3_swiginit(self, _itkImageBoundaryConditionPython.new_itkConstantBoundaryConditionIRGBUC3(*args))
    __swig_destroy__ = _itkImageBoundaryConditionPython.delete_itkConstantBoundaryConditionIRGBUC3

# Register itkConstantBoundaryConditionIRGBUC3 in _itkImageBoundaryConditionPython:
_itkImageBoundaryConditionPython.itkConstantBoundaryConditionIRGBUC3_swigregister(itkConstantBoundaryConditionIRGBUC3)
class itkConstantBoundaryConditionISS2(itkImageBoundaryConditionISS2):
    r"""Proxy of C++ itkConstantBoundaryConditionISS2 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, i=0):
        r"""
        Print(self, os, i=0)

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

        """
        return _itkImageBoundaryConditionPython.itkConstantBoundaryConditionISS2_Print(self, os, i)

    def __call__(self, *args):
        r"""
        __call__(self, arg0, arg1, arg2) -> short

        Parameters
        ----------
        arg0: itkOffset2 const &
        arg1: itkOffset2 const &
        arg2: itk::Neighborhood< short * > const *

        __call__(self, arg0, arg1, arg2, arg3) -> short

        Parameters
        ----------
        arg0: itkOffset2 const &
        arg1: itkOffset2 const &
        arg2: itk::Neighborhood< short * > const *
        arg3: itk::NeighborhoodAccessorFunctor< itk::Image< short > > const &

        """
        return _itkImageBoundaryConditionPython.itkConstantBoundaryConditionISS2___call__(self, *args)

    def SetConstant(self, c):
        r"""
        SetConstant(self, c)

        Parameters
        ----------
        c: short const &

        """
        return _itkImageBoundaryConditionPython.itkConstantBoundaryConditionISS2_SetConstant(self, c)

    def GetConstant(self):
        r"""GetConstant(self) -> short const &"""
        return _itkImageBoundaryConditionPython.itkConstantBoundaryConditionISS2_GetConstant(self)

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

        Parameters
        ----------
        arg0: itkConstantBoundaryConditionISS2 const &

        """
        _itkImageBoundaryConditionPython.itkConstantBoundaryConditionISS2_swiginit(self, _itkImageBoundaryConditionPython.new_itkConstantBoundaryConditionISS2(*args))
    __swig_destroy__ = _itkImageBoundaryConditionPython.delete_itkConstantBoundaryConditionISS2

# Register itkConstantBoundaryConditionISS2 in _itkImageBoundaryConditionPython:
_itkImageBoundaryConditionPython.itkConstantBoundaryConditionISS2_swigregister(itkConstantBoundaryConditionISS2)
class itkConstantBoundaryConditionISS3(itkImageBoundaryConditionISS3):
    r"""Proxy of C++ itkConstantBoundaryConditionISS3 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, i=0):
        r"""
        Print(self, os, i=0)

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

        """
        return _itkImageBoundaryConditionPython.itkConstantBoundaryConditionISS3_Print(self, os, i)

    def __call__(self, *args):
        r"""
        __call__(self, arg0, arg1, arg2) -> short

        Parameters
        ----------
        arg0: itkOffset3 const &
        arg1: itkOffset3 const &
        arg2: itk::Neighborhood< short *,3 > const *

        __call__(self, arg0, arg1, arg2, arg3) -> short

        Parameters
        ----------
        arg0: itkOffset3 const &
        arg1: itkOffset3 const &
        arg2: itk::Neighborhood< short *,3 > const *
        arg3: itk::NeighborhoodAccessorFunctor< itk::Image< short,3 > > const &

        """
        return _itkImageBoundaryConditionPython.itkConstantBoundaryConditionISS3___call__(self, *args)

    def SetConstant(self, c):
        r"""
        SetConstant(self, c)

        Parameters
        ----------
        c: short const &

        """
        return _itkImageBoundaryConditionPython.itkConstantBoundaryConditionISS3_SetConstant(self, c)

    def GetConstant(self):
        r"""GetConstant(self) -> short const &"""
        return _itkImageBoundaryConditionPython.itkConstantBoundaryConditionISS3_GetConstant(self)

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

        Parameters
        ----------
        arg0: itkConstantBoundaryConditionISS3 const &

        """
        _itkImageBoundaryConditionPython.itkConstantBoundaryConditionISS3_swiginit(self, _itkImageBoundaryConditionPython.new_itkConstantBoundaryConditionISS3(*args))
    __swig_destroy__ = _itkImageBoundaryConditionPython.delete_itkConstantBoundaryConditionISS3

# Register itkConstantBoundaryConditionISS3 in _itkImageBoundaryConditionPython:
_itkImageBoundaryConditionPython.itkConstantBoundaryConditionISS3_swigregister(itkConstantBoundaryConditionISS3)
class itkConstantBoundaryConditionIUC2(itkImageBoundaryConditionIUC2):
    r"""Proxy of C++ itkConstantBoundaryConditionIUC2 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, i=0):
        r"""
        Print(self, os, i=0)

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

        """
        return _itkImageBoundaryConditionPython.itkConstantBoundaryConditionIUC2_Print(self, os, i)

    def __call__(self, *args):
        r"""
        __call__(self, arg0, arg1, arg2) -> unsigned char

        Parameters
        ----------
        arg0: itkOffset2 const &
        arg1: itkOffset2 const &
        arg2: itk::Neighborhood< unsigned char * > const *

        __call__(self, arg0, arg1, arg2, arg3) -> unsigned char

        Parameters
        ----------
        arg0: itkOffset2 const &
        arg1: itkOffset2 const &
        arg2: itk::Neighborhood< unsigned char * > const *
        arg3: itk::NeighborhoodAccessorFunctor< itk::Image< unsigned char > > const &

        """
        return _itkImageBoundaryConditionPython.itkConstantBoundaryConditionIUC2___call__(self, *args)

    def SetConstant(self, c):
        r"""
        SetConstant(self, c)

        Parameters
        ----------
        c: unsigned char const &

        """
        return _itkImageBoundaryConditionPython.itkConstantBoundaryConditionIUC2_SetConstant(self, c)

    def GetConstant(self):
        r"""GetConstant(self) -> unsigned char const &"""
        return _itkImageBoundaryConditionPython.itkConstantBoundaryConditionIUC2_GetConstant(self)

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

        Parameters
        ----------
        arg0: itkConstantBoundaryConditionIUC2 const &

        """
        _itkImageBoundaryConditionPython.itkConstantBoundaryConditionIUC2_swiginit(self, _itkImageBoundaryConditionPython.new_itkConstantBoundaryConditionIUC2(*args))
    __swig_destroy__ = _itkImageBoundaryConditionPython.delete_itkConstantBoundaryConditionIUC2

# Register itkConstantBoundaryConditionIUC2 in _itkImageBoundaryConditionPython:
_itkImageBoundaryConditionPython.itkConstantBoundaryConditionIUC2_swigregister(itkConstantBoundaryConditionIUC2)
class itkConstantBoundaryConditionIUC3(itkImageBoundaryConditionIUC3):
    r"""Proxy of C++ itkConstantBoundaryConditionIUC3 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, i=0):
        r"""
        Print(self, os, i=0)

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

        """
        return _itkImageBoundaryConditionPython.itkConstantBoundaryConditionIUC3_Print(self, os, i)

    def __call__(self, *args):
        r"""
        __call__(self, arg0, arg1, arg2) -> unsigned char

        Parameters
        ----------
        arg0: itkOffset3 const &
        arg1: itkOffset3 const &
        arg2: itk::Neighborhood< unsigned char *,3 > const *

        __call__(self, arg0, arg1, arg2, arg3) -> unsigned char

        Parameters
        ----------
        arg0: itkOffset3 const &
        arg1: itkOffset3 const &
        arg2: itk::Neighborhood< unsigned char *,3 > const *
        arg3: itk::NeighborhoodAccessorFunctor< itk::Image< unsigned char,3 > > const &

        """
        return _itkImageBoundaryConditionPython.itkConstantBoundaryConditionIUC3___call__(self, *args)

    def SetConstant(self, c):
        r"""
        SetConstant(self, c)

        Parameters
        ----------
        c: unsigned char const &

        """
        return _itkImageBoundaryConditionPython.itkConstantBoundaryConditionIUC3_SetConstant(self, c)

    def GetConstant(self):
        r"""GetConstant(self) -> unsigned char const &"""
        return _itkImageBoundaryConditionPython.itkConstantBoundaryConditionIUC3_GetConstant(self)

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

        Parameters
        ----------
        arg0: itkConstantBoundaryConditionIUC3 const &

        """
        _itkImageBoundaryConditionPython.itkConstantBoundaryConditionIUC3_swiginit(self, _itkImageBoundaryConditionPython.new_itkConstantBoundaryConditionIUC3(*args))
    __swig_destroy__ = _itkImageBoundaryConditionPython.delete_itkConstantBoundaryConditionIUC3

# Register itkConstantBoundaryConditionIUC3 in _itkImageBoundaryConditionPython:
_itkImageBoundaryConditionPython.itkConstantBoundaryConditionIUC3_swigregister(itkConstantBoundaryConditionIUC3)
class itkConstantBoundaryConditionIVF22(itkImageBoundaryConditionIVF22):
    r"""Proxy of C++ itkConstantBoundaryConditionIVF22 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, i=0):
        r"""
        Print(self, os, i=0)

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

        """
        return _itkImageBoundaryConditionPython.itkConstantBoundaryConditionIVF22_Print(self, os, i)

    def __call__(self, *args):
        r"""
        __call__(self, arg0, arg1, arg2) -> itkVectorF2

        Parameters
        ----------
        arg0: itkOffset2 const &
        arg1: itkOffset2 const &
        arg2: itk::Neighborhood< itk::Vector< float,2 > * > const *

        __call__(self, arg0, arg1, arg2, arg3) -> itkVectorF2

        Parameters
        ----------
        arg0: itkOffset2 const &
        arg1: itkOffset2 const &
        arg2: itk::Neighborhood< itk::Vector< float,2 > * > const *
        arg3: itk::NeighborhoodAccessorFunctor< itk::Image< itk::Vector< float,2 > > > const &

        """
        return _itkImageBoundaryConditionPython.itkConstantBoundaryConditionIVF22___call__(self, *args)

    def SetConstant(self, c):
        r"""
        SetConstant(self, c)

        Parameters
        ----------
        c: itkVectorF2 const &

        """
        return _itkImageBoundaryConditionPython.itkConstantBoundaryConditionIVF22_SetConstant(self, c)

    def GetConstant(self):
        r"""GetConstant(self) -> itkVectorF2"""
        return _itkImageBoundaryConditionPython.itkConstantBoundaryConditionIVF22_GetConstant(self)

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

        Parameters
        ----------
        arg0: itkConstantBoundaryConditionIVF22 const &

        """
        _itkImageBoundaryConditionPython.itkConstantBoundaryConditionIVF22_swiginit(self, _itkImageBoundaryConditionPython.new_itkConstantBoundaryConditionIVF22(*args))
    __swig_destroy__ = _itkImageBoundaryConditionPython.delete_itkConstantBoundaryConditionIVF22

# Register itkConstantBoundaryConditionIVF22 in _itkImageBoundaryConditionPython:
_itkImageBoundaryConditionPython.itkConstantBoundaryConditionIVF22_swigregister(itkConstantBoundaryConditionIVF22)
class itkConstantBoundaryConditionIVF23(itkImageBoundaryConditionIVF23):
    r"""Proxy of C++ itkConstantBoundaryConditionIVF23 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, i=0):
        r"""
        Print(self, os, i=0)

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

        """
        return _itkImageBoundaryConditionPython.itkConstantBoundaryConditionIVF23_Print(self, os, i)

    def __call__(self, *args):
        r"""
        __call__(self, arg0, arg1, arg2) -> itkVectorF2

        Parameters
        ----------
        arg0: itkOffset3 const &
        arg1: itkOffset3 const &
        arg2: itk::Neighborhood< itk::Vector< float,2 > *,3 > const *

        __call__(self, arg0, arg1, arg2, arg3) -> itkVectorF2

        Parameters
        ----------
        arg0: itkOffset3 const &
        arg1: itkOffset3 const &
        arg2: itk::Neighborhood< itk::Vector< float,2 > *,3 > const *
        arg3: itk::NeighborhoodAccessorFunctor< itk::Image< itk::Vector< float,2 >,3 > > const &

        """
        return _itkImageBoundaryConditionPython.itkConstantBoundaryConditionIVF23___call__(self, *args)

    def SetConstant(self, c):
        r"""
        SetConstant(self, c)

        Parameters
        ----------
        c: itkVectorF2 const &

        """
        return _itkImageBoundaryConditionPython.itkConstantBoundaryConditionIVF23_SetConstant(self, c)

    def GetConstant(self):
        r"""GetConstant(self) -> itkVectorF2"""
        return _itkImageBoundaryConditionPython.itkConstantBoundaryConditionIVF23_GetConstant(self)

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

        Parameters
        ----------
        arg0: itkConstantBoundaryConditionIVF23 const &

        """
        _itkImageBoundaryConditionPython.itkConstantBoundaryConditionIVF23_swiginit(self, _itkImageBoundaryConditionPython.new_itkConstantBoundaryConditionIVF23(*args))
    __swig_destroy__ = _itkImageBoundaryConditionPython.delete_itkConstantBoundaryConditionIVF23

# Register itkConstantBoundaryConditionIVF23 in _itkImageBoundaryConditionPython:
_itkImageBoundaryConditionPython.itkConstantBoundaryConditionIVF23_swigregister(itkConstantBoundaryConditionIVF23)
class itkConstantBoundaryConditionIVF32(itkImageBoundaryConditionIVF32):
    r"""Proxy of C++ itkConstantBoundaryConditionIVF32 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, i=0):
        r"""
        Print(self, os, i=0)

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

        """
        return _itkImageBoundaryConditionPython.itkConstantBoundaryConditionIVF32_Print(self, os, i)

    def __call__(self, *args):
        r"""
        __call__(self, arg0, arg1, arg2) -> itkVectorF3

        Parameters
        ----------
        arg0: itkOffset2 const &
        arg1: itkOffset2 const &
        arg2: itk::Neighborhood< itk::Vector< float > * > const *

        __call__(self, arg0, arg1, arg2, arg3) -> itkVectorF3

        Parameters
        ----------
        arg0: itkOffset2 const &
        arg1: itkOffset2 const &
        arg2: itk::Neighborhood< itk::Vector< float > * > const *
        arg3: itk::NeighborhoodAccessorFunctor< itk::Image< itk::Vector< float > > > const &

        """
        return _itkImageBoundaryConditionPython.itkConstantBoundaryConditionIVF32___call__(self, *args)

    def SetConstant(self, c):
        r"""
        SetConstant(self, c)

        Parameters
        ----------
        c: itkVectorF3 const &

        """
        return _itkImageBoundaryConditionPython.itkConstantBoundaryConditionIVF32_SetConstant(self, c)

    def GetConstant(self):
        r"""GetConstant(self) -> itkVectorF3"""
        return _itkImageBoundaryConditionPython.itkConstantBoundaryConditionIVF32_GetConstant(self)

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

        Parameters
        ----------
        arg0: itkConstantBoundaryConditionIVF32 const &

        """
        _itkImageBoundaryConditionPython.itkConstantBoundaryConditionIVF32_swiginit(self, _itkImageBoundaryConditionPython.new_itkConstantBoundaryConditionIVF32(*args))
    __swig_destroy__ = _itkImageBoundaryConditionPython.delete_itkConstantBoundaryConditionIVF32

# Register itkConstantBoundaryConditionIVF32 in _itkImageBoundaryConditionPython:
_itkImageBoundaryConditionPython.itkConstantBoundaryConditionIVF32_swigregister(itkConstantBoundaryConditionIVF32)
class itkConstantBoundaryConditionIVF33(itkImageBoundaryConditionIVF33):
    r"""Proxy of C++ itkConstantBoundaryConditionIVF33 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, i=0):
        r"""
        Print(self, os, i=0)

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

        """
        return _itkImageBoundaryConditionPython.itkConstantBoundaryConditionIVF33_Print(self, os, i)

    def __call__(self, *args):
        r"""
        __call__(self, arg0, arg1, arg2) -> itkVectorF3

        Parameters
        ----------
        arg0: itkOffset3 const &
        arg1: itkOffset3 const &
        arg2: itk::Neighborhood< itk::Vector< float > *,3 > const *

        __call__(self, arg0, arg1, arg2, arg3) -> itkVectorF3

        Parameters
        ----------
        arg0: itkOffset3 const &
        arg1: itkOffset3 const &
        arg2: itk::Neighborhood< itk::Vector< float > *,3 > const *
        arg3: itk::NeighborhoodAccessorFunctor< itk::Image< itk::Vector< float >,3 > > const &

        """
        return _itkImageBoundaryConditionPython.itkConstantBoundaryConditionIVF33___call__(self, *args)

    def SetConstant(self, c):
        r"""
        SetConstant(self, c)

        Parameters
        ----------
        c: itkVectorF3 const &

        """
        return _itkImageBoundaryConditionPython.itkConstantBoundaryConditionIVF33_SetConstant(self, c)

    def GetConstant(self):
        r"""GetConstant(self) -> itkVectorF3"""
        return _itkImageBoundaryConditionPython.itkConstantBoundaryConditionIVF33_GetConstant(self)

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

        Parameters
        ----------
        arg0: itkConstantBoundaryConditionIVF33 const &

        """
        _itkImageBoundaryConditionPython.itkConstantBoundaryConditionIVF33_swiginit(self, _itkImageBoundaryConditionPython.new_itkConstantBoundaryConditionIVF33(*args))
    __swig_destroy__ = _itkImageBoundaryConditionPython.delete_itkConstantBoundaryConditionIVF33

# Register itkConstantBoundaryConditionIVF33 in _itkImageBoundaryConditionPython:
_itkImageBoundaryConditionPython.itkConstantBoundaryConditionIVF33_swigregister(itkConstantBoundaryConditionIVF33)
class itkConstantBoundaryConditionIVF42(itkImageBoundaryConditionIVF42):
    r"""Proxy of C++ itkConstantBoundaryConditionIVF42 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, i=0):
        r"""
        Print(self, os, i=0)

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

        """
        return _itkImageBoundaryConditionPython.itkConstantBoundaryConditionIVF42_Print(self, os, i)

    def __call__(self, *args):
        r"""
        __call__(self, arg0, arg1, arg2) -> itkVectorF4

        Parameters
        ----------
        arg0: itkOffset2 const &
        arg1: itkOffset2 const &
        arg2: itk::Neighborhood< itk::Vector< float,4 > * > const *

        __call__(self, arg0, arg1, arg2, arg3) -> itkVectorF4

        Parameters
        ----------
        arg0: itkOffset2 const &
        arg1: itkOffset2 const &
        arg2: itk::Neighborhood< itk::Vector< float,4 > * > const *
        arg3: itk::NeighborhoodAccessorFunctor< itk::Image< itk::Vector< float,4 > > > const &

        """
        return _itkImageBoundaryConditionPython.itkConstantBoundaryConditionIVF42___call__(self, *args)

    def SetConstant(self, c):
        r"""
        SetConstant(self, c)

        Parameters
        ----------
        c: itkVectorF4 const &

        """
        return _itkImageBoundaryConditionPython.itkConstantBoundaryConditionIVF42_SetConstant(self, c)

    def GetConstant(self):
        r"""GetConstant(self) -> itkVectorF4"""
        return _itkImageBoundaryConditionPython.itkConstantBoundaryConditionIVF42_GetConstant(self)

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

        Parameters
        ----------
        arg0: itkConstantBoundaryConditionIVF42 const &

        """
        _itkImageBoundaryConditionPython.itkConstantBoundaryConditionIVF42_swiginit(self, _itkImageBoundaryConditionPython.new_itkConstantBoundaryConditionIVF42(*args))
    __swig_destroy__ = _itkImageBoundaryConditionPython.delete_itkConstantBoundaryConditionIVF42

# Register itkConstantBoundaryConditionIVF42 in _itkImageBoundaryConditionPython:
_itkImageBoundaryConditionPython.itkConstantBoundaryConditionIVF42_swigregister(itkConstantBoundaryConditionIVF42)
class itkConstantBoundaryConditionIVF43(itkImageBoundaryConditionIVF43):
    r"""Proxy of C++ itkConstantBoundaryConditionIVF43 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, i=0):
        r"""
        Print(self, os, i=0)

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

        """
        return _itkImageBoundaryConditionPython.itkConstantBoundaryConditionIVF43_Print(self, os, i)

    def __call__(self, *args):
        r"""
        __call__(self, arg0, arg1, arg2) -> itkVectorF4

        Parameters
        ----------
        arg0: itkOffset3 const &
        arg1: itkOffset3 const &
        arg2: itk::Neighborhood< itk::Vector< float,4 > *,3 > const *

        __call__(self, arg0, arg1, arg2, arg3) -> itkVectorF4

        Parameters
        ----------
        arg0: itkOffset3 const &
        arg1: itkOffset3 const &
        arg2: itk::Neighborhood< itk::Vector< float,4 > *,3 > const *
        arg3: itk::NeighborhoodAccessorFunctor< itk::Image< itk::Vector< float,4 >,3 > > const &

        """
        return _itkImageBoundaryConditionPython.itkConstantBoundaryConditionIVF43___call__(self, *args)

    def SetConstant(self, c):
        r"""
        SetConstant(self, c)

        Parameters
        ----------
        c: itkVectorF4 const &

        """
        return _itkImageBoundaryConditionPython.itkConstantBoundaryConditionIVF43_SetConstant(self, c)

    def GetConstant(self):
        r"""GetConstant(self) -> itkVectorF4"""
        return _itkImageBoundaryConditionPython.itkConstantBoundaryConditionIVF43_GetConstant(self)

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

        Parameters
        ----------
        arg0: itkConstantBoundaryConditionIVF43 const &

        """
        _itkImageBoundaryConditionPython.itkConstantBoundaryConditionIVF43_swiginit(self, _itkImageBoundaryConditionPython.new_itkConstantBoundaryConditionIVF43(*args))
    __swig_destroy__ = _itkImageBoundaryConditionPython.delete_itkConstantBoundaryConditionIVF43

# Register itkConstantBoundaryConditionIVF43 in _itkImageBoundaryConditionPython:
_itkImageBoundaryConditionPython.itkConstantBoundaryConditionIVF43_swigregister(itkConstantBoundaryConditionIVF43)

