# 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 _itkStreamingImageFilterPython
else:
    import _itkStreamingImageFilterPython

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.ITKCommonBasePython
import itk.itkMatrixPython
import itk.vnl_matrix_fixedPython
import itk.vnl_vectorPython
import itk.stdcomplexPython
import itk.pyBasePython
import itk.vnl_matrixPython
import itk.itkPointPython
import itk.vnl_vector_refPython
import itk.itkFixedArrayPython
import itk.itkVectorPython
import itk.itkCovariantVectorPython
import itk.itkImageToImageFilterAPython
import itk.itkImageRegionPython
import itk.itkSizePython
import itk.itkIndexPython
import itk.itkOffsetPython
import itk.itkImageSourcePython
import itk.itkImagePython
import itk.itkRGBPixelPython
import itk.itkSymmetricSecondRankTensorPython
import itk.itkRGBAPixelPython
import itk.itkImageSourceCommonPython
import itk.itkVectorImagePython
import itk.itkVariableLengthVectorPython
import itk.itkPhasedArray3DSpecialCoordinatesImagePython
import itk.itkImageToImageFilterCommonPython

def itkStreamingImageFilterIF2IF2_New():
    return itkStreamingImageFilterIF2IF2.New()

class itkStreamingImageFilterIF2IF2(itk.itkImageToImageFilterAPython.itkImageToImageFilterIF2IF2):
    r"""Proxy of C++ itkStreamingImageFilterIF2IF2 class."""

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

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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkStreamingImageFilterIF2IF2_Pointer"""
        return _itkStreamingImageFilterPython.itkStreamingImageFilterIF2IF2___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkStreamingImageFilterIF2IF2_Pointer"""
        return _itkStreamingImageFilterPython.itkStreamingImageFilterIF2IF2_Clone(self)

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

        Parameters
        ----------
        _arg: unsigned int

        """
        return _itkStreamingImageFilterPython.itkStreamingImageFilterIF2IF2_SetNumberOfStreamDivisions(self, _arg)

    def GetNumberOfStreamDivisions(self):
        r"""GetNumberOfStreamDivisions(self) -> unsigned int const &"""
        return _itkStreamingImageFilterPython.itkStreamingImageFilterIF2IF2_GetNumberOfStreamDivisions(self)

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

        Parameters
        ----------
        _arg: itkImageRegionSplitterBase *

        """
        return _itkStreamingImageFilterPython.itkStreamingImageFilterIF2IF2_SetRegionSplitter(self, _arg)

    def GetModifiableRegionSplitter(self):
        r"""GetModifiableRegionSplitter(self) -> itkImageRegionSplitterBase"""
        return _itkStreamingImageFilterPython.itkStreamingImageFilterIF2IF2_GetModifiableRegionSplitter(self)

    def GetRegionSplitter(self, *args):
        r"""
        GetRegionSplitter(self) -> itkImageRegionSplitterBase
        GetRegionSplitter(self) -> itkImageRegionSplitterBase
        """
        return _itkStreamingImageFilterPython.itkStreamingImageFilterIF2IF2_GetRegionSplitter(self, *args)
    SameDimensionCheck = _itkStreamingImageFilterPython.itkStreamingImageFilterIF2IF2_SameDimensionCheck
    
    InputConvertibleToOutputCheck = _itkStreamingImageFilterPython.itkStreamingImageFilterIF2IF2_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkStreamingImageFilterPython.delete_itkStreamingImageFilterIF2IF2

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

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

        """
        return _itkStreamingImageFilterPython.itkStreamingImageFilterIF2IF2_cast(obj)

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

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

          itkStreamingImageFilterIF2IF2.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkStreamingImageFilterIF2IF2 in _itkStreamingImageFilterPython:
_itkStreamingImageFilterPython.itkStreamingImageFilterIF2IF2_swigregister(itkStreamingImageFilterIF2IF2)

def itkStreamingImageFilterIF3IF3_New():
    return itkStreamingImageFilterIF3IF3.New()

class itkStreamingImageFilterIF3IF3(itk.itkImageToImageFilterAPython.itkImageToImageFilterIF3IF3):
    r"""Proxy of C++ itkStreamingImageFilterIF3IF3 class."""

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

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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkStreamingImageFilterIF3IF3_Pointer"""
        return _itkStreamingImageFilterPython.itkStreamingImageFilterIF3IF3___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkStreamingImageFilterIF3IF3_Pointer"""
        return _itkStreamingImageFilterPython.itkStreamingImageFilterIF3IF3_Clone(self)

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

        Parameters
        ----------
        _arg: unsigned int

        """
        return _itkStreamingImageFilterPython.itkStreamingImageFilterIF3IF3_SetNumberOfStreamDivisions(self, _arg)

    def GetNumberOfStreamDivisions(self):
        r"""GetNumberOfStreamDivisions(self) -> unsigned int const &"""
        return _itkStreamingImageFilterPython.itkStreamingImageFilterIF3IF3_GetNumberOfStreamDivisions(self)

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

        Parameters
        ----------
        _arg: itkImageRegionSplitterBase *

        """
        return _itkStreamingImageFilterPython.itkStreamingImageFilterIF3IF3_SetRegionSplitter(self, _arg)

    def GetModifiableRegionSplitter(self):
        r"""GetModifiableRegionSplitter(self) -> itkImageRegionSplitterBase"""
        return _itkStreamingImageFilterPython.itkStreamingImageFilterIF3IF3_GetModifiableRegionSplitter(self)

    def GetRegionSplitter(self, *args):
        r"""
        GetRegionSplitter(self) -> itkImageRegionSplitterBase
        GetRegionSplitter(self) -> itkImageRegionSplitterBase
        """
        return _itkStreamingImageFilterPython.itkStreamingImageFilterIF3IF3_GetRegionSplitter(self, *args)
    SameDimensionCheck = _itkStreamingImageFilterPython.itkStreamingImageFilterIF3IF3_SameDimensionCheck
    
    InputConvertibleToOutputCheck = _itkStreamingImageFilterPython.itkStreamingImageFilterIF3IF3_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkStreamingImageFilterPython.delete_itkStreamingImageFilterIF3IF3

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

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

        """
        return _itkStreamingImageFilterPython.itkStreamingImageFilterIF3IF3_cast(obj)

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

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

          itkStreamingImageFilterIF3IF3.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkStreamingImageFilterIF3IF3 in _itkStreamingImageFilterPython:
_itkStreamingImageFilterPython.itkStreamingImageFilterIF3IF3_swigregister(itkStreamingImageFilterIF3IF3)

def itkStreamingImageFilterISS2ISS2_New():
    return itkStreamingImageFilterISS2ISS2.New()

class itkStreamingImageFilterISS2ISS2(itk.itkImageToImageFilterAPython.itkImageToImageFilterISS2ISS2):
    r"""Proxy of C++ itkStreamingImageFilterISS2ISS2 class."""

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

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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkStreamingImageFilterISS2ISS2_Pointer"""
        return _itkStreamingImageFilterPython.itkStreamingImageFilterISS2ISS2___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkStreamingImageFilterISS2ISS2_Pointer"""
        return _itkStreamingImageFilterPython.itkStreamingImageFilterISS2ISS2_Clone(self)

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

        Parameters
        ----------
        _arg: unsigned int

        """
        return _itkStreamingImageFilterPython.itkStreamingImageFilterISS2ISS2_SetNumberOfStreamDivisions(self, _arg)

    def GetNumberOfStreamDivisions(self):
        r"""GetNumberOfStreamDivisions(self) -> unsigned int const &"""
        return _itkStreamingImageFilterPython.itkStreamingImageFilterISS2ISS2_GetNumberOfStreamDivisions(self)

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

        Parameters
        ----------
        _arg: itkImageRegionSplitterBase *

        """
        return _itkStreamingImageFilterPython.itkStreamingImageFilterISS2ISS2_SetRegionSplitter(self, _arg)

    def GetModifiableRegionSplitter(self):
        r"""GetModifiableRegionSplitter(self) -> itkImageRegionSplitterBase"""
        return _itkStreamingImageFilterPython.itkStreamingImageFilterISS2ISS2_GetModifiableRegionSplitter(self)

    def GetRegionSplitter(self, *args):
        r"""
        GetRegionSplitter(self) -> itkImageRegionSplitterBase
        GetRegionSplitter(self) -> itkImageRegionSplitterBase
        """
        return _itkStreamingImageFilterPython.itkStreamingImageFilterISS2ISS2_GetRegionSplitter(self, *args)
    SameDimensionCheck = _itkStreamingImageFilterPython.itkStreamingImageFilterISS2ISS2_SameDimensionCheck
    
    InputConvertibleToOutputCheck = _itkStreamingImageFilterPython.itkStreamingImageFilterISS2ISS2_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkStreamingImageFilterPython.delete_itkStreamingImageFilterISS2ISS2

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

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

        """
        return _itkStreamingImageFilterPython.itkStreamingImageFilterISS2ISS2_cast(obj)

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

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

          itkStreamingImageFilterISS2ISS2.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkStreamingImageFilterISS2ISS2 in _itkStreamingImageFilterPython:
_itkStreamingImageFilterPython.itkStreamingImageFilterISS2ISS2_swigregister(itkStreamingImageFilterISS2ISS2)

def itkStreamingImageFilterISS3ISS3_New():
    return itkStreamingImageFilterISS3ISS3.New()

class itkStreamingImageFilterISS3ISS3(itk.itkImageToImageFilterAPython.itkImageToImageFilterISS3ISS3):
    r"""Proxy of C++ itkStreamingImageFilterISS3ISS3 class."""

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

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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkStreamingImageFilterISS3ISS3_Pointer"""
        return _itkStreamingImageFilterPython.itkStreamingImageFilterISS3ISS3___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkStreamingImageFilterISS3ISS3_Pointer"""
        return _itkStreamingImageFilterPython.itkStreamingImageFilterISS3ISS3_Clone(self)

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

        Parameters
        ----------
        _arg: unsigned int

        """
        return _itkStreamingImageFilterPython.itkStreamingImageFilterISS3ISS3_SetNumberOfStreamDivisions(self, _arg)

    def GetNumberOfStreamDivisions(self):
        r"""GetNumberOfStreamDivisions(self) -> unsigned int const &"""
        return _itkStreamingImageFilterPython.itkStreamingImageFilterISS3ISS3_GetNumberOfStreamDivisions(self)

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

        Parameters
        ----------
        _arg: itkImageRegionSplitterBase *

        """
        return _itkStreamingImageFilterPython.itkStreamingImageFilterISS3ISS3_SetRegionSplitter(self, _arg)

    def GetModifiableRegionSplitter(self):
        r"""GetModifiableRegionSplitter(self) -> itkImageRegionSplitterBase"""
        return _itkStreamingImageFilterPython.itkStreamingImageFilterISS3ISS3_GetModifiableRegionSplitter(self)

    def GetRegionSplitter(self, *args):
        r"""
        GetRegionSplitter(self) -> itkImageRegionSplitterBase
        GetRegionSplitter(self) -> itkImageRegionSplitterBase
        """
        return _itkStreamingImageFilterPython.itkStreamingImageFilterISS3ISS3_GetRegionSplitter(self, *args)
    SameDimensionCheck = _itkStreamingImageFilterPython.itkStreamingImageFilterISS3ISS3_SameDimensionCheck
    
    InputConvertibleToOutputCheck = _itkStreamingImageFilterPython.itkStreamingImageFilterISS3ISS3_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkStreamingImageFilterPython.delete_itkStreamingImageFilterISS3ISS3

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

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

        """
        return _itkStreamingImageFilterPython.itkStreamingImageFilterISS3ISS3_cast(obj)

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

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

          itkStreamingImageFilterISS3ISS3.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkStreamingImageFilterISS3ISS3 in _itkStreamingImageFilterPython:
_itkStreamingImageFilterPython.itkStreamingImageFilterISS3ISS3_swigregister(itkStreamingImageFilterISS3ISS3)

def itkStreamingImageFilterIUC2IUC2_New():
    return itkStreamingImageFilterIUC2IUC2.New()

class itkStreamingImageFilterIUC2IUC2(itk.itkImageToImageFilterAPython.itkImageToImageFilterIUC2IUC2):
    r"""Proxy of C++ itkStreamingImageFilterIUC2IUC2 class."""

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

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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkStreamingImageFilterIUC2IUC2_Pointer"""
        return _itkStreamingImageFilterPython.itkStreamingImageFilterIUC2IUC2___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkStreamingImageFilterIUC2IUC2_Pointer"""
        return _itkStreamingImageFilterPython.itkStreamingImageFilterIUC2IUC2_Clone(self)

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

        Parameters
        ----------
        _arg: unsigned int

        """
        return _itkStreamingImageFilterPython.itkStreamingImageFilterIUC2IUC2_SetNumberOfStreamDivisions(self, _arg)

    def GetNumberOfStreamDivisions(self):
        r"""GetNumberOfStreamDivisions(self) -> unsigned int const &"""
        return _itkStreamingImageFilterPython.itkStreamingImageFilterIUC2IUC2_GetNumberOfStreamDivisions(self)

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

        Parameters
        ----------
        _arg: itkImageRegionSplitterBase *

        """
        return _itkStreamingImageFilterPython.itkStreamingImageFilterIUC2IUC2_SetRegionSplitter(self, _arg)

    def GetModifiableRegionSplitter(self):
        r"""GetModifiableRegionSplitter(self) -> itkImageRegionSplitterBase"""
        return _itkStreamingImageFilterPython.itkStreamingImageFilterIUC2IUC2_GetModifiableRegionSplitter(self)

    def GetRegionSplitter(self, *args):
        r"""
        GetRegionSplitter(self) -> itkImageRegionSplitterBase
        GetRegionSplitter(self) -> itkImageRegionSplitterBase
        """
        return _itkStreamingImageFilterPython.itkStreamingImageFilterIUC2IUC2_GetRegionSplitter(self, *args)
    SameDimensionCheck = _itkStreamingImageFilterPython.itkStreamingImageFilterIUC2IUC2_SameDimensionCheck
    
    InputConvertibleToOutputCheck = _itkStreamingImageFilterPython.itkStreamingImageFilterIUC2IUC2_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkStreamingImageFilterPython.delete_itkStreamingImageFilterIUC2IUC2

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

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

        """
        return _itkStreamingImageFilterPython.itkStreamingImageFilterIUC2IUC2_cast(obj)

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

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

          itkStreamingImageFilterIUC2IUC2.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkStreamingImageFilterIUC2IUC2 in _itkStreamingImageFilterPython:
_itkStreamingImageFilterPython.itkStreamingImageFilterIUC2IUC2_swigregister(itkStreamingImageFilterIUC2IUC2)

def itkStreamingImageFilterIUC3IUC3_New():
    return itkStreamingImageFilterIUC3IUC3.New()

class itkStreamingImageFilterIUC3IUC3(itk.itkImageToImageFilterAPython.itkImageToImageFilterIUC3IUC3):
    r"""Proxy of C++ itkStreamingImageFilterIUC3IUC3 class."""

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

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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkStreamingImageFilterIUC3IUC3_Pointer"""
        return _itkStreamingImageFilterPython.itkStreamingImageFilterIUC3IUC3___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkStreamingImageFilterIUC3IUC3_Pointer"""
        return _itkStreamingImageFilterPython.itkStreamingImageFilterIUC3IUC3_Clone(self)

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

        Parameters
        ----------
        _arg: unsigned int

        """
        return _itkStreamingImageFilterPython.itkStreamingImageFilterIUC3IUC3_SetNumberOfStreamDivisions(self, _arg)

    def GetNumberOfStreamDivisions(self):
        r"""GetNumberOfStreamDivisions(self) -> unsigned int const &"""
        return _itkStreamingImageFilterPython.itkStreamingImageFilterIUC3IUC3_GetNumberOfStreamDivisions(self)

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

        Parameters
        ----------
        _arg: itkImageRegionSplitterBase *

        """
        return _itkStreamingImageFilterPython.itkStreamingImageFilterIUC3IUC3_SetRegionSplitter(self, _arg)

    def GetModifiableRegionSplitter(self):
        r"""GetModifiableRegionSplitter(self) -> itkImageRegionSplitterBase"""
        return _itkStreamingImageFilterPython.itkStreamingImageFilterIUC3IUC3_GetModifiableRegionSplitter(self)

    def GetRegionSplitter(self, *args):
        r"""
        GetRegionSplitter(self) -> itkImageRegionSplitterBase
        GetRegionSplitter(self) -> itkImageRegionSplitterBase
        """
        return _itkStreamingImageFilterPython.itkStreamingImageFilterIUC3IUC3_GetRegionSplitter(self, *args)
    SameDimensionCheck = _itkStreamingImageFilterPython.itkStreamingImageFilterIUC3IUC3_SameDimensionCheck
    
    InputConvertibleToOutputCheck = _itkStreamingImageFilterPython.itkStreamingImageFilterIUC3IUC3_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkStreamingImageFilterPython.delete_itkStreamingImageFilterIUC3IUC3

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

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

        """
        return _itkStreamingImageFilterPython.itkStreamingImageFilterIUC3IUC3_cast(obj)

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

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

          itkStreamingImageFilterIUC3IUC3.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkStreamingImageFilterIUC3IUC3 in _itkStreamingImageFilterPython:
_itkStreamingImageFilterPython.itkStreamingImageFilterIUC3IUC3_swigregister(itkStreamingImageFilterIUC3IUC3)

def itkStreamingImageFilterIVF22IVF22_New():
    return itkStreamingImageFilterIVF22IVF22.New()

class itkStreamingImageFilterIVF22IVF22(itk.itkImageToImageFilterAPython.itkImageToImageFilterIVF22IVF22):
    r"""Proxy of C++ itkStreamingImageFilterIVF22IVF22 class."""

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

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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkStreamingImageFilterIVF22IVF22_Pointer"""
        return _itkStreamingImageFilterPython.itkStreamingImageFilterIVF22IVF22___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkStreamingImageFilterIVF22IVF22_Pointer"""
        return _itkStreamingImageFilterPython.itkStreamingImageFilterIVF22IVF22_Clone(self)

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

        Parameters
        ----------
        _arg: unsigned int

        """
        return _itkStreamingImageFilterPython.itkStreamingImageFilterIVF22IVF22_SetNumberOfStreamDivisions(self, _arg)

    def GetNumberOfStreamDivisions(self):
        r"""GetNumberOfStreamDivisions(self) -> unsigned int const &"""
        return _itkStreamingImageFilterPython.itkStreamingImageFilterIVF22IVF22_GetNumberOfStreamDivisions(self)

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

        Parameters
        ----------
        _arg: itkImageRegionSplitterBase *

        """
        return _itkStreamingImageFilterPython.itkStreamingImageFilterIVF22IVF22_SetRegionSplitter(self, _arg)

    def GetModifiableRegionSplitter(self):
        r"""GetModifiableRegionSplitter(self) -> itkImageRegionSplitterBase"""
        return _itkStreamingImageFilterPython.itkStreamingImageFilterIVF22IVF22_GetModifiableRegionSplitter(self)

    def GetRegionSplitter(self, *args):
        r"""
        GetRegionSplitter(self) -> itkImageRegionSplitterBase
        GetRegionSplitter(self) -> itkImageRegionSplitterBase
        """
        return _itkStreamingImageFilterPython.itkStreamingImageFilterIVF22IVF22_GetRegionSplitter(self, *args)
    SameDimensionCheck = _itkStreamingImageFilterPython.itkStreamingImageFilterIVF22IVF22_SameDimensionCheck
    
    InputConvertibleToOutputCheck = _itkStreamingImageFilterPython.itkStreamingImageFilterIVF22IVF22_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkStreamingImageFilterPython.delete_itkStreamingImageFilterIVF22IVF22

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

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

        """
        return _itkStreamingImageFilterPython.itkStreamingImageFilterIVF22IVF22_cast(obj)

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

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

          itkStreamingImageFilterIVF22IVF22.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkStreamingImageFilterIVF22IVF22 in _itkStreamingImageFilterPython:
_itkStreamingImageFilterPython.itkStreamingImageFilterIVF22IVF22_swigregister(itkStreamingImageFilterIVF22IVF22)

def itkStreamingImageFilterIVF23IVF23_New():
    return itkStreamingImageFilterIVF23IVF23.New()

class itkStreamingImageFilterIVF23IVF23(itk.itkImageToImageFilterAPython.itkImageToImageFilterIVF23IVF23):
    r"""Proxy of C++ itkStreamingImageFilterIVF23IVF23 class."""

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

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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkStreamingImageFilterIVF23IVF23_Pointer"""
        return _itkStreamingImageFilterPython.itkStreamingImageFilterIVF23IVF23___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkStreamingImageFilterIVF23IVF23_Pointer"""
        return _itkStreamingImageFilterPython.itkStreamingImageFilterIVF23IVF23_Clone(self)

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

        Parameters
        ----------
        _arg: unsigned int

        """
        return _itkStreamingImageFilterPython.itkStreamingImageFilterIVF23IVF23_SetNumberOfStreamDivisions(self, _arg)

    def GetNumberOfStreamDivisions(self):
        r"""GetNumberOfStreamDivisions(self) -> unsigned int const &"""
        return _itkStreamingImageFilterPython.itkStreamingImageFilterIVF23IVF23_GetNumberOfStreamDivisions(self)

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

        Parameters
        ----------
        _arg: itkImageRegionSplitterBase *

        """
        return _itkStreamingImageFilterPython.itkStreamingImageFilterIVF23IVF23_SetRegionSplitter(self, _arg)

    def GetModifiableRegionSplitter(self):
        r"""GetModifiableRegionSplitter(self) -> itkImageRegionSplitterBase"""
        return _itkStreamingImageFilterPython.itkStreamingImageFilterIVF23IVF23_GetModifiableRegionSplitter(self)

    def GetRegionSplitter(self, *args):
        r"""
        GetRegionSplitter(self) -> itkImageRegionSplitterBase
        GetRegionSplitter(self) -> itkImageRegionSplitterBase
        """
        return _itkStreamingImageFilterPython.itkStreamingImageFilterIVF23IVF23_GetRegionSplitter(self, *args)
    SameDimensionCheck = _itkStreamingImageFilterPython.itkStreamingImageFilterIVF23IVF23_SameDimensionCheck
    
    InputConvertibleToOutputCheck = _itkStreamingImageFilterPython.itkStreamingImageFilterIVF23IVF23_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkStreamingImageFilterPython.delete_itkStreamingImageFilterIVF23IVF23

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

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

        """
        return _itkStreamingImageFilterPython.itkStreamingImageFilterIVF23IVF23_cast(obj)

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

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

          itkStreamingImageFilterIVF23IVF23.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkStreamingImageFilterIVF23IVF23 in _itkStreamingImageFilterPython:
_itkStreamingImageFilterPython.itkStreamingImageFilterIVF23IVF23_swigregister(itkStreamingImageFilterIVF23IVF23)

def itkStreamingImageFilterIVF32IVF32_New():
    return itkStreamingImageFilterIVF32IVF32.New()

class itkStreamingImageFilterIVF32IVF32(itk.itkImageToImageFilterAPython.itkImageToImageFilterIVF32IVF32):
    r"""Proxy of C++ itkStreamingImageFilterIVF32IVF32 class."""

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

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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkStreamingImageFilterIVF32IVF32_Pointer"""
        return _itkStreamingImageFilterPython.itkStreamingImageFilterIVF32IVF32___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkStreamingImageFilterIVF32IVF32_Pointer"""
        return _itkStreamingImageFilterPython.itkStreamingImageFilterIVF32IVF32_Clone(self)

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

        Parameters
        ----------
        _arg: unsigned int

        """
        return _itkStreamingImageFilterPython.itkStreamingImageFilterIVF32IVF32_SetNumberOfStreamDivisions(self, _arg)

    def GetNumberOfStreamDivisions(self):
        r"""GetNumberOfStreamDivisions(self) -> unsigned int const &"""
        return _itkStreamingImageFilterPython.itkStreamingImageFilterIVF32IVF32_GetNumberOfStreamDivisions(self)

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

        Parameters
        ----------
        _arg: itkImageRegionSplitterBase *

        """
        return _itkStreamingImageFilterPython.itkStreamingImageFilterIVF32IVF32_SetRegionSplitter(self, _arg)

    def GetModifiableRegionSplitter(self):
        r"""GetModifiableRegionSplitter(self) -> itkImageRegionSplitterBase"""
        return _itkStreamingImageFilterPython.itkStreamingImageFilterIVF32IVF32_GetModifiableRegionSplitter(self)

    def GetRegionSplitter(self, *args):
        r"""
        GetRegionSplitter(self) -> itkImageRegionSplitterBase
        GetRegionSplitter(self) -> itkImageRegionSplitterBase
        """
        return _itkStreamingImageFilterPython.itkStreamingImageFilterIVF32IVF32_GetRegionSplitter(self, *args)
    SameDimensionCheck = _itkStreamingImageFilterPython.itkStreamingImageFilterIVF32IVF32_SameDimensionCheck
    
    InputConvertibleToOutputCheck = _itkStreamingImageFilterPython.itkStreamingImageFilterIVF32IVF32_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkStreamingImageFilterPython.delete_itkStreamingImageFilterIVF32IVF32

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

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

        """
        return _itkStreamingImageFilterPython.itkStreamingImageFilterIVF32IVF32_cast(obj)

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

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

          itkStreamingImageFilterIVF32IVF32.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkStreamingImageFilterIVF32IVF32 in _itkStreamingImageFilterPython:
_itkStreamingImageFilterPython.itkStreamingImageFilterIVF32IVF32_swigregister(itkStreamingImageFilterIVF32IVF32)

def itkStreamingImageFilterIVF33IVF33_New():
    return itkStreamingImageFilterIVF33IVF33.New()

class itkStreamingImageFilterIVF33IVF33(itk.itkImageToImageFilterAPython.itkImageToImageFilterIVF33IVF33):
    r"""Proxy of C++ itkStreamingImageFilterIVF33IVF33 class."""

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

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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkStreamingImageFilterIVF33IVF33_Pointer"""
        return _itkStreamingImageFilterPython.itkStreamingImageFilterIVF33IVF33___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkStreamingImageFilterIVF33IVF33_Pointer"""
        return _itkStreamingImageFilterPython.itkStreamingImageFilterIVF33IVF33_Clone(self)

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

        Parameters
        ----------
        _arg: unsigned int

        """
        return _itkStreamingImageFilterPython.itkStreamingImageFilterIVF33IVF33_SetNumberOfStreamDivisions(self, _arg)

    def GetNumberOfStreamDivisions(self):
        r"""GetNumberOfStreamDivisions(self) -> unsigned int const &"""
        return _itkStreamingImageFilterPython.itkStreamingImageFilterIVF33IVF33_GetNumberOfStreamDivisions(self)

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

        Parameters
        ----------
        _arg: itkImageRegionSplitterBase *

        """
        return _itkStreamingImageFilterPython.itkStreamingImageFilterIVF33IVF33_SetRegionSplitter(self, _arg)

    def GetModifiableRegionSplitter(self):
        r"""GetModifiableRegionSplitter(self) -> itkImageRegionSplitterBase"""
        return _itkStreamingImageFilterPython.itkStreamingImageFilterIVF33IVF33_GetModifiableRegionSplitter(self)

    def GetRegionSplitter(self, *args):
        r"""
        GetRegionSplitter(self) -> itkImageRegionSplitterBase
        GetRegionSplitter(self) -> itkImageRegionSplitterBase
        """
        return _itkStreamingImageFilterPython.itkStreamingImageFilterIVF33IVF33_GetRegionSplitter(self, *args)
    SameDimensionCheck = _itkStreamingImageFilterPython.itkStreamingImageFilterIVF33IVF33_SameDimensionCheck
    
    InputConvertibleToOutputCheck = _itkStreamingImageFilterPython.itkStreamingImageFilterIVF33IVF33_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkStreamingImageFilterPython.delete_itkStreamingImageFilterIVF33IVF33

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

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

        """
        return _itkStreamingImageFilterPython.itkStreamingImageFilterIVF33IVF33_cast(obj)

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

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

          itkStreamingImageFilterIVF33IVF33.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkStreamingImageFilterIVF33IVF33 in _itkStreamingImageFilterPython:
_itkStreamingImageFilterPython.itkStreamingImageFilterIVF33IVF33_swigregister(itkStreamingImageFilterIVF33IVF33)

def itkStreamingImageFilterIVF42IVF42_New():
    return itkStreamingImageFilterIVF42IVF42.New()

class itkStreamingImageFilterIVF42IVF42(itk.itkImageToImageFilterAPython.itkImageToImageFilterIVF42IVF42):
    r"""Proxy of C++ itkStreamingImageFilterIVF42IVF42 class."""

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

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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkStreamingImageFilterIVF42IVF42_Pointer"""
        return _itkStreamingImageFilterPython.itkStreamingImageFilterIVF42IVF42___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkStreamingImageFilterIVF42IVF42_Pointer"""
        return _itkStreamingImageFilterPython.itkStreamingImageFilterIVF42IVF42_Clone(self)

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

        Parameters
        ----------
        _arg: unsigned int

        """
        return _itkStreamingImageFilterPython.itkStreamingImageFilterIVF42IVF42_SetNumberOfStreamDivisions(self, _arg)

    def GetNumberOfStreamDivisions(self):
        r"""GetNumberOfStreamDivisions(self) -> unsigned int const &"""
        return _itkStreamingImageFilterPython.itkStreamingImageFilterIVF42IVF42_GetNumberOfStreamDivisions(self)

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

        Parameters
        ----------
        _arg: itkImageRegionSplitterBase *

        """
        return _itkStreamingImageFilterPython.itkStreamingImageFilterIVF42IVF42_SetRegionSplitter(self, _arg)

    def GetModifiableRegionSplitter(self):
        r"""GetModifiableRegionSplitter(self) -> itkImageRegionSplitterBase"""
        return _itkStreamingImageFilterPython.itkStreamingImageFilterIVF42IVF42_GetModifiableRegionSplitter(self)

    def GetRegionSplitter(self, *args):
        r"""
        GetRegionSplitter(self) -> itkImageRegionSplitterBase
        GetRegionSplitter(self) -> itkImageRegionSplitterBase
        """
        return _itkStreamingImageFilterPython.itkStreamingImageFilterIVF42IVF42_GetRegionSplitter(self, *args)
    SameDimensionCheck = _itkStreamingImageFilterPython.itkStreamingImageFilterIVF42IVF42_SameDimensionCheck
    
    InputConvertibleToOutputCheck = _itkStreamingImageFilterPython.itkStreamingImageFilterIVF42IVF42_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkStreamingImageFilterPython.delete_itkStreamingImageFilterIVF42IVF42

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

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

        """
        return _itkStreamingImageFilterPython.itkStreamingImageFilterIVF42IVF42_cast(obj)

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

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

          itkStreamingImageFilterIVF42IVF42.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkStreamingImageFilterIVF42IVF42 in _itkStreamingImageFilterPython:
_itkStreamingImageFilterPython.itkStreamingImageFilterIVF42IVF42_swigregister(itkStreamingImageFilterIVF42IVF42)

def itkStreamingImageFilterIVF43IVF43_New():
    return itkStreamingImageFilterIVF43IVF43.New()

class itkStreamingImageFilterIVF43IVF43(itk.itkImageToImageFilterAPython.itkImageToImageFilterIVF43IVF43):
    r"""Proxy of C++ itkStreamingImageFilterIVF43IVF43 class."""

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

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

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkStreamingImageFilterIVF43IVF43_Pointer"""
        return _itkStreamingImageFilterPython.itkStreamingImageFilterIVF43IVF43___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkStreamingImageFilterIVF43IVF43_Pointer"""
        return _itkStreamingImageFilterPython.itkStreamingImageFilterIVF43IVF43_Clone(self)

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

        Parameters
        ----------
        _arg: unsigned int

        """
        return _itkStreamingImageFilterPython.itkStreamingImageFilterIVF43IVF43_SetNumberOfStreamDivisions(self, _arg)

    def GetNumberOfStreamDivisions(self):
        r"""GetNumberOfStreamDivisions(self) -> unsigned int const &"""
        return _itkStreamingImageFilterPython.itkStreamingImageFilterIVF43IVF43_GetNumberOfStreamDivisions(self)

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

        Parameters
        ----------
        _arg: itkImageRegionSplitterBase *

        """
        return _itkStreamingImageFilterPython.itkStreamingImageFilterIVF43IVF43_SetRegionSplitter(self, _arg)

    def GetModifiableRegionSplitter(self):
        r"""GetModifiableRegionSplitter(self) -> itkImageRegionSplitterBase"""
        return _itkStreamingImageFilterPython.itkStreamingImageFilterIVF43IVF43_GetModifiableRegionSplitter(self)

    def GetRegionSplitter(self, *args):
        r"""
        GetRegionSplitter(self) -> itkImageRegionSplitterBase
        GetRegionSplitter(self) -> itkImageRegionSplitterBase
        """
        return _itkStreamingImageFilterPython.itkStreamingImageFilterIVF43IVF43_GetRegionSplitter(self, *args)
    SameDimensionCheck = _itkStreamingImageFilterPython.itkStreamingImageFilterIVF43IVF43_SameDimensionCheck
    
    InputConvertibleToOutputCheck = _itkStreamingImageFilterPython.itkStreamingImageFilterIVF43IVF43_InputConvertibleToOutputCheck
    
    __swig_destroy__ = _itkStreamingImageFilterPython.delete_itkStreamingImageFilterIVF43IVF43

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

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

        """
        return _itkStreamingImageFilterPython.itkStreamingImageFilterIVF43IVF43_cast(obj)

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

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

          itkStreamingImageFilterIVF43IVF43.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkStreamingImageFilterIVF43IVF43 in _itkStreamingImageFilterPython:
_itkStreamingImageFilterPython.itkStreamingImageFilterIVF43IVF43_swigregister(itkStreamingImageFilterIVF43IVF43)

from itk.support import helpers
import itk.support.types as itkt
from typing import Sequence, Tuple, Union

@helpers.accept_array_like_xarray_torch
def streaming_image_filter(*args: itkt.ImageLike,  number_of_stream_divisions: int=..., region_splitter=...,**kwargs)-> itkt.ImageSourceReturn:
    """Functional interface for StreamingImageFilter"""
    import itk

    kwarg_typehints = { 'number_of_stream_divisions':number_of_stream_divisions,'region_splitter':region_splitter }
    specified_kwarg_typehints = { k:v for (k,v) in kwarg_typehints.items() if kwarg_typehints[k] is not ... }
    kwargs.update(specified_kwarg_typehints)


    instance = itk.StreamingImageFilter.New(*args, **kwargs)

    return instance.__internal_call__()

def streaming_image_filter_init_docstring():
    import itk
    from itk.support import template_class

    filter_class = itk.ITKCommon.StreamingImageFilter
    streaming_image_filter.process_object = filter_class
    is_template = isinstance(filter_class, template_class.itkTemplate)
    if is_template:
        filter_object = filter_class.values()[0]
    else:
        filter_object = filter_class

    streaming_image_filter.__doc__ = filter_object.__doc__



