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



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

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.itkImageRegionPython
import itk.itkSizePython
import itk.pyBasePython
import itk.itkIndexPython
import itk.itkOffsetPython
import itk.ITKCommonBasePython
import itk.itkMatrixPython
import itk.vnl_vectorPython
import itk.vnl_matrixPython
import itk.stdcomplexPython
import itk.vnl_matrix_fixedPython
import itk.itkVectorPython
import itk.itkFixedArrayPython
import itk.vnl_vector_refPython
import itk.itkCovariantVectorPython
import itk.itkPointPython
import itk.itkImageToImageFilterBPython
import itk.itkVectorImagePython
import itk.itkImagePython
import itk.itkRGBPixelPython
import itk.itkSymmetricSecondRankTensorPython
import itk.itkRGBAPixelPython
import itk.itkVariableLengthVectorPython
import itk.itkImageSourcePython
import itk.itkImageSourceCommonPython
import itk.itkPhasedArray3DSpecialCoordinatesImagePython
import itk.itkImageToImageFilterCommonPython
import itk.itkImageBoundaryConditionPython
import itk.itkImageToImageFilterAPython

def itkPadImageFilterBaseICF2ICF2_New():
    return itkPadImageFilterBaseICF2ICF2.New()

class itkPadImageFilterBaseICF2ICF2(itk.itkImageToImageFilterBPython.itkImageToImageFilterICF2ICF2):
    r"""Proxy of C++ itkPadImageFilterBaseICF2ICF2 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__() -> itkPadImageFilterBaseICF2ICF2_Pointer"""
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseICF2ICF2___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkPadImageFilterBaseICF2ICF2_Pointer"""
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseICF2ICF2_Clone(self)

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

        Parameters
        ----------
        _arg: itkImageBoundaryConditionICF2 *

        """
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseICF2ICF2_SetBoundaryCondition(self, _arg)

    def GetBoundaryCondition(self):
        r"""GetBoundaryCondition(self) -> itkImageBoundaryConditionICF2"""
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseICF2ICF2_GetBoundaryCondition(self)
    __swig_destroy__ = _itkPadImageFilterBasePython.delete_itkPadImageFilterBaseICF2ICF2

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

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

        """
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseICF2ICF2_cast(obj)

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

        Create a new object of the class itkPadImageFilterBaseICF2ICF2 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:

          itkPadImageFilterBaseICF2ICF2.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkPadImageFilterBaseICF2ICF2 in _itkPadImageFilterBasePython:
_itkPadImageFilterBasePython.itkPadImageFilterBaseICF2ICF2_swigregister(itkPadImageFilterBaseICF2ICF2)

def itkPadImageFilterBaseICF3ICF3_New():
    return itkPadImageFilterBaseICF3ICF3.New()

class itkPadImageFilterBaseICF3ICF3(itk.itkImageToImageFilterBPython.itkImageToImageFilterICF3ICF3):
    r"""Proxy of C++ itkPadImageFilterBaseICF3ICF3 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__() -> itkPadImageFilterBaseICF3ICF3_Pointer"""
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseICF3ICF3___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkPadImageFilterBaseICF3ICF3_Pointer"""
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseICF3ICF3_Clone(self)

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

        Parameters
        ----------
        _arg: itkImageBoundaryConditionICF3 *

        """
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseICF3ICF3_SetBoundaryCondition(self, _arg)

    def GetBoundaryCondition(self):
        r"""GetBoundaryCondition(self) -> itkImageBoundaryConditionICF3"""
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseICF3ICF3_GetBoundaryCondition(self)
    __swig_destroy__ = _itkPadImageFilterBasePython.delete_itkPadImageFilterBaseICF3ICF3

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

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

        """
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseICF3ICF3_cast(obj)

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

        Create a new object of the class itkPadImageFilterBaseICF3ICF3 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:

          itkPadImageFilterBaseICF3ICF3.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkPadImageFilterBaseICF3ICF3 in _itkPadImageFilterBasePython:
_itkPadImageFilterBasePython.itkPadImageFilterBaseICF3ICF3_swigregister(itkPadImageFilterBaseICF3ICF3)

def itkPadImageFilterBaseICVF22ICVF22_New():
    return itkPadImageFilterBaseICVF22ICVF22.New()

