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

from sys import version_info as _swig_python_version_info
# Import the low-level C/C++ module
if __package__ or "." in __name__:
    from . import _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 itkCovariantVectorPython
import vnl_vectorPython
import stdcomplexPython
import pyBasePython
import vnl_matrixPython
import vnl_vector_refPython
import itkVectorPython
import itkFixedArrayPython
import itkPointPython
import itkArrayPython
import itkRGBAPixelPython
import ITKCommonBasePython
import itkContinuousIndexPython
import itkIndexPython
import itkOffsetPython
import itkSizePython
import itkRGBPixelPython
import itkImagePython
import itkImageRegionPython
import itkMatrixPython
import vnl_matrix_fixedPython
import itkSymmetricSecondRankTensorPython

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)

