# 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.stdcomplexPython
import itk.pyBasePython
import itk.vnl_vectorPython
import itk.vnl_matrixPython
import itk.itkFixedArrayPython
import itk.itkVectorPython
import itk.itkSizePython
import itk.itkRGBAPixelPython
import itk.ITKCommonBasePython
import itk.itkMatrixPython
import itk.vnl_matrix_fixedPython
import itk.itkPointPython
import itk.itkContinuousIndexPython
import itk.itkIndexPython
import itk.itkOffsetPython
import itk.itkRGBPixelPython
import itk.itkInterpolateImageFunctionPython
import itk.itkImageFunctionBasePython
import itk.itkFunctionBasePython
import itk.itkImagePython
import itk.itkImageRegionPython
import itk.itkSymmetricSecondRankTensorPython
import itk.itkArrayPython
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)