class itkPadImageFilterBaseICVF22ICVF22(itk.itkImageToImageFilterAPython.itkImageToImageFilterICVF22ICVF22):
    r"""Proxy of C++ itkPadImageFilterBaseICVF22ICVF22 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__() -> itkPadImageFilterBaseICVF22ICVF22_Pointer"""
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseICVF22ICVF22___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkPadImageFilterBaseICVF22ICVF22_Pointer"""
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseICVF22ICVF22_Clone(self)

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

        Parameters
        ----------
        _arg: itkImageBoundaryConditionICVF22 *

        """
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseICVF22ICVF22_SetBoundaryCondition(self, _arg)

    def GetBoundaryCondition(self):
        r"""GetBoundaryCondition(self) -> itkImageBoundaryConditionICVF22"""
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseICVF22ICVF22_GetBoundaryCondition(self)
    __swig_destroy__ = _itkPadImageFilterBasePython.delete_itkPadImageFilterBaseICVF22ICVF22

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

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

        """
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseICVF22ICVF22_cast(obj)

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

        Create a new object of the class itkPadImageFilterBaseICVF22ICVF22 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:

          itkPadImageFilterBaseICVF22ICVF22.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkPadImageFilterBaseICVF22ICVF22 in _itkPadImageFilterBasePython:
_itkPadImageFilterBasePython.itkPadImageFilterBaseICVF22ICVF22_swigregister(itkPadImageFilterBaseICVF22ICVF22)

def itkPadImageFilterBaseICVF23ICVF23_New():
    return itkPadImageFilterBaseICVF23ICVF23.New()

class itkPadImageFilterBaseICVF23ICVF23(itk.itkImageToImageFilterAPython.itkImageToImageFilterICVF23ICVF23):
    r"""Proxy of C++ itkPadImageFilterBaseICVF23ICVF23 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__() -> itkPadImageFilterBaseICVF23ICVF23_Pointer"""
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseICVF23ICVF23___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkPadImageFilterBaseICVF23ICVF23_Pointer"""
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseICVF23ICVF23_Clone(self)

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

        Parameters
        ----------
        _arg: itkImageBoundaryConditionICVF23 *

        """
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseICVF23ICVF23_SetBoundaryCondition(self, _arg)

    def GetBoundaryCondition(self):
        r"""GetBoundaryCondition(self) -> itkImageBoundaryConditionICVF23"""
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseICVF23ICVF23_GetBoundaryCondition(self)
    __swig_destroy__ = _itkPadImageFilterBasePython.delete_itkPadImageFilterBaseICVF23ICVF23

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

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

        """
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseICVF23ICVF23_cast(obj)

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

        Create a new object of the class itkPadImageFilterBaseICVF23ICVF23 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:

          itkPadImageFilterBaseICVF23ICVF23.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkPadImageFilterBaseICVF23ICVF23 in _itkPadImageFilterBasePython:
_itkPadImageFilterBasePython.itkPadImageFilterBaseICVF23ICVF23_swigregister(itkPadImageFilterBaseICVF23ICVF23)

def itkPadImageFilterBaseICVF32ICVF32_New():
    return itkPadImageFilterBaseICVF32ICVF32.New()

class itkPadImageFilterBaseICVF32ICVF32(itk.itkImageToImageFilterAPython.itkImageToImageFilterICVF32ICVF32):
    r"""Proxy of C++ itkPadImageFilterBaseICVF32ICVF32 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__() -> itkPadImageFilterBaseICVF32ICVF32_Pointer"""
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseICVF32ICVF32___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkPadImageFilterBaseICVF32ICVF32_Pointer"""
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseICVF32ICVF32_Clone(self)

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

        Parameters
        ----------
        _arg: itkImageBoundaryConditionICVF32 *

        """
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseICVF32ICVF32_SetBoundaryCondition(self, _arg)

    def GetBoundaryCondition(self):
        r"""GetBoundaryCondition(self) -> itkImageBoundaryConditionICVF32"""
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseICVF32ICVF32_GetBoundaryCondition(self)
    __swig_destroy__ = _itkPadImageFilterBasePython.delete_itkPadImageFilterBaseICVF32ICVF32

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

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

        """
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseICVF32ICVF32_cast(obj)

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

        Create a new object of the class itkPadImageFilterBaseICVF32ICVF32 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:

          itkPadImageFilterBaseICVF32ICVF32.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkPadImageFilterBaseICVF32ICVF32 in _itkPadImageFilterBasePython:
_itkPadImageFilterBasePython.itkPadImageFilterBaseICVF32ICVF32_swigregister(itkPadImageFilterBaseICVF32ICVF32)

def itkPadImageFilterBaseICVF33ICVF33_New():
    return itkPadImageFilterBaseICVF33ICVF33.New()

class itkPadImageFilterBaseICVF33ICVF33(itk.itkImageToImageFilterAPython.itkImageToImageFilterICVF33ICVF33):
    r"""Proxy of C++ itkPadImageFilterBaseICVF33ICVF33 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__() -> itkPadImageFilterBaseICVF33ICVF33_Pointer"""
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseICVF33ICVF33___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkPadImageFilterBaseICVF33ICVF33_Pointer"""
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseICVF33ICVF33_Clone(self)

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

        Parameters
        ----------
        _arg: itkImageBoundaryConditionICVF33 *

        """
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseICVF33ICVF33_SetBoundaryCondition(self, _arg)

    def GetBoundaryCondition(self):
        r"""GetBoundaryCondition(self) -> itkImageBoundaryConditionICVF33"""
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseICVF33ICVF33_GetBoundaryCondition(self)
    __swig_destroy__ = _itkPadImageFilterBasePython.delete_itkPadImageFilterBaseICVF33ICVF33

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

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

        """
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseICVF33ICVF33_cast(obj)

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

        Create a new object of the class itkPadImageFilterBaseICVF33ICVF33 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:

          itkPadImageFilterBaseICVF33ICVF33.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkPadImageFilterBaseICVF33ICVF33 in _itkPadImageFilterBasePython:
_itkPadImageFilterBasePython.itkPadImageFilterBaseICVF33ICVF33_swigregister(itkPadImageFilterBaseICVF33ICVF33)

def itkPadImageFilterBaseICVF42ICVF42_New():
    return itkPadImageFilterBaseICVF42ICVF42.New()

class itkPadImageFilterBaseICVF42ICVF42(itk.itkImageToImageFilterAPython.itkImageToImageFilterICVF42ICVF42):
    r"""Proxy of C++ itkPadImageFilterBaseICVF42ICVF42 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__() -> itkPadImageFilterBaseICVF42ICVF42_Pointer"""
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseICVF42ICVF42___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkPadImageFilterBaseICVF42ICVF42_Pointer"""
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseICVF42ICVF42_Clone(self)

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

        Parameters
        ----------
        _arg: itkImageBoundaryConditionICVF42 *

        """
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseICVF42ICVF42_SetBoundaryCondition(self, _arg)

    def GetBoundaryCondition(self):
        r"""GetBoundaryCondition(self) -> itkImageBoundaryConditionICVF42"""
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseICVF42ICVF42_GetBoundaryCondition(self)
    __swig_destroy__ = _itkPadImageFilterBasePython.delete_itkPadImageFilterBaseICVF42ICVF42

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

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

        """
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseICVF42ICVF42_cast(obj)

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

        Create a new object of the class itkPadImageFilterBaseICVF42ICVF42 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:

          itkPadImageFilterBaseICVF42ICVF42.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkPadImageFilterBaseICVF42ICVF42 in _itkPadImageFilterBasePython:
_itkPadImageFilterBasePython.itkPadImageFilterBaseICVF42ICVF42_swigregister(itkPadImageFilterBaseICVF42ICVF42)

def itkPadImageFilterBaseICVF43ICVF43_New():
    return itkPadImageFilterBaseICVF43ICVF43.New()

class itkPadImageFilterBaseICVF43ICVF43(itk.itkImageToImageFilterAPython.itkImageToImageFilterICVF43ICVF43):
    r"""Proxy of C++ itkPadImageFilterBaseICVF43ICVF43 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__() -> itkPadImageFilterBaseICVF43ICVF43_Pointer"""
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseICVF43ICVF43___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkPadImageFilterBaseICVF43ICVF43_Pointer"""
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseICVF43ICVF43_Clone(self)

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

        Parameters
        ----------
        _arg: itkImageBoundaryConditionICVF43 *

        """
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseICVF43ICVF43_SetBoundaryCondition(self, _arg)

    def GetBoundaryCondition(self):
        r"""GetBoundaryCondition(self) -> itkImageBoundaryConditionICVF43"""
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseICVF43ICVF43_GetBoundaryCondition(self)
    __swig_destroy__ = _itkPadImageFilterBasePython.delete_itkPadImageFilterBaseICVF43ICVF43

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

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

        """
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseICVF43ICVF43_cast(obj)

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

        Create a new object of the class itkPadImageFilterBaseICVF43ICVF43 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:

          itkPadImageFilterBaseICVF43ICVF43.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkPadImageFilterBaseICVF43ICVF43 in _itkPadImageFilterBasePython:
_itkPadImageFilterBasePython.itkPadImageFilterBaseICVF43ICVF43_swigregister(itkPadImageFilterBaseICVF43ICVF43)

def itkPadImageFilterBaseIF2IF2_New():
    return itkPadImageFilterBaseIF2IF2.New()

