# 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 _ITKCommonPython



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

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.itkImageRegionPython
import itk.ITKCommonBasePython
import itk.itkMatrixPython
import itk.itkPointPython
import itk.vnl_vectorPython
import itk.stdcomplexPython
import itk.pyBasePython
import itk.vnl_matrixPython
import itk.itkVectorPython
import itk.itkFixedArrayPython
import itk.vnl_vector_refPython
import itk.vnl_matrix_fixedPython
import itk.itkCovariantVectorPython
import itk.itkIndexPython
import itk.itkOffsetPython
import itk.itkSizePython
import itk.itkImagePython
import itk.itkRGBAPixelPython
import itk.itkSymmetricSecondRankTensorPython
import itk.itkRGBPixelPython
import itk.itkImageToImageFilterCommonPython
import itk.itkVectorImagePython
import itk.itkVariableLengthVectorPython
class itkImageSinkICF2(itk.ITKCommonBasePython.itkStreamingProcessObject):
    r"""Proxy of C++ itkImageSinkICF2 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

    def SetInput(self, input):
        r"""
        SetInput(self, input)

        Parameters
        ----------
        input: itkImageCF2 const *

        """
        return _itkImageSinkPython.itkImageSinkICF2_SetInput(self, input)

    def GetInput(self, *args):
        r"""
        GetInput(self) -> itkImageCF2
        GetInput(self, idx) -> itkImageCF2

        Parameters
        ----------
        idx: unsigned int

        GetInput(self, key) -> itkImageCF2

        Parameters
        ----------
        key: std::string const &

        """
        return _itkImageSinkPython.itkImageSinkICF2_GetInput(self, *args)

    def SetCoordinateTolerance(self, _arg):
        r"""
        SetCoordinateTolerance(self, _arg)

        Parameters
        ----------
        _arg: double

        """
        return _itkImageSinkPython.itkImageSinkICF2_SetCoordinateTolerance(self, _arg)

    def GetCoordinateTolerance(self):
        r"""GetCoordinateTolerance(self) -> double"""
        return _itkImageSinkPython.itkImageSinkICF2_GetCoordinateTolerance(self)

    def SetDirectionTolerance(self, _arg):
        r"""
        SetDirectionTolerance(self, _arg)

        Parameters
        ----------
        _arg: double

        """
        return _itkImageSinkPython.itkImageSinkICF2_SetDirectionTolerance(self, _arg)

    def GetDirectionTolerance(self):
        r"""GetDirectionTolerance(self) -> double"""
        return _itkImageSinkPython.itkImageSinkICF2_GetDirectionTolerance(self)
    __swig_destroy__ = _itkImageSinkPython.delete_itkImageSinkICF2

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

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

        """
        return _itkImageSinkPython.itkImageSinkICF2_cast(obj)

# Register itkImageSinkICF2 in _itkImageSinkPython:
_itkImageSinkPython.itkImageSinkICF2_swigregister(itkImageSinkICF2)
class itkImageSinkICF3(itk.ITKCommonBasePython.itkStreamingProcessObject):
    r"""Proxy of C++ itkImageSinkICF3 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

    def SetInput(self, input):
        r"""
        SetInput(self, input)

        Parameters
        ----------
        input: itkImageCF3 const *

        """
        return _itkImageSinkPython.itkImageSinkICF3_SetInput(self, input)

    def GetInput(self, *args):
        r"""
        GetInput(self) -> itkImageCF3
        GetInput(self, idx) -> itkImageCF3

        Parameters
        ----------
        idx: unsigned int

        GetInput(self, key) -> itkImageCF3

        Parameters
        ----------
        key: std::string const &

        """
        return _itkImageSinkPython.itkImageSinkICF3_GetInput(self, *args)

    def SetCoordinateTolerance(self, _arg):
        r"""
        SetCoordinateTolerance(self, _arg)

        Parameters
        ----------
        _arg: double

        """
        return _itkImageSinkPython.itkImageSinkICF3_SetCoordinateTolerance(self, _arg)

    def GetCoordinateTolerance(self):
        r"""GetCoordinateTolerance(self) -> double"""
        return _itkImageSinkPython.itkImageSinkICF3_GetCoordinateTolerance(self)

    def SetDirectionTolerance(self, _arg):
        r"""
        SetDirectionTolerance(self, _arg)

        Parameters
        ----------
        _arg: double

        """
        return _itkImageSinkPython.itkImageSinkICF3_SetDirectionTolerance(self, _arg)

    def GetDirectionTolerance(self):
        r"""GetDirectionTolerance(self) -> double"""
        return _itkImageSinkPython.itkImageSinkICF3_GetDirectionTolerance(self)
    __swig_destroy__ = _itkImageSinkPython.delete_itkImageSinkICF3

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

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

        """
        return _itkImageSinkPython.itkImageSinkICF3_cast(obj)

# Register itkImageSinkICF3 in _itkImageSinkPython:
_itkImageSinkPython.itkImageSinkICF3_swigregister(itkImageSinkICF3)
class itkImageSinkICVF22(itk.ITKCommonBasePython.itkStreamingProcessObject):
    r"""Proxy of C++ itkImageSinkICVF22 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

    def SetInput(self, input):
        r"""
        SetInput(self, input)

        Parameters
        ----------
        input: itkImageCVF22 const *

        """
        return _itkImageSinkPython.itkImageSinkICVF22_SetInput(self, input)

    def GetInput(self, *args):
        r"""
        GetInput(self) -> itkImageCVF22
        GetInput(self, idx) -> itkImageCVF22

        Parameters
        ----------
        idx: unsigned int

        GetInput(self, key) -> itkImageCVF22

        Parameters
        ----------
        key: std::string const &

        """
        return _itkImageSinkPython.itkImageSinkICVF22_GetInput(self, *args)

    def SetCoordinateTolerance(self, _arg):
        r"""
        SetCoordinateTolerance(self, _arg)

        Parameters
        ----------
        _arg: double

        """
        return _itkImageSinkPython.itkImageSinkICVF22_SetCoordinateTolerance(self, _arg)

    def GetCoordinateTolerance(self):
        r"""GetCoordinateTolerance(self) -> double"""
        return _itkImageSinkPython.itkImageSinkICVF22_GetCoordinateTolerance(self)

    def SetDirectionTolerance(self, _arg):
        r"""
        SetDirectionTolerance(self, _arg)

        Parameters
        ----------
        _arg: double

        """
        return _itkImageSinkPython.itkImageSinkICVF22_SetDirectionTolerance(self, _arg)

    def GetDirectionTolerance(self):
        r"""GetDirectionTolerance(self) -> double"""
        return _itkImageSinkPython.itkImageSinkICVF22_GetDirectionTolerance(self)
    __swig_destroy__ = _itkImageSinkPython.delete_itkImageSinkICVF22

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

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

        """
        return _itkImageSinkPython.itkImageSinkICVF22_cast(obj)

# Register itkImageSinkICVF22 in _itkImageSinkPython:
_itkImageSinkPython.itkImageSinkICVF22_swigregister(itkImageSinkICVF22)
class itkImageSinkICVF23(itk.ITKCommonBasePython.itkStreamingProcessObject):
    r"""Proxy of C++ itkImageSinkICVF23 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

    def SetInput(self, input):
        r"""
        SetInput(self, input)

        Parameters
        ----------
        input: itkImageCVF23 const *

        """
        return _itkImageSinkPython.itkImageSinkICVF23_SetInput(self, input)

    def GetInput(self, *args):
        r"""
        GetInput(self) -> itkImageCVF23
        GetInput(self, idx) -> itkImageCVF23

        Parameters
        ----------
        idx: unsigned int

        GetInput(self, key) -> itkImageCVF23

        Parameters
        ----------
        key: std::string const &

        """
        return _itkImageSinkPython.itkImageSinkICVF23_GetInput(self, *args)

    def SetCoordinateTolerance(self, _arg):
        r"""
        SetCoordinateTolerance(self, _arg)

        Parameters
        ----------
        _arg: double

        """
        return _itkImageSinkPython.itkImageSinkICVF23_SetCoordinateTolerance(self, _arg)

    def GetCoordinateTolerance(self):
        r"""GetCoordinateTolerance(self) -> double"""
        return _itkImageSinkPython.itkImageSinkICVF23_GetCoordinateTolerance(self)

    def SetDirectionTolerance(self, _arg):
        r"""
        SetDirectionTolerance(self, _arg)

        Parameters
        ----------
        _arg: double

        """
        return _itkImageSinkPython.itkImageSinkICVF23_SetDirectionTolerance(self, _arg)

    def GetDirectionTolerance(self):
        r"""GetDirectionTolerance(self) -> double"""
        return _itkImageSinkPython.itkImageSinkICVF23_GetDirectionTolerance(self)
    __swig_destroy__ = _itkImageSinkPython.delete_itkImageSinkICVF23

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

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

        """
        return _itkImageSinkPython.itkImageSinkICVF23_cast(obj)

