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



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

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.itkImageToImageFilterBPython
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 itkComposeImageFilterIF2ICF2_New():
    return itkComposeImageFilterIF2ICF2.New()

class itkComposeImageFilterIF2ICF2(itk.itkImageToImageFilterBPython.itkImageToImageFilterIF2ICF2):
    r"""Proxy of C++ itkComposeImageFilterIF2ICF2 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__() -> itkComposeImageFilterIF2ICF2_Pointer"""
        return _itkComposeImageFilterPython.itkComposeImageFilterIF2ICF2___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkComposeImageFilterIF2ICF2_Pointer"""
        return _itkComposeImageFilterPython.itkComposeImageFilterIF2ICF2_Clone(self)

    def SetInput1(self, image1):
        r"""
        SetInput1(self, image1)

        Parameters
        ----------
        image1: itkImageF2 const *

        """
        return _itkComposeImageFilterPython.itkComposeImageFilterIF2ICF2_SetInput1(self, image1)

    def SetInput2(self, image2):
        r"""
        SetInput2(self, image2)

        Parameters
        ----------
        image2: itkImageF2 const *

        """
        return _itkComposeImageFilterPython.itkComposeImageFilterIF2ICF2_SetInput2(self, image2)

    def SetInput3(self, image3):
        r"""
        SetInput3(self, image3)

        Parameters
        ----------
        image3: itkImageF2 const *

        """
        return _itkComposeImageFilterPython.itkComposeImageFilterIF2ICF2_SetInput3(self, image3)
    InputCovertibleToOutputCheck = _itkComposeImageFilterPython.itkComposeImageFilterIF2ICF2_InputCovertibleToOutputCheck
    
    __swig_destroy__ = _itkComposeImageFilterPython.delete_itkComposeImageFilterIF2ICF2

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

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

        """
        return _itkComposeImageFilterPython.itkComposeImageFilterIF2ICF2_cast(obj)

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

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

          itkComposeImageFilterIF2ICF2.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkComposeImageFilterIF2ICF2 in _itkComposeImageFilterPython:
_itkComposeImageFilterPython.itkComposeImageFilterIF2ICF2_swigregister(itkComposeImageFilterIF2ICF2)

def itkComposeImageFilterIF2ICVF22_New():
    return itkComposeImageFilterIF2ICVF22.New()

class itkComposeImageFilterIF2ICVF22(itk.itkImageToImageFilterBPython.itkImageToImageFilterIF2ICVF22):
    r"""Proxy of C++ itkComposeImageFilterIF2ICVF22 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__() -> itkComposeImageFilterIF2ICVF22_Pointer"""
        return _itkComposeImageFilterPython.itkComposeImageFilterIF2ICVF22___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkComposeImageFilterIF2ICVF22_Pointer"""
        return _itkComposeImageFilterPython.itkComposeImageFilterIF2ICVF22_Clone(self)

    def SetInput1(self, image1):
        r"""
        SetInput1(self, image1)

        Parameters
        ----------
        image1: itkImageF2 const *

        """
        return _itkComposeImageFilterPython.itkComposeImageFilterIF2ICVF22_SetInput1(self, image1)

    def SetInput2(self, image2):
        r"""
        SetInput2(self, image2)

        Parameters
        ----------
        image2: itkImageF2 const *

        """
        return _itkComposeImageFilterPython.itkComposeImageFilterIF2ICVF22_SetInput2(self, image2)

    def SetInput3(self, image3):
        r"""
        SetInput3(self, image3)

        Parameters
        ----------
        image3: itkImageF2 const *

        """
        return _itkComposeImageFilterPython.itkComposeImageFilterIF2ICVF22_SetInput3(self, image3)
    InputCovertibleToOutputCheck = _itkComposeImageFilterPython.itkComposeImageFilterIF2ICVF22_InputCovertibleToOutputCheck
    
    __swig_destroy__ = _itkComposeImageFilterPython.delete_itkComposeImageFilterIF2ICVF22

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

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

        """
        return _itkComposeImageFilterPython.itkComposeImageFilterIF2ICVF22_cast(obj)

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

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

          itkComposeImageFilterIF2ICVF22.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkComposeImageFilterIF2ICVF22 in _itkComposeImageFilterPython:
_itkComposeImageFilterPython.itkComposeImageFilterIF2ICVF22_swigregister(itkComposeImageFilterIF2ICVF22)

def itkComposeImageFilterIF2ICVF32_New():
    return itkComposeImageFilterIF2ICVF32.New()

class itkComposeImageFilterIF2ICVF32(itk.itkImageToImageFilterBPython.itkImageToImageFilterIF2ICVF32):
    r"""Proxy of C++ itkComposeImageFilterIF2ICVF32 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__() -> itkComposeImageFilterIF2ICVF32_Pointer"""
        return _itkComposeImageFilterPython.itkComposeImageFilterIF2ICVF32___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkComposeImageFilterIF2ICVF32_Pointer"""
        return _itkComposeImageFilterPython.itkComposeImageFilterIF2ICVF32_Clone(self)

    def SetInput1(self, image1):
        r"""
        SetInput1(self, image1)

        Parameters
        ----------
        image1: itkImageF2 const *

        """
        return _itkComposeImageFilterPython.itkComposeImageFilterIF2ICVF32_SetInput1(self, image1)

    def SetInput2(self, image2):
        r"""
        SetInput2(self, image2)

        Parameters
        ----------
        image2: itkImageF2 const *

        """
        return _itkComposeImageFilterPython.itkComposeImageFilterIF2ICVF32_SetInput2(self, image2)

    def SetInput3(self, image3):
        r"""
        SetInput3(self, image3)

        Parameters
        ----------
        image3: itkImageF2 const *

        """
        return _itkComposeImageFilterPython.itkComposeImageFilterIF2ICVF32_SetInput3(self, image3)
    InputCovertibleToOutputCheck = _itkComposeImageFilterPython.itkComposeImageFilterIF2ICVF32_InputCovertibleToOutputCheck
    
    __swig_destroy__ = _itkComposeImageFilterPython.delete_itkComposeImageFilterIF2ICVF32

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

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

        """
        return _itkComposeImageFilterPython.itkComposeImageFilterIF2ICVF32_cast(obj)

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

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

          itkComposeImageFilterIF2ICVF32.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkComposeImageFilterIF2ICVF32 in _itkComposeImageFilterPython:
_itkComposeImageFilterPython.itkComposeImageFilterIF2ICVF32_swigregister(itkComposeImageFilterIF2ICVF32)

def itkComposeImageFilterIF2ICVF42_New():
    return itkComposeImageFilterIF2ICVF42.New()