class itkPadImageFilterBaseIF2IF2(itk.itkImageToImageFilterAPython.itkImageToImageFilterIF2IF2):
    r"""Proxy of C++ itkPadImageFilterBaseIF2IF2 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__() -> itkPadImageFilterBaseIF2IF2_Pointer"""
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseIF2IF2___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkPadImageFilterBaseIF2IF2_Pointer"""
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseIF2IF2_Clone(self)

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

        Parameters
        ----------
        _arg: itkImageBoundaryConditionIF2 *

        """
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseIF2IF2_SetBoundaryCondition(self, _arg)

    def GetBoundaryCondition(self):
        r"""GetBoundaryCondition(self) -> itkImageBoundaryConditionIF2"""
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseIF2IF2_GetBoundaryCondition(self)
    __swig_destroy__ = _itkPadImageFilterBasePython.delete_itkPadImageFilterBaseIF2IF2

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

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

        """
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseIF2IF2_cast(obj)

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

        Create a new object of the class itkPadImageFilterBaseIF2IF2 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:

          itkPadImageFilterBaseIF2IF2.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkPadImageFilterBaseIF2IF2 in _itkPadImageFilterBasePython:
_itkPadImageFilterBasePython.itkPadImageFilterBaseIF2IF2_swigregister(itkPadImageFilterBaseIF2IF2)

def itkPadImageFilterBaseIF3IF3_New():
    return itkPadImageFilterBaseIF3IF3.New()

class itkPadImageFilterBaseIF3IF3(itk.itkImageToImageFilterAPython.itkImageToImageFilterIF3IF3):
    r"""Proxy of C++ itkPadImageFilterBaseIF3IF3 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__() -> itkPadImageFilterBaseIF3IF3_Pointer"""
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseIF3IF3___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkPadImageFilterBaseIF3IF3_Pointer"""
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseIF3IF3_Clone(self)

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

        Parameters
        ----------
        _arg: itkImageBoundaryConditionIF3 *

        """
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseIF3IF3_SetBoundaryCondition(self, _arg)

    def GetBoundaryCondition(self):
        r"""GetBoundaryCondition(self) -> itkImageBoundaryConditionIF3"""
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseIF3IF3_GetBoundaryCondition(self)
    __swig_destroy__ = _itkPadImageFilterBasePython.delete_itkPadImageFilterBaseIF3IF3

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

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

        """
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseIF3IF3_cast(obj)

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

        Create a new object of the class itkPadImageFilterBaseIF3IF3 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:

          itkPadImageFilterBaseIF3IF3.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkPadImageFilterBaseIF3IF3 in _itkPadImageFilterBasePython:
_itkPadImageFilterBasePython.itkPadImageFilterBaseIF3IF3_swigregister(itkPadImageFilterBaseIF3IF3)

def itkPadImageFilterBaseIRGBAUC2IRGBAUC2_New():
    return itkPadImageFilterBaseIRGBAUC2IRGBAUC2.New()

class itkPadImageFilterBaseIRGBAUC2IRGBAUC2(itk.itkImageToImageFilterAPython.itkImageToImageFilterIRGBAUC2IRGBAUC2):
    r"""Proxy of C++ itkPadImageFilterBaseIRGBAUC2IRGBAUC2 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__() -> itkPadImageFilterBaseIRGBAUC2IRGBAUC2_Pointer"""
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseIRGBAUC2IRGBAUC2___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkPadImageFilterBaseIRGBAUC2IRGBAUC2_Pointer"""
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseIRGBAUC2IRGBAUC2_Clone(self)

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

        Parameters
        ----------
        _arg: itkImageBoundaryConditionIRGBAUC2 *

        """
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseIRGBAUC2IRGBAUC2_SetBoundaryCondition(self, _arg)

    def GetBoundaryCondition(self):
        r"""GetBoundaryCondition(self) -> itkImageBoundaryConditionIRGBAUC2"""
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseIRGBAUC2IRGBAUC2_GetBoundaryCondition(self)
    __swig_destroy__ = _itkPadImageFilterBasePython.delete_itkPadImageFilterBaseIRGBAUC2IRGBAUC2

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

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

        """
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseIRGBAUC2IRGBAUC2_cast(obj)

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

        Create a new object of the class itkPadImageFilterBaseIRGBAUC2IRGBAUC2 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:

          itkPadImageFilterBaseIRGBAUC2IRGBAUC2.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkPadImageFilterBaseIRGBAUC2IRGBAUC2 in _itkPadImageFilterBasePython:
_itkPadImageFilterBasePython.itkPadImageFilterBaseIRGBAUC2IRGBAUC2_swigregister(itkPadImageFilterBaseIRGBAUC2IRGBAUC2)

def itkPadImageFilterBaseIRGBAUC3IRGBAUC3_New():
    return itkPadImageFilterBaseIRGBAUC3IRGBAUC3.New()

class itkPadImageFilterBaseIRGBAUC3IRGBAUC3(itk.itkImageToImageFilterAPython.itkImageToImageFilterIRGBAUC3IRGBAUC3):
    r"""Proxy of C++ itkPadImageFilterBaseIRGBAUC3IRGBAUC3 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__() -> itkPadImageFilterBaseIRGBAUC3IRGBAUC3_Pointer"""
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseIRGBAUC3IRGBAUC3___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkPadImageFilterBaseIRGBAUC3IRGBAUC3_Pointer"""
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseIRGBAUC3IRGBAUC3_Clone(self)

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

        Parameters
        ----------
        _arg: itkImageBoundaryConditionIRGBAUC3 *

        """
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseIRGBAUC3IRGBAUC3_SetBoundaryCondition(self, _arg)

    def GetBoundaryCondition(self):
        r"""GetBoundaryCondition(self) -> itkImageBoundaryConditionIRGBAUC3"""
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseIRGBAUC3IRGBAUC3_GetBoundaryCondition(self)
    __swig_destroy__ = _itkPadImageFilterBasePython.delete_itkPadImageFilterBaseIRGBAUC3IRGBAUC3

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

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

        """
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseIRGBAUC3IRGBAUC3_cast(obj)

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

        Create a new object of the class itkPadImageFilterBaseIRGBAUC3IRGBAUC3 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:

          itkPadImageFilterBaseIRGBAUC3IRGBAUC3.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkPadImageFilterBaseIRGBAUC3IRGBAUC3 in _itkPadImageFilterBasePython:
_itkPadImageFilterBasePython.itkPadImageFilterBaseIRGBAUC3IRGBAUC3_swigregister(itkPadImageFilterBaseIRGBAUC3IRGBAUC3)

def itkPadImageFilterBaseIRGBUC2IRGBUC2_New():
    return itkPadImageFilterBaseIRGBUC2IRGBUC2.New()

class itkPadImageFilterBaseIRGBUC2IRGBUC2(itk.itkImageToImageFilterAPython.itkImageToImageFilterIRGBUC2IRGBUC2):
    r"""Proxy of C++ itkPadImageFilterBaseIRGBUC2IRGBUC2 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__() -> itkPadImageFilterBaseIRGBUC2IRGBUC2_Pointer"""
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseIRGBUC2IRGBUC2___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkPadImageFilterBaseIRGBUC2IRGBUC2_Pointer"""
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseIRGBUC2IRGBUC2_Clone(self)

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

        Parameters
        ----------
        _arg: itkImageBoundaryConditionIRGBUC2 *

        """
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseIRGBUC2IRGBUC2_SetBoundaryCondition(self, _arg)

    def GetBoundaryCondition(self):
        r"""GetBoundaryCondition(self) -> itkImageBoundaryConditionIRGBUC2"""
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseIRGBUC2IRGBUC2_GetBoundaryCondition(self)
    __swig_destroy__ = _itkPadImageFilterBasePython.delete_itkPadImageFilterBaseIRGBUC2IRGBUC2

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

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

        """
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseIRGBUC2IRGBUC2_cast(obj)

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

        Create a new object of the class itkPadImageFilterBaseIRGBUC2IRGBUC2 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:

          itkPadImageFilterBaseIRGBUC2IRGBUC2.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkPadImageFilterBaseIRGBUC2IRGBUC2 in _itkPadImageFilterBasePython:
_itkPadImageFilterBasePython.itkPadImageFilterBaseIRGBUC2IRGBUC2_swigregister(itkPadImageFilterBaseIRGBUC2IRGBUC2)

def itkPadImageFilterBaseIRGBUC3IRGBUC3_New():
    return itkPadImageFilterBaseIRGBUC3IRGBUC3.New()

class itkPadImageFilterBaseIRGBUC3IRGBUC3(itk.itkImageToImageFilterAPython.itkImageToImageFilterIRGBUC3IRGBUC3):
    r"""Proxy of C++ itkPadImageFilterBaseIRGBUC3IRGBUC3 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__() -> itkPadImageFilterBaseIRGBUC3IRGBUC3_Pointer"""
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseIRGBUC3IRGBUC3___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkPadImageFilterBaseIRGBUC3IRGBUC3_Pointer"""
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseIRGBUC3IRGBUC3_Clone(self)

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

        Parameters
        ----------
        _arg: itkImageBoundaryConditionIRGBUC3 *

        """
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseIRGBUC3IRGBUC3_SetBoundaryCondition(self, _arg)

    def GetBoundaryCondition(self):
        r"""GetBoundaryCondition(self) -> itkImageBoundaryConditionIRGBUC3"""
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseIRGBUC3IRGBUC3_GetBoundaryCondition(self)
    __swig_destroy__ = _itkPadImageFilterBasePython.delete_itkPadImageFilterBaseIRGBUC3IRGBUC3

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

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

        """
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseIRGBUC3IRGBUC3_cast(obj)

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

        Create a new object of the class itkPadImageFilterBaseIRGBUC3IRGBUC3 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:

          itkPadImageFilterBaseIRGBUC3IRGBUC3.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkPadImageFilterBaseIRGBUC3IRGBUC3 in _itkPadImageFilterBasePython:
_itkPadImageFilterBasePython.itkPadImageFilterBaseIRGBUC3IRGBUC3_swigregister(itkPadImageFilterBaseIRGBUC3IRGBUC3)

def itkPadImageFilterBaseISS2ISS2_New():
    return itkPadImageFilterBaseISS2ISS2.New()

