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


import collections

from sys import version_info as _version_info
if _version_info < (3, 7, 0):
    raise RuntimeError("Python 3.7 or later required")

from . import _ITKCommonPython


from . import _ITKImageFunctionPython



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

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

def _swig_repr(self):
    try:
        strthis = "proxy of " + self.this.__repr__()
    except __builtin__.Exception:
        strthis = ""
    return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)


def _swig_setattr_nondynamic_instance_variable(set):
    def set_instance_attr(self, name, value):
        if name == "this":
            set(self, name, value)
        elif name == "thisown":
            self.this.own(value)
        elif hasattr(self, name) and isinstance(getattr(type(self), name), property):
            set(self, name, value)
        else:
            raise AttributeError("You cannot add instance attributes to %s" % self)
    return set_instance_attr


def _swig_setattr_nondynamic_class_variable(set):
    def set_class_attr(cls, name, value):
        if hasattr(cls, name) and not isinstance(getattr(cls, name), property):
            set(cls, name, value)
        else:
            raise AttributeError("You cannot add class attributes to %s" % cls)
    return set_class_attr


def _swig_add_metaclass(metaclass):
    """Class decorator for adding a metaclass to a SWIG wrapped class - a slimmed down version of six.add_metaclass"""
    def wrapper(cls):
        return metaclass(cls.__name__, cls.__bases__, cls.__dict__.copy())
    return wrapper


class _SwigNonDynamicMeta(type):
    """Meta class to enforce nondynamic attributes (no new attributes) for a class"""
    __setattr__ = _swig_setattr_nondynamic_class_variable(type.__setattr__)


if _swig_python_version_info[0:2] >= (3, 3):
    import collections.abc
else:
    import collections

import itk.itkCovariantVectorPython
import itk.vnl_vector_refPython
import itk.vnl_vectorPython
import itk.stdcomplexPython
import itk.pyBasePython
import itk.vnl_matrixPython
import itk.itkFixedArrayPython
import itk.itkVectorPython
import itk.itkRGBPixelPython
import itk.itkRGBAPixelPython
import itk.itkSizePython
import itk.itkInterpolateImageFunctionPython
import itk.itkIndexPython
import itk.itkOffsetPython
import itk.itkImageFunctionBasePython
import itk.itkFunctionBasePython
import itk.itkPointPython
import itk.itkArrayPython
import itk.ITKCommonBasePython
import itk.itkMatrixPython
import itk.vnl_matrix_fixedPython
import itk.itkContinuousIndexPython
import itk.itkImagePython
import itk.itkImageRegionPython
import itk.itkSymmetricSecondRankTensorPython
import itk.itkPhasedArray3DSpecialCoordinatesImagePython

def itkLinearInterpolateImageFunctionICVF22D_New():
    return itkLinearInterpolateImageFunctionICVF22D.New()

class itkLinearInterpolateImageFunctionICVF22D(itk.itkInterpolateImageFunctionPython.itkInterpolateImageFunctionICVF22D):
    r"""Proxy of C++ itkLinearInterpolateImageFunctionICVF22D class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkLinearInterpolateImageFunctionICVF22D_Pointer"""
        return _itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionICVF22D___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkLinearInterpolateImageFunctionICVF22D_Pointer"""
        return _itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionICVF22D_Clone(self)
    __swig_destroy__ = _itkLinearInterpolateImageFunctionPython.delete_itkLinearInterpolateImageFunctionICVF22D

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

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

        """
        return _itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionICVF22D_cast(obj)

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

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

          itkLinearInterpolateImageFunctionICVF22D.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkLinearInterpolateImageFunctionICVF22D in _itkLinearInterpolateImageFunctionPython:
_itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionICVF22D_swigregister(itkLinearInterpolateImageFunctionICVF22D)

def itkLinearInterpolateImageFunctionICVF33D_New():
    return itkLinearInterpolateImageFunctionICVF33D.New()