class itkComposeImageFilterIF2ICVF42(itk.itkImageToImageFilterBPython.itkImageToImageFilterIF2ICVF42):
    r"""Proxy of C++ itkComposeImageFilterIF2ICVF42 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__() -> itkComposeImageFilterIF2ICVF42_Pointer"""
        return _itkComposeImageFilterPython.itkComposeImageFilterIF2ICVF42___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkComposeImageFilterIF2ICVF42_Pointer"""
        return _itkComposeImageFilterPython.itkComposeImageFilterIF2ICVF42_Clone(self)

    def SetInput1(self, image1):
        r"""
        SetInput1(self, image1)

        Parameters
        ----------
        image1: itkImageF2 const *

        """
        return _itkComposeImageFilterPython.itkComposeImageFilterIF2ICVF42_SetInput1(self, image1)

    def SetInput2(self, image2):
        r"""
        SetInput2(self, image2)

        Parameters
        ----------
        image2: itkImageF2 const *

        """
        return _itkComposeImageFilterPython.itkComposeImageFilterIF2ICVF42_SetInput2(self, image2)

    def SetInput3(self, image3):
        r"""
        SetInput3(self, image3)

        Parameters
        ----------
        image3: itkImageF2 const *

        """
        return _itkComposeImageFilterPython.itkComposeImageFilterIF2ICVF42_SetInput3(self, image3)
    InputCovertibleToOutputCheck = _itkComposeImageFilterPython.itkComposeImageFilterIF2ICVF42_InputCovertibleToOutputCheck
    
    __swig_destroy__ = _itkComposeImageFilterPython.delete_itkComposeImageFilterIF2ICVF42

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

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

        """
        return _itkComposeImageFilterPython.itkComposeImageFilterIF2ICVF42_cast(obj)

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

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

          itkComposeImageFilterIF2ICVF42.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkComposeImageFilterIF2ICVF42 in _itkComposeImageFilterPython:
_itkComposeImageFilterPython.itkComposeImageFilterIF2ICVF42_swigregister(itkComposeImageFilterIF2ICVF42)

def itkComposeImageFilterIF2IVF22_New():
    return itkComposeImageFilterIF2IVF22.New()

class itkComposeImageFilterIF2IVF22(itk.itkImageToImageFilterBPython.itkImageToImageFilterIF2IVF22):
    r"""Proxy of C++ itkComposeImageFilterIF2IVF22 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__() -> itkComposeImageFilterIF2IVF22_Pointer"""
        return _itkComposeImageFilterPython.itkComposeImageFilterIF2IVF22___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkComposeImageFilterIF2IVF22_Pointer"""
        return _itkComposeImageFilterPython.itkComposeImageFilterIF2IVF22_Clone(self)

    def SetInput1(self, image1):
        r"""
        SetInput1(self, image1)

        Parameters
        ----------
        image1: itkImageF2 const *

        """
        return _itkComposeImageFilterPython.itkComposeImageFilterIF2IVF22_SetInput1(self, image1)

    def SetInput2(self, image2):
        r"""
        SetInput2(self, image2)

        Parameters
        ----------
        image2: itkImageF2 const *

        """
        return _itkComposeImageFilterPython.itkComposeImageFilterIF2IVF22_SetInput2(self, image2)

    def SetInput3(self, image3):
        r"""
        SetInput3(self, image3)

        Parameters
        ----------
        image3: itkImageF2 const *

        """
        return _itkComposeImageFilterPython.itkComposeImageFilterIF2IVF22_SetInput3(self, image3)
    InputCovertibleToOutputCheck = _itkComposeImageFilterPython.itkComposeImageFilterIF2IVF22_InputCovertibleToOutputCheck
    
    __swig_destroy__ = _itkComposeImageFilterPython.delete_itkComposeImageFilterIF2IVF22

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

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

        """
        return _itkComposeImageFilterPython.itkComposeImageFilterIF2IVF22_cast(obj)

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

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

          itkComposeImageFilterIF2IVF22.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkComposeImageFilterIF2IVF22 in _itkComposeImageFilterPython:
_itkComposeImageFilterPython.itkComposeImageFilterIF2IVF22_swigregister(itkComposeImageFilterIF2IVF22)

def itkComposeImageFilterIF2IVF32_New():
    return itkComposeImageFilterIF2IVF32.New()

class itkComposeImageFilterIF2IVF32(itk.itkImageToImageFilterBPython.itkImageToImageFilterIF2IVF32):
    r"""Proxy of C++ itkComposeImageFilterIF2IVF32 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__() -> itkComposeImageFilterIF2IVF32_Pointer"""
        return _itkComposeImageFilterPython.itkComposeImageFilterIF2IVF32___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkComposeImageFilterIF2IVF32_Pointer"""
        return _itkComposeImageFilterPython.itkComposeImageFilterIF2IVF32_Clone(self)

    def SetInput1(self, image1):
        r"""
        SetInput1(self, image1)

        Parameters
        ----------
        image1: itkImageF2 const *

        """
        return _itkComposeImageFilterPython.itkComposeImageFilterIF2IVF32_SetInput1(self, image1)

    def SetInput2(self, image2):
        r"""
        SetInput2(self, image2)

        Parameters
        ----------
        image2: itkImageF2 const *

        """
        return _itkComposeImageFilterPython.itkComposeImageFilterIF2IVF32_SetInput2(self, image2)

    def SetInput3(self, image3):
        r"""
        SetInput3(self, image3)

        Parameters
        ----------
        image3: itkImageF2 const *

        """
        return _itkComposeImageFilterPython.itkComposeImageFilterIF2IVF32_SetInput3(self, image3)
    InputCovertibleToOutputCheck = _itkComposeImageFilterPython.itkComposeImageFilterIF2IVF32_InputCovertibleToOutputCheck
    
    __swig_destroy__ = _itkComposeImageFilterPython.delete_itkComposeImageFilterIF2IVF32

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

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

        """
        return _itkComposeImageFilterPython.itkComposeImageFilterIF2IVF32_cast(obj)

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

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

          itkComposeImageFilterIF2IVF32.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkComposeImageFilterIF2IVF32 in _itkComposeImageFilterPython:
_itkComposeImageFilterPython.itkComposeImageFilterIF2IVF32_swigregister(itkComposeImageFilterIF2IVF32)

def itkComposeImageFilterIF2IVF42_New():
    return itkComposeImageFilterIF2IVF42.New()

