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

from sys import version_info as _swig_python_version_info
# Import the low-level C/C++ module
if getattr(globals().get("__spec__"), "parent", None) or __package__ or "." in __name__:
    from . import _itkLinearInterpolateImageFunctionPython
else:
    import _itkLinearInterpolateImageFunctionPython

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

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

def itkLinearInterpolateImageFunctionIRGBAUC3D_New():
  return itkLinearInterpolateImageFunctionIRGBAUC3D.New()


def itkLinearInterpolateImageFunctionIRGBUC3D_New():
  return itkLinearInterpolateImageFunctionIRGBUC3D.New()


def itkLinearInterpolateImageFunctionICVF33D_New():
  return itkLinearInterpolateImageFunctionICVF33D.New()


def itkLinearInterpolateImageFunctionIVF33D_New():
  return itkLinearInterpolateImageFunctionIVF33D.New()


def itkLinearInterpolateImageFunctionIF3D_New():
  return itkLinearInterpolateImageFunctionIF3D.New()


def itkLinearInterpolateImageFunctionIUC3D_New():
  return itkLinearInterpolateImageFunctionIUC3D.New()


def itkLinearInterpolateImageFunctionISS3D_New():
  return itkLinearInterpolateImageFunctionISS3D.New()


def itkLinearInterpolateImageFunctionIRGBAUC2D_New():
  return itkLinearInterpolateImageFunctionIRGBAUC2D.New()


def itkLinearInterpolateImageFunctionIRGBUC2D_New():
  return itkLinearInterpolateImageFunctionIRGBUC2D.New()


def itkLinearInterpolateImageFunctionICVF22D_New():
  return itkLinearInterpolateImageFunctionICVF22D.New()


def itkLinearInterpolateImageFunctionIVF22D_New():
  return itkLinearInterpolateImageFunctionIVF22D.New()


def itkLinearInterpolateImageFunctionIF2D_New():
  return itkLinearInterpolateImageFunctionIF2D.New()


def itkLinearInterpolateImageFunctionIUC2D_New():
  return itkLinearInterpolateImageFunctionIUC2D.New()


def itkLinearInterpolateImageFunctionISS2D_New():
  return itkLinearInterpolateImageFunctionISS2D.New()

