# 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 _ITKImageFilterBasePython



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 _itkNeighborhoodOperatorImageFilterPython
else:
    import _itkNeighborhoodOperatorImageFilterPython

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.ITKCommonBasePython
import itk.itkMatrixPython
import itk.vnl_vectorPython
import itk.vnl_matrixPython
import itk.stdcomplexPython
import itk.pyBasePython
import itk.vnl_matrix_fixedPython
import itk.itkCovariantVectorPython
import itk.itkFixedArrayPython
import itk.vnl_vector_refPython
import itk.itkVectorPython
import itk.itkPointPython
import itk.itkImageRegionPython
import itk.itkSizePython
import itk.itkIndexPython
import itk.itkOffsetPython
import itk.itkNeighborhoodPython
import itk.itkRGBPixelPython
import itk.itkImagePython
import itk.itkRGBAPixelPython
import itk.itkSymmetricSecondRankTensorPython
import itk.itkImageToImageFilterAPython
import itk.itkVectorImagePython
import itk.itkVariableLengthVectorPython
import itk.itkImageToImageFilterCommonPython
import itk.itkImageSourcePython
import itk.itkImageSourceCommonPython
import itk.itkPhasedArray3DSpecialCoordinatesImagePython
class itkImageBoundaryConditionF2F2(object):
    r"""Proxy of C++ itkImageBoundaryConditionF2F2 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 _itkNeighborhoodOperatorImageFilterPython.itkImageBoundaryConditionF2F2_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 _itkNeighborhoodOperatorImageFilterPython.itkImageBoundaryConditionF2F2_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 _itkNeighborhoodOperatorImageFilterPython.itkImageBoundaryConditionF2F2___call__(self, *args)
    __swig_destroy__ = _itkNeighborhoodOperatorImageFilterPython.delete_itkImageBoundaryConditionF2F2

    def RequiresCompleteNeighborhood(self):
        r"""RequiresCompleteNeighborhood(self) -> bool"""
        return _itkNeighborhoodOperatorImageFilterPython.itkImageBoundaryConditionF2F2_RequiresCompleteNeighborhood(self)

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

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

        """
        return _itkNeighborhoodOperatorImageFilterPython.itkImageBoundaryConditionF2F2_GetInputRequestedRegion(self, inputLargestPossibleRegion, outputRequestedRegion)

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

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

        """
        return _itkNeighborhoodOperatorImageFilterPython.itkImageBoundaryConditionF2F2_GetPixel(self, index, image)

# Register itkImageBoundaryConditionF2F2 in _itkNeighborhoodOperatorImageFilterPython:
_itkNeighborhoodOperatorImageFilterPython.itkImageBoundaryConditionF2F2_swigregister(itkImageBoundaryConditionF2F2)
class itkImageBoundaryConditionF3F3(object):
    r"""Proxy of C++ itkImageBoundaryConditionF3F3 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 _itkNeighborhoodOperatorImageFilterPython.itkImageBoundaryConditionF3F3_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 _itkNeighborhoodOperatorImageFilterPython.itkImageBoundaryConditionF3F3_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 _itkNeighborhoodOperatorImageFilterPython.itkImageBoundaryConditionF3F3___call__(self, *args)
    __swig_destroy__ = _itkNeighborhoodOperatorImageFilterPython.delete_itkImageBoundaryConditionF3F3

    def RequiresCompleteNeighborhood(self):
        r"""RequiresCompleteNeighborhood(self) -> bool"""
        return _itkNeighborhoodOperatorImageFilterPython.itkImageBoundaryConditionF3F3_RequiresCompleteNeighborhood(self)

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

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

        """
        return _itkNeighborhoodOperatorImageFilterPython.itkImageBoundaryConditionF3F3_GetInputRequestedRegion(self, inputLargestPossibleRegion, outputRequestedRegion)

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

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

        """
        return _itkNeighborhoodOperatorImageFilterPython.itkImageBoundaryConditionF3F3_GetPixel(self, index, image)