class itkPadImageFilterBaseISS2ISS2(itk.itkImageToImageFilterAPython.itkImageToImageFilterISS2ISS2):
    r"""Proxy of C++ itkPadImageFilterBaseISS2ISS2 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__() -> itkPadImageFilterBaseISS2ISS2_Pointer"""
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseISS2ISS2___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkPadImageFilterBaseISS2ISS2_Pointer"""
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseISS2ISS2_Clone(self)

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

        Parameters
        ----------
        _arg: itkImageBoundaryConditionISS2 *

        """
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseISS2ISS2_SetBoundaryCondition(self, _arg)

    def GetBoundaryCondition(self):
        r"""GetBoundaryCondition(self) -> itkImageBoundaryConditionISS2"""
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseISS2ISS2_GetBoundaryCondition(self)
    __swig_destroy__ = _itkPadImageFilterBasePython.delete_itkPadImageFilterBaseISS2ISS2

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

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

        """
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseISS2ISS2_cast(obj)

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

        Create a new object of the class itkPadImageFilterBaseISS2ISS2 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:

          itkPadImageFilterBaseISS2ISS2.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkPadImageFilterBaseISS2ISS2 in _itkPadImageFilterBasePython:
_itkPadImageFilterBasePython.itkPadImageFilterBaseISS2ISS2_swigregister(itkPadImageFilterBaseISS2ISS2)

def itkPadImageFilterBaseISS3ISS3_New():
    return itkPadImageFilterBaseISS3ISS3.New()

class itkPadImageFilterBaseISS3ISS3(itk.itkImageToImageFilterAPython.itkImageToImageFilterISS3ISS3):
    r"""Proxy of C++ itkPadImageFilterBaseISS3ISS3 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__() -> itkPadImageFilterBaseISS3ISS3_Pointer"""
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseISS3ISS3___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkPadImageFilterBaseISS3ISS3_Pointer"""
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseISS3ISS3_Clone(self)

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

        Parameters
        ----------
        _arg: itkImageBoundaryConditionISS3 *

        """
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseISS3ISS3_SetBoundaryCondition(self, _arg)

    def GetBoundaryCondition(self):
        r"""GetBoundaryCondition(self) -> itkImageBoundaryConditionISS3"""
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseISS3ISS3_GetBoundaryCondition(self)
    __swig_destroy__ = _itkPadImageFilterBasePython.delete_itkPadImageFilterBaseISS3ISS3

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

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

        """
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseISS3ISS3_cast(obj)

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

        Create a new object of the class itkPadImageFilterBaseISS3ISS3 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:

          itkPadImageFilterBaseISS3ISS3.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkPadImageFilterBaseISS3ISS3 in _itkPadImageFilterBasePython:
_itkPadImageFilterBasePython.itkPadImageFilterBaseISS3ISS3_swigregister(itkPadImageFilterBaseISS3ISS3)

def itkPadImageFilterBaseIUC2IUC2_New():
    return itkPadImageFilterBaseIUC2IUC2.New()

class itkPadImageFilterBaseIUC2IUC2(itk.itkImageToImageFilterAPython.itkImageToImageFilterIUC2IUC2):
    r"""Proxy of C++ itkPadImageFilterBaseIUC2IUC2 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__() -> itkPadImageFilterBaseIUC2IUC2_Pointer"""
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseIUC2IUC2___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkPadImageFilterBaseIUC2IUC2_Pointer"""
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseIUC2IUC2_Clone(self)

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

        Parameters
        ----------
        _arg: itkImageBoundaryConditionIUC2 *

        """
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseIUC2IUC2_SetBoundaryCondition(self, _arg)

    def GetBoundaryCondition(self):
        r"""GetBoundaryCondition(self) -> itkImageBoundaryConditionIUC2"""
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseIUC2IUC2_GetBoundaryCondition(self)
    __swig_destroy__ = _itkPadImageFilterBasePython.delete_itkPadImageFilterBaseIUC2IUC2

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

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

        """
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseIUC2IUC2_cast(obj)

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

        Create a new object of the class itkPadImageFilterBaseIUC2IUC2 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:

          itkPadImageFilterBaseIUC2IUC2.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkPadImageFilterBaseIUC2IUC2 in _itkPadImageFilterBasePython:
_itkPadImageFilterBasePython.itkPadImageFilterBaseIUC2IUC2_swigregister(itkPadImageFilterBaseIUC2IUC2)

def itkPadImageFilterBaseIUC3IUC3_New():
    return itkPadImageFilterBaseIUC3IUC3.New()

class itkPadImageFilterBaseIUC3IUC3(itk.itkImageToImageFilterAPython.itkImageToImageFilterIUC3IUC3):
    r"""Proxy of C++ itkPadImageFilterBaseIUC3IUC3 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__() -> itkPadImageFilterBaseIUC3IUC3_Pointer"""
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseIUC3IUC3___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkPadImageFilterBaseIUC3IUC3_Pointer"""
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseIUC3IUC3_Clone(self)

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

        Parameters
        ----------
        _arg: itkImageBoundaryConditionIUC3 *

        """
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseIUC3IUC3_SetBoundaryCondition(self, _arg)

    def GetBoundaryCondition(self):
        r"""GetBoundaryCondition(self) -> itkImageBoundaryConditionIUC3"""
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseIUC3IUC3_GetBoundaryCondition(self)
    __swig_destroy__ = _itkPadImageFilterBasePython.delete_itkPadImageFilterBaseIUC3IUC3

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

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

        """
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseIUC3IUC3_cast(obj)

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

        Create a new object of the class itkPadImageFilterBaseIUC3IUC3 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:

          itkPadImageFilterBaseIUC3IUC3.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkPadImageFilterBaseIUC3IUC3 in _itkPadImageFilterBasePython:
_itkPadImageFilterBasePython.itkPadImageFilterBaseIUC3IUC3_swigregister(itkPadImageFilterBaseIUC3IUC3)