class itkLinearInterpolateImageFunctionICVF33D(itk.itkInterpolateImageFunctionPython.itkInterpolateImageFunctionICVF33D):
    r"""Proxy of C++ itkLinearInterpolateImageFunctionICVF33D class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkLinearInterpolateImageFunctionICVF33D_Pointer"""
        return _itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionICVF33D___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkLinearInterpolateImageFunctionICVF33D_Pointer"""
        return _itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionICVF33D_Clone(self)
    __swig_destroy__ = _itkLinearInterpolateImageFunctionPython.delete_itkLinearInterpolateImageFunctionICVF33D

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

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

        """
        return _itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionICVF33D_cast(obj)

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

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

          itkLinearInterpolateImageFunctionICVF33D.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkLinearInterpolateImageFunctionICVF33D in _itkLinearInterpolateImageFunctionPython:
_itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionICVF33D_swigregister(itkLinearInterpolateImageFunctionICVF33D)

def itkLinearInterpolateImageFunctionIF2D_New():
    return itkLinearInterpolateImageFunctionIF2D.New()

class itkLinearInterpolateImageFunctionIF2D(itk.itkInterpolateImageFunctionPython.itkInterpolateImageFunctionIF2D):
    r"""Proxy of C++ itkLinearInterpolateImageFunctionIF2D class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkLinearInterpolateImageFunctionIF2D_Pointer"""
        return _itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionIF2D___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkLinearInterpolateImageFunctionIF2D_Pointer"""
        return _itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionIF2D_Clone(self)
    __swig_destroy__ = _itkLinearInterpolateImageFunctionPython.delete_itkLinearInterpolateImageFunctionIF2D

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

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

        """
        return _itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionIF2D_cast(obj)

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

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

          itkLinearInterpolateImageFunctionIF2D.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkLinearInterpolateImageFunctionIF2D in _itkLinearInterpolateImageFunctionPython:
_itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionIF2D_swigregister(itkLinearInterpolateImageFunctionIF2D)

def itkLinearInterpolateImageFunctionIF3D_New():
    return itkLinearInterpolateImageFunctionIF3D.New()

class itkLinearInterpolateImageFunctionIF3D(itk.itkInterpolateImageFunctionPython.itkInterpolateImageFunctionIF3D):
    r"""Proxy of C++ itkLinearInterpolateImageFunctionIF3D class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkLinearInterpolateImageFunctionIF3D_Pointer"""
        return _itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionIF3D___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkLinearInterpolateImageFunctionIF3D_Pointer"""
        return _itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionIF3D_Clone(self)
    __swig_destroy__ = _itkLinearInterpolateImageFunctionPython.delete_itkLinearInterpolateImageFunctionIF3D

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

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

        """
        return _itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionIF3D_cast(obj)

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

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

          itkLinearInterpolateImageFunctionIF3D.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkLinearInterpolateImageFunctionIF3D in _itkLinearInterpolateImageFunctionPython:
_itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionIF3D_swigregister(itkLinearInterpolateImageFunctionIF3D)

def itkLinearInterpolateImageFunctionIRGBAUC2D_New():
    return itkLinearInterpolateImageFunctionIRGBAUC2D.New()

class itkLinearInterpolateImageFunctionIRGBAUC2D(itk.itkInterpolateImageFunctionPython.itkInterpolateImageFunctionIRGBAUC2D):
    r"""Proxy of C++ itkLinearInterpolateImageFunctionIRGBAUC2D class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkLinearInterpolateImageFunctionIRGBAUC2D_Pointer"""
        return _itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionIRGBAUC2D___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkLinearInterpolateImageFunctionIRGBAUC2D_Pointer"""
        return _itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionIRGBAUC2D_Clone(self)
    __swig_destroy__ = _itkLinearInterpolateImageFunctionPython.delete_itkLinearInterpolateImageFunctionIRGBAUC2D

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

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

        """
        return _itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionIRGBAUC2D_cast(obj)

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

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

          itkLinearInterpolateImageFunctionIRGBAUC2D.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkLinearInterpolateImageFunctionIRGBAUC2D in _itkLinearInterpolateImageFunctionPython:
_itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionIRGBAUC2D_swigregister(itkLinearInterpolateImageFunctionIRGBAUC2D)

def itkLinearInterpolateImageFunctionIRGBAUC3D_New():
    return itkLinearInterpolateImageFunctionIRGBAUC3D.New()