# Register itkImageBoundaryConditionF3F3 in _itkNeighborhoodOperatorImageFilterPython:
_itkNeighborhoodOperatorImageFilterPython.itkImageBoundaryConditionF3F3_swigregister(itkImageBoundaryConditionF3F3)
class itkImageBoundaryConditionSS2SS2(object):
    r"""Proxy of C++ itkImageBoundaryConditionSS2SS2 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 _itkNeighborhoodOperatorImageFilterPython.itkImageBoundaryConditionSS2SS2_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 _itkNeighborhoodOperatorImageFilterPython.itkImageBoundaryConditionSS2SS2_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 _itkNeighborhoodOperatorImageFilterPython.itkImageBoundaryConditionSS2SS2___call__(self, *args)
    __swig_destroy__ = _itkNeighborhoodOperatorImageFilterPython.delete_itkImageBoundaryConditionSS2SS2

    def RequiresCompleteNeighborhood(self):
        r"""RequiresCompleteNeighborhood(self) -> bool"""
        return _itkNeighborhoodOperatorImageFilterPython.itkImageBoundaryConditionSS2SS2_RequiresCompleteNeighborhood(self)

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

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

        """
        return _itkNeighborhoodOperatorImageFilterPython.itkImageBoundaryConditionSS2SS2_GetInputRequestedRegion(self, inputLargestPossibleRegion, outputRequestedRegion)

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

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

        """
        return _itkNeighborhoodOperatorImageFilterPython.itkImageBoundaryConditionSS2SS2_GetPixel(self, index, image)

# Register itkImageBoundaryConditionSS2SS2 in _itkNeighborhoodOperatorImageFilterPython:
_itkNeighborhoodOperatorImageFilterPython.itkImageBoundaryConditionSS2SS2_swigregister(itkImageBoundaryConditionSS2SS2)
class itkImageBoundaryConditionSS3SS3(object):
    r"""Proxy of C++ itkImageBoundaryConditionSS3SS3 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 _itkNeighborhoodOperatorImageFilterPython.itkImageBoundaryConditionSS3SS3_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 _itkNeighborhoodOperatorImageFilterPython.itkImageBoundaryConditionSS3SS3_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 _itkNeighborhoodOperatorImageFilterPython.itkImageBoundaryConditionSS3SS3___call__(self, *args)
    __swig_destroy__ = _itkNeighborhoodOperatorImageFilterPython.delete_itkImageBoundaryConditionSS3SS3

    def RequiresCompleteNeighborhood(self):
        r"""RequiresCompleteNeighborhood(self) -> bool"""
        return _itkNeighborhoodOperatorImageFilterPython.itkImageBoundaryConditionSS3SS3_RequiresCompleteNeighborhood(self)

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

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

        """
        return _itkNeighborhoodOperatorImageFilterPython.itkImageBoundaryConditionSS3SS3_GetInputRequestedRegion(self, inputLargestPossibleRegion, outputRequestedRegion)

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

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

        """
        return _itkNeighborhoodOperatorImageFilterPython.itkImageBoundaryConditionSS3SS3_GetPixel(self, index, image)

# Register itkImageBoundaryConditionSS3SS3 in _itkNeighborhoodOperatorImageFilterPython:
_itkNeighborhoodOperatorImageFilterPython.itkImageBoundaryConditionSS3SS3_swigregister(itkImageBoundaryConditionSS3SS3)
class itkImageBoundaryConditionUC2UC2(object):
    r"""Proxy of C++ itkImageBoundaryConditionUC2UC2 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 _itkNeighborhoodOperatorImageFilterPython.itkImageBoundaryConditionUC2UC2_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 _itkNeighborhoodOperatorImageFilterPython.itkImageBoundaryConditionUC2UC2_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 _itkNeighborhoodOperatorImageFilterPython.itkImageBoundaryConditionUC2UC2___call__(self, *args)
    __swig_destroy__ = _itkNeighborhoodOperatorImageFilterPython.delete_itkImageBoundaryConditionUC2UC2

    def RequiresCompleteNeighborhood(self):
        r"""RequiresCompleteNeighborhood(self) -> bool"""
        return _itkNeighborhoodOperatorImageFilterPython.itkImageBoundaryConditionUC2UC2_RequiresCompleteNeighborhood(self)

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

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

        """
        return _itkNeighborhoodOperatorImageFilterPython.itkImageBoundaryConditionUC2UC2_GetInputRequestedRegion(self, inputLargestPossibleRegion, outputRequestedRegion)

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

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

        """
        return _itkNeighborhoodOperatorImageFilterPython.itkImageBoundaryConditionUC2UC2_GetPixel(self, index, image)

# Register itkImageBoundaryConditionUC2UC2 in _itkNeighborhoodOperatorImageFilterPython:
_itkNeighborhoodOperatorImageFilterPython.itkImageBoundaryConditionUC2UC2_swigregister(itkImageBoundaryConditionUC2UC2)
class itkImageBoundaryConditionUC3UC3(object):
    r"""Proxy of C++ itkImageBoundaryConditionUC3UC3 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 _itkNeighborhoodOperatorImageFilterPython.itkImageBoundaryConditionUC3UC3_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 _itkNeighborhoodOperatorImageFilterPython.itkImageBoundaryConditionUC3UC3_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 _itkNeighborhoodOperatorImageFilterPython.itkImageBoundaryConditionUC3UC3___call__(self, *args)
    __swig_destroy__ = _itkNeighborhoodOperatorImageFilterPython.delete_itkImageBoundaryConditionUC3UC3

    def RequiresCompleteNeighborhood(self):
        r"""RequiresCompleteNeighborhood(self) -> bool"""
        return _itkNeighborhoodOperatorImageFilterPython.itkImageBoundaryConditionUC3UC3_RequiresCompleteNeighborhood(self)

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

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

        """
        return _itkNeighborhoodOperatorImageFilterPython.itkImageBoundaryConditionUC3UC3_GetInputRequestedRegion(self, inputLargestPossibleRegion, outputRequestedRegion)

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

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

        """
        return _itkNeighborhoodOperatorImageFilterPython.itkImageBoundaryConditionUC3UC3_GetPixel(self, index, image)