class itkComposeImageFilterIF2IVF42(itk.itkImageToImageFilterBPython.itkImageToImageFilterIF2IVF42):
    r"""Proxy of C++ itkComposeImageFilterIF2IVF42 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__() -> itkComposeImageFilterIF2IVF42_Pointer"""
        return _itkComposeImageFilterPython.itkComposeImageFilterIF2IVF42___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkComposeImageFilterIF2IVF42_Pointer"""
        return _itkComposeImageFilterPython.itkComposeImageFilterIF2IVF42_Clone(self)

    def SetInput1(self, image1):
        r"""
        SetInput1(self, image1)

        Parameters
        ----------
        image1: itkImageF2 const *

        """
        return _itkComposeImageFilterPython.itkComposeImageFilterIF2IVF42_SetInput1(self, image1)

    def SetInput2(self, image2):
        r"""
        SetInput2(self, image2)

        Parameters
        ----------
        image2: itkImageF2 const *

        """
        return _itkComposeImageFilterPython.itkComposeImageFilterIF2IVF42_SetInput2(self, image2)

    def SetInput3(self, image3):
        r"""
        SetInput3(self, image3)

        Parameters
        ----------
        image3: itkImageF2 const *

        """
        return _itkComposeImageFilterPython.itkComposeImageFilterIF2IVF42_SetInput3(self, image3)
    InputCovertibleToOutputCheck = _itkComposeImageFilterPython.itkComposeImageFilterIF2IVF42_InputCovertibleToOutputCheck
    
    __swig_destroy__ = _itkComposeImageFilterPython.delete_itkComposeImageFilterIF2IVF42

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

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

        """
        return _itkComposeImageFilterPython.itkComposeImageFilterIF2IVF42_cast(obj)

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

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

          itkComposeImageFilterIF2IVF42.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkComposeImageFilterIF2IVF42 in _itkComposeImageFilterPython:
_itkComposeImageFilterPython.itkComposeImageFilterIF2IVF42_swigregister(itkComposeImageFilterIF2IVF42)

def itkComposeImageFilterIF2VIF2_New():
    return itkComposeImageFilterIF2VIF2.New()

class itkComposeImageFilterIF2VIF2(itk.itkImageToImageFilterBPython.itkImageToImageFilterIF2VIF2):
    r"""Proxy of C++ itkComposeImageFilterIF2VIF2 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__() -> itkComposeImageFilterIF2VIF2_Pointer"""
        return _itkComposeImageFilterPython.itkComposeImageFilterIF2VIF2___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkComposeImageFilterIF2VIF2_Pointer"""
        return _itkComposeImageFilterPython.itkComposeImageFilterIF2VIF2_Clone(self)

    def SetInput1(self, image1):
        r"""
        SetInput1(self, image1)

        Parameters
        ----------
        image1: itkImageF2 const *

        """
        return _itkComposeImageFilterPython.itkComposeImageFilterIF2VIF2_SetInput1(self, image1)

    def SetInput2(self, image2):
        r"""
        SetInput2(self, image2)

        Parameters
        ----------
        image2: itkImageF2 const *

        """
        return _itkComposeImageFilterPython.itkComposeImageFilterIF2VIF2_SetInput2(self, image2)

    def SetInput3(self, image3):
        r"""
        SetInput3(self, image3)

        Parameters
        ----------
        image3: itkImageF2 const *

        """
        return _itkComposeImageFilterPython.itkComposeImageFilterIF2VIF2_SetInput3(self, image3)
    InputCovertibleToOutputCheck = _itkComposeImageFilterPython.itkComposeImageFilterIF2VIF2_InputCovertibleToOutputCheck
    
    __swig_destroy__ = _itkComposeImageFilterPython.delete_itkComposeImageFilterIF2VIF2

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

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

        """
        return _itkComposeImageFilterPython.itkComposeImageFilterIF2VIF2_cast(obj)

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

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

          itkComposeImageFilterIF2VIF2.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkComposeImageFilterIF2VIF2 in _itkComposeImageFilterPython:
_itkComposeImageFilterPython.itkComposeImageFilterIF2VIF2_swigregister(itkComposeImageFilterIF2VIF2)

def itkComposeImageFilterIF3ICF3_New():
    return itkComposeImageFilterIF3ICF3.New()

class itkComposeImageFilterIF3ICF3(itk.itkImageToImageFilterBPython.itkImageToImageFilterIF3ICF3):
    r"""Proxy of C++ itkComposeImageFilterIF3ICF3 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__() -> itkComposeImageFilterIF3ICF3_Pointer"""
        return _itkComposeImageFilterPython.itkComposeImageFilterIF3ICF3___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkComposeImageFilterIF3ICF3_Pointer"""
        return _itkComposeImageFilterPython.itkComposeImageFilterIF3ICF3_Clone(self)

    def SetInput1(self, image1):
        r"""
        SetInput1(self, image1)

        Parameters
        ----------
        image1: itkImageF3 const *

        """
        return _itkComposeImageFilterPython.itkComposeImageFilterIF3ICF3_SetInput1(self, image1)

    def SetInput2(self, image2):
        r"""
        SetInput2(self, image2)

        Parameters
        ----------
        image2: itkImageF3 const *

        """
        return _itkComposeImageFilterPython.itkComposeImageFilterIF3ICF3_SetInput2(self, image2)

    def SetInput3(self, image3):
        r"""
        SetInput3(self, image3)

        Parameters
        ----------
        image3: itkImageF3 const *

        """
        return _itkComposeImageFilterPython.itkComposeImageFilterIF3ICF3_SetInput3(self, image3)
    InputCovertibleToOutputCheck = _itkComposeImageFilterPython.itkComposeImageFilterIF3ICF3_InputCovertibleToOutputCheck
    
    __swig_destroy__ = _itkComposeImageFilterPython.delete_itkComposeImageFilterIF3ICF3

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

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

        """
        return _itkComposeImageFilterPython.itkComposeImageFilterIF3ICF3_cast(obj)

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

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

          itkComposeImageFilterIF3ICF3.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkComposeImageFilterIF3ICF3 in _itkComposeImageFilterPython:
_itkComposeImageFilterPython.itkComposeImageFilterIF3ICF3_swigregister(itkComposeImageFilterIF3ICF3)

def itkComposeImageFilterIF3ICVF23_New():
    return itkComposeImageFilterIF3ICVF23.New()