# Register itkImageSinkICVF23 in _itkImageSinkPython:
_itkImageSinkPython.itkImageSinkICVF23_swigregister(itkImageSinkICVF23)
class itkImageSinkICVF32(itk.ITKCommonBasePython.itkStreamingProcessObject):
    r"""Proxy of C++ itkImageSinkICVF32 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

    def SetInput(self, input):
        r"""
        SetInput(self, input)

        Parameters
        ----------
        input: itkImageCVF32 const *

        """
        return _itkImageSinkPython.itkImageSinkICVF32_SetInput(self, input)

    def GetInput(self, *args):
        r"""
        GetInput(self) -> itkImageCVF32
        GetInput(self, idx) -> itkImageCVF32

        Parameters
        ----------
        idx: unsigned int

        GetInput(self, key) -> itkImageCVF32

        Parameters
        ----------
        key: std::string const &

        """
        return _itkImageSinkPython.itkImageSinkICVF32_GetInput(self, *args)

    def SetCoordinateTolerance(self, _arg):
        r"""
        SetCoordinateTolerance(self, _arg)

        Parameters
        ----------
        _arg: double

        """
        return _itkImageSinkPython.itkImageSinkICVF32_SetCoordinateTolerance(self, _arg)

    def GetCoordinateTolerance(self):
        r"""GetCoordinateTolerance(self) -> double"""
        return _itkImageSinkPython.itkImageSinkICVF32_GetCoordinateTolerance(self)

    def SetDirectionTolerance(self, _arg):
        r"""
        SetDirectionTolerance(self, _arg)

        Parameters
        ----------
        _arg: double

        """
        return _itkImageSinkPython.itkImageSinkICVF32_SetDirectionTolerance(self, _arg)

    def GetDirectionTolerance(self):
        r"""GetDirectionTolerance(self) -> double"""
        return _itkImageSinkPython.itkImageSinkICVF32_GetDirectionTolerance(self)
    __swig_destroy__ = _itkImageSinkPython.delete_itkImageSinkICVF32

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

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

        """
        return _itkImageSinkPython.itkImageSinkICVF32_cast(obj)

# Register itkImageSinkICVF32 in _itkImageSinkPython:
_itkImageSinkPython.itkImageSinkICVF32_swigregister(itkImageSinkICVF32)
class itkImageSinkICVF33(itk.ITKCommonBasePython.itkStreamingProcessObject):
    r"""Proxy of C++ itkImageSinkICVF33 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

    def SetInput(self, input):
        r"""
        SetInput(self, input)

        Parameters
        ----------
        input: itkImageCVF33 const *

        """
        return _itkImageSinkPython.itkImageSinkICVF33_SetInput(self, input)

    def GetInput(self, *args):
        r"""
        GetInput(self) -> itkImageCVF33
        GetInput(self, idx) -> itkImageCVF33

        Parameters
        ----------
        idx: unsigned int

        GetInput(self, key) -> itkImageCVF33

        Parameters
        ----------
        key: std::string const &

        """
        return _itkImageSinkPython.itkImageSinkICVF33_GetInput(self, *args)

    def SetCoordinateTolerance(self, _arg):
        r"""
        SetCoordinateTolerance(self, _arg)

        Parameters
        ----------
        _arg: double

        """
        return _itkImageSinkPython.itkImageSinkICVF33_SetCoordinateTolerance(self, _arg)

    def GetCoordinateTolerance(self):
        r"""GetCoordinateTolerance(self) -> double"""
        return _itkImageSinkPython.itkImageSinkICVF33_GetCoordinateTolerance(self)

    def SetDirectionTolerance(self, _arg):
        r"""
        SetDirectionTolerance(self, _arg)

        Parameters
        ----------
        _arg: double

        """
        return _itkImageSinkPython.itkImageSinkICVF33_SetDirectionTolerance(self, _arg)

    def GetDirectionTolerance(self):
        r"""GetDirectionTolerance(self) -> double"""
        return _itkImageSinkPython.itkImageSinkICVF33_GetDirectionTolerance(self)
    __swig_destroy__ = _itkImageSinkPython.delete_itkImageSinkICVF33

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

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

        """
        return _itkImageSinkPython.itkImageSinkICVF33_cast(obj)

# Register itkImageSinkICVF33 in _itkImageSinkPython:
_itkImageSinkPython.itkImageSinkICVF33_swigregister(itkImageSinkICVF33)
class itkImageSinkICVF42(itk.ITKCommonBasePython.itkStreamingProcessObject):
    r"""Proxy of C++ itkImageSinkICVF42 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

    def SetInput(self, input):
        r"""
        SetInput(self, input)

        Parameters
        ----------
        input: itkImageCVF42 const *

        """
        return _itkImageSinkPython.itkImageSinkICVF42_SetInput(self, input)

    def GetInput(self, *args):
        r"""
        GetInput(self) -> itkImageCVF42
        GetInput(self, idx) -> itkImageCVF42

        Parameters
        ----------
        idx: unsigned int

        GetInput(self, key) -> itkImageCVF42

        Parameters
        ----------
        key: std::string const &

        """
        return _itkImageSinkPython.itkImageSinkICVF42_GetInput(self, *args)

    def SetCoordinateTolerance(self, _arg):
        r"""
        SetCoordinateTolerance(self, _arg)

        Parameters
        ----------
        _arg: double

        """
        return _itkImageSinkPython.itkImageSinkICVF42_SetCoordinateTolerance(self, _arg)

    def GetCoordinateTolerance(self):
        r"""GetCoordinateTolerance(self) -> double"""
        return _itkImageSinkPython.itkImageSinkICVF42_GetCoordinateTolerance(self)

    def SetDirectionTolerance(self, _arg):
        r"""
        SetDirectionTolerance(self, _arg)

        Parameters
        ----------
        _arg: double

        """
        return _itkImageSinkPython.itkImageSinkICVF42_SetDirectionTolerance(self, _arg)

    def GetDirectionTolerance(self):
        r"""GetDirectionTolerance(self) -> double"""
        return _itkImageSinkPython.itkImageSinkICVF42_GetDirectionTolerance(self)
    __swig_destroy__ = _itkImageSinkPython.delete_itkImageSinkICVF42

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

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

        """
        return _itkImageSinkPython.itkImageSinkICVF42_cast(obj)

