# 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 _itkFunctionBasePython
else:
    import _itkFunctionBasePython

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

_swig_new_instance_method = _itkFunctionBasePython.SWIG_PyInstanceMethod_New
_swig_new_static_method = _itkFunctionBasePython.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 itkArrayPython
import vnl_vectorPython
import vnl_matrixPython
import stdcomplexPython
import pyBasePython
import itkRGBAPixelPython
import itkFixedArrayPython
import itkContinuousIndexPython
import itkPointPython
import vnl_vector_refPython
import itkVectorPython
import itkIndexPython
import itkSizePython
import itkOffsetPython
import itkCovariantVectorPython
import itkImagePython
import itkImageRegionPython
import ITKCommonBasePython
import itkSymmetricSecondRankTensorPython
import itkMatrixPython
import vnl_matrix_fixedPython
import itkRGBPixelPython

def itkFunctionBaseFF_New():
  return itkFunctionBaseFF.New()


def itkFunctionBasePD3RGBAD_New():
  return itkFunctionBasePD3RGBAD.New()


def itkFunctionBasePD3RGBD_New():
  return itkFunctionBasePD3RGBD.New()


def itkFunctionBasePD3RGBAUC_New():
  return itkFunctionBasePD3RGBAUC.New()


def itkFunctionBasePD3RGBUC_New():
  return itkFunctionBasePD3RGBUC.New()


def itkFunctionBaseVF3D_New():
  return itkFunctionBaseVF3D.New()


def itkFunctionBasePD3CVD3_New():
  return itkFunctionBasePD3CVD3.New()


def itkFunctionBasePD3VD3_New():
  return itkFunctionBasePD3VD3.New()


def itkFunctionBaseCID3AD_New():
  return itkFunctionBaseCID3AD.New()


def itkFunctionBaseCIF3AD_New():
  return itkFunctionBaseCIF3AD.New()


def itkFunctionBasePF3F_New():
  return itkFunctionBasePF3F.New()


def itkFunctionBasePD3F_New():
  return itkFunctionBasePD3F.New()


def itkFunctionBasePF3D_New():
  return itkFunctionBasePF3D.New()


def itkFunctionBasePD3D_New():
  return itkFunctionBasePD3D.New()


def itkFunctionBaseIF3D_New():
  return itkFunctionBaseIF3D.New()


def itkFunctionBasePD2RGBAD_New():
  return itkFunctionBasePD2RGBAD.New()


def itkFunctionBasePD2RGBD_New():
  return itkFunctionBasePD2RGBD.New()


def itkFunctionBasePD2RGBAUC_New():
  return itkFunctionBasePD2RGBAUC.New()


def itkFunctionBasePD2RGBUC_New():
  return itkFunctionBasePD2RGBUC.New()


def itkFunctionBaseVF2D_New():
  return itkFunctionBaseVF2D.New()


def itkFunctionBasePD2CVD2_New():
  return itkFunctionBasePD2CVD2.New()


def itkFunctionBasePD2VD2_New():
  return itkFunctionBasePD2VD2.New()


def itkFunctionBaseCID2AD_New():
  return itkFunctionBaseCID2AD.New()


def itkFunctionBaseCIF2AD_New():
  return itkFunctionBaseCIF2AD.New()


def itkFunctionBasePF2F_New():
  return itkFunctionBasePF2F.New()


def itkFunctionBasePD2F_New():
  return itkFunctionBasePD2F.New()


def itkFunctionBasePF2D_New():
  return itkFunctionBasePF2D.New()


def itkFunctionBasePD2D_New():
  return itkFunctionBasePD2D.New()


def itkFunctionBaseIF2D_New():
  return itkFunctionBaseIF2D.New()