class itkComposeImageFilterIF3ICVF23(itk.itkImageToImageFilterBPython.itkImageToImageFilterIF3ICVF23):
    r"""Proxy of C++ itkComposeImageFilterIF3ICVF23 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__() -> itkComposeImageFilterIF3ICVF23_Pointer"""
        return _itkComposeImageFilterPython.itkComposeImageFilterIF3ICVF23___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkComposeImageFilterIF3ICVF23_Pointer"""
        return _itkComposeImageFilterPython.itkComposeImageFilterIF3ICVF23_Clone(self)

    def SetInput1(self, image1):
        r"""
        SetInput1(self, image1)

        Parameters
        ----------
        image1: itkImageF3 const *

        """
        return _itkComposeImageFilterPython.itkComposeImageFilterIF3ICVF23_SetInput1(self, image1)

    def SetInput2(self, image2):
        r"""
        SetInput2(self, image2)

        Parameters
        ----------
        image2: itkImageF3 const *

        """
        return _itkComposeImageFilterPython.itkComposeImageFilterIF3ICVF23_SetInput2(self, image2)

    def SetInput3(self, image3):
        r"""
        SetInput3(self, image3)

        Parameters
        ----------
        image3: itkImageF3 const *

        """
        return _itkComposeImageFilterPython.itkComposeImageFilterIF3ICVF23_SetInput3(self, image3)
    InputCovertibleToOutputCheck = _itkComposeImageFilterPython.itkComposeImageFilterIF3ICVF23_InputCovertibleToOutputCheck
    
    __swig_destroy__ = _itkComposeImageFilterPython.delete_itkComposeImageFilterIF3ICVF23

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

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

        """
        return _itkComposeImageFilterPython.itkComposeImageFilterIF3ICVF23_cast(obj)

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

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

          itkComposeImageFilterIF3ICVF23.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkComposeImageFilterIF3ICVF23 in _itkComposeImageFilterPython:
_itkComposeImageFilterPython.itkComposeImageFilterIF3ICVF23_swigregister(itkComposeImageFilterIF3ICVF23)

def itkComposeImageFilterIF3ICVF33_New():
    return itkComposeImageFilterIF3ICVF33.New()

class itkComposeImageFilterIF3ICVF33(itk.itkImageToImageFilterBPython.itkImageToImageFilterIF3ICVF33):
    r"""Proxy of C++ itkComposeImageFilterIF3ICVF33 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__() -> itkComposeImageFilterIF3ICVF33_Pointer"""
        return _itkComposeImageFilterPython.itkComposeImageFilterIF3ICVF33___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkComposeImageFilterIF3ICVF33_Pointer"""
        return _itkComposeImageFilterPython.itkComposeImageFilterIF3ICVF33_Clone(self)

    def SetInput1(self, image1):
        r"""
        SetInput1(self, image1)

        Parameters
        ----------
        image1: itkImageF3 const *

        """
        return _itkComposeImageFilterPython.itkComposeImageFilterIF3ICVF33_SetInput1(self, image1)

    def SetInput2(self, image2):
        r"""
        SetInput2(self, image2)

        Parameters
        ----------
        image2: itkImageF3 const *

        """
        return _itkComposeImageFilterPython.itkComposeImageFilterIF3ICVF33_SetInput2(self, image2)

    def SetInput3(self, image3):
        r"""
        SetInput3(self, image3)

        Parameters
        ----------
        image3: itkImageF3 const *

        """
        return _itkComposeImageFilterPython.itkComposeImageFilterIF3ICVF33_SetInput3(self, image3)
    InputCovertibleToOutputCheck = _itkComposeImageFilterPython.itkComposeImageFilterIF3ICVF33_InputCovertibleToOutputCheck
    
    __swig_destroy__ = _itkComposeImageFilterPython.delete_itkComposeImageFilterIF3ICVF33

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

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

        """
        return _itkComposeImageFilterPython.itkComposeImageFilterIF3ICVF33_cast(obj)

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

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

          itkComposeImageFilterIF3ICVF33.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkComposeImageFilterIF3ICVF33 in _itkComposeImageFilterPython:
_itkComposeImageFilterPython.itkComposeImageFilterIF3ICVF33_swigregister(itkComposeImageFilterIF3ICVF33)

def itkComposeImageFilterIF3ICVF43_New():
    return itkComposeImageFilterIF3ICVF43.New()

class itkComposeImageFilterIF3ICVF43(itk.itkImageToImageFilterBPython.itkImageToImageFilterIF3ICVF43):
    r"""Proxy of C++ itkComposeImageFilterIF3ICVF43 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__() -> itkComposeImageFilterIF3ICVF43_Pointer"""
        return _itkComposeImageFilterPython.itkComposeImageFilterIF3ICVF43___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkComposeImageFilterIF3ICVF43_Pointer"""
        return _itkComposeImageFilterPython.itkComposeImageFilterIF3ICVF43_Clone(self)

    def SetInput1(self, image1):
        r"""
        SetInput1(self, image1)

        Parameters
        ----------
        image1: itkImageF3 const *

        """
        return _itkComposeImageFilterPython.itkComposeImageFilterIF3ICVF43_SetInput1(self, image1)

    def SetInput2(self, image2):
        r"""
        SetInput2(self, image2)

        Parameters
        ----------
        image2: itkImageF3 const *

        """
        return _itkComposeImageFilterPython.itkComposeImageFilterIF3ICVF43_SetInput2(self, image2)

    def SetInput3(self, image3):
        r"""
        SetInput3(self, image3)

        Parameters
        ----------
        image3: itkImageF3 const *

        """
        return _itkComposeImageFilterPython.itkComposeImageFilterIF3ICVF43_SetInput3(self, image3)
    InputCovertibleToOutputCheck = _itkComposeImageFilterPython.itkComposeImageFilterIF3ICVF43_InputCovertibleToOutputCheck
    
    __swig_destroy__ = _itkComposeImageFilterPython.delete_itkComposeImageFilterIF3ICVF43

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

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

        """
        return _itkComposeImageFilterPython.itkComposeImageFilterIF3ICVF43_cast(obj)

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

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

          itkComposeImageFilterIF3ICVF43.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkComposeImageFilterIF3ICVF43 in _itkComposeImageFilterPython:
_itkComposeImageFilterPython.itkComposeImageFilterIF3ICVF43_swigregister(itkComposeImageFilterIF3ICVF43)

def itkComposeImageFilterIF3IVF23_New():
    return itkComposeImageFilterIF3IVF23.New()