# Register itkImageSinkICVF42 in _itkImageSinkPython:
_itkImageSinkPython.itkImageSinkICVF42_swigregister(itkImageSinkICVF42)
class itkImageSinkICVF43(itk.ITKCommonBasePython.itkStreamingProcessObject):
    r"""Proxy of C++ itkImageSinkICVF43 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

    def SetInput(self, input):
        r"""
        SetInput(self, input)

        Parameters
        ----------
        input: itkImageCVF43 const *

        """
        return _itkImageSinkPython.itkImageSinkICVF43_SetInput(self, input)

    def GetInput(self, *args):
        r"""
        GetInput(self) -> itkImageCVF43
        GetInput(self, idx) -> itkImageCVF43

        Parameters
        ----------
        idx: unsigned int

        GetInput(self, key) -> itkImageCVF43

        Parameters
        ----------
        key: std::string const &

        """
        return _itkImageSinkPython.itkImageSinkICVF43_GetInput(self, *args)

    def SetCoordinateTolerance(self, _arg):
        r"""
        SetCoordinateTolerance(self, _arg)

        Parameters
        ----------
        _arg: double

        """
        return _itkImageSinkPython.itkImageSinkICVF43_SetCoordinateTolerance(self, _arg)

    def GetCoordinateTolerance(self):
        r"""GetCoordinateTolerance(self) -> double"""
        return _itkImageSinkPython.itkImageSinkICVF43_GetCoordinateTolerance(self)

    def SetDirectionTolerance(self, _arg):
        r"""
        SetDirectionTolerance(self, _arg)

        Parameters
        ----------
        _arg: double

        """
        return _itkImageSinkPython.itkImageSinkICVF43_SetDirectionTolerance(self, _arg)

    def GetDirectionTolerance(self):
        r"""GetDirectionTolerance(self) -> double"""
        return _itkImageSinkPython.itkImageSinkICVF43_GetDirectionTolerance(self)
    __swig_destroy__ = _itkImageSinkPython.delete_itkImageSinkICVF43

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

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

        """
        return _itkImageSinkPython.itkImageSinkICVF43_cast(obj)

# Register itkImageSinkICVF43 in _itkImageSinkPython:
_itkImageSinkPython.itkImageSinkICVF43_swigregister(itkImageSinkICVF43)
class itkImageSinkIF2(itk.ITKCommonBasePython.itkStreamingProcessObject):
    r"""Proxy of C++ itkImageSinkIF2 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

    def SetInput(self, input):
        r"""
        SetInput(self, input)

        Parameters
        ----------
        input: itkImageF2 const *

        """
        return _itkImageSinkPython.itkImageSinkIF2_SetInput(self, input)

    def GetInput(self, *args):
        r"""
        GetInput(self) -> itkImageF2
        GetInput(self, idx) -> itkImageF2

        Parameters
        ----------
        idx: unsigned int

        GetInput(self, key) -> itkImageF2

        Parameters
        ----------
        key: std::string const &

        """
        return _itkImageSinkPython.itkImageSinkIF2_GetInput(self, *args)

    def SetCoordinateTolerance(self, _arg):
        r"""
        SetCoordinateTolerance(self, _arg)

        Parameters
        ----------
        _arg: double

        """
        return _itkImageSinkPython.itkImageSinkIF2_SetCoordinateTolerance(self, _arg)

    def GetCoordinateTolerance(self):
        r"""GetCoordinateTolerance(self) -> double"""
        return _itkImageSinkPython.itkImageSinkIF2_GetCoordinateTolerance(self)

    def SetDirectionTolerance(self, _arg):
        r"""
        SetDirectionTolerance(self, _arg)

        Parameters
        ----------
        _arg: double

        """
        return _itkImageSinkPython.itkImageSinkIF2_SetDirectionTolerance(self, _arg)

    def GetDirectionTolerance(self):
        r"""GetDirectionTolerance(self) -> double"""
        return _itkImageSinkPython.itkImageSinkIF2_GetDirectionTolerance(self)
    __swig_destroy__ = _itkImageSinkPython.delete_itkImageSinkIF2

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

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

        """
        return _itkImageSinkPython.itkImageSinkIF2_cast(obj)

# Register itkImageSinkIF2 in _itkImageSinkPython:
_itkImageSinkPython.itkImageSinkIF2_swigregister(itkImageSinkIF2)
class itkImageSinkIF3(itk.ITKCommonBasePython.itkStreamingProcessObject):
    r"""Proxy of C++ itkImageSinkIF3 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

    def SetInput(self, input):
        r"""
        SetInput(self, input)

        Parameters
        ----------
        input: itkImageF3 const *

        """
        return _itkImageSinkPython.itkImageSinkIF3_SetInput(self, input)

    def GetInput(self, *args):
        r"""
        GetInput(self) -> itkImageF3
        GetInput(self, idx) -> itkImageF3

        Parameters
        ----------
        idx: unsigned int

        GetInput(self, key) -> itkImageF3

        Parameters
        ----------
        key: std::string const &

        """
        return _itkImageSinkPython.itkImageSinkIF3_GetInput(self, *args)

    def SetCoordinateTolerance(self, _arg):
        r"""
        SetCoordinateTolerance(self, _arg)

        Parameters
        ----------
        _arg: double

        """
        return _itkImageSinkPython.itkImageSinkIF3_SetCoordinateTolerance(self, _arg)

    def GetCoordinateTolerance(self):
        r"""GetCoordinateTolerance(self) -> double"""
        return _itkImageSinkPython.itkImageSinkIF3_GetCoordinateTolerance(self)

    def SetDirectionTolerance(self, _arg):
        r"""
        SetDirectionTolerance(self, _arg)

        Parameters
        ----------
        _arg: double

        """
        return _itkImageSinkPython.itkImageSinkIF3_SetDirectionTolerance(self, _arg)

    def GetDirectionTolerance(self):
        r"""GetDirectionTolerance(self) -> double"""
        return _itkImageSinkPython.itkImageSinkIF3_GetDirectionTolerance(self)
    __swig_destroy__ = _itkImageSinkPython.delete_itkImageSinkIF3

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

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

        """
        return _itkImageSinkPython.itkImageSinkIF3_cast(obj)

# Register itkImageSinkIF3 in _itkImageSinkPython:
_itkImageSinkPython.itkImageSinkIF3_swigregister(itkImageSinkIF3)
class itkImageSinkIRGBAUC2(itk.ITKCommonBasePython.itkStreamingProcessObject):
    r"""Proxy of C++ itkImageSinkIRGBAUC2 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

    def SetInput(self, input):
        r"""
        SetInput(self, input)

        Parameters
        ----------
        input: itkImageRGBAUC2 const *

        """
        return _itkImageSinkPython.itkImageSinkIRGBAUC2_SetInput(self, input)

    def GetInput(self, *args):
        r"""
        GetInput(self) -> itkImageRGBAUC2
        GetInput(self, idx) -> itkImageRGBAUC2

        Parameters
        ----------
        idx: unsigned int

        GetInput(self, key) -> itkImageRGBAUC2

        Parameters
        ----------
        key: std::string const &

        """
        return _itkImageSinkPython.itkImageSinkIRGBAUC2_GetInput(self, *args)

    def SetCoordinateTolerance(self, _arg):
        r"""
        SetCoordinateTolerance(self, _arg)

        Parameters
        ----------
        _arg: double

        """
        return _itkImageSinkPython.itkImageSinkIRGBAUC2_SetCoordinateTolerance(self, _arg)

    def GetCoordinateTolerance(self):
        r"""GetCoordinateTolerance(self) -> double"""
        return _itkImageSinkPython.itkImageSinkIRGBAUC2_GetCoordinateTolerance(self)

    def SetDirectionTolerance(self, _arg):
        r"""
        SetDirectionTolerance(self, _arg)

        Parameters
        ----------
        _arg: double

        """
        return _itkImageSinkPython.itkImageSinkIRGBAUC2_SetDirectionTolerance(self, _arg)

    def GetDirectionTolerance(self):
        r"""GetDirectionTolerance(self) -> double"""
        return _itkImageSinkPython.itkImageSinkIRGBAUC2_GetDirectionTolerance(self)
    __swig_destroy__ = _itkImageSinkPython.delete_itkImageSinkIRGBAUC2

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

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

        """
        return _itkImageSinkPython.itkImageSinkIRGBAUC2_cast(obj)

