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

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

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

_swig_new_instance_method = _itkPadImageFilterBasePython.SWIG_PyInstanceMethod_New
_swig_new_static_method = _itkPadImageFilterBasePython.SWIG_PyStaticMethod_New

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__)


import ITKCommonBasePython
import pyBasePython
import itkImageToImageFilterAPython
import itkImageSourcePython
import itkImageRegionPython
import itkSizePython
import itkIndexPython
import itkOffsetPython
import itkImageSourceCommonPython
import itkVectorImagePython
import stdcomplexPython
import itkVariableLengthVectorPython
import itkImagePython
import itkVectorPython
import itkFixedArrayPython
import vnl_vector_refPython
import vnl_vectorPython
import vnl_matrixPython
import itkRGBAPixelPython
import itkPointPython
import itkRGBPixelPython
import itkSymmetricSecondRankTensorPython
import itkMatrixPython
import vnl_matrix_fixedPython
import itkCovariantVectorPython
import itkImageToImageFilterCommonPython
import itkImageToImageFilterBPython
import itkImageBoundaryConditionPython

def itkPadImageFilterBaseICF3ICF3_New():
  return itkPadImageFilterBaseICF3ICF3.New()


def itkPadImageFilterBaseICF2ICF2_New():
  return itkPadImageFilterBaseICF2ICF2.New()


def itkPadImageFilterBaseIF3IF3_New():
  return itkPadImageFilterBaseIF3IF3.New()


def itkPadImageFilterBaseIF2IF2_New():
  return itkPadImageFilterBaseIF2IF2.New()


def itkPadImageFilterBaseIUC3IUC3_New():
  return itkPadImageFilterBaseIUC3IUC3.New()


def itkPadImageFilterBaseIUC2IUC2_New():
  return itkPadImageFilterBaseIUC2IUC2.New()


def itkPadImageFilterBaseISS3ISS3_New():
  return itkPadImageFilterBaseISS3ISS3.New()


def itkPadImageFilterBaseISS2ISS2_New():
  return itkPadImageFilterBaseISS2ISS2.New()


def itkPadImageFilterBaseICVF43ICVF43_New():
  return itkPadImageFilterBaseICVF43ICVF43.New()


def itkPadImageFilterBaseICVF42ICVF42_New():
  return itkPadImageFilterBaseICVF42ICVF42.New()


def itkPadImageFilterBaseICVF33ICVF33_New():
  return itkPadImageFilterBaseICVF33ICVF33.New()


def itkPadImageFilterBaseICVF32ICVF32_New():
  return itkPadImageFilterBaseICVF32ICVF32.New()


def itkPadImageFilterBaseICVF23ICVF23_New():
  return itkPadImageFilterBaseICVF23ICVF23.New()


def itkPadImageFilterBaseICVF22ICVF22_New():
  return itkPadImageFilterBaseICVF22ICVF22.New()


def itkPadImageFilterBaseIVF43IVF43_New():
  return itkPadImageFilterBaseIVF43IVF43.New()


def itkPadImageFilterBaseIVF42IVF42_New():
  return itkPadImageFilterBaseIVF42IVF42.New()


def itkPadImageFilterBaseIVF33IVF33_New():
  return itkPadImageFilterBaseIVF33IVF33.New()


def itkPadImageFilterBaseIVF32IVF32_New():
  return itkPadImageFilterBaseIVF32IVF32.New()


def itkPadImageFilterBaseIVF23IVF23_New():
  return itkPadImageFilterBaseIVF23IVF23.New()


def itkPadImageFilterBaseIVF22IVF22_New():
  return itkPadImageFilterBaseIVF22IVF22.New()


def itkPadImageFilterBaseIRGBAUC3IRGBAUC3_New():
  return itkPadImageFilterBaseIRGBAUC3IRGBAUC3.New()


def itkPadImageFilterBaseIRGBAUC2IRGBAUC2_New():
  return itkPadImageFilterBaseIRGBAUC2IRGBAUC2.New()


def itkPadImageFilterBaseIRGBUC3IRGBUC3_New():
  return itkPadImageFilterBaseIRGBUC3IRGBUC3.New()