class itkComposeImageFilterIF3IVF23(itk.itkImageToImageFilterBPython.itkImageToImageFilterIF3IVF23):
    r"""Proxy of C++ itkComposeImageFilterIF3IVF23 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__() -> itkComposeImageFilterIF3IVF23_Pointer"""
        return _itkComposeImageFilterPython.itkComposeImageFilterIF3IVF23___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkComposeImageFilterIF3IVF23_Pointer"""
        return _itkComposeImageFilterPython.itkComposeImageFilterIF3IVF23_Clone(self)

    def SetInput1(self, image1):
        r"""
        SetInput1(self, image1)

        Parameters
        ----------
        image1: itkImageF3 const *

        """
        return _itkComposeImageFilterPython.itkComposeImageFilterIF3IVF23_SetInput1(self, image1)

    def SetInput2(self, image2):
        r"""
        SetInput2(self, image2)

        Parameters
        ----------
        image2: itkImageF3 const *

        """
        return _itkComposeImageFilterPython.itkComposeImageFilterIF3IVF23_SetInput2(self, image2)

    def SetInput3(self, image3):
        r"""
        SetInput3(self, image3)

        Parameters
        ----------
        image3: itkImageF3 const *

        """
        return _itkComposeImageFilterPython.itkComposeImageFilterIF3IVF23_SetInput3(self, image3)
    InputCovertibleToOutputCheck = _itkComposeImageFilterPython.itkComposeImageFilterIF3IVF23_InputCovertibleToOutputCheck
    
    __swig_destroy__ = _itkComposeImageFilterPython.delete_itkComposeImageFilterIF3IVF23

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

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

        """
        return _itkComposeImageFilterPython.itkComposeImageFilterIF3IVF23_cast(obj)

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

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

          itkComposeImageFilterIF3IVF23.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkComposeImageFilterIF3IVF23 in _itkComposeImageFilterPython:
_itkComposeImageFilterPython.itkComposeImageFilterIF3IVF23_swigregister(itkComposeImageFilterIF3IVF23)

def itkComposeImageFilterIF3IVF33_New():
    return itkComposeImageFilterIF3IVF33.New()

class itkComposeImageFilterIF3IVF33(itk.itkImageToImageFilterBPython.itkImageToImageFilterIF3IVF33):
    r"""Proxy of C++ itkComposeImageFilterIF3IVF33 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__() -> itkComposeImageFilterIF3IVF33_Pointer"""
        return _itkComposeImageFilterPython.itkComposeImageFilterIF3IVF33___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkComposeImageFilterIF3IVF33_Pointer"""
        return _itkComposeImageFilterPython.itkComposeImageFilterIF3IVF33_Clone(self)

    def SetInput1(self, image1):
        r"""
        SetInput1(self, image1)

        Parameters
        ----------
        image1: itkImageF3 const *

        """
        return _itkComposeImageFilterPython.itkComposeImageFilterIF3IVF33_SetInput1(self, image1)

    def SetInput2(self, image2):
        r"""
        SetInput2(self, image2)

        Parameters
        ----------
        image2: itkImageF3 const *

        """
        return _itkComposeImageFilterPython.itkComposeImageFilterIF3IVF33_SetInput2(self, image2)

    def SetInput3(self, image3):
        r"""
        SetInput3(self, image3)

        Parameters
        ----------
        image3: itkImageF3 const *

        """
        return _itkComposeImageFilterPython.itkComposeImageFilterIF3IVF33_SetInput3(self, image3)
    InputCovertibleToOutputCheck = _itkComposeImageFilterPython.itkComposeImageFilterIF3IVF33_InputCovertibleToOutputCheck
    
    __swig_destroy__ = _itkComposeImageFilterPython.delete_itkComposeImageFilterIF3IVF33

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

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

        """
        return _itkComposeImageFilterPython.itkComposeImageFilterIF3IVF33_cast(obj)

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

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

          itkComposeImageFilterIF3IVF33.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkComposeImageFilterIF3IVF33 in _itkComposeImageFilterPython:
_itkComposeImageFilterPython.itkComposeImageFilterIF3IVF33_swigregister(itkComposeImageFilterIF3IVF33)

def itkComposeImageFilterIF3IVF43_New():
    return itkComposeImageFilterIF3IVF43.New()

class itkComposeImageFilterIF3IVF43(itk.itkImageToImageFilterBPython.itkImageToImageFilterIF3IVF43):
    r"""Proxy of C++ itkComposeImageFilterIF3IVF43 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__() -> itkComposeImageFilterIF3IVF43_Pointer"""
        return _itkComposeImageFilterPython.itkComposeImageFilterIF3IVF43___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkComposeImageFilterIF3IVF43_Pointer"""
        return _itkComposeImageFilterPython.itkComposeImageFilterIF3IVF43_Clone(self)

    def SetInput1(self, image1):
        r"""
        SetInput1(self, image1)

        Parameters
        ----------
        image1: itkImageF3 const *

        """
        return _itkComposeImageFilterPython.itkComposeImageFilterIF3IVF43_SetInput1(self, image1)

    def SetInput2(self, image2):
        r"""
        SetInput2(self, image2)

        Parameters
        ----------
        image2: itkImageF3 const *

        """
        return _itkComposeImageFilterPython.itkComposeImageFilterIF3IVF43_SetInput2(self, image2)

    def SetInput3(self, image3):
        r"""
        SetInput3(self, image3)

        Parameters
        ----------
        image3: itkImageF3 const *

        """
        return _itkComposeImageFilterPython.itkComposeImageFilterIF3IVF43_SetInput3(self, image3)
    InputCovertibleToOutputCheck = _itkComposeImageFilterPython.itkComposeImageFilterIF3IVF43_InputCovertibleToOutputCheck
    
    __swig_destroy__ = _itkComposeImageFilterPython.delete_itkComposeImageFilterIF3IVF43

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

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

        """
        return _itkComposeImageFilterPython.itkComposeImageFilterIF3IVF43_cast(obj)

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

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

          itkComposeImageFilterIF3IVF43.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkComposeImageFilterIF3IVF43 in _itkComposeImageFilterPython:
_itkComposeImageFilterPython.itkComposeImageFilterIF3IVF43_swigregister(itkComposeImageFilterIF3IVF43)

def itkComposeImageFilterIF3VIF3_New():
    return itkComposeImageFilterIF3VIF3.New()