# Register itkImageSinkIRGBAUC2 in _itkImageSinkPython:
_itkImageSinkPython.itkImageSinkIRGBAUC2_swigregister(itkImageSinkIRGBAUC2)
class itkImageSinkIRGBAUC3(itk.ITKCommonBasePython.itkStreamingProcessObject):
    r"""Proxy of C++ itkImageSinkIRGBAUC3 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

    def SetInput(self, input):
        r"""
        SetInput(self, input)

        Parameters
        ----------
        input: itkImageRGBAUC3 const *

        """
        return _itkImageSinkPython.itkImageSinkIRGBAUC3_SetInput(self, input)

    def GetInput(self, *args):
        r"""
        GetInput(self) -> itkImageRGBAUC3
        GetInput(self, idx) -> itkImageRGBAUC3

        Parameters
        ----------
        idx: unsigned int

        GetInput(self, key) -> itkImageRGBAUC3

        Parameters
        ----------
        key: std::string const &

        """
        return _itkImageSinkPython.itkImageSinkIRGBAUC3_GetInput(self, *args)

    def SetCoordinateTolerance(self, _arg):
        r"""
        SetCoordinateTolerance(self, _arg)

        Parameters
        ----------
        _arg: double

        """
        return _itkImageSinkPython.itkImageSinkIRGBAUC3_SetCoordinateTolerance(self, _arg)

    def GetCoordinateTolerance(self):
        r"""GetCoordinateTolerance(self) -> double"""
        return _itkImageSinkPython.itkImageSinkIRGBAUC3_GetCoordinateTolerance(self)

    def SetDirectionTolerance(self, _arg):
        r"""
        SetDirectionTolerance(self, _arg)

        Parameters
        ----------
        _arg: double

        """
        return _itkImageSinkPython.itkImageSinkIRGBAUC3_SetDirectionTolerance(self, _arg)

    def GetDirectionTolerance(self):
        r"""GetDirectionTolerance(self) -> double"""
        return _itkImageSinkPython.itkImageSinkIRGBAUC3_GetDirectionTolerance(self)
    __swig_destroy__ = _itkImageSinkPython.delete_itkImageSinkIRGBAUC3

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

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

        """
        return _itkImageSinkPython.itkImageSinkIRGBAUC3_cast(obj)

# Register itkImageSinkIRGBAUC3 in _itkImageSinkPython:
_itkImageSinkPython.itkImageSinkIRGBAUC3_swigregister(itkImageSinkIRGBAUC3)
class itkImageSinkIRGBUC2(itk.ITKCommonBasePython.itkStreamingProcessObject):
    r"""Proxy of C++ itkImageSinkIRGBUC2 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

    def SetInput(self, input):
        r"""
        SetInput(self, input)

        Parameters
        ----------
        input: itkImageRGBUC2 const *

        """
        return _itkImageSinkPython.itkImageSinkIRGBUC2_SetInput(self, input)

    def GetInput(self, *args):
        r"""
        GetInput(self) -> itkImageRGBUC2
        GetInput(self, idx) -> itkImageRGBUC2

        Parameters
        ----------
        idx: unsigned int

        GetInput(self, key) -> itkImageRGBUC2

        Parameters
        ----------
        key: std::string const &

        """
        return _itkImageSinkPython.itkImageSinkIRGBUC2_GetInput(self, *args)

    def SetCoordinateTolerance(self, _arg):
        r"""
        SetCoordinateTolerance(self, _arg)

        Parameters
        ----------
        _arg: double

        """
        return _itkImageSinkPython.itkImageSinkIRGBUC2_SetCoordinateTolerance(self, _arg)

    def GetCoordinateTolerance(self):
        r"""GetCoordinateTolerance(self) -> double"""
        return _itkImageSinkPython.itkImageSinkIRGBUC2_GetCoordinateTolerance(self)

    def SetDirectionTolerance(self, _arg):
        r"""
        SetDirectionTolerance(self, _arg)

        Parameters
        ----------
        _arg: double

        """
        return _itkImageSinkPython.itkImageSinkIRGBUC2_SetDirectionTolerance(self, _arg)

    def GetDirectionTolerance(self):
        r"""GetDirectionTolerance(self) -> double"""
        return _itkImageSinkPython.itkImageSinkIRGBUC2_GetDirectionTolerance(self)
    __swig_destroy__ = _itkImageSinkPython.delete_itkImageSinkIRGBUC2

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

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

        """
        return _itkImageSinkPython.itkImageSinkIRGBUC2_cast(obj)

# Register itkImageSinkIRGBUC2 in _itkImageSinkPython:
_itkImageSinkPython.itkImageSinkIRGBUC2_swigregister(itkImageSinkIRGBUC2)
class itkImageSinkIRGBUC3(itk.ITKCommonBasePython.itkStreamingProcessObject):
    r"""Proxy of C++ itkImageSinkIRGBUC3 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

    def SetInput(self, input):
        r"""
        SetInput(self, input)

        Parameters
        ----------
        input: itkImageRGBUC3 const *

        """
        return _itkImageSinkPython.itkImageSinkIRGBUC3_SetInput(self, input)

    def GetInput(self, *args):
        r"""
        GetInput(self) -> itkImageRGBUC3
        GetInput(self, idx) -> itkImageRGBUC3

        Parameters
        ----------
        idx: unsigned int

        GetInput(self, key) -> itkImageRGBUC3

        Parameters
        ----------
        key: std::string const &

        """
        return _itkImageSinkPython.itkImageSinkIRGBUC3_GetInput(self, *args)

    def SetCoordinateTolerance(self, _arg):
        r"""
        SetCoordinateTolerance(self, _arg)

        Parameters
        ----------
        _arg: double

        """
        return _itkImageSinkPython.itkImageSinkIRGBUC3_SetCoordinateTolerance(self, _arg)

    def GetCoordinateTolerance(self):
        r"""GetCoordinateTolerance(self) -> double"""
        return _itkImageSinkPython.itkImageSinkIRGBUC3_GetCoordinateTolerance(self)

    def SetDirectionTolerance(self, _arg):
        r"""
        SetDirectionTolerance(self, _arg)

        Parameters
        ----------
        _arg: double

        """
        return _itkImageSinkPython.itkImageSinkIRGBUC3_SetDirectionTolerance(self, _arg)

    def GetDirectionTolerance(self):
        r"""GetDirectionTolerance(self) -> double"""
        return _itkImageSinkPython.itkImageSinkIRGBUC3_GetDirectionTolerance(self)
    __swig_destroy__ = _itkImageSinkPython.delete_itkImageSinkIRGBUC3

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

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

        """
        return _itkImageSinkPython.itkImageSinkIRGBUC3_cast(obj)

# Register itkImageSinkIRGBUC3 in _itkImageSinkPython:
_itkImageSinkPython.itkImageSinkIRGBUC3_swigregister(itkImageSinkIRGBUC3)
class itkImageSinkISS2(itk.ITKCommonBasePython.itkStreamingProcessObject):
    r"""Proxy of C++ itkImageSinkISS2 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

    def SetInput(self, input):
        r"""
        SetInput(self, input)

        Parameters
        ----------
        input: itkImageSS2 const *

        """
        return _itkImageSinkPython.itkImageSinkISS2_SetInput(self, input)

    def GetInput(self, *args):
        r"""
        GetInput(self) -> itkImageSS2
        GetInput(self, idx) -> itkImageSS2

        Parameters
        ----------
        idx: unsigned int

        GetInput(self, key) -> itkImageSS2

        Parameters
        ----------
        key: std::string const &

        """
        return _itkImageSinkPython.itkImageSinkISS2_GetInput(self, *args)

    def SetCoordinateTolerance(self, _arg):
        r"""
        SetCoordinateTolerance(self, _arg)

        Parameters
        ----------
        _arg: double

        """
        return _itkImageSinkPython.itkImageSinkISS2_SetCoordinateTolerance(self, _arg)

    def GetCoordinateTolerance(self):
        r"""GetCoordinateTolerance(self) -> double"""
        return _itkImageSinkPython.itkImageSinkISS2_GetCoordinateTolerance(self)

    def SetDirectionTolerance(self, _arg):
        r"""
        SetDirectionTolerance(self, _arg)

        Parameters
        ----------
        _arg: double

        """
        return _itkImageSinkPython.itkImageSinkISS2_SetDirectionTolerance(self, _arg)

    def GetDirectionTolerance(self):
        r"""GetDirectionTolerance(self) -> double"""
        return _itkImageSinkPython.itkImageSinkISS2_GetDirectionTolerance(self)
    __swig_destroy__ = _itkImageSinkPython.delete_itkImageSinkISS2

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

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

        """
        return _itkImageSinkPython.itkImageSinkISS2_cast(obj)