def itkPadImageFilterBaseIVF22IVF22_New():
    return itkPadImageFilterBaseIVF22IVF22.New()

class itkPadImageFilterBaseIVF22IVF22(itk.itkImageToImageFilterAPython.itkImageToImageFilterIVF22IVF22):
    r"""Proxy of C++ itkPadImageFilterBaseIVF22IVF22 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__() -> itkPadImageFilterBaseIVF22IVF22_Pointer"""
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseIVF22IVF22___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkPadImageFilterBaseIVF22IVF22_Pointer"""
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseIVF22IVF22_Clone(self)

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

        Parameters
        ----------
        _arg: itkImageBoundaryConditionIVF22 *

        """
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseIVF22IVF22_SetBoundaryCondition(self, _arg)

    def GetBoundaryCondition(self):
        r"""GetBoundaryCondition(self) -> itkImageBoundaryConditionIVF22"""
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseIVF22IVF22_GetBoundaryCondition(self)
    __swig_destroy__ = _itkPadImageFilterBasePython.delete_itkPadImageFilterBaseIVF22IVF22

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

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

        """
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseIVF22IVF22_cast(obj)

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

        Create a new object of the class itkPadImageFilterBaseIVF22IVF22 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:

          itkPadImageFilterBaseIVF22IVF22.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkPadImageFilterBaseIVF22IVF22 in _itkPadImageFilterBasePython:
_itkPadImageFilterBasePython.itkPadImageFilterBaseIVF22IVF22_swigregister(itkPadImageFilterBaseIVF22IVF22)

def itkPadImageFilterBaseIVF23IVF23_New():
    return itkPadImageFilterBaseIVF23IVF23.New()

class itkPadImageFilterBaseIVF23IVF23(itk.itkImageToImageFilterAPython.itkImageToImageFilterIVF23IVF23):
    r"""Proxy of C++ itkPadImageFilterBaseIVF23IVF23 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__() -> itkPadImageFilterBaseIVF23IVF23_Pointer"""
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseIVF23IVF23___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkPadImageFilterBaseIVF23IVF23_Pointer"""
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseIVF23IVF23_Clone(self)

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

        Parameters
        ----------
        _arg: itkImageBoundaryConditionIVF23 *

        """
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseIVF23IVF23_SetBoundaryCondition(self, _arg)

    def GetBoundaryCondition(self):
        r"""GetBoundaryCondition(self) -> itkImageBoundaryConditionIVF23"""
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseIVF23IVF23_GetBoundaryCondition(self)
    __swig_destroy__ = _itkPadImageFilterBasePython.delete_itkPadImageFilterBaseIVF23IVF23

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

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

        """
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseIVF23IVF23_cast(obj)

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

        Create a new object of the class itkPadImageFilterBaseIVF23IVF23 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:

          itkPadImageFilterBaseIVF23IVF23.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkPadImageFilterBaseIVF23IVF23 in _itkPadImageFilterBasePython:
_itkPadImageFilterBasePython.itkPadImageFilterBaseIVF23IVF23_swigregister(itkPadImageFilterBaseIVF23IVF23)

def itkPadImageFilterBaseIVF32IVF32_New():
    return itkPadImageFilterBaseIVF32IVF32.New()

class itkPadImageFilterBaseIVF32IVF32(itk.itkImageToImageFilterAPython.itkImageToImageFilterIVF32IVF32):
    r"""Proxy of C++ itkPadImageFilterBaseIVF32IVF32 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__() -> itkPadImageFilterBaseIVF32IVF32_Pointer"""
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseIVF32IVF32___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkPadImageFilterBaseIVF32IVF32_Pointer"""
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseIVF32IVF32_Clone(self)

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

        Parameters
        ----------
        _arg: itkImageBoundaryConditionIVF32 *

        """
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseIVF32IVF32_SetBoundaryCondition(self, _arg)

    def GetBoundaryCondition(self):
        r"""GetBoundaryCondition(self) -> itkImageBoundaryConditionIVF32"""
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseIVF32IVF32_GetBoundaryCondition(self)
    __swig_destroy__ = _itkPadImageFilterBasePython.delete_itkPadImageFilterBaseIVF32IVF32

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

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

        """
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseIVF32IVF32_cast(obj)

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

        Create a new object of the class itkPadImageFilterBaseIVF32IVF32 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:

          itkPadImageFilterBaseIVF32IVF32.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkPadImageFilterBaseIVF32IVF32 in _itkPadImageFilterBasePython:
_itkPadImageFilterBasePython.itkPadImageFilterBaseIVF32IVF32_swigregister(itkPadImageFilterBaseIVF32IVF32)

def itkPadImageFilterBaseIVF33IVF33_New():
    return itkPadImageFilterBaseIVF33IVF33.New()

class itkPadImageFilterBaseIVF33IVF33(itk.itkImageToImageFilterAPython.itkImageToImageFilterIVF33IVF33):
    r"""Proxy of C++ itkPadImageFilterBaseIVF33IVF33 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__() -> itkPadImageFilterBaseIVF33IVF33_Pointer"""
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseIVF33IVF33___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkPadImageFilterBaseIVF33IVF33_Pointer"""
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseIVF33IVF33_Clone(self)

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

        Parameters
        ----------
        _arg: itkImageBoundaryConditionIVF33 *

        """
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseIVF33IVF33_SetBoundaryCondition(self, _arg)

    def GetBoundaryCondition(self):
        r"""GetBoundaryCondition(self) -> itkImageBoundaryConditionIVF33"""
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseIVF33IVF33_GetBoundaryCondition(self)
    __swig_destroy__ = _itkPadImageFilterBasePython.delete_itkPadImageFilterBaseIVF33IVF33

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

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

        """
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseIVF33IVF33_cast(obj)

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

        Create a new object of the class itkPadImageFilterBaseIVF33IVF33 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:

          itkPadImageFilterBaseIVF33IVF33.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkPadImageFilterBaseIVF33IVF33 in _itkPadImageFilterBasePython:
_itkPadImageFilterBasePython.itkPadImageFilterBaseIVF33IVF33_swigregister(itkPadImageFilterBaseIVF33IVF33)

def itkPadImageFilterBaseIVF42IVF42_New():
    return itkPadImageFilterBaseIVF42IVF42.New()

class itkPadImageFilterBaseIVF42IVF42(itk.itkImageToImageFilterAPython.itkImageToImageFilterIVF42IVF42):
    r"""Proxy of C++ itkPadImageFilterBaseIVF42IVF42 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__() -> itkPadImageFilterBaseIVF42IVF42_Pointer"""
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseIVF42IVF42___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkPadImageFilterBaseIVF42IVF42_Pointer"""
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseIVF42IVF42_Clone(self)

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

        Parameters
        ----------
        _arg: itkImageBoundaryConditionIVF42 *

        """
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseIVF42IVF42_SetBoundaryCondition(self, _arg)

    def GetBoundaryCondition(self):
        r"""GetBoundaryCondition(self) -> itkImageBoundaryConditionIVF42"""
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseIVF42IVF42_GetBoundaryCondition(self)
    __swig_destroy__ = _itkPadImageFilterBasePython.delete_itkPadImageFilterBaseIVF42IVF42

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

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

        """
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseIVF42IVF42_cast(obj)

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

        Create a new object of the class itkPadImageFilterBaseIVF42IVF42 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:

          itkPadImageFilterBaseIVF42IVF42.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkPadImageFilterBaseIVF42IVF42 in _itkPadImageFilterBasePython:
_itkPadImageFilterBasePython.itkPadImageFilterBaseIVF42IVF42_swigregister(itkPadImageFilterBaseIVF42IVF42)

def itkPadImageFilterBaseIVF43IVF43_New():
    return itkPadImageFilterBaseIVF43IVF43.New()

class itkPadImageFilterBaseIVF43IVF43(itk.itkImageToImageFilterAPython.itkImageToImageFilterIVF43IVF43):
    r"""Proxy of C++ itkPadImageFilterBaseIVF43IVF43 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__() -> itkPadImageFilterBaseIVF43IVF43_Pointer"""
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseIVF43IVF43___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkPadImageFilterBaseIVF43IVF43_Pointer"""
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseIVF43IVF43_Clone(self)

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

        Parameters
        ----------
        _arg: itkImageBoundaryConditionIVF43 *

        """
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseIVF43IVF43_SetBoundaryCondition(self, _arg)

    def GetBoundaryCondition(self):
        r"""GetBoundaryCondition(self) -> itkImageBoundaryConditionIVF43"""
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseIVF43IVF43_GetBoundaryCondition(self)
    __swig_destroy__ = _itkPadImageFilterBasePython.delete_itkPadImageFilterBaseIVF43IVF43

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

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

        """
        return _itkPadImageFilterBasePython.itkPadImageFilterBaseIVF43IVF43_cast(obj)

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

        Create a new object of the class itkPadImageFilterBaseIVF43IVF43 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:

          itkPadImageFilterBaseIVF43IVF43.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkPadImageFilterBaseIVF43IVF43 in _itkPadImageFilterBasePython:
_itkPadImageFilterBasePython.itkPadImageFilterBaseIVF43IVF43_swigregister(itkPadImageFilterBaseIVF43IVF43)

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

@helpers.accept_array_like_xarray_torch
def pad_image_filter_base(*args: itkt.ImageLike,  boundary_condition: itkt.ImageBoundaryCondition=...,**kwargs)-> itkt.ImageSourceReturn:
    """Functional interface for PadImageFilterBase"""
    import itk

    kwarg_typehints = { 'boundary_condition':boundary_condition }
    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.PadImageFilterBase.New(*args, **kwargs)

    return instance.__internal_call__()

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

    filter_class = itk.ITKImageGrid.PadImageFilterBase
    pad_image_filter_base.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

    pad_image_filter_base.__doc__ = filter_object.__doc__