class itkComposeImageFilterIF3VIF3(itk.itkImageToImageFilterBPython.itkImageToImageFilterIF3VIF3):
    r"""Proxy of C++ itkComposeImageFilterIF3VIF3 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__() -> itkComposeImageFilterIF3VIF3_Pointer"""
        return _itkComposeImageFilterPython.itkComposeImageFilterIF3VIF3___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkComposeImageFilterIF3VIF3_Pointer"""
        return _itkComposeImageFilterPython.itkComposeImageFilterIF3VIF3_Clone(self)

    def SetInput1(self, image1):
        r"""
        SetInput1(self, image1)

        Parameters
        ----------
        image1: itkImageF3 const *

        """
        return _itkComposeImageFilterPython.itkComposeImageFilterIF3VIF3_SetInput1(self, image1)

    def SetInput2(self, image2):
        r"""
        SetInput2(self, image2)

        Parameters
        ----------
        image2: itkImageF3 const *

        """
        return _itkComposeImageFilterPython.itkComposeImageFilterIF3VIF3_SetInput2(self, image2)

    def SetInput3(self, image3):
        r"""
        SetInput3(self, image3)

        Parameters
        ----------
        image3: itkImageF3 const *

        """
        return _itkComposeImageFilterPython.itkComposeImageFilterIF3VIF3_SetInput3(self, image3)
    InputCovertibleToOutputCheck = _itkComposeImageFilterPython.itkComposeImageFilterIF3VIF3_InputCovertibleToOutputCheck
    
    __swig_destroy__ = _itkComposeImageFilterPython.delete_itkComposeImageFilterIF3VIF3

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

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

        """
        return _itkComposeImageFilterPython.itkComposeImageFilterIF3VIF3_cast(obj)

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

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

          itkComposeImageFilterIF3VIF3.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkComposeImageFilterIF3VIF3 in _itkComposeImageFilterPython:
_itkComposeImageFilterPython.itkComposeImageFilterIF3VIF3_swigregister(itkComposeImageFilterIF3VIF3)

def itkComposeImageFilterISS2VISS2_New():
    return itkComposeImageFilterISS2VISS2.New()

class itkComposeImageFilterISS2VISS2(itk.itkImageToImageFilterBPython.itkImageToImageFilterISS2VISS2):
    r"""Proxy of C++ itkComposeImageFilterISS2VISS2 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__() -> itkComposeImageFilterISS2VISS2_Pointer"""
        return _itkComposeImageFilterPython.itkComposeImageFilterISS2VISS2___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkComposeImageFilterISS2VISS2_Pointer"""
        return _itkComposeImageFilterPython.itkComposeImageFilterISS2VISS2_Clone(self)

    def SetInput1(self, image1):
        r"""
        SetInput1(self, image1)

        Parameters
        ----------
        image1: itkImageSS2 const *

        """
        return _itkComposeImageFilterPython.itkComposeImageFilterISS2VISS2_SetInput1(self, image1)

    def SetInput2(self, image2):
        r"""
        SetInput2(self, image2)

        Parameters
        ----------
        image2: itkImageSS2 const *

        """
        return _itkComposeImageFilterPython.itkComposeImageFilterISS2VISS2_SetInput2(self, image2)

    def SetInput3(self, image3):
        r"""
        SetInput3(self, image3)

        Parameters
        ----------
        image3: itkImageSS2 const *

        """
        return _itkComposeImageFilterPython.itkComposeImageFilterISS2VISS2_SetInput3(self, image3)
    InputCovertibleToOutputCheck = _itkComposeImageFilterPython.itkComposeImageFilterISS2VISS2_InputCovertibleToOutputCheck
    
    __swig_destroy__ = _itkComposeImageFilterPython.delete_itkComposeImageFilterISS2VISS2

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

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

        """
        return _itkComposeImageFilterPython.itkComposeImageFilterISS2VISS2_cast(obj)

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

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

          itkComposeImageFilterISS2VISS2.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkComposeImageFilterISS2VISS2 in _itkComposeImageFilterPython:
_itkComposeImageFilterPython.itkComposeImageFilterISS2VISS2_swigregister(itkComposeImageFilterISS2VISS2)

def itkComposeImageFilterISS3VISS3_New():
    return itkComposeImageFilterISS3VISS3.New()

class itkComposeImageFilterISS3VISS3(itk.itkImageToImageFilterBPython.itkImageToImageFilterISS3VISS3):
    r"""Proxy of C++ itkComposeImageFilterISS3VISS3 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__() -> itkComposeImageFilterISS3VISS3_Pointer"""
        return _itkComposeImageFilterPython.itkComposeImageFilterISS3VISS3___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkComposeImageFilterISS3VISS3_Pointer"""
        return _itkComposeImageFilterPython.itkComposeImageFilterISS3VISS3_Clone(self)

    def SetInput1(self, image1):
        r"""
        SetInput1(self, image1)

        Parameters
        ----------
        image1: itkImageSS3 const *

        """
        return _itkComposeImageFilterPython.itkComposeImageFilterISS3VISS3_SetInput1(self, image1)

    def SetInput2(self, image2):
        r"""
        SetInput2(self, image2)

        Parameters
        ----------
        image2: itkImageSS3 const *

        """
        return _itkComposeImageFilterPython.itkComposeImageFilterISS3VISS3_SetInput2(self, image2)

    def SetInput3(self, image3):
        r"""
        SetInput3(self, image3)

        Parameters
        ----------
        image3: itkImageSS3 const *

        """
        return _itkComposeImageFilterPython.itkComposeImageFilterISS3VISS3_SetInput3(self, image3)
    InputCovertibleToOutputCheck = _itkComposeImageFilterPython.itkComposeImageFilterISS3VISS3_InputCovertibleToOutputCheck
    
    __swig_destroy__ = _itkComposeImageFilterPython.delete_itkComposeImageFilterISS3VISS3

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

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

        """
        return _itkComposeImageFilterPython.itkComposeImageFilterISS3VISS3_cast(obj)

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

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

          itkComposeImageFilterISS3VISS3.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkComposeImageFilterISS3VISS3 in _itkComposeImageFilterPython:
_itkComposeImageFilterPython.itkComposeImageFilterISS3VISS3_swigregister(itkComposeImageFilterISS3VISS3)

def itkComposeImageFilterIUC2IRGBAUC2_New():
    return itkComposeImageFilterIUC2IRGBAUC2.New()

class itkComposeImageFilterIUC2IRGBAUC2(itk.itkImageToImageFilterBPython.itkImageToImageFilterIUC2IRGBAUC2):
    r"""Proxy of C++ itkComposeImageFilterIUC2IRGBAUC2 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__() -> itkComposeImageFilterIUC2IRGBAUC2_Pointer"""
        return _itkComposeImageFilterPython.itkComposeImageFilterIUC2IRGBAUC2___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkComposeImageFilterIUC2IRGBAUC2_Pointer"""
        return _itkComposeImageFilterPython.itkComposeImageFilterIUC2IRGBAUC2_Clone(self)

    def SetInput1(self, image1):
        r"""
        SetInput1(self, image1)

        Parameters
        ----------
        image1: itkImageUC2 const *

        """
        return _itkComposeImageFilterPython.itkComposeImageFilterIUC2IRGBAUC2_SetInput1(self, image1)

    def SetInput2(self, image2):
        r"""
        SetInput2(self, image2)

        Parameters
        ----------
        image2: itkImageUC2 const *

        """
        return _itkComposeImageFilterPython.itkComposeImageFilterIUC2IRGBAUC2_SetInput2(self, image2)

    def SetInput3(self, image3):
        r"""
        SetInput3(self, image3)

        Parameters
        ----------
        image3: itkImageUC2 const *

        """
        return _itkComposeImageFilterPython.itkComposeImageFilterIUC2IRGBAUC2_SetInput3(self, image3)
    InputCovertibleToOutputCheck = _itkComposeImageFilterPython.itkComposeImageFilterIUC2IRGBAUC2_InputCovertibleToOutputCheck
    
    __swig_destroy__ = _itkComposeImageFilterPython.delete_itkComposeImageFilterIUC2IRGBAUC2

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

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

        """
        return _itkComposeImageFilterPython.itkComposeImageFilterIUC2IRGBAUC2_cast(obj)

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

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

          itkComposeImageFilterIUC2IRGBAUC2.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkComposeImageFilterIUC2IRGBAUC2 in _itkComposeImageFilterPython:
_itkComposeImageFilterPython.itkComposeImageFilterIUC2IRGBAUC2_swigregister(itkComposeImageFilterIUC2IRGBAUC2)

def itkComposeImageFilterIUC2IRGBUC2_New():
    return itkComposeImageFilterIUC2IRGBUC2.New()

class itkComposeImageFilterIUC2IRGBUC2(itk.itkImageToImageFilterBPython.itkImageToImageFilterIUC2IRGBUC2):
    r"""Proxy of C++ itkComposeImageFilterIUC2IRGBUC2 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__() -> itkComposeImageFilterIUC2IRGBUC2_Pointer"""
        return _itkComposeImageFilterPython.itkComposeImageFilterIUC2IRGBUC2___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkComposeImageFilterIUC2IRGBUC2_Pointer"""
        return _itkComposeImageFilterPython.itkComposeImageFilterIUC2IRGBUC2_Clone(self)

    def SetInput1(self, image1):
        r"""
        SetInput1(self, image1)

        Parameters
        ----------
        image1: itkImageUC2 const *

        """
        return _itkComposeImageFilterPython.itkComposeImageFilterIUC2IRGBUC2_SetInput1(self, image1)

    def SetInput2(self, image2):
        r"""
        SetInput2(self, image2)

        Parameters
        ----------
        image2: itkImageUC2 const *

        """
        return _itkComposeImageFilterPython.itkComposeImageFilterIUC2IRGBUC2_SetInput2(self, image2)

    def SetInput3(self, image3):
        r"""
        SetInput3(self, image3)

        Parameters
        ----------
        image3: itkImageUC2 const *

        """
        return _itkComposeImageFilterPython.itkComposeImageFilterIUC2IRGBUC2_SetInput3(self, image3)
    InputCovertibleToOutputCheck = _itkComposeImageFilterPython.itkComposeImageFilterIUC2IRGBUC2_InputCovertibleToOutputCheck
    
    __swig_destroy__ = _itkComposeImageFilterPython.delete_itkComposeImageFilterIUC2IRGBUC2

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

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

        """
        return _itkComposeImageFilterPython.itkComposeImageFilterIUC2IRGBUC2_cast(obj)

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

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

          itkComposeImageFilterIUC2IRGBUC2.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkComposeImageFilterIUC2IRGBUC2 in _itkComposeImageFilterPython:
_itkComposeImageFilterPython.itkComposeImageFilterIUC2IRGBUC2_swigregister(itkComposeImageFilterIUC2IRGBUC2)

def itkComposeImageFilterIUC2VIUC2_New():
    return itkComposeImageFilterIUC2VIUC2.New()

class itkComposeImageFilterIUC2VIUC2(itk.itkImageToImageFilterBPython.itkImageToImageFilterIUC2VIUC2):
    r"""Proxy of C++ itkComposeImageFilterIUC2VIUC2 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__() -> itkComposeImageFilterIUC2VIUC2_Pointer"""
        return _itkComposeImageFilterPython.itkComposeImageFilterIUC2VIUC2___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkComposeImageFilterIUC2VIUC2_Pointer"""
        return _itkComposeImageFilterPython.itkComposeImageFilterIUC2VIUC2_Clone(self)

    def SetInput1(self, image1):
        r"""
        SetInput1(self, image1)

        Parameters
        ----------
        image1: itkImageUC2 const *

        """
        return _itkComposeImageFilterPython.itkComposeImageFilterIUC2VIUC2_SetInput1(self, image1)

    def SetInput2(self, image2):
        r"""
        SetInput2(self, image2)

        Parameters
        ----------
        image2: itkImageUC2 const *

        """
        return _itkComposeImageFilterPython.itkComposeImageFilterIUC2VIUC2_SetInput2(self, image2)

    def SetInput3(self, image3):
        r"""
        SetInput3(self, image3)

        Parameters
        ----------
        image3: itkImageUC2 const *

        """
        return _itkComposeImageFilterPython.itkComposeImageFilterIUC2VIUC2_SetInput3(self, image3)
    InputCovertibleToOutputCheck = _itkComposeImageFilterPython.itkComposeImageFilterIUC2VIUC2_InputCovertibleToOutputCheck
    
    __swig_destroy__ = _itkComposeImageFilterPython.delete_itkComposeImageFilterIUC2VIUC2

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

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

        """
        return _itkComposeImageFilterPython.itkComposeImageFilterIUC2VIUC2_cast(obj)

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

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

          itkComposeImageFilterIUC2VIUC2.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkComposeImageFilterIUC2VIUC2 in _itkComposeImageFilterPython:
_itkComposeImageFilterPython.itkComposeImageFilterIUC2VIUC2_swigregister(itkComposeImageFilterIUC2VIUC2)

def itkComposeImageFilterIUC3IRGBAUC3_New():
    return itkComposeImageFilterIUC3IRGBAUC3.New()