# Register itkImageSinkISS2 in _itkImageSinkPython:
_itkImageSinkPython.itkImageSinkISS2_swigregister(itkImageSinkISS2)
class itkImageSinkISS3(itk.ITKCommonBasePython.itkStreamingProcessObject):
    r"""Proxy of C++ itkImageSinkISS3 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

    def SetInput(self, input):
        r"""
        SetInput(self, input)

        Parameters
        ----------
        input: itkImageSS3 const *

        """
        return _itkImageSinkPython.itkImageSinkISS3_SetInput(self, input)

    def GetInput(self, *args):
        r"""
        GetInput(self) -> itkImageSS3
        GetInput(self, idx) -> itkImageSS3

        Parameters
        ----------
        idx: unsigned int

        GetInput(self, key) -> itkImageSS3

        Parameters
        ----------
        key: std::string const &

        """
        return _itkImageSinkPython.itkImageSinkISS3_GetInput(self, *args)

    def SetCoordinateTolerance(self, _arg):
        r"""
        SetCoordinateTolerance(self, _arg)

        Parameters
        ----------
        _arg: double

        """
        return _itkImageSinkPython.itkImageSinkISS3_SetCoordinateTolerance(self, _arg)

    def GetCoordinateTolerance(self):
        r"""GetCoordinateTolerance(self) -> double"""
        return _itkImageSinkPython.itkImageSinkISS3_GetCoordinateTolerance(self)

    def SetDirectionTolerance(self, _arg):
        r"""
        SetDirectionTolerance(self, _arg)

        Parameters
        ----------
        _arg: double

        """
        return _itkImageSinkPython.itkImageSinkISS3_SetDirectionTolerance(self, _arg)

    def GetDirectionTolerance(self):
        r"""GetDirectionTolerance(self) -> double"""
        return _itkImageSinkPython.itkImageSinkISS3_GetDirectionTolerance(self)
    __swig_destroy__ = _itkImageSinkPython.delete_itkImageSinkISS3

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

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

        """
        return _itkImageSinkPython.itkImageSinkISS3_cast(obj)

# Register itkImageSinkISS3 in _itkImageSinkPython:
_itkImageSinkPython.itkImageSinkISS3_swigregister(itkImageSinkISS3)
class itkImageSinkIUC2(itk.ITKCommonBasePython.itkStreamingProcessObject):
    r"""Proxy of C++ itkImageSinkIUC2 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

    def SetInput(self, input):
        r"""
        SetInput(self, input)

        Parameters
        ----------
        input: itkImageUC2 const *

        """
        return _itkImageSinkPython.itkImageSinkIUC2_SetInput(self, input)

    def GetInput(self, *args):
        r"""
        GetInput(self) -> itkImageUC2
        GetInput(self, idx) -> itkImageUC2

        Parameters
        ----------
        idx: unsigned int

        GetInput(self, key) -> itkImageUC2

        Parameters
        ----------
        key: std::string const &

        """
        return _itkImageSinkPython.itkImageSinkIUC2_GetInput(self, *args)

    def SetCoordinateTolerance(self, _arg):
        r"""
        SetCoordinateTolerance(self, _arg)

        Parameters
        ----------
        _arg: double

        """
        return _itkImageSinkPython.itkImageSinkIUC2_SetCoordinateTolerance(self, _arg)

    def GetCoordinateTolerance(self):
        r"""GetCoordinateTolerance(self) -> double"""
        return _itkImageSinkPython.itkImageSinkIUC2_GetCoordinateTolerance(self)

    def SetDirectionTolerance(self, _arg):
        r"""
        SetDirectionTolerance(self, _arg)

        Parameters
        ----------
        _arg: double

        """
        return _itkImageSinkPython.itkImageSinkIUC2_SetDirectionTolerance(self, _arg)

    def GetDirectionTolerance(self):
        r"""GetDirectionTolerance(self) -> double"""
        return _itkImageSinkPython.itkImageSinkIUC2_GetDirectionTolerance(self)
    __swig_destroy__ = _itkImageSinkPython.delete_itkImageSinkIUC2

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

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

        """
        return _itkImageSinkPython.itkImageSinkIUC2_cast(obj)

# Register itkImageSinkIUC2 in _itkImageSinkPython:
_itkImageSinkPython.itkImageSinkIUC2_swigregister(itkImageSinkIUC2)
class itkImageSinkIUC3(itk.ITKCommonBasePython.itkStreamingProcessObject):
    r"""Proxy of C++ itkImageSinkIUC3 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

    def SetInput(self, input):
        r"""
        SetInput(self, input)

        Parameters
        ----------
        input: itkImageUC3 const *

        """
        return _itkImageSinkPython.itkImageSinkIUC3_SetInput(self, input)

    def GetInput(self, *args):
        r"""
        GetInput(self) -> itkImageUC3
        GetInput(self, idx) -> itkImageUC3

        Parameters
        ----------
        idx: unsigned int

        GetInput(self, key) -> itkImageUC3

        Parameters
        ----------
        key: std::string const &

        """
        return _itkImageSinkPython.itkImageSinkIUC3_GetInput(self, *args)

    def SetCoordinateTolerance(self, _arg):
        r"""
        SetCoordinateTolerance(self, _arg)

        Parameters
        ----------
        _arg: double

        """
        return _itkImageSinkPython.itkImageSinkIUC3_SetCoordinateTolerance(self, _arg)

    def GetCoordinateTolerance(self):
        r"""GetCoordinateTolerance(self) -> double"""
        return _itkImageSinkPython.itkImageSinkIUC3_GetCoordinateTolerance(self)

    def SetDirectionTolerance(self, _arg):
        r"""
        SetDirectionTolerance(self, _arg)

        Parameters
        ----------
        _arg: double

        """
        return _itkImageSinkPython.itkImageSinkIUC3_SetDirectionTolerance(self, _arg)

    def GetDirectionTolerance(self):
        r"""GetDirectionTolerance(self) -> double"""
        return _itkImageSinkPython.itkImageSinkIUC3_GetDirectionTolerance(self)
    __swig_destroy__ = _itkImageSinkPython.delete_itkImageSinkIUC3

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

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

        """
        return _itkImageSinkPython.itkImageSinkIUC3_cast(obj)

# Register itkImageSinkIUC3 in _itkImageSinkPython:
_itkImageSinkPython.itkImageSinkIUC3_swigregister(itkImageSinkIUC3)
class itkImageSinkIVF22(itk.ITKCommonBasePython.itkStreamingProcessObject):
    r"""Proxy of C++ itkImageSinkIVF22 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

    def SetInput(self, input):
        r"""
        SetInput(self, input)

        Parameters
        ----------
        input: itkImageVF22 const *

        """
        return _itkImageSinkPython.itkImageSinkIVF22_SetInput(self, input)

    def GetInput(self, *args):
        r"""
        GetInput(self) -> itkImageVF22
        GetInput(self, idx) -> itkImageVF22

        Parameters
        ----------
        idx: unsigned int

        GetInput(self, key) -> itkImageVF22

        Parameters
        ----------
        key: std::string const &

        """
        return _itkImageSinkPython.itkImageSinkIVF22_GetInput(self, *args)

    def SetCoordinateTolerance(self, _arg):
        r"""
        SetCoordinateTolerance(self, _arg)

        Parameters
        ----------
        _arg: double

        """
        return _itkImageSinkPython.itkImageSinkIVF22_SetCoordinateTolerance(self, _arg)

    def GetCoordinateTolerance(self):
        r"""GetCoordinateTolerance(self) -> double"""
        return _itkImageSinkPython.itkImageSinkIVF22_GetCoordinateTolerance(self)

    def SetDirectionTolerance(self, _arg):
        r"""
        SetDirectionTolerance(self, _arg)

        Parameters
        ----------
        _arg: double

        """
        return _itkImageSinkPython.itkImageSinkIVF22_SetDirectionTolerance(self, _arg)

    def GetDirectionTolerance(self):
        r"""GetDirectionTolerance(self) -> double"""
        return _itkImageSinkPython.itkImageSinkIVF22_GetDirectionTolerance(self)
    __swig_destroy__ = _itkImageSinkPython.delete_itkImageSinkIVF22

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

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

        """
        return _itkImageSinkPython.itkImageSinkIVF22_cast(obj)

