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

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

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

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

def itkPadImageFilterICF3ICF3_New():
  return itkPadImageFilterICF3ICF3.New()


def itkPadImageFilterICF2ICF2_New():
  return itkPadImageFilterICF2ICF2.New()


def itkPadImageFilterIF3IF3_New():
  return itkPadImageFilterIF3IF3.New()


def itkPadImageFilterIF2IF2_New():
  return itkPadImageFilterIF2IF2.New()


def itkPadImageFilterIUC3IUC3_New():
  return itkPadImageFilterIUC3IUC3.New()


def itkPadImageFilterIUC2IUC2_New():
  return itkPadImageFilterIUC2IUC2.New()


def itkPadImageFilterISS3ISS3_New():
  return itkPadImageFilterISS3ISS3.New()


def itkPadImageFilterISS2ISS2_New():
  return itkPadImageFilterISS2ISS2.New()


def itkPadImageFilterICVF43ICVF43_New():
  return itkPadImageFilterICVF43ICVF43.New()


def itkPadImageFilterICVF42ICVF42_New():
  return itkPadImageFilterICVF42ICVF42.New()


def itkPadImageFilterICVF33ICVF33_New():
  return itkPadImageFilterICVF33ICVF33.New()


def itkPadImageFilterICVF32ICVF32_New():
  return itkPadImageFilterICVF32ICVF32.New()


def itkPadImageFilterICVF23ICVF23_New():
  return itkPadImageFilterICVF23ICVF23.New()


def itkPadImageFilterICVF22ICVF22_New():
  return itkPadImageFilterICVF22ICVF22.New()


def itkPadImageFilterIVF43IVF43_New():
  return itkPadImageFilterIVF43IVF43.New()


def itkPadImageFilterIVF42IVF42_New():
  return itkPadImageFilterIVF42IVF42.New()


def itkPadImageFilterIVF33IVF33_New():
  return itkPadImageFilterIVF33IVF33.New()


def itkPadImageFilterIVF32IVF32_New():
  return itkPadImageFilterIVF32IVF32.New()


def itkPadImageFilterIVF23IVF23_New():
  return itkPadImageFilterIVF23IVF23.New()


def itkPadImageFilterIVF22IVF22_New():
  return itkPadImageFilterIVF22IVF22.New()


def itkPadImageFilterIRGBAUC3IRGBAUC3_New():
  return itkPadImageFilterIRGBAUC3IRGBAUC3.New()


def itkPadImageFilterIRGBAUC2IRGBAUC2_New():
  return itkPadImageFilterIRGBAUC2IRGBAUC2.New()


def itkPadImageFilterIRGBUC3IRGBUC3_New():
  return itkPadImageFilterIRGBUC3IRGBUC3.New()


def itkPadImageFilterIRGBUC2IRGBUC2_New():
  return itkPadImageFilterIRGBUC2IRGBUC2.New()

class itkPadImageFilterICF2ICF2(itkPadImageFilterBasePython.itkPadImageFilterBaseICF2ICF2):
    r"""Proxy of C++ itkPadImageFilterICF2ICF2 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(_itkPadImageFilterPython.itkPadImageFilterICF2ICF2___New_orig__)
    Clone = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterICF2ICF2_Clone)
    GetPadLowerBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterICF2ICF2_GetPadLowerBound)
    GetPadUpperBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterICF2ICF2_GetPadUpperBound)
    SetPadLowerBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterICF2ICF2_SetPadLowerBound)
    SetPadUpperBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterICF2ICF2_SetPadUpperBound)
    SetPadBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterICF2ICF2_SetPadBound)
    __swig_destroy__ = _itkPadImageFilterPython.delete_itkPadImageFilterICF2ICF2
    cast = _swig_new_static_method(_itkPadImageFilterPython.itkPadImageFilterICF2ICF2_cast)
    GetPointer = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterICF2ICF2_GetPointer)

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

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

          itkPadImageFilterICF2ICF2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

          obj = itkPadImageFilterICF2ICF2.New()
          obj.SetInput( 0, reader.GetOutput() )
          obj.SetThreshold( 10 )
        """
        obj = itkPadImageFilterICF2ICF2.__New_orig__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkPadImageFilterICF2ICF2 in _itkPadImageFilterPython:
_itkPadImageFilterPython.itkPadImageFilterICF2ICF2_swigregister(itkPadImageFilterICF2ICF2)
class itkPadImageFilterICF3ICF3(itkPadImageFilterBasePython.itkPadImageFilterBaseICF3ICF3):
    r"""Proxy of C++ itkPadImageFilterICF3ICF3 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(_itkPadImageFilterPython.itkPadImageFilterICF3ICF3___New_orig__)
    Clone = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterICF3ICF3_Clone)
    GetPadLowerBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterICF3ICF3_GetPadLowerBound)
    GetPadUpperBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterICF3ICF3_GetPadUpperBound)
    SetPadLowerBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterICF3ICF3_SetPadLowerBound)
    SetPadUpperBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterICF3ICF3_SetPadUpperBound)
    SetPadBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterICF3ICF3_SetPadBound)
    __swig_destroy__ = _itkPadImageFilterPython.delete_itkPadImageFilterICF3ICF3
    cast = _swig_new_static_method(_itkPadImageFilterPython.itkPadImageFilterICF3ICF3_cast)
    GetPointer = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterICF3ICF3_GetPointer)

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

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

          itkPadImageFilterICF3ICF3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

          obj = itkPadImageFilterICF3ICF3.New()
          obj.SetInput( 0, reader.GetOutput() )
          obj.SetThreshold( 10 )
        """
        obj = itkPadImageFilterICF3ICF3.__New_orig__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkPadImageFilterICF3ICF3 in _itkPadImageFilterPython:
_itkPadImageFilterPython.itkPadImageFilterICF3ICF3_swigregister(itkPadImageFilterICF3ICF3)
class itkPadImageFilterICVF22ICVF22(itkPadImageFilterBasePython.itkPadImageFilterBaseICVF22ICVF22):
    r"""Proxy of C++ itkPadImageFilterICVF22ICVF22 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(_itkPadImageFilterPython.itkPadImageFilterICVF22ICVF22___New_orig__)
    Clone = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterICVF22ICVF22_Clone)
    GetPadLowerBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterICVF22ICVF22_GetPadLowerBound)
    GetPadUpperBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterICVF22ICVF22_GetPadUpperBound)
    SetPadLowerBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterICVF22ICVF22_SetPadLowerBound)
    SetPadUpperBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterICVF22ICVF22_SetPadUpperBound)
    SetPadBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterICVF22ICVF22_SetPadBound)
    __swig_destroy__ = _itkPadImageFilterPython.delete_itkPadImageFilterICVF22ICVF22
    cast = _swig_new_static_method(_itkPadImageFilterPython.itkPadImageFilterICVF22ICVF22_cast)
    GetPointer = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterICVF22ICVF22_GetPointer)

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

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

          itkPadImageFilterICVF22ICVF22.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

          obj = itkPadImageFilterICVF22ICVF22.New()
          obj.SetInput( 0, reader.GetOutput() )
          obj.SetThreshold( 10 )
        """
        obj = itkPadImageFilterICVF22ICVF22.__New_orig__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkPadImageFilterICVF22ICVF22 in _itkPadImageFilterPython:
_itkPadImageFilterPython.itkPadImageFilterICVF22ICVF22_swigregister(itkPadImageFilterICVF22ICVF22)
class itkPadImageFilterICVF23ICVF23(itkPadImageFilterBasePython.itkPadImageFilterBaseICVF23ICVF23):
    r"""Proxy of C++ itkPadImageFilterICVF23ICVF23 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(_itkPadImageFilterPython.itkPadImageFilterICVF23ICVF23___New_orig__)
    Clone = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterICVF23ICVF23_Clone)
    GetPadLowerBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterICVF23ICVF23_GetPadLowerBound)
    GetPadUpperBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterICVF23ICVF23_GetPadUpperBound)
    SetPadLowerBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterICVF23ICVF23_SetPadLowerBound)
    SetPadUpperBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterICVF23ICVF23_SetPadUpperBound)
    SetPadBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterICVF23ICVF23_SetPadBound)
    __swig_destroy__ = _itkPadImageFilterPython.delete_itkPadImageFilterICVF23ICVF23
    cast = _swig_new_static_method(_itkPadImageFilterPython.itkPadImageFilterICVF23ICVF23_cast)
    GetPointer = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterICVF23ICVF23_GetPointer)

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

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

          itkPadImageFilterICVF23ICVF23.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

          obj = itkPadImageFilterICVF23ICVF23.New()
          obj.SetInput( 0, reader.GetOutput() )
          obj.SetThreshold( 10 )
        """
        obj = itkPadImageFilterICVF23ICVF23.__New_orig__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkPadImageFilterICVF23ICVF23 in _itkPadImageFilterPython:
_itkPadImageFilterPython.itkPadImageFilterICVF23ICVF23_swigregister(itkPadImageFilterICVF23ICVF23)
class itkPadImageFilterICVF32ICVF32(itkPadImageFilterBasePython.itkPadImageFilterBaseICVF32ICVF32):
    r"""Proxy of C++ itkPadImageFilterICVF32ICVF32 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(_itkPadImageFilterPython.itkPadImageFilterICVF32ICVF32___New_orig__)
    Clone = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterICVF32ICVF32_Clone)
    GetPadLowerBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterICVF32ICVF32_GetPadLowerBound)
    GetPadUpperBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterICVF32ICVF32_GetPadUpperBound)
    SetPadLowerBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterICVF32ICVF32_SetPadLowerBound)
    SetPadUpperBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterICVF32ICVF32_SetPadUpperBound)
    SetPadBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterICVF32ICVF32_SetPadBound)
    __swig_destroy__ = _itkPadImageFilterPython.delete_itkPadImageFilterICVF32ICVF32
    cast = _swig_new_static_method(_itkPadImageFilterPython.itkPadImageFilterICVF32ICVF32_cast)
    GetPointer = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterICVF32ICVF32_GetPointer)

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

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

          itkPadImageFilterICVF32ICVF32.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

          obj = itkPadImageFilterICVF32ICVF32.New()
          obj.SetInput( 0, reader.GetOutput() )
          obj.SetThreshold( 10 )
        """
        obj = itkPadImageFilterICVF32ICVF32.__New_orig__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkPadImageFilterICVF32ICVF32 in _itkPadImageFilterPython:
_itkPadImageFilterPython.itkPadImageFilterICVF32ICVF32_swigregister(itkPadImageFilterICVF32ICVF32)
class itkPadImageFilterICVF33ICVF33(itkPadImageFilterBasePython.itkPadImageFilterBaseICVF33ICVF33):
    r"""Proxy of C++ itkPadImageFilterICVF33ICVF33 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(_itkPadImageFilterPython.itkPadImageFilterICVF33ICVF33___New_orig__)
    Clone = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterICVF33ICVF33_Clone)
    GetPadLowerBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterICVF33ICVF33_GetPadLowerBound)
    GetPadUpperBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterICVF33ICVF33_GetPadUpperBound)
    SetPadLowerBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterICVF33ICVF33_SetPadLowerBound)
    SetPadUpperBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterICVF33ICVF33_SetPadUpperBound)
    SetPadBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterICVF33ICVF33_SetPadBound)
    __swig_destroy__ = _itkPadImageFilterPython.delete_itkPadImageFilterICVF33ICVF33
    cast = _swig_new_static_method(_itkPadImageFilterPython.itkPadImageFilterICVF33ICVF33_cast)
    GetPointer = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterICVF33ICVF33_GetPointer)

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

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

          itkPadImageFilterICVF33ICVF33.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

          obj = itkPadImageFilterICVF33ICVF33.New()
          obj.SetInput( 0, reader.GetOutput() )
          obj.SetThreshold( 10 )
        """
        obj = itkPadImageFilterICVF33ICVF33.__New_orig__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkPadImageFilterICVF33ICVF33 in _itkPadImageFilterPython:
_itkPadImageFilterPython.itkPadImageFilterICVF33ICVF33_swigregister(itkPadImageFilterICVF33ICVF33)
class itkPadImageFilterICVF42ICVF42(itkPadImageFilterBasePython.itkPadImageFilterBaseICVF42ICVF42):
    r"""Proxy of C++ itkPadImageFilterICVF42ICVF42 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(_itkPadImageFilterPython.itkPadImageFilterICVF42ICVF42___New_orig__)
    Clone = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterICVF42ICVF42_Clone)
    GetPadLowerBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterICVF42ICVF42_GetPadLowerBound)
    GetPadUpperBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterICVF42ICVF42_GetPadUpperBound)
    SetPadLowerBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterICVF42ICVF42_SetPadLowerBound)
    SetPadUpperBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterICVF42ICVF42_SetPadUpperBound)
    SetPadBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterICVF42ICVF42_SetPadBound)
    __swig_destroy__ = _itkPadImageFilterPython.delete_itkPadImageFilterICVF42ICVF42
    cast = _swig_new_static_method(_itkPadImageFilterPython.itkPadImageFilterICVF42ICVF42_cast)
    GetPointer = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterICVF42ICVF42_GetPointer)

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

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

          itkPadImageFilterICVF42ICVF42.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

          obj = itkPadImageFilterICVF42ICVF42.New()
          obj.SetInput( 0, reader.GetOutput() )
          obj.SetThreshold( 10 )
        """
        obj = itkPadImageFilterICVF42ICVF42.__New_orig__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkPadImageFilterICVF42ICVF42 in _itkPadImageFilterPython:
_itkPadImageFilterPython.itkPadImageFilterICVF42ICVF42_swigregister(itkPadImageFilterICVF42ICVF42)
class itkPadImageFilterICVF43ICVF43(itkPadImageFilterBasePython.itkPadImageFilterBaseICVF43ICVF43):
    r"""Proxy of C++ itkPadImageFilterICVF43ICVF43 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(_itkPadImageFilterPython.itkPadImageFilterICVF43ICVF43___New_orig__)
    Clone = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterICVF43ICVF43_Clone)
    GetPadLowerBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterICVF43ICVF43_GetPadLowerBound)
    GetPadUpperBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterICVF43ICVF43_GetPadUpperBound)
    SetPadLowerBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterICVF43ICVF43_SetPadLowerBound)
    SetPadUpperBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterICVF43ICVF43_SetPadUpperBound)
    SetPadBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterICVF43ICVF43_SetPadBound)
    __swig_destroy__ = _itkPadImageFilterPython.delete_itkPadImageFilterICVF43ICVF43
    cast = _swig_new_static_method(_itkPadImageFilterPython.itkPadImageFilterICVF43ICVF43_cast)
    GetPointer = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterICVF43ICVF43_GetPointer)

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

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

          itkPadImageFilterICVF43ICVF43.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

          obj = itkPadImageFilterICVF43ICVF43.New()
          obj.SetInput( 0, reader.GetOutput() )
          obj.SetThreshold( 10 )
        """
        obj = itkPadImageFilterICVF43ICVF43.__New_orig__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkPadImageFilterICVF43ICVF43 in _itkPadImageFilterPython:
_itkPadImageFilterPython.itkPadImageFilterICVF43ICVF43_swigregister(itkPadImageFilterICVF43ICVF43)
class itkPadImageFilterIF2IF2(itkPadImageFilterBasePython.itkPadImageFilterBaseIF2IF2):
    r"""Proxy of C++ itkPadImageFilterIF2IF2 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(_itkPadImageFilterPython.itkPadImageFilterIF2IF2___New_orig__)
    Clone = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterIF2IF2_Clone)
    GetPadLowerBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterIF2IF2_GetPadLowerBound)
    GetPadUpperBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterIF2IF2_GetPadUpperBound)
    SetPadLowerBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterIF2IF2_SetPadLowerBound)
    SetPadUpperBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterIF2IF2_SetPadUpperBound)
    SetPadBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterIF2IF2_SetPadBound)
    __swig_destroy__ = _itkPadImageFilterPython.delete_itkPadImageFilterIF2IF2
    cast = _swig_new_static_method(_itkPadImageFilterPython.itkPadImageFilterIF2IF2_cast)
    GetPointer = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterIF2IF2_GetPointer)

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

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

          itkPadImageFilterIF2IF2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

          obj = itkPadImageFilterIF2IF2.New()
          obj.SetInput( 0, reader.GetOutput() )
          obj.SetThreshold( 10 )
        """
        obj = itkPadImageFilterIF2IF2.__New_orig__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkPadImageFilterIF2IF2 in _itkPadImageFilterPython:
_itkPadImageFilterPython.itkPadImageFilterIF2IF2_swigregister(itkPadImageFilterIF2IF2)
class itkPadImageFilterIF3IF3(itkPadImageFilterBasePython.itkPadImageFilterBaseIF3IF3):
    r"""Proxy of C++ itkPadImageFilterIF3IF3 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(_itkPadImageFilterPython.itkPadImageFilterIF3IF3___New_orig__)
    Clone = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterIF3IF3_Clone)
    GetPadLowerBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterIF3IF3_GetPadLowerBound)
    GetPadUpperBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterIF3IF3_GetPadUpperBound)
    SetPadLowerBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterIF3IF3_SetPadLowerBound)
    SetPadUpperBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterIF3IF3_SetPadUpperBound)
    SetPadBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterIF3IF3_SetPadBound)
    __swig_destroy__ = _itkPadImageFilterPython.delete_itkPadImageFilterIF3IF3
    cast = _swig_new_static_method(_itkPadImageFilterPython.itkPadImageFilterIF3IF3_cast)
    GetPointer = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterIF3IF3_GetPointer)

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

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

          itkPadImageFilterIF3IF3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

          obj = itkPadImageFilterIF3IF3.New()
          obj.SetInput( 0, reader.GetOutput() )
          obj.SetThreshold( 10 )
        """
        obj = itkPadImageFilterIF3IF3.__New_orig__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkPadImageFilterIF3IF3 in _itkPadImageFilterPython:
_itkPadImageFilterPython.itkPadImageFilterIF3IF3_swigregister(itkPadImageFilterIF3IF3)
class itkPadImageFilterIRGBAUC2IRGBAUC2(itkPadImageFilterBasePython.itkPadImageFilterBaseIRGBAUC2IRGBAUC2):
    r"""Proxy of C++ itkPadImageFilterIRGBAUC2IRGBAUC2 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(_itkPadImageFilterPython.itkPadImageFilterIRGBAUC2IRGBAUC2___New_orig__)
    Clone = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterIRGBAUC2IRGBAUC2_Clone)
    GetPadLowerBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterIRGBAUC2IRGBAUC2_GetPadLowerBound)
    GetPadUpperBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterIRGBAUC2IRGBAUC2_GetPadUpperBound)
    SetPadLowerBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterIRGBAUC2IRGBAUC2_SetPadLowerBound)
    SetPadUpperBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterIRGBAUC2IRGBAUC2_SetPadUpperBound)
    SetPadBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterIRGBAUC2IRGBAUC2_SetPadBound)
    __swig_destroy__ = _itkPadImageFilterPython.delete_itkPadImageFilterIRGBAUC2IRGBAUC2
    cast = _swig_new_static_method(_itkPadImageFilterPython.itkPadImageFilterIRGBAUC2IRGBAUC2_cast)
    GetPointer = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterIRGBAUC2IRGBAUC2_GetPointer)

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

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

          itkPadImageFilterIRGBAUC2IRGBAUC2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

          obj = itkPadImageFilterIRGBAUC2IRGBAUC2.New()
          obj.SetInput( 0, reader.GetOutput() )
          obj.SetThreshold( 10 )
        """
        obj = itkPadImageFilterIRGBAUC2IRGBAUC2.__New_orig__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkPadImageFilterIRGBAUC2IRGBAUC2 in _itkPadImageFilterPython:
_itkPadImageFilterPython.itkPadImageFilterIRGBAUC2IRGBAUC2_swigregister(itkPadImageFilterIRGBAUC2IRGBAUC2)
class itkPadImageFilterIRGBAUC3IRGBAUC3(itkPadImageFilterBasePython.itkPadImageFilterBaseIRGBAUC3IRGBAUC3):
    r"""Proxy of C++ itkPadImageFilterIRGBAUC3IRGBAUC3 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(_itkPadImageFilterPython.itkPadImageFilterIRGBAUC3IRGBAUC3___New_orig__)
    Clone = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterIRGBAUC3IRGBAUC3_Clone)
    GetPadLowerBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterIRGBAUC3IRGBAUC3_GetPadLowerBound)
    GetPadUpperBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterIRGBAUC3IRGBAUC3_GetPadUpperBound)
    SetPadLowerBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterIRGBAUC3IRGBAUC3_SetPadLowerBound)
    SetPadUpperBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterIRGBAUC3IRGBAUC3_SetPadUpperBound)
    SetPadBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterIRGBAUC3IRGBAUC3_SetPadBound)
    __swig_destroy__ = _itkPadImageFilterPython.delete_itkPadImageFilterIRGBAUC3IRGBAUC3
    cast = _swig_new_static_method(_itkPadImageFilterPython.itkPadImageFilterIRGBAUC3IRGBAUC3_cast)
    GetPointer = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterIRGBAUC3IRGBAUC3_GetPointer)

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

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

          itkPadImageFilterIRGBAUC3IRGBAUC3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

          obj = itkPadImageFilterIRGBAUC3IRGBAUC3.New()
          obj.SetInput( 0, reader.GetOutput() )
          obj.SetThreshold( 10 )
        """
        obj = itkPadImageFilterIRGBAUC3IRGBAUC3.__New_orig__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkPadImageFilterIRGBAUC3IRGBAUC3 in _itkPadImageFilterPython:
_itkPadImageFilterPython.itkPadImageFilterIRGBAUC3IRGBAUC3_swigregister(itkPadImageFilterIRGBAUC3IRGBAUC3)
class itkPadImageFilterIRGBUC2IRGBUC2(itkPadImageFilterBasePython.itkPadImageFilterBaseIRGBUC2IRGBUC2):
    r"""Proxy of C++ itkPadImageFilterIRGBUC2IRGBUC2 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(_itkPadImageFilterPython.itkPadImageFilterIRGBUC2IRGBUC2___New_orig__)
    Clone = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterIRGBUC2IRGBUC2_Clone)
    GetPadLowerBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterIRGBUC2IRGBUC2_GetPadLowerBound)
    GetPadUpperBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterIRGBUC2IRGBUC2_GetPadUpperBound)
    SetPadLowerBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterIRGBUC2IRGBUC2_SetPadLowerBound)
    SetPadUpperBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterIRGBUC2IRGBUC2_SetPadUpperBound)
    SetPadBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterIRGBUC2IRGBUC2_SetPadBound)
    __swig_destroy__ = _itkPadImageFilterPython.delete_itkPadImageFilterIRGBUC2IRGBUC2
    cast = _swig_new_static_method(_itkPadImageFilterPython.itkPadImageFilterIRGBUC2IRGBUC2_cast)
    GetPointer = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterIRGBUC2IRGBUC2_GetPointer)

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

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

          itkPadImageFilterIRGBUC2IRGBUC2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

          obj = itkPadImageFilterIRGBUC2IRGBUC2.New()
          obj.SetInput( 0, reader.GetOutput() )
          obj.SetThreshold( 10 )
        """
        obj = itkPadImageFilterIRGBUC2IRGBUC2.__New_orig__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkPadImageFilterIRGBUC2IRGBUC2 in _itkPadImageFilterPython:
_itkPadImageFilterPython.itkPadImageFilterIRGBUC2IRGBUC2_swigregister(itkPadImageFilterIRGBUC2IRGBUC2)
class itkPadImageFilterIRGBUC3IRGBUC3(itkPadImageFilterBasePython.itkPadImageFilterBaseIRGBUC3IRGBUC3):
    r"""Proxy of C++ itkPadImageFilterIRGBUC3IRGBUC3 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(_itkPadImageFilterPython.itkPadImageFilterIRGBUC3IRGBUC3___New_orig__)
    Clone = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterIRGBUC3IRGBUC3_Clone)
    GetPadLowerBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterIRGBUC3IRGBUC3_GetPadLowerBound)
    GetPadUpperBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterIRGBUC3IRGBUC3_GetPadUpperBound)
    SetPadLowerBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterIRGBUC3IRGBUC3_SetPadLowerBound)
    SetPadUpperBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterIRGBUC3IRGBUC3_SetPadUpperBound)
    SetPadBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterIRGBUC3IRGBUC3_SetPadBound)
    __swig_destroy__ = _itkPadImageFilterPython.delete_itkPadImageFilterIRGBUC3IRGBUC3
    cast = _swig_new_static_method(_itkPadImageFilterPython.itkPadImageFilterIRGBUC3IRGBUC3_cast)
    GetPointer = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterIRGBUC3IRGBUC3_GetPointer)

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

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

          itkPadImageFilterIRGBUC3IRGBUC3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

          obj = itkPadImageFilterIRGBUC3IRGBUC3.New()
          obj.SetInput( 0, reader.GetOutput() )
          obj.SetThreshold( 10 )
        """
        obj = itkPadImageFilterIRGBUC3IRGBUC3.__New_orig__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkPadImageFilterIRGBUC3IRGBUC3 in _itkPadImageFilterPython:
_itkPadImageFilterPython.itkPadImageFilterIRGBUC3IRGBUC3_swigregister(itkPadImageFilterIRGBUC3IRGBUC3)
class itkPadImageFilterISS2ISS2(itkPadImageFilterBasePython.itkPadImageFilterBaseISS2ISS2):
    r"""Proxy of C++ itkPadImageFilterISS2ISS2 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(_itkPadImageFilterPython.itkPadImageFilterISS2ISS2___New_orig__)
    Clone = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterISS2ISS2_Clone)
    GetPadLowerBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterISS2ISS2_GetPadLowerBound)
    GetPadUpperBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterISS2ISS2_GetPadUpperBound)
    SetPadLowerBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterISS2ISS2_SetPadLowerBound)
    SetPadUpperBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterISS2ISS2_SetPadUpperBound)
    SetPadBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterISS2ISS2_SetPadBound)
    __swig_destroy__ = _itkPadImageFilterPython.delete_itkPadImageFilterISS2ISS2
    cast = _swig_new_static_method(_itkPadImageFilterPython.itkPadImageFilterISS2ISS2_cast)
    GetPointer = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterISS2ISS2_GetPointer)

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

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

          itkPadImageFilterISS2ISS2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

          obj = itkPadImageFilterISS2ISS2.New()
          obj.SetInput( 0, reader.GetOutput() )
          obj.SetThreshold( 10 )
        """
        obj = itkPadImageFilterISS2ISS2.__New_orig__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkPadImageFilterISS2ISS2 in _itkPadImageFilterPython:
_itkPadImageFilterPython.itkPadImageFilterISS2ISS2_swigregister(itkPadImageFilterISS2ISS2)
class itkPadImageFilterISS3ISS3(itkPadImageFilterBasePython.itkPadImageFilterBaseISS3ISS3):
    r"""Proxy of C++ itkPadImageFilterISS3ISS3 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(_itkPadImageFilterPython.itkPadImageFilterISS3ISS3___New_orig__)
    Clone = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterISS3ISS3_Clone)
    GetPadLowerBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterISS3ISS3_GetPadLowerBound)
    GetPadUpperBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterISS3ISS3_GetPadUpperBound)
    SetPadLowerBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterISS3ISS3_SetPadLowerBound)
    SetPadUpperBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterISS3ISS3_SetPadUpperBound)
    SetPadBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterISS3ISS3_SetPadBound)
    __swig_destroy__ = _itkPadImageFilterPython.delete_itkPadImageFilterISS3ISS3
    cast = _swig_new_static_method(_itkPadImageFilterPython.itkPadImageFilterISS3ISS3_cast)
    GetPointer = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterISS3ISS3_GetPointer)

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

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

          itkPadImageFilterISS3ISS3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

          obj = itkPadImageFilterISS3ISS3.New()
          obj.SetInput( 0, reader.GetOutput() )
          obj.SetThreshold( 10 )
        """
        obj = itkPadImageFilterISS3ISS3.__New_orig__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkPadImageFilterISS3ISS3 in _itkPadImageFilterPython:
_itkPadImageFilterPython.itkPadImageFilterISS3ISS3_swigregister(itkPadImageFilterISS3ISS3)
class itkPadImageFilterIUC2IUC2(itkPadImageFilterBasePython.itkPadImageFilterBaseIUC2IUC2):
    r"""Proxy of C++ itkPadImageFilterIUC2IUC2 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(_itkPadImageFilterPython.itkPadImageFilterIUC2IUC2___New_orig__)
    Clone = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterIUC2IUC2_Clone)
    GetPadLowerBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterIUC2IUC2_GetPadLowerBound)
    GetPadUpperBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterIUC2IUC2_GetPadUpperBound)
    SetPadLowerBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterIUC2IUC2_SetPadLowerBound)
    SetPadUpperBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterIUC2IUC2_SetPadUpperBound)
    SetPadBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterIUC2IUC2_SetPadBound)
    __swig_destroy__ = _itkPadImageFilterPython.delete_itkPadImageFilterIUC2IUC2
    cast = _swig_new_static_method(_itkPadImageFilterPython.itkPadImageFilterIUC2IUC2_cast)
    GetPointer = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterIUC2IUC2_GetPointer)

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

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

          itkPadImageFilterIUC2IUC2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

          obj = itkPadImageFilterIUC2IUC2.New()
          obj.SetInput( 0, reader.GetOutput() )
          obj.SetThreshold( 10 )
        """
        obj = itkPadImageFilterIUC2IUC2.__New_orig__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkPadImageFilterIUC2IUC2 in _itkPadImageFilterPython:
_itkPadImageFilterPython.itkPadImageFilterIUC2IUC2_swigregister(itkPadImageFilterIUC2IUC2)
class itkPadImageFilterIUC3IUC3(itkPadImageFilterBasePython.itkPadImageFilterBaseIUC3IUC3):
    r"""Proxy of C++ itkPadImageFilterIUC3IUC3 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(_itkPadImageFilterPython.itkPadImageFilterIUC3IUC3___New_orig__)
    Clone = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterIUC3IUC3_Clone)
    GetPadLowerBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterIUC3IUC3_GetPadLowerBound)
    GetPadUpperBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterIUC3IUC3_GetPadUpperBound)
    SetPadLowerBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterIUC3IUC3_SetPadLowerBound)
    SetPadUpperBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterIUC3IUC3_SetPadUpperBound)
    SetPadBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterIUC3IUC3_SetPadBound)
    __swig_destroy__ = _itkPadImageFilterPython.delete_itkPadImageFilterIUC3IUC3
    cast = _swig_new_static_method(_itkPadImageFilterPython.itkPadImageFilterIUC3IUC3_cast)
    GetPointer = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterIUC3IUC3_GetPointer)

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

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

          itkPadImageFilterIUC3IUC3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

          obj = itkPadImageFilterIUC3IUC3.New()
          obj.SetInput( 0, reader.GetOutput() )
          obj.SetThreshold( 10 )
        """
        obj = itkPadImageFilterIUC3IUC3.__New_orig__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkPadImageFilterIUC3IUC3 in _itkPadImageFilterPython:
_itkPadImageFilterPython.itkPadImageFilterIUC3IUC3_swigregister(itkPadImageFilterIUC3IUC3)
class itkPadImageFilterIVF22IVF22(itkPadImageFilterBasePython.itkPadImageFilterBaseIVF22IVF22):
    r"""Proxy of C++ itkPadImageFilterIVF22IVF22 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(_itkPadImageFilterPython.itkPadImageFilterIVF22IVF22___New_orig__)
    Clone = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterIVF22IVF22_Clone)
    GetPadLowerBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterIVF22IVF22_GetPadLowerBound)
    GetPadUpperBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterIVF22IVF22_GetPadUpperBound)
    SetPadLowerBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterIVF22IVF22_SetPadLowerBound)
    SetPadUpperBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterIVF22IVF22_SetPadUpperBound)
    SetPadBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterIVF22IVF22_SetPadBound)
    __swig_destroy__ = _itkPadImageFilterPython.delete_itkPadImageFilterIVF22IVF22
    cast = _swig_new_static_method(_itkPadImageFilterPython.itkPadImageFilterIVF22IVF22_cast)
    GetPointer = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterIVF22IVF22_GetPointer)

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

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

          itkPadImageFilterIVF22IVF22.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

          obj = itkPadImageFilterIVF22IVF22.New()
          obj.SetInput( 0, reader.GetOutput() )
          obj.SetThreshold( 10 )
        """
        obj = itkPadImageFilterIVF22IVF22.__New_orig__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkPadImageFilterIVF22IVF22 in _itkPadImageFilterPython:
_itkPadImageFilterPython.itkPadImageFilterIVF22IVF22_swigregister(itkPadImageFilterIVF22IVF22)
class itkPadImageFilterIVF23IVF23(itkPadImageFilterBasePython.itkPadImageFilterBaseIVF23IVF23):
    r"""Proxy of C++ itkPadImageFilterIVF23IVF23 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(_itkPadImageFilterPython.itkPadImageFilterIVF23IVF23___New_orig__)
    Clone = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterIVF23IVF23_Clone)
    GetPadLowerBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterIVF23IVF23_GetPadLowerBound)
    GetPadUpperBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterIVF23IVF23_GetPadUpperBound)
    SetPadLowerBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterIVF23IVF23_SetPadLowerBound)
    SetPadUpperBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterIVF23IVF23_SetPadUpperBound)
    SetPadBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterIVF23IVF23_SetPadBound)
    __swig_destroy__ = _itkPadImageFilterPython.delete_itkPadImageFilterIVF23IVF23
    cast = _swig_new_static_method(_itkPadImageFilterPython.itkPadImageFilterIVF23IVF23_cast)
    GetPointer = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterIVF23IVF23_GetPointer)

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

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

          itkPadImageFilterIVF23IVF23.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

          obj = itkPadImageFilterIVF23IVF23.New()
          obj.SetInput( 0, reader.GetOutput() )
          obj.SetThreshold( 10 )
        """
        obj = itkPadImageFilterIVF23IVF23.__New_orig__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkPadImageFilterIVF23IVF23 in _itkPadImageFilterPython:
_itkPadImageFilterPython.itkPadImageFilterIVF23IVF23_swigregister(itkPadImageFilterIVF23IVF23)
class itkPadImageFilterIVF32IVF32(itkPadImageFilterBasePython.itkPadImageFilterBaseIVF32IVF32):
    r"""Proxy of C++ itkPadImageFilterIVF32IVF32 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(_itkPadImageFilterPython.itkPadImageFilterIVF32IVF32___New_orig__)
    Clone = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterIVF32IVF32_Clone)
    GetPadLowerBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterIVF32IVF32_GetPadLowerBound)
    GetPadUpperBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterIVF32IVF32_GetPadUpperBound)
    SetPadLowerBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterIVF32IVF32_SetPadLowerBound)
    SetPadUpperBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterIVF32IVF32_SetPadUpperBound)
    SetPadBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterIVF32IVF32_SetPadBound)
    __swig_destroy__ = _itkPadImageFilterPython.delete_itkPadImageFilterIVF32IVF32
    cast = _swig_new_static_method(_itkPadImageFilterPython.itkPadImageFilterIVF32IVF32_cast)
    GetPointer = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterIVF32IVF32_GetPointer)

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

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

          itkPadImageFilterIVF32IVF32.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

          obj = itkPadImageFilterIVF32IVF32.New()
          obj.SetInput( 0, reader.GetOutput() )
          obj.SetThreshold( 10 )
        """
        obj = itkPadImageFilterIVF32IVF32.__New_orig__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkPadImageFilterIVF32IVF32 in _itkPadImageFilterPython:
_itkPadImageFilterPython.itkPadImageFilterIVF32IVF32_swigregister(itkPadImageFilterIVF32IVF32)
class itkPadImageFilterIVF33IVF33(itkPadImageFilterBasePython.itkPadImageFilterBaseIVF33IVF33):
    r"""Proxy of C++ itkPadImageFilterIVF33IVF33 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(_itkPadImageFilterPython.itkPadImageFilterIVF33IVF33___New_orig__)
    Clone = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterIVF33IVF33_Clone)
    GetPadLowerBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterIVF33IVF33_GetPadLowerBound)
    GetPadUpperBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterIVF33IVF33_GetPadUpperBound)
    SetPadLowerBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterIVF33IVF33_SetPadLowerBound)
    SetPadUpperBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterIVF33IVF33_SetPadUpperBound)
    SetPadBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterIVF33IVF33_SetPadBound)
    __swig_destroy__ = _itkPadImageFilterPython.delete_itkPadImageFilterIVF33IVF33
    cast = _swig_new_static_method(_itkPadImageFilterPython.itkPadImageFilterIVF33IVF33_cast)
    GetPointer = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterIVF33IVF33_GetPointer)

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

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

          itkPadImageFilterIVF33IVF33.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

          obj = itkPadImageFilterIVF33IVF33.New()
          obj.SetInput( 0, reader.GetOutput() )
          obj.SetThreshold( 10 )
        """
        obj = itkPadImageFilterIVF33IVF33.__New_orig__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkPadImageFilterIVF33IVF33 in _itkPadImageFilterPython:
_itkPadImageFilterPython.itkPadImageFilterIVF33IVF33_swigregister(itkPadImageFilterIVF33IVF33)
class itkPadImageFilterIVF42IVF42(itkPadImageFilterBasePython.itkPadImageFilterBaseIVF42IVF42):
    r"""Proxy of C++ itkPadImageFilterIVF42IVF42 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(_itkPadImageFilterPython.itkPadImageFilterIVF42IVF42___New_orig__)
    Clone = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterIVF42IVF42_Clone)
    GetPadLowerBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterIVF42IVF42_GetPadLowerBound)
    GetPadUpperBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterIVF42IVF42_GetPadUpperBound)
    SetPadLowerBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterIVF42IVF42_SetPadLowerBound)
    SetPadUpperBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterIVF42IVF42_SetPadUpperBound)
    SetPadBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterIVF42IVF42_SetPadBound)
    __swig_destroy__ = _itkPadImageFilterPython.delete_itkPadImageFilterIVF42IVF42
    cast = _swig_new_static_method(_itkPadImageFilterPython.itkPadImageFilterIVF42IVF42_cast)
    GetPointer = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterIVF42IVF42_GetPointer)

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

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

          itkPadImageFilterIVF42IVF42.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

          obj = itkPadImageFilterIVF42IVF42.New()
          obj.SetInput( 0, reader.GetOutput() )
          obj.SetThreshold( 10 )
        """
        obj = itkPadImageFilterIVF42IVF42.__New_orig__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkPadImageFilterIVF42IVF42 in _itkPadImageFilterPython:
_itkPadImageFilterPython.itkPadImageFilterIVF42IVF42_swigregister(itkPadImageFilterIVF42IVF42)
class itkPadImageFilterIVF43IVF43(itkPadImageFilterBasePython.itkPadImageFilterBaseIVF43IVF43):
    r"""Proxy of C++ itkPadImageFilterIVF43IVF43 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(_itkPadImageFilterPython.itkPadImageFilterIVF43IVF43___New_orig__)
    Clone = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterIVF43IVF43_Clone)
    GetPadLowerBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterIVF43IVF43_GetPadLowerBound)
    GetPadUpperBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterIVF43IVF43_GetPadUpperBound)
    SetPadLowerBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterIVF43IVF43_SetPadLowerBound)
    SetPadUpperBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterIVF43IVF43_SetPadUpperBound)
    SetPadBound = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterIVF43IVF43_SetPadBound)
    __swig_destroy__ = _itkPadImageFilterPython.delete_itkPadImageFilterIVF43IVF43
    cast = _swig_new_static_method(_itkPadImageFilterPython.itkPadImageFilterIVF43IVF43_cast)
    GetPointer = _swig_new_instance_method(_itkPadImageFilterPython.itkPadImageFilterIVF43IVF43_GetPointer)

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

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

          itkPadImageFilterIVF43IVF43.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

          obj = itkPadImageFilterIVF43IVF43.New()
          obj.SetInput( 0, reader.GetOutput() )
          obj.SetThreshold( 10 )
        """
        obj = itkPadImageFilterIVF43IVF43.__New_orig__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkPadImageFilterIVF43IVF43 in _itkPadImageFilterPython:
_itkPadImageFilterPython.itkPadImageFilterIVF43IVF43_swigregister(itkPadImageFilterIVF43IVF43)