class itkLinearInterpolateImageFunctionIRGBAUC3D(itk.itkInterpolateImageFunctionPython.itkInterpolateImageFunctionIRGBAUC3D):
    r"""Proxy of C++ itkLinearInterpolateImageFunctionIRGBAUC3D class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkLinearInterpolateImageFunctionIRGBAUC3D_Pointer"""
        return _itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionIRGBAUC3D___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkLinearInterpolateImageFunctionIRGBAUC3D_Pointer"""
        return _itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionIRGBAUC3D_Clone(self)
    __swig_destroy__ = _itkLinearInterpolateImageFunctionPython.delete_itkLinearInterpolateImageFunctionIRGBAUC3D

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

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

        """
        return _itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionIRGBAUC3D_cast(obj)

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

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

          itkLinearInterpolateImageFunctionIRGBAUC3D.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkLinearInterpolateImageFunctionIRGBAUC3D in _itkLinearInterpolateImageFunctionPython:
_itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionIRGBAUC3D_swigregister(itkLinearInterpolateImageFunctionIRGBAUC3D)

def itkLinearInterpolateImageFunctionIRGBUC2D_New():
    return itkLinearInterpolateImageFunctionIRGBUC2D.New()

class itkLinearInterpolateImageFunctionIRGBUC2D(itk.itkInterpolateImageFunctionPython.itkInterpolateImageFunctionIRGBUC2D):
    r"""Proxy of C++ itkLinearInterpolateImageFunctionIRGBUC2D class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkLinearInterpolateImageFunctionIRGBUC2D_Pointer"""
        return _itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionIRGBUC2D___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkLinearInterpolateImageFunctionIRGBUC2D_Pointer"""
        return _itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionIRGBUC2D_Clone(self)
    __swig_destroy__ = _itkLinearInterpolateImageFunctionPython.delete_itkLinearInterpolateImageFunctionIRGBUC2D

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

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

        """
        return _itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionIRGBUC2D_cast(obj)

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

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

          itkLinearInterpolateImageFunctionIRGBUC2D.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkLinearInterpolateImageFunctionIRGBUC2D in _itkLinearInterpolateImageFunctionPython:
_itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionIRGBUC2D_swigregister(itkLinearInterpolateImageFunctionIRGBUC2D)

def itkLinearInterpolateImageFunctionIRGBUC3D_New():
    return itkLinearInterpolateImageFunctionIRGBUC3D.New()

class itkLinearInterpolateImageFunctionIRGBUC3D(itk.itkInterpolateImageFunctionPython.itkInterpolateImageFunctionIRGBUC3D):
    r"""Proxy of C++ itkLinearInterpolateImageFunctionIRGBUC3D class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkLinearInterpolateImageFunctionIRGBUC3D_Pointer"""
        return _itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionIRGBUC3D___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkLinearInterpolateImageFunctionIRGBUC3D_Pointer"""
        return _itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionIRGBUC3D_Clone(self)
    __swig_destroy__ = _itkLinearInterpolateImageFunctionPython.delete_itkLinearInterpolateImageFunctionIRGBUC3D

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

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

        """
        return _itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionIRGBUC3D_cast(obj)

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

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

          itkLinearInterpolateImageFunctionIRGBUC3D.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkLinearInterpolateImageFunctionIRGBUC3D in _itkLinearInterpolateImageFunctionPython:
_itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionIRGBUC3D_swigregister(itkLinearInterpolateImageFunctionIRGBUC3D)

def itkLinearInterpolateImageFunctionISS2D_New():
    return itkLinearInterpolateImageFunctionISS2D.New()

class itkLinearInterpolateImageFunctionISS2D(itk.itkInterpolateImageFunctionPython.itkInterpolateImageFunctionISS2D):
    r"""Proxy of C++ itkLinearInterpolateImageFunctionISS2D class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkLinearInterpolateImageFunctionISS2D_Pointer"""
        return _itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionISS2D___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkLinearInterpolateImageFunctionISS2D_Pointer"""
        return _itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionISS2D_Clone(self)
    __swig_destroy__ = _itkLinearInterpolateImageFunctionPython.delete_itkLinearInterpolateImageFunctionISS2D

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

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

        """
        return _itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionISS2D_cast(obj)

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

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

          itkLinearInterpolateImageFunctionISS2D.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkLinearInterpolateImageFunctionISS2D in _itkLinearInterpolateImageFunctionPython:
_itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionISS2D_swigregister(itkLinearInterpolateImageFunctionISS2D)

def itkLinearInterpolateImageFunctionISS3D_New():
    return itkLinearInterpolateImageFunctionISS3D.New()

class itkLinearInterpolateImageFunctionISS3D(itk.itkInterpolateImageFunctionPython.itkInterpolateImageFunctionISS3D):
    r"""Proxy of C++ itkLinearInterpolateImageFunctionISS3D class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkLinearInterpolateImageFunctionISS3D_Pointer"""
        return _itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionISS3D___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkLinearInterpolateImageFunctionISS3D_Pointer"""
        return _itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionISS3D_Clone(self)
    __swig_destroy__ = _itkLinearInterpolateImageFunctionPython.delete_itkLinearInterpolateImageFunctionISS3D

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

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

        """
        return _itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionISS3D_cast(obj)

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

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

          itkLinearInterpolateImageFunctionISS3D.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkLinearInterpolateImageFunctionISS3D in _itkLinearInterpolateImageFunctionPython:
_itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionISS3D_swigregister(itkLinearInterpolateImageFunctionISS3D)

def itkLinearInterpolateImageFunctionIUC2D_New():
    return itkLinearInterpolateImageFunctionIUC2D.New()

class itkLinearInterpolateImageFunctionIUC2D(itk.itkInterpolateImageFunctionPython.itkInterpolateImageFunctionIUC2D):
    r"""Proxy of C++ itkLinearInterpolateImageFunctionIUC2D class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkLinearInterpolateImageFunctionIUC2D_Pointer"""
        return _itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionIUC2D___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkLinearInterpolateImageFunctionIUC2D_Pointer"""
        return _itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionIUC2D_Clone(self)
    __swig_destroy__ = _itkLinearInterpolateImageFunctionPython.delete_itkLinearInterpolateImageFunctionIUC2D

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

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

        """
        return _itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionIUC2D_cast(obj)

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

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

          itkLinearInterpolateImageFunctionIUC2D.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkLinearInterpolateImageFunctionIUC2D in _itkLinearInterpolateImageFunctionPython:
_itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionIUC2D_swigregister(itkLinearInterpolateImageFunctionIUC2D)

def itkLinearInterpolateImageFunctionIUC3D_New():
    return itkLinearInterpolateImageFunctionIUC3D.New()

class itkLinearInterpolateImageFunctionIUC3D(itk.itkInterpolateImageFunctionPython.itkInterpolateImageFunctionIUC3D):
    r"""Proxy of C++ itkLinearInterpolateImageFunctionIUC3D class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkLinearInterpolateImageFunctionIUC3D_Pointer"""
        return _itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionIUC3D___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkLinearInterpolateImageFunctionIUC3D_Pointer"""
        return _itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionIUC3D_Clone(self)
    __swig_destroy__ = _itkLinearInterpolateImageFunctionPython.delete_itkLinearInterpolateImageFunctionIUC3D

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

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

        """
        return _itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionIUC3D_cast(obj)

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

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

          itkLinearInterpolateImageFunctionIUC3D.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkLinearInterpolateImageFunctionIUC3D in _itkLinearInterpolateImageFunctionPython:
_itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionIUC3D_swigregister(itkLinearInterpolateImageFunctionIUC3D)

def itkLinearInterpolateImageFunctionIVF22D_New():
    return itkLinearInterpolateImageFunctionIVF22D.New()