# Register itkImageSinkIVF22 in _itkImageSinkPython:
_itkImageSinkPython.itkImageSinkIVF22_swigregister(itkImageSinkIVF22)
class itkImageSinkIVF23(itk.ITKCommonBasePython.itkStreamingProcessObject):
    r"""Proxy of C++ itkImageSinkIVF23 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

    def SetInput(self, input):
        r"""
        SetInput(self, input)

        Parameters
        ----------
        input: itkImageVF23 const *

        """
        return _itkImageSinkPython.itkImageSinkIVF23_SetInput(self, input)

    def GetInput(self, *args):
        r"""
        GetInput(self) -> itkImageVF23
        GetInput(self, idx) -> itkImageVF23

        Parameters
        ----------
        idx: unsigned int

        GetInput(self, key) -> itkImageVF23

        Parameters
        ----------
        key: std::string const &

        """
        return _itkImageSinkPython.itkImageSinkIVF23_GetInput(self, *args)

    def SetCoordinateTolerance(self, _arg):
        r"""
        SetCoordinateTolerance(self, _arg)

        Parameters
        ----------
        _arg: double

        """
        return _itkImageSinkPython.itkImageSinkIVF23_SetCoordinateTolerance(self, _arg)

    def GetCoordinateTolerance(self):
        r"""GetCoordinateTolerance(self) -> double"""
        return _itkImageSinkPython.itkImageSinkIVF23_GetCoordinateTolerance(self)

    def SetDirectionTolerance(self, _arg):
        r"""
        SetDirectionTolerance(self, _arg)

        Parameters
        ----------
        _arg: double

        """
        return _itkImageSinkPython.itkImageSinkIVF23_SetDirectionTolerance(self, _arg)

    def GetDirectionTolerance(self):
        r"""GetDirectionTolerance(self) -> double"""
        return _itkImageSinkPython.itkImageSinkIVF23_GetDirectionTolerance(self)
    __swig_destroy__ = _itkImageSinkPython.delete_itkImageSinkIVF23

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

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

        """
        return _itkImageSinkPython.itkImageSinkIVF23_cast(obj)

# Register itkImageSinkIVF23 in _itkImageSinkPython:
_itkImageSinkPython.itkImageSinkIVF23_swigregister(itkImageSinkIVF23)
class itkImageSinkIVF32(itk.ITKCommonBasePython.itkStreamingProcessObject):
    r"""Proxy of C++ itkImageSinkIVF32 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

    def SetInput(self, input):
        r"""
        SetInput(self, input)

        Parameters
        ----------
        input: itkImageVF32 const *

        """
        return _itkImageSinkPython.itkImageSinkIVF32_SetInput(self, input)

    def GetInput(self, *args):
        r"""
        GetInput(self) -> itkImageVF32
        GetInput(self, idx) -> itkImageVF32

        Parameters
        ----------
        idx: unsigned int

        GetInput(self, key) -> itkImageVF32

        Parameters
        ----------
        key: std::string const &

        """
        return _itkImageSinkPython.itkImageSinkIVF32_GetInput(self, *args)

    def SetCoordinateTolerance(self, _arg):
        r"""
        SetCoordinateTolerance(self, _arg)

        Parameters
        ----------
        _arg: double

        """
        return _itkImageSinkPython.itkImageSinkIVF32_SetCoordinateTolerance(self, _arg)

    def GetCoordinateTolerance(self):
        r"""GetCoordinateTolerance(self) -> double"""
        return _itkImageSinkPython.itkImageSinkIVF32_GetCoordinateTolerance(self)

    def SetDirectionTolerance(self, _arg):
        r"""
        SetDirectionTolerance(self, _arg)

        Parameters
        ----------
        _arg: double

        """
        return _itkImageSinkPython.itkImageSinkIVF32_SetDirectionTolerance(self, _arg)

    def GetDirectionTolerance(self):
        r"""GetDirectionTolerance(self) -> double"""
        return _itkImageSinkPython.itkImageSinkIVF32_GetDirectionTolerance(self)
    __swig_destroy__ = _itkImageSinkPython.delete_itkImageSinkIVF32

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

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

        """
        return _itkImageSinkPython.itkImageSinkIVF32_cast(obj)

# Register itkImageSinkIVF32 in _itkImageSinkPython:
_itkImageSinkPython.itkImageSinkIVF32_swigregister(itkImageSinkIVF32)
class itkImageSinkIVF33(itk.ITKCommonBasePython.itkStreamingProcessObject):
    r"""Proxy of C++ itkImageSinkIVF33 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

    def SetInput(self, input):
        r"""
        SetInput(self, input)

        Parameters
        ----------
        input: itkImageVF33 const *

        """
        return _itkImageSinkPython.itkImageSinkIVF33_SetInput(self, input)

    def GetInput(self, *args):
        r"""
        GetInput(self) -> itkImageVF33
        GetInput(self, idx) -> itkImageVF33

        Parameters
        ----------
        idx: unsigned int

        GetInput(self, key) -> itkImageVF33

        Parameters
        ----------
        key: std::string const &

        """
        return _itkImageSinkPython.itkImageSinkIVF33_GetInput(self, *args)

    def SetCoordinateTolerance(self, _arg):
        r"""
        SetCoordinateTolerance(self, _arg)

        Parameters
        ----------
        _arg: double

        """
        return _itkImageSinkPython.itkImageSinkIVF33_SetCoordinateTolerance(self, _arg)

    def GetCoordinateTolerance(self):
        r"""GetCoordinateTolerance(self) -> double"""
        return _itkImageSinkPython.itkImageSinkIVF33_GetCoordinateTolerance(self)

    def SetDirectionTolerance(self, _arg):
        r"""
        SetDirectionTolerance(self, _arg)

        Parameters
        ----------
        _arg: double

        """
        return _itkImageSinkPython.itkImageSinkIVF33_SetDirectionTolerance(self, _arg)

    def GetDirectionTolerance(self):
        r"""GetDirectionTolerance(self) -> double"""
        return _itkImageSinkPython.itkImageSinkIVF33_GetDirectionTolerance(self)
    __swig_destroy__ = _itkImageSinkPython.delete_itkImageSinkIVF33

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

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

        """
        return _itkImageSinkPython.itkImageSinkIVF33_cast(obj)

# Register itkImageSinkIVF33 in _itkImageSinkPython:
_itkImageSinkPython.itkImageSinkIVF33_swigregister(itkImageSinkIVF33)
class itkImageSinkIVF42(itk.ITKCommonBasePython.itkStreamingProcessObject):
    r"""Proxy of C++ itkImageSinkIVF42 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

    def SetInput(self, input):
        r"""
        SetInput(self, input)

        Parameters
        ----------
        input: itkImageVF42 const *

        """
        return _itkImageSinkPython.itkImageSinkIVF42_SetInput(self, input)

    def GetInput(self, *args):
        r"""
        GetInput(self) -> itkImageVF42
        GetInput(self, idx) -> itkImageVF42

        Parameters
        ----------
        idx: unsigned int

        GetInput(self, key) -> itkImageVF42

        Parameters
        ----------
        key: std::string const &

        """
        return _itkImageSinkPython.itkImageSinkIVF42_GetInput(self, *args)

    def SetCoordinateTolerance(self, _arg):
        r"""
        SetCoordinateTolerance(self, _arg)

        Parameters
        ----------
        _arg: double

        """
        return _itkImageSinkPython.itkImageSinkIVF42_SetCoordinateTolerance(self, _arg)

    def GetCoordinateTolerance(self):
        r"""GetCoordinateTolerance(self) -> double"""
        return _itkImageSinkPython.itkImageSinkIVF42_GetCoordinateTolerance(self)

    def SetDirectionTolerance(self, _arg):
        r"""
        SetDirectionTolerance(self, _arg)

        Parameters
        ----------
        _arg: double

        """
        return _itkImageSinkPython.itkImageSinkIVF42_SetDirectionTolerance(self, _arg)

    def GetDirectionTolerance(self):
        r"""GetDirectionTolerance(self) -> double"""
        return _itkImageSinkPython.itkImageSinkIVF42_GetDirectionTolerance(self)
    __swig_destroy__ = _itkImageSinkPython.delete_itkImageSinkIVF42

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

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

        """
        return _itkImageSinkPython.itkImageSinkIVF42_cast(obj)