def itkPadImageFilterBaseIRGBUC2IRGBUC2_New():
  return itkPadImageFilterBaseIRGBUC2IRGBUC2.New()

class itkPadImageFilterBaseICF2ICF2(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
    __New_orig__ = _swig_new_static_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseICF2ICF2___New_orig__)
    Clone = _swig_new_instance_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseICF2ICF2_Clone)
    SetBoundaryCondition = _swig_new_instance_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseICF2ICF2_SetBoundaryCondition)
    GetBoundaryCondition = _swig_new_instance_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseICF2ICF2_GetBoundaryCondition)
    __swig_destroy__ = _itkPadImageFilterBasePython.delete_itkPadImageFilterBaseICF2ICF2
    cast = _swig_new_static_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseICF2ICF2_cast)
    GetPointer = _swig_new_instance_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseICF2ICF2_GetPointer)

    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__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkPadImageFilterBaseICF2ICF2 in _itkPadImageFilterBasePython:
_itkPadImageFilterBasePython.itkPadImageFilterBaseICF2ICF2_swigregister(itkPadImageFilterBaseICF2ICF2)
class itkPadImageFilterBaseICF3ICF3(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
    __New_orig__ = _swig_new_static_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseICF3ICF3___New_orig__)
    Clone = _swig_new_instance_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseICF3ICF3_Clone)
    SetBoundaryCondition = _swig_new_instance_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseICF3ICF3_SetBoundaryCondition)
    GetBoundaryCondition = _swig_new_instance_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseICF3ICF3_GetBoundaryCondition)
    __swig_destroy__ = _itkPadImageFilterBasePython.delete_itkPadImageFilterBaseICF3ICF3
    cast = _swig_new_static_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseICF3ICF3_cast)
    GetPointer = _swig_new_instance_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseICF3ICF3_GetPointer)

    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__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkPadImageFilterBaseICF3ICF3 in _itkPadImageFilterBasePython:
_itkPadImageFilterBasePython.itkPadImageFilterBaseICF3ICF3_swigregister(itkPadImageFilterBaseICF3ICF3)
class itkPadImageFilterBaseICVF22ICVF22(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
    __New_orig__ = _swig_new_static_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseICVF22ICVF22___New_orig__)
    Clone = _swig_new_instance_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseICVF22ICVF22_Clone)
    SetBoundaryCondition = _swig_new_instance_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseICVF22ICVF22_SetBoundaryCondition)
    GetBoundaryCondition = _swig_new_instance_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseICVF22ICVF22_GetBoundaryCondition)
    __swig_destroy__ = _itkPadImageFilterBasePython.delete_itkPadImageFilterBaseICVF22ICVF22
    cast = _swig_new_static_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseICVF22ICVF22_cast)
    GetPointer = _swig_new_instance_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseICVF22ICVF22_GetPointer)

    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__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkPadImageFilterBaseICVF22ICVF22 in _itkPadImageFilterBasePython:
_itkPadImageFilterBasePython.itkPadImageFilterBaseICVF22ICVF22_swigregister(itkPadImageFilterBaseICVF22ICVF22)
class itkPadImageFilterBaseICVF23ICVF23(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
    __New_orig__ = _swig_new_static_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseICVF23ICVF23___New_orig__)
    Clone = _swig_new_instance_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseICVF23ICVF23_Clone)
    SetBoundaryCondition = _swig_new_instance_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseICVF23ICVF23_SetBoundaryCondition)
    GetBoundaryCondition = _swig_new_instance_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseICVF23ICVF23_GetBoundaryCondition)
    __swig_destroy__ = _itkPadImageFilterBasePython.delete_itkPadImageFilterBaseICVF23ICVF23
    cast = _swig_new_static_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseICVF23ICVF23_cast)
    GetPointer = _swig_new_instance_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseICVF23ICVF23_GetPointer)

    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__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkPadImageFilterBaseICVF23ICVF23 in _itkPadImageFilterBasePython:
_itkPadImageFilterBasePython.itkPadImageFilterBaseICVF23ICVF23_swigregister(itkPadImageFilterBaseICVF23ICVF23)
class itkPadImageFilterBaseICVF32ICVF32(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
    __New_orig__ = _swig_new_static_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseICVF32ICVF32___New_orig__)
    Clone = _swig_new_instance_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseICVF32ICVF32_Clone)
    SetBoundaryCondition = _swig_new_instance_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseICVF32ICVF32_SetBoundaryCondition)
    GetBoundaryCondition = _swig_new_instance_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseICVF32ICVF32_GetBoundaryCondition)
    __swig_destroy__ = _itkPadImageFilterBasePython.delete_itkPadImageFilterBaseICVF32ICVF32
    cast = _swig_new_static_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseICVF32ICVF32_cast)
    GetPointer = _swig_new_instance_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseICVF32ICVF32_GetPointer)

    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__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkPadImageFilterBaseICVF32ICVF32 in _itkPadImageFilterBasePython:
_itkPadImageFilterBasePython.itkPadImageFilterBaseICVF32ICVF32_swigregister(itkPadImageFilterBaseICVF32ICVF32)
class itkPadImageFilterBaseICVF33ICVF33(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
    __New_orig__ = _swig_new_static_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseICVF33ICVF33___New_orig__)
    Clone = _swig_new_instance_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseICVF33ICVF33_Clone)
    SetBoundaryCondition = _swig_new_instance_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseICVF33ICVF33_SetBoundaryCondition)
    GetBoundaryCondition = _swig_new_instance_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseICVF33ICVF33_GetBoundaryCondition)
    __swig_destroy__ = _itkPadImageFilterBasePython.delete_itkPadImageFilterBaseICVF33ICVF33
    cast = _swig_new_static_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseICVF33ICVF33_cast)
    GetPointer = _swig_new_instance_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseICVF33ICVF33_GetPointer)

    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__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkPadImageFilterBaseICVF33ICVF33 in _itkPadImageFilterBasePython:
_itkPadImageFilterBasePython.itkPadImageFilterBaseICVF33ICVF33_swigregister(itkPadImageFilterBaseICVF33ICVF33)
class itkPadImageFilterBaseICVF42ICVF42(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
    __New_orig__ = _swig_new_static_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseICVF42ICVF42___New_orig__)
    Clone = _swig_new_instance_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseICVF42ICVF42_Clone)
    SetBoundaryCondition = _swig_new_instance_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseICVF42ICVF42_SetBoundaryCondition)
    GetBoundaryCondition = _swig_new_instance_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseICVF42ICVF42_GetBoundaryCondition)
    __swig_destroy__ = _itkPadImageFilterBasePython.delete_itkPadImageFilterBaseICVF42ICVF42
    cast = _swig_new_static_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseICVF42ICVF42_cast)
    GetPointer = _swig_new_instance_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseICVF42ICVF42_GetPointer)

    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__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkPadImageFilterBaseICVF42ICVF42 in _itkPadImageFilterBasePython:
_itkPadImageFilterBasePython.itkPadImageFilterBaseICVF42ICVF42_swigregister(itkPadImageFilterBaseICVF42ICVF42)
class itkPadImageFilterBaseICVF43ICVF43(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
    __New_orig__ = _swig_new_static_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseICVF43ICVF43___New_orig__)
    Clone = _swig_new_instance_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseICVF43ICVF43_Clone)
    SetBoundaryCondition = _swig_new_instance_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseICVF43ICVF43_SetBoundaryCondition)
    GetBoundaryCondition = _swig_new_instance_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseICVF43ICVF43_GetBoundaryCondition)
    __swig_destroy__ = _itkPadImageFilterBasePython.delete_itkPadImageFilterBaseICVF43ICVF43
    cast = _swig_new_static_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseICVF43ICVF43_cast)
    GetPointer = _swig_new_instance_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseICVF43ICVF43_GetPointer)

    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__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkPadImageFilterBaseICVF43ICVF43 in _itkPadImageFilterBasePython:
_itkPadImageFilterBasePython.itkPadImageFilterBaseICVF43ICVF43_swigregister(itkPadImageFilterBaseICVF43ICVF43)
class itkPadImageFilterBaseIF2IF2(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
    __New_orig__ = _swig_new_static_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseIF2IF2___New_orig__)
    Clone = _swig_new_instance_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseIF2IF2_Clone)
    SetBoundaryCondition = _swig_new_instance_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseIF2IF2_SetBoundaryCondition)
    GetBoundaryCondition = _swig_new_instance_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseIF2IF2_GetBoundaryCondition)
    __swig_destroy__ = _itkPadImageFilterBasePython.delete_itkPadImageFilterBaseIF2IF2
    cast = _swig_new_static_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseIF2IF2_cast)
    GetPointer = _swig_new_instance_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseIF2IF2_GetPointer)

    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__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkPadImageFilterBaseIF2IF2 in _itkPadImageFilterBasePython:
_itkPadImageFilterBasePython.itkPadImageFilterBaseIF2IF2_swigregister(itkPadImageFilterBaseIF2IF2)
class itkPadImageFilterBaseIF3IF3(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
    __New_orig__ = _swig_new_static_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseIF3IF3___New_orig__)
    Clone = _swig_new_instance_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseIF3IF3_Clone)
    SetBoundaryCondition = _swig_new_instance_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseIF3IF3_SetBoundaryCondition)
    GetBoundaryCondition = _swig_new_instance_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseIF3IF3_GetBoundaryCondition)
    __swig_destroy__ = _itkPadImageFilterBasePython.delete_itkPadImageFilterBaseIF3IF3
    cast = _swig_new_static_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseIF3IF3_cast)
    GetPointer = _swig_new_instance_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseIF3IF3_GetPointer)

    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__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkPadImageFilterBaseIF3IF3 in _itkPadImageFilterBasePython:
_itkPadImageFilterBasePython.itkPadImageFilterBaseIF3IF3_swigregister(itkPadImageFilterBaseIF3IF3)
class itkPadImageFilterBaseIRGBAUC2IRGBAUC2(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
    __New_orig__ = _swig_new_static_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseIRGBAUC2IRGBAUC2___New_orig__)
    Clone = _swig_new_instance_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseIRGBAUC2IRGBAUC2_Clone)
    SetBoundaryCondition = _swig_new_instance_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseIRGBAUC2IRGBAUC2_SetBoundaryCondition)
    GetBoundaryCondition = _swig_new_instance_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseIRGBAUC2IRGBAUC2_GetBoundaryCondition)
    __swig_destroy__ = _itkPadImageFilterBasePython.delete_itkPadImageFilterBaseIRGBAUC2IRGBAUC2
    cast = _swig_new_static_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseIRGBAUC2IRGBAUC2_cast)
    GetPointer = _swig_new_instance_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseIRGBAUC2IRGBAUC2_GetPointer)

    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__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkPadImageFilterBaseIRGBAUC2IRGBAUC2 in _itkPadImageFilterBasePython:
_itkPadImageFilterBasePython.itkPadImageFilterBaseIRGBAUC2IRGBAUC2_swigregister(itkPadImageFilterBaseIRGBAUC2IRGBAUC2)
class itkPadImageFilterBaseIRGBAUC3IRGBAUC3(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
    __New_orig__ = _swig_new_static_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseIRGBAUC3IRGBAUC3___New_orig__)
    Clone = _swig_new_instance_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseIRGBAUC3IRGBAUC3_Clone)
    SetBoundaryCondition = _swig_new_instance_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseIRGBAUC3IRGBAUC3_SetBoundaryCondition)
    GetBoundaryCondition = _swig_new_instance_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseIRGBAUC3IRGBAUC3_GetBoundaryCondition)
    __swig_destroy__ = _itkPadImageFilterBasePython.delete_itkPadImageFilterBaseIRGBAUC3IRGBAUC3
    cast = _swig_new_static_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseIRGBAUC3IRGBAUC3_cast)
    GetPointer = _swig_new_instance_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseIRGBAUC3IRGBAUC3_GetPointer)

    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__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkPadImageFilterBaseIRGBAUC3IRGBAUC3 in _itkPadImageFilterBasePython:
_itkPadImageFilterBasePython.itkPadImageFilterBaseIRGBAUC3IRGBAUC3_swigregister(itkPadImageFilterBaseIRGBAUC3IRGBAUC3)
class itkPadImageFilterBaseIRGBUC2IRGBUC2(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
    __New_orig__ = _swig_new_static_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseIRGBUC2IRGBUC2___New_orig__)
    Clone = _swig_new_instance_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseIRGBUC2IRGBUC2_Clone)
    SetBoundaryCondition = _swig_new_instance_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseIRGBUC2IRGBUC2_SetBoundaryCondition)
    GetBoundaryCondition = _swig_new_instance_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseIRGBUC2IRGBUC2_GetBoundaryCondition)
    __swig_destroy__ = _itkPadImageFilterBasePython.delete_itkPadImageFilterBaseIRGBUC2IRGBUC2
    cast = _swig_new_static_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseIRGBUC2IRGBUC2_cast)
    GetPointer = _swig_new_instance_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseIRGBUC2IRGBUC2_GetPointer)

    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__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkPadImageFilterBaseIRGBUC2IRGBUC2 in _itkPadImageFilterBasePython:
_itkPadImageFilterBasePython.itkPadImageFilterBaseIRGBUC2IRGBUC2_swigregister(itkPadImageFilterBaseIRGBUC2IRGBUC2)
class itkPadImageFilterBaseIRGBUC3IRGBUC3(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
    __New_orig__ = _swig_new_static_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseIRGBUC3IRGBUC3___New_orig__)
    Clone = _swig_new_instance_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseIRGBUC3IRGBUC3_Clone)
    SetBoundaryCondition = _swig_new_instance_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseIRGBUC3IRGBUC3_SetBoundaryCondition)
    GetBoundaryCondition = _swig_new_instance_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseIRGBUC3IRGBUC3_GetBoundaryCondition)
    __swig_destroy__ = _itkPadImageFilterBasePython.delete_itkPadImageFilterBaseIRGBUC3IRGBUC3
    cast = _swig_new_static_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseIRGBUC3IRGBUC3_cast)
    GetPointer = _swig_new_instance_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseIRGBUC3IRGBUC3_GetPointer)

    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__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkPadImageFilterBaseIRGBUC3IRGBUC3 in _itkPadImageFilterBasePython:
_itkPadImageFilterBasePython.itkPadImageFilterBaseIRGBUC3IRGBUC3_swigregister(itkPadImageFilterBaseIRGBUC3IRGBUC3)
class itkPadImageFilterBaseISS2ISS2(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
    __New_orig__ = _swig_new_static_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseISS2ISS2___New_orig__)
    Clone = _swig_new_instance_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseISS2ISS2_Clone)
    SetBoundaryCondition = _swig_new_instance_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseISS2ISS2_SetBoundaryCondition)
    GetBoundaryCondition = _swig_new_instance_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseISS2ISS2_GetBoundaryCondition)
    __swig_destroy__ = _itkPadImageFilterBasePython.delete_itkPadImageFilterBaseISS2ISS2
    cast = _swig_new_static_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseISS2ISS2_cast)
    GetPointer = _swig_new_instance_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseISS2ISS2_GetPointer)

    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__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkPadImageFilterBaseISS2ISS2 in _itkPadImageFilterBasePython:
_itkPadImageFilterBasePython.itkPadImageFilterBaseISS2ISS2_swigregister(itkPadImageFilterBaseISS2ISS2)
class itkPadImageFilterBaseISS3ISS3(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
    __New_orig__ = _swig_new_static_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseISS3ISS3___New_orig__)
    Clone = _swig_new_instance_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseISS3ISS3_Clone)
    SetBoundaryCondition = _swig_new_instance_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseISS3ISS3_SetBoundaryCondition)
    GetBoundaryCondition = _swig_new_instance_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseISS3ISS3_GetBoundaryCondition)
    __swig_destroy__ = _itkPadImageFilterBasePython.delete_itkPadImageFilterBaseISS3ISS3
    cast = _swig_new_static_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseISS3ISS3_cast)
    GetPointer = _swig_new_instance_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseISS3ISS3_GetPointer)

    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__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkPadImageFilterBaseISS3ISS3 in _itkPadImageFilterBasePython:
_itkPadImageFilterBasePython.itkPadImageFilterBaseISS3ISS3_swigregister(itkPadImageFilterBaseISS3ISS3)
class itkPadImageFilterBaseIUC2IUC2(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
    __New_orig__ = _swig_new_static_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseIUC2IUC2___New_orig__)
    Clone = _swig_new_instance_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseIUC2IUC2_Clone)
    SetBoundaryCondition = _swig_new_instance_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseIUC2IUC2_SetBoundaryCondition)
    GetBoundaryCondition = _swig_new_instance_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseIUC2IUC2_GetBoundaryCondition)
    __swig_destroy__ = _itkPadImageFilterBasePython.delete_itkPadImageFilterBaseIUC2IUC2
    cast = _swig_new_static_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseIUC2IUC2_cast)
    GetPointer = _swig_new_instance_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseIUC2IUC2_GetPointer)

    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__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkPadImageFilterBaseIUC2IUC2 in _itkPadImageFilterBasePython:
_itkPadImageFilterBasePython.itkPadImageFilterBaseIUC2IUC2_swigregister(itkPadImageFilterBaseIUC2IUC2)
class itkPadImageFilterBaseIUC3IUC3(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
    __New_orig__ = _swig_new_static_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseIUC3IUC3___New_orig__)
    Clone = _swig_new_instance_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseIUC3IUC3_Clone)
    SetBoundaryCondition = _swig_new_instance_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseIUC3IUC3_SetBoundaryCondition)
    GetBoundaryCondition = _swig_new_instance_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseIUC3IUC3_GetBoundaryCondition)
    __swig_destroy__ = _itkPadImageFilterBasePython.delete_itkPadImageFilterBaseIUC3IUC3
    cast = _swig_new_static_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseIUC3IUC3_cast)
    GetPointer = _swig_new_instance_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseIUC3IUC3_GetPointer)

    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__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkPadImageFilterBaseIUC3IUC3 in _itkPadImageFilterBasePython:
_itkPadImageFilterBasePython.itkPadImageFilterBaseIUC3IUC3_swigregister(itkPadImageFilterBaseIUC3IUC3)
class itkPadImageFilterBaseIVF22IVF22(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
    __New_orig__ = _swig_new_static_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseIVF22IVF22___New_orig__)
    Clone = _swig_new_instance_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseIVF22IVF22_Clone)
    SetBoundaryCondition = _swig_new_instance_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseIVF22IVF22_SetBoundaryCondition)
    GetBoundaryCondition = _swig_new_instance_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseIVF22IVF22_GetBoundaryCondition)
    __swig_destroy__ = _itkPadImageFilterBasePython.delete_itkPadImageFilterBaseIVF22IVF22
    cast = _swig_new_static_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseIVF22IVF22_cast)
    GetPointer = _swig_new_instance_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseIVF22IVF22_GetPointer)

    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__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkPadImageFilterBaseIVF22IVF22 in _itkPadImageFilterBasePython:
_itkPadImageFilterBasePython.itkPadImageFilterBaseIVF22IVF22_swigregister(itkPadImageFilterBaseIVF22IVF22)
class itkPadImageFilterBaseIVF23IVF23(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
    __New_orig__ = _swig_new_static_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseIVF23IVF23___New_orig__)
    Clone = _swig_new_instance_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseIVF23IVF23_Clone)
    SetBoundaryCondition = _swig_new_instance_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseIVF23IVF23_SetBoundaryCondition)
    GetBoundaryCondition = _swig_new_instance_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseIVF23IVF23_GetBoundaryCondition)
    __swig_destroy__ = _itkPadImageFilterBasePython.delete_itkPadImageFilterBaseIVF23IVF23
    cast = _swig_new_static_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseIVF23IVF23_cast)
    GetPointer = _swig_new_instance_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseIVF23IVF23_GetPointer)

    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__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkPadImageFilterBaseIVF23IVF23 in _itkPadImageFilterBasePython:
_itkPadImageFilterBasePython.itkPadImageFilterBaseIVF23IVF23_swigregister(itkPadImageFilterBaseIVF23IVF23)
class itkPadImageFilterBaseIVF32IVF32(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
    __New_orig__ = _swig_new_static_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseIVF32IVF32___New_orig__)
    Clone = _swig_new_instance_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseIVF32IVF32_Clone)
    SetBoundaryCondition = _swig_new_instance_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseIVF32IVF32_SetBoundaryCondition)
    GetBoundaryCondition = _swig_new_instance_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseIVF32IVF32_GetBoundaryCondition)
    __swig_destroy__ = _itkPadImageFilterBasePython.delete_itkPadImageFilterBaseIVF32IVF32
    cast = _swig_new_static_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseIVF32IVF32_cast)
    GetPointer = _swig_new_instance_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseIVF32IVF32_GetPointer)

    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__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkPadImageFilterBaseIVF32IVF32 in _itkPadImageFilterBasePython:
_itkPadImageFilterBasePython.itkPadImageFilterBaseIVF32IVF32_swigregister(itkPadImageFilterBaseIVF32IVF32)
class itkPadImageFilterBaseIVF33IVF33(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
    __New_orig__ = _swig_new_static_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseIVF33IVF33___New_orig__)
    Clone = _swig_new_instance_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseIVF33IVF33_Clone)
    SetBoundaryCondition = _swig_new_instance_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseIVF33IVF33_SetBoundaryCondition)
    GetBoundaryCondition = _swig_new_instance_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseIVF33IVF33_GetBoundaryCondition)
    __swig_destroy__ = _itkPadImageFilterBasePython.delete_itkPadImageFilterBaseIVF33IVF33
    cast = _swig_new_static_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseIVF33IVF33_cast)
    GetPointer = _swig_new_instance_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseIVF33IVF33_GetPointer)

    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__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkPadImageFilterBaseIVF33IVF33 in _itkPadImageFilterBasePython:
_itkPadImageFilterBasePython.itkPadImageFilterBaseIVF33IVF33_swigregister(itkPadImageFilterBaseIVF33IVF33)
class itkPadImageFilterBaseIVF42IVF42(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
    __New_orig__ = _swig_new_static_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseIVF42IVF42___New_orig__)
    Clone = _swig_new_instance_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseIVF42IVF42_Clone)
    SetBoundaryCondition = _swig_new_instance_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseIVF42IVF42_SetBoundaryCondition)
    GetBoundaryCondition = _swig_new_instance_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseIVF42IVF42_GetBoundaryCondition)
    __swig_destroy__ = _itkPadImageFilterBasePython.delete_itkPadImageFilterBaseIVF42IVF42
    cast = _swig_new_static_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseIVF42IVF42_cast)
    GetPointer = _swig_new_instance_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseIVF42IVF42_GetPointer)

    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__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkPadImageFilterBaseIVF42IVF42 in _itkPadImageFilterBasePython:
_itkPadImageFilterBasePython.itkPadImageFilterBaseIVF42IVF42_swigregister(itkPadImageFilterBaseIVF42IVF42)
class itkPadImageFilterBaseIVF43IVF43(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
    __New_orig__ = _swig_new_static_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseIVF43IVF43___New_orig__)
    Clone = _swig_new_instance_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseIVF43IVF43_Clone)
    SetBoundaryCondition = _swig_new_instance_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseIVF43IVF43_SetBoundaryCondition)
    GetBoundaryCondition = _swig_new_instance_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseIVF43IVF43_GetBoundaryCondition)
    __swig_destroy__ = _itkPadImageFilterBasePython.delete_itkPadImageFilterBaseIVF43IVF43
    cast = _swig_new_static_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseIVF43IVF43_cast)
    GetPointer = _swig_new_instance_method(_itkPadImageFilterBasePython.itkPadImageFilterBaseIVF43IVF43_GetPointer)

    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__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


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