class itkFunctionBaseCID2AD(ITKCommonBasePython.itkObject):
    r"""Proxy of C++ itkFunctionBaseCID2AD class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    Evaluate = _swig_new_instance_method(_itkFunctionBasePython.itkFunctionBaseCID2AD_Evaluate)
    __swig_destroy__ = _itkFunctionBasePython.delete_itkFunctionBaseCID2AD
    cast = _swig_new_static_method(_itkFunctionBasePython.itkFunctionBaseCID2AD_cast)
    GetPointer = _swig_new_instance_method(_itkFunctionBasePython.itkFunctionBaseCID2AD_GetPointer)

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

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

          itkFunctionBaseCID2AD.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkFunctionBaseCID2AD in _itkFunctionBasePython:
_itkFunctionBasePython.itkFunctionBaseCID2AD_swigregister(itkFunctionBaseCID2AD)
class itkFunctionBaseCID3AD(ITKCommonBasePython.itkObject):
    r"""Proxy of C++ itkFunctionBaseCID3AD class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    Evaluate = _swig_new_instance_method(_itkFunctionBasePython.itkFunctionBaseCID3AD_Evaluate)
    __swig_destroy__ = _itkFunctionBasePython.delete_itkFunctionBaseCID3AD
    cast = _swig_new_static_method(_itkFunctionBasePython.itkFunctionBaseCID3AD_cast)
    GetPointer = _swig_new_instance_method(_itkFunctionBasePython.itkFunctionBaseCID3AD_GetPointer)

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

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

          itkFunctionBaseCID3AD.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkFunctionBaseCID3AD in _itkFunctionBasePython:
_itkFunctionBasePython.itkFunctionBaseCID3AD_swigregister(itkFunctionBaseCID3AD)
class itkFunctionBaseCIF2AD(ITKCommonBasePython.itkObject):
    r"""Proxy of C++ itkFunctionBaseCIF2AD class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    Evaluate = _swig_new_instance_method(_itkFunctionBasePython.itkFunctionBaseCIF2AD_Evaluate)
    __swig_destroy__ = _itkFunctionBasePython.delete_itkFunctionBaseCIF2AD
    cast = _swig_new_static_method(_itkFunctionBasePython.itkFunctionBaseCIF2AD_cast)
    GetPointer = _swig_new_instance_method(_itkFunctionBasePython.itkFunctionBaseCIF2AD_GetPointer)

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

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

          itkFunctionBaseCIF2AD.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkFunctionBaseCIF2AD in _itkFunctionBasePython:
_itkFunctionBasePython.itkFunctionBaseCIF2AD_swigregister(itkFunctionBaseCIF2AD)
class itkFunctionBaseCIF3AD(ITKCommonBasePython.itkObject):
    r"""Proxy of C++ itkFunctionBaseCIF3AD class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    Evaluate = _swig_new_instance_method(_itkFunctionBasePython.itkFunctionBaseCIF3AD_Evaluate)
    __swig_destroy__ = _itkFunctionBasePython.delete_itkFunctionBaseCIF3AD
    cast = _swig_new_static_method(_itkFunctionBasePython.itkFunctionBaseCIF3AD_cast)
    GetPointer = _swig_new_instance_method(_itkFunctionBasePython.itkFunctionBaseCIF3AD_GetPointer)

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

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

          itkFunctionBaseCIF3AD.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkFunctionBaseCIF3AD in _itkFunctionBasePython:
_itkFunctionBasePython.itkFunctionBaseCIF3AD_swigregister(itkFunctionBaseCIF3AD)
class itkFunctionBaseFF(ITKCommonBasePython.itkObject):
    r"""Proxy of C++ itkFunctionBaseFF class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    Evaluate = _swig_new_instance_method(_itkFunctionBasePython.itkFunctionBaseFF_Evaluate)
    __swig_destroy__ = _itkFunctionBasePython.delete_itkFunctionBaseFF
    cast = _swig_new_static_method(_itkFunctionBasePython.itkFunctionBaseFF_cast)
    GetPointer = _swig_new_instance_method(_itkFunctionBasePython.itkFunctionBaseFF_GetPointer)

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

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

          itkFunctionBaseFF.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkFunctionBaseFF in _itkFunctionBasePython:
_itkFunctionBasePython.itkFunctionBaseFF_swigregister(itkFunctionBaseFF)
class itkFunctionBaseIF2D(ITKCommonBasePython.itkObject):
    r"""Proxy of C++ itkFunctionBaseIF2D class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    Evaluate = _swig_new_instance_method(_itkFunctionBasePython.itkFunctionBaseIF2D_Evaluate)
    __swig_destroy__ = _itkFunctionBasePython.delete_itkFunctionBaseIF2D
    cast = _swig_new_static_method(_itkFunctionBasePython.itkFunctionBaseIF2D_cast)
    GetPointer = _swig_new_instance_method(_itkFunctionBasePython.itkFunctionBaseIF2D_GetPointer)

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

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

          itkFunctionBaseIF2D.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkFunctionBaseIF2D in _itkFunctionBasePython:
_itkFunctionBasePython.itkFunctionBaseIF2D_swigregister(itkFunctionBaseIF2D)
class itkFunctionBaseIF3D(ITKCommonBasePython.itkObject):
    r"""Proxy of C++ itkFunctionBaseIF3D class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    Evaluate = _swig_new_instance_method(_itkFunctionBasePython.itkFunctionBaseIF3D_Evaluate)
    __swig_destroy__ = _itkFunctionBasePython.delete_itkFunctionBaseIF3D
    cast = _swig_new_static_method(_itkFunctionBasePython.itkFunctionBaseIF3D_cast)
    GetPointer = _swig_new_instance_method(_itkFunctionBasePython.itkFunctionBaseIF3D_GetPointer)

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

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

          itkFunctionBaseIF3D.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkFunctionBaseIF3D in _itkFunctionBasePython:
_itkFunctionBasePython.itkFunctionBaseIF3D_swigregister(itkFunctionBaseIF3D)
class itkFunctionBasePD2CVD2(ITKCommonBasePython.itkObject):
    r"""Proxy of C++ itkFunctionBasePD2CVD2 class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    Evaluate = _swig_new_instance_method(_itkFunctionBasePython.itkFunctionBasePD2CVD2_Evaluate)
    __swig_destroy__ = _itkFunctionBasePython.delete_itkFunctionBasePD2CVD2
    cast = _swig_new_static_method(_itkFunctionBasePython.itkFunctionBasePD2CVD2_cast)
    GetPointer = _swig_new_instance_method(_itkFunctionBasePython.itkFunctionBasePD2CVD2_GetPointer)

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

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

          itkFunctionBasePD2CVD2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkFunctionBasePD2CVD2 in _itkFunctionBasePython:
_itkFunctionBasePython.itkFunctionBasePD2CVD2_swigregister(itkFunctionBasePD2CVD2)
class itkFunctionBasePD2D(ITKCommonBasePython.itkObject):
    r"""Proxy of C++ itkFunctionBasePD2D class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    Evaluate = _swig_new_instance_method(_itkFunctionBasePython.itkFunctionBasePD2D_Evaluate)
    __swig_destroy__ = _itkFunctionBasePython.delete_itkFunctionBasePD2D
    cast = _swig_new_static_method(_itkFunctionBasePython.itkFunctionBasePD2D_cast)
    GetPointer = _swig_new_instance_method(_itkFunctionBasePython.itkFunctionBasePD2D_GetPointer)

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

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

          itkFunctionBasePD2D.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkFunctionBasePD2D in _itkFunctionBasePython:
_itkFunctionBasePython.itkFunctionBasePD2D_swigregister(itkFunctionBasePD2D)
class itkFunctionBasePD2F(ITKCommonBasePython.itkObject):
    r"""Proxy of C++ itkFunctionBasePD2F class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    Evaluate = _swig_new_instance_method(_itkFunctionBasePython.itkFunctionBasePD2F_Evaluate)
    __swig_destroy__ = _itkFunctionBasePython.delete_itkFunctionBasePD2F
    cast = _swig_new_static_method(_itkFunctionBasePython.itkFunctionBasePD2F_cast)
    GetPointer = _swig_new_instance_method(_itkFunctionBasePython.itkFunctionBasePD2F_GetPointer)

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

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

          itkFunctionBasePD2F.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkFunctionBasePD2F in _itkFunctionBasePython:
_itkFunctionBasePython.itkFunctionBasePD2F_swigregister(itkFunctionBasePD2F)
class itkFunctionBasePD2RGBAD(ITKCommonBasePython.itkObject):
    r"""Proxy of C++ itkFunctionBasePD2RGBAD class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    Evaluate = _swig_new_instance_method(_itkFunctionBasePython.itkFunctionBasePD2RGBAD_Evaluate)
    __swig_destroy__ = _itkFunctionBasePython.delete_itkFunctionBasePD2RGBAD
    cast = _swig_new_static_method(_itkFunctionBasePython.itkFunctionBasePD2RGBAD_cast)
    GetPointer = _swig_new_instance_method(_itkFunctionBasePython.itkFunctionBasePD2RGBAD_GetPointer)

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

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

          itkFunctionBasePD2RGBAD.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkFunctionBasePD2RGBAD in _itkFunctionBasePython:
_itkFunctionBasePython.itkFunctionBasePD2RGBAD_swigregister(itkFunctionBasePD2RGBAD)
class itkFunctionBasePD2RGBAUC(ITKCommonBasePython.itkObject):
    r"""Proxy of C++ itkFunctionBasePD2RGBAUC class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    Evaluate = _swig_new_instance_method(_itkFunctionBasePython.itkFunctionBasePD2RGBAUC_Evaluate)
    __swig_destroy__ = _itkFunctionBasePython.delete_itkFunctionBasePD2RGBAUC
    cast = _swig_new_static_method(_itkFunctionBasePython.itkFunctionBasePD2RGBAUC_cast)
    GetPointer = _swig_new_instance_method(_itkFunctionBasePython.itkFunctionBasePD2RGBAUC_GetPointer)

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

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

          itkFunctionBasePD2RGBAUC.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkFunctionBasePD2RGBAUC in _itkFunctionBasePython:
_itkFunctionBasePython.itkFunctionBasePD2RGBAUC_swigregister(itkFunctionBasePD2RGBAUC)
class itkFunctionBasePD2RGBD(ITKCommonBasePython.itkObject):
    r"""Proxy of C++ itkFunctionBasePD2RGBD class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    Evaluate = _swig_new_instance_method(_itkFunctionBasePython.itkFunctionBasePD2RGBD_Evaluate)
    __swig_destroy__ = _itkFunctionBasePython.delete_itkFunctionBasePD2RGBD
    cast = _swig_new_static_method(_itkFunctionBasePython.itkFunctionBasePD2RGBD_cast)
    GetPointer = _swig_new_instance_method(_itkFunctionBasePython.itkFunctionBasePD2RGBD_GetPointer)

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

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

          itkFunctionBasePD2RGBD.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkFunctionBasePD2RGBD in _itkFunctionBasePython:
_itkFunctionBasePython.itkFunctionBasePD2RGBD_swigregister(itkFunctionBasePD2RGBD)
class itkFunctionBasePD2RGBUC(ITKCommonBasePython.itkObject):
    r"""Proxy of C++ itkFunctionBasePD2RGBUC class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    Evaluate = _swig_new_instance_method(_itkFunctionBasePython.itkFunctionBasePD2RGBUC_Evaluate)
    __swig_destroy__ = _itkFunctionBasePython.delete_itkFunctionBasePD2RGBUC
    cast = _swig_new_static_method(_itkFunctionBasePython.itkFunctionBasePD2RGBUC_cast)
    GetPointer = _swig_new_instance_method(_itkFunctionBasePython.itkFunctionBasePD2RGBUC_GetPointer)

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

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

          itkFunctionBasePD2RGBUC.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkFunctionBasePD2RGBUC in _itkFunctionBasePython:
_itkFunctionBasePython.itkFunctionBasePD2RGBUC_swigregister(itkFunctionBasePD2RGBUC)
class itkFunctionBasePD2VD2(ITKCommonBasePython.itkObject):
    r"""Proxy of C++ itkFunctionBasePD2VD2 class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    Evaluate = _swig_new_instance_method(_itkFunctionBasePython.itkFunctionBasePD2VD2_Evaluate)
    __swig_destroy__ = _itkFunctionBasePython.delete_itkFunctionBasePD2VD2
    cast = _swig_new_static_method(_itkFunctionBasePython.itkFunctionBasePD2VD2_cast)
    GetPointer = _swig_new_instance_method(_itkFunctionBasePython.itkFunctionBasePD2VD2_GetPointer)

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

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

          itkFunctionBasePD2VD2.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkFunctionBasePD2VD2 in _itkFunctionBasePython:
_itkFunctionBasePython.itkFunctionBasePD2VD2_swigregister(itkFunctionBasePD2VD2)
class itkFunctionBasePD3CVD3(ITKCommonBasePython.itkObject):
    r"""Proxy of C++ itkFunctionBasePD3CVD3 class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    Evaluate = _swig_new_instance_method(_itkFunctionBasePython.itkFunctionBasePD3CVD3_Evaluate)
    __swig_destroy__ = _itkFunctionBasePython.delete_itkFunctionBasePD3CVD3
    cast = _swig_new_static_method(_itkFunctionBasePython.itkFunctionBasePD3CVD3_cast)
    GetPointer = _swig_new_instance_method(_itkFunctionBasePython.itkFunctionBasePD3CVD3_GetPointer)

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

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

          itkFunctionBasePD3CVD3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkFunctionBasePD3CVD3 in _itkFunctionBasePython:
_itkFunctionBasePython.itkFunctionBasePD3CVD3_swigregister(itkFunctionBasePD3CVD3)
class itkFunctionBasePD3D(ITKCommonBasePython.itkObject):
    r"""Proxy of C++ itkFunctionBasePD3D class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    Evaluate = _swig_new_instance_method(_itkFunctionBasePython.itkFunctionBasePD3D_Evaluate)
    __swig_destroy__ = _itkFunctionBasePython.delete_itkFunctionBasePD3D
    cast = _swig_new_static_method(_itkFunctionBasePython.itkFunctionBasePD3D_cast)
    GetPointer = _swig_new_instance_method(_itkFunctionBasePython.itkFunctionBasePD3D_GetPointer)

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

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

          itkFunctionBasePD3D.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkFunctionBasePD3D in _itkFunctionBasePython:
_itkFunctionBasePython.itkFunctionBasePD3D_swigregister(itkFunctionBasePD3D)
class itkFunctionBasePD3F(ITKCommonBasePython.itkObject):
    r"""Proxy of C++ itkFunctionBasePD3F class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    Evaluate = _swig_new_instance_method(_itkFunctionBasePython.itkFunctionBasePD3F_Evaluate)
    __swig_destroy__ = _itkFunctionBasePython.delete_itkFunctionBasePD3F
    cast = _swig_new_static_method(_itkFunctionBasePython.itkFunctionBasePD3F_cast)
    GetPointer = _swig_new_instance_method(_itkFunctionBasePython.itkFunctionBasePD3F_GetPointer)

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

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

          itkFunctionBasePD3F.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkFunctionBasePD3F in _itkFunctionBasePython:
_itkFunctionBasePython.itkFunctionBasePD3F_swigregister(itkFunctionBasePD3F)
class itkFunctionBasePD3RGBAD(ITKCommonBasePython.itkObject):
    r"""Proxy of C++ itkFunctionBasePD3RGBAD class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    Evaluate = _swig_new_instance_method(_itkFunctionBasePython.itkFunctionBasePD3RGBAD_Evaluate)
    __swig_destroy__ = _itkFunctionBasePython.delete_itkFunctionBasePD3RGBAD
    cast = _swig_new_static_method(_itkFunctionBasePython.itkFunctionBasePD3RGBAD_cast)
    GetPointer = _swig_new_instance_method(_itkFunctionBasePython.itkFunctionBasePD3RGBAD_GetPointer)

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

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

          itkFunctionBasePD3RGBAD.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkFunctionBasePD3RGBAD in _itkFunctionBasePython:
_itkFunctionBasePython.itkFunctionBasePD3RGBAD_swigregister(itkFunctionBasePD3RGBAD)
class itkFunctionBasePD3RGBAUC(ITKCommonBasePython.itkObject):
    r"""Proxy of C++ itkFunctionBasePD3RGBAUC class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    Evaluate = _swig_new_instance_method(_itkFunctionBasePython.itkFunctionBasePD3RGBAUC_Evaluate)
    __swig_destroy__ = _itkFunctionBasePython.delete_itkFunctionBasePD3RGBAUC
    cast = _swig_new_static_method(_itkFunctionBasePython.itkFunctionBasePD3RGBAUC_cast)
    GetPointer = _swig_new_instance_method(_itkFunctionBasePython.itkFunctionBasePD3RGBAUC_GetPointer)

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

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

          itkFunctionBasePD3RGBAUC.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkFunctionBasePD3RGBAUC in _itkFunctionBasePython:
_itkFunctionBasePython.itkFunctionBasePD3RGBAUC_swigregister(itkFunctionBasePD3RGBAUC)
class itkFunctionBasePD3RGBD(ITKCommonBasePython.itkObject):
    r"""Proxy of C++ itkFunctionBasePD3RGBD class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    Evaluate = _swig_new_instance_method(_itkFunctionBasePython.itkFunctionBasePD3RGBD_Evaluate)
    __swig_destroy__ = _itkFunctionBasePython.delete_itkFunctionBasePD3RGBD
    cast = _swig_new_static_method(_itkFunctionBasePython.itkFunctionBasePD3RGBD_cast)
    GetPointer = _swig_new_instance_method(_itkFunctionBasePython.itkFunctionBasePD3RGBD_GetPointer)

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

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

          itkFunctionBasePD3RGBD.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkFunctionBasePD3RGBD in _itkFunctionBasePython:
_itkFunctionBasePython.itkFunctionBasePD3RGBD_swigregister(itkFunctionBasePD3RGBD)
class itkFunctionBasePD3RGBUC(ITKCommonBasePython.itkObject):
    r"""Proxy of C++ itkFunctionBasePD3RGBUC class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    Evaluate = _swig_new_instance_method(_itkFunctionBasePython.itkFunctionBasePD3RGBUC_Evaluate)
    __swig_destroy__ = _itkFunctionBasePython.delete_itkFunctionBasePD3RGBUC
    cast = _swig_new_static_method(_itkFunctionBasePython.itkFunctionBasePD3RGBUC_cast)
    GetPointer = _swig_new_instance_method(_itkFunctionBasePython.itkFunctionBasePD3RGBUC_GetPointer)

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

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

          itkFunctionBasePD3RGBUC.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkFunctionBasePD3RGBUC in _itkFunctionBasePython:
_itkFunctionBasePython.itkFunctionBasePD3RGBUC_swigregister(itkFunctionBasePD3RGBUC)
class itkFunctionBasePD3VD3(ITKCommonBasePython.itkObject):
    r"""Proxy of C++ itkFunctionBasePD3VD3 class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    Evaluate = _swig_new_instance_method(_itkFunctionBasePython.itkFunctionBasePD3VD3_Evaluate)
    __swig_destroy__ = _itkFunctionBasePython.delete_itkFunctionBasePD3VD3
    cast = _swig_new_static_method(_itkFunctionBasePython.itkFunctionBasePD3VD3_cast)
    GetPointer = _swig_new_instance_method(_itkFunctionBasePython.itkFunctionBasePD3VD3_GetPointer)

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

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

          itkFunctionBasePD3VD3.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkFunctionBasePD3VD3 in _itkFunctionBasePython:
_itkFunctionBasePython.itkFunctionBasePD3VD3_swigregister(itkFunctionBasePD3VD3)
class itkFunctionBasePF2D(ITKCommonBasePython.itkObject):
    r"""Proxy of C++ itkFunctionBasePF2D class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    Evaluate = _swig_new_instance_method(_itkFunctionBasePython.itkFunctionBasePF2D_Evaluate)
    __swig_destroy__ = _itkFunctionBasePython.delete_itkFunctionBasePF2D
    cast = _swig_new_static_method(_itkFunctionBasePython.itkFunctionBasePF2D_cast)
    GetPointer = _swig_new_instance_method(_itkFunctionBasePython.itkFunctionBasePF2D_GetPointer)

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

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

          itkFunctionBasePF2D.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkFunctionBasePF2D in _itkFunctionBasePython:
_itkFunctionBasePython.itkFunctionBasePF2D_swigregister(itkFunctionBasePF2D)
class itkFunctionBasePF2F(ITKCommonBasePython.itkObject):
    r"""Proxy of C++ itkFunctionBasePF2F class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    Evaluate = _swig_new_instance_method(_itkFunctionBasePython.itkFunctionBasePF2F_Evaluate)
    __swig_destroy__ = _itkFunctionBasePython.delete_itkFunctionBasePF2F
    cast = _swig_new_static_method(_itkFunctionBasePython.itkFunctionBasePF2F_cast)
    GetPointer = _swig_new_instance_method(_itkFunctionBasePython.itkFunctionBasePF2F_GetPointer)

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

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

          itkFunctionBasePF2F.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkFunctionBasePF2F in _itkFunctionBasePython:
_itkFunctionBasePython.itkFunctionBasePF2F_swigregister(itkFunctionBasePF2F)
class itkFunctionBasePF3D(ITKCommonBasePython.itkObject):
    r"""Proxy of C++ itkFunctionBasePF3D class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    Evaluate = _swig_new_instance_method(_itkFunctionBasePython.itkFunctionBasePF3D_Evaluate)
    __swig_destroy__ = _itkFunctionBasePython.delete_itkFunctionBasePF3D
    cast = _swig_new_static_method(_itkFunctionBasePython.itkFunctionBasePF3D_cast)
    GetPointer = _swig_new_instance_method(_itkFunctionBasePython.itkFunctionBasePF3D_GetPointer)

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

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

          itkFunctionBasePF3D.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkFunctionBasePF3D in _itkFunctionBasePython:
_itkFunctionBasePython.itkFunctionBasePF3D_swigregister(itkFunctionBasePF3D)
class itkFunctionBasePF3F(ITKCommonBasePython.itkObject):
    r"""Proxy of C++ itkFunctionBasePF3F class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    Evaluate = _swig_new_instance_method(_itkFunctionBasePython.itkFunctionBasePF3F_Evaluate)
    __swig_destroy__ = _itkFunctionBasePython.delete_itkFunctionBasePF3F
    cast = _swig_new_static_method(_itkFunctionBasePython.itkFunctionBasePF3F_cast)
    GetPointer = _swig_new_instance_method(_itkFunctionBasePython.itkFunctionBasePF3F_GetPointer)

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

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

          itkFunctionBasePF3F.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkFunctionBasePF3F in _itkFunctionBasePython:
_itkFunctionBasePython.itkFunctionBasePF3F_swigregister(itkFunctionBasePF3F)
class itkFunctionBaseVF2D(ITKCommonBasePython.itkObject):
    r"""Proxy of C++ itkFunctionBaseVF2D class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    Evaluate = _swig_new_instance_method(_itkFunctionBasePython.itkFunctionBaseVF2D_Evaluate)
    __swig_destroy__ = _itkFunctionBasePython.delete_itkFunctionBaseVF2D
    cast = _swig_new_static_method(_itkFunctionBasePython.itkFunctionBaseVF2D_cast)
    GetPointer = _swig_new_instance_method(_itkFunctionBasePython.itkFunctionBaseVF2D_GetPointer)

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

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

          itkFunctionBaseVF2D.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkFunctionBaseVF2D in _itkFunctionBasePython:
_itkFunctionBasePython.itkFunctionBaseVF2D_swigregister(itkFunctionBaseVF2D)
class itkFunctionBaseVF3D(ITKCommonBasePython.itkObject):
    r"""Proxy of C++ itkFunctionBaseVF3D class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    Evaluate = _swig_new_instance_method(_itkFunctionBasePython.itkFunctionBaseVF3D_Evaluate)
    __swig_destroy__ = _itkFunctionBasePython.delete_itkFunctionBaseVF3D
    cast = _swig_new_static_method(_itkFunctionBasePython.itkFunctionBaseVF3D_cast)
    GetPointer = _swig_new_instance_method(_itkFunctionBasePython.itkFunctionBaseVF3D_GetPointer)

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

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

          itkFunctionBaseVF3D.New( reader, Threshold=10 )

        is (most of the time) equivalent to:

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


# Register itkFunctionBaseVF3D in _itkFunctionBasePython:
_itkFunctionBasePython.itkFunctionBaseVF3D_swigregister(itkFunctionBaseVF3D)