# Register itkImageSinkIVF42 in _itkImageSinkPython:
_itkImageSinkPython.itkImageSinkIVF42_swigregister(itkImageSinkIVF42)
class itkImageSinkIVF43(itk.ITKCommonBasePython.itkStreamingProcessObject):
    r"""Proxy of C++ itkImageSinkIVF43 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

    def SetInput(self, input):
        r"""
        SetInput(self, input)

        Parameters
        ----------
        input: itkImageVF43 const *

        """
        return _itkImageSinkPython.itkImageSinkIVF43_SetInput(self, input)

    def GetInput(self, *args):
        r"""
        GetInput(self) -> itkImageVF43
        GetInput(self, idx) -> itkImageVF43

        Parameters
        ----------
        idx: unsigned int

        GetInput(self, key) -> itkImageVF43

        Parameters
        ----------
        key: std::string const &

        """
        return _itkImageSinkPython.itkImageSinkIVF43_GetInput(self, *args)

    def SetCoordinateTolerance(self, _arg):
        r"""
        SetCoordinateTolerance(self, _arg)

        Parameters
        ----------
        _arg: double

        """
        return _itkImageSinkPython.itkImageSinkIVF43_SetCoordinateTolerance(self, _arg)

    def GetCoordinateTolerance(self):
        r"""GetCoordinateTolerance(self) -> double"""
        return _itkImageSinkPython.itkImageSinkIVF43_GetCoordinateTolerance(self)

    def SetDirectionTolerance(self, _arg):
        r"""
        SetDirectionTolerance(self, _arg)

        Parameters
        ----------
        _arg: double

        """
        return _itkImageSinkPython.itkImageSinkIVF43_SetDirectionTolerance(self, _arg)

    def GetDirectionTolerance(self):
        r"""GetDirectionTolerance(self) -> double"""
        return _itkImageSinkPython.itkImageSinkIVF43_GetDirectionTolerance(self)
    __swig_destroy__ = _itkImageSinkPython.delete_itkImageSinkIVF43

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

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

        """
        return _itkImageSinkPython.itkImageSinkIVF43_cast(obj)

# Register itkImageSinkIVF43 in _itkImageSinkPython:
_itkImageSinkPython.itkImageSinkIVF43_swigregister(itkImageSinkIVF43)
class itkImageSinkVIF2(itk.ITKCommonBasePython.itkStreamingProcessObject):
    r"""Proxy of C++ itkImageSinkVIF2 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

    def SetInput(self, input):
        r"""
        SetInput(self, input)

        Parameters
        ----------
        input: itkVectorImageF2 const *

        """
        return _itkImageSinkPython.itkImageSinkVIF2_SetInput(self, input)

    def GetInput(self, *args):
        r"""
        GetInput(self) -> itkVectorImageF2
        GetInput(self, idx) -> itkVectorImageF2

        Parameters
        ----------
        idx: unsigned int

        GetInput(self, key) -> itkVectorImageF2

        Parameters
        ----------
        key: std::string const &

        """
        return _itkImageSinkPython.itkImageSinkVIF2_GetInput(self, *args)

    def SetCoordinateTolerance(self, _arg):
        r"""
        SetCoordinateTolerance(self, _arg)

        Parameters
        ----------
        _arg: double

        """
        return _itkImageSinkPython.itkImageSinkVIF2_SetCoordinateTolerance(self, _arg)

    def GetCoordinateTolerance(self):
        r"""GetCoordinateTolerance(self) -> double"""
        return _itkImageSinkPython.itkImageSinkVIF2_GetCoordinateTolerance(self)

    def SetDirectionTolerance(self, _arg):
        r"""
        SetDirectionTolerance(self, _arg)

        Parameters
        ----------
        _arg: double

        """
        return _itkImageSinkPython.itkImageSinkVIF2_SetDirectionTolerance(self, _arg)

    def GetDirectionTolerance(self):
        r"""GetDirectionTolerance(self) -> double"""
        return _itkImageSinkPython.itkImageSinkVIF2_GetDirectionTolerance(self)
    __swig_destroy__ = _itkImageSinkPython.delete_itkImageSinkVIF2

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

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

        """
        return _itkImageSinkPython.itkImageSinkVIF2_cast(obj)

# Register itkImageSinkVIF2 in _itkImageSinkPython:
_itkImageSinkPython.itkImageSinkVIF2_swigregister(itkImageSinkVIF2)
class itkImageSinkVIF3(itk.ITKCommonBasePython.itkStreamingProcessObject):
    r"""Proxy of C++ itkImageSinkVIF3 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

    def SetInput(self, input):
        r"""
        SetInput(self, input)

        Parameters
        ----------
        input: itkVectorImageF3 const *

        """
        return _itkImageSinkPython.itkImageSinkVIF3_SetInput(self, input)

    def GetInput(self, *args):
        r"""
        GetInput(self) -> itkVectorImageF3
        GetInput(self, idx) -> itkVectorImageF3

        Parameters
        ----------
        idx: unsigned int

        GetInput(self, key) -> itkVectorImageF3

        Parameters
        ----------
        key: std::string const &

        """
        return _itkImageSinkPython.itkImageSinkVIF3_GetInput(self, *args)

    def SetCoordinateTolerance(self, _arg):
        r"""
        SetCoordinateTolerance(self, _arg)

        Parameters
        ----------
        _arg: double

        """
        return _itkImageSinkPython.itkImageSinkVIF3_SetCoordinateTolerance(self, _arg)

    def GetCoordinateTolerance(self):
        r"""GetCoordinateTolerance(self) -> double"""
        return _itkImageSinkPython.itkImageSinkVIF3_GetCoordinateTolerance(self)

    def SetDirectionTolerance(self, _arg):
        r"""
        SetDirectionTolerance(self, _arg)

        Parameters
        ----------
        _arg: double

        """
        return _itkImageSinkPython.itkImageSinkVIF3_SetDirectionTolerance(self, _arg)

    def GetDirectionTolerance(self):
        r"""GetDirectionTolerance(self) -> double"""
        return _itkImageSinkPython.itkImageSinkVIF3_GetDirectionTolerance(self)
    __swig_destroy__ = _itkImageSinkPython.delete_itkImageSinkVIF3

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

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

        """
        return _itkImageSinkPython.itkImageSinkVIF3_cast(obj)