class itkLinearInterpolateImageFunctionIVF22D(itk.itkInterpolateImageFunctionPython.itkInterpolateImageFunctionIVF22D):
    r"""Proxy of C++ itkLinearInterpolateImageFunctionIVF22D 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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkLinearInterpolateImageFunctionIVF22D_Pointer"""
        return _itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionIVF22D___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkLinearInterpolateImageFunctionIVF22D_Pointer"""
        return _itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionIVF22D_Clone(self)
    __swig_destroy__ = _itkLinearInterpolateImageFunctionPython.delete_itkLinearInterpolateImageFunctionIVF22D

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

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

        """
        return _itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionIVF22D_cast(obj)

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

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

          itkLinearInterpolateImageFunctionIVF22D.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkLinearInterpolateImageFunctionIVF22D in _itkLinearInterpolateImageFunctionPython:
_itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionIVF22D_swigregister(itkLinearInterpolateImageFunctionIVF22D)

def itkLinearInterpolateImageFunctionIVF33D_New():
    return itkLinearInterpolateImageFunctionIVF33D.New()

class itkLinearInterpolateImageFunctionIVF33D(itk.itkInterpolateImageFunctionPython.itkInterpolateImageFunctionIVF33D):
    r"""Proxy of C++ itkLinearInterpolateImageFunctionIVF33D 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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkLinearInterpolateImageFunctionIVF33D_Pointer"""
        return _itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionIVF33D___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkLinearInterpolateImageFunctionIVF33D_Pointer"""
        return _itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionIVF33D_Clone(self)
    __swig_destroy__ = _itkLinearInterpolateImageFunctionPython.delete_itkLinearInterpolateImageFunctionIVF33D

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

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

        """
        return _itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionIVF33D_cast(obj)

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

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

          itkLinearInterpolateImageFunctionIVF33D.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkLinearInterpolateImageFunctionIVF33D in _itkLinearInterpolateImageFunctionPython:
_itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionIVF33D_swigregister(itkLinearInterpolateImageFunctionIVF33D)

def itkLinearInterpolateImageFunctionPA3DSCIFD_New():
    return itkLinearInterpolateImageFunctionPA3DSCIFD.New()

class itkLinearInterpolateImageFunctionPA3DSCIFD(itk.itkInterpolateImageFunctionPython.itkInterpolateImageFunctionPA3DSCIFD):
    r"""Proxy of C++ itkLinearInterpolateImageFunctionPA3DSCIFD class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkLinearInterpolateImageFunctionPA3DSCIFD_Pointer"""
        return _itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionPA3DSCIFD___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkLinearInterpolateImageFunctionPA3DSCIFD_Pointer"""
        return _itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionPA3DSCIFD_Clone(self)
    __swig_destroy__ = _itkLinearInterpolateImageFunctionPython.delete_itkLinearInterpolateImageFunctionPA3DSCIFD

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

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

        """
        return _itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionPA3DSCIFD_cast(obj)

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

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

          itkLinearInterpolateImageFunctionPA3DSCIFD.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkLinearInterpolateImageFunctionPA3DSCIFD in _itkLinearInterpolateImageFunctionPython:
_itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionPA3DSCIFD_swigregister(itkLinearInterpolateImageFunctionPA3DSCIFD)

def itkLinearInterpolateImageFunctionPA3DSCIUCD_New():
    return itkLinearInterpolateImageFunctionPA3DSCIUCD.New()

class itkLinearInterpolateImageFunctionPA3DSCIUCD(itk.itkInterpolateImageFunctionPython.itkInterpolateImageFunctionPA3DSCIUCD):
    r"""Proxy of C++ itkLinearInterpolateImageFunctionPA3DSCIUCD class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkLinearInterpolateImageFunctionPA3DSCIUCD_Pointer"""
        return _itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionPA3DSCIUCD___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkLinearInterpolateImageFunctionPA3DSCIUCD_Pointer"""
        return _itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionPA3DSCIUCD_Clone(self)
    __swig_destroy__ = _itkLinearInterpolateImageFunctionPython.delete_itkLinearInterpolateImageFunctionPA3DSCIUCD

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

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

        """
        return _itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionPA3DSCIUCD_cast(obj)

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

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

          itkLinearInterpolateImageFunctionPA3DSCIUCD.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkLinearInterpolateImageFunctionPA3DSCIUCD in _itkLinearInterpolateImageFunctionPython:
_itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionPA3DSCIUCD_swigregister(itkLinearInterpolateImageFunctionPA3DSCIUCD)