class itkLinearInterpolateImageFunctionICVF22D(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
    __New_orig__ = _swig_new_static_method(_itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionICVF22D___New_orig__)
    Clone = _swig_new_instance_method(_itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionICVF22D_Clone)
    __swig_destroy__ = _itkLinearInterpolateImageFunctionPython.delete_itkLinearInterpolateImageFunctionICVF22D
    cast = _swig_new_static_method(_itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionICVF22D_cast)
    GetPointer = _swig_new_instance_method(_itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionICVF22D_GetPointer)

    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__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkLinearInterpolateImageFunctionICVF22D in _itkLinearInterpolateImageFunctionPython:
_itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionICVF22D_swigregister(itkLinearInterpolateImageFunctionICVF22D)
class itkLinearInterpolateImageFunctionICVF33D(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
    __New_orig__ = _swig_new_static_method(_itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionICVF33D___New_orig__)
    Clone = _swig_new_instance_method(_itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionICVF33D_Clone)
    __swig_destroy__ = _itkLinearInterpolateImageFunctionPython.delete_itkLinearInterpolateImageFunctionICVF33D
    cast = _swig_new_static_method(_itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionICVF33D_cast)
    GetPointer = _swig_new_instance_method(_itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionICVF33D_GetPointer)

    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__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkLinearInterpolateImageFunctionICVF33D in _itkLinearInterpolateImageFunctionPython:
_itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionICVF33D_swigregister(itkLinearInterpolateImageFunctionICVF33D)
class itkLinearInterpolateImageFunctionIF2D(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
    __New_orig__ = _swig_new_static_method(_itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionIF2D___New_orig__)
    Clone = _swig_new_instance_method(_itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionIF2D_Clone)
    __swig_destroy__ = _itkLinearInterpolateImageFunctionPython.delete_itkLinearInterpolateImageFunctionIF2D
    cast = _swig_new_static_method(_itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionIF2D_cast)
    GetPointer = _swig_new_instance_method(_itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionIF2D_GetPointer)

    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__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkLinearInterpolateImageFunctionIF2D in _itkLinearInterpolateImageFunctionPython:
_itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionIF2D_swigregister(itkLinearInterpolateImageFunctionIF2D)
class itkLinearInterpolateImageFunctionIF3D(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
    __New_orig__ = _swig_new_static_method(_itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionIF3D___New_orig__)
    Clone = _swig_new_instance_method(_itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionIF3D_Clone)
    __swig_destroy__ = _itkLinearInterpolateImageFunctionPython.delete_itkLinearInterpolateImageFunctionIF3D
    cast = _swig_new_static_method(_itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionIF3D_cast)
    GetPointer = _swig_new_instance_method(_itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionIF3D_GetPointer)

    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__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkLinearInterpolateImageFunctionIF3D in _itkLinearInterpolateImageFunctionPython:
_itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionIF3D_swigregister(itkLinearInterpolateImageFunctionIF3D)
class itkLinearInterpolateImageFunctionIRGBAUC2D(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
    __New_orig__ = _swig_new_static_method(_itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionIRGBAUC2D___New_orig__)
    Clone = _swig_new_instance_method(_itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionIRGBAUC2D_Clone)
    __swig_destroy__ = _itkLinearInterpolateImageFunctionPython.delete_itkLinearInterpolateImageFunctionIRGBAUC2D
    cast = _swig_new_static_method(_itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionIRGBAUC2D_cast)
    GetPointer = _swig_new_instance_method(_itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionIRGBAUC2D_GetPointer)

    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__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkLinearInterpolateImageFunctionIRGBAUC2D in _itkLinearInterpolateImageFunctionPython:
_itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionIRGBAUC2D_swigregister(itkLinearInterpolateImageFunctionIRGBAUC2D)
class itkLinearInterpolateImageFunctionIRGBAUC3D(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
    __New_orig__ = _swig_new_static_method(_itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionIRGBAUC3D___New_orig__)
    Clone = _swig_new_instance_method(_itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionIRGBAUC3D_Clone)
    __swig_destroy__ = _itkLinearInterpolateImageFunctionPython.delete_itkLinearInterpolateImageFunctionIRGBAUC3D
    cast = _swig_new_static_method(_itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionIRGBAUC3D_cast)
    GetPointer = _swig_new_instance_method(_itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionIRGBAUC3D_GetPointer)

    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__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkLinearInterpolateImageFunctionIRGBAUC3D in _itkLinearInterpolateImageFunctionPython:
_itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionIRGBAUC3D_swigregister(itkLinearInterpolateImageFunctionIRGBAUC3D)
class itkLinearInterpolateImageFunctionIRGBUC2D(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
    __New_orig__ = _swig_new_static_method(_itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionIRGBUC2D___New_orig__)
    Clone = _swig_new_instance_method(_itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionIRGBUC2D_Clone)
    __swig_destroy__ = _itkLinearInterpolateImageFunctionPython.delete_itkLinearInterpolateImageFunctionIRGBUC2D
    cast = _swig_new_static_method(_itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionIRGBUC2D_cast)
    GetPointer = _swig_new_instance_method(_itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionIRGBUC2D_GetPointer)

    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__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkLinearInterpolateImageFunctionIRGBUC2D in _itkLinearInterpolateImageFunctionPython:
_itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionIRGBUC2D_swigregister(itkLinearInterpolateImageFunctionIRGBUC2D)
class itkLinearInterpolateImageFunctionIRGBUC3D(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
    __New_orig__ = _swig_new_static_method(_itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionIRGBUC3D___New_orig__)
    Clone = _swig_new_instance_method(_itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionIRGBUC3D_Clone)
    __swig_destroy__ = _itkLinearInterpolateImageFunctionPython.delete_itkLinearInterpolateImageFunctionIRGBUC3D
    cast = _swig_new_static_method(_itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionIRGBUC3D_cast)
    GetPointer = _swig_new_instance_method(_itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionIRGBUC3D_GetPointer)

    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__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkLinearInterpolateImageFunctionIRGBUC3D in _itkLinearInterpolateImageFunctionPython:
_itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionIRGBUC3D_swigregister(itkLinearInterpolateImageFunctionIRGBUC3D)
class itkLinearInterpolateImageFunctionISS2D(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
    __New_orig__ = _swig_new_static_method(_itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionISS2D___New_orig__)
    Clone = _swig_new_instance_method(_itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionISS2D_Clone)
    __swig_destroy__ = _itkLinearInterpolateImageFunctionPython.delete_itkLinearInterpolateImageFunctionISS2D
    cast = _swig_new_static_method(_itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionISS2D_cast)
    GetPointer = _swig_new_instance_method(_itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionISS2D_GetPointer)

    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__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkLinearInterpolateImageFunctionISS2D in _itkLinearInterpolateImageFunctionPython:
_itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionISS2D_swigregister(itkLinearInterpolateImageFunctionISS2D)
class itkLinearInterpolateImageFunctionISS3D(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
    __New_orig__ = _swig_new_static_method(_itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionISS3D___New_orig__)
    Clone = _swig_new_instance_method(_itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionISS3D_Clone)
    __swig_destroy__ = _itkLinearInterpolateImageFunctionPython.delete_itkLinearInterpolateImageFunctionISS3D
    cast = _swig_new_static_method(_itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionISS3D_cast)
    GetPointer = _swig_new_instance_method(_itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionISS3D_GetPointer)

    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__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkLinearInterpolateImageFunctionISS3D in _itkLinearInterpolateImageFunctionPython:
_itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionISS3D_swigregister(itkLinearInterpolateImageFunctionISS3D)
class itkLinearInterpolateImageFunctionIUC2D(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
    __New_orig__ = _swig_new_static_method(_itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionIUC2D___New_orig__)
    Clone = _swig_new_instance_method(_itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionIUC2D_Clone)
    __swig_destroy__ = _itkLinearInterpolateImageFunctionPython.delete_itkLinearInterpolateImageFunctionIUC2D
    cast = _swig_new_static_method(_itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionIUC2D_cast)
    GetPointer = _swig_new_instance_method(_itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionIUC2D_GetPointer)

    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__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkLinearInterpolateImageFunctionIUC2D in _itkLinearInterpolateImageFunctionPython:
_itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionIUC2D_swigregister(itkLinearInterpolateImageFunctionIUC2D)
class itkLinearInterpolateImageFunctionIUC3D(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
    __New_orig__ = _swig_new_static_method(_itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionIUC3D___New_orig__)
    Clone = _swig_new_instance_method(_itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionIUC3D_Clone)
    __swig_destroy__ = _itkLinearInterpolateImageFunctionPython.delete_itkLinearInterpolateImageFunctionIUC3D
    cast = _swig_new_static_method(_itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionIUC3D_cast)
    GetPointer = _swig_new_instance_method(_itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionIUC3D_GetPointer)

    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__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkLinearInterpolateImageFunctionIUC3D in _itkLinearInterpolateImageFunctionPython:
_itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionIUC3D_swigregister(itkLinearInterpolateImageFunctionIUC3D)
class itkLinearInterpolateImageFunctionIVF22D(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
    __New_orig__ = _swig_new_static_method(_itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionIVF22D___New_orig__)
    Clone = _swig_new_instance_method(_itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionIVF22D_Clone)
    __swig_destroy__ = _itkLinearInterpolateImageFunctionPython.delete_itkLinearInterpolateImageFunctionIVF22D
    cast = _swig_new_static_method(_itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionIVF22D_cast)
    GetPointer = _swig_new_instance_method(_itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionIVF22D_GetPointer)

    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__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkLinearInterpolateImageFunctionIVF22D in _itkLinearInterpolateImageFunctionPython:
_itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionIVF22D_swigregister(itkLinearInterpolateImageFunctionIVF22D)
class itkLinearInterpolateImageFunctionIVF33D(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
    __New_orig__ = _swig_new_static_method(_itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionIVF33D___New_orig__)
    Clone = _swig_new_instance_method(_itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionIVF33D_Clone)
    __swig_destroy__ = _itkLinearInterpolateImageFunctionPython.delete_itkLinearInterpolateImageFunctionIVF33D
    cast = _swig_new_static_method(_itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionIVF33D_cast)
    GetPointer = _swig_new_instance_method(_itkLinearInterpolateImageFunctionPython.itkLinearInterpolateImageFunctionIVF33D_GetPointer)

    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__()
        import itkTemplate
        itkTemplate.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


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