# Register itkImageSinkVIF3 in _itkImageSinkPython:
_itkImageSinkPython.itkImageSinkVIF3_swigregister(itkImageSinkVIF3)
class itkImageSinkVISS2(itk.ITKCommonBasePython.itkStreamingProcessObject):
    r"""Proxy of C++ itkImageSinkVISS2 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

    def SetInput(self, input):
        r"""
        SetInput(self, input)

        Parameters
        ----------
        input: itkVectorImageSS2 const *

        """
        return _itkImageSinkPython.itkImageSinkVISS2_SetInput(self, input)

    def GetInput(self, *args):
        r"""
        GetInput(self) -> itkVectorImageSS2
        GetInput(self, idx) -> itkVectorImageSS2

        Parameters
        ----------
        idx: unsigned int

        GetInput(self, key) -> itkVectorImageSS2

        Parameters
        ----------
        key: std::string const &

        """
        return _itkImageSinkPython.itkImageSinkVISS2_GetInput(self, *args)

    def SetCoordinateTolerance(self, _arg):
        r"""
        SetCoordinateTolerance(self, _arg)

        Parameters
        ----------
        _arg: double

        """
        return _itkImageSinkPython.itkImageSinkVISS2_SetCoordinateTolerance(self, _arg)

    def GetCoordinateTolerance(self):
        r"""GetCoordinateTolerance(self) -> double"""
        return _itkImageSinkPython.itkImageSinkVISS2_GetCoordinateTolerance(self)

    def SetDirectionTolerance(self, _arg):
        r"""
        SetDirectionTolerance(self, _arg)

        Parameters
        ----------
        _arg: double

        """
        return _itkImageSinkPython.itkImageSinkVISS2_SetDirectionTolerance(self, _arg)

    def GetDirectionTolerance(self):
        r"""GetDirectionTolerance(self) -> double"""
        return _itkImageSinkPython.itkImageSinkVISS2_GetDirectionTolerance(self)
    __swig_destroy__ = _itkImageSinkPython.delete_itkImageSinkVISS2

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

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

        """
        return _itkImageSinkPython.itkImageSinkVISS2_cast(obj)

# Register itkImageSinkVISS2 in _itkImageSinkPython:
_itkImageSinkPython.itkImageSinkVISS2_swigregister(itkImageSinkVISS2)
class itkImageSinkVISS3(itk.ITKCommonBasePython.itkStreamingProcessObject):
    r"""Proxy of C++ itkImageSinkVISS3 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

    def SetInput(self, input):
        r"""
        SetInput(self, input)

        Parameters
        ----------
        input: itkVectorImageSS3 const *

        """
        return _itkImageSinkPython.itkImageSinkVISS3_SetInput(self, input)

    def GetInput(self, *args):
        r"""
        GetInput(self) -> itkVectorImageSS3
        GetInput(self, idx) -> itkVectorImageSS3

        Parameters
        ----------
        idx: unsigned int

        GetInput(self, key) -> itkVectorImageSS3

        Parameters
        ----------
        key: std::string const &

        """
        return _itkImageSinkPython.itkImageSinkVISS3_GetInput(self, *args)

    def SetCoordinateTolerance(self, _arg):
        r"""
        SetCoordinateTolerance(self, _arg)

        Parameters
        ----------
        _arg: double

        """
        return _itkImageSinkPython.itkImageSinkVISS3_SetCoordinateTolerance(self, _arg)

    def GetCoordinateTolerance(self):
        r"""GetCoordinateTolerance(self) -> double"""
        return _itkImageSinkPython.itkImageSinkVISS3_GetCoordinateTolerance(self)

    def SetDirectionTolerance(self, _arg):
        r"""
        SetDirectionTolerance(self, _arg)

        Parameters
        ----------
        _arg: double

        """
        return _itkImageSinkPython.itkImageSinkVISS3_SetDirectionTolerance(self, _arg)

    def GetDirectionTolerance(self):
        r"""GetDirectionTolerance(self) -> double"""
        return _itkImageSinkPython.itkImageSinkVISS3_GetDirectionTolerance(self)
    __swig_destroy__ = _itkImageSinkPython.delete_itkImageSinkVISS3

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

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

        """
        return _itkImageSinkPython.itkImageSinkVISS3_cast(obj)

# Register itkImageSinkVISS3 in _itkImageSinkPython:
_itkImageSinkPython.itkImageSinkVISS3_swigregister(itkImageSinkVISS3)
class itkImageSinkVIUC2(itk.ITKCommonBasePython.itkStreamingProcessObject):
    r"""Proxy of C++ itkImageSinkVIUC2 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

    def SetInput(self, input):
        r"""
        SetInput(self, input)

        Parameters
        ----------
        input: itkVectorImageUC2 const *

        """
        return _itkImageSinkPython.itkImageSinkVIUC2_SetInput(self, input)

    def GetInput(self, *args):
        r"""
        GetInput(self) -> itkVectorImageUC2
        GetInput(self, idx) -> itkVectorImageUC2

        Parameters
        ----------
        idx: unsigned int

        GetInput(self, key) -> itkVectorImageUC2

        Parameters
        ----------
        key: std::string const &

        """
        return _itkImageSinkPython.itkImageSinkVIUC2_GetInput(self, *args)

    def SetCoordinateTolerance(self, _arg):
        r"""
        SetCoordinateTolerance(self, _arg)

        Parameters
        ----------
        _arg: double

        """
        return _itkImageSinkPython.itkImageSinkVIUC2_SetCoordinateTolerance(self, _arg)

    def GetCoordinateTolerance(self):
        r"""GetCoordinateTolerance(self) -> double"""
        return _itkImageSinkPython.itkImageSinkVIUC2_GetCoordinateTolerance(self)

    def SetDirectionTolerance(self, _arg):
        r"""
        SetDirectionTolerance(self, _arg)

        Parameters
        ----------
        _arg: double

        """
        return _itkImageSinkPython.itkImageSinkVIUC2_SetDirectionTolerance(self, _arg)

    def GetDirectionTolerance(self):
        r"""GetDirectionTolerance(self) -> double"""
        return _itkImageSinkPython.itkImageSinkVIUC2_GetDirectionTolerance(self)
    __swig_destroy__ = _itkImageSinkPython.delete_itkImageSinkVIUC2

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

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

        """
        return _itkImageSinkPython.itkImageSinkVIUC2_cast(obj)

# Register itkImageSinkVIUC2 in _itkImageSinkPython:
_itkImageSinkPython.itkImageSinkVIUC2_swigregister(itkImageSinkVIUC2)
class itkImageSinkVIUC3(itk.ITKCommonBasePython.itkStreamingProcessObject):
    r"""Proxy of C++ itkImageSinkVIUC3 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

    def SetInput(self, input):
        r"""
        SetInput(self, input)

        Parameters
        ----------
        input: itkVectorImageUC3 const *

        """
        return _itkImageSinkPython.itkImageSinkVIUC3_SetInput(self, input)

    def GetInput(self, *args):
        r"""
        GetInput(self) -> itkVectorImageUC3
        GetInput(self, idx) -> itkVectorImageUC3

        Parameters
        ----------
        idx: unsigned int

        GetInput(self, key) -> itkVectorImageUC3

        Parameters
        ----------
        key: std::string const &

        """
        return _itkImageSinkPython.itkImageSinkVIUC3_GetInput(self, *args)

    def SetCoordinateTolerance(self, _arg):
        r"""
        SetCoordinateTolerance(self, _arg)

        Parameters
        ----------
        _arg: double

        """
        return _itkImageSinkPython.itkImageSinkVIUC3_SetCoordinateTolerance(self, _arg)

    def GetCoordinateTolerance(self):
        r"""GetCoordinateTolerance(self) -> double"""
        return _itkImageSinkPython.itkImageSinkVIUC3_GetCoordinateTolerance(self)

    def SetDirectionTolerance(self, _arg):
        r"""
        SetDirectionTolerance(self, _arg)

        Parameters
        ----------
        _arg: double

        """
        return _itkImageSinkPython.itkImageSinkVIUC3_SetDirectionTolerance(self, _arg)

    def GetDirectionTolerance(self):
        r"""GetDirectionTolerance(self) -> double"""
        return _itkImageSinkPython.itkImageSinkVIUC3_GetDirectionTolerance(self)
    __swig_destroy__ = _itkImageSinkPython.delete_itkImageSinkVIUC3

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

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

        """
        return _itkImageSinkPython.itkImageSinkVIUC3_cast(obj)

# Register itkImageSinkVIUC3 in _itkImageSinkPython:
_itkImageSinkPython.itkImageSinkVIUC3_swigregister(itkImageSinkVIUC3)