class itkComposeImageFilterIUC3IRGBAUC3(itk.itkImageToImageFilterBPython.itkImageToImageFilterIUC3IRGBAUC3):
    r"""Proxy of C++ itkComposeImageFilterIUC3IRGBAUC3 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__() -> itkComposeImageFilterIUC3IRGBAUC3_Pointer"""
        return _itkComposeImageFilterPython.itkComposeImageFilterIUC3IRGBAUC3___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkComposeImageFilterIUC3IRGBAUC3_Pointer"""
        return _itkComposeImageFilterPython.itkComposeImageFilterIUC3IRGBAUC3_Clone(self)

    def SetInput1(self, image1):
        r"""
        SetInput1(self, image1)

        Parameters
        ----------
        image1: itkImageUC3 const *

        """
        return _itkComposeImageFilterPython.itkComposeImageFilterIUC3IRGBAUC3_SetInput1(self, image1)

    def SetInput2(self, image2):
        r"""
        SetInput2(self, image2)

        Parameters
        ----------
        image2: itkImageUC3 const *

        """
        return _itkComposeImageFilterPython.itkComposeImageFilterIUC3IRGBAUC3_SetInput2(self, image2)

    def SetInput3(self, image3):
        r"""
        SetInput3(self, image3)

        Parameters
        ----------
        image3: itkImageUC3 const *

        """
        return _itkComposeImageFilterPython.itkComposeImageFilterIUC3IRGBAUC3_SetInput3(self, image3)
    InputCovertibleToOutputCheck = _itkComposeImageFilterPython.itkComposeImageFilterIUC3IRGBAUC3_InputCovertibleToOutputCheck
    
    __swig_destroy__ = _itkComposeImageFilterPython.delete_itkComposeImageFilterIUC3IRGBAUC3

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

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

        """
        return _itkComposeImageFilterPython.itkComposeImageFilterIUC3IRGBAUC3_cast(obj)

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

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

          itkComposeImageFilterIUC3IRGBAUC3.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkComposeImageFilterIUC3IRGBAUC3 in _itkComposeImageFilterPython:
_itkComposeImageFilterPython.itkComposeImageFilterIUC3IRGBAUC3_swigregister(itkComposeImageFilterIUC3IRGBAUC3)

def itkComposeImageFilterIUC3IRGBUC3_New():
    return itkComposeImageFilterIUC3IRGBUC3.New()

class itkComposeImageFilterIUC3IRGBUC3(itk.itkImageToImageFilterBPython.itkImageToImageFilterIUC3IRGBUC3):
    r"""Proxy of C++ itkComposeImageFilterIUC3IRGBUC3 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__() -> itkComposeImageFilterIUC3IRGBUC3_Pointer"""
        return _itkComposeImageFilterPython.itkComposeImageFilterIUC3IRGBUC3___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkComposeImageFilterIUC3IRGBUC3_Pointer"""
        return _itkComposeImageFilterPython.itkComposeImageFilterIUC3IRGBUC3_Clone(self)

    def SetInput1(self, image1):
        r"""
        SetInput1(self, image1)

        Parameters
        ----------
        image1: itkImageUC3 const *

        """
        return _itkComposeImageFilterPython.itkComposeImageFilterIUC3IRGBUC3_SetInput1(self, image1)

    def SetInput2(self, image2):
        r"""
        SetInput2(self, image2)

        Parameters
        ----------
        image2: itkImageUC3 const *

        """
        return _itkComposeImageFilterPython.itkComposeImageFilterIUC3IRGBUC3_SetInput2(self, image2)

    def SetInput3(self, image3):
        r"""
        SetInput3(self, image3)

        Parameters
        ----------
        image3: itkImageUC3 const *

        """
        return _itkComposeImageFilterPython.itkComposeImageFilterIUC3IRGBUC3_SetInput3(self, image3)
    InputCovertibleToOutputCheck = _itkComposeImageFilterPython.itkComposeImageFilterIUC3IRGBUC3_InputCovertibleToOutputCheck
    
    __swig_destroy__ = _itkComposeImageFilterPython.delete_itkComposeImageFilterIUC3IRGBUC3

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

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

        """
        return _itkComposeImageFilterPython.itkComposeImageFilterIUC3IRGBUC3_cast(obj)

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

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

          itkComposeImageFilterIUC3IRGBUC3.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkComposeImageFilterIUC3IRGBUC3 in _itkComposeImageFilterPython:
_itkComposeImageFilterPython.itkComposeImageFilterIUC3IRGBUC3_swigregister(itkComposeImageFilterIUC3IRGBUC3)

def itkComposeImageFilterIUC3VIUC3_New():
    return itkComposeImageFilterIUC3VIUC3.New()

class itkComposeImageFilterIUC3VIUC3(itk.itkImageToImageFilterBPython.itkImageToImageFilterIUC3VIUC3):
    r"""Proxy of C++ itkComposeImageFilterIUC3VIUC3 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__() -> itkComposeImageFilterIUC3VIUC3_Pointer"""
        return _itkComposeImageFilterPython.itkComposeImageFilterIUC3VIUC3___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkComposeImageFilterIUC3VIUC3_Pointer"""
        return _itkComposeImageFilterPython.itkComposeImageFilterIUC3VIUC3_Clone(self)

    def SetInput1(self, image1):
        r"""
        SetInput1(self, image1)

        Parameters
        ----------
        image1: itkImageUC3 const *

        """
        return _itkComposeImageFilterPython.itkComposeImageFilterIUC3VIUC3_SetInput1(self, image1)

    def SetInput2(self, image2):
        r"""
        SetInput2(self, image2)

        Parameters
        ----------
        image2: itkImageUC3 const *

        """
        return _itkComposeImageFilterPython.itkComposeImageFilterIUC3VIUC3_SetInput2(self, image2)

    def SetInput3(self, image3):
        r"""
        SetInput3(self, image3)

        Parameters
        ----------
        image3: itkImageUC3 const *

        """
        return _itkComposeImageFilterPython.itkComposeImageFilterIUC3VIUC3_SetInput3(self, image3)
    InputCovertibleToOutputCheck = _itkComposeImageFilterPython.itkComposeImageFilterIUC3VIUC3_InputCovertibleToOutputCheck
    
    __swig_destroy__ = _itkComposeImageFilterPython.delete_itkComposeImageFilterIUC3VIUC3

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

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

        """
        return _itkComposeImageFilterPython.itkComposeImageFilterIUC3VIUC3_cast(obj)

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

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

          itkComposeImageFilterIUC3VIUC3.New(reader, threshold=10)

        is (most of the time) equivalent to:

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


# Register itkComposeImageFilterIUC3VIUC3 in _itkComposeImageFilterPython:
_itkComposeImageFilterPython.itkComposeImageFilterIUC3VIUC3_swigregister(itkComposeImageFilterIUC3VIUC3)

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

@helpers.accept_array_like_xarray_torch
def compose_image_filter(*args: itkt.ImageLike, **kwargs)-> itkt.ImageSourceReturn:
    """Functional interface for ComposeImageFilter"""
    import itk

    kwarg_typehints = {  }
    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.ComposeImageFilter.New(*args, **kwargs)

    return instance.__internal_call__()

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

    filter_class = itk.ITKImageCompose.ComposeImageFilter
    compose_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

    compose_image_filter.__doc__ = filter_object.__doc__