# Register itkImageBoundaryConditionUC3UC3 in _itkNeighborhoodOperatorImageFilterPython:
_itkNeighborhoodOperatorImageFilterPython.itkImageBoundaryConditionUC3UC3_swigregister(itkImageBoundaryConditionUC3UC3)

def itkNeighborhoodOperatorImageFilterF2F2F_New():
    return itkNeighborhoodOperatorImageFilterF2F2F.New()

class itkNeighborhoodOperatorImageFilterF2F2F(itk.itkImageToImageFilterAPython.itkImageToImageFilterIF2IF2):
    r"""Proxy of C++ itkNeighborhoodOperatorImageFilterF2F2F class."""

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

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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkNeighborhoodOperatorImageFilterF2F2F_Pointer"""
        return _itkNeighborhoodOperatorImageFilterPython.itkNeighborhoodOperatorImageFilterF2F2F___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkNeighborhoodOperatorImageFilterF2F2F_Pointer"""
        return _itkNeighborhoodOperatorImageFilterPython.itkNeighborhoodOperatorImageFilterF2F2F_Clone(self)

    def SetOperator(self, p):
        r"""
        SetOperator(self, p)

        Parameters
        ----------
        p: itkNeighborhoodF2 const &

        """
        return _itkNeighborhoodOperatorImageFilterPython.itkNeighborhoodOperatorImageFilterF2F2F_SetOperator(self, p)

    def GetOperator(self):
        r"""GetOperator(self) -> itkNeighborhoodF2"""
        return _itkNeighborhoodOperatorImageFilterPython.itkNeighborhoodOperatorImageFilterF2F2F_GetOperator(self)

    def OverrideBoundaryCondition(self, i):
        r"""
        OverrideBoundaryCondition(self, i)

        Parameters
        ----------
        i: itkImageBoundaryConditionF2F2 *const

        """
        return _itkNeighborhoodOperatorImageFilterPython.itkNeighborhoodOperatorImageFilterF2F2F_OverrideBoundaryCondition(self, i)

    def GetBoundaryCondition(self):
        r"""GetBoundaryCondition(self) -> itkImageBoundaryConditionF2F2"""
        return _itkNeighborhoodOperatorImageFilterPython.itkNeighborhoodOperatorImageFilterF2F2F_GetBoundaryCondition(self)

    def GenerateInputRequestedRegion(self):
        r"""GenerateInputRequestedRegion(self)"""
        return _itkNeighborhoodOperatorImageFilterPython.itkNeighborhoodOperatorImageFilterF2F2F_GenerateInputRequestedRegion(self)
    SameDimensionCheck = _itkNeighborhoodOperatorImageFilterPython.itkNeighborhoodOperatorImageFilterF2F2F_SameDimensionCheck
    
    OperatorConvertibleToOutputCheck = _itkNeighborhoodOperatorImageFilterPython.itkNeighborhoodOperatorImageFilterF2F2F_OperatorConvertibleToOutputCheck
    
    InputConvertibleToOperatorCheck = _itkNeighborhoodOperatorImageFilterPython.itkNeighborhoodOperatorImageFilterF2F2F_InputConvertibleToOperatorCheck
    
    OperatorMultiplyOperatorCheck = _itkNeighborhoodOperatorImageFilterPython.itkNeighborhoodOperatorImageFilterF2F2F_OperatorMultiplyOperatorCheck
    
    OperatorAdditiveOperatorsCheck = _itkNeighborhoodOperatorImageFilterPython.itkNeighborhoodOperatorImageFilterF2F2F_OperatorAdditiveOperatorsCheck
    
    __swig_destroy__ = _itkNeighborhoodOperatorImageFilterPython.delete_itkNeighborhoodOperatorImageFilterF2F2F

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

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

        """
        return _itkNeighborhoodOperatorImageFilterPython.itkNeighborhoodOperatorImageFilterF2F2F_cast(obj)

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

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

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

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

        Ex:

          itkNeighborhoodOperatorImageFilterF2F2F.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkNeighborhoodOperatorImageFilterF2F2F in _itkNeighborhoodOperatorImageFilterPython:
_itkNeighborhoodOperatorImageFilterPython.itkNeighborhoodOperatorImageFilterF2F2F_swigregister(itkNeighborhoodOperatorImageFilterF2F2F)

def itkNeighborhoodOperatorImageFilterF3F3F_New():
    return itkNeighborhoodOperatorImageFilterF3F3F.New()

class itkNeighborhoodOperatorImageFilterF3F3F(itk.itkImageToImageFilterAPython.itkImageToImageFilterIF3IF3):
    r"""Proxy of C++ itkNeighborhoodOperatorImageFilterF3F3F class."""

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

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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkNeighborhoodOperatorImageFilterF3F3F_Pointer"""
        return _itkNeighborhoodOperatorImageFilterPython.itkNeighborhoodOperatorImageFilterF3F3F___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkNeighborhoodOperatorImageFilterF3F3F_Pointer"""
        return _itkNeighborhoodOperatorImageFilterPython.itkNeighborhoodOperatorImageFilterF3F3F_Clone(self)

    def SetOperator(self, p):
        r"""
        SetOperator(self, p)

        Parameters
        ----------
        p: itkNeighborhoodF3 const &

        """
        return _itkNeighborhoodOperatorImageFilterPython.itkNeighborhoodOperatorImageFilterF3F3F_SetOperator(self, p)

    def GetOperator(self):
        r"""GetOperator(self) -> itkNeighborhoodF3"""
        return _itkNeighborhoodOperatorImageFilterPython.itkNeighborhoodOperatorImageFilterF3F3F_GetOperator(self)

    def OverrideBoundaryCondition(self, i):
        r"""
        OverrideBoundaryCondition(self, i)

        Parameters
        ----------
        i: itkImageBoundaryConditionF3F3 *const

        """
        return _itkNeighborhoodOperatorImageFilterPython.itkNeighborhoodOperatorImageFilterF3F3F_OverrideBoundaryCondition(self, i)

    def GetBoundaryCondition(self):
        r"""GetBoundaryCondition(self) -> itkImageBoundaryConditionF3F3"""
        return _itkNeighborhoodOperatorImageFilterPython.itkNeighborhoodOperatorImageFilterF3F3F_GetBoundaryCondition(self)

    def GenerateInputRequestedRegion(self):
        r"""GenerateInputRequestedRegion(self)"""
        return _itkNeighborhoodOperatorImageFilterPython.itkNeighborhoodOperatorImageFilterF3F3F_GenerateInputRequestedRegion(self)
    SameDimensionCheck = _itkNeighborhoodOperatorImageFilterPython.itkNeighborhoodOperatorImageFilterF3F3F_SameDimensionCheck
    
    OperatorConvertibleToOutputCheck = _itkNeighborhoodOperatorImageFilterPython.itkNeighborhoodOperatorImageFilterF3F3F_OperatorConvertibleToOutputCheck
    
    InputConvertibleToOperatorCheck = _itkNeighborhoodOperatorImageFilterPython.itkNeighborhoodOperatorImageFilterF3F3F_InputConvertibleToOperatorCheck
    
    OperatorMultiplyOperatorCheck = _itkNeighborhoodOperatorImageFilterPython.itkNeighborhoodOperatorImageFilterF3F3F_OperatorMultiplyOperatorCheck
    
    OperatorAdditiveOperatorsCheck = _itkNeighborhoodOperatorImageFilterPython.itkNeighborhoodOperatorImageFilterF3F3F_OperatorAdditiveOperatorsCheck
    
    __swig_destroy__ = _itkNeighborhoodOperatorImageFilterPython.delete_itkNeighborhoodOperatorImageFilterF3F3F

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

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

        """
        return _itkNeighborhoodOperatorImageFilterPython.itkNeighborhoodOperatorImageFilterF3F3F_cast(obj)

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

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

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

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

        Ex:

          itkNeighborhoodOperatorImageFilterF3F3F.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkNeighborhoodOperatorImageFilterF3F3F in _itkNeighborhoodOperatorImageFilterPython:
_itkNeighborhoodOperatorImageFilterPython.itkNeighborhoodOperatorImageFilterF3F3F_swigregister(itkNeighborhoodOperatorImageFilterF3F3F)

def itkNeighborhoodOperatorImageFilterSS2SS2SS_New():
    return itkNeighborhoodOperatorImageFilterSS2SS2SS.New()

class itkNeighborhoodOperatorImageFilterSS2SS2SS(itk.itkImageToImageFilterAPython.itkImageToImageFilterISS2ISS2):
    r"""Proxy of C++ itkNeighborhoodOperatorImageFilterSS2SS2SS class."""

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

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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkNeighborhoodOperatorImageFilterSS2SS2SS_Pointer"""
        return _itkNeighborhoodOperatorImageFilterPython.itkNeighborhoodOperatorImageFilterSS2SS2SS___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkNeighborhoodOperatorImageFilterSS2SS2SS_Pointer"""
        return _itkNeighborhoodOperatorImageFilterPython.itkNeighborhoodOperatorImageFilterSS2SS2SS_Clone(self)

    def SetOperator(self, p):
        r"""
        SetOperator(self, p)

        Parameters
        ----------
        p: itkNeighborhoodSS2 const &

        """
        return _itkNeighborhoodOperatorImageFilterPython.itkNeighborhoodOperatorImageFilterSS2SS2SS_SetOperator(self, p)

    def GetOperator(self):
        r"""GetOperator(self) -> itkNeighborhoodSS2"""
        return _itkNeighborhoodOperatorImageFilterPython.itkNeighborhoodOperatorImageFilterSS2SS2SS_GetOperator(self)

    def OverrideBoundaryCondition(self, i):
        r"""
        OverrideBoundaryCondition(self, i)

        Parameters
        ----------
        i: itkImageBoundaryConditionSS2SS2 *const

        """
        return _itkNeighborhoodOperatorImageFilterPython.itkNeighborhoodOperatorImageFilterSS2SS2SS_OverrideBoundaryCondition(self, i)

    def GetBoundaryCondition(self):
        r"""GetBoundaryCondition(self) -> itkImageBoundaryConditionSS2SS2"""
        return _itkNeighborhoodOperatorImageFilterPython.itkNeighborhoodOperatorImageFilterSS2SS2SS_GetBoundaryCondition(self)

    def GenerateInputRequestedRegion(self):
        r"""GenerateInputRequestedRegion(self)"""
        return _itkNeighborhoodOperatorImageFilterPython.itkNeighborhoodOperatorImageFilterSS2SS2SS_GenerateInputRequestedRegion(self)
    SameDimensionCheck = _itkNeighborhoodOperatorImageFilterPython.itkNeighborhoodOperatorImageFilterSS2SS2SS_SameDimensionCheck
    
    OperatorConvertibleToOutputCheck = _itkNeighborhoodOperatorImageFilterPython.itkNeighborhoodOperatorImageFilterSS2SS2SS_OperatorConvertibleToOutputCheck
    
    InputConvertibleToOperatorCheck = _itkNeighborhoodOperatorImageFilterPython.itkNeighborhoodOperatorImageFilterSS2SS2SS_InputConvertibleToOperatorCheck
    
    OperatorMultiplyOperatorCheck = _itkNeighborhoodOperatorImageFilterPython.itkNeighborhoodOperatorImageFilterSS2SS2SS_OperatorMultiplyOperatorCheck
    
    OperatorAdditiveOperatorsCheck = _itkNeighborhoodOperatorImageFilterPython.itkNeighborhoodOperatorImageFilterSS2SS2SS_OperatorAdditiveOperatorsCheck
    
    __swig_destroy__ = _itkNeighborhoodOperatorImageFilterPython.delete_itkNeighborhoodOperatorImageFilterSS2SS2SS

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

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

        """
        return _itkNeighborhoodOperatorImageFilterPython.itkNeighborhoodOperatorImageFilterSS2SS2SS_cast(obj)

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

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

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

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

        Ex:

          itkNeighborhoodOperatorImageFilterSS2SS2SS.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkNeighborhoodOperatorImageFilterSS2SS2SS in _itkNeighborhoodOperatorImageFilterPython:
_itkNeighborhoodOperatorImageFilterPython.itkNeighborhoodOperatorImageFilterSS2SS2SS_swigregister(itkNeighborhoodOperatorImageFilterSS2SS2SS)

def itkNeighborhoodOperatorImageFilterSS3SS3SS_New():
    return itkNeighborhoodOperatorImageFilterSS3SS3SS.New()

class itkNeighborhoodOperatorImageFilterSS3SS3SS(itk.itkImageToImageFilterAPython.itkImageToImageFilterISS3ISS3):
    r"""Proxy of C++ itkNeighborhoodOperatorImageFilterSS3SS3SS class."""

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

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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkNeighborhoodOperatorImageFilterSS3SS3SS_Pointer"""
        return _itkNeighborhoodOperatorImageFilterPython.itkNeighborhoodOperatorImageFilterSS3SS3SS___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkNeighborhoodOperatorImageFilterSS3SS3SS_Pointer"""
        return _itkNeighborhoodOperatorImageFilterPython.itkNeighborhoodOperatorImageFilterSS3SS3SS_Clone(self)

    def SetOperator(self, p):
        r"""
        SetOperator(self, p)

        Parameters
        ----------
        p: itkNeighborhoodSS3 const &

        """
        return _itkNeighborhoodOperatorImageFilterPython.itkNeighborhoodOperatorImageFilterSS3SS3SS_SetOperator(self, p)

    def GetOperator(self):
        r"""GetOperator(self) -> itkNeighborhoodSS3"""
        return _itkNeighborhoodOperatorImageFilterPython.itkNeighborhoodOperatorImageFilterSS3SS3SS_GetOperator(self)

    def OverrideBoundaryCondition(self, i):
        r"""
        OverrideBoundaryCondition(self, i)

        Parameters
        ----------
        i: itkImageBoundaryConditionSS3SS3 *const

        """
        return _itkNeighborhoodOperatorImageFilterPython.itkNeighborhoodOperatorImageFilterSS3SS3SS_OverrideBoundaryCondition(self, i)

    def GetBoundaryCondition(self):
        r"""GetBoundaryCondition(self) -> itkImageBoundaryConditionSS3SS3"""
        return _itkNeighborhoodOperatorImageFilterPython.itkNeighborhoodOperatorImageFilterSS3SS3SS_GetBoundaryCondition(self)

    def GenerateInputRequestedRegion(self):
        r"""GenerateInputRequestedRegion(self)"""
        return _itkNeighborhoodOperatorImageFilterPython.itkNeighborhoodOperatorImageFilterSS3SS3SS_GenerateInputRequestedRegion(self)
    SameDimensionCheck = _itkNeighborhoodOperatorImageFilterPython.itkNeighborhoodOperatorImageFilterSS3SS3SS_SameDimensionCheck
    
    OperatorConvertibleToOutputCheck = _itkNeighborhoodOperatorImageFilterPython.itkNeighborhoodOperatorImageFilterSS3SS3SS_OperatorConvertibleToOutputCheck
    
    InputConvertibleToOperatorCheck = _itkNeighborhoodOperatorImageFilterPython.itkNeighborhoodOperatorImageFilterSS3SS3SS_InputConvertibleToOperatorCheck
    
    OperatorMultiplyOperatorCheck = _itkNeighborhoodOperatorImageFilterPython.itkNeighborhoodOperatorImageFilterSS3SS3SS_OperatorMultiplyOperatorCheck
    
    OperatorAdditiveOperatorsCheck = _itkNeighborhoodOperatorImageFilterPython.itkNeighborhoodOperatorImageFilterSS3SS3SS_OperatorAdditiveOperatorsCheck
    
    __swig_destroy__ = _itkNeighborhoodOperatorImageFilterPython.delete_itkNeighborhoodOperatorImageFilterSS3SS3SS

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

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

        """
        return _itkNeighborhoodOperatorImageFilterPython.itkNeighborhoodOperatorImageFilterSS3SS3SS_cast(obj)

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

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

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

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

        Ex:

          itkNeighborhoodOperatorImageFilterSS3SS3SS.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkNeighborhoodOperatorImageFilterSS3SS3SS in _itkNeighborhoodOperatorImageFilterPython:
_itkNeighborhoodOperatorImageFilterPython.itkNeighborhoodOperatorImageFilterSS3SS3SS_swigregister(itkNeighborhoodOperatorImageFilterSS3SS3SS)

def itkNeighborhoodOperatorImageFilterUC2UC2UC_New():
    return itkNeighborhoodOperatorImageFilterUC2UC2UC.New()

class itkNeighborhoodOperatorImageFilterUC2UC2UC(itk.itkImageToImageFilterAPython.itkImageToImageFilterIUC2IUC2):
    r"""Proxy of C++ itkNeighborhoodOperatorImageFilterUC2UC2UC class."""

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

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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkNeighborhoodOperatorImageFilterUC2UC2UC_Pointer"""
        return _itkNeighborhoodOperatorImageFilterPython.itkNeighborhoodOperatorImageFilterUC2UC2UC___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkNeighborhoodOperatorImageFilterUC2UC2UC_Pointer"""
        return _itkNeighborhoodOperatorImageFilterPython.itkNeighborhoodOperatorImageFilterUC2UC2UC_Clone(self)

    def SetOperator(self, p):
        r"""
        SetOperator(self, p)

        Parameters
        ----------
        p: itkNeighborhoodUC2 const &

        """
        return _itkNeighborhoodOperatorImageFilterPython.itkNeighborhoodOperatorImageFilterUC2UC2UC_SetOperator(self, p)

    def GetOperator(self):
        r"""GetOperator(self) -> itkNeighborhoodUC2"""
        return _itkNeighborhoodOperatorImageFilterPython.itkNeighborhoodOperatorImageFilterUC2UC2UC_GetOperator(self)

    def OverrideBoundaryCondition(self, i):
        r"""
        OverrideBoundaryCondition(self, i)

        Parameters
        ----------
        i: itkImageBoundaryConditionUC2UC2 *const

        """
        return _itkNeighborhoodOperatorImageFilterPython.itkNeighborhoodOperatorImageFilterUC2UC2UC_OverrideBoundaryCondition(self, i)

    def GetBoundaryCondition(self):
        r"""GetBoundaryCondition(self) -> itkImageBoundaryConditionUC2UC2"""
        return _itkNeighborhoodOperatorImageFilterPython.itkNeighborhoodOperatorImageFilterUC2UC2UC_GetBoundaryCondition(self)

    def GenerateInputRequestedRegion(self):
        r"""GenerateInputRequestedRegion(self)"""
        return _itkNeighborhoodOperatorImageFilterPython.itkNeighborhoodOperatorImageFilterUC2UC2UC_GenerateInputRequestedRegion(self)
    SameDimensionCheck = _itkNeighborhoodOperatorImageFilterPython.itkNeighborhoodOperatorImageFilterUC2UC2UC_SameDimensionCheck
    
    OperatorConvertibleToOutputCheck = _itkNeighborhoodOperatorImageFilterPython.itkNeighborhoodOperatorImageFilterUC2UC2UC_OperatorConvertibleToOutputCheck
    
    InputConvertibleToOperatorCheck = _itkNeighborhoodOperatorImageFilterPython.itkNeighborhoodOperatorImageFilterUC2UC2UC_InputConvertibleToOperatorCheck
    
    OperatorMultiplyOperatorCheck = _itkNeighborhoodOperatorImageFilterPython.itkNeighborhoodOperatorImageFilterUC2UC2UC_OperatorMultiplyOperatorCheck
    
    OperatorAdditiveOperatorsCheck = _itkNeighborhoodOperatorImageFilterPython.itkNeighborhoodOperatorImageFilterUC2UC2UC_OperatorAdditiveOperatorsCheck
    
    __swig_destroy__ = _itkNeighborhoodOperatorImageFilterPython.delete_itkNeighborhoodOperatorImageFilterUC2UC2UC

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

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

        """
        return _itkNeighborhoodOperatorImageFilterPython.itkNeighborhoodOperatorImageFilterUC2UC2UC_cast(obj)

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

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

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

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

        Ex:

          itkNeighborhoodOperatorImageFilterUC2UC2UC.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkNeighborhoodOperatorImageFilterUC2UC2UC in _itkNeighborhoodOperatorImageFilterPython:
_itkNeighborhoodOperatorImageFilterPython.itkNeighborhoodOperatorImageFilterUC2UC2UC_swigregister(itkNeighborhoodOperatorImageFilterUC2UC2UC)

def itkNeighborhoodOperatorImageFilterUC3UC3UC_New():
    return itkNeighborhoodOperatorImageFilterUC3UC3UC.New()

class itkNeighborhoodOperatorImageFilterUC3UC3UC(itk.itkImageToImageFilterAPython.itkImageToImageFilterIUC3IUC3):
    r"""Proxy of C++ itkNeighborhoodOperatorImageFilterUC3UC3UC class."""

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

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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkNeighborhoodOperatorImageFilterUC3UC3UC_Pointer"""
        return _itkNeighborhoodOperatorImageFilterPython.itkNeighborhoodOperatorImageFilterUC3UC3UC___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkNeighborhoodOperatorImageFilterUC3UC3UC_Pointer"""
        return _itkNeighborhoodOperatorImageFilterPython.itkNeighborhoodOperatorImageFilterUC3UC3UC_Clone(self)

    def SetOperator(self, p):
        r"""
        SetOperator(self, p)

        Parameters
        ----------
        p: itkNeighborhoodUC3 const &

        """
        return _itkNeighborhoodOperatorImageFilterPython.itkNeighborhoodOperatorImageFilterUC3UC3UC_SetOperator(self, p)

    def GetOperator(self):
        r"""GetOperator(self) -> itkNeighborhoodUC3"""
        return _itkNeighborhoodOperatorImageFilterPython.itkNeighborhoodOperatorImageFilterUC3UC3UC_GetOperator(self)

    def OverrideBoundaryCondition(self, i):
        r"""
        OverrideBoundaryCondition(self, i)

        Parameters
        ----------
        i: itkImageBoundaryConditionUC3UC3 *const

        """
        return _itkNeighborhoodOperatorImageFilterPython.itkNeighborhoodOperatorImageFilterUC3UC3UC_OverrideBoundaryCondition(self, i)

    def GetBoundaryCondition(self):
        r"""GetBoundaryCondition(self) -> itkImageBoundaryConditionUC3UC3"""
        return _itkNeighborhoodOperatorImageFilterPython.itkNeighborhoodOperatorImageFilterUC3UC3UC_GetBoundaryCondition(self)

    def GenerateInputRequestedRegion(self):
        r"""GenerateInputRequestedRegion(self)"""
        return _itkNeighborhoodOperatorImageFilterPython.itkNeighborhoodOperatorImageFilterUC3UC3UC_GenerateInputRequestedRegion(self)
    SameDimensionCheck = _itkNeighborhoodOperatorImageFilterPython.itkNeighborhoodOperatorImageFilterUC3UC3UC_SameDimensionCheck
    
    OperatorConvertibleToOutputCheck = _itkNeighborhoodOperatorImageFilterPython.itkNeighborhoodOperatorImageFilterUC3UC3UC_OperatorConvertibleToOutputCheck
    
    InputConvertibleToOperatorCheck = _itkNeighborhoodOperatorImageFilterPython.itkNeighborhoodOperatorImageFilterUC3UC3UC_InputConvertibleToOperatorCheck
    
    OperatorMultiplyOperatorCheck = _itkNeighborhoodOperatorImageFilterPython.itkNeighborhoodOperatorImageFilterUC3UC3UC_OperatorMultiplyOperatorCheck
    
    OperatorAdditiveOperatorsCheck = _itkNeighborhoodOperatorImageFilterPython.itkNeighborhoodOperatorImageFilterUC3UC3UC_OperatorAdditiveOperatorsCheck
    
    __swig_destroy__ = _itkNeighborhoodOperatorImageFilterPython.delete_itkNeighborhoodOperatorImageFilterUC3UC3UC

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

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

        """
        return _itkNeighborhoodOperatorImageFilterPython.itkNeighborhoodOperatorImageFilterUC3UC3UC_cast(obj)

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

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

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

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

        Ex:

          itkNeighborhoodOperatorImageFilterUC3UC3UC.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkNeighborhoodOperatorImageFilterUC3UC3UC in _itkNeighborhoodOperatorImageFilterPython:
_itkNeighborhoodOperatorImageFilterPython.itkNeighborhoodOperatorImageFilterUC3UC3UC_swigregister(itkNeighborhoodOperatorImageFilterUC3UC3UC)

from itk.support import helpers
import itk.support.types as itkt
from typing import Sequence, Tuple, Union

@helpers.accept_array_like_xarray_torch
def neighborhood_operator_image_filter(*args: itkt.ImageLike,  operator=...,**kwargs)-> itkt.ImageSourceReturn:
    """Functional interface for NeighborhoodOperatorImageFilter"""
    import itk

    kwarg_typehints = { 'operator':operator }
    specified_kwarg_typehints = { k:v for (k,v) in kwarg_typehints.items() if kwarg_typehints[k] is not ... }
    kwargs.update(specified_kwarg_typehints)


    instance = itk.NeighborhoodOperatorImageFilter.New(*args, **kwargs)

    return instance.__internal_call__()

def neighborhood_operator_image_filter_init_docstring():
    import itk
    from itk.support import template_class

    filter_class = itk.ITKImageFilterBase.NeighborhoodOperatorImageFilter
    neighborhood_operator_image_filter.process_object = filter_class
    is_template = isinstance(filter_class, template_class.itkTemplate)
    if is_template:
        filter_object = filter_class.values()[0]
    else:
        filter_object = filter_class

    neighborhood_operator_image_filter.__doc__ = filter_object.__doc__



